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

api_logic_server_cli/manager.py

@@ -12,7 +12,7 @@ import api_logic_server_cli.api_logic_server as PR
 
 def create_manager(clean: bool, open_with: str, api_logic_server_path: Path, 
                    volume: str = "", open_manager: bool = True, samples: bool = True):
-    """Implements als start to create manager - called from api_logic_server_cli/cli.py
+    """Implements `als start` to create manager - called from api_logic_server_cli/cli.py
 
     create Manager at os.getcwd(), including:
 
@@ -27,11 +27,11 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
         Bit tricky to find find cli in subdirectories of the lib path for manager run launches
 
     Args:
-        clean (bool): _description_
-        open_with (str): _description_
+        clean (bool): Overlay existing manager (projects and web_genai retained)
+        open_with (str): IDE to use
         api_logic_server_path (Path): _description_
         volume (str, optional): _description_. Defaults to "".
-        open_manager (bool, optional): _description_. Defaults to True.
+        open_manager (bool, optional): Whether to open IDE at Manager. Defaults to True.
     """    
     
     log = logging.getLogger(__name__)
@@ -68,8 +68,9 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
             docker_volume = volume + '/'
 
     to_dir = Path(os.getcwd())
+    """ location for creating (cleaning) the Manager """
     path = Path(__file__)
-    from_dir = api_logic_server_path.joinpath('prototypes/manager')
+    from_dir_proto_mgr = api_logic_server_path.joinpath('prototypes/manager')
     to_dir_str = str(to_dir)
     to_dir_check = Path(to_dir).joinpath('venv')
     if not Path(to_dir).joinpath('venv').exists():
@@ -85,12 +86,12 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
     if to_dir_check.exists() and not clean:
         manager_exists = True
         if env_path.exists():
-            log.info(f"    Using manager at: {to_dir}\n\n")
+            log.info(f"    Using existing manager (update .env APILOGICSERVER_AUTO_OPEN, only) at: {to_dir}\n\n")
         else:
             log.info(f"    Refreshing .env in manager at: {to_dir}\n\n")
-            copied_env = shutil.copy(src=from_dir.joinpath('settings.txt'), dst=to_dir.joinpath('.env'))
+            copied_env = shutil.copy(src=from_dir_proto_mgr.joinpath('settings.txt'), dst=to_dir.joinpath('.env'))
             os.remove(to_dir.joinpath('settings.txt'))
-    else:
+    else:   # new Manager, or clean existing manager
         mgr_save_level = log.level
         codegen_logger = logging.getLogger('sqlacodegen_wrapper.sqlacodegen.sqlacodegen.codegen')
         codegen_logger_save_level= codegen_logger.level
@@ -99,8 +100,16 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
         if to_dir_check.exists():
             log.info(f"    Cleaning manager at: {to_dir}\n\n")
 
-        copied_path = shutil.copytree(src=from_dir, dst=to_dir, dirs_exist_ok=True)  # issue: not permitted
-        copied_env = shutil.copy(src=from_dir.joinpath('settings.txt'), dst=to_dir.joinpath('.env'))
+        # create the manager system files and shell scripts (samples created below).
+        copied_path = shutil.copytree(src=from_dir_proto_mgr, dst=to_dir, dirs_exist_ok=True, )  # issue: not permitted
+        copied_env = shutil.copy(src=from_dir_proto_mgr.joinpath('settings.txt'), dst=to_dir.joinpath('.env'))
+        web_genai_docker = to_dir.joinpath('webgenai/docker-compose.yml')
+        if web_genai_docker.exists():
+            log.debug('    .. WebGenAI docker_compose unaltered (license preserved)')
+        else:
+            log.debug('    .. WebGenAI docker_compose created')
+            copied_env = shutil.copy(src=api_logic_server_path.joinpath('fragments/docker-compose.yml'), 
+                                     dst=web_genai_docker)
         os.remove(to_dir.joinpath('settings.txt'))
         log.debug(f"    .. created manager\n")
 
@@ -128,7 +137,7 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
         else:
             if project.is_docker:
                 log.debug(f"    tutorial not created for docker\n\n")
-            else:
+            elif create_manager := False:
                 tutorial_project = PR.ProjectRun(command="tutorial", 
                         project_name='./samples', 
                         db_url="",
@@ -136,7 +145,8 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
                         open_with="NO_AUTO_OPEN"
                         )
                 tutorial_project = tutorial_project.tutorial(msg="Creating:") ##, create='tutorial')
-
+            else:
+                log.debug(f"For Tutorial, use Northwind and basic_demo\n\n")
             samples_project = PR.ProjectRun(command= "create", project_name=f'{docker_volume}samples/nw_sample', db_url='nw+', open_with="NO_AUTO_OPEN")
             log.setLevel(mgr_save_level)
             log.disabled = False  # todo why was it reset?

api_logic_server_cli/prototypes/base/.vscode/launch.json

@@ -22,6 +22,25 @@
             "console": "internalConsole",
             "internalConsoleOptions": "openOnSessionStart"
         },
+        {
+            "name": "ApiLogicServer DEBUG",
+            "type": "debugpy",
+            "cwd": "${workspaceFolder}",
+            "env": {
+                "PYTHONPATH": "", 
+                "EXPERIMENT": "",
+                "PYTHONHASHSEED": "0", 
+                "APILOGICPROJECT_LOGGING_CONFIG": "config/logging.yml",
+                "APILOGICPROJECT_STOP_OK": "True",
+                "APILOGICPROJECT_DEBUG": "False"},
+            "request": "launch",
+            "program": "api_logic_server_run.py",
+            "redirectOutput": true,
+            "justMyCode": false,
+            "args": ["--flask_host=localhost", "--port=5656", "--swagger_port=5656", "--swagger_host=localhost", "--verbose=False"],
+            "console": "internalConsole",
+            "internalConsoleOptions": "openOnSessionStart"
+        },
         {
             "name": "  - API Logic Server - VERBOSE",
             "type": "debugpy",
@@ -76,7 +95,8 @@
             "internalConsoleOptions": "openOnSessionStart"
         },
         {
-            "name": "  - test/basic/server_test.py",
+            "name": "Test - test/basic/server_test.py",
+// use this for test programs, eg to test the server
             "type": "debugpy",
             "request": "launch",
             "cwd": "${workspaceFolder}",
@@ -93,7 +113,7 @@
             "request": "launch",
             "cwd": "${workspaceFolder}/ui/app",
             "runtimeExecutable": "npm",
-            "runtimeArgs": ["install"],
+            "runtimeArgs": ["install --force"],
             "console": "integratedTerminal"
         },
         {

api_logic_server_cli/prototypes/base/api/expose_api_models.py

@@ -4,6 +4,8 @@ import importlib
 import pathlib
 import logging as logging
 import flask_sqlalchemy
+from config.config import Args
+from config import config
 
 # use absolute path import for easier multi-{app,model,db} support
 database = __import__('database')
@@ -40,7 +42,7 @@ def expose_models(api, method_decorators = []):
     """
 
     debug_inspect_list = inspect.getmembers(database.models)
-    pass
+
     # Get all the subclasses of the Base class and expose them in the api
     for name, obj in inspect.getmembers(database.models):
         if inspect.isclass(obj) and issubclass(obj, database.models.SAFRSBaseX) and obj is not database.models.SAFRSBaseX:

api_logic_server_cli/prototypes/base/api_logic_server_run.py

@@ -31,7 +31,7 @@ import os, logging, logging.config, sys, yaml  # failure here means venv probabl
 from flask_sqlalchemy import SQLAlchemy
 import json
 from pathlib import Path
-from config.config import Args
+from config.config import Args  # sets up logging
 from config import server_setup
 
 current_path = os.path.abspath(os.path.dirname(__file__))
@@ -68,8 +68,11 @@ import ui.admin.admin_loader as AdminLoader
 from security.system.authentication import configure_auth
 import oracledb
 
+if os.getenv("EXPERIMENT") == '+':
+    app_logger = logging.getLogger("api_logic_server_app")
+else:
+    app_logger = server_setup.logging_setup()
 
-app_logger = server_setup.logging_setup()
 
 
 # ==================================

api_logic_server_cli/prototypes/base/config/activate_logicbank.py

@@ -40,6 +40,7 @@ def activate_logicbank(session, constraint_handler):
         app_logger.exception(e)
         if not os.environ.get("WG_PROJECT") == "True":
             # Continue if inside WebGenAI
+            # see: https://apilogicserver.github.io/Docs/WebGenAI-CLI/#wg_rules-and-ide-rules
             raise e
     logic_logger.setLevel(logic_logger_level)
     

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,31 +207,35 @@ 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
+    # N8N is a workflow automation tool that allows you to connect different applications and automate tasks between them.
     wh_scheme = "http"
     wh_server = "localhost" # or cloud.n8n.io...
     wh_port = 5678
-    wh_endpoint = "webhook-test"
-    wh_path = "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"
-    token = "YWRtaW46cA=="
-    N8N_PRODUCER = {"authorization": f"Basic {token}", "n8n_url": f'"{wh_scheme}://{wh_server}:{wh_port}/{wh_endpoint}/{wh_path}"'} 
+    wh_endpoint = "webhook-test" # This comes from the WebHook node in n8n
+    wh_path = "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69" # This comes from the WebHook node in n8n
+    wh_token = "YWRtaW46cA==" # This is the base64 encoded string of username:password (e.g. admin:password)
+    N8N_PRODUCER = {"authorization": f"Basic {wh_token}", "n8n_url": f'"{wh_scheme}://{wh_server}:{wh_port}/{wh_endpoint}/{wh_path}"'} 
     # Or enter the n8n_url directly:
-    N8N_PRODUCER = {"authorization": f"Basic {token}","n8n_url":"http://localhost:5678/webhook-test/002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"}  
+    #N8N_PRODUCER = {"authorization": f"Basic {wh_token}","n8n_url":"http://localhost:5678/webhook-test/002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"}  
     N8N_PRODUCER = None # comment out to enable N8N producer
-    # Consumer under consideration
+    # See integration/n8n/n8n_readme.md for more details
+    
 
     OPT_LOCKING = "optional"
     if os.getenv('OPT_LOCKING'):  # e.g. export OPT_LOCKING=required
@@ -260,14 +300,19 @@ class Args():
         self.kafka_producer = Config.KAFKA_PRODUCER
         self.kafka_consumer = Config.KAFKA_CONSUMER
         self.kafka_consumer_group = Config.KAFKA_CONSUMER_GROUP
-        self.n8n_producer = Config.N8N_PRODUCER
         self.keycloak_base = Config.KEYCLOAK_BASE
         self.keycloak_realm = Config.KEYCLOAK_REALM
         self.keycloak_base_url = Config.KEYCLOAK_BASE_URL
         self.keycloak_client_id = Config.KEYCLOAK_CLIENT_ID
         self.backtic_as_quote = Config.BACKTIC_AS_QUOTE
         self.service_type = Config.ONTIMIZE_SERVICE_TYPE
-
+        self.wh_scheme = Config.wh_scheme
+        self.wh_server = Config.wh_server
+        self.wh_port = Config.wh_port
+        self.wh_endpoint = Config.wh_endpoint
+        self.wh_path = Config.wh_path       
+        self.wh_token = Config.wh_token
+        self.n8n_producer = Config.N8N_PRODUCER
         self.verbose = False
         self.create_and_run = False
 
@@ -479,10 +524,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 +542,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
@@ -533,7 +583,56 @@ class Args():
     def n8n_producer(self, a: str):
         self.flask_app.config["N8N_PRODUCER"] = a
 
-
+    # WebHook Args (used by N8N producer - see n8n_producer above)
+    @property
+    def wh_scheme(self) -> str:
+        """ n8n connect string """  
+        return self.flask_app.config["WH_SCHEME"]
+    @wh_scheme.setter           
+    def wh_scheme(self, a: str):
+        self.flask_app.config["WH_SCHEME"] = a
+        
+    @property
+    def wh_server(self) -> str:
+        """ n8n connect string """
+        return self.flask_app.config["WH_SERVER"]
+    @wh_server.setter
+    def wh_server(self, a: str):
+        self.flask_app.config["WH_SERVER"] = a  
+        
+    @property
+    def wh_port(self) -> str:       
+        """ n8n connect string """
+        return self.flask_app.config["WH_PORT"]
+    
+    @wh_port.setter         
+    def wh_port(self, a: str):
+        self.flask_app.config["WH_PORT"] = a
+        
+    @property
+    def wh_endpoint(self) -> str:
+        """ n8n connect string """
+        return self.flask_app.config["WH_ENDPOINT"]
+    @wh_endpoint.setter     
+    def wh_endpoint(self, a: str):
+        self.flask_app.config["WH_ENDPOINT"] = a
+    @property
+    def wh_path(self) -> str:
+        """ n8n connect string """
+        return self.flask_app.config["WH_PATH"] 
+    
+    @wh_path.setter
+    def wh_path(self, a: str):
+        self.flask_app.config["WH_PATH"] = a
+    @property
+    def wh_token(self) -> str:
+        """ n8n connect string """
+        return self.flask_app.config["WH_TOKEN"]
+    @wh_token.setter
+    def wh_token(self, a: str):
+        self.flask_app.config["WH_TOKEN"] = a
+        
+    
     def __str__(self) -> str:
         rtn =  f'.. flask_host: {self.flask_host}, port: {self.port}, \n'\
             f'.. swagger_host: {self.swagger_host}, swagger_port: {self.swagger_port}, \n'\
@@ -652,5 +751,4 @@ class Args():
             args.swagger_port = 443
             args.http_scheme = 'https'
 
-        return
-   
+        return

api_logic_server_cli/prototypes/base/config/default.env

@@ -4,4 +4,10 @@ SQLAlCHEMY_ECHO = False
 # AGGREGATE_DEFAULTS =  True
 # ALL_DEFAULTS = True
 # APILOGICPROJECT_KAFKA_PRODUCER = "{\"bootstrap.servers\": \"localhost:9092\"}"
-# SQLALCHEMY_DATABASE_URI=db.sqlite
+# SQLALCHEMY_DATABASE_URI=db.sqlite
+
+SECURITY_ENABLED = false
+
+# if using tunnel for mcp, function, or ai_plugin
+# eg, https://tunnel_url.ngrok-free.app
+API_LOGIC_SERVER_TUNNEL = "TUNNEL_URL"

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

@@ -1,10 +1,13 @@
+This rebuilds test data into `database/test_data/db.sqlite`, for example as used by genai project creation.
+
 ChatGPT sometimes fails to build proper test data that matches the derivation rules.
 
 You can rebuild the test data, using Logic Bank rules for proper derivations, to rebuild your `database/db.sqlite` (make a copy first to preserve your existing data).
 
-
 ```
 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: