ApiLogicServer 14.2.20__py3-none-any.whl → 14.3.7__py3-none-any.whl

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"].lower().split("(")[0] in ["bigint", "int","integer", "numeric","decimal"]:
+                            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/genai.py

@@ -176,6 +176,19 @@ 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}')
+                    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)
+
         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 +316,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
@@ -494,13 +507,12 @@ class GenAI(object):
             return return_line
 
         logic_file = self.project.project_directory_path.joinpath('logic/declare_logic.py')
-        if True:  # self.project.is_genai_demo == False: translate logic
+        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 += genai_svcs.get_code(self.response_dict.rules)
-            if self.logic_enabled == False:
-                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"
+            translated_logic += "\n    # LogicBank Disabled \n"  
             utils.insert_lines_at(lines=translated_logic, 
                                 file_name=logic_file, 
                                 at='discover_logic()', 
@@ -541,7 +553,12 @@ class GenAI(object):
             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 recurive copy)
+                # 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, 

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')
@@ -354,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:

api_logic_server_cli/genai/genai_svcs.py

@@ -71,16 +71,99 @@ try:  # this is just for WebGenAI
 except Exception as exc:
     pass # this is just for WebGenAI, ok to ignore error
 
-def get_code(rule_list: List[DotMap]) -> str:
-    """returns code snippet for rules from rule
+def get_code_update_logic_file(rule_list: List[DotMap], logic_file_path: Path = None) -> str:
+    """returns code snippet for rules from rule, updates rules if logic_file_path provided
+
+        * see avoid_collisions_on_rule
 
     Args:
         rule_list (List[DotMap]): list of rules from ChatGPT in DotMap format
+        logic_file_path (Path): if provided, update default rule file, with provisions for model named `Rule`
 
     Returns:
         str: the rule code
     """    
 
+    import re
+
+    patterns = [ re.compile(r"derive=(\w+).*$"),
+                 re.compile(r"from_parent=(\w+).*$"),
+                 re.compile(r"Rule\.constraint\(validate=(\w+).*$"),
+                 re.compile(r"as_sum_of=(\w+).*$"),
+                 re.compile(r"as_count_of=(\w+).*$")
+               ]
+
+    def get_imports(each_line: str, imports: set):
+        """updates imports by extracting the class names to import
+        
+        eg, Rule.constraint(validate=Customer) -> Customer
+
+        Args:
+            each_line (str): the ChatGPT code
+            imports (set): the set of imported classes (updated in place)
+        """
+
+        for each_pattern in patterns:
+            match = each_pattern.search(each_line)
+            if match:
+                the_class_name = match.group(1)
+                log.debug(f'.. found class: {the_class_name} in: {each_line}')
+                imports.add(the_class_name)
+            else:
+                pass
+                # log.debug(f'.. no classes found in: {each_line}')
+        return
+
+    def insert_logic_into_file_and_avoid_collisions_on_rule(translated_logic: str, imports: set, logic_file_path: Path = None) -> None:
+        """ Update logic file with rule code (if provided), with collision avoidance on models named Rule
+        
+        If there's a model named `Rule`, that collides with LogicBank.Rule.  So, change LogicBank.Rule refs:
+
+        1. `from logic_bank.logic_bank import Rule`
+                * to: from logic_bank.logic_bank import Rule as LogicBankRule
+        2. `Rule.early_row_event_all_classes(early_row_event_all_classes=handle_all)`
+                * to: LogicBankRule.early_row_event_all_classes
+                * not used in logic_files, so project is None
+        3. Users' logic (e.g, Rule.constraint) --> LogicBank.Rule.constraint
+
+        Beware of these cases:
+        1. als create - this is not used (but logic/declare_logic.py must exist)
+        2. als genai - uses this, with discovery stuff & Rule.early_event at the end
+        3. als genai-logic - logic/logic_discovery files, no discovery stuff at end
+        4. webG logic - operates differently, to create logic/wg_rules files (for diagnostics)
+
+        Args:
+            rule_list (List[DotMap]): list of rules from ChatGPT in DotMap format
+            project (Project): a Project object (unless creating a logic file)
+            imports (set): the set of imported classes
+        """        
+        insert_logic = "\n    # Logic from GenAI: (or, use your IDE w/ code completion)\n"
+        insert_logic += translated_logic
+        insert_logic += "\n    # End Logic from GenAI\n\n"
+
+        utils.insert_lines_at(lines=insert_logic, 
+                            file_name=logic_file_path, 
+                            at='discover_logic()', 
+                            after=True)
+        
+        if 'Rule' not in imports:
+            return
+        if logic_file_path is None:  # this needs review for WebGenAI
+            log.debug(f'.. .. WebGenAI - avoid_collisions_on_rule: {logic_file_path}')
+            return
+        # find and replace `Rule` in declare_logic.py:
+        utils.replace_string_in_file(search_for='from logic_bank.logic_bank import Rule', 
+                                     replace_with='from logic_bank.logic_bank import Rule as LogicBankRule', 
+                                     in_file=logic_file_path)
+        utils.replace_string_in_file(search_for='Rule.early_row_event_all_classes', 
+                                     replace_with='LogicBankRule.early_row_event_all_classes', 
+                                     in_file=logic_file_path)
+        utils.replace_string_in_file(search_for='    Rule.', 
+                                     replace_with='    LogicBankRule.', 
+                                     in_file=logic_file_path)
+
+
+
     def remove_logic_halluncinations(each_line: str) -> str:
         """remove hallucinations from logic
 
@@ -110,6 +193,8 @@ def get_code(rule_list: List[DotMap]) -> str:
                 pass
             elif 'Rule.constraint' in each_line:
                 pass
+            elif 'Rule.after_flush_row_event' in each_line:
+                pass
             elif 'Rule.allocate' in each_line:
                 pass
             elif 'Rule.calculate' in each_line:
@@ -119,7 +204,9 @@ def get_code(rule_list: List[DotMap]) -> str:
                 log.debug(f'.. removed hallucination: {each_line}')
         return return_line
 
+
     translated_logic = ""
+    imports = set()
     for each_rule in rule_list:
         comment_line = each_rule.description
         translated_logic += f'\n    # {comment_line}\n'
@@ -129,11 +216,19 @@ def get_code(rule_list: List[DotMap]) -> str:
         for each_line in code_lines:
             if 'declare_logic.py' not in each_line:
                 each_repaired_line = remove_logic_halluncinations(each_line=each_line)
+                get_imports(each_line = each_repaired_line, imports=imports)
                 if not each_repaired_line.startswith('    '):  # sometimes in indents, sometimes not
                     each_repaired_line = '    ' + each_repaired_line
                 if 'def declare_logic' not in each_repaired_line:
-                    translated_logic += each_repaired_line + '\n'    
-    return translated_logic
+                    translated_logic += each_repaired_line + '\n' 
+
+    # from database.models import Customer, Order, Item, Product 
+    return_translated_logic = '    from database.models import ' + ', '.join(imports) + '\n' + translated_logic
+    insert_logic_into_file_and_avoid_collisions_on_rule(
+        imports=imports, 
+        translated_logic=return_translated_logic, 
+        logic_file_path=logic_file_path)
+    return return_translated_logic
 
 def rebuild_test_data_for_project(response: str = 'docs/response.json',
                                   project: Project = None,
@@ -168,7 +263,6 @@ def rebuild_test_data_for_project(response: str = 'docs/response.json',
         existing_models = rebuild_project
         del existing_models['rules']
         del existing_models['test_data']
-        del existing_models['test_data_rows']
         del existing_models['test_data_sqlite']
         rebuild_request.append({"role": "user", "content": json.dumps(existing_models)})
         with open(get_manager_path().joinpath('system/genai/prompt_inserts/rebuild_test_data.prompt'), 'r') as file:
@@ -436,6 +530,8 @@ def fix_and_write_model_file(response_dict: DotMap,  save_dir: str, post_error:
                 check_for_row_name = False
             if 'Base.metadata.create_all(engine)' in each_fixed_line:
                 each_fixed_line = each_fixed_line.replace('Base.metadata.create_all(engine)', '# Base.metadata.create_all(engine)')
+            if ',00' in each_fixed_line:
+                each_fixed_line = each_fixed_line.replace(',00', ',0')
             return each_fixed_line
 
         row_names = list()
@@ -767,8 +863,9 @@ def call_chatgpt(messages: List[Dict[str, str]], api_version: str, using: str) -
         model = api_version
         if model == "":  # default from CLI is '', meaning fall back to env variable or system default...
             model = os.getenv("APILOGICSERVER_CHATGPT_MODEL")
-            if model is None or model == "*":  # system default chatgpt model
-                model = "gpt-4o-2024-08-06"
+            if model is None or model == "*":   # system default chatgpt model
+                model = "gpt-4o-2024-08-06"     #  33 sec
+                # model = "o3-mini"               # 130 sec
         with open(Path(using).joinpath('request.json'), "w") as request_file:  # save for debug
             json.dump(messages, request_file, indent=4)
         log.info(f'.. saved request: {using}/request.json')