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

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

@@ -23,21 +23,30 @@ def discover_logic():
                     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)
+    # 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")
-    for root, dirs, files in os.walk(wg_logic_path):
-        for file in files:
-            if file.endswith(".py"):
-                spec = importlib.util.spec_from_file_location("module.name", wg_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.init_rule()  # invoke create function
+    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/api/customize_api.py

@@ -5,8 +5,8 @@ from flask import request, jsonify
 from safrs import jsonapi_rpc
 from database import models
 import integration.system.RowDictMapper as row_dict_mapper
-from integration.row_dict_maps.OrderShipping import OrderShipping
-from integration.row_dict_maps.OrderB2B import OrderB2B
+# from integration.row_dict_maps.OrderShipping import OrderShipping
+from integration.row_dict_maps.OrderB2B import OrderB2B  # TODO - how to drive; B2B...
 
 # called by api_logic_server_run.py, to customize api (new end points, services).
 # separate from expose_api_models.py, to simplify merge if project recreated
@@ -140,15 +140,13 @@ class ServicesEndPoint(safrs.JABase):
         """ # yaml creates Swagger description
             args :
                 order:
-                    Account: "Jane Smith"
+                    Account: "Alice"
                     Notes: "Please Rush"
                     Items :
-                    - ProductName: "Widget A"
+                    - ProductName: "Product 1"
                       QuantityOrdered: 1
-                    - ProductName: "Gadget B"
+                    - ProductName: "Product 2"
                       QuantityOrdered: 2
-                    - ProductName: "Green Apples"
-                      QuantityOrdered: 3
             ---
 
         Note attribute alias, Lookup automation in OrderB2B
@@ -159,19 +157,19 @@ class ServicesEndPoint(safrs.JABase):
         $(venv) ApiLogicServer login --user=admin --password=p
         $(venv) ApiLogicServer curl "'POST' 'http://localhost:5656/api/ServicesEndPoint/OrderB2B'" --data '
         {"meta": {"args": {"order": {
-            "Account": "Jane Smith",
+            "Account": "Alice",
             "Notes": "Please Rush",
             "Items": [
                 {
-                "ProductName": "Widget A",
+                "ProductName": "Product 1",
                 "QuantityOrdered": 1
                 },
                 {
-                "ProductName": "Gadget B",
+                "ProductName": "Product 2",
                 "QuantityOrdered": 2
                 },
                 {
-                "ProductName": "Gadget B",
+                "ProductName": "Green Apples",
                 "QuantityOrdered": 2
                 }
                 ]

api_logic_server_cli/prototypes/genai_demo/database/models.py

@@ -1,5 +1,6 @@
 # coding: utf-8
-from sqlalchemy import Boolean, Column, DECIMAL, DateTime, ForeignKey, Integer, Text, text
+from sqlalchemy import DECIMAL, DateTime  # API Logic Server GenAI assist
+from sqlalchemy import Column, Date, ForeignKey, Integer, Numeric, String, Boolean
 from sqlalchemy.orm import relationship
 from sqlalchemy.ext.declarative import declarative_base
 
@@ -9,13 +10,13 @@ from sqlalchemy.ext.declarative import declarative_base
 # Alter this file per your database maintenance policy
 #    See https://apilogicserver.github.io/Docs/Project-Rebuild/#rebuilding
 #
-# Created:  May 03, 2024 22:23:08
-# Database: sqlite:////Users/val/dev/ApiLogicServer/ApiLogicServer-dev/clean/ApiLogicServer/genai_demo/database/db.sqlite
+# Created:  January 31, 2025 17:52:29
+# Database: sqlite:////Users/val/dev/ApiLogicServer/ApiLogicServer-dev/build_and_test/ApiLogicServer/genai_demo/database/db.sqlite
 # Dialect:  sqlite
 #
 # mypy: ignore-errors
 ########################################################################################################################
-
+ 
 from database.system.SAFRSBaseX import SAFRSBaseX, TestBase
 from flask_login import UserMixin
 import safrs, flask_sqlalchemy, os
@@ -42,72 +43,81 @@ else:
     print('*** Models.py Using TestBase ***')
 
 
-class Customer(Base):
-    __tablename__ = 'Customers'
+
+class Customer(Base):  # type: ignore
+    """
+    description: Customer table with unique name, balance and credit_limit.
+    """
+    __tablename__ = 'customer'
     _s_collection_name = 'Customer'  # type: ignore
 
-    CustomerID = Column(Integer, primary_key=True)
-    CustomerName = Column(Text, nullable=False)
-    Address = Column(Text)
-    Phone = Column(Text)
-    Balance : DECIMAL = Column(DECIMAL(10, 2))
-    CreditLimit : DECIMAL = Column(DECIMAL(10, 2), nullable=False)
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255), unique=True)
+    balance = Column(Numeric)
+    credit_limit = Column(Numeric)
 
     # parent relationships (access parent)
 
     # child relationships (access children)
-    OrderList : Mapped[List["Order"]] = relationship(back_populates="Customer")
+    OrderList : Mapped[List["Order"]] = relationship(back_populates="customer")
 
 
-class Product(Base):
-    __tablename__ = 'Products'
-    _s_collection_name = 'Product'  # type: ignore
 
-    ProductID = Column(Integer, primary_key=True)
-    ProductName = Column(Text, nullable=False)
-    UnitPrice : DECIMAL = Column(DECIMAL(10, 2), nullable=False)
-    CarbonNeutral = Column(Boolean)
+class Product(Base):  # type: ignore
+    """
+    description: Product table with unit_price used for copying to Item.
+    """
+    __tablename__ = 'product'
+    _s_collection_name = 'Product'  # type: ignore
 
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255))
+    unit_price = Column(Numeric)
+    carbon_neutral = Column(Boolean)
     # parent relationships (access parent)
 
     # child relationships (access children)
-    ItemList : Mapped[List["Item"]] = relationship(back_populates="Product")
+    ItemList : Mapped[List["Item"]] = relationship(back_populates="product")
 
 
 
-class Order(Base):
-    __tablename__ = 'Orders'
+class Order(Base):  # type: ignore
+    """
+    description: Order table with a foreign key to Customer, a notes field, date_shipped and derived amount_total.
+    """
+    __tablename__ = 'order'
     _s_collection_name = 'Order'  # type: ignore
 
-    OrderID = Column(Integer, primary_key=True)
-    CustomerID = Column(ForeignKey('Customers.CustomerID'))
-    OrderDate = Column(DateTime, server_default=text("CURRENT_TIMESTAMP"))
-    Notes = Column(Text)
-    ShipDate = Column(DateTime)
-    AmountTotal : DECIMAL = Column(DECIMAL(10, 2))
+    id = Column(Integer, primary_key=True)
+    customer_id = Column(ForeignKey('customer.id'))
+    date_shipped = Column(Date)
+    notes = Column(String(255))
+    amount_total = Column(Numeric)
 
     # parent relationships (access parent)
-    Customer : Mapped["Customer"] = relationship(back_populates=("OrderList"))
+    customer : Mapped["Customer"] = relationship(back_populates=("OrderList"))
 
     # child relationships (access children)
-    ItemList : Mapped[List["Item"]] = relationship(back_populates="Order")
+    ItemList : Mapped[List["Item"]] = relationship(back_populates="order")
 
 
 
-class Item(Base):
-    __tablename__ = 'Items'
+class Item(Base):  # type: ignore
+    """
+    description: Item table with non-null quantity, derived amount and unit_price copied from Product.
+    """
+    __tablename__ = 'item'
     _s_collection_name = 'Item'  # type: ignore
 
-    ItemID = Column(Integer, primary_key=True)
-    OrderID = Column(ForeignKey('Orders.OrderID'))
-    ProductID = Column(ForeignKey('Products.ProductID'))
-    Quantity = Column(Integer, nullable=False)
-    UnitPrice : DECIMAL = Column(DECIMAL(10, 2))
-    Amount : DECIMAL = Column(DECIMAL(10, 2))
+    id = Column(Integer, primary_key=True)
+    order_id = Column(ForeignKey('order.id'))
+    product_id = Column(ForeignKey('product.id'))
+    quantity = Column(Integer, nullable=False)
+    unit_price = Column(Numeric)
+    amount = Column(Numeric)
 
     # parent relationships (access parent)
-    Order : Mapped["Order"] = relationship(back_populates=("ItemList"))
-    Product : Mapped["Product"] = relationship(back_populates=("ItemList"))
+    order : Mapped["Order"] = relationship(back_populates=("ItemList"))
+    product : Mapped["Product"] = relationship(back_populates=("ItemList"))
 
     # child relationships (access children)
-

api_logic_server_cli/prototypes/genai_demo/integration/row_dict_maps/OrderB2B.py

@@ -19,15 +19,13 @@ class OrderB2B(RowDictMapper):
         order = super(OrderB2B, self).__init__(
             model_class=models.Order
             , alias = "order"
-            , fields = [(models.Order.Notes)]
-            , parent_lookups = [( models.Customer, 
-                                  [(models.Customer.CustomerName, 'Account')]
-                                )]
+            , fields = [(models.Order.notes, "Notes")]
+            , parent_lookups = [( models.Customer, [(models.Customer.name, 'Account')] )]
             , related = [
                 (RowDictMapper(model_class=models.Item
                     , alias="Items"
-                    , fields = [(models.Item.Quantity, "QuantityOrdered")]
-                    , parent_lookups = [( models.Product, [models.Product.ProductName] )]
+                    , fields = [(models.Item.quantity, "QuantityOrdered")]
+                    , parent_lookups = [( models.Product, [(models.Product.name, 'ProductName')] )]
                     )
                 )
             ]

api_logic_server_cli/prototypes/genai_demo/integration/row_dict_maps/row_dict_maps_readme.md

@@ -0,0 +1,3 @@
+Create definitions here to configure mappings for row <-> dicts, typically for application integration.
+
+To see a Sample Integration, [click here](https://apilogicserver.github.io/Docs/Sample-Integration/).

api_logic_server_cli/prototypes/genai_demo/logic/declare_logic.py

@@ -1,16 +1,15 @@
-import datetime
+import datetime, os
 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.models import *
-from database.models import Customer, Order, Item, Product
+from logic_bank.logic_bank import DeclareRule
+import database.models as models
 import api.system.opt_locking.opt_locking as opt_locking
-from security.system.authorization import Grant
-import logging, os
-from integration.row_dict_maps.OrderShipping import OrderShipping
-from confluent_kafka import Producer, KafkaException
+from security.system.authorization import Grant, Security
+from logic.load_verify_rules import load_verify_rules
 import integration.kafka.kafka_producer as kafka_producer
+import logging
 
 app_logger = logging.getLogger(__name__)
 
@@ -22,94 +21,91 @@ def declare_logic():
     Brief background: see readme_declare_logic.md
     
     Your Code Goes Here - Use code completion (Rule.) to declare rules
-
-    GenAI: Paste the following into Copilot Chat, and paste the result below.
-        
-    Use Logic Bank to enforce these requirements:
-    
-    Enforce the Check Credit requirement (do not generate check constraints):
-    1. Customer.Balance <= CreditLimit
-    2. Customer.Balance = Sum(Order.AmountTotal where date shipped is null)
-    3. Order.AmountTotal = Sum(Items.Amount)
-    4. Items.Amount = Quantity * UnitPrice
-    5. Store the Items.UnitPrice as a copy from Product.UnitPrice
     '''
 
-    from logic_bank.logic_bank import Rule
+    if os.environ.get("WG_PROJECT"):
+        # Inside WG: Load rules from docs/expprt/export.json
+        load_verify_rules()
+    else:
+        # Outside WG: load declare_logic function
+        from logic.logic_discovery.auto_discovery import discover_logic
+        discover_logic()
 
-    from logic.logic_discovery.auto_discovery import discover_logic
-    discover_logic()
+    # Logic from GenAI: (or, use your IDE w/ code completion)
+    from database.models import Product, Customer, Item, Order
 
-    # Logic from GenAI: (or, use your IDE w/ code completion)n
-    Rule.sum(derive=Customer.Balance, as_sum_of=Order.AmountTotal, where=lambda row: row.ShipDate is None)
-    Rule.sum(derive=Order.AmountTotal, as_sum_of=Item.Amount)
-    # Rule.formula(derive=Item.amount, as_expression=lambda row: row.quantity * row.unit_price)
-    Rule.copy(derive=Item.UnitPrice, from_parent=Product.UnitPrice)
+    # Ensure that Customer balance does not exceed credit_limit.
     Rule.constraint(validate=Customer,
-                    as_condition=lambda row: row.Balance <= row.CreditLimit,
-                    error_msg="Customer balance ({row.Balance}) exceeds credit limit ({row.CreditLimit})")
+                as_condition=lambda row: row.balance <= row.credit_limit,
+                error_msg="Customer balance ({row.balance}) exceeds credit limit ({row.credit_limit})")
 
-    # End Logic from GenAI
+    # Customer.balance is the sum of Order.amount_total for orders not yet shipped.
+    Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, where=lambda row: row.date_shipped is None)
+
+    # Order.amount_total is the sum of Item.amount.
+    Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)
 
-    def derive_amount(row: Item, old_row: Item, logic_row: LogicRow):
+    def derive_amount(row: models.Item, old_row: models.Item, logic_row: LogicRow):
         amount = row.Quantity * row.UnitPrice
         if row.Product.CarbonNeutral == True and row.Quantity >= 10:
            amount = amount * Decimal(0.9)  # breakpoint here
         return amount
 
-    # 4. Items.Amount = Quantity * UnitPrice
-    Rule.formula(derive=Item.Amount, calling=derive_amount)
+    # Items.Amount = Quantity * UnitPrice with discount for CarbonNeutral products.
+    Rule.formula(derive=models.Item.Amount, 
+                 calling=derive_amount)
 
-    #als: Demonstrate that logic == Rules + Python (for extensibility)
+    # Item.unit_price is copied from Product.unit_price.
+    Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)
 
-    def send_order_to_shipping(row: Order, old_row: Order, logic_row: LogicRow):
-        """ #als: Send Kafka message formatted by OrderShipping RowDictMapper
-
-        Format row per shipping requirements, and send (e.g., a message)
-
-        NB: the after_flush event makes Order.Id avaible.  Contrast to congratulate_sales_rep().
-
-        Args:
-            row (Order): inserted Order
-            old_row (Order): n/a
-            logic_row (LogicRow): bundles curr/old row, with ins/upd/dlt logic
-        """
-        if logic_row.is_inserted():
-            kafka_producer.send_kafka_message(logic_row=logic_row,
-                                              row_dict_mapper=OrderShipping,
-                                              kafka_topic="order_shipping",
-                                              kafka_key=str(row.OrderID),
-                                              msg="Sending Order to Shipping")
-            
-    Rule.after_flush_row_event(on_class=Order, calling=send_order_to_shipping)  # see above
+    # Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None.
+    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'})
 
+    # End Logic from GenAI
 
 
-    def handle_all(logic_row: LogicRow):  # OPTIMISTIC LOCKING, [TIME / DATE STAMPING]
+    def handle_all(logic_row: LogicRow):  # #als: TIME / DATE STAMPING, OPTIMISTIC LOCKING
         """
         This is generic - executed for all classes.
 
-        Invokes optimistic locking.
+        Invokes optimistic locking, and checks Grant permissions.
 
-        You can optionally do time and date stamping here, as shown below.
+        Also provides user/date stamping.
 
         Args:
             logic_row (LogicRow): from LogicBank - old/new row, state
         """
 
-        if not os.getenv("APILOGICPROJECT_NO_FLASK") is not None:
+        if os.getenv("APILOGICPROJECT_NO_FLASK") is not None:
+            print("\ndeclare_logic.py Using TestBase\n")
             return  # enables rules to be used outside of Flask, e.g., test data loading
 
         if logic_row.is_updated() and logic_row.old_row is not None and logic_row.nest_level == 0:
             opt_locking.opt_lock_patch(logic_row=logic_row)
-        enable_creation_stamping = False  # CreatedOn time stamping
-        if enable_creation_stamping:
+
+        Grant.process_updates(logic_row=logic_row)
+
+        did_stamping = False
+        if enable_stamping := False:  # #als:  DATE / USER STAMPING
             row = logic_row.row
             if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedOn"):
                 row.CreatedOn = datetime.datetime.now()
-                logic_row.log("early_row_event_all_classes - handle_all sets 'Created_on"'')
-            Grant.process_updates(logic_row=logic_row)
-
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedBy"):
+                row.CreatedBy = Security.current_user().id
+                #    if Config.SECURITY_ENABLED == True else 'public'
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "upd" and hasattr(row, "UpdatedOn"):
+                row.UpdatedOn = datetime.datetime.now()
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "upd" and hasattr(row, "UpdatedBy"):
+                row.UpdatedBy = Security.current_user().id  \
+                    if Config.SECURITY_ENABLED == True else 'public'
+                did_stamping = True
+            if did_stamping:
+                logic_row.log("early_row_event_all_classes - handle_all did stamping")     
     Rule.early_row_event_all_classes(early_row_event_all_classes=handle_all)
 
     #als rules report