ApiLogicServer 14.2.2__py3-none-any.whl → 14.3.0__py3-none-any.whl

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)
+

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iteration_discount/002_create_db_models.prompt

@@ -0,0 +1,150 @@
+Use SQLAlchemy to create a sqlite database named system/genai/temp/create_db_models.sqlite for the following requirements. These requirements are very important!
+Requirements:
+<Requirements>
+Create a system with customers, orders, items and products.
+
+Include a notes field for orders.
+
+Use LogicBank to enforce these requirements (do not generate check constraints); be sure to update the data model and *all* test data with any attributes used in the logic:
+
+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
+
+Ensure each customer has a unique name.
+
+Ensure each Item quantity is not null.
+
+Ensure each order has a valid customer_id that exists in the Customer table.
+.
+</Requirements>
+
+Hints: use autonum keys (for all tables - including for link/join/junction/intersection tables), allow nulls, foreign keys, no check constraints.
+
+Be sure to create classes, never tables.
+Class names are singular, and first letter is capitalized.
+
+If you create sum, count or formula Logic Bank rules, then you MUST create a corresponding column in the data model.
+
+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.
+
+When creating SQLAlchemy data model classes, follow these guidelines carefully:
+* Use foreign key columns instead of relationship names for the data.  
+* Do not specify nullable unless explicitly specified.
+* Do not use unique unless explicitly specified.
+* Do not use Float unless explicitly specified.
+* Generate the classes ONLY.
+* Do NOT generate imports.
+* Do NOT generate connect statements.
+* Do NOT generate engines.
+
+Create 4 rows of test data for each table, and follow these guidelines carefully:
+* Create separate objects for each test data row, not in arrays. 
+* Be sure to initialize derived attributes for test data rows - including all sums and counts, but do not rely on Logic Bank,
+and do not generate db.execute statements.
+* Do not create arrays of test data.
+* Do not create a function to load test data.  
+* Do not print the test data. 
+* Use double quotes " for strings.
+* For test data, format dates as date(year, month, day).
+
+<responseFormat>
+class Rule(BaseModel):
+    name: str
+    description: str
+    use_case: str # specified use case or requirement name (use 'General' if missing)
+    entity: str # the entity being constrained or derived
+    code: str # logicbank rule code
+    
+class Model(BaseModel):
+    classname: str
+    code: str # sqlalchemy model code
+    sqlite_create: str # sqlite create table statement
+    description: str
+    name: str
+
+class TestDataRow(BaseModel):
+    test_data_row_variable: str  # the Python test data row variable
+    code: str  # Python code to create a test data row instance
+
+class WGResult(BaseModel):  # must match system/genai/prompt_inserts/response_format.prompt
+    # response: str # result
+    models : List[Model] # list of sqlalchemy classes in the response
+    rules : List[Rule] # list rule declarations
+    test_data: str
+    test_data_rows: List[TestDataRow]  # list of test data rows
+    test_data_sqlite: str # test data as sqlite INSERT statements
+    name: str  # suggest a short name for the project
+
+Format the response as a WGResult.
+
+</responseFormat>
+
+<responseFormat>
+
+class Rule(BaseModel):
+
+    name: str
+
+    description: str
+
+    use_case: str # specified use case or requirement name (use 'General' if missing)
+
+    entity: str # the entity being constrained or derived
+
+    code: str # logicbank rule code
+
+    
+
+class Model(BaseModel):
+
+    classname: str
+
+    code: str # sqlalchemy model code
+
+    sqlite_create: str # sqlite create table statement
+
+    description: str
+
+    name: str
+
+
+
+class TestDataRow(BaseModel):
+
+    test_data_row_variable: str  # the Python test data row variable
+
+    code: str  # Python code to create a test data row instance
+
+
+
+class WGResult(BaseModel):  # must match system/genai/prompt_inserts/response_format.prompt
+
+    # response: str # result
+
+    models : List[Model] # list of sqlalchemy classes in the response
+
+    rules : List[Rule] # list rule declarations
+
+    test_data: str
+
+    test_data_rows: List[TestDataRow]  # list of test data rows
+
+    test_data_sqlite: str # test data as sqlite INSERT statements
+
+    name: str  # suggest a short name for the project
+
+
+
+Format the response as a WGResult.
+
+
+
+</responseFormat>

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_iteration_discount/003_create_db_models.response

@@ -0,0 +1,134 @@
+{
+    "models": [
+        {
+            "classname": "Customer",
+            "code": "class Customer(Base):\n    __tablename__ = 'customer'\n\n    id = Column(Integer, primary_key=True)\n    name = Column(String, unique=True)\n    credit_limit = Column(Integer)\n    balance = Column(Integer)\n    ",
+            "description": "Model for customers, ensuring unique names and supporting logic for balance computation.",
+            "name": "Customer"
+        },
+        {
+            "classname": "Order",
+            "code": "class Order(Base):\n    __tablename__ = 'order'\n\n    id = Column(Integer, primary_key=True)\n    customer_id = Column(Integer, ForeignKey('customer.id'), nullable=False)\n    date_shipped = Column(DateTime)\n    amount_total = Column(Integer)\n    notes = Column(String)\n    ",
+            "description": "Model for orders, with a reference to customers, a notes field, and computed total amount for logic enforcement.",
+            "name": "Order"
+        },
+        {
+            "classname": "Product",
+            "code": "class Product(Base):\n    __tablename__ = 'product'\n\n    id = Column(Integer, primary_key=True)\n    unit_price = Column(Integer)\n    \n    ",
+            "description": "Model for products, storing unit prices to be copied to items.",
+            "name": "Product"
+        },
+        {
+            "classname": "Item",
+            "code": "class Item(Base):\n    __tablename__ = 'item'\n\n    id = Column(Integer, primary_key=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(Integer)\n    amount = Column(Integer)\n    ",
+            "description": "Model for items, referencing orders and products, using unit_price copied from products and calculated amount.",
+            "name": "Item"
+        }
+    ],
+    "rules": [
+        {
+            "name": "Customer Balance Constraint",
+            "description": "Ensures that a Customer's balance does not exceed its credit limit.",
+            "use_case": "Check Credit",
+            "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 Computation",
+            "description": "Calculates Customer's balance as sum of Order amounts where date_shipped is null.",
+            "use_case": "Check Credit",
+            "entity": "Customer",
+            "code": "Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, \n          where=lambda row: row.date_shipped is None)"
+        },
+        {
+            "name": "Order Amount Total",
+            "description": "Calculates Order amount_total as sum of Item amounts.",
+            "use_case": "Check Credit",
+            "entity": "Order",
+            "code": "Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)"
+        },
+        {
+            "name": "Item Amount Calculation",
+            "description": "Calculates Item's amount as the product of quantity and unit_price.",
+            "use_case": "Check Credit",
+            "entity": "Item",
+            "code": "Rule.formula(derive=Item.amount, as_expression=lambda row: row.quantity * row.unit_price)"
+        },
+        {
+            "name": "Item Unit Price Copy",
+            "description": "Copies Product's unit_price to item's unit_price.",
+            "use_case": "Check Credit",
+            "entity": "Item",
+            "code": "Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)"
+        }
+    ],
+    "test_data": "# Test Customers\ntest_customer_1 = Customer(id=1, name=\"Customer A\", credit_limit=5000, balance=0)\ntest_customer_2 = Customer(id=2, name=\"Customer B\", credit_limit=6000, balance=0)\ntest_customer_3 = Customer(id=3, name=\"Customer C\", credit_limit=7000, balance=0)\ntest_customer_4 = Customer(id=4, name=\"Customer D\", credit_limit=8000, balance=0)\n\n# Test Products\ntest_product_1 = Product(id=1, unit_price=10)\ntest_product_2 = Product(id=2, unit_price=15)\ntest_product_3 = Product(id=3, unit_price=20)\ntest_product_4 = Product(id=4, unit_price=25)\n\n# Test Orders\ntest_order_1 = Order(id=1, customer_id=1, date_shipped=None, amount_total=0, notes=\"First order\")\ntest_order_2 = Order(id=2, customer_id=2, date_shipped=None, amount_total=0, notes=\"Second order\")\ntest_order_3 = Order(id=3, customer_id=3, date_shipped=None, amount_total=0, notes=\"Third order\")\ntest_order_4 = Order(id=4, customer_id=4, date_shipped=None, amount_total=0, notes=\"Fourth order\")\n\n# Test Items\ntest_item_1 = Item(id=1, order_id=1, product_id=1, quantity=2, unit_price=10, amount=20)\ntest_item_2 = Item(id=2, order_id=2, product_id=2, quantity=3, unit_price=15, amount=45)\ntest_item_3 = Item(id=3, order_id=3, product_id=3, quantity=4, unit_price=20, amount=80)\ntest_item_4 = Item(id=4, order_id=4, product_id=4, quantity=5, unit_price=25, amount=125)",
+    "test_data_rows": [
+        {
+            "test_data_row_variable": "test_customer_1",
+            "code": "test_customer_1 = Customer(id=1, name=\"Customer A\", credit_limit=5000, balance=0)"
+        },
+        {
+            "test_data_row_variable": "test_customer_2",
+            "code": "test_customer_2 = Customer(id=2, name=\"Customer B\", credit_limit=6000, balance=0)"
+        },
+        {
+            "test_data_row_variable": "test_customer_3",
+            "code": "test_customer_3 = Customer(id=3, name=\"Customer C\", credit_limit=7000, balance=0)"
+        },
+        {
+            "test_data_row_variable": "test_customer_4",
+            "code": "test_customer_4 = Customer(id=4, name=\"Customer D\", credit_limit=8000, balance=0)"
+        },
+        {
+            "test_data_row_variable": "test_product_1",
+            "code": "test_product_1 = Product(id=1, unit_price=10)"
+        },
+        {
+            "test_data_row_variable": "test_product_2",
+            "code": "test_product_2 = Product(id=2, unit_price=15)"
+        },
+        {
+            "test_data_row_variable": "test_product_3",
+            "code": "test_product_3 = Product(id=3, unit_price=20)"
+        },
+        {
+            "test_data_row_variable": "test_product_4",
+            "code": "test_product_4 = Product(id=4, unit_price=25)"
+        },
+        {
+            "test_data_row_variable": "test_order_1",
+            "code": "test_order_1 = Order(id=1, customer_id=1, date_shipped=None, amount_total=0, notes=\"First order\")"
+        },
+        {
+            "test_data_row_variable": "test_order_2",
+            "code": "test_order_2 = Order(id=2, customer_id=2, date_shipped=None, amount_total=0, notes=\"Second order\")"
+        },
+        {
+            "test_data_row_variable": "test_order_3",
+            "code": "test_order_3 = Order(id=3, customer_id=3, date_shipped=None, amount_total=0, notes=\"Third order\")"
+        },
+        {
+            "test_data_row_variable": "test_order_4",
+            "code": "test_order_4 = Order(id=4, customer_id=4, date_shipped=None, amount_total=0, notes=\"Fourth order\")"
+        },
+        {
+            "test_data_row_variable": "test_item_1",
+            "code": "test_item_1 = Item(id=1, order_id=1, product_id=1, quantity=2, unit_price=10, amount=20)"
+        },
+        {
+            "test_data_row_variable": "test_item_2",
+            "code": "test_item_2 = Item(id=2, order_id=2, product_id=2, quantity=3, unit_price=15, amount=45)"
+        },
+        {
+            "test_data_row_variable": "test_item_3",
+            "code": "test_item_3 = Item(id=3, order_id=3, product_id=3, quantity=4, unit_price=20, amount=80)"
+        },
+        {
+            "test_data_row_variable": "test_item_4",
+            "code": "test_item_4 = Item(id=4, order_id=4, product_id=4, quantity=5, unit_price=25, amount=125)"
+        }
+    ],
+    "test_data_sqlite": "-- Test Customers\nINSERT INTO customer (id, name, credit_limit, balance) VALUES (1, 'Customer A', 5000, 0);\nINSERT INTO customer (id, name, credit_limit, balance) VALUES (2, 'Customer B', 6000, 0);\nINSERT INTO customer (id, name, credit_limit, balance) VALUES (3, 'Customer C', 7000, 0);\nINSERT INTO customer (id, name, credit_limit, balance) VALUES (4, 'Customer D', 8000, 0);\n\n-- Test Products\nINSERT INTO product (id, unit_price) VALUES (1, 10);\nINSERT INTO product (id, unit_price) VALUES (2, 15);\nINSERT INTO product (id, unit_price) VALUES (3, 20);\nINSERT INTO product (id, unit_price) VALUES (4, 25);\n\n-- Test Orders\nINSERT INTO \"order\" (id, customer_id, date_shipped, amount_total, notes) VALUES (1, 1, NULL, 0, 'First order');\nINSERT INTO \"order\" (id, customer_id, date_shipped, amount_total, notes) VALUES (2, 2, NULL, 0, 'Second order');\nINSERT INTO \"order\" (id, customer_id, date_shipped, amount_total, notes) VALUES (3, 3, NULL, 0, 'Third order');\nINSERT INTO \"order\" (id, customer_id, date_shipped, amount_total, notes) VALUES (4, 4, NULL, 0, 'Fourth order');\n\n-- Test Items\nINSERT INTO item (id, order_id, product_id, quantity, unit_price, amount) VALUES (1, 1, 1, 2, 10, 20);\nINSERT INTO item (id, order_id, product_id, quantity, unit_price, amount) VALUES (2, 2, 2, 3, 15, 45);\nINSERT INTO item (id, order_id, product_id, quantity, unit_price, amount) VALUES (3, 3, 3, 4, 20, 80);\nINSERT INTO item (id, order_id, product_id, quantity, unit_price, amount) VALUES (4, 4, 4, 5, 25, 125);",
+    "name": "Order Management System"
+}