gibson-cli 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

gibson/command/code/Entity.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import sys
 from string import Template
@@ -5,11 +7,13 @@ from string import Template
 import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.command.code.Base import Base
 from gibson.command.code.Model import Model
 from gibson.command.code.Schema import Schema
 from gibson.command.code.Test import Test
 from gibson.command.Merge import Merge
 from gibson.core.Configuration import Configuration
+from gibson.core.Diff import additions, diff
 from gibson.core.Spinner import ComputingSpinner, Spinner
 from gibson.display.Header import Header
 from gibson.display.WorkspaceFooter import WorkspaceFooter
@@ -60,34 +64,15 @@ class Entity(BaseCommand):
 
         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):
         cli = Cli(self.configuration)
-
-        self.configuration.require_project()
-        definition = self.configure_definition()
+        entity_name = sys.argv[3]
+        existing_entity = self.memory.recall_entity(entity_name)
+        definition = (
+            existing_entity["definition"]
+            if existing_entity
+            else self.template_definition(entity_name)
+        )
 
         with ComputingSpinner():
             self.__context = CodeContextSchemaManager().from_code_writer_schema_context(
@@ -104,10 +89,20 @@ class Entity(BaseCommand):
                 .instantiate(self.configuration.project.datastore.type)
                 .import_from_struct(data)
             )
+            original_entity = entity if existing_entity else None
+            original_model_code = (
+                data["code"][0]["definition"] if existing_entity else None
+            )
 
         while True:
             try:
-                self.__render_workspace(entity, data["code"][0]["definition"])
+                self.__render_workspace(
+                    original_entity,
+                    entity,
+                    data["code"][0]["name"],
+                    original_model_code,
+                    data["code"][0]["definition"],
+                )
                 input_ = input("> ")
                 if input_.lower() in [":q", ":q!", ":wq"]:
                     self.conversation.newline()
@@ -133,12 +128,16 @@ class Entity(BaseCommand):
                     Schema(self.configuration).execute(entity_name=entity.name)
                     Test(self.configuration).execute(entity_name=entity.name)
 
+                    if original_entity is None:
+                        # We need to ensure the testing.py file is updated to import the new entity
+                        Base(self.configuration).execute()
+
                     self.conversation.unmute()
                     self.conversation.type(
-                        f"\nAll code for the {Colors.violet(entity.name)} entity has been written 🎉\n\n"
+                        f"\nAll code for the {Colors.entity(entity.name)} entity has been written 🎉\n\n"
                     )
                     exit()
-                elif input_ == "":
+                elif input_ == "" or input_.startswith(":"):
                     continue
 
                 with ComputingSpinner():
@@ -185,8 +184,25 @@ class Entity(BaseCommand):
             + "/default-table.tmpl"
         )
 
-    def __render_workspace(self, entity: StructureEntity, model):
+    def __render_workspace(
+        self,
+        original_entity: StructureEntity | None,
+        entity: StructureEntity,
+        model_name: str,
+        original_model_code: str | None,
+        model_code: str,
+    ):
         self.configuration.platform.cmd_clear()
+        create_table_statement_diff = (
+            diff(original_entity.create_statement(), entity.create_statement())
+            if original_entity
+            else additions(entity.create_statement())
+        )
+        model_code_diff = (
+            diff(original_model_code, model_code)
+            if original_model_code
+            else additions(model_code)
+        )
 
         print("")
         print(WorkspaceHeader().render(self.configuration.project.name))
@@ -194,11 +210,29 @@ class Entity(BaseCommand):
         print("")
         print(Header().render("SQL", Colors.cyan))
         print("")
-        print(Colors.table(entity.create_statement(), entity.name))
+        print(Colors.table(create_table_statement_diff, entity.name))
 
         print("")
         print(Header().render("Model", Colors.yellow))
         print("")
-        print(Colors.model(model, entity.name))
-
+        print(Colors.model(model_code_diff, model_name, entity.name))
         print(WorkspaceFooter().render())
+
+    def template_definition(self, entity_name):
+        parts = entity_name.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": entity_name})
+
+                self.memory.append_last({"definition": definition, "name": entity_name})
+
+                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": entity_name})

gibson/command/code/Model.py

@@ -14,14 +14,12 @@ class Model(BaseCommand):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(entity_name)
         if entity is None:
-            self.conversation.not_sure_no_entity(
-                self.configuration.project.name, entity_name
-            )
+            self.conversation.not_sure_no_entity(self.configuration, entity_name)
             exit(1)
 
         time_keeper = TimeKeeper()
 
-        with Spinner("Gibson is writing the models...", "Models written"):
+        with Spinner("Gibson is writing the model...", "Model written"):
             cli = Cli(self.configuration)
             response = cli.code_models([entity["name"]])
             Dev(self.configuration).model(

gibson/command/code/Schema.py

@@ -14,9 +14,7 @@ class Schema(BaseCommand):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(entity_name)
         if entity is None:
-            self.conversation.not_sure_no_entity(
-                self.configuration.project.name, entity_name
-            )
+            self.conversation.not_sure_no_entity(self.configuration, entity_name)
             exit(1)
 
         time_keeper = TimeKeeper()
@@ -24,15 +22,18 @@ class Schema(BaseCommand):
         with Spinner("Gibson is writing the schemas...", "Schemas written"):
             cli = Cli(self.configuration)
             response = cli.code_schemas([entity["name"]])
-            Dev(self.configuration).schema(
-                response["code"][0]["entity"]["name"], response["code"][0]["definition"]
-            )
+            code = response["code"][0] if len(response["code"]) > 0 else None
+            if code:
+                Dev(self.configuration).schema(
+                    code["entity"]["name"], code["definition"]
+                )
 
-        if self.configuration.project.dev.active is True:
+        if code and self.configuration.project.dev.active is True:
             self.conversation.type(
                 f"\nGibson wrote the following {Colors.argument('schema')} code to your project:\n"
             )
 
         if not self.conversation.muted():
-            print(response["code"][0]["definition"])
+            if code:
+                print(code["definition"])
             time_keeper.display()

gibson/command/code/Test.py

@@ -14,9 +14,7 @@ class Test(BaseCommand):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(entity_name)
         if entity is None:
-            self.conversation.not_sure_no_entity(
-                self.configuration.project.name, entity_name
-            )
+            self.conversation.not_sure_no_entity(self.configuration, entity_name)
             exit(1)
 
         time_keeper = TimeKeeper()

gibson/command/importer/Import.py

@@ -56,7 +56,7 @@ class Import(BaseCommand):
         self.conversation.type("Building schema...\n")
 
         for entity in response["project"]["entities"]:
-            self.conversation.type(f"    {entity['name']}\n", delay=0.002)
+            self.conversation.type(f"    {entity['name']}\n")
 
         return response["project"]["entities"]
 
@@ -74,7 +74,7 @@ class Import(BaseCommand):
         entities = []
         for table in tables:
             if table[0] not in table_exceptions:
-                self.conversation.type(f"    {table[0]}\n", delay=0.002)
+                self.conversation.type(f"    {table[0]}\n")
 
                 create_statement = session.execute(
                     f"show create table {table[0]}"
@@ -139,7 +139,7 @@ class Import(BaseCommand):
 
         entities = []
         for table_name, definition in tables.items():
-            self.conversation.type(f"    {table_name}\n", delay=0.002)
+            self.conversation.type(f"    {table_name}\n")
 
             definition[-1] = definition[-1].rstrip(",")
 
@@ -160,19 +160,19 @@ class Import(BaseCommand):
             else ""
         )
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.arguments(['api', 'mysql', 'pg_dump', 'openapi'])} {Colors.hint('import entities')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'import', args=['api', 'mysql', 'pg_dump', 'openapi'], hint='import entities')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('api')} {Colors.hint(f'import all entities from your project created on {Colors.link(self.configuration.app_domain())}')}\n"
+            f"       {Colors.command(self.configuration.command, 'import', args='api', hint=f'import all entities from your project created on {Colors.link(self.configuration.app_domain())}')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('mysql')} {Colors.hint('import all entities from your MySQL database')} ({Colors.link(datastore_uri)})\n"
+            f"       {Colors.command(self.configuration.command, 'import', args='mysql', hint='import all entities from your MySQL database')} ({Colors.link(datastore_uri)})\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('pg_dump')} {Colors.input('path/to/pg_dump.sql')} {Colors.hint('import all entities from a pg_dump file')}\n"
+            f"       {Colors.command(self.configuration.command, 'import', args='pg_dump', inputs='path/to/pg_dump.sql', hint='import all entities from a pg_dump file')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('openapi')} {Colors.input('path/to/openapi.json')} {Colors.hint('import all entities from an OpenAPI spec file')}\n"
+            f"       {Colors.command(self.configuration.command, 'import', args='openapi', inputs='path/to/openapi.json', hint='import all entities from an OpenAPI spec file')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/importer/OpenApi.py

@@ -46,7 +46,7 @@ class OpenApi(BaseCommand):
 
         i = 0
         for path in path_list:
-            self.conversation.type(f"   {i}: ".rjust(10) + path + "\n", delay=0.0009)
+            self.conversation.type(f"   {i}: ".rjust(10) + path + "\n")
             i += 1
 
         self.conversation.newline()

gibson/command/list/Entities.py

@@ -1,5 +1,10 @@
 import sys
 
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
 from gibson.command.BaseCommand import BaseCommand
 
 
@@ -8,44 +13,27 @@ class Entities(BaseCommand):
         self.configuration.require_project()
         self.configuration.display_project()
 
-        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"])
+        last = self.memory.recall_last() or []
+        stored = self.memory.recall_entities() or []
 
-        if len(entities["last"]) == 0 and len(entities["stored"]) == 0:
+        if len(last) == 0 and len(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()
+            console = Console()
+            table = Table(
+                title="Entities",
+                header_style="bold",
+                box=box.ROUNDED,
+                leading=1,
+            )
+            table.add_column("Name", style="magenta", header_style="magenta")
+            table.add_column("Memory")
+
+            for entity in sorted(stored, key=lambda x: x["name"]):
+                table.add_row(entity["name"], Text("stored", style="green"))
+
+            for entity in sorted(last, key=lambda x: x["name"]):
+                table.add_row(entity["name"], Text("last", style="yellow"))
+
+            console.print(table)

gibson/command/list/List.py

@@ -18,13 +18,13 @@ class List(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('list')} {Colors.arguments(['entities', 'projects'])}\n"
+            f"usage: {Colors.command(self.configuration.command, 'list', args=['entities', 'projects'])}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('list')} {Colors.argument('entities')} {Colors.hint('list all entities')}\n"
+            f"       {Colors.command(self.configuration.command, 'list', args='entities', hint='list all entities')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('list')} {Colors.argument('projects')} {Colors.hint('list all projects')}\n"
+            f"       {Colors.command(self.configuration.command, 'list', args='projects', hint='list all projects')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/list/Projects.py

@@ -1,31 +1,41 @@
-import re
+from rich import box
+from rich.console import Console
+from rich.table import Table
 
 import gibson.core.Colors as Colors
 from gibson.api.ProjectApi import ProjectApi
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Spinner import DisappearingSpinner
 
 
 class Projects(BaseCommand):
     def execute(self):
         self.configuration.require_login()
-        projects = ProjectApi(self.configuration).all_projects()
+
+        with DisappearingSpinner():
+            projects = ProjectApi(self.configuration).all_projects()
 
         if len(projects) == 0:
             self.conversation.type(
-                f"No projects found. Create one with {Colors.command('gibson')} {Colors.subcommand('new')} {Colors.argument('project')}\n"
+                f"No projects found. Create one with {Colors.command(self.configuration.command, 'new', args='project')}\n"
             )
             exit(1)
 
-        self.conversation.type("Name".ljust(40))
-        self.conversation.type("ID")
-        self.conversation.newline()
-        self.conversation.type("----".ljust(40))
-        self.conversation.type("-" * 36)
-        self.conversation.newline()
+        console = Console()
+        table = Table(
+            title="Projects",
+            header_style="bold magenta",
+            box=box.ROUNDED,
+            leading=1,
+        )
+        table.add_column("Name")
+        table.add_column("ID", min_width=36)
 
         for project in projects:
             name = project["name"] if project["name"] is not None else "Untitled"
-            name = re.sub(r"^(.{36}).*$", "\g<1>...", name).ljust(40)
-            self.conversation.type(f"{Colors.command(name)}")
-            self.conversation.type(f"{project['uuid']}")
-            self.conversation.newline()
+            table.add_row(
+                name,
+                project["uuid"],
+            )
+
+        console.print(table)

gibson/command/new/Module.py

@@ -34,7 +34,7 @@ class Module(BaseCommand):
         self.conversation.newline()
         self.conversation.type(f"If you want to persist these new entities run:\n")
         self.conversation.type(
-            f"{Colors.command(self.configuration.command)} {Colors.subcommand('merge')}\n"
+            f"{Colors.command(self.configuration.command, 'merge')}\n"
         )
 
         self.conversation.newline()
@@ -42,5 +42,5 @@ class Module(BaseCommand):
             f"Afterwards, you can modify any of these entities by running:\n"
         )
         self.conversation.type(
-            f"{Colors.command(self.configuration.command)} {Colors.subcommand('modify')} {Colors.argument('[entity name]')} {Colors.input('[instructions]')}\n"
+            f"{Colors.command(self.configuration.command, 'modify', inputs=['[entity name]', '[instructions]'])}\n"
         )

gibson/command/new/New.py

@@ -21,16 +21,16 @@ class New(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.arguments(['project', 'module', 'entity'])} {Colors.hint('create something new')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'new', args=['project', 'module', 'entity'], hint='create something new')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.argument('project')} {Colors.hint('create a new project')}\n"
+            f"       {Colors.command(self.configuration.command, 'new', args='project', hint='create a new project')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.argument('module')} {Colors.hint('create a new module')}\n"
+            f"       {Colors.command(self.configuration.command, 'new', args='module', hint='create a new module')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.argument('entity')} {Colors.input('[entity name]')} {Colors.hint('create a new entity')}\n"
+            f"       {Colors.command(self.configuration.command, 'new', args='entity', inputs='[entity name]', hint='create a new entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/rename/Rename.py

@@ -15,7 +15,7 @@ class Rename(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('rename')} {Colors.argument('entity')} {Colors.input('[existing name]')} {Colors.input('[new name]')} {Colors.hint('rename an entity')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'rename', args='entity', inputs=['[existing name]', '[new name]'], hint='rename an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/rewrite/Rewrite.py

@@ -115,7 +115,7 @@ class Rewrite(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('rewrite')} {Colors.hint('rewrite all code')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'rewrite', hint='rewrite all code')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/core/Colors.py

@@ -46,8 +46,30 @@ def colorize(text, color):
 
 
 # Colorize a command
-def command(text):
-    return green(text)
+def command(
+    command,
+    sub=None,
+    args=None,
+    inputs=None,
+    hint=None,
+):
+    parts = [green(command)]
+    if sub:
+        parts.append(subcommand(sub))
+    if args:
+        if isinstance(args, list):
+            parts.append(arguments(args))
+        else:
+            parts.append(argument(args))
+    if inputs:
+        if isinstance(inputs, list):
+            for input_ in inputs:
+                parts.append(user_input(input_))
+        else:
+            parts.append(user_input(inputs))
+    if hint:
+        parts.append(grey(hint))
+    return " ".join(parts)
 
 
 # Colorize a subcommand
@@ -66,7 +88,7 @@ def arguments(list):
 
 
 # Colorize user input
-def input(text):
+def user_input(text):
     return white(text)
 
 
@@ -90,15 +112,20 @@ def link(text):
     return underline(blue(text))
 
 
+# Colorize an entity name
+def entity(text):
+    return bold(violet(text))
+
+
 # Colorize the table name in a SQL statement
 def table(sql, name):
-    return sql.replace(name, violet(name))
+    return sql.replace(name, entity(name), 1)
 
 
 # Colorize the table name in model code
-def model(code, name):
-    return code.replace(
-        f'__tablename__ = "{name}"', f'__tablename__ = "{violet(name)}"'
+def model(code, model_name, entity_name):
+    return code.replace(model_name, entity(model_name), 1).replace(
+        f'__tablename__ = "{entity_name}"', f'__tablename__ = "{entity(entity_name)}"'
     )
 
 

gibson/core/CommandRouter.py

@@ -20,7 +20,6 @@ from gibson.command.rewrite.Rewrite import Rewrite
 from gibson.command.Show import Show
 from gibson.command.Tree import Tree
 from gibson.command.Version import Version
-from gibson.command.WarGames import WarGames
 from gibson.core.Configuration import Configuration
 from gibson.core.Conversation import Conversation
 from gibson.core.Env import Env

gibson/core/Configuration.py

@@ -313,7 +313,7 @@ class Configuration:
 
     def require_login(self):
         if self.get_access_token() is None:
-            self.conversation.message_login_required()
+            self.conversation.message_login_required(self)
             exit(1)
 
         return self
@@ -329,9 +329,12 @@ class Configuration:
 
         return self
 
-    def require_project_key(self):
+    def require_project_key_or_id(self):
+        if self.project.id:
+            return self
+
         if not self.project.api.key or self.project.api.key == "FIXME":
-            self.conversation.project_api_key_not_set(self.app_domain())
+            self.conversation.project_api_key_not_set(self)
             exit(1)
 
         return self
@@ -345,6 +348,7 @@ class Configuration:
         with open(f"{self.paths.auth}/{self.API_ENV}", "w") as f:
             data = {"access_token": access_token, "refresh_token": refresh_token}
             json.dump(data, f, indent=2)
+            f.write("\n")
 
     def set_config_paths(self):
         config_path = os.environ.get("GIBSONAI_CONFIG_PATH", None)
@@ -448,6 +452,7 @@ class Configuration:
 
         with open(self.paths.config, "w") as f:
             json.dump(self.settings, f, indent=2)
+            f.write("\n")
 
         self.read_config()