ApiLogicServer 14.3.25__py3-none-any.whl → 14.4.0__py3-none-any.whl

api_logic_server_cli/prototypes/base/config/config.py

@@ -4,11 +4,12 @@ from pathlib import Path
 import os
 import typing
 from dotenv import load_dotenv
-import logging
+import logging, logging.config
 from enum import Enum
 import socket
 import json
 
+
 '''
 #als: configuration settings
 
@@ -57,6 +58,39 @@ def is_docker() -> bool:
     # assert path_result == env_result
     return path_result
 
+
+
+# ==================================
+#       LOGGING SETUP 
+# ================================== 
+
+def logging_setup() -> logging.Logger:
+    """
+    Setup Logging
+    """
+    import yaml
+    global app_logger, debug_value, project_path
+    logging_config = f'{project_path}/config/logging.yml'
+    if os.getenv('APILOGICPROJECT_LOGGING_CONFIG'):
+        logging_config = project_path.joinpath(os.getenv("APILOGICPROJECT_LOGGING_CONFIG"))
+    with open(logging_config,'rt') as f:  # see also logic/declare_logic.py
+            config=yaml.safe_load(f.read())
+            f.close()
+    logging.config.dictConfig(config)  # log levels: notset 0, debug 10, info 20, warn 30, error 40, critical 50
+    app_logger = logging.getLogger("api_logic_server_app")
+    debug_value = os.getenv('APILOGICPROJECT_DEBUG')
+    if debug_value is not None:  # > export APILOGICPROJECT_DEBUG=True
+        debug_value = debug_value.upper()
+        if debug_value.startswith("F") or debug_value.startswith("N"):
+            app_logger.setLevel(logging.INFO)
+        else:
+            app_logger.setLevel(logging.DEBUG)
+            app_logger.debug(f'\nDEBUG level set from env\n')
+    # app_logger.info(f'\nAPI Logic Project Server Setup ({project_name}) Starting with CLI args: \n.. {args}\n')
+    # app_logger.info(f'Created August 03, 2024 09:34:01 at {str(project_path)}\n') 
+    return app_logger  
+
+
 class Config:
     """
     
@@ -67,6 +101,8 @@ class Config:
     Code should therefore access these ONLY as described in Args, below.
     
     """
+    if os.getenv("EXPERIMENT") == '+':
+        logging_setup()  # set up logging as early as possible so capture critical config logging
 
     # Project Creation Defaults (overridden from args, env variables)
     CREATED_API_PREFIX = "/api"
@@ -171,18 +207,20 @@ class Config:
     KAFKA_CONSUMER = None
     KAFKA_CONSUMER_GROUP = None
     KAFKA_SERVER = None
-    #KAFKA_SERVER = os.getenv('KAFKA_SERVER','localhost:9092') # if running locally default
-    if KAFKA_SERVER:
+    KAFKA_SERVER = os.getenv('KAFKA_SERVER', None) # 'localhost:9092' # if running locally default
+    if KAFKA_SERVER is not None and KAFKA_SERVER != "None" and KAFKA_SERVER != "":
         app_logger.info(f'config.py - KAFKA_SERVER: {KAFKA_SERVER}')
         KAFKA_PRODUCER = os.getenv('KAFKA_PRODUCER',{"bootstrap.servers": f"{KAFKA_SERVER}"})  #  , "client.id": "aaa.b.c.d"}'
-        KAFKA_CONSUMER_GROUP = os.getenv('KAFKA_CONSUMER_GROUP','als-default-group1')
-        KAFKA_CONSUMER =  os.getenv('KAFKA_CONSUMER', {"bootstrap.servers": f"{KAFKA_SERVER}", "group.id": f"{KAFKA_CONSUMER_GROUP}", "enable.auto.commit": "false", "auto.offset.reset": "earliest"})
+        KAFKA_CONSUMER_GROUP = os.getenv('KAFKA_CONSUMER_GROUP') #'als-default-group1'
+        if KAFKA_CONSUMER_GROUP is not None: # and KAFKA_CONSUMER_GROUP != "None":
+            KAFKA_CONSUMER =  os.getenv('KAFKA_CONSUMER', {"bootstrap.servers": f"{KAFKA_SERVER}", "group.id": f"{KAFKA_CONSUMER_GROUP}", "enable.auto.commit": "false", "auto.offset.reset": "earliest"})
     else:
         app_logger.info(f'config.py - KAFKA_SERVER: {KAFKA_SERVER} - not set, no kafka producer/consumer')
-    print(f'config.py - KAFKA_PRODUCER: {KAFKA_PRODUCER}')
-    print(f'config.py - KAFKA_CONSUMER: {KAFKA_CONSUMER}')
-    print(f'config.py - KAFKA_CONSUMER_GROUP: {KAFKA_CONSUMER_GROUP}')
-    print(f'config.py - KAFKA_SERVER: {KAFKA_SERVER}')
+    producer_is_empty = "" == KAFKA_PRODUCER
+    app_logger.info(f'config.py - KAFKA_PRODUCER: {KAFKA_PRODUCER} (is_empty={producer_is_empty})')
+    app_logger.info(f'config.py - KAFKA_CONSUMER: {KAFKA_CONSUMER}')
+    app_logger.info(f'config.py - KAFKA_CONSUMER_GROUP: {KAFKA_CONSUMER_GROUP}')
+    app_logger.info(f'config.py - KAFKA_SERVER: {KAFKA_SERVER}')
     # N8N Webhook Args (for testing)
 	# see https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/?utm_source=n8n_app&utm_medium=node_settings_modal-credential_link&utm_campaign=n8n-nodes-base.webhook#path
     wh_scheme = "http"
@@ -479,10 +517,13 @@ class Args():
     def kafka_producer(self) -> dict:
         """ kafka connect string """
         if "KAFKA_PRODUCER" in self.flask_app.config and self.flask_app.config["KAFKA_PRODUCER"] is not None:
-            value = self.flask_app.config["KAFKA_PRODUCER"]
-            if not isinstance(value, dict):
-                value = json.loads(self.flask_app.config["KAFKA_PRODUCER"])
-            return value
+            if self.flask_app.config["KAFKA_PRODUCER"] is not None:
+                value = self.flask_app.config["KAFKA_PRODUCER"]
+                if isinstance(value, dict):
+                    pass  # eg, from VSCode Run Config: "APILOGICPROJECT_KAFKA_PRODUCER": "{\"bootstrap.servers\": \"localhost:9092\"}",
+                else:
+                    value = json.loads(self.flask_app.config["KAFKA_PRODUCER"])
+                return value
         return None
     
     @kafka_producer.setter
@@ -494,7 +535,9 @@ class Args():
         """ kafka enable consumer """
         if "KAFKA_CONSUMER" in self.flask_app.config and self.flask_app.config["KAFKA_CONSUMER"] is not None:
             value = self.flask_app.config["KAFKA_CONSUMER"]
-            if not isinstance(value, dict):
+            if isinstance(value, dict):
+                pass  # eg, from VSCode Run Config: "APILOGICPROJECT_KAFKA_PRODUCER": "{\"bootstrap.servers\": \"localhost:9092\"}",
+            else:
                 value = json.loads(self.flask_app.config["KAFKA_CONSUMER"])
             return value
         return None

api_logic_server_cli/prototypes/base/config/logging.yml

@@ -1,4 +1,5 @@
 version: 1
+# notset 0, debug 10, info 20, warn 30, error 40, critical 50
 
 formatters:
     simple:

api_logic_server_cli/prototypes/base/config/server_setup.py

@@ -9,6 +9,24 @@
 #
 ###############################################################################
 
+"""
+Operation:
+    1. api_logic_server_run.py - imports config
+        1. captures args
+    2. api_logic_server_run.py - imports server_setup
+        1. server_setup#logging_setup()
+    3. api_logic_server_run.py - server_setup.api_logic_server_setup
+On error, NOT CALLED: constraint_handler or ValidationErrorExt (!)
+
++ Operation:
+    1. api_logic_server_run.py - imports config
+        1. captures args
+        1. config#logging_setup()
+    2. api_logic_server_run.py - imports server_setup
+    3. api_logic_server_run.py - server_setup.api_logic_server_setup
+
+"""
+
 start_up_message = "normal start"
 
 import traceback
@@ -25,6 +43,8 @@ except:
 from flask_sqlalchemy import SQLAlchemy
 import json
 from pathlib import Path
+if os.getenv("EXPERIMENT") == '+':
+    import config
 from config.config import Args
 
 
@@ -88,6 +108,9 @@ import integration.kafka.kafka_consumer as kafka_consumer
 import integration.n8n.n8n_producer as n8n_producer
 
 
+if os.getenv("EXPERIMENT") == '+':
+    app_logger = logging.getLogger("api_logic_server_app")
+
 
 class SAFRSAPI(_SAFRSAPI):
     """
@@ -121,7 +144,7 @@ def get_args(flask_app: Flask) -> Args:
 
     import config.config as config
     flask_app.config.from_object(config.Config)
-    app_logger.debug(f"\nserver_setup - get_args: Config args: \n{args}")  # FIXME                  # config file (e.g., db uri's)
+    app_logger.debug(f"\nserver_setup - get_args: Config args: \n{args}")  #                 # config file (e.g., db uri's)
 
     args.get_cli_args(dunder_name=__name__, args=args)
     app_logger.debug(f"\nserver_setup - get_args: CLI args: \n{args}")                       # api_logic_server_run cl args
@@ -351,4 +374,13 @@ def api_logic_server_setup(flask_app: Flask, args: Args):
         db_logger.setLevel(db_log_level)
         authorization_logger.setLevel(authorization_log_level)
 
+        if os.getenv('APILOGICPROJECT_DEBUG'):  # temp debug since logging in config is not happening
+            KAFKA_SERVER = os.getenv('KAFKA_SERVER')
+            is_empty = False
+            if KAFKA_SERVER is not None:
+                is_empty = KAFKA_SERVER == ""
+            is_none = KAFKA_SERVER is None
+            app_logger.debug(f'\nDEBUG KAFKA_SERVER: [{KAFKA_SERVER}] (is_empty: {is_empty}) (is_none: {is_none}) \n')
+            app_logger.debug(f'... Args.instance.kafka_producer: {Args.instance.kafka_producer}\n')
+
 

api_logic_server_cli/prototypes/base/database/test_data/readme.md

@@ -7,4 +7,6 @@ You can rebuild the test data, using Logic Bank rules for proper derivations, to
 als genai-utils --rebuild-test-data 
 ```
 
-You can explore the generated `database/test_data/test_data_code.py` to control test data generation.
+You can explore the generated `database/test_data/test_data_code.py` to control test data generation.
+
+If required, you can copy `database/test_data/test_data_preamble.py` to a new file, to rebuild your database (e.g., from an altered model file), and load your own test data (if any).

api_logic_server_cli/prototypes/base/devops/docker-standard-image/docker-compose-standard-image.yml

@@ -14,8 +14,13 @@ services:
     image: apilogicserver/api_logic_server
     container_name: api_logic_project
     environment:
-      - APILOGICPROJECT_VERBOSE=true
-      - SECURITY_ENABLED=true
+      - APILOGICPROJECT_VERBOSE=false
+      - APILOGICPROJECT_SECURITY_ENABLED=false
+      - APILOGICPROJECT_KEYCLOAK_REALM=kcals
+      # use your IP, below....
+      - APILOGICPROJECT_KEYCLOAK_BASE_URL=http://10.0.0.249:8080/realms/kcals
+      - APILOGICPROJECT_KEYCLOAK_BASE=http://10.0.0.249:8080
+      - APILOGICPROJECT_KEYCLOAK_CLIENT_ID=alsclient
     env_file:
       - ./env.list
     volumes:

api_logic_server_cli/prototypes/base/docs/training/logic_bank_api.prompt

@@ -0,0 +1,314 @@
+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.
+
+
+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):
+
+        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"})
+
+
+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)
+
+logic should create python files in logic/logic_discovery, 
+and cross-check/use attribute names in database/models.py

api_logic_server_cli/prototypes/base/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'")
+

api_logic_server_cli/prototypes/base/integration/kafka/kafka_producer.py

@@ -44,8 +44,12 @@ def kafka_producer():
         if "client.id" not in conf:
             conf["client.id"] = socket.gethostname()
         # conf = {'bootstrap.servers': 'localhost:9092', 'client.id': socket.gethostname()}
-        producer = Producer(conf)
-        logger.debug(f'\nKafka producer connected')
+        try:
+            producer = Producer(conf)
+            logger.debug(f'\nKafka producer connected')
+        except Exception as ke:
+            logger.debug(f'Kafka producer error: {ke}')
+            producer = None
 
 from sqlalchemy.inspection import inspect
 
@@ -64,7 +68,7 @@ def get_primary_key(logic_row: LogicRow):
 
 
 def send_kafka_message(kafka_topic: str, kafka_key: str = None, msg: str="", json_root_name: str = "", 
-                       logic_row: LogicRow = None, row_dict_mapper: RowDictMapper = None, payload: dict = None):
+                        logic_row: LogicRow = None, row_dict_mapper: RowDictMapper = None, payload: dict = None):
     """ Send Kafka message regarding logic_row, mapped by row_dict_mapper
 
     * Typically called from declare_logic event

api_logic_server_cli/prototypes/base/integration/system/FlaskKafka.py

@@ -64,7 +64,11 @@ class FlaskKafka():
         logger.info(f" - FlaskKafka._start: begin polling (v {__version__}), with \n -- conf: {self.conf} \n -- topics: {topics}")
         consumer = Consumer(self.conf)
         consumer.subscribe(topics=list(topics))
-        while True:
+        while True and len(topics) > 0:
+            if self.interrupt_event.is_set():
+                logger.info("Kafka thread interrupted")
+                break
+    
             msg = consumer.poll(1.0)
             logger.debug(f' - KafkaConnect._start - consuming consumer.poll(1.0): {msg}')
             if msg is None: