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

gibson/structure/{testing.py → postgresql/testing.py}

@@ -1,97 +1,78 @@
-from gibson.structure.Entity import Entity
+from gibson.structure.postgresql.Entity import Entity
 
 
 def structure_testing_get_entity():
     entity = Entity()
     entity.attributes = [
         {
-            "as_": None,
-            "bytes_": None,
             "check": None,
-            "comment": None,
+            "datastore": {
+                "specifics": {
+                    "references": None,
+                }
+            },
             "data_type": {"formatted": "bigint", "raw": "bigint"},
             "default": None,
-            "extra": {"increment": {"auto": True}},
             "key": {"index": None, "primary": True, "unique": None},
             "length": None,
             "name": "id",
             "nullable": False,
             "numeric": {"precision": None, "scale": None},
-            "on": None,
-            "reference": None,
             "sql": "id bigint not null auto_increment primary key",
-            "unsigned": None,
-            "values": None,
         },
         {
-            "as_": None,
-            "bytes_": None,
             "check": None,
-            "comment": None,
+            "datastore": {
+                "specifics": {
+                    "references": None,
+                }
+            },
             "data_type": {"formatted": "varchar(36)", "raw": "varchar"},
             "default": None,
-            "extra": {"increment": {"auto": None}},
             "key": {"index": None, "primary": None, "unique": True},
             "length": 36,
             "name": "uuid",
             "nullable": False,
             "numeric": {"precision": None, "scale": None},
-            "on": None,
-            "reference": None,
             "sql": "uuid varchar(36) not null unique key",
-            "unsigned": None,
-            "values": None,
         },
         {
-            "as_": None,
-            "bytes_": None,
             "check": None,
-            "comment": None,
+            "datastore": {
+                "specifics": {
+                    "references": None,
+                }
+            },
             "data_type": {"formatted": "datetime", "raw": "datetime"},
             "default": "current_timestamp",
-            "extra": {"increment": {"auto": None}},
             "key": {"index": None, "primary": None, "unique": None},
             "length": None,
             "name": "date_created",
             "nullable": False,
             "numeric": {"precision": None, "scale": None},
-            "on": None,
-            "reference": None,
             "sql": "date_created datetime not null default current_timestamp",
-            "unsigned": None,
-            "values": None,
         },
         {
-            "as_": None,
-            "bytes_": None,
             "check": None,
-            "comment": None,
+            "datastore": {
+                "specifics": {
+                    "references": None,
+                }
+            },
             "data_type": {"formatted": "datetime", "raw": "datetime"},
             "default": "null",
-            "extra": {"increment": {"auto": None}},
             "key": {"index": None, "primary": None, "unique": None},
             "length": None,
             "name": "date_updated",
             "nullable": None,
             "numeric": {"precision": None, "scale": None},
-            "on": "update current_timestamp",
-            "reference": None,
             "sql": "date_updated datetime default null on update current_timestamp",
-            "unsigned": None,
-            "values": None,
         },
     ]
     entity.constraints = {"check": []}
     entity.keys = {"foreign": [], "index": [], "primary": None, "unique": []}
     entity.name = "abc_def"
-    entity.parameters = {
-        "auto": None,
-        "charset": None,
-        "collate": None,
-        "default": None,
-        "engine": None,
-        "sql": None,
-    }
+    entity.table = None
 
     return entity
 
@@ -103,92 +84,74 @@ def structure_testing_get_struct_data():
             "struct": {
                 "attributes": [
                     {
-                        "as_": None,
-                        "bytes_": None,
                         "check": None,
-                        "comment": None,
+                        "datastore": {
+                            "specifics": {
+                                "references": None,
+                            }
+                        },
                         "data_type": {"formatted": "bigint", "raw": "bigint"},
                         "default": None,
-                        "extra": {"increment": {"auto": True}},
                         "key": {"index": None, "primary": True, "unique": None},
                         "length": None,
                         "name": "id",
                         "nullable": False,
                         "numeric": {"precision": None, "scale": None},
-                        "on": None,
-                        "reference": None,
                         "sql": "id bigint not null auto_increment primary key",
-                        "unsigned": None,
-                        "values": None,
                     },
                     {
-                        "as_": None,
-                        "bytes_": None,
                         "check": None,
-                        "comment": None,
+                        "datastore": {
+                            "specifics": {
+                                "reference": None,
+                            }
+                        },
                         "data_type": {"formatted": "varchar(36)", "raw": "varchar"},
                         "default": None,
-                        "extra": {"increment": {"auto": None}},
                         "key": {"index": None, "primary": None, "unique": True},
                         "length": 36,
                         "name": "uuid",
                         "nullable": False,
                         "numeric": {"precision": None, "scale": None},
-                        "on": None,
-                        "reference": None,
                         "sql": "uuid varchar(36) not null unique key",
-                        "unsigned": None,
-                        "values": None,
                     },
                     {
-                        "as_": None,
-                        "bytes_": None,
                         "check": None,
-                        "comment": None,
+                        "datastore": {
+                            "specifics": {
+                                "references": None,
+                            }
+                        },
                         "data_type": {"formatted": "datetime", "raw": "datetime"},
                         "default": "current_timestamp",
-                        "extra": {"increment": {"auto": None}},
                         "key": {"index": None, "primary": None, "unique": None},
                         "length": None,
                         "name": "date_created",
                         "nullable": False,
                         "numeric": {"precision": None, "scale": None},
-                        "on": None,
-                        "reference": None,
                         "sql": "date_created datetime not null default current_timestamp",
-                        "unsigned": None,
-                        "values": None,
                     },
                     {
-                        "as_": None,
-                        "bytes_": None,
                         "check": None,
-                        "comment": None,
+                        "datastore": {
+                            "specifics": {
+                                "references": None,
+                            }
+                        },
                         "data_type": {"formatted": "datetime", "raw": "datetime"},
                         "default": "null",
-                        "extra": {"increment": {"auto": None}},
                         "key": {"index": None, "primary": None, "unique": None},
                         "length": None,
                         "name": "date_updated",
                         "nullable": None,
                         "numeric": {"precision": None, "scale": None},
-                        "on": "update current_timestamp",
-                        "reference": None,
-                        "sql": "date_updated datetime default null on update current_timestamp",
-                        "unsigned": None,
-                        "values": None,
+                        "sql": "date_updated datetime default null on update "
+                        + "current_timestamp",
                     },
                 ],
                 "constraints": {"check": []},
                 "keys": {"foreign": [], "index": [], "primary": None, "unique": []},
-                "parameters": {
-                    "auto": None,
-                    "charset": None,
-                    "collate": None,
-                    "default": None,
-                    "engine": None,
-                    "sql": None,
-                },
+                "table": None,
             },
         }
     }

gibson/structure/postgresql/tests/test_structure_postgresql_Entity.py

@@ -0,0 +1,82 @@
+import pytest
+
+from gibson.structure.postgresql.Entity import Entity
+from gibson.structure.postgresql.References import References
+from gibson.structure.postgresql.table.ForeignKey import ForeignKey
+from gibson.structure.postgresql.testing import (
+    structure_testing_get_entity,
+    structure_testing_get_struct_data,
+)
+
+
+def test_add_foreign_key():
+    references = References()
+    references.columns = ["a", "b"]
+    references.ref_table = "abc_def"
+
+    foreign_key = ForeignKey()
+    foreign_key.columns = ["c", "d"]
+    foreign_key.references = references
+
+    entity = structure_testing_get_entity()
+    entity.add_foreign_key(foreign_key)
+
+    assert entity.keys["foreign"] == [
+        {
+            "attributes": ["c", "d"],
+            "references": {
+                "attributes": ["a", "b"],
+                "datastore": {
+                    "specifics": {
+                        "match": {"full": None, "partial": None, "simple": None}
+                    }
+                },
+                "entity": {"name": "abc_def", "schema_": None},
+                "on": {"delete": None, "update": None},
+                "sql": "references abc_def (a, b)",
+            },
+            "sql": "foreign key (c, d) references abc_def (a, b)",
+        }
+    ]
+
+
+def test_add_attribute_after():
+    entity = structure_testing_get_entity()
+    entity.add_attribute("abc", "bigint", after="uuid")
+
+    assert entity.attributes[2]["sql"] == "abc bigint"
+
+
+def test_add_attribute_before():
+    entity = structure_testing_get_entity()
+    entity.add_attribute("abc", "bigint", before="uuid")
+
+    assert entity.attributes[1]["sql"] == "abc bigint"
+
+
+def test_add_attribute_append():
+    entity = structure_testing_get_entity()
+    entity.add_attribute("abc", "bigint")
+
+    assert entity.attributes[-1]["sql"] == "abc bigint"
+
+
+def test_import_from_struct_incorrect_data_format():
+    with pytest.raises(RuntimeError) as e:
+        Entity().import_from_struct({"abc": "def"})
+
+    assert str(e.value) == "cannot import from struct, incorrect data format"
+
+
+def test_import_from_struct():
+    entity = Entity().import_from_struct(structure_testing_get_struct_data())
+
+    assert entity.name == "abc_def"
+    assert len(entity.attributes) == 4
+    assert entity.attributes[0]["name"] == "id"
+    assert entity.attributes[1]["name"] == "uuid"
+    assert entity.attributes[2]["name"] == "date_created"
+    assert entity.attributes[3]["name"] == "date_updated"
+    assert entity.constraints == {"check": []}
+    assert entity.keys == {"foreign": [], "index": [], "primary": None, "unique": []}
+    assert entity.table is None

gibson/structure/tests/test_structure_Entity.py

@@ -0,0 +1,22 @@
+import pytest
+
+from gibson.structure.Entity import Entity
+from gibson.structure.mysql.Entity import Entity as MysqlEntity
+from gibson.structure.postgresql.Entity import Entity as PostgresqlEntity
+
+
+def test_instantiate_exceptions():
+    with pytest.raises(RuntimeError) as e:
+        Entity().instantiate("invalid")
+
+    assert str(e.value) == 'unrecognized datastore type "invalid"'
+
+
+def test_instantiate_mysql():
+    entity = Entity().instantiate("mysql")
+    assert isinstance(entity, MysqlEntity)
+
+
+def test_instantiate_postgresql():
+    entity = Entity().instantiate("postgresql")
+    assert isinstance(entity, PostgresqlEntity)

{gibson_cli-0.6.0.dist-info → gibson_cli-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gibson-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/
@@ -14,6 +14,57 @@ Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3.9
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: annotated-types==0.6.0
+Requires-Dist: anyio==4.3.0
+Requires-Dist: certifi==2024.2.2
+Requires-Dist: charset-normalizer==3.3.2
+Requires-Dist: click==8.1.7
+Requires-Dist: dnspython==2.6.1
+Requires-Dist: email-validator==2.1.1
+Requires-Dist: exceptiongroup==1.2.0
+Requires-Dist: Faker==24.0.0
+Requires-Dist: faker-sqlalchemy==0.10.2208140
+Requires-Dist: fastapi==0.111.0
+Requires-Dist: fastapi-cli==0.0.2
+Requires-Dist: h11==0.14.0
+Requires-Dist: httpcore==1.0.5
+Requires-Dist: httptools==0.6.1
+Requires-Dist: httpx==0.27.0
+Requires-Dist: idna==3.6
+Requires-Dist: iniconfig==2.0.0
+Requires-Dist: Jinja2==3.1.4
+Requires-Dist: markdown-it-py==3.0.0
+Requires-Dist: MarkupSafe==2.1.5
+Requires-Dist: mdurl==0.1.2
+Requires-Dist: orjson==3.10.3
+Requires-Dist: packaging==23.2
+Requires-Dist: pluggy==1.4.0
+Requires-Dist: pydantic==2.6.1
+Requires-Dist: pydantic-core==2.16.2
+Requires-Dist: pyfiglet==1.0.2
+Requires-Dist: Pygments==2.18.0
+Requires-Dist: PyMySQL==1.1.0
+Requires-Dist: pytest==8.0.1
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: python-multipart==0.0.9
+Requires-Dist: PyYAML==6.0.1
+Requires-Dist: requests==2.31.0
+Requires-Dist: rich==13.7.1
+Requires-Dist: shellingham==1.5.4
+Requires-Dist: six==1.16.0
+Requires-Dist: sniffio==1.3.1
+Requires-Dist: SQLAlchemy==1.4.41
+Requires-Dist: starlette==0.37.2
+Requires-Dist: tomli==2.0.1
+Requires-Dist: typer==0.12.3
+Requires-Dist: typing-extensions==4.9.0
+Requires-Dist: ujson==5.9.0
+Requires-Dist: urllib3==1.26.6
+Requires-Dist: uvicorn==0.29.0
+Requires-Dist: uvloop==0.19.0
+Requires-Dist: watchfiles==0.21.0
+Requires-Dist: websockets==12.0
 
 
 [![GibsonAI](https://github.com/user-attachments/assets/26bc1002-f878-4995-a6c5-eb8d5eb69c28)](https://gibsonai.com/)
@@ -69,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.
 
@@ -125,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
 
@@ -184,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
@@ -203,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.
@@ -234,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.
@@ -263,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
@@ -295,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