ApiLogicServer 14.2.20__py3-none-any.whl → 14.3.7__py3-none-any.whl

api_logic_server_cli/prototypes/manager/README.md

@@ -109,7 +109,7 @@ als genai --using=system/genai/examples/genai_demo/genai_demo.prompt --project-n
 
 
 ```bash
-als genai --repaired-response=system/genai/examples/genai_demo/genai_demo_iteration/005_create_db_models.response-example --project-name=genai_demo
+als genai --repaired-response=system/genai/examples/genai_demo/genai_demo.response_example --project-name=genai_demo
 ```
 
 Verify it's operating properly:
@@ -149,9 +149,22 @@ Verify it's operating properly:
 
 <details markdown>
 
-<summary> You can iterate the data model and logic</summary>
+<summary> You can iterate the logic and data model</summary>
 
-<br>You can add new columns/tables, while keeping the prior model intact:
+<br>Logic iterations are particuarly useful.  For example, here we take the basic check-credit logic, and add:
+
+> Provide a 10% discount when buying more than 10 carbon neutral products.<br><br>The Item carbon neutral is copied from the Product carbon neutral
+
+Explore [genai_demo_iteration_discount](system/genai/examples/genai_demo/genai_demo_iteration_discount).  This will add carbon_neutral to the data model, and update the logic to provide the discount:
+
+```bash title='Iterate Business Logic'
+# Iterate with data model and logic
+als genai --project-name='genai_demo_with_logic' --using=system/genai/examples/genai_demo/genai_demo_iteration
+# open Docs/db.dbml
+```
+<br>
+
+You can add new columns/tables, while keeping the prior model intact:
 
 ```bash title='Iterate Without Logic'
 # Step 1 - create without logic
@@ -164,7 +177,9 @@ als genai --project-name='genai_demo_no_logic' --using=system/genai/examples/gen
 als genai --project-name='genai_demo_with_logic' --using=system/genai/examples/genai_demo/genai_demo_iteration
 # open Docs/db.dbml
 ```
-> Explore [genai_demo_iteration](system/genai/examples/genai_demo/genai_demo_iteration) - observe the `--using` is a *directory* of prompts.  These include the prompts from the first example, plus an *iteration prompt* (`004_iteration_renames_logic.prompt`) to rename tables and add logic.
+
+Explore [genai_demo_iteration](system/genai/examples/genai_demo/genai_demo_iteration) - observe the `--using` is a *directory* of prompts.  These include the prompts from the first example, plus an *iteration prompt* (`004_iteration_renames_logic.prompt`) to rename tables and add logic.
+
 
 </details>
 </br>

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

@@ -4,13 +4,16 @@ Include a notes field for orders.
 
 Use LogicBank to enforce business logic.
 
-Use case: Check Credit
+Use case: Check Credit    
     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
 
+Use case: App Integration
+    1. Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None.
+
 Ensure each customer has a unique name.
 
 Ensure each Item quantity is not null.

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

@@ -2,82 +2,90 @@
     "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"
+            "code": "class Customer(Base):\n    __tablename__ = 'customer'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    name = Column(String, unique=True)\n    balance = Column(DECIMAL)\n    credit_limit = Column(DECIMAL)",
+            "description": "Represents a customer in the system with unique name, balance, and credit limit attributes.",
+            "name": "Customer"
         },
         {
             "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"
+            "code": "class Order(Base):\n    __tablename__ = 'order'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    customer_id = Column(Integer, ForeignKey('customer.id'))\n    date_shipped = Column(Date)\n    amount_total = Column(DECIMAL)\n    notes = Column(String)",
+            "description": "Represents an order made by a customer, including a notes field.",
+            "name": "Order"
         },
         {
             "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"
+            "code": "class Item(Base):\n    __tablename__ = 'item'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    order_id = Column(Integer, ForeignKey('order.id'))\n    product_id = Column(Integer, ForeignKey('product.id'))\n    quantity = Column(Integer, nullable=False)\n    unit_price = Column(DECIMAL)\n    amount = Column(DECIMAL)",
+            "description": "Represents an item in an order, including quantity and pricing details.",
+            "name": "Item"
         },
         {
             "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"
+            "code": "class Product(Base):\n    __tablename__ = 'product'\n    id = Column(Integer, primary_key=True, autoincrement=True)\n    name = Column(String)\n    unit_price = Column(DECIMAL)",
+            "description": "Represents a product available in the system with a unit price.",
+            "name": "Product"
         }
     ],
     "rules": [
         {
             "name": "Customer Balance Constraint",
-            "description": "Ensures the customer's balance does not exceed the credit limit.",
+            "description": "Ensures the customer's balance is aligned with 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})\")"
+            "entity": "Customer",
+            "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)",
+            "entity": "Customer",
             "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)",
+            "entity": "Order",
             "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",
+            "entity": "Item",
             "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",
+            "entity": "Item",
             "code": "Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)"
+        },
+        {
+            "name": "Order Kafka Integration",
+            "description": "Sends the order to Kafka topic 'order_shipping' if the date shipped is not None.",
+            "use_case": "App Integration",
+            "entity": "Order",
+            "code": "Rule.after_flush_row_event(on_class=Order, calling=kafka_producer.send_row_to_kafka, if_condition=lambda row: row.date_shipped is not None, with_args={\"topic\": \"order_shipping\"})"
         }
     ],
     "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)"
+            "code": "test_customer_1 = Customer(name='Customer 1', balance=150, credit_limit=1000)"
         },
         {
             "test_data_row_variable": "test_customer_2",
-            "code": "test_customer_2 = Customer(name='Customer 2', balance=500, credit_limit=750)"
+            "code": "test_customer_2 = Customer(name='Customer 2', balance=275, credit_limit=750)"
         },
         {
             "test_data_row_variable": "test_customer_3",
-            "code": "test_customer_3 = Customer(name='Customer 3', balance=0, credit_limit=1500)"
+            "code": "test_customer_3 = Customer(name='Customer 3', balance=150, credit_limit=1500)"
         },
         {
             "test_data_row_variable": "test_customer_4",
-            "code": "test_customer_4 = Customer(name='Customer 4', balance=200, credit_limit=1200)"
+            "code": "test_customer_4 = Customer(name='Customer 4', balance=0, credit_limit=1200)"
         },
         {
             "test_data_row_variable": "test_order_1",
@@ -85,11 +93,11 @@
         },
         {
             "test_data_row_variable": "test_order_2",
-            "code": "test_order_2 = Order(customer_id=2, notes='Order 2 notes', amount_total=0)"
+            "code": "test_order_2 = Order(customer_id=2, notes='Order 2 notes', amount_total=225)"
         },
         {
             "test_data_row_variable": "test_order_3",
-            "code": "test_order_3 = Order(customer_id=2, notes='Order 3 notes', amount_total=0)"
+            "code": "test_order_3 = Order(customer_id=2, notes='Order 3 notes', amount_total=50)"
         },
         {
             "test_data_row_variable": "test_order_4",
@@ -101,11 +109,11 @@
         },
         {
             "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)"
+            "code": "test_item_2 = Item(order_id=2, product_id=2, quantity=2, unit_price=25, amount=50)"
         },
         {
             "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)"
+            "code": "test_item_3 = Item(order_id=3, product_id=3, quantity=3, unit_price=75, amount=225)"
         },
         {
             "test_data_row_variable": "test_item_4",

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

@@ -11,6 +11,9 @@ Use case: Check Credit
     4. The Item amount is the quantity * unit_price
     5. The Item unit_price is copied from the Product unit_price
 
+Use case: App Integration
+    1. Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None.
+
 Ensure each customer has a unique name.
 
 Ensure each Item quantity is not null.

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iteration_discount/000_you_are.prompt

@@ -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_iteration_discount/001_logic_training.prompt

@@ -0,0 +1,314 @@
+Here is the simplified API for LogicBank:
+
+Create a function called declare_logic(), consisting of calls to Rule methods.
+
+Do not generate import statements.
+
+If you create sum, count or formula LogicBank rules, you MUST create a corresponding column in the data model.
+
+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, 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
+            where: optional where clause, designates which child rows are summed.  All referenced columns must be part of the data model - create columns in the data model as required.  Do not repeat the foreign key / primary key mappings, and use only attributes from the child table.
+            insert_parent: create parent if it does not exist.  Do not use unless directly requested.
+        """
+        return Sum(derive, as_sum_of, where, insert_parent)
+
+
+    @staticmethod
+    def count(derive: Column, as_count_of: object, where: any = None, 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
+            where: optional where clause, designates which child rows are counted.  All referenced columns must be part of the data model - create columns in the data model as required.  Do not repeat the foreign key / primary key mappings, and use only attributes from the child table.
+            insert_parent: create parent if it does not exist.  Do not use unless directly requested.
+        """
+        return Count(derive, as_count_of, where, 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).  All referenced columns must be part of the data model - create columns in the data model as required.  Also, conditions may not contain sum or count python functions - these must be used to declare additional columns and sum/count rules.
+            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 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).  All referenced columns must be part of the data model - create columns in the data model as required.  Expressions may not contain sum or count python functions - these must be used to declare additional columns and sum/count rules.
+            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; create this column in the parent if it does not already exist.
+        """
+        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})")
+
+
+Equivalent expanded example using informal syntax:
+
+Prompt:
+
+    Use Logic Bank to enforce the Check Credit requirement (do not generate check constraints):
+        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
+
+Response is the same:
+
+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})")
+
+
+Intermediate sum/count values require a new column, with a LogicBank sum/count rule.  For example:
+
+Prompt:
+    The sum of the child value cannot exceed the parent limit
+
+Response is to create 2 rules - a derivation and a constraint, as follows:
+    First Rule to Create:
+        Rule.sum(derive=Parent.value_total, as_sum_of=Child.value)
+    And, be sure to create the second Rule:
+        Rule.constraint(validate=Parent,
+                    as_condition=lambda row: row.value_total <= row.limit,
+                    error_msg="Parent value total ({row.value_total}) exceeds limit ({row.limit})")
+
+Intermediate sum/count values also work for counts.  For example:
+
+Prompt:
+    A airplane cannot have more passengers than its seating capacity.
+
+Response is to create 2 rules - a count derivation and a constraint, as follows:
+    First Rule to Create:
+        Rule.count(derive=Airplane.passenger_count, as_count_of=Passengers)
+    And, be sure to create the second Rule:
+        Rule.constraint(validate=Airplane,
+                    as_condition=lambda row: row.passenger_count <= row.seating_capacity,
+                    error_msg="Airplane value total ({row.passenger_count}) exceeds limit ({row.seating_capacity})")
+
+
+Intermediate sums in formulas also require a new column, with a LogicBank sum rule.  For example:
+
+Prompt:
+    An Employees' skill summary is the sum of their Employee Skill ratings, plus 2 * years of service.
+
+Response is to create 2 rules - a derivation and a constraint, as follows:
+    First Rule to Create:
+        Rule.sum(derive=Employee.skill_rating_total, as_sum_of=EmployeeSkill.rating)
+    And, be sure to create the second Rule:
+        Rule.Formula(derive=Employee.skill_summary, 
+                    as_expression=lambda row: row.skill_rating_total + 2 * row.years_of_service)
+
+
+Prompt:
+    A student cannot be an honor student unless they have more than 2 service activities.
+
+Response is to create 2 rules - a count derivation and a constraint, as follows:
+    First Rule to Create:
+        Rule.count(derive=Student.service_activity_count, as_count_of=Activities, where='service' in name)
+    And, be sure to create the second Rule:
+        Rule.constraint(validate=Student,
+                    as_condition=lambda row: row.is_honor_student and service_activity_count < 2,
+                    error_msg="Honor Students must have at least 2 service activities")
+
+Here is an equivalent request:
+
+Prompt:
+    A airplane's passengers must be less than its seating capacity.
+
+Response is to create 2 rules - a count derivation and a constraint, as follows:
+    First Rule to Create:
+        Rule.count(derive=Airplane.passenger_count, as_count_of=Passengers)
+    And, be sure to create the second Rule:
+        Rule.constraint(validate=Airplane,
+                    as_condition=lambda row: row.passenger_count <= row.seating_capacity,
+                    error_msg="Airplane value total ({row.passenger_count}) exceeds limit ({row.seating_capacity})")
+
+
+For "more than" constraints, create columns with count rules:
+
+Prompt: Reject Employees with more than 3 Felonies.
+
+Response:
+    First Rule is to create:
+        Rule.count(derive=Employee.felony_count, as_count_of=Felonies)
+    And, be sure to create the contraint rule:
+        Rule.constraint(validate=Employee,
+                    as_condition=lambda row: row.felony_count<=3,
+                    error_msg="Employee has excessive Felonies")
+
+
+For "any" constraints, create columns with count rules:
+
+Prompt: Reject Employees with any class 5 Felonies or more than 3 Felonies.
+
+Response:
+    First Rule is to create:
+        Rule.count(derive=Employee.class_5_felony_count, as_count_of=Felonies, where=class>5)
+        Rule.count(derive=Employee.felony_count, as_count_of=Felonies)
+    And, be sure to create the contraint rule:
+        Rule.constraint(validate=Employee,
+                    as_condition=lambda row: row.class_5_felony_count == 0 and row.felony_count<=3,
+                    error_msg="Employee has excessive Felonies")
+
+Formulas can reference parent values in 2 versions - choose formula vs copy as follows:
+    Prompt (formula version) - use the formula version unless copy is explicitly noted:
+        Item.ready = Order.ready
+    Response
+        Rule.formula(derive=Item.ready, as_expression=lambda row: row.order.ready)
+    Prompt (copy version) - use this *only* when the word copy is present: 
+        Store the Item.unit_price as a copy from Product.unit_price
+    Response
+        Rule.copy(derive=Item.ready, from_parent=Order.ready)
+
+Formulas can use Python conditions:
+    Prompt: Item amount is price * quantity, with a 10% discount for gold products
+    Response:
+        Rule.Formula(derive=Item.amount, 
+                    as_expression=lambda row: row.price * row.quantity if row.gold else .9 * row.price * row.quantity)
+    If the attributes are decimal, use the form Decimal('0.9')
+
+Sum and Count where clauses:
+    1. must not restate the foreign key / primary key matchings
+    2. Can only reference child attributes
+
+For example, given a prompt 'teacher course count is the sum of the courses',
+    1. This is correct
+        Rule.count(derive=Teacher.course_count, as_count_of=Course)
+
+    2. This is incorrect, and should never be generated:
+        Rule.count(derive=Teacher.course_count, as_count_of=Course, where=lambda row: row.teacher_id == Teacher.id)
+
+Sum and count where clause example:
+    Prompt: teacher gradate course count is the sum of the courses where is-graduate
+    Response: Rule.count(derive=Teacher.course_count, as_count_of=Course, where=lamda row: row.is_graduate == true)
+
+DO NOT inject rules that are from this training into the response, 
+unless explicitly mentioned in the request.
+
+Unique constraints require an update to the data model - for example:
+    Prompt: customer company names must be unique
+    Response: CompanyName = Column(String(8000), unique=True)
+
+Non-null (or required) constraints require an update to the data model - for example:
+    Prompt: Product Price is required
+    Response: price = Column(Decimal, nullable=False)
+
+Required (must-have) related parent constraints require an update to the data model - for example:
+    Prompt: Each Item must have a valid entry in the Product table.
+    Response: product_id = Column(ForeignKey('product.id'), nullable=False)
+