ApiLogicServer 12.1.0__py3-none-any.whl → 12.2.0__py3-none-any.whl

api_logic_server_cli/genaiZ.py

@@ -1,752 +0,0 @@
-from typing import Dict, List
-from api_logic_server_cli.cli_args_project import Project
-import logging
-from pathlib import Path
-import importlib
-import requests
-import os
-import create_from_model.api_logic_server_utils as utils
-import shutil
-
-log = logging.getLogger(__name__)
-
-
-class GenAI(object):
-    """ Create project from genai prompt(s).  
-    
-    Called by api_logic_server, to run ChatGPT (or respone 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
-    """
-
-    def __init__(self, project: Project):
-        """ 
-
-        The key argument is `--using`
-        * It can be a file, dir (conversation) or text argument.
-        * It's "stem" denotes the project name to be created at cwd
-        * `self.project.genai_using`
-
-        The (rarely used) `--repaired_response` 
-        * is for retry from corrected response
-        * `--using` is required to get the project name, to be created at cwd
-        * `self.project.genai_repaired_response`
-
-        __init__() is the main driver (work directory is <manager>/system/genai/temp/)
-        
-        1. run ChatGPT to create system/genai/temp/chatgpt_original.response, using...
-        2. get_prompt_messages() - get self.messages[] from file, dir (conversation) or text argument
-        3. Compute create_db_models
-            a. Usually call chatGPT to get response, save to system/genai/temp/chatgpt_original.response
-            b. If --gen-using-file, read response from file        
-        4. self.get_logic() - saves prompt logic as comments for insertion into model (4.3)
-        5. fix_and_write_model_file()
-        6. returns to main driver (api_logic_server#create_project()), which 
-            1. runs create_db_from_model.create_db(self)
-            2. proceeds to create project
-            3. calls this.insert_logic_into_created_project() - merge logic into declare_logic.py
-
-        developer then can use CoPilot to create logic (Rule.) from the prompt (or just code completion)
-
-        see key_module_map() for key methods
-
-
-        ##### Explore interim copilot access:
-
-        VSCode/Copilot-chat can turn prompts into logic, so can we automate with API?
-
-        https://stackoverflow.com/questions/76741410/how-to-invoke-github-copilot-programmatically
-        https://docs.google.com/document/d/1o0TeNQtuT6moWU1bOq2K20IbSw4YhV1x_aFnKwo_XeU/edit#heading=h.3xmoi7pevsnp
-        https://code.visualstudio.com/api/extension-guides/chat
-        https://code.visualstudio.com/api/extension-guides/language-model
-        https://github.com/B00TK1D/copilot-api
-
-        ### Or use ChatGPT:
-
-        Not sure vscode/copilot is best approach, since we'd like to activate this during project creation
-        (eg on web/GenAI - not using vscode).
-
-        * Thomas suggests there are ways to "teach" ChatGPT about Logic Bank.  This is a *great* idea.
-
-        https://platform.openai.com/docs/guides/fine-tuning/create-a-fine-tuned-model
-        """        
-
-        self.project = project
-        log.info(f'\nGenAI [{self.project.project_name}] creating microservice from: {self.project.genai_using}')
-        if self.project.genai_repaired_response != '':
-            log.info(f'..     retry from [repaired] response file: {self.project.genai_repaired_response}')
-        
-        self.project.from_model = f'system/genai/temp/create_db_models.py' # we always write the model to this file
-        self.ensure_system_dir_exists()  # ~ manager, so we can write to system/genai/temp
-        self.delete_temp_files()
-        self.post_error = ""
-        """ eg, if response contains table defs, save_prompt_messages_to_system_genai_temp_project raises an exception to trigger retry """
-        self.prompt = ""
-        """ `--using` - can come from file or text argument """
-
-        self.messages = self.get_prompt_messages()  # compute self.messages, from file, dir or text argument
-
-        if self.project.genai_repaired_response == '':  # normal path - get response from ChatGPT
-            log.debug(f'.. ChatGPT - saving response to: system/genai/temp/chatgpt_original.response')
-            self.headers = self.get_headers_with_openai_api_key()
-            url = "https://api.openai.com/v1/chat/completions"
-            api_version = f'{self.project.genai_version}'  # eg, "gpt-4o"
-            data = {"model": api_version, "messages": self.messages}
-            response = requests.post(url, headers=self.headers, json=data)
-            # todo - review request structured output using openapi pkg
-            # but, does not create the .py code to create database via SQLAlchemy
-            create_db_models = self.get_and_save_raw_response_data(response)
-        else: # for retry from corrected response... eg system/genai/temp/chatgpt_retry.response
-            log.debug(f'\nUsing [corrected] response from: {self.project.genai_repaired_response}')
-            with open(self.project.genai_repaired_response, 'r') as file:
-                create_db_models = file.read()
-        self.create_db_models = create_db_models
-        """ the raw response data from ChatGPT which will be fixed & saved create_db_models.py """
-
-        self.project.genai_logic = self.get_logic_from_prompt()
-
-        self.fix_and_write_model_file(create_db_models) # write create_db_models.py for db creation   
-        self.save_prompt_messages_to_system_genai_temp_project()  # save prompts, response and models.py
-        if project.project_name_last_node == 'genai_demo_conversation':
-            debug_string = "good breakpoint - check create_db_models.py"
-        pass # if we've set self.post_error, we'll raise an exception to trigger retry
-        pass # return to api_logic_server.ProjectRun to create db/project from create_db_models.py
-
-    def delete_temp_files(self):
-        """Delete temp files created by genai ((system/genai/temp -- models, responses)"""
-        Path('system/genai/temp/create_db_models.sqlite').unlink(missing_ok=True)  # delete temp (work) files
-        Path(self.project.from_model).unlink(missing_ok=True)
-        if self.project.genai_repaired_response == '':  # clean up unless retrying from chatgpt_original.response
-            Path('system/genai/temp/chatgpt_original.response').unlink(missing_ok=True)
-            Path('system/genai/temp/chatgpt_retry.response').unlink(missing_ok=True)
-    
-    def create_presets(self, prompt_messages: List[Dict[str, str]]):
-        """ Create presets - you are a data modelling expert, and logicbank api etc """
-        pass
-
-        starting_message = {"role": "system", "content": "You are a data modelling expert and python software architect who expands on user input ideas. You create data models with at least 4 tables"}
-        prompt_messages.append( starting_message)
-
-        learning_requests = self.get_learning_requests()
-        prompt_messages.extend(learning_requests)  # if any, prepend learning requests (logicbank api etc)
-        log.debug(f'get_prompt_messages()')
-        log.debug(f'.. conv[000] presets: {starting_message}')
-        log.debug(f'.. conv[001] presets: {learning_requests[0]["content"][:30]}...')
-        return len(learning_requests)
-    
-    def get_prompt_messages(self) -> List[Dict[str, str]]:
-        """ Get prompt from file, dir (conversation) or text argument
-            Prepend with learning_requests (if any)
-
-            Returned prompts include inserts from prompt_inserts (prompt engineering)
-
-        Returns:
-            dict[]: [ {role: (system | user) }: { content: user-prompt-or-system-response } ]
-
-        """
-
-        prompt_messages : List[ Dict[str, str] ] = []  # prompt/response conversation to be sent to ChatGPT
-        
-        if self.project.genai_repaired_response != '':       # if exists, get prompt (just for inserting into declare_logic.py)
-            prompt = ""  # we are not calling ChatGPT, just getting the prompt to scan for logic
-            if Path(self.project.genai_using).is_file():  # eg, launch.json for airport_4 is just a name
-                with open(f'{self.project.genai_using}', 'r') as file:
-                    prompt = file.read()
-                prompt_messages.append( {"role": "user", "content": prompt})
-        elif Path(self.project.genai_using).is_dir():  # conversation from directory
-            response_count = 0
-            request_count = 0
-            learning_requests_len = 0
-            prompt = ""
-            for each_file in sorted(Path(self.project.genai_using).iterdir()):
-                if each_file.is_file() and each_file.suffix == '.prompt' or each_file.suffix == '.response':
-                    with open(each_file, 'r') as file:
-                        prompt = file.read()
-                    role = "user"
-                    if response_count == 0 and request_count == 0:
-                        if not prompt.startswith('You are a '):  # add *missing* presets
-                            learning_requests_len = self.create_presets(prompt_messages)
-                            request_count = 1
-                            response_count = learning_requests_len
-                    file_num = request_count + response_count
-                    file_str = str(file_num).zfill(3)
-                    log.debug(f'.. conv[{file_str}] processes: {os.path.basename(each_file)} - {prompt[:30]}...')
-                    if each_file.suffix == ".response":
-                        role = 'system'
-                        response_count += 1
-                    else:
-                        request_count += 1      # rebuild response with *all* tables
-                        if request_count > 1:   # Run Config: genai AUTO DEALERSHIP CONVERSATION
-                            if 'updating the prior response' not in prompt:
-                                prompt = self.get_prompt__with_inserts(raw_prompt=prompt, for_iteration=True)                  
-                    prompt_messages.append( {"role": role, "content": prompt})
-                else:
-                    log.debug(f'.. .. conv ignores: {os.path.basename(each_file)}')
-            if response_count == 0:
-                log.debug(f".. no response files - applying insert to prompt")
-                prompt = self.get_prompt__with_inserts(raw_prompt=prompt)  # insert db-specific logic
-                prompt_messages[1 + learning_requests_len]["content"] = prompt
-        else:                                   # prompt from text (add system/genai/pre_post.prompt)
-            # open and read the project description in natural language
-            learning_requests_len = self.create_presets(prompt_messages)
-            with open(f'{self.project.genai_using}', 'r') as file:
-                log.debug(f'.. from file: {self.project.genai_using}')
-                raw_prompt = file.read()
-            prompt = self.get_prompt__with_inserts(raw_prompt=raw_prompt)  # insert db-specific logic
-            prompt_messages.append( {"role": "user", "content": prompt})
-
-
-        # log.debug(f'.. prompt_messages: {prompt_messages}')  # heaps of output
-        return prompt_messages      
-
-    def get_learning_requests(self) -> List [ Dict[str, str]]:
-        """ Get learning requests from cwd/system/genai/learning_requests
-
-        Returns:
-            list: learning_requests dicts {"role": "user", "content": learning_request_lines}
-        """
-
-        learning_requests : List[ Dict[str, str] ] = []  # learning -> prompt/response conversation to be sent to ChatGPT
-        request_files_dir_path = Path(f'system/genai/learning_requests')
-        if request_files_dir_path.exists():
-            # loop through files in request_files_dir, and append to prompt_messages
-            for root, dirs, files in os.walk(request_files_dir_path):
-                for file in files:
-                    if file.endswith(".prompt"):
-                        with open(request_files_dir_path.joinpath(file), "r") as learnings:
-                            learning_request_lines = learnings.read()
-                        learning_requests.append( {"role": "user", "content": learning_request_lines})
-        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: insert db-specific logic into prompt 
-            raw_prompt: the prompt from file or text argument
-        """
-        prompt_result = raw_prompt
-        prompt_inserts = ''
-        if '*' == self.project.genai_prompt_inserts:    # * means no inserts
-            prompt_inserts = "*"
-        elif '' != self.project.genai_prompt_inserts:   # if text, use this file
-            prompt_inserts = self.project.genai_prompt_inserts
-        elif 'sqlite' in self.project.db_url:           # if blank, use default for db    
-            prompt_inserts = f'sqlite_inserts.prompt'
-        elif 'postgresql' in self.project.db_url:
-            prompt_inserts = f'postgresql_inserts.prompt'
-        elif 'mysql' in self.project.db_url:
-            prompt_inserts = f'mysql_inserts.prompt'
-
-        if prompt_inserts != "*":
-            prompt_eng_file_name = f'system/genai/prompt_inserts/{prompt_inserts}'
-            if for_iteration:
-                prompt_eng_file_name = prompt_eng_file_name.replace('.', '_iterations.')
-            assert Path(prompt_eng_file_name).exists(), \
-                f"Missing prompt_inserts file: {prompt_eng_file_name}"  # eg api_logic_server_cli/prototypes/manager/system/genai/prompt_inserts/sqlite_inserts.prompt
-            log.debug(f'get_prompt__with_inserts: {str(os.getcwd())} / {prompt_eng_file_name}')
-            with open(prompt_eng_file_name, 'r') as file:
-                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)
-
-            prompt_lines = prompt_result.split('\n')
-            prompt_line_number = 0
-            for each_line in prompt_lines:
-                if "LogicBank" in each_line:
-                    log.debug(f'.. inserted: {each_line}')
-                    prompt_eng_logic_file_name = f'system/genai/prompt_inserts/logic_inserts.prompt'
-                    with open(prompt_eng_logic_file_name, 'r') as file:
-                        prompt_logic = file.read()  # eg, Use SQLAlchemy to...
-                    prompt_lines[prompt_line_number] = prompt_logic
-                    break
-                prompt_line_number += 1
-            prompt_result = "\n".join(prompt_lines)  # back to a string
-            pass
-        return prompt_result
-    
-    def ensure_system_dir_exists(self):
-        """
-        If missing, copy prototypes/manager/system -> os.getcwd()/system
-
-        cwd is typically a manager...
-        * eg als dev: ~/dev/ApiLogicServer/ApiLogicServer-dev/build_and_test/ApiLogicServer
-        * eg, user: ~/dev/ApiLogicServer/
-        * we need to create genai/temp files there
-        """
-
-        from_dir = self.project.api_logic_server_dir_path.joinpath('prototypes/manager')
-        to_dir = Path(os.getcwd())
-        to_dir_check = Path(to_dir).joinpath('system')
-        if not to_dir_check.exists():
-            copied_path = shutil.copytree(src=from_dir, dst=to_dir, dirs_exist_ok=True)
-
-    def get_logic_from_prompt(self) -> list[str]:
-        """ Get logic from ChatGPT prompt (code after "Enforce")
-
-        Args:
-
-        Returns: list[str] of the prompt logic
-        """
-
-        prompt = self.prompt  # TODO - redesign if conversation
-        prompt_array = prompt.split('\n')
-        logic_text = """
-    GenAI: Used Logic Bank to enforce these requirements:
-    
-"""
-        line_num = 0
-        logic_lines = 0
-        writing = False
-        for each_line in prompt_array:
-            line_num += 1
-            if "Enforce" in each_line:
-                writing = True
-            if writing:
-                if 'Hints: use autonum keys' in each_line:
-                    break
-                logic_lines += 1
-                logic_text += '    ' + each_line + '\n'
-        return logic_text
-
-    @staticmethod
-    def remove_logic_halluncinations(each_line: str) -> str:
-        """remove hallucinations from logic
-
-        eg: Rule.setup()
-
-        Args:
-            each_line (str): _description_
-
-        Returns:
-            str: _description_
-        """        """ """
-        return_line = each_line
-        if each_line.startswith('    Rule.') or each_line.startswith('    DeclareRule.'):
-            if 'Rule.sum' in each_line:
-                pass
-            elif 'Rule.count' in each_line:
-                pass
-            elif 'Rule.formula' in each_line:
-                pass
-            elif 'Rule.copy' in each_line:
-                pass
-            elif 'Rule.constraint' in each_line:
-                pass
-            elif 'Rule.allocate' in each_line:
-                pass
-            elif 'Rule.calculate' in each_line:
-                return_line = each_line.replace('Rule.calculate', 'Rule.copy')
-            else:
-                return_line = each_line.replace('    ', '    # ')
-                log.debug(f'.. removed hallucination: {each_line}')
-        return return_line
-
-    def insert_logic_into_created_project(self):  # TODO - redesign if conversation
-        """Called *after project created* to insert prompt logic into 
-        1. declare_logic.py (as comment)
-        2. readme.md
-
-        Also creates the doc directory for record of prompt, response.
-        """
-
-        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\n"
-        for each_line in self.create_db_models.split('\n'):
-            if in_logic:
-                if each_line.startswith('    '):    # indent => still in logic
-                    each_repaired_line = self.remove_logic_halluncinations(each_line=each_line)
-                    translated_logic += each_repaired_line + '\n'      
-                elif each_line.strip() == '':       # blank => still in logic
-                    pass
-                else:                               # no-indent => end of logic
-                    in_logic = False
-            if "declare_logic()" in each_line:
-                in_logic = True
-        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)
-
-        readme_lines = \
-            f'\n**GenAI Microservice Automation:** after verifying, apply logic:\n' +\
-            f'1. Open [logic/declare_logic.py](logic/declare_logic.py) and use Copilot\n' +\
-            f'\n' +\
-            f'&nbsp;\n'
-        if update_readme := False:
-            readme_file = self.project.project_directory_path.joinpath('readme.md')
-            utils.insert_lines_at(lines=readme_lines, 
-                                file_name=readme_file, 
-                                at='**other IDEs,**', 
-                                after=True)
-        try:
-            docs_dir = self.project.project_directory_path.joinpath("docs")
-            # os.makedirs(docs_dir, exist_ok=True)
-            # prompt_file_path = docs_dir.joinpath("created_genai_using.prompt")
-            # copy self.project.gen_ai_save_dir to docs_dir
-            shutil.copytree(self.project.gen_ai_save_dir, docs_dir, dirs_exist_ok=True)
-
-            docs_readme_file_path = docs_dir.joinpath("readme.md")
-            docs_readme_lines  = "## GenAI Notes\n\n" 
-            docs_readme_lines += "Review the [database diagram](https://apilogicserver.github.io/Docs/Database-Diagram/).\n\n" 
-            docs_readme_lines += "GenAI work files (exact prompts, with inserts) saved for iterations, diagnostics\n" 
-            docs_readme_lines += "See [WebGenAI-CLI](https://apilogicserver.github.io/Docs/WebGenAI-CLI/). " 
-            with open(docs_readme_file_path, "w") as docs_readme_file:
-                docs_readme_file.write(docs_readme_lines)
-
-        except:  # intentional try/catch/bury - it's just docs, so don't fail
-            import traceback
-            log.error(f"\n\nERROR creating genai project docs: {docs_dir}\n\n{traceback.format_exc()}")
-        pass
-
-    def fix_and_write_model_file(self, response_data: str):
-        """
-        1. break response data into lines
-        2. throw away instructions
-        3. ChatGPT work-arounds (decimal, indent, bogus relns)
-        4. Ensure the sqlite url is correct: sqlite:///system/genai/temp/create_db_models.sqlite
-        5. write model file to self.project.from_model
-
-        Args:
-            response_data (str): the chatgpt response
-
-        """
-        model_class =  "# created from response - used to create database and project\n"
-        model_class += "#  should run without error\n"
-        model_class += "#  if not, check for decimal, indent, or import issues\n\n"
-        with open(f'system/genai/create_db_models_inserts/create_db_models_prefix.py', "r") as inserts:
-            model_lines = inserts.readlines()
-        for each_line in model_lines:
-            model_class += each_line + '\n'
-
-        response_array = response_data.split('\n')
-        line_num = 0
-        writing = False
-        indents_to_remove = 0
-        for each_line in response_array:
-            line_num += 1
-            if "```python" in each_line:
-                writing = True
-                # count spaces before "```"
-                # next_line = response_array[line_num+1]
-                position = each_line.find("```")
-                if position > 0:
-                    indents_to_remove = each_line[:position].count(' ')                
-            elif "```" in each_line:
-                writing = False
-            elif writing:  # ChatGPT work-arounds
-                ''' decimal issues
-
-                    1. bad import: see Run: tests/test_databases/ai-created/genai_demo/genai_demo_decimal
-                        from decimal import Decimal  # Decimal fix: needs to be from decimal import DECIMAL
-
-                    2. Missing missing import: from SQLAlchemy import .... DECIMAL
-
-                    3. Column(Decimal) -> Column(DECIMAL)
-                        see in: tests/test_databases/ai-created/budget_allocation/budget_allocations/budget_allocations_3_decimal
-
-                    4. Bad syntax on test data: see Run: blt/time_cards_decimal from RESPONSE
-                        got:    balance=DECIMAL('100.50')
-                        needed: balance=1000.0
-                        fixed with import in create_db_models_prefix.py
-
-                    5. Bad syntax on test data cals: see api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_conversation_bad_decimal/genai_demo_03.response
-                        got: or Decimal('0.00')
-                        needed: or decimal.Decimal('0.00')
-
-                    6. Bad syntax on test data cals: see api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo_conversation_bad_decimal_2/genai_demo_conversation_002.response
-                        got: or DECIMAL('
-                        needed: or decimal.Decimal('0.00')
-                '''
-                if "= Table(" in each_line:  # tests/test_databases/ai-created/time_cards/time_card_kw_arg/genai.response
-                    log.debug(f'.. fix_and_write_model_file detects table - raise excp to trigger retry')
-                    self.post_error = "ChatGPT Response contains table (not class) definitions: " + each_line
-                if 'sqlite:///' in each_line:  # must be sqlite:///system/genai/temp/create_db_models.sqlite
-                    current_url_rest = each_line.split('sqlite:///')[1]
-                    quote_type = "'"
-                    if '"' in current_url_rest:
-                        quote_type = '"'  # eg, tests/test_databases/ai-created/time_cards/time_card_decimal/genai.response
-                    current_url = current_url_rest.split(quote_type)[0]  
-                    proper_url = 'system/genai/temp/create_db_models.sqlite'
-                    each_line = each_line.replace(current_url, proper_url)
-                    if current_url != proper_url:
-                        log.debug(f'.. fixed sqlite url: {current_url} -> system/genai/temp/create_db_models.sqlite')
-                if 'Decimal,' in each_line:  # SQLAlchemy import
-                    each_line = each_line.replace('Decimal,', 'DECIMAL,')
-                    # other Decimal bugs: see api_logic_server_cli/prototypes/manager/system/genai/reference/errors/chatgpt_decimal.txt
-                if ', Decimal' in each_line:  # Cap'n K, at your service
-                    each_line = each_line.replace(', Decimal', ', DECIMAL')
-                if 'rom decimal import Decimal' in each_line:
-                    each_line = each_line.replace('from decimal import Decimal', 'import decimal')
-                if '=Decimal(' in each_line:
-                    each_line = each_line.replace('=Decimal(', '=decimal.Decimal(')
-                if ' Decimal(' in each_line:
-                    each_line = each_line.replace(' Decimal(', ' decimal.Decimal(')
-                if 'Column(Decimal)' in each_line:
-                    each_line = each_line.replace('Column(Decimal)', 'Column(DECIMAL)')
-                if "DECIMAL('" in each_line:
-                    each_line = each_line.replace("DECIMAL('", "decimal.Decimal('")
-                if 'end_time(datetime' in each_line:  # tests/test_databases/ai-created/time_cards/time_card_kw_arg/genai.response
-                    each_line = each_line.replace('end_time(datetime', 'end_time=datetime')
-                if indents_to_remove > 0:
-                    each_line = each_line[indents_to_remove:]
-                if 'relationship(' in each_line and self.project.genai_use_relns == False:
-                    # airport4 fails with could not determine join condition between parent/child tables on relationship Airport.flights
-                    if each_line.startswith('    '):
-                        each_line = each_line.replace('    ', '    # ')
-                    else:  # sometimes it puts relns outside the class (so, outdented)
-                        each_line = '# ' + each_line
-                if 'sqlite:///system/genai/temp/model.sqlite':  # fix prior version
-                    each_line = each_line.replace('sqlite:///system/genai/temp/model.sqlite', 
-                                                  'sqlite:///system/genai/temp/create_db_models.sqlite')
-
-                # logicbank fixes
-                if 'from logic_bank' in each_line:  # we do our own imports
-                    each_line = each_line.replace('from', '# from')
-                if 'LogicBank.activate' in each_line:
-                    each_line = each_line.replace('LogicBank.activate', '# LogicBank.activate')
-                
-                model_class += each_line + '\n'
-        with open(f'{self.project.from_model}', "w") as model_file:
-            model_file.write(model_class)
-        
-        log.debug(f'.. model file created: {self.project.from_model}')
-
-    def save_prompt_messages_to_system_genai_temp_project(self):
-        """
-        Save prompts / responses to system/genai/temp/{project}/genai.response
-
-        Copy system/genai/temp/create_db_models.py to system/genai/temp/{project}/create_db_models.py
-        """
-        try:
-            to_dir = Path(os.getcwd())
-            gen_temp_dir = Path(to_dir).joinpath(f'system/genai/temp')
-            to_dir_save_dir = Path(to_dir).joinpath(f'system/genai/temp/{self.project.project_name_last_node}')
-            """ project work files saved to system/genai/temp/<project> """
-            log.info(f'.. saving work files to: system/genai/temp/{self.project.project_name_last_node}')
-            """ system/genai/temp/project - save prompt, response, and create_db_models.py to this directory """
-            self.project.gen_ai_save_dir = to_dir_save_dir
-            """ project work files saved to system/genai/temp/<project> """
-            # delete and recreate the directory
-            if to_dir_save_dir.exists():
-                shutil.rmtree(to_dir_save_dir)
-            os.makedirs(to_dir_save_dir, exist_ok=True)
-            log.debug(f'save_prompt_messages_to_system_genai_temp_project() - {str(to_dir_save_dir)}')
-
-            if self.project.genai_repaired_response == '':  # normal path, from --using
-                if write_prompt := True:
-                    pass
-                    file_num = 0
-                    flat_project_name = Path(self.project.project_name).stem  # in case project is dir/project-name
-                    for each_message in self.messages:
-                        suffix = 'prompt'
-                        if each_message['role'] == 'system':
-                            suffix = 'response' 
-                        file_name = f'{flat_project_name}_{str(file_num).zfill(3)}.{suffix}'
-                        file_path = to_dir_save_dir.joinpath(file_name)
-                        log.debug(f'.. saving[{file_name}]  - {each_message["content"][:30]}...')
-                        with open(file_path, "w") as message_file:
-                            message_file.write(each_message['content']) 
-                        file_num += 1
-                    suffix = 'response'  # now add the this response
-                    file_name = f'{flat_project_name}_{str(file_num).zfill(3)}.{suffix}'  # FIXME 
-                    file_path = to_dir_save_dir.joinpath(file_name)
-                    log.debug(f'.. saving[{file_name}]  - {each_message["content"][:30]}...')
-                    with open(file_path, "w") as message_file:
-                        message_file.write(self.create_db_models)
-                shutil.copyfile(self.project.from_model, to_dir_save_dir.joinpath('create_db_models.py'))
-        except Exception as inst:
-            # FileNotFoundError(2, 'No such file or directory')
-            log.error(f"\n\nError: {inst} \n..creating diagnostic files into dir: {str(gen_temp_dir)}\n\n")
-            pass  # intentional try/catch/bury - it's just diagnostics, so don't fail
-        debug_string = "good breakpoint - return to main driver, and execute create_db_models.py"
-
-    def get_headers_with_openai_api_key(self) -> dict:
-        """
-        Returns:
-            dict: api header with OpenAI key (exits if not provided)
-        """
-        
-        pass  # https://community.openai.com/t/how-do-i-call-chatgpt-api-with-python-code/554554
-        if os.getenv('APILOGICSERVER_CHATGPT_APIKEY'):
-            openai_api_key = os.getenv('APILOGICSERVER_CHATGPT_APIKEY')
-        else:
-            from dotenv import dotenv_values
-            secrets = dotenv_values("system/secrets.txt")
-            openai_api_key = secrets['APILOGICSERVER_CHATGPT_APIKEY']
-            if openai_api_key == 'your-api-key-here':
-                if os.getenv('APILOGICSERVER_CHATGPT_APIKEY'):
-                    openai_api_key = os.getenv('APILOGICSERVER_CHATGPT_APIKEY')
-                else:
-                    log.error("\n\nMissing env value: APILOGICSERVER_CHATGPT_APIKEY")
-                    log.error("... Check your system/secrets file...\n")
-                    exit(1)
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {openai_api_key}"
-        }
-        return headers
-    
-    def get_and_save_raw_response_data(self, response) -> str:
-        """
-        Returns:
-            str: response_data
-        """
-        
-
-        # Check if the request was successful
-        if response.status_code == 400:
-            raise Exception("Bad ChatGPT Request: " + response.text)
-        
-        if response.status_code != 200:
-            print("Error:", response.status_code, response.text)   # eg, You exceeded your current quota 
-
-        response_data = response.json()['choices'][0]['message']['content']
-        file_name = f'system/genai/temp/chatgpt_original.response'
-        with open(f'system/genai/temp/chatgpt_original.response', "w") as model_file:  # save for debug
-            model_file.write(response_data)
-            file_name = model_file.name
-        with open(f'system/genai/temp/chatgpt_retry.response', "w") as model_file:     # repair this & retry
-            model_file.write(response_data)
-        log.debug(f'.. stored raw response: {model_file.name}')
-        return response_data
-
-
-def genai(using, db_url, repaired_response: bool, genai_version: str, 
-          retries: int, opt_locking: str, prompt_inserts: str, quote: bool,
-          use_relns: bool, project_name: str):
-    """ cli caller provides using, or repaired_response & using
-    
-        Called from cli commands: genai, genai-create, genai-iterate
-        
-        Invokes api_logic_server.ProjectRun (with 3 retries)
-        
-        Which calls Genai()
-    """
-    import api_logic_server_cli.api_logic_server as PR
-
-    resolved_project_name = project_name
-    if resolved_project_name == '' or resolved_project_name is None:
-        resolved_project_name = Path(using).stem  # default project name is the <cwd>/last node of using
-    resolved_project_name  = resolved_project_name.replace(' ', '_')
-
-    try_number = 1
-    genai_use_relns = use_relns
-    """ if 'unable to determine join condition', we retry this with False """
-    if repaired_response != "":
-        try_number = retries  # if not calling GenAI, no need to retry:
-    # TODO or 0, right?
-    if retries < 0:  # for debug: catch exceptions at point of failure
-        PR.ProjectRun(command="create", genai_version=genai_version, 
-                    genai_using=using,                      # the prompt file, or conversation dir
-                    repaired_response=repaired_response,    # retry from [repaired] response file
-                    opt_locking=opt_locking,
-                    genai_prompt_inserts=prompt_inserts,
-                    genai_use_relns=genai_use_relns,
-                    quote=quote,
-                    project_name=resolved_project_name, db_url=db_url)
-        log.info(f"GENAI successful")  
-    else:
-        failed = False
-        while try_number <= retries:
-            try:
-                failed = False
-                PR.ProjectRun(command="create", genai_version=genai_version, 
-                            genai_using=using,                      # the prompt file, or dir of prompt/response
-                            repaired_response=repaired_response,    # retry from [repaired] response file
-                            opt_locking=opt_locking,
-                            genai_prompt_inserts=prompt_inserts,
-                            genai_use_relns=genai_use_relns,
-                            quote=quote,
-                            project_name=resolved_project_name, db_url=db_url)
-                if do_force_failure := False:
-                    if try_number < 3:
-                        raise Exception("Forced Failure for Internal Testing")
-                break  # success - exit the loop
-            except Exception as e:  # almost certaily in api_logic_server_cli/create_from_model/create_db_from_model.py
-                log.error(f"\n\nGenai failed With Error: {e}")
-
-                if Path(using).is_dir():
-                    log.debug('conversation dir, check in-place iteration')
-                    '''
-                    cases:
-                        - conv in temp - in_place_conversation
-                        - conv elsewhere 
-                    test (sorry, no automated blt test for this):
-                        1. genai CONVERSATION - clean/ApiLogicServer/genai_demo_conversation
-                        2. genai CONVERSATION ITERATE IN-PLACE (NB: DELETE LAST RESPONSE FIRST)
-                            a. Stop: find 'good breakpoint - check create_db_models.py'
-                            b. Introduce error in system/genai/temp/create_db_models.py
-                    '''
-
-                    to_dir_save_dir = Path(Path(os.getcwd())).joinpath(f'system/genai/temp/{resolved_project_name}')
-                    in_place_conversation = str(to_dir_save_dir) == str(Path(using).resolve())
-                    """ means we are using to_dir as the save directory """
-                    if in_place_conversation:
-                        last_response_file_name = ''
-                        last_type = ''
-                        for each_file in sorted(Path(to_dir_save_dir).iterdir()):
-                            if each_file.is_file() and each_file.suffix == '.prompt':
-                                last_type = '.prompt'
-                            if each_file.suffix == '.response':
-                                last_type = '.response'
-                                last_response_file_name = each_file.name
-                        if last_type == ".response":  # being careful to delete only recent response
-                            last_response_path = to_dir_save_dir.joinpath(last_response_file_name)
-                            log.debug(f'in-place conversation dir, deleting most recent response: {last_response_path}')
-                            Path(last_response_path).unlink(missing_ok=True)
-
-                # save the temp files for diagnosis (eg, <resolved_project_name>_1)
-                manager_dir = Path(os.getcwd())  # rename save dir (append retry) for diagnosis
-                resolved__project_name_parts = resolved_project_name
-                parts = resolved__project_name_parts.split('/')
-                # Return the last element
-                resolved_temp_project_name = parts[-1]
-                to_dir_save_dir = Path(manager_dir).joinpath(f'system/genai/temp/{resolved_temp_project_name}')
-                to_dir_save_dir_retry = Path(manager_dir).joinpath(f'system/genai/temp/{resolved_temp_project_name}_{try_number}')
-                if repaired_response != "":
-                    to_dir_save_dir_retry = Path(manager_dir).joinpath(f'system/genai/temp/{resolved_temp_project_name}_retry')  
-                if to_dir_save_dir_retry.exists():
-                    shutil.rmtree(to_dir_save_dir_retry)
-                # to_dir_save_dir.rename(to_dir_save_dir_retry) 
-                assert to_dir_save_dir.is_dir(), f"\nInternal Error - missing save directory: {to_dir_save_dir}"
-                # assert to_dir_save_dir_retry.is_dir(), f"\nInternal Error - missing retry directory: {to_dir_save_dir_retry}"
-                log.debug(f'.. copying work files...')
-                log.debug(f'.... from: {to_dir_save_dir}')
-                log.debug(f'.... to:   {to_dir_save_dir_retry}')
-                shutil.copytree(to_dir_save_dir, to_dir_save_dir_retry, dirs_exist_ok=True) 
-
-                failed = True
-                if genai_use_relns and "Could not determine join condition" in str(e):
-                    genai_use_relns = False  # just for db_models (fk's still there!!)
-                    log.error(f"\n   Failed with join condition - retrying without relns\n")
-                    failed = False
-                else:
-                    try_number += 1
-                    log.debug(f"\n\nRetry Genai #{try_number}\n")
-            pass # retry (retries times)
-        if failed == True:  # retries exhausted (if failed: threw "an integer is required" ??
-            log.error(f"\n\nGenai Failed (Retries: {retries})") 
-            exit(1) 
-        log.info(f"GENAI successful on try {try_number}")  
-
-
-def key_module_map():
-    """ does not execute - strictly fo find key modules """
-    import api_logic_server_cli.api_logic_server as als
-    import api_logic_server_cli.create_from_model.create_db_from_model as create_db_from_model
-
-    genai()                                         # called from cli.genai/create/iterate
-                                                    # try/catch/retry loop!
-    als.ProjectRun()                                # calls api_logic_server.ProjectRun
-
-    genai = GenAI(Project())                        # called from api_logic_server.ProjectRun
-    genai.__init__()                                # main driver, calls...  
-    genai.get_prompt_messages()                     # get self.messages from file/dir/text/arg
-    genai.fix_and_write_model_file('response_data') # write create_db_models.py for db creation
-    genai.save_files_to_system_genai_temp_project() # save prompt, response and create_db_models.py
-                                                    # returns to api_logic_server, which...
-    create_db_from_model.create_db()                #   creates create_db_models.sqlite from create_db_models.py
-                                                    #   creates project from that db; and calls...
-    genai.insert_logic_into_created_project()       #   merge logic (comments) into declare_logic.py
-