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

api_logic_server_cli/prototypes/genai_demo/logic/load_verify_rules.py

@@ -0,0 +1,216 @@
+#
+# This code loads and verifies rules from export.json and activates them if they pass verification
+# It is WebGenAI specific, used only when env var WG_PROJECT is set
+#
+import ast
+import json
+import logging
+import os
+import sys
+import safrs
+import subprocess
+from importlib import import_module
+from pathlib import Path
+from werkzeug.utils import secure_filename
+from database.models import *
+from logic_bank.logic_bank import DeclareRule, Rule, LogicBank
+from colorama import Fore, Style, init
+from logic_bank.logic_bank import RuleBank
+from logic_bank.rule_bank.rule_bank_setup import find_referenced_attributes
+import tempfile
+
+
+app_logger = logging.getLogger(__name__)
+declare_logic_message = "ALERT:  *** No Rules Yet ***"  # printed in api_logic_server.py
+
+rule_import_template = """
+from logic_bank.logic_bank import Rule
+from database.models import *
+
+def init_rule():
+{rule_code}
+"""
+
+MANAGER_PATH = "/opt/webgenai/database/manager.py"
+EXPORT_JSON_PATH = os.environ.get("EXPORT_JSON_PATH", "./docs/export/export.json")
+
+
+def set_rule_status(rule_id, status):
+    """
+    Call the manager.py script to set the status of a rule 
+    
+    (if the status is "active", the manager will remove the rule error)
+    """
+    if not Path(MANAGER_PATH).exists():
+        app_logger.info(f"No manager, can't set rule {rule_id} status {status}")
+        return
+    subprocess.run([
+            "python", MANAGER_PATH, 
+            "-R", rule_id,
+            "--rule-status", status],
+            cwd="/opt/webgenai")
+
+
+def set_rule_error(rule_id, error):
+    """
+    Call the manager.py script to set the error of a rule
+    """
+    if not Path(MANAGER_PATH).exists():
+        app_logger.warning(f"No manager, can't set rule {rule_id} error {error}")
+        return
+    subprocess.check_output([
+                "python", MANAGER_PATH, 
+                "-R", rule_id,
+                "--rule-error", error],
+                cwd="/opt/webgenai")
+
+
+def check_rule_code_syntax(rule_code):
+    """
+    Check the syntax of the rule code
+    """
+    try:
+        ast.parse(rule_code)
+        return rule_code
+    except Exception as exc:
+        log.warning(f"Syntax error in rule code '{rule_code}': {exc}")
+    
+    rule_code = rule_code.replace("\\\\", "\\")
+    try:
+        ast.parse(rule_code)
+        return rule_code
+    except Exception as exc:
+        log.warning(f"Syntax error in rule code '{rule_code}': {exc}")
+        return None
+
+
+def get_exported_rules(rule_code_dir):
+    """
+    Read the exported rules from export.json and write the code to the 
+    rule_code_dir
+    """
+    export_file = Path(EXPORT_JSON_PATH)
+    if not export_file.exists():
+        app_logger.info(f"{export_file.resolve()} does not exist")
+        return []
+
+    try:
+        with open(export_file) as f:
+            export = json.load(f)
+        rules = export.get("rules", [])
+    except Exception as exc:
+        app_logger.warning(f"Failed to load rules from {export_file}: {exc}")
+        return []
+
+    for rule in rules:
+        if rule["status"] == "rejected":
+            continue
+        rule_file = rule_code_dir / f"{secure_filename(rule['name']).replace('.','_')}.py"
+        try:
+            # write current rule to rule_file
+            # (we can't use eval, because logicbank uses inspect)
+            rule_code_str = check_rule_code_syntax(rule["code"])
+            if not rule_code_str:
+                continue
+            with open(rule_file, "w") as temp_file:
+                rule_code = "\n".join([f"  {code}" for code in rule_code_str.split("\n")])
+                temp_file.write(rule_import_template.format(rule_code=rule_code))
+                temp_file_path = temp_file.name
+            # module_name used to import current rule
+            module_name = Path(temp_file_path).stem
+            rule["module_name"] = module_name
+            app_logger.info(f"{rule['id']} rule file: {rule_file}")
+        except Exception as exc:
+            app_logger.exception(exc)
+            app_logger.warning(f"Failed to write rule code to {rule_file}: {exc}")
+            
+    return rules
+
+
+def verify_rules(rule_code_dir, rule_type="accepted"):
+    """
+    Verify the rules from export.json and activate them if they pass verification
+    
+    Write the rule code to a temporary file and import it as a module
+    """
+    rules = get_exported_rules(rule_code_dir)
+    
+    for rule in rules:
+        if not rule["status"] == rule_type:
+            continue
+        module_name = rule["module_name"]
+        app_logger.info(f"\n{Fore.BLUE}Verifying rule: {module_name} - {rule['id']}{Style.RESET_ALL}")
+        try:
+            rule_module = import_module(module_name)
+            rule_module.init_rule()
+            LogicBank.activate(session=safrs.DB.session, activator=rule_module.init_rule)
+            if rule["status"] != "active":
+                set_rule_status(rule["id"], "active")
+            app_logger.info(f"\n{Fore.GREEN}Activated rule {rule['id']}{Style.RESET_ALL}")
+            
+        except Exception as exc:
+            app_logger.exception(exc)
+            set_rule_error(rule["id"], f"{type(exc).__name__}: {exc}")
+            app_logger.warning(f"{Fore.RED}Failed to verify {rule_type} rule code\n{rule['code']}\n{Fore.YELLOW}{type(exc).__name__}: {exc}{Style.RESET_ALL}")
+            app_logger.debug(f"{rule}")
+            rule["status"] = "accepted"
+            rule["error"] = f"{type(exc).__name__}: {exc}"
+        
+    return rules
+   
+      
+def load_active_rules(rule_code_dir, rules=None):
+    """
+    Load the active rules from export.json
+    """
+    if not rules:
+        rules = get_exported_rules(rule_code_dir)
+    for rule in rules:
+        module_name = rule.get("module_name", None)
+        if not rule["status"] == "active" or module_name is None:
+            continue
+        app_logger.info(f"{Fore.GREEN}Loading Rule Module {module_name} {rule['id']} {Style.RESET_ALL}")
+        rule_module = import_module(module_name)
+        try:
+            rule_module.init_rule()
+        except Exception as exc:
+            app_logger.exception(exc)
+            app_logger.warning(f"{Fore.RED}Failed to load active rule {rule['id']} {rule['code']} {Style.RESET_ALL}")
+            set_rule_error(rule["id"], f"{type(exc).__name__}: {exc}")
+            
+
+def get_project_id():
+    if os.environ.get("PROJECT_ID"):
+        return os.environ.get("PROJECT_ID")
+    
+    return Path(os.getcwd()).name
+
+
+def load_verify_rules():
+    
+    # Add FileHandler to root_logger
+    log_file = Path(os.getenv("LOG_DIR",tempfile.mkdtemp())) / "load_verify_rules.log"
+    file_handler = logging.FileHandler(log_file)
+    root_logger = logging.getLogger()
+    root_logger.addHandler(file_handler)
+    
+    rule_code_dir = Path("./logic/wg_rules") # in the project root
+    rule_code_dir.mkdir(parents=True, exist_ok=True)
+    sys.path.append(f"{rule_code_dir}")
+    
+    app_logger.info(f"Loading rules from {rule_code_dir.resolve()}")
+    
+    rules = []
+    
+    if os.environ.get("VERIFY_RULES") == "True":
+        rules = verify_rules(rule_code_dir, rule_type="active")
+        verify_rules(rule_code_dir, rule_type="accepted")
+    else:
+        try:
+            load_active_rules(rule_code_dir, rules)
+        except Exception as exc:
+            app_logger.exception(exc)
+            app_logger.warning(f"{Fore.RED}Failed to load active exported rules: {exc}{Style.RESET_ALL}")
+            
+    root_logger.removeHandler(file_handler)
+    

api_logic_server_cli/prototypes/genai_demo/logic/logic_discovery/auto_discovery.py

@@ -0,0 +1,52 @@
+import importlib
+from pathlib import Path
+import logging
+
+app_logger = logging.getLogger(__name__)
+
+def discover_logic():
+    """
+    Discover additional logic in this directory
+    """
+    import os
+    logic = []
+    logic_path = Path(__file__).parent
+    for root, dirs, files in os.walk(logic_path):
+        for file in files:
+            if file.endswith(".py"):
+                spec = importlib.util.spec_from_file_location("module.name", logic_path.joinpath(file))
+                if file.endswith("auto_discovery.py"):
+                    pass
+                else:
+                    logic.append(file)
+                    each_logic_file = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(each_logic_file)  # runs "bare" module code (e.g., initialization)
+                    each_logic_file.declare_logic()  # invoke create function
+
+    # if False and Path(__file__).parent.parent.parent.joinpath("docs/project_is_genai_demo.txt").exists():
+    #     return  # for genai_demo, logic is in logic/declare_logic.py (so ignore logic_discovery)
+    
+    wg_logic_path = Path(__file__).parent.parent.joinpath("wg_rules")
+    if wg_logic_path.exists():
+        run_local = os.environ.get("WG_PROJECT") is None  # eg, running export locally
+        # run_local = False  # for debug
+        if run_local:  
+            wg_export_logic_path = Path(__file__).parent.parent.parent.joinpath("logic/wg_rules/active_rules_export.py") 
+            if wg_export_logic_path.is_file():
+                    spec = importlib.util.spec_from_file_location("module.name", wg_export_logic_path)
+                    logic.append(str(wg_export_logic_path))
+                    wg_export_logic_file = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(wg_export_logic_file)  # runs "bare" module code (e.g., initialization)  
+                    wg_export_logic_file.declare_logic()  # invoke create function
+        else:
+            for root, dirs, files in os.walk(wg_logic_path):
+                for file in files:
+                    if file.endswith(".py") and 'active_rules_export.py' != file:
+                        spec = importlib.util.spec_from_file_location("module.name", wg_logic_path.joinpath(file))
+                        logic.append(file)
+                        each_logic_file = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(each_logic_file)  # runs "bare" module code (e.g., initialization)
+                        each_logic_file.init_rule()  # invoke create function
+
+    app_logger.info(f"..discovered logic: {logic}")
+    return

api_logic_server_cli/prototypes/genai_demo/logic/readme_declare_logic.md

@@ -0,0 +1,172 @@
+This describes how to use Logic; for more information, [see here](https://apilogicserver.github.io/Docs/Logic-Why).
+
+> Key Takeway -  Logic: Multi-table Derivation and Constraint Rules, Extensible with Python 
+<br>Rules are:
+<br>1. **Declared** in your IDE - 40X more concise
+<br>2. **Activated** on server start
+<br>3. **Executed** - *automatically* -  on updates (using SQLAlchemy events)
+<br>4. **Debugged** in your IDE, and with the console log
+<br>For more on rules, [click here](https://apilogicserver.github.io/Docs/Logic-Why/).
+
+&nbsp;
+
+## Examples      
+Examples from tutorial project:
+* Examples drawn from [tutorial project](https://github.com/ApiLogicServer/demo/blob/main/logic/declare_logic.py)
+* Use Shift + "." to view in project mode
+
+You can [find the rules here](https://apilogicserver.github.io/Docs/Logic).  Below, we explore the syntax of 3 typical rules.
+
+&nbsp;
+
+### 1. Multi-Table Derivations
+
+This declares the Customer.Balance as the sum of the unshipped Order.AmountTotal:
+
+```python
+    Rule.sum(derive=models.Customer.Balance,
+            as_sum_of=models.Order.AmountTotal,
+            where=lambda row: row.ShippedDate is None)
+```
+It means the rule engine **watches** for these changes:
+* Order inserted/deleted, or
+* AmountTotal or ShippedDate or CustomerID changes
+
+Iff changes are detected, the engine **reacts** by *adjusting* the Customer.Balance.  SQLs are [optimized](#declarative-logic-important-notes).
+
+This would **chain** to check the Customers' Constraint rule, described below.
+
+&nbsp;
+
+### 2. Constraints: lambda or function
+
+Constraints are multi-field conditions which must be true for transactions to succeed (else an exception is raised).  You can express the condition as a lambda or a function:
+
+**As a lambda:**
+```python
+    Rule.constraint(validate=models.Customer,
+        as_condition=lambda row: row.Balance <= row.CreditLimit,  # parent references are supported
+        error_msg="balance ({row.Balance}) exceeds credit ({row.CreditLimit})")
+```
+
+**Or, as a function:**
+```python
+    def check_balance(row: models.Customer, old_row: models.Customer, logic_row: LogicRow):
+        if logic_row.ins_upd_dlt != "dlt":  # see also: logic_row.old_row
+            return row.Balance <= row.CreditLimit
+        else:
+            return True
+
+    Rule.constraint(validate=models.Customer,
+        calling=check_balance,
+        error_msg=f"balance ({row.Balance}) exceeds credit ({row.CreditLimit})")
+```
+
+&nbsp;
+
+### 3. Row Events: Extensible with Python
+
+Events are procedural Python code, providing extensibility for declarative rules:
+```python
+    def congratulate_sales_rep(row: models.Order, old_row: models.Order, logic_row: LogicRow):
+        pass  # event code here - sending email, messages, etc.
+
+    Rule.commit_row_event(on_class=models.Order, calling=congratulate_sales_rep)
+```
+Note there are multiple kinds of events, so you can control whether they run before or after rule execution.  For more information, [see here](https://apilogicserver.github.io/Docs/Logic-Type-Constraint).
+
+&nbsp;
+
+## LogicRow: old_row, verb, etc
+
+A key argument to functions is `logic_row`:
+
+* **Wraps row and old_row,** plus methods for insert, update and delete - rule enforcement
+
+* **Additional instance variables:** ins_upd_dlt, nest_level, session, etc.
+
+* **Helper Methods:** are_attributes_changed, set_same_named_attributes, get_parent_logic_row(role_name), get_derived_attributes, log, is_inserted, etc
+
+Here is an example:
+
+```python
+"""
+    STATE TRANSITION LOGIC, using old_row
+"""
+def raise_over_20_percent(row: models.Employee, old_row: models.Employee, logic_row: LogicRow):
+    if logic_row.ins_upd_dlt == "upd" and row.Salary > old_row.Salary:
+        return row.Salary >= Decimal('1.20') * old_row.Salary
+    else:
+        return True
+
+Rule.constraint(validate=models.Employee,
+                calling=raise_over_20_percent,
+                error_msg="{row.LastName} needs a more meaningful raise")
+```
+
+Note the `log` method, which enables you to write row/old_row into the log with a short message:
+
+```python
+logic_row.log("no manager for this order's salesrep")
+```
+
+&nbsp;
+
+## Declarative Logic: Important Notes
+
+Logic *declarative*, which differs from conventional *procedural* logic:
+
+1. **Automatic Invocation:** you don't call the rules; they execute in response to updates (via SQLAlchemy events).
+
+2. **Automatic Ordering:** you don't order the rules; execution order is based on system-discovered depencencies.
+
+3. **Automatic Optimizations:** logic is optimized to reduce SQLs.
+
+    * Rule execution is *pruned* if dependent attributes are not altered
+    * SQL is optimized, e.g., `sum` rules operate by *adjustment*, not expensive SQL `select sum`
+
+These simplify maintenance / iteration: you can be sure new logic is always called, in the correct order.
+
+&nbsp;
+
+## Debugging
+
+Debug rules using **system-generated logic log** and your **IDE debugger**; for more information, [see here](https://apilogicserver.github.io/Docs/Logic-Use).
+
+&nbsp;
+
+### Using the debugger
+
+Use the debugger as shown below.  Note you can stop in lambda functions.
+
+![Logic Debugger](https://apilogicserver.github.io/Docs/images/logic/logic-debug.png)
+
+&nbsp;
+
+### Logic Log
+
+Logging is performed using standard Python logging, with a logger named `logic_logger`.  Use `info` for tracing, and `debug` for additional information (e.g., all declared rules are logged).
+
+In addition, the system logs all rules that fire, to aid in debugging.  Referring the the screen shot above:
+
+*   Each line represents a rule execution, showing row state (old/new values), and the _{reason}_ that caused the update (e.g., client, sum adjustment)
+*   Log indention shows multi-table chaining
+
+&nbsp;
+
+## How Logic works
+
+*Activation* occurs in `api_logic_server_run.py`:
+```python
+    LogicBank.activate(session=session, activator=declare_logic, constraint_event=constraint_handler)
+```
+
+This installs the rule engine as a SQLAlchemy event listener (`before_flush`).  So, Logic *runs* automatically, in response to transaction commits (typically via the API).
+
+Rules plug into SQLAlchemy events, and execute as follows:
+
+| Logic Phase | Why It Matters |
+|:-----------------------------|:---------------------|
+| **Watch** for changes at the attribute level | Performance - Automatic Attribute-level Pruning |
+| **React** by recomputing value | Ensures Reuse - Invocation is automatic<br>Derivations are optimized (e.g. *adjustment updates* - not aggregate queries) |
+| **Chain** to other referencing data | Simplifies Maintenance - ordering is automatic<br>Multi-table logic automation |

api_logic_server_cli/prototypes/genai_demo/ui/admin/admin.yaml

@@ -1,109 +1,142 @@
 about:
-  date: January 27, 2024 16:41:35
-  merged:
-    at: January 28, 2024 13:17:27
-    new_attributes: 'Product.CarbonNeutral '
-    new_resources: ''
-    new_tab_groups: ''
+  date: February 02, 2025 11:44:16
   recent_changes: works with modified safrs-react-admin
   version: 0.0.0
 api_root: '{http_type}://{swagger_host}:{port}/{api}'
-authentication:
-  endpoint: '{http_type}://{swagger_host}:{port}/api/auth/login'
+authentication: '{system-default}'
 info:
   number_relationships: 3
   number_tables: 4
+info_toggle_checked: true
 resources:
   Customer:
     attributes:
-    - label: ' Customer Name*'
-      name: CustomerName
-      required: true
+    - label: ' name*'
+      name: name
       search: true
       sort: true
-    - name: Address
-    - name: Phone
-    - name: Balance
-    - name: CreditLimit
-      required: true
-    - name: CustomerID
+    - name: balance
+      type: DECIMAL
+    - name: credit_limit
+      type: DECIMAL
+    - name: id
+    description: Represents a customer in the system with unique name, balance, and
+      credit limit attributes.
+    info_list: Represents a customer in the system with unique name, balance, and
+      credit limit attributes.
     tab_groups:
     - direction: tomany
       fks:
-      - CustomerID
+      - customer_id
       name: OrderList
       resource: Order
     type: Customer
-    user_key: CustomerName
+    user_key: name
   Item:
     attributes:
-    - label: ' Item I D*'
-      name: ItemID
+    - label: ' id*'
+      name: id
       search: true
       sort: true
-    - name: OrderID
-    - name: ProductID
-    - name: Quantity
+    - name: order_id
+    - name: product_id
+    - name: quantity
       required: true
-    - name: UnitPrice
-    - name: Amount
+    - name: unit_price
+      type: DECIMAL
+    - name: amount
+      type: DECIMAL
+    description: Represents an item in an order, including quantity and pricing details.
+    info_list: Represents an item in an order, including quantity and pricing details.
     tab_groups:
     - direction: toone
       fks:
-      - OrderID
-      name: Order
+      - order_id
+      name: order
       resource: Order
     - direction: toone
       fks:
-      - ProductID
-      name: Product
+      - product_id
+      name: product
       resource: Product
     type: Item
-    user_key: ItemID
+    user_key: id
   Order:
     attributes:
-    - label: ' Order I D*'
-      name: OrderID
+    - label: ' id*'
+      name: id
       search: true
       sort: true
-    - name: CustomerID
-    - name: OrderDate
-    - name: Notes
-    - name: ShipDate
-    - name: AmountTotal
+    - name: customer_id
+    - name: amount_total
+      type: DECIMAL
+    - name: notes
+    - name: date_shipped
+      type: DATE
+    description: Represents an order made by a customer, including a notes field.
+    info_list: Represents an order made by a customer, including a notes field.
     tab_groups:
     - direction: tomany
       fks:
-      - OrderID
+      - order_id
       name: ItemList
       resource: Item
     - direction: toone
       fks:
-      - CustomerID
-      name: Customer
+      - customer_id
+      name: customer
       resource: Customer
     type: Order
-    user_key: OrderID
+    user_key: id
   Product:
     attributes:
-    - label: ' Product Name*'
-      name: ProductName
-      required: true
+    - label: ' name*'
+      name: name
       search: true
       sort: true
-    - name: UnitPrice
-      required: true
-    - name: ProductID
-    - name: CarbonNeutral
-      type: Boolean
+    - name: unit_price
+      type: DECIMAL
+    - name: carbon_neutral
+      type: BOOLEAN
+    - name: id
+    description: Represents a product available in the system with a unit price.
+    info_list: Represents a product available in the system with a unit price.
     tab_groups:
     - direction: tomany
       fks:
-      - ProductID
+      - product_id
       name: ItemList
       resource: Item
     type: Product
-    user_key: ProductName
+    user_key: name
 settings:
-  HomeJS: http://localhost:5656/admin-app/home.js
+  HomeJS: /admin-app/home.js
   max_list_columns: 8
+  style_guide:
+    applicationLocales:
+    - en
+    - es
+    currency_symbol: $
+    currency_symbol_position: left
+    date_format: LL
+    decimal_max: '1000000000'
+    decimal_min: '0'
+    decimal_separator: .
+    detail_mode: tab
+    edit_on_mode: dblclick
+    exclude_listpicker: false
+    include_translation: 'false'
+    keycloak_client_id: alsclient
+    keycloak_realm: kcals
+    keycloak_url: http://localhost:8080
+    locale: en
+    max_decimal_digits: '4'
+    min_decimal_digits: '2'
+    new_mode: dialog
+    pick_style: list
+    row_height: small,
+    serviceType: OntimizeEE
+    startSessionPath: /auth/login
+    style: light
+    thousand_separator: ','
+    use_keycloak: 'false'

api_logic_server_cli/prototypes/manager/.vscode/launch.json

@@ -730,7 +730,7 @@
             "id": "runProjectName",
             "type": "promptString",
             "description": "Project Name (folder) to run",
-            "default": "samples/nw"
+            "default": "genai_demo"
         },
         {
             "id": "inputGenaiProjectName",