gibson-cli 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

gibson/command/rewrite/Rewrite.py

@@ -3,17 +3,16 @@ import shutil
 import sys
 
 import gibson.core.Colors as Colors
+from gibson.command.BaseCommand import BaseCommand
+from gibson.command.code.Api import Api
+from gibson.command.code.Base import Base
+from gibson.command.code.Models import Models
+from gibson.command.code.Schemas import Schemas
+from gibson.command.code.Tests import Tests
 from gibson.core.Configuration import Configuration
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.services.code.customization.CustomizationManager import CustomizationManager
 
-from ..BaseCommand import BaseCommand
-from .Api import Api
-from .Base import Base
-from .Models import Models
-from .Schemas import Schemas
-from .Tests import Tests
-
 
 class Rewrite(BaseCommand):
     def __init__(
@@ -29,10 +28,8 @@ class Rewrite(BaseCommand):
         self.arguments = ["api", "base", "models", "schemas", "tests"]
 
     def execute(self):
-        if len(sys.argv) != 3:
+        if len(sys.argv) == 2:
             self.write()
-        elif sys.argv[2] in self.arguments:
-            self.write(sys.argv[2])
         else:
             self.usage()
 
@@ -66,7 +63,8 @@ class Rewrite(BaseCommand):
                 time_keeper = TimeKeeper()
                 self.conversation.type("  API      ")
                 self.conversation.mute()
-                # Disable customization management here so we don't process this twice (see finally block)
+                # Disable customization management here so we don't process this
+                # twice (see finally block).
                 Api(self.configuration).disable_customization_management().execute()
                 self.conversation.unmute()
                 self.conversation.type(time_keeper.get_display())
@@ -120,8 +118,5 @@ class Rewrite(BaseCommand):
         self.conversation.type(
             f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('rewrite')} {Colors.hint('rewrite all code')}\n"
         )
-        self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('rewrite')} {Colors.arguments(self.arguments)} {Colors.hint('rewrite only the specified code')}\n"
-        )
         self.conversation.newline()
         exit(1)

gibson/command/tests/test_command_Conf.py

@@ -4,6 +4,7 @@ from gibson.core.Configuration import Configuration
 
 def test_get_configuration_keys():
     assert Conf(Configuration()).get_configuration_keys() == [
+        "id",
         "api::key",
         "code::custom::model::class",
         "code::custom::model::path",

gibson/conf/Project.py

@@ -8,6 +8,7 @@ from .Paths import ProjectPaths
 
 class Project:
     def __init__(self):
+        self.id = None
         self.api = Api()
         self.code = Code()
         self.datastore = Datastore()

gibson/core/Configuration.py

@@ -1,9 +1,7 @@
 import errno
 import json
 import os
-import shutil
 import sys
-import time
 
 from gibson.conf.Dependencies import Dependencies
 from gibson.conf.Paths import ConfigPaths
@@ -61,8 +59,11 @@ class Configuration:
             "production": "da287371-240b-4b53-bfde-4b1581cca62a",
         }[self.API_ENV]
 
-    def append_project_to_conf(self, project_name, project_description):
+    def append_project_to_conf(
+        self, project_name, project_description, project_id=None
+    ):
         self.project = Project()
+        self.project.id = project_id
         self.project.api.key = "FIXME"
         self.project.name = project_name
         self.project.datastore.type = "mysql"
@@ -71,62 +72,11 @@ class Configuration:
 
         dependencies = Dependencies().compute()
 
-        section = f""""{self.project.name}": {{
-    "api": {{
-        "key": "{self.project.api.key}"
-    }},
-    "code": {{
-        "custom": {{
-            "model": {{
-                "class": None,
-                "path": None
-            }}
-        }},
-        "frameworks": {{
-            "api": "{dependencies.api}",
-            "model": "{dependencies.model}",
-            "revision": "{dependencies.revision}",
-            "schema": "{dependencies.schema}",
-            "test": "{dependencies.test}",
-        }},
-        "language": "python"
-    }},
-    "datastore": {{
-        "type": "{self.project.datastore.type}",
-        "uri": "{self.project.datastore.uri}"
-    }},
-    "dev": {{
-        "active": False,
-        "api": {{
-            "path": None,
-            "prefix": "-",
-            "version": "v1"
-        }},
-        "base": {{
-            "path": None
-        }},
-        "model": {{
-            "path": None
-        }},
-        "schema": {{
-            "path": None
-        }}
-    }},
-    "meta": {{
-        "project": {{
-            "description": "{self.project.description}"
-        }},
-        "version": {self.VERSION}
-    }},
-    "modeler": {{
-        "version": "generic-v7"
-    }}
-}}"""
-
         if self.settings is None:
             self.settings = {}
 
         self.settings[self.project.name] = {
+            "id": self.project.id,
             "api": {"key": self.project.api.key},
             "code": {
                 "custom": {"model": {"class": None, "path": None}},
@@ -161,7 +111,10 @@ class Configuration:
 
         self.write_config()
 
-        return section
+        # Return a printable version of the project configuration
+        return json.dumps(
+            {self.project.name: self.settings[self.project.name]}, indent=2
+        )
 
     def ask_for_path(self, current_value):
         while True:
@@ -243,6 +196,12 @@ class Configuration:
 
                 self.settings[project_name] = conf
 
+            if conf["meta"]["version"] == 2:
+                if "id" not in conf:
+                    # Add the project ID and make it the first key in the project config
+                    conf = dict({"id": None}, **conf)
+                    self.settings[project_name] = conf
+
         self.write_config()
 
         return self
@@ -256,8 +215,11 @@ class Configuration:
                 raise
 
     def display_project(self):
+        project_name = "[None]"
         if self.project is not None:
-            self.conversation.display_project(self.project.name)
+            project_name = self.project.name
+
+        self.conversation.display_project(project_name)
 
     def get_access_token(self):
         try:
@@ -295,7 +257,7 @@ class Configuration:
 
         self.conversation.message_project_setup()
         project_name = self.conversation.prompt_project()
-        project_description = self.conversation.prompt_description(project_name)
+        project_description = self.conversation.prompt_project_description(project_name)
 
         self.conversation.message_new_project(project_name)
         self.conversation.pause()
@@ -420,6 +382,7 @@ class Configuration:
         if config is None or self.project is None:
             return self
 
+        self.project.id = config.get("id")
         self.project.api.key = config["api"]["key"]
         self.project.code.custom.model_class = config["code"]["custom"]["model"][
             "class"

gibson/core/Conversation.py

@@ -82,6 +82,9 @@ class Conversation:
         )
         return self
 
+    def file_not_found(self, file_path):
+        self.type(f'404, My Friend. Cannot find file "{file_path}".\n')
+
     def gibsonai_project_not_set(self, configuration):
         self.type(
             "\nYou have to set the environment variable GIBSONAI_PROJECT "
@@ -227,13 +230,6 @@ class Conversation:
         )
         self.newline()
 
-    def prompt_description(self, project_name):
-        while True:
-            self.type(f"Tell me about {project_name}. Don't be shy > ")
-            user_prompt = input("")
-            if len(user_prompt) > 0:
-                return user_prompt
-
     def prompt_module(self):
         while True:
             self.type("Module Name [a-z0-9] > ")
@@ -248,6 +244,28 @@ class Conversation:
             if re.search("^[A-Za-z0-9_-]+$", user_prompt):
                 return user_prompt
 
+    def prompt_project_description(self, project_name):
+        while True:
+            self.type(f"Tell me about {project_name}. Don't be shy > ")
+            user_prompt = input("")
+            if len(user_prompt) > 0:
+                return user_prompt
+
+    def prompt_project_id(self):
+        while True:
+            self.type("Project ID (UUID) > ")
+            user_prompt = input("")
+
+            if user_prompt == "":
+                return None
+
+            if re.search(
+                "^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$",
+                user_prompt,
+                re.IGNORECASE,
+            ):
+                return user_prompt
+
     def raw_llm_response(self):
         print("\n+" + "-" * 75 + "+")
         print("| Raw LLM Response" + " " * 58 + "|")

gibson/data/bash-completion.tmpl

@@ -57,15 +57,14 @@ __gibson_completions() {
     case "${previous_word}" in
     gibson) __gibson_commands_and_options ;;
     auth) __gibson_generate_completion "login logout" ;;
-    code) __gibson_generate_completion "entity model schema tests" ;;
-    conf) __gibson_generate_completion "api::key code::custom::model::class code::custom::path datastore::uri datastore::type" ;;
+    code) __gibson_generate_completion "api base entity models schemas tests" ;;
+    conf) __gibson_generate_completion "id api::key code::custom::model::class code::custom::model::path code::frameworks::api code::frameworks::model code::frameworks::revision code::frameworks::schema code::frameworks::test code::language datastore::type datastore::uri meta::project::description" ;;
     dev) __gibson_generate_completion "on off" ;;
     forget) __gibson_generate_completion "stored last all" ;;
-    import) __gibson_generate_completion "api datastore openapi" ;;
+    import) __gibson_generate_completion "api mysql pg_dump openapi" ;;
     list) __gibson_generate_completion "entities projects" ;;
     new) __gibson_generate_completion "project module entity" ;;
     rename) __gibson_generate_completion "entity" ;;
-    rewrite) __gibson_generate_completion "api base models schemas tests" ;;
     esac
 
     return 0

gibson/data/postgresql/default-ref-table.tmpl

@@ -0,0 +1,4 @@
+create table $entity_name (
+  id bigint primary key generated always as identity,
+  value text unique
+)

gibson/data/postgresql/default-table.tmpl

@@ -0,0 +1,5 @@
+create table $entity_name (
+  id bigint primary key generated always as identity,
+  uuid varchar(36) unique not null,
+  date_created timestamptz with time zone default now() not null
+)

gibson/db/TableExceptions.py

@@ -2,5 +2,8 @@ class TableExceptions:
     def mysql(self):
         return self.universal()
 
+    def postgresql(self):
+        return self.universal()
+
     def universal(self):
         return ["alembic_version"]

gibson/db/tests/test_db_TableExceptions.py

@@ -7,3 +7,7 @@ def test_universal():
 
 def test_mysql():
     assert TableExceptions().mysql() == ["alembic_version"]
+
+
+def test_postgresql():
+    assert TableExceptions().postgresql() == ["alembic_version"]

gibson/services/code/context/schema/EntityKeys.py

@@ -1,6 +1,6 @@
-from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
-from gibson.structure.keys.ForeignKey import ForeignKey
-from gibson.structure.keys.Index import Index
+from gibson.structure.mysql.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.mysql.keys.ForeignKey import ForeignKey
+from gibson.structure.mysql.keys.Index import Index
 
 
 class EntityKeys:

gibson/services/code/context/schema/tests/test_code_context_schema_EntityKeys.py

@@ -1,7 +1,7 @@
 from gibson.services.code.context.schema.EntityKeys import EntityKeys
-from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
-from gibson.structure.keys.ForeignKey import ForeignKey
-from gibson.structure.keys.Index import Index
+from gibson.structure.mysql.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.mysql.keys.ForeignKey import ForeignKey
+from gibson.structure.mysql.keys.Index import Index
 
 
 def test_best_sql_foreign_key_no_match():

gibson/structure/Entity.py

@@ -1,115 +1,18 @@
-from gibson.structure.keys.ForeignKey import ForeignKey
-from gibson.structure.keys.Index import Index
+from gibson.structure.mysql.Entity import Entity as MysqlEntity
+from gibson.structure.postgresql.Entity import Entity as PostgresqlEntity
 
 
 class Entity:
-    def __init__(self):
-        self.attributes = None
-        self.constraints = None
-        self.keys = None
-        self.name = None
-        self.parameters = None
+    TYPE_MYSQL = "mysql"
+    TYPE_POSTGRESQL = "postgresql"
 
-    def add_attribute(self, name, data_type, after=None, before=None):
-        was_added = False
+    def instantiate(self, datastore_type: str):
+        if datastore_type not in [self.TYPE_MYSQL, self.TYPE_POSTGRESQL]:
+            raise RuntimeError(f'unrecognized datastore type "{datastore_type}"')
 
-        json = {
-            "as": None,
-            "bytes": None,
-            "check": None,
-            "comment": None,
-            "data_type": {
-                "formatted": data_type,
-                "raw": data_type,
-            },
-            "default": None,
-            "extra": {"increment": {"auto": None}},
-            "key": {"index": None, "primary": None, "unique": None},
-            "length": None,
-            "name": name,
-            "nullable": None,
-            "numeric": {
-                "precision": None,
-                "scale": None,
-            },
-            "on": None,
-            "reference": None,
-            "sql": f"{name} {data_type}",
-            "unsigned": None,
-            "values": None,
-        }
+        if datastore_type == self.TYPE_MYSQL:
+            return MysqlEntity()
+        elif datastore_type == self.TYPE_POSTGRESQL:
+            return PostgresqlEntity()
 
-        attributes = []
-        for attribute in self.attributes:
-            if was_added is False and attribute["name"] == after:
-                was_added = True
-                attributes.append(attribute)
-                attributes.append(json)
-            elif was_added is False and attribute["name"] == before:
-                was_added = True
-                attributes.append(json)
-                attributes.append(attribute)
-            else:
-                attributes.append(attribute)
-
-        if was_added is False:
-            attributes.append(json)
-
-        self.attributes = attributes
-        return self
-
-    def add_foreign_key(self, foreign_key: ForeignKey):
-        self.keys["foreign"].append(foreign_key.json())
-        return self
-
-    def add_index(self, index: Index):
-        self.keys["index"].append(index.json())
-        return self
-
-    def create_statement(self):
-        parts = []
-        for attribute in self.attributes:
-            parts.append("    " + attribute["sql"])
-
-        if self.keys["primary"] is not None:
-            parts.append("    " + self.keys["primary"]["sql"])
-
-        for unique_key in self.keys["unique"]:
-            parts.append("    " + unique_key["sql"])
-
-        for index in self.keys["index"]:
-            parts.append("    " + index["sql"])
-
-        for fk in self.keys["foreign"]:
-            parts.append("    " + fk["sql"])
-
-        for check in self.constraints["check"]:
-            parts.append("    " + check["sql"])
-
-        parameters = self.parameters["sql"]
-        if parameters not in [None, ""]:
-            parameters = " " + parameters
-        else:
-            parameters = ""
-
-        return (
-            f"create table if not exists {self.name}(\n"
-            + ",\n".join(parts)
-            + f"\n){parameters}"
-        )
-
-    def import_from_struct(self, data: dict):
-        if "name" in data and "struct" in data:
-            self.name = data["name"]
-
-            for key in data["struct"].keys():
-                setattr(self, key, data["struct"][key])
-        elif "entity" in data and "struct" in data["entity"]:
-            self.name = data["entity"]["name"]
-
-            for key in data["entity"]["struct"].keys():
-                setattr(self, key, data["entity"]["struct"][key])
-        else:
-            raise RuntimeError("cannot import from struct, incorrect data format")
-
-        return self
+        raise NotImplementedError(f'"{datastore_type}" is not currently supported')

gibson/structure/mysql/Entity.py

@@ -0,0 +1,117 @@
+from gibson.structure.mysql.keys.ForeignKey import ForeignKey
+from gibson.structure.mysql.keys.Index import Index
+
+
+class Entity:
+    def __init__(self):
+        self.attributes = None
+        self.constraints = None
+        self.keys = None
+        self.name = None
+        self.table = None
+
+    def add_attribute(self, name, data_type, after=None, before=None):
+        was_added = False
+
+        json = {
+            "check": None,
+            "datastore": {
+                "specifics": {
+                    "as": None,
+                    "bytes": None,
+                    "comment": None,
+                    "extra": {"increment": {"auto": None}},
+                    "on": None,
+                    "reference": None,
+                    "unsigned": None,
+                    "values": None,
+                }
+            },
+            "data_type": {
+                "formatted": data_type,
+                "raw": data_type,
+            },
+            "default": None,
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": name,
+            "nullable": None,
+            "numeric": {
+                "precision": None,
+                "scale": None,
+            },
+            "sql": f"{name} {data_type}",
+        }
+
+        attributes = []
+        for attribute in self.attributes:
+            if was_added is False and attribute["name"] == after:
+                was_added = True
+                attributes.append(attribute)
+                attributes.append(json)
+            elif was_added is False and attribute["name"] == before:
+                was_added = True
+                attributes.append(json)
+                attributes.append(attribute)
+            else:
+                attributes.append(attribute)
+
+        if was_added is False:
+            attributes.append(json)
+
+        self.attributes = attributes
+        return self
+
+    def add_foreign_key(self, foreign_key: ForeignKey):
+        self.keys["foreign"].append(foreign_key.json())
+        return self
+
+    def add_index(self, index: Index):
+        self.keys["index"].append(index.json())
+        return self
+
+    def create_statement(self):
+        parts = []
+        for attribute in self.attributes:
+            parts.append("    " + attribute["sql"])
+
+        if self.keys["primary"] is not None:
+            parts.append("    " + self.keys["primary"]["sql"])
+
+        for unique_key in self.keys["unique"]:
+            parts.append("    " + unique_key["sql"])
+
+        for index in self.keys["index"]:
+            parts.append("    " + index["sql"])
+
+        for fk in self.keys["foreign"]:
+            parts.append("    " + fk["sql"])
+
+        for check in self.constraints["check"]:
+            parts.append("    " + check["sql"])
+
+        parameters = ""
+        if self.table["parameters"] and self.table["parameters"].get("sql"):
+            parameters = " " + self.table["parameters"].get("sql")
+
+        return (
+            f"create table if not exists {self.name}(\n"
+            + ",\n".join(parts)
+            + f"\n){parameters}"
+        )
+
+    def import_from_struct(self, data: dict):
+        if "name" in data and "struct" in data:
+            self.name = data["name"]
+
+            for key in data["struct"].keys():
+                setattr(self, key, data["struct"][key])
+        elif "entity" in data and "struct" in data["entity"]:
+            self.name = data["entity"]["name"]
+
+            for key in data["entity"]["struct"].keys():
+                setattr(self, key, data["entity"]["struct"][key])
+        else:
+            raise RuntimeError("cannot import from struct, incorrect data format")
+
+        return self

gibson/structure/{constraints → mysql/constraints}/ReferenceConstraint.py

@@ -9,9 +9,13 @@ class ReferenceConstraint:
     def json(self):
         return {
             "attributes": self.attributes,
-            "match": self.match,
+            "datastore": {
+                "specifics": {
+                    "match": self.match,
+                }
+            },
+            "entity": {"name": self.references, "schema_": None},
             "on": {"delete": self.on_delete, "update": self.on_update},
-            "references": self.references,
             "sql": self.sql(),
         }
 

gibson/structure/{keys → mysql/keys}/ForeignKey.py

@@ -1,4 +1,4 @@
-from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.mysql.constraints.ReferenceConstraint import ReferenceConstraint
 
 
 class ForeignKey:
@@ -12,11 +12,15 @@ class ForeignKey:
     def json(self):
         return {
             "attributes": self.attributes,
-            "name": self.name,
-            "reference": self.reference.json(),
-            "relationship": {"type": None},
+            "datastore": {
+                "specifics": {
+                    "name": self.name,
+                    "relationship": {"type": None},
+                    "symbol": self.symbol,
+                }
+            },
+            "references": self.reference.json(),
             "sql": self.sql(),
-            "symbol": self.symbol,
         }
 
     def sql(self):

gibson/structure/{keys → mysql/keys}/Index.py

@@ -1,4 +1,4 @@
-from gibson.structure.keys.IndexAttribute import IndexAttribute
+from gibson.structure.mysql.keys.IndexAttribute import IndexAttribute
 
 
 class Index:
@@ -34,9 +34,13 @@ class Index:
     def json(self):
         return {
             "attributes": self.__attribute_name_list,
-            "name": self.name,
+            "datastore": {
+                "specifics": {
+                    "name": self.name,
+                    "using": self.using,
+                }
+            },
             "sql": self.sql(),
-            "using": self.using,
         }
 
     def reset_attributes(self):