ApiLogicServer 15.0.61__py3-none-any.whl → 15.1.0__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo/docs/system-creation-vibe.md

@@ -0,0 +1,158 @@
+---
+title: Vibe MCP / Microservice
+do_process_code_block_titles: True
+version: 0.23 from docsite 7/11/2025
+---
+<style>
+  .md-typeset h1,
+  .md-content__button {
+    display: none;
+  }
+</style>
+
+<< Under Construction >>
+
+# Vibe an MCP Microservice
+
+See the Readme for detailed walk through.
+
+Scenario: we have an existing database (customers, order, items and product), and we require:
+
+* An MCP-enabled API, for integration
+* MCP client support to send emails for overdue orders
+* Business Logic to check credit by rolling up Items and Orders.
+
+This is a record of how we created the system using CoPilot Chat (*Vibe*).
+
+<br>
+
+## Initialize CoPilot
+
+```
+Please find and read `.github/.copilot-instructions.md`.
+```
+
+<br>
+
+## Create the System
+
+```bash title="Create a project from an existing database"
+# in the GenAI-Logic Manager:
+Create a database project from samples/dbs/basic_demo.sqlite
+```
+
+<br>
+
+## Verify the API and Admin App
+
+The project should automatically open a new window in VSCode.  Again, open CoPilot and bootstrap it with: <br>
+
+```bash title="Initialize CoPilot"
+Please find and read `.github/.copilot-instructions.md`**.
+```
+
+Verify it as follows:
+
+* **Click F5** to start server, open app at http://localhost:5656/
+* **Verify API:** filtering, sorting, pagination, optimistic locking and related data access - see the Swagger
+* **Verify Admin App:** multi-page, multi-table, automatic joins, lookups, cascade add - collaboration-ready
+
+<br>
+
+## Create a Custom React App
+
+```bash title="Create a custom react app"
+Create a react app.
+```
+
+<br>
+
+```txt title='Customize using Natural Language - Add Cards'
+In the ui/react app, update the Product list to provide users an option to see results in a list,
+or in cards.
+```
+<br>
+
+todo - diagram 
+
+**Test: verify option for cards on `http://localhost:3000`**
+
+<br>
+
+## MCP Client - Overdue Orders
+
+**Stop the Server**
+
+<br>
+
+``` bash title="Add a Table to Track Sent Emails"
+Create a table SysEmail in `database/db.sqlite` as a child of customer, 
+with columns id, message, subject, customer_id and CreatedOn.
+```
+Follow the suggestions to update the admin app.
+
+<br>
+
+<br>
+
+``` bash title="Create MCP Executor: process request - invokes the LLM to obtain a series of API calls to run, and runs them"
+Create the mcp client executor
+```
+
+<br>
+
+``` bash title="Create the email service using SysEmail as a Request Table"
+Add an after_flush event on SysEmail to produce a log message "email sent",
+unless the customer has opted out.
+```
+
+<br>
+
+```bash title="Business Logic to Honor Email Opt-out"
+Add an after_flush event on SysEmail to produce a log message "email sent",
+unless the customer has opted out.
+```
+
+<br>
+
+```text title="Test the MCP Client: Click SysMCP >> Create New, and enter"
+List the orders date_shipped is null and CreatedOn before 2023-07-14, 
+and send a discount email (subject: 'Discount Offer') to the customer for each one.
+```
+
+<br>
+todo - diagram 
+
+**Use the Admin App to Verify the first customer has an email**
+
+<br>
+
+## Check Credit Business Logic
+
+**1. Stop the Server** (Red Stop button, or Shift-F5 -- see Appendix)
+
+**2. Add Business Logic**
+
+```bash title="Check Credit Logic (instead of 220 lines of code)"
+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.
+```
+
+To test the logic:
+
+**1. Use the Admin App to access the first order for `Customer Alice`**
+
+**2. Edit its first item to a very high quantity**
+
+todo - diagram 
+
+The update is properly rejected because it exceeds the credit limit.  Observe the rules firing in the console log - see Logic In Action, below.
+
+<br>

api_logic_server_cli/prototypes/manager/samples/basic_demo/docs/training/admin_app_1_context.prompt.md

@@ -0,0 +1,43 @@
+
+Generate a full React Admin application using the following instructions.  
+The result must be a runnable React app (`npm start`) that connects to the supplied JSON:API, with fully implemented components (no placeholders or empty files).
+
+## Critical Data Access Provider Configuration
+
+This project uses a **pre-configured JSON:API data provider** that was built when the project was created. 
+
+### Key Requirements:
+
+1. **Data Provider**: Use the existing `jsonapiClient` from `./rav4-jsonapi-client/ra-jsonapi-client`
+2. **Record Context**: For custom components (like cards), ALWAYS wrap with `<RecordContextProvider value={record}>` 
+3. **List Data Access**: Use `useListContext()` to get data and loading state
+4. **Individual Records**: Use `useRecordContext()` to access record data within providers
+5. **API Root**: The data provider connects to `conf.api_root` (typically `http://localhost:5656/api`)
+
+### Example Pattern for Custom List Views:
+```javascript
+import { useListContext, RecordContextProvider, useRecordContext } from 'react-admin';
+
+const CustomGrid = () => {
+    const { data, isLoading } = useListContext();
+    
+    return (
+        <Grid container>
+            {data?.map(record => (
+                <Grid item key={record.id}>
+                    <RecordContextProvider value={record}>
+                        <CustomCard />
+                    </RecordContextProvider>
+                </Grid>
+            ))}
+        </Grid>
+    );
+};
+
+const CustomCard = () => {
+    const record = useRecordContext();
+    return <Card>{record.name}</Card>;
+};
+```
+
+### CRITICAL: Do NOT create new data providers or modify the existing JSON:API client configuration. The project's data flow depends on the pre-built provider.

api_logic_server_cli/prototypes/manager/samples/basic_demo/docs/training/admin_app_2_functionality.prompt.md

@@ -0,0 +1,69 @@
+
+
+## App Features
+
+### Multi-Page
+
+For each resource:
+- Create a **List page** showing 7 user-friendly columns
+- Add **pagination**, **sorting**, and **filtering**
+- Link each row to a **Display (Show) page**
+
+### Multi-Resource
+
+Each **Display Page** should:
+- Show all fields in a **multi-column layout**
+- Include a **tab sheet** (`<TabbedShowLayout>`) for each related resource using `<ReferenceManyField>`
+- Link child rows to their own display page
+
+Example:  
+- Customer Display has tab for OrderList  
+- Each Order in the tab links to Order Display
+
+### Automatic Joins
+
+For foreign keys:
+- Display joined value (e.g., `product.name` instead of `product_id`)
+- Use first string field from parent table containing `name`, `title`, or `description`
+
+Primary key fields:
+- Display at the end of forms/lists
+
+### Lookups (Foreign Keys)
+
+For foreign key fields:
+- Provide auto-complete dropdown (`<ReferenceInput>`)
+- For numeric foreign keys, use the joined string field as lookup text
+
+
+---
+
+## Per-Resource Files (Required)
+
+For each resource (`Customer`, `Order`, `Product`, `Item`):
+- Create a source file under `src/`, e.g., `Customer.js`
+- **Each file must fully implement**:
+  - `CustomerList`
+  - `CustomerShow`
+  - `CustomerCreate`
+  - `CustomerEdit`
+
+Use:
+- `<ReferenceField>` for foreign key displays
+- `<ReferenceInput>` for foreign key input
+- `<ReferenceManyField>` for tabbed child lists
+- `<TabbedShowLayout>` for display pages
+
+Do **not leave any file empty**.
+
+---
+
+## App Wiring
+
+In `App.js`:
+- Import each resource file
+- Register them in `<Admin>` using:
+
+```jsx
+<Resource name="Customer" list={CustomerList} show={CustomerShow} edit={CustomerEdit} create={CustomerCreate} />
+```

api_logic_server_cli/prototypes/manager/samples/basic_demo/docs/training/admin_app_3_architecture.prompt.md

@@ -0,0 +1,29 @@
+
+## Architecture
+
+- **Framework**: React 18 + react-admin 4.x
+- **Data Provider**: Custom `dataProvider.js` using `fetchUtils` (no external `ra-jsonapi-client`)
+  - Must support: `getList`, `getOne`, `getMany`, `getManyReference`, `create`, `update`, `delete`
+  - Must support: filters, joins, sorting, pagination
+- **Backend**: JSON:API per `mcp_discovery.json`
+- **CORS**: Ensure API allows `http://localhost:3000`
+  ```py
+  from flask_cors import CORS  
+  CORS(app, origins='*')  # or restrict to localhost:3000
+  ```
+- **Project Setup**:
+  - Use `create-react-app`
+  - Include: `react-admin`, `@mui/material`, `@emotion/react`, `@emotion/styled`, `react-router-dom`
+  - Do not use any deprecated or unmaintained libraries
+  - Include complete and correct `App.js`, `index.js`, `dataProvider.js`, and `index.html`
+
+---
+
+## Run Instructions
+
+```bash
+npm install
+npm start
+```
+
+Then open in browser: `http://localhost:3000`

api_logic_server_cli/prototypes/manager/samples/basic_demo/docs/training/logic_bank_api.prompt

@@ -0,0 +1,342 @@
+Here is the simplified API for LogicBank:
+
+Translate the user prompt into a series of calls to Rule methods, described here.
+
+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.
+
+IMPORTANT: Keep it simple! Use the built-in Rule methods with their parameters (like if_condition) rather than creating custom functions. The Rule methods are designed to handle common patterns directly.
+
+
+class Rule:
+    """ Invoke these functions to declare rules """
+
+    @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)
+
+
+    @staticmethod
+    def after_flush_row_event(on_class: object, calling: Callable = None,
+                              if_condition: any = None,
+                              when_condition: any = None,
+                              with_args: dict = None):
+        """
+        Events are triggered after database flush for integration (Kafka, etc.)
+        
+        IMPORTANT: Use this simple pattern - do NOT create custom functions unless absolutely necessary.
+        Use if_condition parameter for conditional logic instead of writing custom event handlers.
+
+        Example:
+            Prompt:
+                Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None
+            Response:
+                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"})
+            Prompt:
+                Send the Product to Kafka topic 'ready_to_ship' if the is_complete is True
+            Response:
+                Rule.after_flush_row_event(on_class=Product, calling=kafka_producer.send_row_to_kafka,
+                               if_condition=lambda row: row.is_complete is True,
+                               with_args={"topic": "ready_to_ship"})
+
+        Args:
+            on_class: The model class to watch for changes
+            calling: Use kafka_producer.send_row_to_kafka for Kafka integration
+            if_condition: Lambda function to specify when the event should trigger
+            with_args: Dictionary with parameters like {"topic": "topic_name"}
+        """
+
+
+Expanded example:
+
+    Prompt:
+        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:
+        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:
+        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:
+        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")
+
+
+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)
+
+CRITICAL: For event handling (Kafka integration, etc.), do NOT create custom event functions.
+Use Rule.after_flush_row_event with if_condition parameter instead.
+
+WRONG (do not do this):
+    def my_custom_kafka_function(row, old_row, logic_row):
+        # custom logic here
+    Rule.commit_row_event(on_class=Order, calling=my_custom_kafka_function)
+
+RIGHT (do this instead):
+import integration.kafka.kafka_producer as kafka_producer
+    Rule.after_flush_row_event(on_class=models.Order, calling=kafka_producer.send_row_to_kafka,
+                               if_condition=lambda row: row.date_shipped is not None,
+                               with_args={"topic": "order_shipping"})
+
+logic should create python files in logic/logic_discovery, 
+and cross-check/use attribute names in database/models.py

api_logic_server_cli/prototypes/manager/samples/basic_demo/docs/training/logic_example.py

@@ -0,0 +1,41 @@
+import datetime
+from decimal import Decimal
+from logic_bank.exec_row_logic.logic_row import LogicRow
+from logic_bank.extensions.rule_extensions import RuleExtension
+from logic_bank.logic_bank import Rule
+from database import models
+import api.system.opt_locking.opt_locking as opt_locking
+from security.system.authorization import Grant
+import logging
+from flask import jsonify
+
+
+""" 
+logic should create python files in logic/logic_discovery, 
+and cross-check/use attribute names in database/models.py
+"""
+
+app_logger = logging.getLogger(__name__)
+
+
+def declare_logic():
+    """
+        Simple constraints for error testing 
+    """
+    Rule.constraint(validate=models.Customer,
+        as_condition=lambda row: row.CompanyName != 'x',
+        error_msg="CustomerName cannot be 'x'")
+
+    Rule.constraint(validate=models.Employee,
+        as_condition=lambda row: row.LastName != 'x',
+        error_msg="LastName cannot be 'x'")
+    
+    def valid_category_description(row: models.Category, old_row: models.Category, logic_row: LogicRow):
+        if logic_row.ins_upd_dlt == "upd":
+            return row.Description != 'x'
+        else:
+            return True
+    Rule.constraint(validate=models.Category,
+                    calling=valid_category_description,
+                    error_msg="Description cannot be 'x'")
+