gibson-cli 0.6.1__tar.gz → 0.7.1__tar.gz

{gibson_cli-0.6.1/gibson_cli.egg-info → gibson_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gibson-cli
-Version: 0.6.1
+Version: 0.7.1
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/
@@ -120,7 +120,7 @@ Let's consider a more concrete example. You imported your datastore into the CLI
 
 So Gibson creates a new version of the user table containing a nickname column. This new table is stored in last memory.  If you execute:
 
-`gibson rewrite models`
+`gibson code models`
 
 The CLI will write the code for what is sitting in last memory.
 
@@ -176,8 +176,8 @@ All of Gibson's configuration files and caches are stored in `$HOME/.gibson`. Us
   - `:command! -nargs=* Gibson r ! gibson <args>`
 - Open a file and execute commands:
   - `:Gibson module abc`
-  - `:Gibson rewrite models`
-  - `:Gibson rewrite schemas`
+  - `:Gibson code models`
+  - `:Gibson code schemas`
 
 ## Currently Supported Software
 
@@ -235,10 +235,9 @@ Note: Gibson currently only supports MySQL. Let us know if you need something el
 
 ### Importing Your Datastore
 
-`gibson import datastore`
+`gibson import mysql` or `gibson import pg_dump /path/to/pg_dump.sql` or `gibson import openapi /path/to/openapi.json`
 
 - This will make Gibson's stored memory aware of all of your datastore objects.
-- `gibson import datastore .. dev`
 - In addition to making Gibson aware, this will write all of the base, model and schema code for you.
 
 ### Configuring a Custom BaseModel
@@ -254,30 +253,30 @@ For example, you might provide class name = `MyBaseModel` and import path = `pro
 
 ### Writing the Base Code
 
-`gibson rewrite base`
+`gibson code base`
 
 ### Writing the Code for a Single Model
 
-`gibson model [table name]`
+`gibson code model [entity name]`
 
 ### Writing the Code for a Single Schema
 
-`gibson schema [table name]`
+`gibson code schema [entity name]`
 
 ### Writing the Code for All Models
 
-`gibson rewrite models`
+`gibson code models`
 
 ### Writing the Code for All Schemas
 
-`gibson rewrite schemas`
+`gibson code schemas`
 
 ### Adding a New Module to the Software Using AI
 
 - gibson module [module name]
   - e.g. gibson module user
 - Gibson will display the SQL tables it has generated as a result of your request. It will store these entities in its last memory.
-- `gibson rewrite models`
+- `gibson code models`
 - This will write the code for the entities it just created.
 - `gibson merge`
 - This will merge the new entities into your project.
@@ -285,10 +284,10 @@ For example, you might provide class name = `MyBaseModel` and import path = `pro
 
 ### Making Changes to the Software Using AI
 
-- `gibson modify [table name] [natural language request]`
+- `gibson modify [entity name] [natural language request]`
   - e.g. `gibson modify my_table I want to add a new column called name and remove all of the columns related to email`
 - Gibson will display the modified SQL table and store it in its last memory.
-- `gibson rewrite models`
+- `gibson code models`
 - This will write the code for the modified entity.
 - `gibson merge`
 - This will merge the modified entity into your project.
@@ -314,7 +313,7 @@ For example, you might provide class name = `MyBaseModel` and import path = `pro
 - Chat with Gibson and create a new project.
 - When your project is complete Gibson will email you the API key.
 - `gibson conf api::key [API key]`
-- `gibson import api .. dev`
+- `gibson import api`
 - Magic, no?
 
 ### Integrating a Model into Your Code
@@ -346,26 +345,25 @@ At the moment, just refer to the base-level schema directly.
 
 ### Migrating Your Software from PHP to Python
 
-- Configure your datastore.
-- Turn on Dev Mode.
-- `gibson import datastore .. dev`
-- 70% of your code is written, customize the remaining.
+- Configure your datastore
+- Turn on Dev Mode
+- `gibson import mysql` (alternatively import from pg_dump or openapi)
+- 70% of your code is written, customize the remaining
 
 ### Asking Gibson Questions With Context
 
-- `gibson ? [natural language request]`
+- `gibson q [natural language request]`
 - Your natural language request can include:
   - `file://[full path]` to import a file from the filesystem
   - `py://[import]` to import a file from `PYTHONPATH`
   - `sql://[entity name]` to import the SQL
 - For example:
-  - `gibson ? format file:///Users/me/file.py for PEP8`
-  - `gibson ? code review py://user.modules.User`
-  - `gibson ? add nickname to sql://user`
-- When using `sql://`, any entities that are created as part of Gibson's response will be transferred into Gibson's last memory allowing you to execute a question, create a new entity and have Gibson immediately create a model or schema from it.
-  - e.g. `gibson ? add nickname to sql://user`
-  - `gibson model`
-- Important note, `gibson ?` may cause your shell to incorrectly interpret the question mark. If it does, you can use `gibson q` instead (just replace the question mark with the letter `q`).
+  - `gibson q format file:///Users/me/file.py for PEP8`
+  - `gibson q code review py://user.modules.User`
+  - `gibson q add nickname to sql://user`
+- When using `sql://`, any entities that are created as part of Gibson's response will be transferred into Gibson's last memory allowing you to execute a query, create a new entity and have Gibson immediately create a model or schema from it.
+  - e.g. `gibson q add nickname to sql://user`
+  - `gibson code model user`
 
 ## Contributing
 

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/README.md

@@ -52,7 +52,7 @@ Let's consider a more concrete example. You imported your datastore into the CLI
 
 So Gibson creates a new version of the user table containing a nickname column. This new table is stored in last memory.  If you execute:
 
-`gibson rewrite models`
+`gibson code models`
 
 The CLI will write the code for what is sitting in last memory.
 
@@ -108,8 +108,8 @@ All of Gibson's configuration files and caches are stored in `$HOME/.gibson`. Us
   - `:command! -nargs=* Gibson r ! gibson <args>`
 - Open a file and execute commands:
   - `:Gibson module abc`
-  - `:Gibson rewrite models`
-  - `:Gibson rewrite schemas`
+  - `:Gibson code models`
+  - `:Gibson code schemas`
 
 ## Currently Supported Software
 
@@ -167,10 +167,9 @@ Note: Gibson currently only supports MySQL. Let us know if you need something el
 
 ### Importing Your Datastore
 
-`gibson import datastore`
+`gibson import mysql` or `gibson import pg_dump /path/to/pg_dump.sql` or `gibson import openapi /path/to/openapi.json`
 
 - This will make Gibson's stored memory aware of all of your datastore objects.
-- `gibson import datastore .. dev`
 - In addition to making Gibson aware, this will write all of the base, model and schema code for you.
 
 ### Configuring a Custom BaseModel
@@ -186,30 +185,30 @@ For example, you might provide class name = `MyBaseModel` and import path = `pro
 
 ### Writing the Base Code
 
-`gibson rewrite base`
+`gibson code base`
 
 ### Writing the Code for a Single Model
 
-`gibson model [table name]`
+`gibson code model [entity name]`
 
 ### Writing the Code for a Single Schema
 
-`gibson schema [table name]`
+`gibson code schema [entity name]`
 
 ### Writing the Code for All Models
 
-`gibson rewrite models`
+`gibson code models`
 
 ### Writing the Code for All Schemas
 
-`gibson rewrite schemas`
+`gibson code schemas`
 
 ### Adding a New Module to the Software Using AI
 
 - gibson module [module name]
   - e.g. gibson module user
 - Gibson will display the SQL tables it has generated as a result of your request. It will store these entities in its last memory.
-- `gibson rewrite models`
+- `gibson code models`
 - This will write the code for the entities it just created.
 - `gibson merge`
 - This will merge the new entities into your project.
@@ -217,10 +216,10 @@ For example, you might provide class name = `MyBaseModel` and import path = `pro
 
 ### Making Changes to the Software Using AI
 
-- `gibson modify [table name] [natural language request]`
+- `gibson modify [entity name] [natural language request]`
   - e.g. `gibson modify my_table I want to add a new column called name and remove all of the columns related to email`
 - Gibson will display the modified SQL table and store it in its last memory.
-- `gibson rewrite models`
+- `gibson code models`
 - This will write the code for the modified entity.
 - `gibson merge`
 - This will merge the modified entity into your project.
@@ -246,7 +245,7 @@ For example, you might provide class name = `MyBaseModel` and import path = `pro
 - Chat with Gibson and create a new project.
 - When your project is complete Gibson will email you the API key.
 - `gibson conf api::key [API key]`
-- `gibson import api .. dev`
+- `gibson import api`
 - Magic, no?
 
 ### Integrating a Model into Your Code
@@ -278,26 +277,25 @@ At the moment, just refer to the base-level schema directly.
 
 ### Migrating Your Software from PHP to Python
 
-- Configure your datastore.
-- Turn on Dev Mode.
-- `gibson import datastore .. dev`
-- 70% of your code is written, customize the remaining.
+- Configure your datastore
+- Turn on Dev Mode
+- `gibson import mysql` (alternatively import from pg_dump or openapi)
+- 70% of your code is written, customize the remaining
 
 ### Asking Gibson Questions With Context
 
-- `gibson ? [natural language request]`
+- `gibson q [natural language request]`
 - Your natural language request can include:
   - `file://[full path]` to import a file from the filesystem
   - `py://[import]` to import a file from `PYTHONPATH`
   - `sql://[entity name]` to import the SQL
 - For example:
-  - `gibson ? format file:///Users/me/file.py for PEP8`
-  - `gibson ? code review py://user.modules.User`
-  - `gibson ? add nickname to sql://user`
-- When using `sql://`, any entities that are created as part of Gibson's response will be transferred into Gibson's last memory allowing you to execute a question, create a new entity and have Gibson immediately create a model or schema from it.
-  - e.g. `gibson ? add nickname to sql://user`
-  - `gibson model`
-- Important note, `gibson ?` may cause your shell to incorrectly interpret the question mark. If it does, you can use `gibson q` instead (just replace the question mark with the letter `q`).
+  - `gibson q format file:///Users/me/file.py for PEP8`
+  - `gibson q code review py://user.modules.User`
+  - `gibson q add nickname to sql://user`
+- When using `sql://`, any entities that are created as part of Gibson's response will be transferred into Gibson's last memory allowing you to execute a query, create a new entity and have Gibson immediately create a model or schema from it.
+  - e.g. `gibson q add nickname to sql://user`
+  - `gibson code model user`
 
 ## Contributing
 

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/api/BaseApi.py

@@ -1,4 +1,5 @@
 import os
+import pprint
 
 import requests
 
@@ -96,7 +97,7 @@ class BaseApi:
                 message = r.json()
                 print("=" * 78)
                 print("Raw Response:\n")
-                print(message)
+                pprint.pprint(message)
                 print("\n" + "=" * 78)
             except requests.exceptions.JSONDecodeError:
                 pass

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/api/Cli.py

@@ -66,7 +66,10 @@ class Cli(BaseApi):
 
     def headers(self):
         headers = super().headers()
-        headers["X-Gibson-API-Key"] = self.configuration.project.api.key
+        if self.configuration.project.id:
+            headers["X-Gibson-Project-ID"] = self.configuration.project.id
+        else:
+            headers["X-Gibson-API-Key"] = self.configuration.project.api.key
         return headers
 
     def import_(self):
@@ -157,7 +160,11 @@ class Cli(BaseApi):
     def modeler_openapi(self, modeler_version, contents):
         r = self.post(
             "modeler/openapi",
-            {"contents": contents, "modeler": {"version": modeler_version}},
+            {
+                "contents": contents,
+                "datastore": {"type": self.configuration.project.datastore.type},
+                "modeler": {"version": modeler_version},
+            },
         )
 
         return r.json()

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/command/Build.py

@@ -1,5 +1,6 @@
 import sys
 
+import sqlalchemy
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
@@ -18,11 +19,19 @@ class Build(BaseCommand):
 
         self.conversation.type("Connected to datastore...\n")
 
+        if self.configuration.project.datastore.type == "mysql":
+            self.__build_mysql(session)
+        elif self.configuration.project.datastore.type == "postgresql":
+            self.__build_postgresql(session)
+
+        self.conversation.newline()
+
+    def __build_mysql(self, session):
         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")
+            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:
@@ -39,11 +48,54 @@ class Build(BaseCommand):
                 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")
+            session.execute("set foreign_key_checks = 1")
+            self.conversation.type("  foreign key checks have been enabled\n")
+
+    def __build_postgresql(self, session):
+        table_exceptions = TableExceptions().postgresql()
+
+        schema = list(session.execute("select current_schema()"))[0][0]
+        self.conversation.type(f"  current schema is {schema}\n")
+
+        tables = list(
+            session.execute(
+                """select table_name
+                     from information_schema.tables
+                    where table_schema = :table_schema""",
+                {"table_schema": schema},
+            )
+        )
 
-        self.conversation.newline()
+        if len(tables) > 0:
+            self.conversation.type("  dropping existing entities\n")
+
+            for table in tables:
+                self.conversation.type(f"    {table[0]}\n", delay=0.002)
+                session.execute(f"drop table if exists {schema}.{table[0]} cascade")
+                session.commit()
+
+        self.conversation.type("  building entities\n")
+
+        tables = {}
+        for entity in self.memory.entities:
+            tables[entity["name"]] = entity["definition"]
+
+        while tables != {}:
+            remove = []
+            for name, definition in tables.items():
+
+                try:
+                    session.execute(definition)
+                    session.commit()
+
+                    self.conversation.type(f'    {name.split(".")[-1]}\n', delay=0.002)
+
+                    remove.append(name)
+                except sqlalchemy.exc.ProgrammingError:
+                    session.rollback()
+
+            for name in remove:
+                del tables[name]
 
     def execute(self):
         if len(sys.argv) != 3 or sys.argv[2] != "datastore":

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/command/Help.py

@@ -48,10 +48,6 @@ class Help(BaseCommand):
                 "description": "move last changes into project",
                 "memory": "last -> stored",
             },
-            "model": {
-                "description": "write the model code for an entity",
-                "memory": "stored",
-            },
             "modify": {
                 "description": "change an entity using natural language",
                 "memory": "last > stored",
@@ -69,15 +65,7 @@ class Help(BaseCommand):
                 "description": "rewrite code",
                 "memory": "stored",
             },
-            "schema": {
-                "description": "write the schema code for an entity",
-                "memory": "stored",
-            },
             "show": {"description": "display an entity", "memory": "last > stored"},
-            "test": {
-                "description": "write the unit tests for an entity",
-                "memory": "stored",
-            },
             "tree": {"description": "illustrate the project layout", "memory": None},
             "q": {"description": "ask Gibson a question", "memory": None},
         }

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/command/Question.py

@@ -28,7 +28,10 @@ class Question(BaseCommand):
                     with open(path, "r") as f:
                         contents = f.read()
                 except FileNotFoundError:
-                    self.__file_not_found(path)
+                    self.configuration.display_project()
+                    self.conversation.file_not_found(path)
+                    self.conversation.newline()
+                    exit(1)
 
                 has_file = True
                 instructions += f"\n\n{contents}\n\n"
@@ -81,12 +84,6 @@ class Question(BaseCommand):
 
         self.conversation.newline()
 
-    def __file_not_found(self, path):
-        self.configuration.display_project()
-        self.conversation.type(f'404, My Friend. Cannot find file "{path}".\n')
-        self.conversation.newline()
-        exit(1)
-
     def __python_import_not_found(self, import_):
         self.configuration.display_project()
         self.conversation.type(f'That\'s a misfire, "{import_}" does not exist.\n')

gibson_cli-0.7.1/gibson/command/code/Code.py

@@ -0,0 +1,72 @@
+import sys
+
+import gibson.core.Colors as Colors
+from gibson.command.BaseCommand import BaseCommand
+from gibson.command.code.Api import Api as CodeApi
+from gibson.command.code.Base import Base as CodeBase
+from gibson.command.code.Entity import Entity as CodeEntity
+from gibson.command.code.Model import Model as CodeModel
+from gibson.command.code.Models import Models as CodeModels
+from gibson.command.code.Schema import Schema as CodeSchema
+from gibson.command.code.Schemas import Schemas as CodeSchemas
+from gibson.command.code.Test import Test as CodeTest
+from gibson.command.code.Tests import Tests as CodeTests
+
+
+class Code(BaseCommand):
+    def execute(self):
+        if len(sys.argv) == 3 and sys.argv[2] == "api":
+            CodeApi(self.configuration).execute()
+        elif len(sys.argv) == 3 and sys.argv[2] == "base":
+            CodeBase(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "entity":
+            CodeEntity(self.configuration).execute()
+        elif len(sys.argv) == 3 and sys.argv[2] == "models":
+            CodeModels(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "models":
+            CodeModel(self.configuration).execute()
+        elif len(sys.argv) == 3 and sys.argv[2] == "schemas":
+            CodeSchemas(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "schemas":
+            CodeSchema(self.configuration).execute()
+        elif len(sys.argv) == 3 and sys.argv[2] == "tests":
+            CodeTests(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "tests":
+            CodeTest(self.configuration).execute()
+        else:
+            self.usage()
+
+    def usage(self):
+        self.configuration.display_project()
+        self.conversation.type(
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.arguments(['api', 'base', 'entity', 'models', 'schemas', 'tests'])} {Colors.input('[entity name]')} {Colors.hint('write code')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('api')} {Colors.hint('generate the API code')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('base')} {Colors.hint('generate the base code')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('entity')} {Colors.input('[entity name]')} {Colors.hint('create or update an entity using the AI pair programmer')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('models')} {Colors.hint('generate the models for all entities')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('models')} {Colors.input('[entity name]')} {Colors.hint('generate the model(s) for a single entity')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('schemas')} {Colors.hint('generate the schemas for all entities')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('schemas')} {Colors.input('[entity name]')} {Colors.hint('generate the schema(s) for a single entity')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('tests')} {Colors.hint('generate the unit tests for all entities')}\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('tests')} {Colors.input('[entity name]')} {Colors.hint('generate the unit tests for a single entity')}\n"
+        )
+        self.conversation.newline()
+        exit(1)

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/command/code/Entity.py

@@ -14,10 +14,10 @@ from gibson.display.WorkspaceHeader import WorkspaceHeader
 from gibson.services.code.context.schema.Manager import (
     Manager as CodeContextSchemaManager,
 )
-from gibson.structure.Entity import Entity
+from gibson.structure.Entity import Entity as StructureEntity
 
 
-class CodeEntity(BaseCommand):
+class Entity(BaseCommand):
     CODE_WRITER_ENTITY_MODIFIER_NOOP = ""
 
     def __init__(self, configuration: Configuration):
@@ -96,7 +96,11 @@ class CodeEntity(BaseCommand):
             definition,
             self.CODE_WRITER_ENTITY_MODIFIER_NOOP,
         )
-        entity = Entity().import_from_struct(data)
+        entity = (
+            StructureEntity()
+            .instantiate(self.configuration.project.datastore.type)
+            .import_from_struct(data)
+        )
 
         while True:
             self.__render_workspace(entity, data["code"][0]["definition"])
@@ -147,15 +151,29 @@ class CodeEntity(BaseCommand):
                     entity.create_statement(),
                     input_,
                 )
-                entity = Entity().import_from_struct(data)
+                entity = (
+                    StructureEntity()
+                    .instantiate(self.configuration.project.datastore.type)
+                    .import_from_struct(data)
+                )
 
     def get_default_ref_table_template_path(self):
-        return os.path.dirname(__file__) + "/../../data/default-ref-table.tmpl"
+        return (
+            os.path.dirname(__file__)
+            + "/../../data/"
+            + self.configuration.project.datastore.type
+            + "/default-ref-table.tmpl"
+        )
 
     def get_default_table_template_path(self):
-        return os.path.dirname(__file__) + "/../../data/default-table.tmpl"
+        return (
+            os.path.dirname(__file__)
+            + "/../../data/"
+            + self.configuration.project.datastore.type
+            + "/default-table.tmpl"
+        )
 
-    def __render_workspace(self, entity: Entity, model):
+    def __render_workspace(self, entity: StructureEntity, model):
         self.configuration.platform.cmd_clear()
 
         print("")

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/command/code/Model.py

@@ -7,7 +7,7 @@ from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
 
-class CodeModel(BaseCommand):
+class Model(BaseCommand):
     def execute(self):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[3])

{gibson_cli-0.6.1 → gibson_cli-0.7.1}/gibson/command/code/Schema.py

@@ -7,7 +7,7 @@ from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
 
-class CodeSchema(BaseCommand):
+class Schema(BaseCommand):
     def execute(self):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[3])

gibson_cli-0.6.1/gibson/command/code/Tests.py → gibson_cli-0.7.1/gibson/command/code/Test.py

@@ -7,7 +7,7 @@ from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
 
-class CodeTests(BaseCommand):
+class Test(BaseCommand):
     def execute(self):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[3])