gibson-cli 0.1.0__py3-none-any.whl

command/Conf.py

@@ -0,0 +1,74 @@
+import sys
+
+from .BaseCommand import BaseCommand
+
+
+class Conf(BaseCommand):
+    def __compile_configuration_keys(self, element, setting, keys):
+        if not isinstance(element, dict):
+            keys.append("::".join(setting))
+        else:
+            for key, value in element.items():
+                if key not in ["dev", "modeler"]:
+                    self.__compile_configuration_keys(
+                        element[key], setting + [key], keys
+                    )
+
+        return keys
+
+    def execute(self):
+        if len(sys.argv) != 4 or sys.argv[2] not in self.get_configuration_keys():
+            self.usage()
+
+        settings = self.configuration.get_my_settings()
+        key = sys.argv[2]
+        value = sys.argv[3]
+        item = settings
+
+        elements = key.split("::")
+        for i in range(len(elements) - 1):
+            try:
+                item = item[elements[i]]
+            except KeyError:
+                self.usage()
+
+        try:
+            old_value = item[elements[-1]]
+            item[elements[-1]] = value
+        except KeyError:
+            self.usage()
+
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(f"{key}\n")
+        self.conversation.type(f"  [old value] {old_value}\n")
+        self.conversation.type(f"  [new value] {value}\n")
+        self.conversation.newline()
+        self.configuration.write_config()
+
+        return self
+
+    def get_configuration_keys(self):
+        configuration_keys = self.__compile_configuration_keys(
+            self.configuration.get_my_settings(), [], []
+        )
+
+        del configuration_keys[configuration_keys.index("meta::version")]
+
+        return configuration_keys
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} conf [key] [value]\n"
+            "  where [key] is one of:\n"
+        )
+        self.conversation.set_delay(0.004)
+
+        for key in self.get_configuration_keys():
+            self.conversation.type(f"    {key}\n")
+
+        self.conversation.newline()
+        self.conversation.type('"That was recursive! I used recursion, guys!"\n')
+        self.conversation.type("                      -- Montero, 02/06/2024\n")
+        self.conversation.newline()
+        exit(1)

command/Count.py

@@ -0,0 +1,35 @@
+import sys
+
+from .BaseCommand import BaseCommand
+
+
+class Count(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3 or sys.argv[2] not in ["last", "stored"]:
+            self.usage()
+
+        if sys.argv[2] == "last":
+            count = 0
+            if self.memory.last is not None:
+                count = len(self.memory.last["entities"])
+
+            print(count)
+        elif sys.argv[2] == "stored":
+            count = 0
+            if self.memory.entities is not None:
+                count = len(self.memory.entities)
+
+            print(count)
+        else:
+            raise NotImplementedError
+
+        return self
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} count [which memory]\n"
+            + '  where [which memory] is one of "last" or "stored"\n'
+        )
+        self.conversation.newline()
+        exit(1)

command/Dev.py

@@ -0,0 +1,121 @@
+import os
+import sys
+
+from lang.Python import Python
+
+from .BaseCommand import BaseCommand
+
+
+class Dev(BaseCommand):
+    def __display_language_specific_instructions(self):
+        if self.configuration.project.code.language == "python":
+            pythonpath = Python().define_python_path(
+                [
+                    os.path.expandvars(self.configuration.project.dev.base.path),
+                    os.path.expandvars(self.configuration.project.dev.model.path),
+                    os.path.expandvars(self.configuration.project.dev.schema.path),
+                ]
+            )
+            if pythonpath is not None:
+                self.conversation.type(
+                    "Your Python environment needs to be configured, so do this:\n"
+                )
+                self.conversation.type(
+                    f"  export PYTHONPATH=$PYTHONPATH:{pythonpath}\n\n"
+                )
+
+        return self
+
+    def execute(self):
+        if len(sys.argv) != 3 or sys.argv[2] not in ["off", "on"]:
+            self.usage()
+
+        if sys.argv[2] == "off":
+            if self.configuration.project.dev.active is True:
+                self.configuration.turn_dev_off()
+
+            self.off()
+
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            "Leveling up. Nice! I need a little context to make sure I write "
+            + "code\nin the correct place. Then I will need you to tell me "
+            + "about how to\nconfigure the API.\n\n"
+        )
+
+        api_path = self.configuration.project.dev.api.path
+        if api_path is None:
+            api_path = ""
+
+        base_path = self.configuration.project.dev.base.path
+        if base_path is None:
+            base_path = ""
+
+        model_path = self.configuration.project.dev.model.path
+        if model_path is None:
+            model_path = ""
+
+        schema_path = self.configuration.project.dev.schema.path
+        if schema_path is None:
+            schema_path = ""
+
+        self.conversation.type(
+            "  I need a writable directory into which I can put code.\n"
+        )
+        base = self.configuration.ask_for_path(base_path)
+
+        for subdir in ["api", "model", "schema"]:
+            try:
+                os.mkdir(f"{os.path.expandvars(base)}/{subdir}")
+            except FileExistsError:
+                pass
+
+        self.conversation.type(
+            "\n  https://api.yourdomain.com/v1/-/sneakers GET\n", delay=0.002
+        )
+        self.conversation.type("                             ^  ^\n", delay=0.002)
+        self.conversation.type("                             |  |\n", delay=0.002)
+        self.conversation.type("                    version _|  |\n", delay=0.002)
+        self.conversation.type(
+            "                                |_ prefix (to isolate GibsonAI "
+            + "API routes)\n\n",
+            delay=0.002,
+        )
+        self.conversation.type(
+            "  It is OK if you are not sure about these. Just leave the defaults\n"
+            + "  and when you make a decision I will rewrite the code for you.\n\n"
+        )
+
+        api_version = self.configuration.ask_for_value(
+            "  version", self.configuration.project.dev.api.version
+        )
+        api_prefix = self.configuration.ask_for_value(
+            "   prefix", self.configuration.project.dev.api.prefix
+        )
+
+        self.configuration.turn_dev_on(
+            f"{base}/api",
+            api_prefix,
+            api_version,
+            base,
+            f"{base}/model",
+            f"{base}/schema",
+        )
+
+        self.conversation.newline()
+        self.__display_language_specific_instructions()
+        self.conversation.type("Dev Mode is on!\n\n")
+
+        return self
+
+    def off(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type("Dev Mode is off!\n")
+        self.conversation.newline()
+        exit(1)
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(f"usage: {self.configuration.command} dev [off | on]\n")
+        self.conversation.newline()
+        exit(1)

command/Forget.py

@@ -0,0 +1,34 @@
+import sys
+
+from .BaseCommand import BaseCommand
+
+
+class Forget(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3 or sys.argv[2] not in ["all", "last", "stored"]:
+            self.usage()
+
+        if sys.argv[2] == "all":
+            self.memory.forget_last()
+            self.memory.forget_entities()
+        elif sys.argv[2] == "last":
+            self.memory.forget_last()
+        elif sys.argv[2] == "stored":
+            self.memory.forget_entities()
+        else:
+            raise NotImplementedError
+
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type("Yeah man, forgotten.\n")
+        self.conversation.newline()
+
+        return self
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} forget [which memory]\n"
+            + '  where [which memory] is one of "all", "last" or "stored"\n'
+        )
+        self.conversation.newline()
+        exit(1)

command/Import.py

@@ -0,0 +1,109 @@
+import sys
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from api.Cli import Cli
+from db.TableExceptions import TableExceptions
+
+from .BaseCommand import BaseCommand
+from .Rewrite import Rewrite
+
+
+class Import(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3 and len(sys.argv) != 5:
+            self.usage()
+
+        write_code = False
+        if len(sys.argv) == 5:
+            if sys.argv[3] != ".." or sys.argv[4] != "dev":
+                self.usage()
+
+            if self.configuration.project.dev.active is False:
+                self.conversation.display_project(self.configuration.project.name)
+                self.conversation.type(
+                    "Dude, seriously?! You have Dev Mode turned off. "
+                    + "Why would you do that?\n"
+                )
+                self.conversation.newline()
+                exit(1)
+
+            write_code = True
+
+        if sys.argv[2] == "api":
+            entities = self.__import_from_api()
+        elif sys.argv[2] == "datastore":
+            entities = self.__import_from_datastore()
+        else:
+            self.usage()
+
+        self.memory.remember_entities(entities)
+
+        word_entities = "entities"
+        if len(entities) == 1:
+            word_entities = "entity"
+
+        self.conversation.type("\nSummary\n")
+        self.conversation.type(f"    {len(entities)} {word_entities} imported\n")
+        self.conversation.newline()
+
+        if write_code:
+            Rewrite(self.configuration).execute()
+            self.conversation.newline()
+
+        return True
+
+    def __import_from_api(self):
+        self.conversation.display_project(self.configuration.project.name)
+
+        self.conversation.type("Connected to API...\n")
+        response = Cli(self.configuration).import_()
+        self.conversation.type("Building schema...\n")
+
+        entities = []
+        for entity in response["project"]["entities"]:
+            self.conversation.type(f"    {entity['name']}\n", delay=0.002)
+
+        return response["project"]["entities"]
+
+    def __import_from_datastore(self):
+        self.conversation.display_project(self.configuration.project.name)
+
+        db = create_engine(self.configuration.project.datastore.uri)
+        session = sessionmaker(autocommit=False, autoflush=False, bind=db)()
+
+        table_exceptions = TableExceptions().universal()
+        if self.configuration.project.datastore.type == "mysql":
+            table_exceptions = TableExceptions().mysql()
+
+        self.conversation.type("Connected to datastore...\n")
+        self.conversation.type("Building schema...\n")
+
+        tables = session.execute("show tables").all()
+
+        entities = []
+        for table in tables:
+            if table[0] not in table_exceptions:
+                self.conversation.type(f"    {table[0]}\n", delay=0.002)
+
+                create_statement = session.execute(
+                    f"show create table {table[0]}"
+                ).one()
+
+                entities.append(
+                    {"definition": str(create_statement[1]), "name": str(table[0])}
+                )
+
+        return entities
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} import [api | datastore] {{.. dev}}"
+            + "\n  api = the project stored in your API key on GibsonAI.com\n"
+            + f"  datastore = {self.configuration.project.datastore.uri}\n"
+            + "  {.. dev} have Dev Mode write all the code\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/List.py

@@ -0,0 +1,61 @@
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class List(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        self.conversation.display_project(self.configuration.project.name)
+
+        entities = {"last": [], "stored": []}
+
+        last = self.memory.recall_last()
+        if last is not None:
+            for entity in last["entities"]:
+                entities["last"].append(entity["name"])
+
+        stored = self.memory.recall_entities()
+        if stored is not None:
+            for entity in stored:
+                entities["stored"].append(entity["name"])
+
+        if len(entities["last"]) == 0 and len(entities["stored"]) == 0:
+            self.conversation.nothing_to_list(sys.argv[2])
+            self.conversation.newline()
+        else:
+            self.conversation.type("    Name".ljust(60), delay=0.0001)
+            self.conversation.type("Memory", delay=0.002)
+            self.conversation.newline()
+            self.conversation.type("    ----".ljust(60), delay=0.0001)
+            self.conversation.type("------", delay=0.002)
+            self.conversation.newline()
+
+            entities["last"].sort()
+            entities["stored"].sort()
+
+            if len(entities["stored"]) > 0:
+                for entity in entities["stored"]:
+                    self.conversation.type(f"    {entity}".ljust(60), delay=0.0001)
+                    self.conversation.type("[stored]", delay=0.002)
+                    self.conversation.newline()
+
+                self.conversation.newline()
+
+            if len(entities["last"]) > 0:
+                for entity in entities["last"]:
+                    self.conversation.type(f"    {entity}".ljust(60), delay=0.0001)
+                    self.conversation.type("[last]", delay=0.002)
+                    self.conversation.newline()
+
+                self.conversation.newline()
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(f"usage: {self.configuration.command} list entities\n")
+        self.conversation.newline()
+        exit(1)

command/Merge.py

@@ -0,0 +1,35 @@
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class Merge(BaseCommand):
+    def execute(self):
+        self.conversation.display_project(self.configuration.project.name)
+
+        if self.memory.last is None or "entities" not in self.memory.last:
+            self.conversation.type("No bueno. There is nothing to merge.\n\n")
+            exit(1)
+
+        if self.memory.entities is None:
+            self.memory.entities = []
+
+        entity_map = {}
+        for i in range(len(self.memory.entities)):
+            entity_map[self.memory.entities[i]["name"]] = i
+
+        for entity in self.memory.last["entities"]:
+            if entity["name"] not in entity_map:
+                self.memory.entities.append(entity)
+            else:
+                self.memory.entities[entity_map[entity["name"]]] = entity
+
+            self.conversation.type(f"[Merged] {entity['name']}\n")
+
+        self.memory.remember_entities(self.memory.entities)
+        self.memory.forget_last()
+        self.memory.last = None
+
+        self.conversation.newline()

command/Model.py

@@ -0,0 +1,42 @@
+import sys
+
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Model(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        entity = self.memory.recall_stored_entity(sys.argv[2])
+        if entity is None:
+            self.conversation.not_sure_no_entity(
+                self.configuration.project.name, sys.argv[2]
+            )
+            exit(1)
+
+        time_keeper = TimeKeeper()
+
+        cli = Cli(self.configuration)
+        response = cli.code_models([entity["name"]])
+
+        Dev(self.configuration).model(
+            response["code"][0]["entity"]["name"], response["code"][0]["definition"]
+        )
+
+        print(response["code"][0]["definition"])
+        time_keeper.display()
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} model [entity name]\n"
+            + "  where [entity name] is one of the entities that exists "
+            + "in this project\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Models.py

@@ -0,0 +1,31 @@
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Models(BaseCommand):
+    def execute(self):
+        entities = []
+        if self.memory.entities is not None:
+            for entity in self.memory.entities:
+                entities.append(entity["name"])
+
+        if len(entities) == 0:
+            self.conversation.cant_no_entities(self.configuration.project.name)
+            exit(1)
+
+        time_keeper = TimeKeeper()
+
+        cli = Cli(self.configuration)
+        response = cli.code_models(entities)
+
+        for entry in response["code"]:
+            Dev(self.configuration).model(entry["entity"]["name"], entry["definition"])
+
+            if self.conversation.muted() is False:
+                print(entry["definition"])
+
+        if self.conversation.muted() is False:
+            time_keeper.display()

command/Modify.py

@@ -0,0 +1,43 @@
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class Modify(BaseCommand):
+    def execute(self):
+        if len(sys.argv) < 4:
+            self.usage()
+
+        entity = self.memory.recall_entity(sys.argv[2])
+        if entity is None:
+            self.conversation.not_sure_no_entity(
+                self.configuration.project.name, sys.argv[2]
+            )
+            exit(1)
+
+        cli = Cli(self.configuration)
+
+        response = cli.modeler_entity_modify(
+            self.configuration.project.modeler.version,
+            self.configuration.project.description,
+            entity,
+            " ".join(sys.argv[3:]),
+        )
+
+        self.memory.remember_last(response)
+
+        print(response["entities"][0]["definition"])
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} "
+            + "modify [entity name] [instructions]\n"
+            + "  where [entity name] is one of the entities that exists in "
+            + "this project\n"
+            + "  and [instructions] is natural language describing the changes\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Module.py

@@ -0,0 +1,42 @@
+import re
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class Module(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        if not re.search("^[a-z0-9]+$", sys.argv[2]):
+            self.conversation.display_project(self.configuration.project.name)
+            self.conversation.type("[module name] should only contain ^[a-z0-9]+$.\n\n")
+            return True
+
+        cli = Cli(self.configuration)
+
+        response = cli.modeler_module(
+            self.configuration.project.modeler.version,
+            self.configuration.project.description,
+            sys.argv[2],
+        )
+
+        self.memory.remember_last(response)
+
+        for entity in response["entities"]:
+            print(entity["definition"])
+            self.conversation.newline()
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} module [module name]\n"
+            + "  where [module name] is the name of the module I should create for "
+            + "this project\n"
+            + "  [module name] ~ ^[a-z0-9]+$\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/New.py

@@ -0,0 +1,38 @@
+import os
+import re
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class New(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        if sys.argv[2] != "project":
+            self.usage()
+
+        self.conversation.new_project(self.configuration)
+        project_name = self.conversation.prompt_project()
+        if project_name in self.configuration.settings:
+            self.conversation.project_already_exists(project_name)
+            exit(1)
+
+        project_description = self.conversation.prompt_description(project_name)
+
+        self.configuration.set_project_env(project_name)
+        self.configuration.append_project_to_conf(project_name, project_description)
+
+        self.conversation.configure_new_project(self.configuration)
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} new [thing]\n"
+            + '  where [thing] can only be "project", for now\n'
+        )
+        self.conversation.newline()
+        exit(1)