ApiLogicServer 14.2.2__py3-none-any.whl → 14.3.0__py3-none-any.whl

api_logic_server_cli/cli.py

@@ -563,8 +563,7 @@ def tutorial(ctx, create):
 @main.command("genai", cls=HideDunderCommand)
 @click.option('--using',
               default=f'genai_demo',
-              prompt="File or dir (determines project name)",
-              help="File or dir (determines project name)")
+              help="File or dir of prompt")
 @click.option('--db-url', 'db_url',
               default=f'sqlite',
               help="SQLAlchemy Database URL\n")
@@ -614,6 +613,9 @@ def genai(ctx, using, db_url, repaired_response: str,
     """
     global command
     import api_logic_server_cli.genai.genai as genai_svcs
+    if using is None and repaired_response is None:
+        log.error("Error - must provide --using or --repaired-response")
+        exit(1) 
     defaulted_using = using
     if defaulted_using == 'genai_demo': # default to genai_demo.prompt
         defaulted_using = 'system/genai/examples/genai_demo/genai_demo.prompt'
@@ -1546,12 +1548,16 @@ def add_cust(ctx, bind_key_url_separator: str, api_name: str, project_name: str)
     log.debug(f"\ncli[add-cust] models_py_path={models_py_path}")
     if not models_py_path.exists():
         raise Exception("Customizations are northwind/genai-specific - models.py does not exist")
+
+    project_is_genai_demo = False  # can't use project.is_genai_demo because this is not the create command...
+    if project.project_directory_path.joinpath('docs/project_is_genai_demo.txt').exists():
+        project_is_genai_demo = True
     
     project.abs_db_url, project.nw_db_status, project.model_file_name = create_utils.get_abs_db_url("0. Using Sample DB", project)
     if create_utils.does_file_contain(search_for="CategoryTableNameTest", in_file=models_py_path):
         project.add_nw_customizations(do_security=False)
         log.info("\nNext step - add authentication:\n  $ ApiLogicServer add-auth --db_url=auth\n\n")
-    elif project_name == 'genai_demo' and create_utils.does_file_contain(search_for="Customer", in_file=models_py_path):
+    elif project_is_genai_demo and create_utils.does_file_contain(search_for="Customer", in_file=models_py_path):
         project.add_genai_customizations(do_security=False)
     elif project_name == 'sample_ai' and create_utils.does_file_contain(search_for="CustomerName = Column(Text", in_file=models_py_path):
         cocktail_napkin_path = project.project_directory_path.joinpath('logic/cocktail-napkin.jpg')

api_logic_server_cli/create_from_model/api_logic_server_utils.py

@@ -92,6 +92,10 @@ def copy_md(project: 'ProjectRun', from_doc_file: str, to_project_file: str = "R
 
     2. Except if 1st line has ## - then remove indents to retain sections
 
+    Image references are made absolute (to github).
+
+    Doc Links are not well displayed in Codespaces, so should me minimized.
+
     Args:
         project (ProjectRun): project object (project name, etc)
         from_doc_file (str): eg, Sample-Basic_Demo.md

api_logic_server_cli/create_from_model/ont_build.py

@@ -159,8 +159,11 @@ class OntBuilder(object):
         if use_local:
             with contextlib.suppress(Exception):
                 return self.local_env.get_template(template_name)
-
-        return self.env.get_template(template_name)
+        try:
+            return self.env.get_template(template_name)
+        except Exception as e:
+            log.error(f"Error loading template {template_name} - {e}")
+            return None 
 
     
     def build_application(self, show_messages: bool = True):
@@ -229,11 +232,7 @@ class OntBuilder(object):
             self.generate_home_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
             self.generate_new_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
             self.generate_detail_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
-            if self.api_endpoint:
-                print(f"Ontimize Build for --api-endpoint={self.api_endpoint} - entity: {each_entity_name}")
-                return
             self.generate_routing(app_path, each_entity_name, each_entity, entity_name)
-
             self.generate_card_home_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
             
         # menu groups/routing and service config
@@ -269,7 +268,11 @@ class OntBuilder(object):
             source=app_config,
         )
     def generate_routing(self, app_path, each_entity_name, each_entity, entity_name):
-        routing = self.load_routing("routing.jinja", entity_name, each_entity)
+        home_template_name = self.find_template(each_entity, "home_template","home_template.html")
+        if home_template_name == "home_tree_template.html":
+            routing = self.load_routing("tree_routing.jinja", entity_name, each_entity)
+        else:
+            routing = self.load_routing("routing.jinja", entity_name, each_entity)
         write_file(app_path, entity_name, "", "-routing.module.ts", routing)
         module = self.load_module("module.jinja", entity_name=each_entity_name, entity=each_entity)
         write_file(app_path, entity_name, "", ".module.ts", module)
@@ -324,6 +327,11 @@ class OntBuilder(object):
         if home_template_name == "grid_template.html":
             home_scss = self.get_template("grid_home.scss").render(entity=each_entity_name)
             ts = self.load_ts("grid_home_template.jinja", each_entity_name, each_entity, entity_favorites)
+        elif home_template_name != "home_template.html":
+            home_scss = self.get_template("home.scss").render(entity=each_entity_name)
+            home_template_nm = home_template_name.split(".")
+            ts_template = self.find_template(each_entity, f"{home_template_nm[0]}.jinja","home_template.jinja")
+            ts = self.load_ts(ts_template, each_entity_name, each_entity, entity_favorites)
         else:
             home_scss = self.get_template("home.scss").render(entity=each_entity_name)     
             ts = self.load_ts("home_template.jinja", each_entity_name, each_entity, entity_favorites)
@@ -455,7 +463,7 @@ class OntBuilder(object):
             # loader=PackageLoader(package_name="APILOGICPROJECT",package_path="/ApiLogicServer/ApiLogicServer-dev/build_and_test/nw/ui/templates"),
             loader=FileSystemLoader(searchpath=f"{templates_path}")
         )
-        local_templates_path = self.app_path.joinpath(f'templates')
+        local_templates_path = self.app_path.joinpath('templates')
         local_env = Environment (
             loader=FileSystemLoader(searchpath=f"{local_templates_path}")
         )
@@ -464,7 +472,7 @@ class OntBuilder(object):
             template_env = Environment(
                 loader=FileSystemLoader(searchpath=f"{self.template_dir}")
             )
-        return (env,local_env, template_env)
+        return (env, local_env, template_env)
     
     def load_ts(self, template_name: str, entity_name: str, entity: any, favorites: any) -> str:
         # The above code is a Python function that takes a template name as input, retrieves the template
@@ -586,9 +594,15 @@ class OntBuilder(object):
         if getattr(entity,"tab_groups",None) != None:
                 for tg in entity["tab_groups"]:
                     exclude = tg.get("exclude", False) or self.global_values["exclude_listpicker"]  == True
-                    if tg["direction"] == "toone" and column.name in tg["fks"] and column.name not in ["Id","id"] and len(tg["fks"]) == 1 and not exclude:
-                        tab_name, tab_var = self.get_tab_attrs(entity=entity, parent_entity=parent_entity, fk_tab=tg)
-                        return self.table_cell_render.render(tab_var)
+                    if tg["direction"] == "toone" \
+                        and column.name in tg["fks"] \
+                        and column.name not in ["Id","id"] \
+                        and len(tg["fks"]) == 1 \
+                        and not exclude:
+                        col_type = next((col.type for col in entity.columns if col.name == col_var["name"]), None)
+                        if col_type and col_var["type"] != col_type:
+                            tab_name, tab_var = self.get_tab_attrs(entity=entity, parent_entity=parent_entity, fk_tab=tg)
+                            return self.table_cell_render.render(tab_var)
                         
         name = column.label if hasattr(column, "label") and column.label != DotMap() else column.name
         self.add_title(column["name"], name)
@@ -606,6 +620,8 @@ class OntBuilder(object):
             return self.table_real_template.render(col_var)
         elif template_type == "table_column":
             return self.table_column.render(col_var)
+        elif template_type.upper() == "CHECKBOX":
+            return self.check_circle_template.render(col_var)
         else:
             if template_type == "TEXTAREA":
                 return self.table_textarea_template.render(col_var)
@@ -629,6 +645,8 @@ class OntBuilder(object):
                 return "CURRENCY"
             elif column.type in ["BLOB","CLOB", "VARBINARY"]:
                 return "IMAGE"
+            elif column.type == "BOOLEAN":
+                return "BOOLEAN"
         return "TEXT"
     def load_new_template(self, template_name: str,entity_name: str,  entity: any, favorites: any) -> str:
         """
@@ -662,8 +680,14 @@ class OntBuilder(object):
         self.add_title(column["name"], name)
         for fk in fks:
             exclude = fk.get("exclude", "false") == "true"
-            if column.name in fk["attrs"]  and fk["direction"] == "toone" and len(fk["attrs"]) == 1 and not exclude:
+            if column.name in fk["attrs"] \
+                and fk["direction"] == "toone" \
+                and len(fk["attrs"]) == 1 \
+                and not exclude: 
+                #and column.template != 'text':
                 fk_entity = self.get_entity(fk["resource"])
+                #col_type = next((col.type for col in entity.columns if col.name == col_var["name"]), None)
+                #if col_type and col_var["type"] != col_type:
                 return self.gen_pick_list_col(col_var, fk, entity)
         return self.gen_field_template(column, col_var)
     
@@ -723,8 +747,14 @@ class OntBuilder(object):
         for fk in fks:
             # TODO - not sure how to handle multiple fks attrs - so only support 1 for now
             exclude = fk.get("exclude", "false") == "true"
-            if column.name in fk["attrs"] and fk["direction"] == "toone" and len(fk["attrs"]) == 1 and not exclude:
-                return self.gen_pick_list_col(col_var, fk, entity)
+            if column.name in fk["attrs"] \
+                and fk["direction"] == "toone" \
+                    and len(fk["attrs"]) == 1 \
+                    and not exclude:
+                    #and column.template != 'text':
+                #col_type = next((col.type for col in entity.columns if col.name == col_var["name"]), None)
+                #if col_type and col_var["type"] != col_type:
+                    return self.gen_pick_list_col(col_var, fk, entity)
         self.add_title(column["name"], name)
         return self.gen_field_template(column, col_var)
 
@@ -912,7 +942,7 @@ class OntBuilder(object):
                 rv = self.nif_template.render(col_var)
             elif col_type in ["DECIMAL","NUMERIC", "DOUBLE","REAL"]:
                 rv = self.real_template.render(col_var)
-            elif template_type == "CHECK_CIRCLE" and col_type in ["BIT","BOOLEAN"]:
+            elif template_type == "CHECK_CIRCLE" or col_type in ["BIT","BOOLEAN"]:
                 rv == self.check_circle_template.render(col_var)
             else:
                 rv = self.text_template.render(col_var)
@@ -1069,11 +1099,15 @@ def get_first_tab_group_entity(entity: any):
 def calculate_template(column):
     col_type = column.type.upper().split("(")[0]
     name = column.name.upper()
-    if name.endswith("AMT") or name.endswith("AMOUNT") or name.endswith("TOTAL") or name in ["BALANCE","CREDITLIMIT","FREIGHT"]:
+    if col_type in ["INTEGER","INT", "TINYINT", "SMALLINT"]:
+        return "INTEGER"
+    if col_type in ["BIT","BOOLEAN"]:
+        return "CHECKBOX"
+    elif name.endswith("AMT") or name.endswith("AMOUNT") or name.endswith("TOTAL") or name in ["BALANCE","CREDITLIMIT","FREIGHT"]:
         return "CURRENCY"
-    if name.endswith("DT") or name.endswith("DATE"):
+    elif name.endswith("DT") or name.endswith("DATE"):
         return "DATE" if col_type == "DATE" else "TIMESTAMP"
-    if name == "DISCOUNT":
+    elif name == "DISCOUNT":
         return "PERCENT"
     template = column.template.upper() if hasattr(column,"template") and column.template != DotMap() else col_type
     if template == "TEXT" and col_type in ["DECIMAL","INTEGER","NUMERIC","REAL","FLOAT"]:

api_logic_server_cli/create_from_model/ont_create.py

@@ -63,6 +63,10 @@ class OntCreator(object):
         self.admin_app = admin_app
         self.app = app
 
+    def attribute_exists(self, attribute: DotMap, attributes: List[DotMap]) -> bool:
+        return any(
+            each_attribute.name == attribute.name for each_attribute in attributes
+        )
     def create_application(self, show_messages: bool = True):
         """ Iterate over ui/admin/admin.yml, and create app...
 
@@ -124,7 +128,8 @@ class OntCreator(object):
                     each_attribute=each_attribute, 
                     each_resource_name=each_resource_name,
                     resources=resources)
-                app_model_out.entities[each_resource_name].columns.append(app_model_attribute)
+                if not self.attribute_exists(app_model_attribute, app_model_out.entities[each_resource_name].columns):
+                    app_model_out.entities[each_resource_name].columns.append(app_model_attribute)
             app_model_out.entities[each_resource_name].pop('attributes')
 
             app_model_out.entities[each_resource_name].primary_key = []
@@ -151,8 +156,7 @@ class OntCreator(object):
         pass
         if show_messages:
             log.info("\nEdit the add_model.yaml as desired, and ApiLogicServer app-build\n")
-
-
+            
     def create_model_entity(self, each_resource, resources: list) -> DotMap:
         each_resource.favorite = each_resource.user_key
         each_resource.exclude = "false"
@@ -227,7 +231,7 @@ class OntCreator(object):
             if col_type in ["SERIAL","SERIAL4"]:
                 rv = "nif"
             if col_type in ["DECIMAL","NUMERIC"]:
-                rv = "currency"  
+                rv = "real"  
             elif col_type in ["DOUBLE", "FLOAT", "REAL"]:
                 rv = "real"  
             elif col_type in ["DATE","DATETIME","TIME","TIMESTAMP"]:
@@ -240,8 +244,13 @@ class OntCreator(object):
                 rv = "image"  
             elif col_type in ["BLOB","CLOB","VARBINARY","BINARY","BYTEA","LONGBLOB","MEDIUMBLOB","TINYBLOB"]:
                 rv = "textarea"
+            elif col_type in ["BOOLEAN","BOOL"]:
+                rv = "checkbox"
             else:
-                rv = "text"  
+                if "amount" in column.name or "price" in column.name or "rate" in column.name:
+                    rv = "currency"
+                else:
+                    rv = "text"  #char varchar string etc
         else:
             rv = "text"  
         return rv

api_logic_server_cli/fragments/declare_logic.py

@@ -0,0 +1,72 @@
+import datetime
+from decimal import Decimal
+from logic_bank.exec_row_logic.logic_row import LogicRow
+from logic_bank.extensions.rule_extensions import RuleExtension
+from logic_bank.logic_bank import Rule
+import database.models as models
+import api.system.opt_locking.opt_locking as opt_locking
+from security.system.authorization import Grant, Security
+import logging
+
+logger = logging.getLogger(__name__)
+
+def declare_logic():
+    ''' Declarative multi-table derivations and constraints, extensible with Python.
+ 
+    Brief background: see readme_declare_logic.md
+    
+    Your Code Goes Here - Use code completion (Rule.) to declare rules
+    '''
+
+    from logic.logic_discovery.auto_discovery import discover_logic
+    discover_logic()
+
+    def handle_all(logic_row: LogicRow):  # #als: TIME / DATE STAMPING, OPTIMISTIC LOCKING
+        """
+        This is generic - executed for all classes.
+
+        Invokes optimistic locking, and checks Grant permissions.
+
+        Also provides user/date stamping.
+
+        Args:
+            logic_row (LogicRow): from LogicBank - old/new row, state
+        """
+
+        if os.getenv("APILOGICPROJECT_NO_FLASK") is not None:
+            print("\ndeclare_logic.py Using TestBase\n")
+            return  # enables rules to be used outside of Flask, e.g., test data loading
+
+        if logic_row.is_updated() and logic_row.old_row is not None and logic_row.nest_level == 0:
+            opt_locking.opt_lock_patch(logic_row=logic_row)
+
+        Grant.process_updates(logic_row=logic_row)
+
+        did_stamping = False
+        if enable_stamping := False:  # #als:  DATE / USER STAMPING
+            row = logic_row.row
+            if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedOn"):
+                row.CreatedOn = datetime.datetime.now()
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedBy"):
+                row.CreatedBy = Security.current_user().id
+                #    if Config.SECURITY_ENABLED == True else 'public'
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "upd" and hasattr(row, "UpdatedOn"):
+                row.UpdatedOn = datetime.datetime.now()
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "upd" and hasattr(row, "UpdatedBy"):
+                row.UpdatedBy = Security.current_user().id  \
+                    if Config.SECURITY_ENABLED == True else 'public'
+                did_stamping = True
+            if did_stamping:
+                logic_row.log("early_row_event_all_classes - handle_all did stamping")     
+    Rule.early_row_event_all_classes(early_row_event_all_classes=handle_all)
+
+    #als rules report
+    from api.system import api_utils
+    # api_utils.rules_report()
+
+    app_logger.debug("..logic/declare_logic.py (logic == rules + code)")
+
+    

api_logic_server_cli/{prototypes/manager/system/genai/create_db_models_inserts/logic_discovery_prefix.py → fragments/declare_logic_begin.py}

@@ -4,7 +4,6 @@ from logic_bank.exec_row_logic.logic_row import LogicRow
 from logic_bank.extensions.rule_extensions import RuleExtension
 from logic_bank.logic_bank import Rule
 import database.models as models
-from database.models import *
 import api.system.opt_locking.opt_locking as opt_locking
 from security.system.authorization import Grant, Security
 import logging
@@ -18,4 +17,6 @@ def declare_logic():
     
     Your Code Goes Here - Use code completion (Rule.) to declare rules
     '''
+
+    # this logic is automatically discovered by declare_logic.py#discover_logic()
     

api_logic_server_cli/fragments/declare_logic_end.py

@@ -0,0 +1,52 @@
+
+    from logic.logic_discovery.auto_discovery import discover_logic
+    discover_logic()
+
+    def handle_all(logic_row: LogicRow):  # #als: TIME / DATE STAMPING, OPTIMISTIC LOCKING
+        """
+        This is generic - executed for all classes.
+
+        Invokes optimistic locking, and checks Grant permissions.
+
+        Also provides user/date stamping.
+
+        Args:
+            logic_row (LogicRow): from LogicBank - old/new row, state
+        """
+
+        if os.getenv("APILOGICPROJECT_NO_FLASK") is not None:
+            print("\ndeclare_logic.py Using TestBase\n")
+            return  # enables rules to be used outside of Flask, e.g., test data loading
+
+        if logic_row.is_updated() and logic_row.old_row is not None and logic_row.nest_level == 0:
+            opt_locking.opt_lock_patch(logic_row=logic_row)
+
+        Grant.process_updates(logic_row=logic_row)
+
+        did_stamping = False
+        if enable_stamping := False:  # #als:  DATE / USER STAMPING
+            row = logic_row.row
+            if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedOn"):
+                row.CreatedOn = datetime.datetime.now()
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedBy"):
+                row.CreatedBy = Security.current_user().id
+                #    if Config.SECURITY_ENABLED == True else 'public'
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "upd" and hasattr(row, "UpdatedOn"):
+                row.UpdatedOn = datetime.datetime.now()
+                did_stamping = True
+            if logic_row.ins_upd_dlt == "upd" and hasattr(row, "UpdatedBy"):
+                row.UpdatedBy = Security.current_user().id  \
+                    if Config.SECURITY_ENABLED == True else 'public'
+                did_stamping = True
+            if did_stamping:
+                logic_row.log("early_row_event_all_classes - handle_all did stamping")     
+    Rule.early_row_event_all_classes(early_row_event_all_classes=handle_all)
+
+    #als rules report
+    from api.system import api_utils
+    # api_utils.rules_report()
+
+    app_logger.debug("..logic/declare_logic.py (logic == rules + code)")
+

api_logic_server_cli/genai/client.py

@@ -0,0 +1,24 @@
+import os
+from openai import AzureOpenAI
+from openai import OpenAI
+
+
+def get_ai_client():
+    api_key = os.getenv("APILOGICSERVER_CHATGPT_APIKEY")
+
+    if not api_key:
+        raise Exception("APILOGICSERVER_CHATGPT_APIKEY environment variable not set")
+
+    azure_endpoint = os.getenv("APILOGICSERVER_CHATGPT_AZURE_ENDPOINT")
+    if azure_endpoint:
+        api_version = os.getenv("APILOGICSERVER_CHATGPT_AZURE_API_VERSION", "2024-10-21")
+        client = AzureOpenAI(
+            azure_endpoint = azure_endpoint, 
+            api_key=api_key,  
+            api_version=api_version)
+        print(f"Using Azure OpenAI, endpoint: {azure_endpoint}, version: {api_version}")
+    else:
+        client = OpenAI(api_key=api_key)
+    
+    return client
+

api_logic_server_cli/genai/genai.py

@@ -176,6 +176,15 @@ class GenAI(object):
                 using = 'system/genai/temp', 
                 api_version=self.project.genai_version)
             response_dict = json.loads(data)
+            if os.environ.get("APILOGICPROJECT_IS_GENAI_DEMO") is not None and \
+                os.environ.get("APILOGICPROJECT_IS_GENAI_DEMO") == 'True':
+                genai_demo_response_path = Path('system/genai/examples/genai_demo/genai_demo.response_example')
+                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)
+                    log.debug(f'.. used standard genai_demo response: {genai_demo_response_path}')
         else: # for retry from corrected response... eg system/genai/temp/chatgpt_retry.response
             self.resolved_model = "(n/a: model not used for repaired response)"
             log.debug(f'\nUsing [corrected] response from: {self.project.genai_repaired_response}')
@@ -303,7 +312,7 @@ class GenAI(object):
                 raw_prompt = file.read()
             prompt = self.get_prompt__with_inserts(raw_prompt=raw_prompt, for_iteration=False)  # insert db-specific logic
             self.logic_enabled = False
-            if 'LogicBank' in prompt:  # if prompt has logic, we need to insert the training
+            if 'LogicBank' in prompt and K_LogicBankOff not in prompt:  # if prompt has logic, we need to insert the training
                 prompt_messages.extend( self.get_prompt_learning_requests())
                 self.logic_enabled = True
             if prompt.startswith('You are a '):  # if it's a preset, we need to insert the prompt
@@ -493,19 +502,17 @@ class GenAI(object):
                     log.debug(f'.. removed hallucination: {each_line}')
             return return_line
 
-        logic_enabled = True
         logic_file = self.project.project_directory_path.joinpath('logic/declare_logic.py')
-        in_logic = False
-        translated_logic = "\n    # Logic from GenAI: (or, use your IDE w/ code completion)\n"
-        translated_logic += genai_svcs.get_code(self.response_dict.rules)
-        if self.logic_enabled == False:
+        if self.logic_enabled:
+            translated_logic = genai_svcs.get_code_update_logic_file(rule_list = self.response_dict.rules,
+                                                                     logic_file_path = logic_file)
+        else:  # prompt contains LogicBankOff (eg, LBX - some demo thing)
             translated_logic = "\n    # Logic from GenAI: (or, use your IDE w/ code completion)\n"
             translated_logic += "\n    # LogicBank Disabled \n"  
-        translated_logic += "\n    # End Logic from GenAI\n\n"
-        utils.insert_lines_at(lines=translated_logic, 
-                              file_name=logic_file, 
-                              at='discover_logic()', 
-                              after=True)
+            utils.insert_lines_at(lines=translated_logic, 
+                                file_name=logic_file, 
+                                at='discover_logic()', 
+                                after=True)
 
         readme_lines = \
             f'\n**GenAI Microservice Automation:** after verifying, apply logic:\n' +\
@@ -535,12 +542,25 @@ class GenAI(object):
 
             response_file = self.project.project_directory_path.joinpath("docs/response.json")
             if Path(self.project.genai_using).stem == 'logic_suggestions':
-                response_file = self.project.project_directory_path.joinpath("docs/logic_suggestions/response.json")  
-            genai_svcs.rebuild_test_data_for_project(
-                use_project_path = self.project.project_directory_path, 
-                project = self.project,
-                use_existing_response = True,
-                response = response_file)
+                response_file = self.project.project_directory_path.joinpath("docs/logic_suggestions/response.json")
+            elif not response_file.exists():
+                if Path(self.project.genai_repaired_response).is_file():
+                    shutil.copyfile(self.project.genai_repaired_response, response_file)
+            is_genai_demo = False
+            if os.getenv('APILOGICPROJECT_IS_GENAI_DEMO') is not None or self.project.project_name == 'genai_demo':
+                self.project.project_directory_path.joinpath('docs/project_is_genai_demo.txt').touch()
+                # and DON'T create test data (db.sqlite already set up in recursive copy)
+                project_docs_response = self.project.project_directory_path.joinpath('docs/response.json')
+                with open(project_docs_response, "w") as response_file:  # WebG uses this for wg_rules
+                    json.dump(self.response_dict, response_file, indent=4)
+                    pass  # not possible on create_db_models, since project paths not yet set by api_logic_server
+
+            else:  # normal path
+                genai_svcs.rebuild_test_data_for_project(
+                    use_project_path = self.project.project_directory_path, 
+                    project = self.project,
+                    use_existing_response = True,
+                    response = response_file)
 
         except:  # intentional try/catch/bury - it's just docs, so don't fail
             import traceback

api_logic_server_cli/genai/genai_logic_builder.py

@@ -84,7 +84,9 @@ class GenAILogic(object):
                 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)
-                self.get_and_save_response_data(response=response, file=each_file)          # save raw response to docs/logic
+                # 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')
@@ -298,30 +300,13 @@ class GenAILogic(object):
         suggest_or_get_code_prompt = get_suggest_or_get_code_prompt()
         self.messages.append({"role": "user", "content": suggest_or_get_code_prompt})
 
-
-        if use_svs := True:
-            response_dict_str = call_chatgpt(
-                messages=self.messages,
-                api_version=self.project.genai_version,
-                using=self.project.project_directory_path.joinpath('docs/logic_suggestions')
-            )
-            response_dict = json.loads(response_dict_str)
-        else:
-            debug_key = os.getenv("APILOGICSERVER_CHATGPT_APIKEY")
-            client = OpenAI(api_key=os.getenv("APILOGICSERVER_CHATGPT_APIKEY"))
-            model = os.getenv("APILOGICSERVER_CHATGPT_MODEL_SUGGESTION")
-            if model is None or model == "*":  # system default chatgpt model
-                model = "gpt-4o-2024-08-06"
-                model = 'gpt-4o-mini'  # reduces from 40 -> 7 secs
-            # 0 = 'you are', 1 = the classes, 2 = rule training
-            # FIXME - use gena0_svcs.call_chatgpt()
-            completion = client.beta.chat.completions.parse(
-                messages=self.messages, response_format=WGResult,
-                model=model  # for own model, use "ft:gpt-4o-2024-08-06:personal:logicbank:ARY904vS" 
-            )
-            
-            data = completion.choices[0].message.content
-            response_dict = json.loads(data)
+        response_dict_str = call_chatgpt(
+            messages=self.messages,
+            api_version=self.project.genai_version,
+            using=self.project.project_directory_path.joinpath('docs/logic_suggestions')
+        )
+        response_dict = json.loads(response_dict_str)
+        
         self.response_dict = DotMap(response_dict)
 
         # starting creating files in docs/logic_suggestions, starting with response
@@ -371,21 +356,22 @@ class GenAILogic(object):
         """
         translated_logic = ""
         if file.suffix == '.py':  # for logic files (not suggestions - they are .txt)
-            manager_root = Path(os.getcwd()).parent
-            with open(manager_root.joinpath('system/genai/create_db_models_inserts/logic_discovery_prefix.py'), "r") as logic_prefix_file:
+            manager_root = Path(os.getcwd()).parent  # FIXME this moved
+            logic_prefix_path = self.project.api_logic_server_dir_path.joinpath('fragments/declare_logic_begin.py')
+            with open(logic_prefix_path, "r") as logic_prefix_file:
                 logic_prefix = logic_prefix_file.read()
-            translated_logic = logic_prefix  # imports, your code goes here
+            translated_logic = logic_prefix  # imports (such as `from logic_bank.logic_bank import Rule``), your code goes here
         translated_logic += f'\n    # Logic from GenAI {str(datetime.datetime.now().strftime("%B %d, %Y %H:%M:%S"))}:\n\n'
 
-        rule_code = genai_svcs.get_code(rule_list)  # get code from logic
+        with open(file, "w") as logic_file:  # write the prefix, so get_code can fix the imports
+            logic_file.write(translated_logic)
+        log.debug(f'.. created logic code: {file}')
+
+        # update logic file with translated rules (and fix import if there is a Rule table)
+        rule_code = genai_svcs.get_code_update_logic_file(rule_list = rule_list,
+                                                          logic_file_path = file) 
         translated_logic += rule_code
         translated_logic += "\n    # End Logic from GenAI\n\n"
-
-        # logic_file_name = file.stem + '.py'
-        # logic_file_path = self.project.project_directory_path.joinpath(f'logic/logic_discovery/{logic_file_name}')
-        with open(file, "w") as logic_file:
-            logic_file.write(translated_logic)
-        log.debug(f'.. stored logic code: {file}')
         pass
 
     def get_headers_with_openai_api_key(self) -> dict: