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

api_logic_server_cli/genai/genai_graphics.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import importlib
 from api_logic_server_cli.genai.genai_utils import call_chatgpt
 import requests
-import os
+import os, time
 import datetime
 import create_from_model.api_logic_server_utils as utils
 import time
@@ -29,49 +29,101 @@ 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)
+    """ 4/3/2025
+    Adds Graphics to projects (genai project or als project):
+    * adds `database/database_discovery` file to project (methods on database.models classes)
+    * adds `api/api_discovery` file to project (dashboard services - calls db methods, above)
+    * adds `docs/graphics` prompt files to **wg** project (graphics prompt files)
 
     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`  
+        * `--using` is None ==> Docs folder already has WGResponse.graphics[]
+        * see api_logic_server_cli/genai/genai_svcs.py#insert_logic_into_created_project      
+    2. **Existing Project:** `als genai-graphics [--using]`  # existing project
+        * `--using`  ==> Call ChatGPT for WGResponse.graphics, default = `<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
 
+    Testing:
+    * BLT to create manager
+    * Test from source: launch.json (in group 3) has `Add Graphics to blt/samples/nw...`
+        * Note: uses `<mgr>/system/genai/graphics_templates`
+        * Don't forget to copy these back to `api_logic_server_cli/prototypes/manager/system/genai/graphics_templates`
+    * Optionally: update `bypass_for_debug` to True to skip ChatGPT call
 
-    **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?
-
+    Persistence model for graphics: docs/response.json (also in docs/graphics/response.json, for als customization)
+    * Requirements:
+        1. Fail-safe: do not let WG projects fail due to graphics - but alert user, just once
+        2. Iterable: do not lose graphics on WG iteration
+    * Running design: 4/12 
+        * Fail-safe: implemented in dashboard_service.py -- for each <graphic.name> query:
+            1. if exists(docs/graphics/<graphics.name>.err), bypass the query
+            2. wrap each dashboard_service query in a try/except block
+            3. if exception, 
+                * return "graphics failed" to iFrame so user can see it
+                * create docs/graphics/<graphics>.err to inhibit future calls
+        * For wg (--using == None):
+            * iterations build on docs/response.json, so graphics are preserved
+                * todo: verify add-rules
+            * this code creates docs/graphics/<graphics.name>.prompt
+                * preserves graphics when opening project in als mode
+            * ALS developers manage their own docs/graphics
+            
     Open Issues
-    * How to integrate with als/wg home.js?
-    * How to enforce licensing?
-    * How to choose graph vs chart?
+    * How to enforce licensing? eg, create stubbed api/api_discovery/dashboard_services.py
+    * How can user delete or alter the graphics?  Activate the Project Summary Graphics button [replace]
+    * Graphics for wg projects (not showing)
+    * No Graphics (just shows {} )
     
     """
 
-    def __init__(self, project: Project, using: str, genai_version: str):
+    def __init__(self, project: Project, using: str, genai_version: str, replace_with: 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
+        Called to inject graphics into existing project, by:
+        1. genai#insert_logic for NEW WG   projects  (--replace_with = '!new-wg', using already-built docs dir)
+        2. cli                for EXISTING projects  (add from docs/graphics, or update per replace_with)    
 
+        Args:
+            project (Project): Project object
+            using (str): path to graphics prompt files (set by genai#insert_logic, or None, for existing project)
+            replace_with (str): (request type): '!using' (default), '!new-wg', '!delete', '!retry`, or '!request'
+            genai_version (str): GenAI version to use
         """        
 
         self.project = project        
-        self.project.genai_using = using
+        self.using = using
         self.manager_path = genai_svcs.get_manager_path()
-
-        if using is None:           # New GenAI Project: use docs/response.json
+        self.start_time = time.time()
+        self.replace_with = replace_with
+        ''' '!using', '!new-wg', '!delete', '!retry`, or '!request Graph Sales... '''
+        graphics_response_path = self.project.project_directory_path.joinpath('docs/graphics/response.json')  # assume existing project
+        if replace_with == '!new-wg':  # if new webgenai, response already prepared here
             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')
+
+        log.info(f"\nGenAIGraphics start...")
+        log.info(f"... args:")
+        log.info(f"..... self.replace_with: {self.replace_with}")
+        log.info(f"..... self.using: {self.using}")
+        log.info(f"..... graphics_response_path: {graphics_response_path}")
+        log.info(f"..... self.project.project_directory_actual: {self.project.project_directory_actual}")
+        log.info(f"..... self.project.project_directory_path: {str(self.project.project_directory_path)}")
+
+        if self.replace_with != '!new-wg' and self.replace_with != '!using' :  # update existing genai project
+            replaced_graphics = self.graphics_replace_with_in_existing_project()
+            if self.replace_with == '!delete':     # we are done (else create docs/graphics prompts for processing below)
+                log.info(f"... update existing genai project - delete graphics")
+                return
+            log.info(f"... update genai existing project - from docs/graphics prompts with {replaced_graphics}")
+
+        if replace_with == '!new-wg':
+            log.info(f"... NEW WG project - already built: docs/002_create_db_models.prompt")
+        else:
+            log.info(f"... EXISTING project - process prompts in docs/graphics")
             if bypass_for_debug := False:
-                pass
+                pass # uses already-built docs/graphics/response.json
             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
@@ -87,74 +139,236 @@ class GenAIGraphics(object):
                                         using = self.project.project_directory_path.joinpath('docs/graphics'),
                                         api_version=genai_version)
 
-        self.process_graphics_response(graphics_response_path)
+        self.create_data_class_methods(graphics_response_path)
+        self.create_graphics_dashboard_service(graphics_response_path)
+        self.create_genai_graphics_prompts(graphics_response_path)
+        log.info(f"\ngenai-graphics completed in [{str(int(time.time() - self.start_time))} secs] \n")
         pass
 
-    def process_graphics_response(self, graphics_response_path: Path):
-        """ Process graphics response from ChatGPT graphics_response_path """
+    def create_data_class_methods(self, graphics_response_path: Path):
+        """ Process graphics response from ChatGPT docs/graphics/response.json
+        * 'graphics' attributes map directly (by name) to <mgr>/system/genai/graphics_templates
+        """
 
-        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)
+        shutil.copy(self.manager_path.joinpath('system/genai/graphics_templates/graphics_services_db.jinja'),
+                    self.project.project_directory_path.joinpath('database/database_discovery/graphics_services.py')) # all the db-class methods are created in this file
 
         # 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}')
+            log.info(f'... create_data_class_methods - 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')
+            template = env.get_template('graphics_services_db_each_method.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:
+            with open(self.project.project_directory_path.joinpath(f'database/database_discovery/graphics_services.py'), 'a') as out_file:
                 out_file.write(rendered_result)
 
+            log.info(f'..... added db class method: {each_graphic['name']} to database_discovery')
+        pass
+
+
+    """ note it needs the /1 - what is that about?
+    curl -X 'GET' \
+    'http://localhost:5656/api/Category/sales_by_category' \
+    -H 'accept: application/vnd.api+json' \
+    -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTc0MzY5MTc3OCwianRpIjoiNDBlYzZkNGMtMzk4My00OGEwLTgxMjQtYzQwY2RmYWFiZWRhIiwidHlwZSI6ImFjY2VzcyIsInN1YiI6InUxIiwibmJmIjoxNzQzNjkxNzc4LCJleHAiOjE3NDM3MDUwOTh9.WLDxdkp3PIsgUqR0t9-ymQDR0eOAECdQsgS_3YTqAQ0'
+    """
+
+    def create_graphics_dashboard_service(self, graphics_response_path: Path):
+        """ Process graphics response from ChatGPT graphics_response_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)
+        if 'graphics' not in graphics_response:
+            log.error(f'No graphics found in {graphics_response_path}')
+            return
+        graphics = graphics_response['graphics']
+    
+        env = Environment(loader=FileSystemLoader(self.manager_path.joinpath('system/genai/graphics_templates')))
+        iframe_templates= []
+        has_iframe = False
+        iframe_links = []
+        dashboards = []
+        cnt = 0
+        template = env.get_template('dashboard_services.jinja')
+        for each_graphic in graphics:  # add each service to api/api_discovery
+            cnt += 1
+            server = '{server}'
+            iframe = f'iframe_{cnt} = iframe_template.format(url=f"{server}chart_graphics/{each_graphic['name']}")\n'
+            iframe_templates.append(iframe)
+            link = "{"+ f'iframe_{cnt}' + "}"
+            iframe_links.append(f'{link}')
+            sqlalchemy_query = each_graphic['class_x_axis']
+
+            # create the dashboard service query (skip if .err file exists, create .err file if query fails)
+            # typical failure: xxx
+            db = f"""
+        previously_failed = Path('docs/graphics/{each_graphic['name']}.err').exists()
+        if previously_failed:
+            pass  # query has previously failed, so skip it
+        else:
+            try:
+                results = models.{sqlalchemy_query}.{each_graphic['name']}(None)
+                color = 'rgba(75, 192, 192, 0.2)'
+                dashboard{cnt} = template.render(result=results, color=color)
+                dashboard_result['{each_graphic['name']}']= dashboard{cnt}
+            except Exception as e:
+                msg = f"GenAI query creation error on models.{sqlalchemy_query}.{each_graphic['name']}: "  + str(e)
+                dashboard_result['{each_graphic['name']}'] = msg
+                app_logger.error(msg)
+                with open('docs/graphics//{each_graphic['name']}.err', 'w') as err_file:
+                    err_file.write(msg)  # this logs the error to prevent future calls
+
+            """
+            dashboards.append(db)
+        
+        rendered_result = template.render(iframe_templates=iframe_templates, iframe_links=" ".join(iframe_links), has_iframe=cnt > 0 , dashboards= dashboards)
+        with open(self.project.project_directory_path.joinpath(f'api/api_discovery/dashboard_services.py'), 'w') as out_file:
+            out_file.write(rendered_result)
+            log.info(f'... create_graphics_dashboard_service - created api/api_discovery/dashboard_services.py')
+            
+        for each_graphic in graphics: 
+            self.fix_sqlalchemy_query(each_graphic)
             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'])
+                sql_query = "System Error: missing sql_query - check WGResult format"
+                if 'sql_query' in each_graphic:
+                    sql_query = each_graphic['sql_query']
+                out_file.write(sql_query)
 
-            log.info(f'.. added service: {each_graphic['name']} to api_discovery')
+            log.info(f'..... added dashboard query: {each_graphic['name']} to api_discovery')
+        
         pass
 
+    def create_genai_graphics_prompts(self, graphics_response_path: Path):
+        """ if genai project, create graphics prompt file: docs/graphics/wg_graphics.prompt
+        """
+        if self.using is not None:
+            return  # it's an als request, not a genai project (todo: confirm this works on iterations)
+
+        # 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'... create_genai_graphics_prompts - from {graphics_response_path}')
+        graphics = graphics_response['graphics']
+        graphics_prompt = ''
+        graphics_prompt_count = 0
+        for each_graphic in graphics:  # add each prompt to docs/graphics
+            graphics_prompt_count += 1
+            graphics_prompt += each_graphic['prompt'] + '\n'
+        with open(self.project.project_directory_path.joinpath(f'docs/graphics/wg_graphics.prompt'), 'w') as out_file:
+            out_file.write(graphics_prompt)
+        log.info(f'..... added docs/graphics/wg_graphics.prompt')
+        pass
+
+    def graphics_replace_with_in_existing_project(self) -> str:
+        """
+        Delete graphics for wg project (als projects - just delete the docs/graphics files)
+        1. Update docs/*.prompt to remove lines starting with Graphics
+            * Prevents reappearance on iteration
+        2. Presume (!) not necessary to delete the graphics[] in docs/*.response files
+        3. If delete, rename the api/api_discovery/dashboard_services.py file so it won't be called
+
+        This does not rebuild / create a new project - operates on current project.
+
+        If self.replace_with is retry or request, build docs/graphics/wg_graphics.prompt
+        """
+
+        # for all docs/*.prompt files, alter lines where the first characters are 'Graph' (case insensitive)
+        docs_dir = self.project.project_directory_path.joinpath('docs')
+        replaced_count = 0
+        replaced_prompts = ''
+        log.info(f"... graphics_replace_with_in_existing_project - self.replace_with: {self.replace_with}")
+
+        for prompt_file in docs_dir.glob('*.prompt'):
+            with open(prompt_file, 'r') as file:
+                lines = file.readlines()
+                line_number = 0
+                with open(prompt_file, 'w') as file:
+                    for line in lines:
+                        line_number += 1
+                        if not line.strip().lower().startswith('graph '):
+                            file.write(line)
+                        else:
+                            replaced_prompts += line
+                            replaced_count += 1
+                            if self.replace_with == '!retry':  # we are just doing retry - don't replace, use existing wg_graphics
+                                file.write(line)
+                                continue
+                            elif self.replace_with.startswith('!request'):  # replacing - replace ==> docs and doc/graphics
+                                if replaced_count == 1:
+                                    file.write(self.replace_with + '\n')
+                                    graphics_prompt = self.replace_with[8:]
+                                    with open(self.project.project_directory_path.joinpath(f'docs/graphics/wg_graphics.prompt'), 'w') as out_file:
+                                        out_file.write(self.replace_with)
+                            else:
+                                assert self.replace_with == '!delete', f"genai_graphics - expected !delete, got: {self.replace_with}"
+                                pass  # removing line
+
+        log.info(f"..... completed - processed {replaced_count} graph line(s).")
+
+        # Stop graphics: rename the old dashboard_services.py file to dashboard_services.pyZ
+        dashboard_service_path = self.project.project_directory_path.joinpath('api/api_discovery/dashboard_services.py')
+        if dashboard_service_path.exists():
+            renamed_path = dashboard_service_path.with_suffix('.pyZ')
+            dashboard_service_path.rename(renamed_path)
+            log.info(f"..... Renamed existing dashboard_services.py to {renamed_path}")
+        else:
+            log.info(f'.. Note: {dashboard_service_path} not found')
+        return replaced_prompts
+
     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
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace('.isnot', '.is_not')
 
+        # this part is for readability, not 'fixing'
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace('session.query', '(session.query')
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'] + ')'
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace(').', ')\n            .')
+        pass
 
     def append_data_model(self) -> List[str]:
         """ Get the data model
 
         Returns:
-            list: logic_files
+            list[str]: the data model lines
         """
 
         data_model_lines = []
+        data_model_lines.extend(['Here is the data model - please use it to create the graphics:'])
         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)
+        data_model_lines.extend(['End of data model'])
         return data_model_lines
     
     def append_graphics_files(self) -> List[str]:
-        """ Get graphics files (typically from project)
+        """ Get graphics files (typically from project/docs/graphics)
+        * 1 file per graphic
 
         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 Path(self.using).is_dir():  # conversation from directory
+            for each_file in sorted(Path(self.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:

api_logic_server_cli/genai/genai_svcs.py

@@ -42,11 +42,18 @@ class Model(BaseModel):
     description: str
     name: str
 
-class Graph(BaseModel):
-    sqlalchemy_query: str  # sqlalchemy group by result = { "result": [ ("name", "value)  ] }
+class Graphic(BaseModel):
+    sqlalchemy_query: str  # sqlalchemy query using group by, returns 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
+    class_x_axis: str # name of class for x axis
+    name: str  # suggested Python name for sqlalchemy_query - unique
+    prompt: str  # prompt used to create the graphic
+    title: str # expanded name
+    xAxis: str # caption for x axis
+    yAxis: str # caption for y axis
+    dashboard: bool  # whether appears on home page
+    graph_type: str  # Bar, Line, Pie
     html_code: str # create a java script app to show a bar chart from sqlalchemy_query result
 
 class TestDataRow(BaseModel):
@@ -57,7 +64,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
+    graphics: List[Graphic] # 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
@@ -737,10 +744,10 @@ def get_create_prompt__with_inserts(arg_prompt_inserts: str='', raw_prompt: str=
                 pre_post = file.read()  # eg, Use SQLAlchemy to create a sqlite database named system/genai/temp/create_db_models.sqlite, with
         prompt_result = pre_post.replace('{{prompt}}', raw_prompt)
         if for_iteration:
-            # Update the prior response - be sure not to lose classes and test data already created.
-            prompt_result = 'Update the prior response - be sure not to lose classes and test data already created.' \
-                + '\n\n' + prompt_result
-            log.debug(f'.. iteration inserted: Update the prior response')
+            # Update the prior response - be sure not to lose classes, attributes, rules and test data already created.
+            iteration_prompt = read_and_expand_prompt(get_manager_path().joinpath(f'system/genai/prompt_inserts/iteration.prompt'))
+            prompt_result = iteration_prompt  + '\n\n' + prompt_result
+            log.debug(f'.. iteration inserted: Update the prior response, using prompt_inserts/iteration.prompt')
             #log.debug(f'.... iteration prompt result: {prompt_result}')
 
         prompt_lines = prompt_result.split('\n')
@@ -766,10 +773,11 @@ def get_create_prompt__with_inserts(arg_prompt_inserts: str='', raw_prompt: str=
                 do_logic = False
             prompt_line_number += 1
         
-        response_format_file_name = get_manager_path().joinpath(f'system/genai/prompt_inserts/response_format.prompt')
-        with open(response_format_file_name, 'r') as file:
-            response_format = file.readlines()
-        prompt_lines.extend(response_format)
+        if format_not_requested := False:  # FIXME - double format definition on create; others??
+            response_format_file_name = get_manager_path().joinpath(f'system/genai/prompt_inserts/response_format.prompt')
+            with open(response_format_file_name, 'r') as file:
+                response_format = file.readlines()
+            prompt_lines.extend(response_format)
 
         prompt_result = "\n".join(prompt_lines)  # back to a string
         pass

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")
 

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",

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)