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

api_logic_server_cli/genai/genai.py

@@ -27,6 +27,7 @@ from api_logic_server_cli.genai.genai_svcs import K_LogicBankOff
 from api_logic_server_cli.genai.genai_svcs import K_LogicBankTraining
 from api_logic_server_cli.genai.genai_svcs import fix_and_write_model_file as fix_and_write_model_file_svcs
 import api_logic_server_cli.genai.genai_svcs as genai_svcs
+from api_logic_server_cli.genai.genai_graphics import GenAIGraphics
 
 log = logging.getLogger(__name__)
 
@@ -575,7 +576,7 @@ class GenAI(object):
         except:  # intentional try/catch/bury - it's just docs, so don't fail
             import traceback
             log.error(f"\n\nERROR creating genai project docs: {docs_dir}\n\n{traceback.format_exc()}")
-        pass
+        genai_graphics = GenAIGraphics(project=self.project, using=None, genai_version=self.project.genai_version)
 
     def save_prompt_messages_to_system_genai_temp_project(self):
         """

api_logic_server_cli/genai/genai_graphics.py

@@ -0,0 +1,165 @@
+import shutil
+from typing import Dict, List
+from api_logic_server_cli.cli_args_project import Project
+import logging
+from pathlib import Path
+import importlib
+from api_logic_server_cli.genai.genai_utils import call_chatgpt
+import requests
+import os
+import datetime
+import create_from_model.api_logic_server_utils as utils
+import time
+from openai import OpenAI
+from api_logic_server_cli.genai.genai_svcs import WGResult
+from api_logic_server_cli.genai.genai_svcs import Rule
+import api_logic_server_cli.genai.genai_svcs as genai_svcs
+import json
+from typing import List, Dict
+from pydantic import BaseModel
+from dotmap import DotMap
+from natsort import natsorted
+import glob
+import create_from_model.api_logic_server_utils as create_utils
+from jinja2 import Environment, FileSystemLoader
+
+
+K_data_model_prompt = "Use SQLAlchemy to create"
+
+log = logging.getLogger(__name__)
+
+class GenAIGraphics(object):
+    """ 
+    Adds Graphics to **existing** projects (genai project or als project):
+    * adds `api/api_discovery` file(s) to project
+    * adds html to `home.js` (?  currently just creating a 1-off in api/api_discovery)
+
+    Invoked from:
+    1. **New GenAI Project:** for newly created project (e,g, mgr system/genai/examples/genai_demo/genai_demo.prompt)
+        * `--using` is None ==> Docs folder already has WGResponse.graphics[]      
+    2. **Existing Project:** CLI/genai-graphics existing project, using *docs/graphics* eg 
+        * `--using`  ==> Call ChatGPT for WGResponse.graphics `<project>/docs/graphics/*.prompt`  
+        * note: dbml not rebuilt after rebuild-from-db
+    3. **Existing WG Project:** in-place (do not create new project with new test data)
+        *  Same as #1, but requires WG UI change ('in place', 'graphics' button, ...) to use genai_graphics cmd
+
+
+    **Issue:** what is the persistence model for graphics?  (eg, in docs/graphics, or docs/response.json, wg database??)
+    * if existing wg project, is docs/response.json updated?
+
+    Open Issues
+    * How to integrate with als/wg home.js?
+    * How to enforce licensing?
+    * How to choose graph vs chart?
+    
+    """
+
+    def __init__(self, project: Project, using: str, genai_version: str):
+        """ 
+        Add graphics to existing projects - [see docs](https://apilogicserver.github.io/Docs/WebGenAI-CLI/#add-graphics-to-existing-projects)
+
+        see key_module_map() for key methods
+
+        """        
+
+        self.project = project        
+        self.project.genai_using = using
+        self.manager_path = genai_svcs.get_manager_path()
+
+        if using is None:           # New GenAI Project: use docs/response.json
+            graphics_response_path = self.project.project_directory_path.joinpath('docs/response.json')
+        else:                       # Existing (any) Project - use graphics files  -> ChatGPT
+            graphics_response_path = self.project.project_directory_path.joinpath('docs/graphics/response.json')
+            if bypass_for_debug := False:
+                pass
+            else:
+                prompt = genai_svcs.read_and_expand_prompt(self.manager_path.joinpath('system/genai/prompt_inserts/graphics_request.prompt'))
+                prompt_lines = prompt.split('\n')                   # ChatGPT instructions
+                prompt_lines.extend(self.append_data_model())       # add data model
+                prompt_lines.extend(self.append_graphics_files())   # and the users's requests from graphics files
+                prompt_str = "\n".join(prompt_lines)
+                
+                prompt_messages : List[ Dict[str, str] ] = []  # prompt/response conversation to be sent to ChatGPT
+                prompt = genai_svcs.get_prompt_you_are()
+                prompt["content"] = prompt_str
+                prompt_messages.append( prompt )
+                genai_svcs.call_chatgpt(messages = prompt_messages, 
+                                        using = self.project.project_directory_path.joinpath('docs/graphics'),
+                                        api_version=genai_version)
+
+        self.process_graphics_response(graphics_response_path)
+        pass
+
+    def process_graphics_response(self, graphics_response_path: Path):
+        """ Process graphics response from ChatGPT graphics_response_path """
+
+        graphic_services_header_path = self.manager_path.joinpath('system/genai/graphics_templates/graphics_services.py')
+        graphics_services_path = self.project.project_directory_path.joinpath('api/api_discovery/graphics_services.py')
+        shutil.copy(graphic_services_header_path, graphics_services_path)
+
+        # open and read the graphics_response_path json file
+        assert graphics_response_path.exists(), f'Graphics response file not found: {graphics_response_path}'
+        with open(graphics_response_path, 'r') as file:
+            graphics_response = json.load(file)
+            log.info(f'Graphics response loaded from {graphics_response_path}')
+        graphics = graphics_response['graphics']
+        for each_graphic in graphics:  # add each service to api/api_discovery
+            self.fix_sqlalchemy_query(each_graphic)
+            env = Environment(loader=FileSystemLoader(self.manager_path.joinpath('system/genai/graphics_templates')))
+
+            template = env.get_template('service_template_jsonapi_rpc.jinja')
+            rendered_result = template.render( **each_graphic )
+            with open(self.project.project_directory_path.joinpath(f'api/api_discovery/graphics_services.py'), 'a') as out_file:
+                out_file.write(rendered_result)
+
+            template = env.get_template('html_template.jinja')
+            rendered_result = template.render( **each_graphic )
+            with open(self.project.project_directory_path.joinpath(f'api/api_discovery/{each_graphic['name']}.html'), 'w') as out_file:
+                out_file.write(rendered_result)
+
+            with open(self.project.project_directory_path.joinpath(f'api/api_discovery/{each_graphic['name']}.sql'), 'w') as out_file:
+                out_file.write(each_graphic['sql_query'])
+
+            log.info(f'.. added service: {each_graphic['name']} to api_discovery')
+        pass
+
+    def fix_sqlalchemy_query(self, graphic: Dict):
+        """ Fix the SQLAlchemy query for the graphic """
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace('\\n', '\n')
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace('\"', '"')
+        pass
+
+
+    def append_data_model(self) -> List[str]:
+        """ Get the data model
+
+        Returns:
+            list: logic_files
+        """
+
+        data_model_lines = []
+        data_model_path = self.project.project_directory_path.joinpath('database/models.py')
+        assert data_model_path.exists(), f"Data model file not found: {data_model_path}"
+        with open(data_model_path, 'r') as file:
+            prompt_lines = file.readlines()
+        data_model_lines.extend(prompt_lines)
+        return data_model_lines
+    
+    def append_graphics_files(self) -> List[str]:
+        """ Get graphics files (typically from project)
+
+        Returns:
+            list: logic_files
+        """
+
+        graphics_lines = []
+        if Path(self.project.genai_using).is_dir():  # conversation from directory
+            for each_file in sorted(Path(self.project.genai_using).iterdir()):
+                if each_file.is_file() and each_file.suffix == '.prompt':
+                    # read lines from each_file, and append to prompt
+                    with open(each_file, 'r') as file:
+                        prompt_lines = file.readlines()
+                    graphics_lines.extend(prompt_lines)
+        return graphics_lines
+
+ 

api_logic_server_cli/genai/genai_logic_builder.py

@@ -27,7 +27,7 @@ log = logging.getLogger(__name__)
 
 class GenAILogic(object):
     """ 
-        Called by cli for *existing* project 
+        Called by cli for *existing* project (must be wg project with docs models)
         
         * **Create logic** from *logic files* eg `<project>/docs/logic/check_credit.prompt`
 
@@ -74,23 +74,7 @@ class GenAILogic(object):
         if suggest:
             self.suggest_logic()                  # suggest logic for prompt, or see logic code
         else:
-            logic_files = self.get_logic_files()  # rebuild rules from docs/logic/*.prompt
-            for each_file in logic_files:
-                with open(each_file, 'r') as file:
-                    log.debug(f'.. genai_logic_builder processes: {os.path.basename(each_file)}')
-                    logic = file.read()
-                logic_message = {"role": "user", "content": logic}
-                self.messages.append( logic_message ) # replace data model with logic
-                log.debug(f'.. ChatGPT - saving raw response to: system/genai/temp/chatgpt_original.response')
-                response_str = genai_svcs.call_chatgpt(messages=self.messages, api_version=self.project.genai_version, using=self.project.genai_using)
-                response = json.loads(response_str)
-                # FIXME - perhaps required for fixup (it is failing)
-                # the rules & data models are expected to be in docs... not there
-                # self.get_and_save_response_data(response=response, file=each_file)          # save raw response to docs/logic
-                self.response_dict = DotMap(response)
-                rule_list = self.response_dict.rules
-                each_code_file = self.project.project_directory_path.joinpath(f'logic/logic_discovery/{each_file.stem}.py')
-                self.insert_logic_into_project(rule_list=rule_list, file=each_code_file)     # insert logic into project
+            self.process_logic_files()            # process logic files (eg, from docs/logic/*.prompt)
         pass
 
     def get_logic_files(self) -> List[str]:
@@ -129,7 +113,7 @@ class GenAILogic(object):
         return learning_requests  # TODO - what if no learning requests?
     
     def get_learnings_and_data_model(self) -> List[Dict[str, str]]:
-        """ Get prompts from the docs dir (so GPT knows model, learnings)
+        """ Get prompts from the docs dir (so GPT knows model, learnings) -- **not** from database/models.py
 
         Most often, adding logic to new project, which looks like:
 
@@ -186,7 +170,63 @@ class GenAILogic(object):
         prompt_messages.extend(learnings)
                         
         return prompt_messages      
-    
+
+
+    def process_logic_files(self):
+        """
+        Processes logic files by reading them, sending their content to a generative AI service, 
+        and then inserting the generated logic into the project.
+
+        Process each docs/logic/*.prompt file to create corresponding file in logic/logic_discovery
+
+        """
+        """ CoPilot's doc (meh)
+
+        Steps:
+        1. Retrieve logic files from the specified directory.
+        2. For each logic file:
+            a. Read the file content.
+            b. Log the processing of the file.
+            c. Create a message with the file content.
+            d. Append the message to the list of messages.
+            e. Call the generative AI service with the messages.
+            f. Parse the response from the AI service.
+            g. Insert the generated logic into the project.
+            h. Reset the messages for the next file.
+        3. Log the completion of the process and provide instructions for checking and renaming files.
+
+        Note:
+        - The method assumes the existence of several helper methods and attributes such as 
+          `get_logic_files`, `genai_svcs.call_chatgpt`, `get_and_save_response_data`, 
+          `insert_logic_into_project`, and `get_learnings_and_data_model`.
+        - There are some FIXME comments indicating areas that may need further attention or fixing.
+        """
+
+        logic_files = self.get_logic_files()  # rebuild rules from docs/logic/*.prompt
+        for each_file in logic_files:
+            with open(each_file, 'r') as file:
+                log.debug(f'\n.. genai_logic_builder/process_logic_files - logic file: {os.path.basename(each_file)}')
+                logic = file.read()
+            logic_message = {"role": "user", "content": logic}
+            self.messages.append( logic_message ) # replace data model with logic
+            log.debug(f'.. ChatGPT - saving raw response to: system/genai/temp/chatgpt_original.response')
+            response_str = genai_svcs.call_chatgpt(messages=self.messages, api_version=self.project.genai_version, using=self.project.genai_using)
+            response = json.loads(response_str)
+            # see launch: GenAI - include Multiple Docs/Logic Files
+            # FIXME - perhaps required for fixup (it is failing)
+            # the rules & data models are expected to be in docs... not there for als projects?
+            # self.get_and_save_response_data(response=response, file=each_file)
+            # save raw response to docs/logic
+            self.response_dict = DotMap(response)
+            rule_list = self.response_dict.rules
+            each_code_file = self.project.project_directory_path.joinpath(f'logic/logic_discovery/{each_file.stem}.py')
+            self.insert_logic_into_project(rule_list=rule_list, file=each_code_file)     # insert logic into project
+            self.messages = self.get_learnings_and_data_model()  # reset messages for next file
+            self.messages_length = len(self.messages)
+        log.info(f'\n.. Completed -- check logic/logic_discovery for new logic files, rename docs/logic files')
+
+
+
     def suggest_logic(self):
         """ Suggest logic for prompt, or translate suggestion to code
             self.messages already has learnings and data model
@@ -411,16 +451,35 @@ class GenAILogic(object):
         """
         result_path = Path(os.getcwd())
         check_system_genai = result_path.joinpath('system/genai')
+        if check_system_genai.exists():
+            return result_path
+        
+        result_path = result_path.parent
+        check_system_genai = result_path.joinpath('system/genai')
+        if check_system_genai.exists():
+            return result_path
         
+        result_path = result_path.parent
+        check_system_genai = result_path.joinpath('system/genai')
         if check_system_genai.exists():
             return result_path
         
         result_path = result_path.parent
         check_system_genai = result_path.joinpath('system/genai')
+        if check_system_genai.exists():
+            return result_path
         
+        
+        result_path = result_path.parent
+        check_system_genai = result_path.joinpath('system/genai')
         if check_system_genai.exists():
             return result_path
         
+        result_path = result_path.parent
+        check_system_genai = result_path.joinpath('system/genai')
+        if check_system_genai.exists():
+            return result_path
+
         result_path = result_path.parent
         check_system_genai = result_path.joinpath('system/genai')
         

api_logic_server_cli/genai/genai_svcs.py

@@ -42,6 +42,13 @@ class Model(BaseModel):
     description: str
     name: str
 
+class Graph(BaseModel):
+    sqlalchemy_query: str  # sqlalchemy group by result = { "result": [ ("name", "value)  ] }
+    sql_query: str  # sql query using group by, returns result = { "result": [ ("name", "value")  ] }
+    classes_used: str # comma-delimited list of classes used in sqlalchemy_query
+    name: str  # suggested Python name for sqlalchemy_query
+    html_code: str # create a java script app to show a bar chart from sqlalchemy_query result
+
 class TestDataRow(BaseModel):
     test_data_row_variable: str  # the Python test data row variable
     code: str  # Python code to create a test data row instance
@@ -50,6 +57,7 @@ class WGResult(BaseModel):  # must match system/genai/prompt_inserts/response_fo
     # response: str # result
     models : List[Model] # list of sqlalchemy classes in the response
     rules : List[Rule] # list rule declarations
+    graphics: List[Graph] # list of graphs
     test_data: str
     test_data_rows: List[TestDataRow]  # list of test data rows
     test_data_sqlite: str # test data as sqlite INSERT statements
@@ -141,9 +149,13 @@ def get_code_update_logic_file(rule_list: List[DotMap], logic_file_path: Path =
         insert_logic += translated_logic
         insert_logic += "\n    # End Logic from GenAI\n\n"
 
+        insert_point = 'discover_logic()'  # default for als`
+        if utils.does_file_contain(in_file=logic_file_path, search_for='# Logic from GenAI'):
+            insert_point = '# Logic from GenAI'
+
         utils.insert_lines_at(lines=insert_logic, 
                             file_name=logic_file_path, 
-                            at='discover_logic()', 
+                            at=insert_point, 
                             after=True)
         
         if 'Rule' not in imports:

api_logic_server_cli/prototypes/base/config/config.py

@@ -116,15 +116,16 @@ class Config:
     # als add-auth --provider-type=sql --db-url=
     # als add-auth --provider-type=keycloak --db-url=localhost
     # als add-auth --provider-type=keycloak --db-url=http://10.0.0.77:8080
-    kc_base = 'http://localhost:8080'  # e.g., 'http://localhost:8080'
+    kc_base = os.getenv('KEYCLOAK_BASE','https://localhost:8080')
+    #kc_base = 'http://localhost:8080'
     ''' keycloak location '''
-    KEYCLOAK_REALM =  'kcals'
-    KEYCLOAK_BASE = f'{kc_base}/realms/{KEYCLOAK_REALM}'
-    KEYCLOAK_BASE_URL = f'{kc_base}'
-    KEYCLOAK_CLIENT_ID = 'alsclient'
+    KEYCLOAK_REALM =  os.getenv('KEYCLOAK_REALM','kcals')
+    KEYCLOAK_BASE = os.getenv('KEYCLOAK_BASE',f'{kc_base}')
+    KEYCLOAK_BASE_URL = os.getenv('KEYCLOAK_BASE_URL',f'{kc_base}/realms/{KEYCLOAK_REALM}')
+    KEYCLOAK_CLIENT_ID = os.getenv('KEYCLOAK_CLIENT_ID','alsclient')
     ''' keycloak client id '''
 
-    SECURITY_ENABLED = False  # disables security (regardless of SECURITY_PROVIDER)
+    SECURITY_ENABLED = os.getenv("SECURITY_ENABLED",False)
     SECURITY_PROVIDER = None
     if os.getenv('SECURITY_ENABLED'):  # e.g. export SECURITY_ENABLED=true
         security_export = os.getenv('SECURITY_ENABLED')  # type: ignore # type: str
@@ -141,6 +142,8 @@ class Config:
         app_logger.debug(f'config.py - security enabled')
     else:
         app_logger.info(f'config.py - security disabled')
+	
+    app_logger.info(f'SECURITY_PROVIDER={SECURITY_PROVIDER}')
 
     # Begin Multi-Database URLs (from ApiLogicServer add-db...)
     auth_db_path = str(project_path.joinpath('database/authentication_db.sqlite'))
@@ -164,11 +167,22 @@ class Config:
     SQLALCHEMY_TRACK_MODIFICATIONS = False
     PROPAGATE_EXCEPTIONS = False
 
-    KAFKA_PRODUCER = '{"bootstrap.servers": "localhost:9092"}'  #  , "client.id": "aaa.b.c.d"}'
-    KAFKA_PRODUCER = None  # comment out to enable Kafka producer
-    KAFKA_CONSUMER = '{"bootstrap.servers": "localhost:9092", "group.id": "als-default-group1"}'
-    KAFKA_CONSUMER = None  # comment out to enable Kafka consumer
-
+    KAFKA_PRODUCER = None
+    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:
+        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"})
+    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}')
     # 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"
@@ -245,6 +259,7 @@ class Args():
         self.http_scheme = Config.CREATED_HTTP_SCHEME
         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
@@ -463,14 +478,11 @@ class Args():
     @property
     def kafka_producer(self) -> dict:
         """ kafka connect string """
-        if "KAFKA_PRODUCER" in self.flask_app.config:
-            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
+        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
         return None
     
     @kafka_producer.setter
@@ -480,23 +492,30 @@ class Args():
     @property
     def kafka_consumer(self) -> dict:
         """ kafka enable consumer """
-        if "KAFKA_CONSUMER" in self.flask_app.config:
-            if self.flask_app.config["KAFKA_CONSUMER"] is not None:
-                return json.loads(self.flask_app.config["KAFKA_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):
+                value = json.loads(self.flask_app.config["KAFKA_CONSUMER"])
+            return value
         return None
     
     @kafka_consumer.setter
     def kafka_consumer(self, a: str):
         self.flask_app.config["KAFKA_CONSUMER"] = 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'\
-               f'.. client_uri: {self.client_uri}, \n'\
-               f'.. http_scheme: {self.http_scheme}, api_prefix: {self.api_prefix}, \n'\
-               f'.. | verbose: {self.verbose}, create_and_run: {self.create_and_run}'
-        return rtn
-
+	
+    @property
+    def kafka_consumer_group(self) -> dict:
+        """ kafka enable consumer group """
+        if "KAFKA_CONSUMER_GROUP" in self.flask_app.config:
+            if self.flask_app.config["KAFKA_CONSUMER_GROUP"] is not None:
+                return self.flask_app.config["KAFKA_CONSUMER_GROUP"]
+        return None
+    
+    @kafka_consumer_group.setter
+    def kafka_consumer_group(self, a: str):
+        self.flask_app.config["KAFKA_CONSUMER_GROUP"] = a
+		
     @property
     def n8n_producer(self) -> dict:
         """ n8n connect string """
@@ -515,6 +534,15 @@ class Args():
         self.flask_app.config["N8N_PRODUCER"] = 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'\
+            f'.. client_uri: {self.client_uri}, \n'\
+            f'.. http_scheme: {self.http_scheme}, api_prefix: {self.api_prefix}, \n'\
+            f'.. | verbose: {self.verbose}, create_and_run: {self.create_and_run}'
+        return rtn
+
+
     def get_cli_args(self, args: 'Args', dunder_name: str):
         """
         returns tuple of start args:

api_logic_server_cli/prototypes/base/config/default.env

@@ -1,5 +1,7 @@
 SECRET_KEY = "whatnothow"
 SQLALCHEMY_TRACK_MODIFICATIONS = False
 SQLAlCHEMY_ECHO = False
+# AGGREGATE_DEFAULTS =  True
+# ALL_DEFAULTS = True
 # APILOGICPROJECT_KAFKA_PRODUCER = "{\"bootstrap.servers\": \"localhost:9092\"}"
 # SQLALCHEMY_DATABASE_URI=db.sqlite

api_logic_server_cli/prototypes/base/docs/graphics/readme.md

@@ -0,0 +1,12 @@
+### Add Natural Language Logic to Your Project
+
+You can add Natural Language logic files to this directory, e.g.: 
+
+* `.sales_by_category.prompt`: Graph Sales by Category
+
+Then, use GenAI to create executable logic in your `api/api_discovery` directory, e.g.,
+
+```bash
+als genai-graphics
+```
+1. Consider renaming your graphics files afterward (`valid_names.z-prompt`)so they are skipped on future runs

api_logic_server_cli/prototypes/base/security/authentication_provider/keycloak/auth_provider.py

@@ -78,7 +78,7 @@ class Authentication_Provider(Abstract_Authentication_Provider):
         from flask import jsonify, request
         from config.config import Args  # circular import error if at top
         
-        jwks_uri = Args.instance.keycloak_base + '/protocol/openid-connect/certs'
+        jwks_uri = Args.instance.keycloak_base_url + '/protocol/openid-connect/certs'
         for i in range(100):
             # we retry a couple of times in case there are connection problems
             try:

api_logic_server_cli/prototypes/base/security/declare_security.py

@@ -34,6 +34,8 @@ class Roles():
     admin = "CS_ADMIN"
     public="public"             # p1/p (no roles, but gets public)
     sa="sa"
+    default_roles_kcals = "default-roles-kcals"
+    uma_authorization = "uma_authorization"
     
 DefaultRolePermission(to_role=Roles.sa, can_read=True, can_update=True, can_insert=True, can_delete=True)
 DefaultRolePermission(to_role=Roles.tenant, can_read=True, can_delete=True)
@@ -43,3 +45,5 @@ DefaultRolePermission(to_role=Roles.teller, can_read=True, can_insert=True,can_u
 DefaultRolePermission(to_role=Roles.customer, can_read=True, can_insert=True,can_update=True, can_delete=False)
 DefaultRolePermission(to_role=Roles.read_only, can_read=True, can_insert=False,can_update=False, can_delete=False)
 DefaultRolePermission(to_role=Roles.public, can_read=True, can_insert=False,can_update=False, can_delete=False)
+DefaultRolePermission(to_role=Roles.default_roles_kcals, can_read=True, can_insert=True,can_update=True, can_delete=False)
+DefaultRolePermission(to_role=Roles.uma_authorization, can_read=True, can_insert=True,can_update=True, can_delete=False)

api_logic_server_cli/prototypes/base/ui/admin/admin_loader.py

@@ -140,7 +140,7 @@ def admin_events(flask_app: Flask, args: Args, validation_error: ValidationError
                 if "keycloak" in provider_name:
                     s = (f'\n'
                         f'  keycloak:\n'
-                        f'    url: {args.keycloak_base_url}\n'
+                        f'    url: {args.keycloak_base}\n'
                         f'    realm: {args.keycloak_realm}\n'
                         f'    clientId: {args.keycloak_client_id}\n'
                     )   
@@ -148,6 +148,8 @@ def admin_events(flask_app: Flask, args: Args, validation_error: ValidationError
                 elif "sql" in provider_name:
                     sql_auth_config = f'\n  endpoint: {args.http_scheme}://{args.swagger_host}:{args.swagger_port}/{args.api_prefix[1:]}/auth/login\n'
                     content = content.replace("'{system-default}'", sql_auth_config)
+                elif getattr(Config.SECURITY_PROVIDER, 'auth_config', None):
+                    content = content.replace("'{system-default}'", Config.SECURITY_PROVIDER.auth_config)
                 else:
                     sys.exit(f"ERROR[admin_loader]: unknown security type: {Config.SECURITY_PROVIDER}")         
 

api_logic_server_cli/prototypes/manager/.vscode/ApiLogicServer.code-workspace

@@ -9,7 +9,7 @@
 		"workbench.editorAssociations": {
 			"*.md": "vscode.markdown.preview.editor"
 		},
-		"workbench.colorTheme": "Office Theme (Publisher)",
-		"workbench.preferredLightColorTheme": "Office Theme (Publisher)"
+		"workbench.colorTheme": "Office Theme (Word)",
+		"workbench.preferredLightColorTheme": "Office Theme (Word)"
 	}
 }

api_logic_server_cli/prototypes/manager/README.md

@@ -98,7 +98,7 @@ Then, try your own databases [(db-url examples here)](https://apilogicserver.git
 
 <br>You can do this with or without signup:
 
-1. If you have signed up, this will create and open a project called `genai_demo` from `genai_demo.prompt` (available in left Explorer pane):
+1. If you have signed up (see *To obtain a ChatGPT API Key*, below), this will create and open a project called `genai_demo` from `genai_demo.prompt` (available in left Explorer pane):
 
 ```bash
 als genai --using=system/genai/examples/genai_demo/genai_demo.prompt --project-name=genai_demo
@@ -122,6 +122,20 @@ Verify it's operating properly:
 
 </br>
 
+
+<details markdown>
+
+<summary> To obtain a ChatGPT API Key</summary>
+
+<br>GenAI-Logic uses OpenAI, which requires an Open API Key:
+
+1. Obtain one from [here](https://platform.openai.com/account/api-keys) or [here](https://platform.openai.com/api-keys)
+2. Authorize payments [here](https://platform.openai.com/settings/organization/billing/overview)
+
+</details>
+
+</br>
+
 <details markdown>
 
 <summary> What Just Happened? &nbsp;&nbsp;&nbsp;Next Steps...</summary>
@@ -544,6 +558,21 @@ ApiLogicServer create --project-name=samples/nw_sample_nocust --db-url=nw
 
 &nbsp;
 
+## Explore WebGenAI
+
+In addition to the CLI examples above, you can use [WebGenAI](https://apilogicserver.github.io/Docs/WebGenAI/) - a web interface for creating projects from prompts.  You can install WebGenAI on a server, so that created projects are easy to review with colleagues.
+
+To try WebGenAI:
+
+```bash
+cd webgenai
+docker compose up
+```
+
+You will be directed to the registration process.  You will also require a ChatGPT API Key as described above.
+
+&nbsp;
+
 &nbsp;
 
 ## Appendix: Quick Basic Demo