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

api_logic_server_cli/genai/genai.py

@@ -43,11 +43,11 @@ def import_module_from_path(module_name, file_path):
 class GenAI(object):
     """ Create project from genai prompt(s).  
     
-    Called by api_logic_server, to run ChatGPT (or respone file) to create SQLAlchemy model
+    Called by api_logic_server, to run ChatGPT (or response file) to create SQLAlchemy model
 
     api_logic_server then uses model to create db, proceeds with normal project creation.
 
-    * there is also a callback to genai to insert logic into created project
+    * NB: there is also a callback to genai to genai#insert_logic.. (& graphics) into created project
     """
 
     def __init__(self, project: Project):
@@ -71,7 +71,8 @@ class GenAI(object):
         """ 
         Main Driver for GenAI - called by api_logic_server, to 
         * run ChatGPT (or respone file) to create_db_models.py - models & test data
-        * which then used to create db, for normal project creation.
+        * which then used by apiLogic_server#api_logic_server_cli/create_from_model/create_db_from_model.py, for normal project creation.
+            * warning - test data failure here is not reported
 
         The key argument is `--using`
         * It can be a file, dir (conversation) or text argument.
@@ -152,9 +153,11 @@ class GenAI(object):
         # main driver starts here
         #######################################################
 
-        log.info(f'\nGenAI [{self.project.project_name}] creating microservice...')
+        log.info(f'\n\nGenAI [{self.project.project_name}] creating microservice...')
         log.info(f'.. .. --using prompt: {self.project.genai_using}')
-        log.info(f'.. .. in pwd: {os.getcwd()}')
+        log.info(f'.. .. --project-name[self.project.project_name]: {self.project.project_name}')
+        log.info(f'.. .. project.project_directory_actual: {self.project.project_directory_actual}')
+        log.info(f'.. .. in pwd: {os.getcwd()}\n')
 
         if self.project.genai_repaired_response != '':
             log.info(f'..     retry from [repaired] response file: {self.project.genai_repaired_response}')
@@ -183,12 +186,22 @@ class GenAI(object):
                 if not genai_demo_response_path.is_file():
                     log.debug(f'.. standard genai_demo response not found: {genai_demo_response_path}')
                 else:
-                    with open(genai_demo_response_path, 'r') as response_file:
-                        response_dict = json.load(response_file)
+                    with open(genai_demo_response_path, 'r') as response_file:  # fail-safe demo
+                        response_dict = json.load(response_file)                # BUT, the prompt is in wg?  which needs graphics
                     log.debug(f'.. used standard genai_demo response: {genai_demo_response_path}')
                     genai_demo_response_path = Path('system/genai/temp/response.json')
                     with open(genai_demo_response_path, 'w') as response_file:
                          json.dump(response_dict, response_file, indent=4)
+                    # the request is a cli arg; for wg: sra/src/components/apifab/WebGenAICreate.tsx
+                    if limit_tables := False:  # failed experiment to limit table iterations for genai_demo
+                        # eg, fails to: Add Sales Rep table, as a parent of Order.
+                        genai_demo_request_path = Path('system/genai/temp/request.json')
+                        utils.replace_string_in_file(in_file=genai_demo_request_path,
+                                                    search_for='at least 12 tables',
+                                                    replace_with='only the requested and added tables')
+                        self.messages[0]['content'] = self.messages[0]['content'].replace(
+                            'at least 12 tables', 'only the requested and added tables')
+                        pass
 
         else: # for retry from corrected response... eg system/genai/temp/chatgpt_retry.response
             self.resolved_model = "(n/a: model not used for repaired response)"
@@ -316,7 +329,7 @@ class GenAI(object):
                 log.debug(f'.. from file: {self.project.genai_using}')
                 raw_prompt = file.read()
             prompt = self.get_prompt__with_inserts(raw_prompt=raw_prompt, for_iteration=False)  # insert db-specific logic
-            self.logic_enabled = True
+            self.logic_enabled = True 
             if os.environ.get("APILOGICPROJECT_LOGIC_ENABLED") is not None and \
                             os.environ.get("APILOGICPROJECT_LOGIC_ENABLED") == 'False':
                 self.logic_enabled = False
@@ -398,13 +411,20 @@ class GenAI(object):
         return learning_requests  # TODO - what if no learning requests?
     
     def get_prompt__with_inserts(self, raw_prompt: str, for_iteration: bool = False) -> str:
-        """ prompt-engineering:
+        """ prompt-engineering for both initial & iteration:
 
             1. insert db-specific logic into prompt 
-            2. insert iteration prompt     (if for_iteration)
+            2. insert iteration prompt     (iff for_iteration)
             3. insert logic_inserts.prompt ('1 line: Use LogicBank to create declare_logic()...')
             4. designates prompt-format    (response_format.prompt)
 
+        Eg, initial creation: expands system/genai/prompt_inserts/sqlite_inserts.prompt
+            1. use sqlalchemy to create...
+            2. <requirements>prompt</requirements>
+            3. Use autonum.. (sql hints)
+            4. Graphics training...
+            5. Response format
+
         Args:
             raw_prompt (str): the prompt from file or text argument
             for_iteration (bool, optional): Inserts 'Update the prior response...' Defaults to False.
@@ -473,6 +493,8 @@ class GenAI(object):
         
         Also creates the doc directory for record of prompt, response.
 
+        And, invokes genai_graphics
+
         TODO - use genai_rules_from_response
 
         """
@@ -513,6 +535,12 @@ class GenAI(object):
                     log.debug(f'.. removed hallucination: {each_line}')
             return return_line
 
+        log.info(f'\n\nGenAI [{self.project.project_name}] creating microservice...')
+        log.info(f'.. .. --using prompt: {self.project.genai_using}')
+        log.info(f'.. .. --project-name[self.project.project_name]: {self.project.project_name}')
+        log.info(f'.. .. project.project_directory_actual: {self.project.project_directory_actual}')
+        log.info(f'.. .. in pwd: {os.getcwd()}\n')
+
         logic_file = self.project.project_directory_path.joinpath('logic/declare_logic.py')
         if self.logic_enabled:
             translated_logic = genai_svcs.get_code_update_logic_file(rule_list = self.response_dict.rules,
@@ -576,7 +604,10 @@ 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()}")
-        genai_graphics = GenAIGraphics(project=self.project, using=None, genai_version=self.project.genai_version)
+        genai_graphics = GenAIGraphics(project=self.project, 
+                                       replace_with='!new-wg',
+                                       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

@@ -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