gibson-cli 0.1.0__py3-none-any.whl

api/BaseApi.py

@@ -0,0 +1,45 @@
+import requests
+
+
+class BaseApi:
+    def get_headers(self):
+        raise NotImplementedError
+
+    def _get(self, end_point):
+        r = requests.get(self.get_url(end_point), headers=self.get_headers())
+
+        self.__raise_for_status(r)
+
+        return r.json()
+
+    def _post(self, end_point, json: dict):
+        r = requests.post(
+            self.get_url(end_point), headers=self.get_headers(), json=json
+        )
+
+        self.__raise_for_status(r)
+
+        return r
+
+    def _put(self, end_point, json: dict):
+        r = requests.put(self.get_url(end_point), headers=self.get_headers(), json=json)
+
+        self.__raise_for_status(r)
+
+        return r
+
+    def __raise_for_status(self, r):
+        try:
+            r.raise_for_status()
+        except:
+            try:
+                message = r.json()
+
+                print("=" * 78)
+                print("Raw Response:\n")
+                print(message)
+                print("\n" + "=" * 78)
+            except requests.exceptions.JSONDecodeError:
+                pass
+
+            raise

api/Cli.py

@@ -0,0 +1,248 @@
+import os
+import requests
+
+from services.auth.Server import Server as AuthServer
+from core.Configuration import Configuration
+from lang.Python import Python
+from core.Memory import Memory
+
+from .BaseApi import BaseApi
+
+
+class Cli(BaseApi):
+    API_ENV = os.environ.get("GIBSONAI_API_ENV", "staging")
+    PREFIX = "cli"
+    VERSION = "v1"
+
+    def __init__(self, configuration: Configuration):
+        super().__init__()
+        self.configuration = configuration
+
+    def code_api(self):
+        return self._post(
+            "code/api",
+            self.__structure_context_payload(self.configuration, with_stored=True),
+        ).json()
+
+    def code_base(self):
+        return self._post(
+            "code/base",
+            self.__structure_context_payload(self.configuration, with_stored=True),
+        ).json()
+
+    def code_model_attributes(self, model_name, instructions):
+        payload = self.__structure_context_payload(self.configuration)
+        payload["model"] = {"name": model_name}
+        payload["q"] = instructions
+
+        return self._post("code/model/attributes", payload).json()
+
+    def code_models(self, entities: list):
+        payload = self.__structure_context_payload(self.configuration, with_stored=True)
+        payload["entities"] = entities
+
+        return self._post("code/models", payload).json()
+
+    def code_schemas(self, entities: list):
+        payload = self.__structure_context_payload(self.configuration, with_stored=True)
+        payload["entities"] = entities
+
+        return self._post("code/schemas", payload).json()
+
+    def code_testing(self, entities: list):
+        payload = self.__structure_context_payload(self.configuration, with_stored=True)
+        payload["entities"] = entities
+
+        return self._post("code/testing", payload).json()
+
+    def code_writer_entity_modifier(self, context, name, definition, instructions):
+        payload = self.__structure_context_payload(self.configuration)
+        payload["context"] = context
+        payload["entity"] = {"definition": definition, "name": name}
+        payload["q"] = instructions
+
+        return self._post("code/writer/entity/modifier", payload).json()
+
+    def code_writer_schema_context(self):
+        return self._post(
+            "code/writer/schema/context",
+            self.__structure_context_payload(self.configuration, with_stored=True),
+        ).json()
+
+    def get_client_id(self):
+        return {
+            "local": "9b0cbebd-3eb4-47be-89ac-4aa589316ff4",
+            "staging": "02459e16-f356-4c01-b689-59847ed04b0a",
+            "production": "da287371-240b-4b53-bfde-4b1581cca62a",
+        }[self.API_ENV]
+
+    def get_api_domain(self):
+        return {
+            "local": "http://localhost:8000",
+            "staging": "https://staging-api.gibsonai.com",
+            "production": "https://api.gibsonai.com",
+        }[self.API_ENV]
+
+    def get_app_domain(self):
+        return {
+            "local": "http://localhost:5173",
+            "staging": "https://staging-app.gibsonai.com",
+            "production": "https://app.gibsonai.com",
+        }[self.API_ENV]
+
+    def get_headers(self):
+        headers = {
+            "X-Gibson-Client-ID": self.get_client_id(),
+            "X-Gibson-API-Key": self.configuration.project.api.key,
+        }
+
+        token = self.configuration.get_access_token()
+        if token is not None:
+            headers["Authorization"] = f"Bearer {token}"
+
+        return headers
+
+    def get_url(self, end_point):
+        return f"{self.get_api_domain()}/{self.VERSION}/{self.PREFIX}/{end_point}"
+
+    def import_(self):
+        return self._get("import")
+
+    def llm_query(self, instructions, has_file, has_python, has_sql):
+        project_config = self.configuration.project
+        r = self._post(
+            "llm/query",
+            {
+                "content": {
+                    "meta": {
+                        "file": int(has_file),
+                        "python": int(has_python),
+                        "sql": int(has_sql),
+                    }
+                },
+                "frameworks": {
+                    "api": project_config.code.frameworks.api,
+                    "model": project_config.code.frameworks.model,
+                    "revision": project_config.code.frameworks.revision,
+                    "schema_": project_config.code.frameworks.schema,
+                    "test": project_config.code.frameworks.test,
+                },
+                "q": instructions,
+            },
+        )
+
+        return r.json()
+
+    def login(self):
+        token = AuthServer(self.get_app_domain()).get_token()
+        return token
+
+    def modeler_entity_modify(
+        self, modeler_version, project_description, entity: dict, modifications: str
+    ):
+        r = self._put(
+            "modeler/entity/modify",
+            {
+                "entity": entity,
+                "modeler": {"version": modeler_version},
+                "modifications": modifications,
+                "project": {"description": project_description},
+            },
+        )
+
+        return r.json()
+
+    def modeler_entity_remove(self, modeler_version, entities: list, entity_name):
+        r = self._put(
+            "modeler/entity/remove",
+            {
+                "entity": {"name": entity_name},
+                "modeler": {"version": modeler_version},
+                "schema_": entities,
+            },
+        )
+
+        return r.json()
+
+    def modeler_entity_rename(self, modeler_version, entities: list, current, new):
+        r = self._put(
+            "modeler/entity/rename",
+            {
+                "entity": {"current": current, "new": new},
+                "modeler": {"version": modeler_version},
+                "schema_": entities,
+            },
+        )
+
+        return r.json()
+
+    def modeler_module(self, modeler_version, project_description, module):
+        r = self._post(
+            "modeler/module",
+            {
+                "modeler": {"version": modeler_version},
+                "module": module,
+                "project": {"description": project_description},
+            },
+        )
+
+        return r.json()
+
+    def modeler_openapi(self, modeler_version, contents):
+        r = self._post(
+            "modeler/openapi",
+            {"contents": contents, "modeler": {"version": modeler_version}},
+        )
+
+        return r.json()
+
+    def modeler_reconcile(self, modeler_version, entities: list):
+        r = self._post(
+            "modeler/reconcile",
+            {"modeler": {"version": modeler_version}, "schema_": entities},
+        )
+
+        return r.json()
+
+    def __structure_context_payload(
+        self,
+        with_last=False,
+        with_merged=False,
+        with_stored=False,
+    ):
+        project_config = self.configuration.project
+        payload = {
+            "api": {
+                "prefix": project_config.dev.api.prefix,
+                "version": project_config.dev.api.version,
+            },
+            "frameworks": {
+                "api": project_config.code.frameworks.api,
+                "model": project_config.code.frameworks.model,
+                "revision": project_config.code.frameworks.revision,
+                "schema_": project_config.code.frameworks.schema,
+                "test": project_config.code.frameworks.test,
+            },
+            "language": project_config.code.language,
+            "path": {
+                "api": Python().make_import_path(project_config.dev.api.path),
+                "base": Python().make_import_path(project_config.dev.base.path),
+                "custom": {
+                    "model": {
+                        "class_": project_config.code.custom.model_class,
+                        "path": project_config.code.custom.model_path,
+                    }
+                },
+                "model": Python().make_import_path(project_config.dev.model.path),
+                "schema_": Python().make_import_path(project_config.dev.schema.path),
+            },
+        }
+
+        if with_last is True:
+            payload["schema_"] = Memory(self.configuration).recall_last()["entities"]
+        elif with_merged is True:
+            payload["schema_"] = Memory(self.configuration).recall_merged()
+        elif with_stored is True:
+            payload["schema_"] = Memory(self.configuration).recall_entities()
+
+        return payload

bin/gibson.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+from core.CommandRouter import CommandRouter
+from core.Configuration import Configuration
+
+
+def main():
+    configuration = Configuration()
+    if configuration.settings is None:
+        configuration.initialize()
+    else:
+        router = CommandRouter(configuration).run()
+
+
+if __name__ == "__main__":
+    main()

command/Api.py

@@ -0,0 +1,31 @@
+from api.Cli import Cli
+from dev.Dev import Dev
+from services.code.customization.Authenticator import Authenticator
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Api(BaseCommand):
+    def execute(self):
+        time_keeper = TimeKeeper()
+        dev = Dev(self.configuration)
+
+        cli = Cli(self.configuration)
+        response = cli.code_api()
+
+        if self.customization_management_is_enabled() is True:
+            authenticator = Authenticator(self.configuration).preserve()
+
+        try:
+            for entry in response["code"]:
+                dev.api_component(entry["name"], entry["definition"])
+
+                if self.conversation.muted() is False:
+                    print(entry["definition"])
+        finally:
+            if self.customization_management_is_enabled() is True:
+                authenticator.restore()
+
+        if self.conversation.muted() is False:
+            time_keeper.display()

command/Base.py

@@ -0,0 +1,28 @@
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Base(BaseCommand):
+    def execute(self):
+        entities = self.memory.recall_merged()
+        if len(entities) == 0:
+            self.conversation.cant_no_entities(self.configuration.project.name)
+            exit(1)
+
+        time_keeper = TimeKeeper()
+        dev = Dev(self.configuration)
+
+        cli = Cli(self.configuration)
+        response = cli.code_base()
+
+        for entry in response["code"]:
+            dev.base_component(entry["name"], entry["definition"])
+
+            if self.conversation.muted() is False:
+                print(entry["definition"])
+
+        if self.conversation.muted() is False:
+            time_keeper.display()

command/BaseCommand.py

@@ -0,0 +1,26 @@
+from core.Configuration import Configuration
+from core.Memory import Memory
+
+
+class BaseCommand:
+    def __init__(self, configuration: Configuration):
+        self.__enable_customization_management = True
+        self.configuration = configuration
+        self.conversation = self.configuration.conversation
+        self.memory = Memory(self.configuration)
+
+    def customization_management_is_enabled(self):
+        return self.__enable_customization_management == True
+
+    def disable_customization_management(self):
+        self.__enable_customization_management = False
+        return self
+
+    def execute(self):
+        raise NotImplementedError
+
+    def num_required_args(self):
+        raise NotImplementedError
+
+    def usage(self):
+        return self

command/Build.py

@@ -0,0 +1,69 @@
+import sys
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from db.TableExceptions import TableExceptions
+
+from .BaseCommand import BaseCommand
+
+
+class Build(BaseCommand):
+    def __build_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()
+
+        self.conversation.type("Connected to datastore...\n")
+
+        try:
+            if self.configuration.project.datastore.type == "mysql":
+                table_exceptions = TableExceptions().mysql()
+                session.execute("set foreign_key_checks = 0")
+                self.conversation.type("  foreign key checks have been disabled\n")
+
+            tables = session.execute("show tables").all()
+            if len(tables) > 0:
+                self.conversation.type("  dropping existing entities\n")
+
+                for table in tables:
+                    if table not in table_exceptions:
+                        self.conversation.type(f"    {table[0]}\n", delay=0.002)
+                        session.execute(f"drop table if exists {table[0]}")
+
+            self.conversation.type("  building entities\n")
+
+            for entity in self.memory.entities:
+                self.conversation.type(f"    {entity['name']}\n", delay=0.002)
+                session.execute(entity["definition"])
+        finally:
+            if self.configuration.project.datastore.type == "mysql":
+                session.execute("set foreign_key_checks = 1")
+                self.conversation.type("  foreign key checks have been enabled\n")
+
+        self.conversation.newline()
+
+    def execute(self):
+        if len(sys.argv) != 3 or sys.argv[2] != "datastore":
+            self.usage()
+
+        if self.memory.entities is None or len(self.memory.entities) == 0:
+            self.no_entities()
+
+        self.__build_datastore()
+
+    def no_entities(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            "Ahhh man. I would love to but there aren't any entities.\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} build datastore\n")
+        self.conversation.newline()
+        exit(1)

command/Code.py

@@ -0,0 +1,198 @@
+import os
+import re
+import sys
+from string import Template
+
+from api.Cli import Cli
+from core.Configuration import Configuration
+from display.Header import Header
+from display.WorkspaceFooter import WorkspaceFooter
+from display.WorkspaceHeader import WorkspaceHeader
+from services.code.context.schema.Manager import Manager as CodeContextSchemaManager
+from structure.Entity import Entity
+
+from .BaseCommand import BaseCommand
+from .Merge import Merge
+from .Rewrite import Rewrite
+
+
+class Code(BaseCommand):
+    CODE_WRITER_ENTITY_MODIFIER_NOOP = ""
+
+    def __init__(self, configuration: Configuration):
+        super().__init__(configuration)
+        self.__context = None
+
+    def __add_foreign_key(self, entity, entity_name):
+        entity_keys = self.__context.get_entity_keys(entity_name)
+        if entity_keys is None:
+            self.conversation.type(
+                f'\nThe entity you referenced, "{entity_name}", does not exist.\n'
+            )
+            self.conversation.wait()
+            return False
+
+        best_sql_foreign_key = entity_keys.best_sql_foreign_key()
+        if best_sql_foreign_key is None:
+            self.conversation.type(
+                f'\nYou cannot make a foreign key to "{entity_name}".\n'
+                + "It does not have primary or unique keys.\n"
+            )
+            self.conversation.wait()
+            return False
+
+        foreign_key, index, data_types = best_sql_foreign_key
+
+        for i in range(len(foreign_key.attributes)):
+            entity.add_attribute(
+                foreign_key.attributes[i],
+                data_types[i],
+                after="uuid",
+                before="date_created",
+            )
+
+        entity.add_foreign_key(foreign_key)
+        entity.add_index(index)
+
+        return True
+
+    def configure_definition(self):
+        existing_entity = self.memory.recall_entity(sys.argv[3])
+        if existing_entity is not None:
+            return existing_entity["definition"]
+
+        parts = sys.argv[3].split("_")
+        if len(parts) > 1 and parts[1] == "ref":
+            # This is a reference table implementation. We will handle this here.
+            with open(self.get_default_ref_table_template_path()) as f:
+                definition = Template(f.read()).substitute({"entity_name": sys.argv[3]})
+
+                self.memory.append_last({"definition": definition, "name": sys.argv[3]})
+
+                self.conversation.type(
+                    "Reference table created and stored in last memory. What's next?\n"
+                )
+                self.conversation.newline()
+
+                exit(1)
+
+        with open(self.get_default_table_template_path()) as f:
+            return Template(f.read()).substitute({"entity_name": sys.argv[3]})
+
+    def execute(self):
+        if len(sys.argv) != 4 or sys.argv[2] not in ["entity"]:
+            self.usage()
+
+        cli = Cli(self.configuration)
+
+        self.conversation.display_project(self.configuration.project.name)
+        definition = self.configure_definition()
+
+        self.conversation.c64_boot_search()
+
+        self.__context = CodeContextSchemaManager().from_code_writer_schema_context(
+            cli.code_writer_schema_context()
+        )
+
+        self.conversation.c64_boot_loading()
+
+        data = cli.code_writer_entity_modifier(
+            self.__context.json,
+            sys.argv[3],
+            definition,
+            self.CODE_WRITER_ENTITY_MODIFIER_NOOP,
+        )
+        entity = Entity().import_from_struct(data)
+
+        self.conversation.c64_ready_run()
+
+        while True:
+            self.__render_workspace(entity, data["code"][0]["definition"])
+
+            input_ = input("> ")
+            if input_ in [".", ":q", ":w"]:
+                self.conversation.newline()
+
+                if input_ == ":q":
+                    exit(1)
+
+                self.memory.remember_last({"entities": [data["entity"]]})
+
+                if input_ == ".":
+                    self.conversation.type(
+                        "Damn we write good code. I stored this in last memory. "
+                        + "Your move.\n"
+                    )
+                else:
+                    self.conversation.mute()
+                    Merge(self.configuration).execute()
+                    self.conversation.unmute()
+
+                    Rewrite(self.configuration, wipe=False).execute()
+
+                self.conversation.newline()
+
+                exit(1)
+            elif input_ == "":
+                continue
+
+            talk_to_gibsonai = True
+
+            parts = input_.split(" ")
+            if parts[0] == "fk":
+                input_ = self.CODE_WRITER_ENTITY_MODIFIER_NOOP
+                if not self.__add_foreign_key(entity, parts[1]):
+                    # If the entity was not modified, likely because the table
+                    # referenced does not exist or does not contain indexes which
+                    # can be used for a foreign key, do not waste the network call
+                    # to GibsonAI since there is nothing to do.
+                    talk_to_gibsonai = False
+
+            if talk_to_gibsonai is True:
+                data = cli.code_writer_entity_modifier(
+                    self.__context.json,
+                    data["entity"]["name"],
+                    entity.create_statement(),
+                    input_,
+                )
+                entity = Entity().import_from_struct(data)
+
+    def get_default_ref_table_template_path(self):
+        return os.path.dirname(__file__) + "/../data/default-ref-table.tmpl"
+
+    def get_default_table_template_path(self):
+        return os.path.dirname(__file__) + "/../data/default-table.tmpl"
+
+    def __render_workspace(self, entity: Entity, model):
+        self.configuration.platform.cmd_clear()
+
+        print("")
+        print(WorkspaceHeader().render(self.configuration.project.name))
+
+        print("")
+        print(Header().render("SQL"))
+        print("")
+        print(entity.create_statement())
+
+        print("")
+        print(Header().render("Model"))
+        print("")
+        print(model)
+
+        print("")
+        print(WorkspaceFooter().render())
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} code [thing] [name]\n"
+            + '  where [thing] can only be "entity", for now\n'
+            + "  and [name] is what you want [thing] to be called\n"
+        )
+        self.conversation.newline()
+        self.conversation.type(
+            '  To create a new entity called "user":\n'
+            "      gibson code entity user\n"
+        )
+        self.conversation.newline()
+        exit(1)