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

api_logic_server_cli/prototypes/manager/samples/basic_demo/logic/load_verify_rules.py

@@ -0,0 +1,217 @@
+#
+# 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 *
+import integration.kafka.kafka_producer as kafka_producer
+
+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/manager/samples/basic_demo/logic/logic_discovery/app_integration.py

@@ -0,0 +1,23 @@
+import datetime
+from decimal import Decimal
+import integration.kafka.kafka_producer as kafka_producer
+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 logging
+
+app_logger = logging.getLogger(__name__)
+
+
+def declare_logic():
+    """
+    App Integration Use Case Logic
+    
+    Natural Language Requirements:
+    1. Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None.
+    """
+    
+    # 1. Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None
+    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'})

api_logic_server_cli/prototypes/manager/samples/basic_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/manager/samples/basic_demo/logic/logic_discovery/check_credit.py

@@ -0,0 +1,44 @@
+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 logging
+
+app_logger = logging.getLogger(__name__)
+
+
+def declare_logic():
+    """
+    Check Credit Use Case Logic
+    
+    Natural Language Requirements:
+    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
+    """
+    
+    # 1. The Customer's balance is less than the credit limit
+    Rule.constraint(validate=models.Customer,
+                   as_condition=lambda row: row.balance <= row.credit_limit,
+                   error_msg="Customer balance exceeds credit limit")
+    
+    # 2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
+    Rule.sum(derive=models.Customer.balance, 
+             as_sum_of=models.Order.amount_total,
+             where=lambda row: row.date_shipped is None)
+    
+    # 3. The Order's amount_total is the sum of the Item amount
+    Rule.sum(derive=models.Order.amount_total, 
+             as_sum_of=models.Item.amount)
+    
+    # 4. The Item amount is the quantity * unit_price
+    Rule.formula(derive=models.Item.amount, 
+                 as_expression=lambda row: row.quantity * row.unit_price)
+    
+    # 5. The Item unit_price is copied from the Product unit_price
+    Rule.copy(derive=models.Item.unit_price, 
+              from_parent=models.Product.unit_price)

api_logic_server_cli/prototypes/manager/samples/basic_demo/logic/logic_discovery/mcp_client_executor_request.py

@@ -0,0 +1,50 @@
+""" 
+Invokes MCP client executor to process MCP requests when a new SysMcp row is inserted.
+"""
+
+import json
+import os, logging
+from typing import Dict, List
+import openai
+import requests
+from logic_bank.logic_bank import Rule
+from logic_bank.exec_row_logic.logic_row import LogicRow
+from database import models
+from database.mcp_models import SysMcp as SysMcp  # type: ignore
+from sqlalchemy import Column, Integer, String, DECIMAL, Boolean
+from logic_bank.util import ConstraintException
+import integration.mcp.mcp_client_executor as mcp_client_executor
+
+
+def declare_logic():
+    """
+        This illustrates the request pattern.
+
+        The request pattern is a common pattern in API Logic Server, 
+        where an insert triggers service invocation, such as sending email or issue mcp requests.
+        
+        The SysMCP table captures the prompt (in the row); this logic executes the MCP processing. 
+
+        See: https://apilogicserver.github.io/Docs/Integration-MCP/#3a-logic-request-pattern     
+    """
+
+
+    def mcp_client_executor_event(row: SysMcp, old_row: SysMcp, logic_row: LogicRow):
+        """ 
+
+        #als: create an MCP request.  See https://apilogicserver.github.io/Docs/Integration-MCP/
+
+        Test:
+        * curl -X 'POST' 'http://localhost:5656/api/SysMcp/' -H 'accept: application/vnd.api+json' -H 'Content-Type: application/json' -d '{ "data": { "attributes": {"request": "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."}, "type": "SysMcp"}}'
+        * Or, use the Admin App and insert a row into SysMCP, eg:
+            * 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."
+
+        Args:
+            row (Mcp): inserted SysMcp with prompt
+            old_row (Mcp): n/a
+            logic_row (LogicRow): bundles curr/old row, with ins/upd/dlt logic
+        """
+        result = mcp_client_executor.mcp_client_executor(row.request)
+        pass
+
+    Rule.row_event(on_class=SysMcp, calling=mcp_client_executor_event)  # see above

api_logic_server_cli/prototypes/manager/samples/basic_demo/logic/logic_discovery/readme_logic_discovery.md

@@ -0,0 +1,9 @@
+You can declare logic in `declare_logic.py`,
+but that can lead to a lot of rules in 1 file.
+
+A *best practice* is to create logic files in this directory,
+named after the use case (e.g., `check_credit.py`).  
+
+The easiest way to to copy/paste `use_case.py` to a new file, then
+add your logic either by Natural Language (use your Coding Assistant, such as CoPilot),
+or your IDE's code completion.

api_logic_server_cli/prototypes/manager/samples/basic_demo/logic/logic_discovery/use_case.py

@@ -0,0 +1,31 @@
+import datetime
+from decimal import Decimal
+from integration.kafka import kafka_producer
+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
+
+
+""" 
+Best practice: create logic files for each use case, 
+named for the use case (eg, check_credit.py) 
+"""
+
+app_logger = logging.getLogger(__name__)
+
+
+def declare_logic():
+    """
+    Use GenAI to convert Natural Language into logic, paste here.  See readme_logic_discovery_readme.md for an example.
+    
+    Sample logic:
+    Rule.constraint(validate=models.Customer,
+        as_condition=lambda row: row.CompanyName != 'x',
+        error_msg="CompanyName cannot be 'x'")
+    """
+    pass

api_logic_server_cli/prototypes/manager/samples/basic_demo/logic/procedural/credit_service.py

@@ -0,0 +1,204 @@
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+from src.models.northwind import Customer, Order, OrderDetail, Product
+from typing import Dict, Any, Optional
+from decimal import Decimal
+
+class CreditService:
+    """Service class for credit checking business logic"""
+    
+    def __init__(self, session: Session):
+        self.session = session
+    
+    def calculate_item_amount(self, quantity: int, unit_price: Decimal) -> Decimal:
+        """
+        Calculate item amount: quantity * unit_price
+        
+        Args:
+            quantity: Number of units
+            unit_price: Price per unit
+            
+        Returns:
+            Total amount for the item
+        """
+        if quantity is None or unit_price is None:
+            return Decimal('0.00')
+        return Decimal(str(quantity)) * Decimal(str(unit_price))
+    
+    def calculate_order_amount_total(self, order_id: int) -> Decimal:
+        """
+        Calculate order amount_total as sum of all item amounts in the order
+        
+        Args:
+            order_id: Order ID to calculate total for
+            
+        Returns:
+            Total amount for the order
+        """
+        order_details = self.session.query(OrderDetail, Product)\
+            .join(Product, OrderDetail.ProductId == Product.Id)\
+            .filter(OrderDetail.OrderId == order_id)\
+            .all()
+        
+        total = Decimal('0.00')
+        for order_detail, product in order_details:
+            # Use product's current unit price if order detail doesn't have one
+            unit_price = order_detail.UnitPrice or product.UnitPrice
+            quantity = order_detail.Quantity or 0
+            
+            item_amount = self.calculate_item_amount(quantity, unit_price)
+            
+            # Apply discount if any
+            if order_detail.Discount:
+                discount_factor = Decimal('1.00') - (Decimal(str(order_detail.Discount)) / Decimal('100'))
+                item_amount *= discount_factor
+            
+            total += item_amount
+        
+        return total
+    
+    def calculate_customer_balance(self, customer_id: str) -> Decimal:
+        """
+        Calculate customer balance as sum of Order amount_total where date_shipped is null
+        
+        Args:
+            customer_id: Customer ID to calculate balance for
+            
+        Returns:
+            Current outstanding balance for the customer
+        """
+        # Get all unshipped orders for the customer
+        unshipped_orders = self.session.query(Order)\
+            .filter(Order.CustomerId == customer_id)\
+            .filter(Order.ShippedDate.is_(None))\
+            .all()
+        
+        total_balance = Decimal('0.00')
+        
+        for order in unshipped_orders:
+            # Calculate the order total if not already calculated
+            if order.AmountTotal is not None:
+                order_total = Decimal(str(order.AmountTotal))
+            else:
+                order_total = self.calculate_order_amount_total(order.Id)
+                # Update the order with calculated total
+                order.AmountTotal = float(order_total)
+            
+            total_balance += order_total
+        
+        # Commit any updates to order totals
+        self.session.commit()
+        
+        return total_balance
+    
+    def check_credit_limit(self, customer_id: str) -> Dict[str, Any]:
+        """
+        Check if customer's balance is less than credit limit
+        
+        Args:
+            customer_id: Customer ID to check credit for
+            
+        Returns:
+            Dictionary containing credit check results
+        """
+        customer = self.session.query(Customer).filter(Customer.Id == customer_id).first()
+        
+        if not customer:
+            return {
+                'success': False,
+                'error': 'Customer not found',
+                'customer_id': customer_id
+            }
+        
+        # Calculate current balance
+        current_balance = self.calculate_customer_balance(customer_id)
+        
+        # Get credit limit
+        credit_limit = Decimal(str(customer.CreditLimit)) if customer.CreditLimit else Decimal('0.00')
+        
+        # Check if balance is within credit limit
+        credit_available = credit_limit - current_balance
+        within_limit = current_balance <= credit_limit
+        
+        return {
+            'success': True,
+            'customer_id': customer_id,
+            'customer_name': customer.CompanyName,
+            'current_balance': float(current_balance),
+            'credit_limit': float(credit_limit),
+            'credit_available': float(credit_available),
+            'within_credit_limit': within_limit,
+            'balance_percentage': float((current_balance / credit_limit * 100) if credit_limit > 0 else 0),
+            'unshipped_order_count': self.session.query(Order)
+                                                .filter(Order.CustomerId == customer_id)
+                                                .filter(Order.ShippedDate.is_(None))
+                                                .count()
+        }
+    
+    def get_credit_status_summary(self, customer_id: str) -> Dict[str, Any]:
+        """
+        Get comprehensive credit status including order details
+        
+        Args:
+            customer_id: Customer ID to get status for
+            
+        Returns:
+            Detailed credit status information
+        """
+        credit_check = self.check_credit_limit(customer_id)
+        
+        if not credit_check['success']:
+            return credit_check
+        
+        # Get unshipped orders with details
+        unshipped_orders = self.session.query(Order)\
+            .filter(Order.CustomerId == customer_id)\
+            .filter(Order.ShippedDate.is_(None))\
+            .order_by(Order.OrderDate.desc())\
+            .all()
+        
+        orders_details = []
+        for order in unshipped_orders:
+            order_total = self.calculate_order_amount_total(order.Id)
+            orders_details.append({
+                'order_id': order.Id,
+                'order_date': order.OrderDate,
+                'required_date': order.RequiredDate,
+                'amount_total': float(order_total),
+                'freight': float(order.Freight) if order.Freight else 0,
+                'ship_name': order.ShipName,
+                'order_detail_count': order.OrderDetailCount or 0
+            })
+        
+        credit_check['unshipped_orders'] = orders_details
+        return credit_check
+    
+    def update_order_amounts(self, order_id: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Update order amount totals based on current order details and product prices
+        
+        Args:
+            order_id: Specific order to update, or None to update all orders
+            
+        Returns:
+            Update results
+        """
+        if order_id:
+            orders = self.session.query(Order).filter(Order.Id == order_id).all()
+        else:
+            orders = self.session.query(Order).all()
+        
+        updated_count = 0
+        for order in orders:
+            new_total = self.calculate_order_amount_total(order.Id)
+            if order.AmountTotal != float(new_total):
+                order.AmountTotal = float(new_total)
+                updated_count += 1
+        
+        self.session.commit()
+        
+        return {
+            'success': True,
+            'updated_orders': updated_count,
+            'total_orders_processed': len(orders)
+        }