ApiLogicServer 12.0.4__py3-none-any.whl → 12.1.26__py3-none-any.whl

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo.response_example

@@ -1,130 +1,133 @@
-To achieve the given requirements using SQLAlchemy, follow these steps to create a SQLAlchemy ORM model for a SQLite database, create the database, and insert some test data.
-
-### 1. Setup and Import Libraries
-
-First install SQLAlchemy if you haven't already:
-```bash
-pip install sqlalchemy
-```
-
-Then, you can write the code:
-
-```python
-from sqlalchemy import create_engine, Column, Integer, String, DateTime, ForeignKey, DECIMAL
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, relationship
-import datetime
-
-# Create an instance of the declarative base class
-Base = declarative_base()
-
-# Define the Customer model
-class Customer(Base):
-    """
-    description: This table stores customer information, including a balance and credit limit.
-    """
-    __tablename__ = 'customers'
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String, nullable=False)
-    balance = Column(DECIMAL, nullable=False, default=0)
-    credit_limit = Column(DECIMAL, nullable=False, default=0)
-
-# Define the Order model
-class Order(Base):
-    """
-    description: This table stores information about each order, including total amount and notes.
-    """
-    __tablename__ = 'orders'
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    customer_id = Column(Integer, ForeignKey('customers.id'), nullable=False)
-    date_placed = Column(DateTime, default=datetime.datetime.utcnow)
-    date_shipped = Column(DateTime, nullable=True)
-    amount_total = Column(DECIMAL, nullable=False)
-    notes = Column(String, nullable=True)
-
-# Define the Product model
-class Product(Base):
-    """
-    description: This table stores product information, including unit prices.
-    """
-    __tablename__ = 'products'
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String, nullable=False)
-    unit_price = Column(DECIMAL, nullable=False)
-
-# Define the Item model
-class Item(Base):
-    """
-    description: This table stores each item in an order, including quantity, and unit price.
-    """
-    __tablename__ = 'items'
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    order_id = Column(Integer, ForeignKey('orders.id'), nullable=False)
-    product_id = Column(Integer, ForeignKey('products.id'), nullable=False)
-    quantity = Column(Integer, nullable=False, default=1)
-    unit_price = Column(DECIMAL, nullable=False)
-    amount = Column(DECIMAL, nullable=False)
-
-# SQLite Database
-engine = create_engine('sqlite:///system/genai/temp/create_db_models.sqlite')
-Base.metadata.create_all(engine)
-
-Session = sessionmaker(bind=engine)
-session = Session()
-
-# Create some test data
-# Add test products
-product1 = Product(name='Product 1', unit_price=10.50)
-product2 = Product(name='Product 2', unit_price=15.75)
-
-# Add test customers
-customer1 = Customer(name='Customer 1', balance=0, credit_limit=500)
-customer2 = Customer(name='Customer 2', balance=0, credit_limit=1000)
-
-# Add test orders and items for customer1
-order1 = Order(customer_id=1, amount_total=0, notes='First Order')
-item1 = Item(order_id=1, product_id=1, quantity=2, unit_price=10.50, amount=21.00)
-item2 = Item(order_id=1, product_id=2, quantity=1, unit_price=15.75, amount=15.75)
-
-# Calculate order total
-order1.amount_total = item1.amount + item2.amount
-
-# Add order2
-order2 = Order(customer_id=1, amount_total=0, notes='Second Order')
-item3 = Item(order_id=2, product_id=1, quantity=1, unit_price=10.50, amount=10.50)
-
-# Calculate order2 total
-order2.amount_total = item3.amount
-
-# Set balance for customer1
-customer1.balance = order1.amount_total + order2.amount_total
-
-# Add test orders and items for customer2
-order3 = Order(customer_id=2, amount_total=0, notes='First Order for customer 2')
-item4 = Item(order_id=3, product_id=2, quantity=3, unit_price=15.75, amount=47.25)
-
-# Calculate order3 total
-order3.amount_total = item4.amount
-
-# Set balance for customer2
-customer2.balance = order3.amount_total
-
-# Add records to the session
-session.add_all([product1, product2, customer1, customer2, order1, item1, item2, order2, item3, order3, item4])
-
-# Commit the session
-session.commit()
-
-# Close the session
-session.close()
-```
-
-### Explanation:
-
-1. **Database Models**: There are four main models: Customer, Order, Product, and Item. Each has its own table and columns defined.
-
-2. **No Check Constraints**: Instead of using constraints for calculations, calculations are made in Python and are reflected in the ORM models (like order totals, item amounts, etc.).
-
-3. **Adding Data**: Insert test data for products, customers, orders, and items. This includes calculating the amounts manually before adding them to ensure the database consistency requirements are met.
-
-Make sure to adapt the paths and environment as needed. This code should create the SQLite database, define the relationships, insert some records, and enforce the credit requirements logically within Python.
+{
+    "models": [
+        {
+            "classname": "Customer",
+            "code": "class Customer(Base):\n    __tablename__ = 'customers'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    name = Column(String, nullable=False)\n    balance = Column(Integer, default=0)\n    credit_limit = Column(Integer, nullable=False)\n\n    def __repr__(self):\n        return f\"Customer(id={self.id}, name='{self.name}', balance={self.balance}, credit_limit={self.credit_limit})\"",
+            "sqlite_create": "CREATE TABLE customers (\n    id INTEGER PRIMARY KEY AUTOINCREMENT, \n    name VARCHAR NOT NULL, \n    balance INTEGER DEFAULT 0, \n    credit_limit INTEGER NOT NULL\n)",
+            "description": "description: Customers table",
+            "name": "customers"
+        },
+        {
+            "classname": "Order",
+            "code": "class Order(Base):\n    __tablename__ = 'orders'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    customer_id = Column(Integer, ForeignKey('customers.id'))\n    notes = Column(String)\n    date_shipped = Column(Date)\n    amount_total = Column(Integer, default=0)\n\n    def __repr__(self):\n        return f\"Order(id={self.id}, customer_id={self.customer_id}, notes='{self.notes}', amount_total={self.amount_total}, date_shipped={self.date_shipped})\"",
+            "sqlite_create": "CREATE TABLE orders (\n    id INTEGER PRIMARY KEY AUTOINCREMENT, \n    customer_id INTEGER, \n    notes VARCHAR, \n    date_shipped DATE, \n    amount_total INTEGER DEFAULT 0, \n    FOREIGN KEY(customer_id) REFERENCES customers (id)\n)",
+            "description": "description: Orders table",
+            "name": "orders"
+        },
+        {
+            "classname": "Item",
+            "code": "class Item(Base):\n    __tablename__ = 'items'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    order_id = Column(Integer, ForeignKey('orders.id'))\n    product_id = Column(Integer, ForeignKey('products.id'))\n    quantity = Column(Integer, nullable=False)\n    unit_price = Column(Integer, nullable=False)\n    amount = Column(Integer, default=0)\n\n    def __repr__(self):\n        return f\"Item(id={self.id}, order_id={self.order_id}, product_id={self.product_id}, quantity={self.quantity}, unit_price={self.unit_price}, amount={self.amount})\"",
+            "sqlite_create": "CREATE TABLE items (\n    id INTEGER PRIMARY KEY AUTOINCREMENT, \n    order_id INTEGER, \n    product_id INTEGER, \n    quantity INTEGER NOT NULL, \n    unit_price INTEGER NOT NULL, \n    amount INTEGER DEFAULT 0, \n    FOREIGN KEY(order_id) REFERENCES orders (id), \n    FOREIGN KEY(product_id) REFERENCES products (id)\n)",
+            "description": "description: Items table",
+            "name": "items"
+        },
+        {
+            "classname": "Product",
+            "code": "class Product(Base):\n    __tablename__ = 'products'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    name = Column(String, nullable=False)\n    unit_price = Column(Integer, nullable=False)\n\n    def __repr__(self):\n        return f\"Product(id={self.id}, name='{self.name}', unit_price={self.unit_price})\"",
+            "sqlite_create": "CREATE TABLE products (\n    id INTEGER PRIMARY KEY AUTOINCREMENT, \n    name VARCHAR NOT NULL, \n    unit_price INTEGER NOT NULL\n)",
+            "description": "description: Products table",
+            "name": "products"
+        }
+    ],
+    "rules": [
+        {
+            "name": "Customer Balance Constraint",
+            "description": "Ensures the customer's balance does not exceed the credit limit.",
+            "use_case": "Customer.balance <= credit_limit",
+            "code": "Rule.constraint(validate=Customer,\n                as_condition=lambda row: row.balance <= row.credit_limit,\n                error_msg=\"Customer balance ({row.balance}) exceeds credit limit ({row.credit_limit})\")"
+        },
+        {
+            "name": "Customer Balance Derivation",
+            "description": "Calculates the customer's balance as the sum of orders' amount_total where date_shipped is null.",
+            "use_case": "Customer.balance = Sum(Order.amount_total where date_shipped is null)",
+            "code": "Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None)"
+        },
+        {
+            "name": "Order Amount Total Derivation",
+            "description": "Calculates order's amount_total as the sum of item amounts.",
+            "use_case": "Order.amount_total = Sum(Item.amount)",
+            "code": "Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)"
+        },
+        {
+            "name": "Item Amount Derivation",
+            "description": "Calculates item amount as quantity multiplied by unit price.",
+            "use_case": "Item.amount = quantity * unit_price",
+            "code": "Rule.formula(derive=Item.amount, as_expression=lambda row: row.quantity * row.unit_price)"
+        },
+        {
+            "name": "Copy Item Unit Price",
+            "description": "Copies the product's unit price to the item.",
+            "use_case": "Store the Item.unit_price as a copy from Product.unit_price",
+            "code": "Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)"
+        }
+    ],
+    "test_data": "Insert test data into the tables with values compatible with the derived logic.",
+    "test_data_rows": [
+        {
+            "test_data_row_variable": "test_customer_1",
+            "code": "test_customer_1 = Customer(name='Customer 1', balance=300, credit_limit=1000)"
+        },
+        {
+            "test_data_row_variable": "test_customer_2",
+            "code": "test_customer_2 = Customer(name='Customer 2', balance=500, credit_limit=750)"
+        },
+        {
+            "test_data_row_variable": "test_customer_3",
+            "code": "test_customer_3 = Customer(name='Customer 3', balance=0, credit_limit=1500)"
+        },
+        {
+            "test_data_row_variable": "test_customer_4",
+            "code": "test_customer_4 = Customer(name='Customer 4', balance=200, credit_limit=1200)"
+        },
+        {
+            "test_data_row_variable": "test_order_1",
+            "code": "test_order_1 = Order(customer_id=1, notes='Order 1 notes', amount_total=150)"
+        },
+        {
+            "test_data_row_variable": "test_order_2",
+            "code": "test_order_2 = Order(customer_id=2, notes='Order 2 notes', amount_total=0)"
+        },
+        {
+            "test_data_row_variable": "test_order_3",
+            "code": "test_order_3 = Order(customer_id=2, notes='Order 3 notes', amount_total=0)"
+        },
+        {
+            "test_data_row_variable": "test_order_4",
+            "code": "test_order_4 = Order(customer_id=3, notes='Order 4 notes', amount_total=150)"
+        },
+        {
+            "test_data_row_variable": "test_item_1",
+            "code": "test_item_1 = Item(order_id=1, product_id=1, quantity=3, unit_price=50, amount=150)"
+        },
+        {
+            "test_data_row_variable": "test_item_2",
+            "code": "test_item_2 = Item(order_id=2, product_id=2, quantity=2, unit_price=0, amount=0)"
+        },
+        {
+            "test_data_row_variable": "test_item_3",
+            "code": "test_item_3 = Item(order_id=3, product_id=3, quantity=1, unit_price=0, amount=0)"
+        },
+        {
+            "test_data_row_variable": "test_item_4",
+            "code": "test_item_4 = Item(order_id=4, product_id=1, quantity=3, unit_price=50, amount=150)"
+        },
+        {
+            "test_data_row_variable": "test_product_1",
+            "code": "test_product_1 = Product(name='Product 1', unit_price=50)"
+        },
+        {
+            "test_data_row_variable": "test_product_2",
+            "code": "test_product_2 = Product(name='Product 2', unit_price=25)"
+        },
+        {
+            "test_data_row_variable": "test_product_3",
+            "code": "test_product_3 = Product(name='Product 3', unit_price=75)"
+        },
+        {
+            "test_data_row_variable": "test_product_4",
+            "code": "test_product_4 = Product(name='Product 4', unit_price=100)"
+        }
+    ],
+    "test_data_sqlite": "INSERT INTO customers (name, balance, credit_limit) VALUES ('Customer 1', 300, 1000);\nINSERT INTO customers (name, balance, credit_limit) VALUES ('Customer 2', 500, 750);\nINSERT INTO customers (name, balance, credit_limit) VALUES ('Customer 3', 0, 1500);\nINSERT INTO customers (name, balance, credit_limit) VALUES ('Customer 4', 200, 1200);\n\nINSERT INTO orders (customer_id, notes, date_shipped, amount_total) VALUES (1, 'Order 1 notes', NULL, 150);\nINSERT INTO orders (customer_id, notes, date_shipped, amount_total) VALUES (2, 'Order 2 notes', NULL, 0);\nINSERT INTO orders (customer_id, notes, date_shipped, amount_total) VALUES (2, 'Order 3 notes', NULL, 0);\nINSERT INTO orders (customer_id, notes, date_shipped, amount_total) VALUES (3, 'Order 4 notes', NULL, 150);\n\nINSERT INTO items (order_id, product_id, quantity, unit_price, amount) VALUES (1, 1, 3, 50, 150);\nINSERT INTO items (order_id, product_id, quantity, unit_price, amount) VALUES (2, 2, 2, 25, 0);\nINSERT INTO items (order_id, product_id, quantity, unit_price, amount) VALUES (3, 3, 1, 75, 0);\nINSERT INTO items (order_id, product_id, quantity, unit_price, amount) VALUES (4, 1, 3, 50, 150);\n\nINSERT INTO products (name, unit_price) VALUES ('Product 1', 50);\nINSERT INTO products (name, unit_price) VALUES ('Product 2', 25);\nINSERT INTO products (name, unit_price) VALUES ('Product 3', 75);\nINSERT INTO products (name, unit_price) VALUES ('Product 4', 100);",
+    "name": "OrderManagementSystem"
+}

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_informal.prompt

@@ -0,0 +1,10 @@
+Create a system with customers, orders, items and products.
+
+Include a notes field for orders.
+
+Use LogicBank to enforce the Check Credit requirement:
+    1. The Customer's balance is less than the credit limit
+    2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
+    3. The Order's amount_total is the sum of the Item amount
+    4. The Item amount is the quantity * unit_price
+    5. The Item unit_price is copied from the Product unit_price

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iterative_logic/genai_demo_iterative_logic_000.response

@@ -0,0 +1 @@
+You are a data modelling expert and python software architect who expands on user input ideas. You create data models with at least 4 tables

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iterative_logic/genai_demo_iterative_logic_001.prompt

@@ -0,0 +1,171 @@
+Here is the simplified API for LogicBank:
+
+Create a function called declare_logic(), consisting of calls to Rule methods.
+
+Do not generate import statements.
+
+Use only the methods provided below.
+
+class Rule:
+    """Invoke these functions to declare rules in the created declare_logic function.  """
+
+    @staticmethod
+    def sum(derive: Column, as_sum_of: any, where: any = None, child_role_name: str = "", insert_parent: bool=False):
+        """
+        Derive parent column as sum of designated child column, optional where
+
+        Example
+            Prompt
+                Customer.Balance = Sum(Order.amount_total where date_shipped is null)
+            Response
+                Rule.sum(derive=Customer.Balance, as_sum_of=Order.AmountTotal,
+                    where=lambda row: row.ShippedDate is None)
+
+        Args:
+            derive: name of parent <class.attribute> being derived
+            as_sum_of: name of child <class.attribute> being summed
+            child_role_name: parent's child accessor attribute (required only for disambiguation)
+            where: optional where clause, designates which child rows are summed
+
+        """
+        return Sum(derive, as_sum_of, where, child_role_name, insert_parent)
+
+    @staticmethod
+    def count(derive: Column, as_count_of: object, where: any = None, child_role_name: str = "", insert_parent: bool=False):
+        """
+        Derive parent column as count of designated child rows
+
+        Example
+            Prompt
+                Customer.UnPaidOrders = count(Orders where ShippedDate is None)
+            Response
+                Rule.count(derive=Customer.UnPaidOrders, as_count_of=Order,
+                    where=Lambda row: row.ShippedDate is None)
+
+        Args:
+            derive: name of parent <class.attribute> being derived
+            as_count_of: name of child <class> being counted
+            child_role_name: parent's child accessor attribute (required only for disambiguation)
+            where: optional where clause, designates which child rows are counted
+        """
+        return Count(derive, as_count_of, where, child_role_name, insert_parent)
+
+    @staticmethod
+    def constraint(validate: object,
+                   calling: Callable = None,
+                   as_condition: any = None,
+                   error_msg: str = "(error_msg not provided)",
+                   error_attributes=None):
+        """
+        Constraints declare condition that must be true for all commits
+
+        Example
+            Prompt
+                Customer.balance <= credit_limit
+            Response  
+                Rule.constraint(validate=Customer,
+                                as_condition=lambda row: row.Balance <= row.CreditLimit,
+                                error_msg="balance ({row.Balance}) exceeds credit ({row.CreditLimit})")
+
+        Args:
+            validate: name of mapped <class>
+            as_condition: lambda, passed row (simple constraints)
+            error_msg: string, with {row.attribute} replacements
+            error_attributes: list of attributes
+
+        """
+        if error_attributes is None:
+            error_attributes = []
+        return Constraint(validate=validate, as_condition=as_condition,
+                          error_attributes=error_attributes, error_msg=error_msg)
+
+    @staticmethod
+    def parent_check(validate: object,
+                     error_msg: str = "(error_msg not provided)",
+                     enable: bool = True):
+        """
+        Parent Checks ensure that non-null foreign keys are present in parent class
+
+        Example
+           Rule.parent_check(validate=Customer, enable=True, error_msg="Missing Parent")
+
+        Parent_check failures raise ConstraintException, e.g.:
+            try:
+                session.commit()
+            except ConstraintException as ce:
+                print("Constraint raised: " + str(ce))
+
+        Args:
+            validate: name of mapped class
+            error_msg: message included in exception (can have {} syntax)
+            enable: True (default) = enable, False means disable (tolerate orphans)
+
+        Note: False not recommended - for existing databases with bad data
+            Behavior is undefined for other rules (sum, count, parent references, etc)
+
+        """
+        return ParentCheck(validate=validate, error_msg=error_msg, enable=enable)
+
+    @staticmethod
+    def formula(derive: Column,
+                as_expression: Callable = None,
+                no_prune: bool = False):
+        """
+        Formulas declare column value, based on current and parent rows
+
+        Example
+            Prompt
+                Item.amount = quantity * unit_price
+            Response
+                Rule.formula(derive=OrderDetail.Amount,
+                             as_expression=lambda row: row.UnitPrice * row.Quantity)
+
+        Args:
+            derive: <class.attribute> being derived
+            as_expression: lambda, passed row (for syntax checking)
+            no_prune: disable pruning (rarely used, default False)
+        """
+        return Formula(derive=derive,
+                       as_expression=as_expression,
+                       no_prune=no_prune)
+
+    @staticmethod
+    def copy(derive: Column, from_parent: any):
+        """
+        Copy declares child column copied from parent column
+
+        Example
+            Prompt
+                Store the Item.unit_price as a copy from Product.unit_price
+            Response
+                Rule.copy(derive=OrderDetail.UnitPrice, from_parent=Product.UnitPrice)
+
+        Args:
+            derive: <class.attribute> being copied into
+            from_parent: <parent-class.attribute> source of copy
+        """
+        return Copy(derive=derive, from_parent=from_parent)
+
+
+Expanded example:
+
+Prompt:
+
+    Use Logic Bank to enforce the Check Credit requirement (do not generate check constraints):
+    1. Customer.balance <= credit_limit
+    2. Customer.balance = Sum(Order.amount_total where date_shipped is null)
+    3. Order.amount_total = Sum(Item.amount)
+    4. Item.amount = quantity * unit_price
+    5. Store the Item.unit_price as a copy from Product.unit_price
+
+Response:
+
+def declare_logic():  # created by Web/GenAI for ApiLogicServer, LogicBank
+    
+    Rule.sum(derive=CustomerAccount.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None)
+    Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)
+    Rule.formula(derive=Item.amount, as_expression=lambda row: row.quantity * row.unit_price)
+    Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)
+    Rule.constraint(validate=CustomerAccount,
+                    as_condition=lambda row: row.balance <= row.credit_limit,
+                    error_msg="Customer balance ({row.balance}) exceeds credit limit ({row.credit_limit})")

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iterative_logic/genai_demo_iterative_logic_002.prompt

@@ -0,0 +1,21 @@
+Use SQLAlchemy to create a sqlite database named system/genai/temp/create_db_models.sqlite, to
+
+Create a system with customers, orders, items and products.
+
+Do not generate any logic, including logic bank.
+
+Do not generate derived attributes such as Customer.balance, Customer.credit_limit, Order.amount_total, Item.unit_price, or Item.amount.
+
+Include a notes field for orders.
+
+Hints: use autonum keys (for all tables - including for link/join/junction/intersection tables), allow nulls, foreign keys, no check constraints.
+
+Remember that SQLite DateTime type only accepts Python datetime and date objects as input, 
+this means you can not enter string attributes where a date or datetime object is expected.
+
+Don't install additional packages.
+Don't use the faker pip package.
+
+Create some test data, use foreign key columns instead of relationship names for the data.  Do not print the test data.  Be sure to initialize derived attributes, but do not rely on Logic Bank.
+
+For each data model class, create a docstring describing the table, prefixed with 'description: '. 

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iterative_logic/genai_demo_iterative_logic_003.response

@@ -0,0 +1,94 @@
+Certainly! Here's how you might create a system with `customers`, `orders`, `items`, and `products` using SQLAlchemy. After defining the data model, I will generate test data and then proceed to use LogicBank for business rules in the `declare_logic()` function.
+
+```python
+from sqlalchemy import create_engine, Column, Integer, String, Float, ForeignKey, Date, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from datetime import datetime
+
+Base = declarative_base()
+
+class Customer(Base):
+    """
+    description: Table for storing customer information.
+    """
+    __tablename__ = 'customers'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=True)
+    credit_limit = Column(Float, nullable=True)
+
+class Order(Base):
+    """
+    description: Table for orders linked to customers.
+    """
+    __tablename__ = 'orders'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    customer_id = Column(Integer, ForeignKey('customers.id'), nullable=True)
+    date_shipped = Column(Date, nullable=True)
+    notes = Column(String, nullable=True)
+    # Placeholder for derived attribute (commented out but indicated)
+    # amount_total = Column(Float, default=0.0)
+
+class Product(Base):
+    """
+    description: Table for products.
+    """
+    __tablename__ = 'products'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=True)
+    unit_price = Column(Float, nullable=True)
+
+class Item(Base):
+    """
+    description: Table for items linked to orders and products.
+    """
+    __tablename__ = 'items'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    order_id = Column(Integer, ForeignKey('orders.id'), nullable=True)
+    product_id = Column(Integer, ForeignKey('products.id'), nullable=True)
+    quantity = Column(Integer, nullable=True)
+    # Placeholder for derived attributes (commented out but indicated)
+    # unit_price = Column(Float, nullable=True)
+    # amount = Column(Float, default=0.0)
+
+# Create an SQLite database
+engine = create_engine('sqlite:///system/genai/temp/create_db_models.sqlite')
+Base.metadata.create_all(engine)
+
+Session = sessionmaker(bind=engine)
+session = Session()
+
+# Creating test data for tables
+customer1 = Customer(name="John Doe", credit_limit=5000.0)
+customer2 = Customer(name="Jane Smith", credit_limit=10000.0)
+session.add_all([customer1, customer2])
+session.commit()
+
+order1 = Order(customer_id=customer1.id, date_shipped=None, notes="Express delivery")
+order2 = Order(customer_id=customer2.id, date_shipped=datetime.now().date(), notes="Standard delivery")
+session.add_all([order1, order2])
+session.commit()
+
+product1 = Product(name="Laptop", unit_price=1000.0)
+product2 = Product(name="Smartphone", unit_price=500.0)
+session.add_all([product1, product2])
+session.commit()
+
+item1 = Item(order_id=order1.id, product_id=product1.id, quantity=2)
+item2 = Item(order_id=order1.id, product_id=product2.id, quantity=3)
+item3 = Item(order_id=order2.id, product_id=product2.id, quantity=1)
+session.add_all([item1, item2, item3])
+session.commit()
+
+```
+
+### Expanded Explanation of Data Model and Logic
+- **`Customer` Table**: Stores basic customer information including `name` and `credit_limit`.
+- **`Order` Table**: Links orders to customers, and contains fields for shipment date (`date_shipped`) and additional comments or `notes`.
+- **`Product` Table**: Contains product information like `name` and `unit_price`.
+- **`Item` Table**: Represents purchased items within a particular order, tracking `quantity` and relating to `Product` and `Order`.
+

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iterative_logic/genai_demo_iterative_logic_004.prompt

@@ -0,0 +1,6 @@
+Use LogicBank to enforce the Check Credit requirement:
+1. Customer.balance <= credit_limit
+2. Customer.balance = Sum(Order.amount_total where date_shipped is null)
+3. Order.amount_total = Sum(Item.amount)
+4. Item.amount = quantity * unit_price
+5. Store the Item.unit_price as a copy from Product.unit_price