gibson-cli 0.1.0__py3-none-any.whl

core/Memory.py

@@ -0,0 +1,148 @@
+import json
+import os
+
+from .Configuration import Configuration
+
+
+class Memory:
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+        self.entities = None
+        self.last = None
+        self.bootstrap()
+
+    def append_last(self, entity: dict):
+        if self.last is None:
+            self.last = {"entities": []}
+
+        self.last["entities"].append(entity)
+        self.remember_last(self.last)
+
+        return self
+
+    def bootstrap(self):
+        self.__make_memory_dir()
+        self.entities = self.recall_entities()
+        self.last = self.recall_last()
+
+    def __forget(self, file):
+        try:
+            os.remove(file)
+        except FileNotFoundError:
+            pass
+
+        return self
+
+    def forget_entities(self):
+        self.__forget(self.get_path_entities())
+        return self
+
+    def forget_last(self):
+        self.__forget(self.get_path_last())
+        return self
+
+    def __recall(self, file):
+        try:
+            with open(file, "r") as f:
+                contents = f.read()
+        except FileNotFoundError:
+            return None
+
+        return json.loads(contents)
+
+    def recall_entities(self):
+        return self.__recall(self.get_path_entities())
+
+    def recall_entity(self, name):
+        entity = self.recall_last_entity(name)
+        if entity is not None:
+            return entity
+
+        entity = self.recall_stored_entity(name)
+        if entity is not None:
+            return entity
+
+        return None
+
+    def recall_last(self):
+        return self.__recall(self.get_path_last())
+
+    def recall_last_entity(self, name):
+        if self.last is not None:
+            for entity in self.last["entities"]:
+                if entity["name"] == name:
+                    return entity
+        return None
+
+    def recall_merged(self):
+        if self.entities is None:
+            if self.last is not None:
+                return self.last["entities"]
+            else:
+                return []
+
+        entities = []
+        last_map = {}
+        if self.last is not None:
+            for entry in self.last["entities"]:
+                last_map[entry["name"]] = True
+                entities.append(entry)
+
+        for entry in self.entities:
+            if entry["name"] not in last_map:
+                entities.append(entry)
+
+        return entities
+
+    def recall_stored_entity(self, name):
+        if self.entities is not None:
+            for entity in self.entities:
+                if entity["name"] == name:
+                    return entity
+
+        return None
+
+    def __remember(self, file, data):
+        with open(file, "w") as f:
+            f.write(json.dumps(data))
+
+        return self
+
+    def remember_entities(self, entities: list):
+        self.__remember(self.get_path_entities(), entities)
+        return self
+
+    def remember_last(self, data: dict):
+        self.__remember(self.get_path_last(), data)
+        return self
+
+    def get_path_entities(self):
+        return self.get_path_top() + "/entities"
+
+    def get_path_last(self):
+        return self.get_path_top() + "/last"
+
+    def get_path_top(self):
+        return (
+            self.configuration.project.paths.memory
+            + "/"
+            + self.configuration.project.name
+        )
+
+    def __make_memory_dir(self):
+        try:
+            os.mkdir(self.get_path_top())
+        except FileExistsError:
+            pass
+
+    def stats(self):
+        num_entities = len(self.entities) if self.entities is not None else 0
+        num_last = len(self.last["entities"]) if self.last is not None else 0
+
+        return {
+            "entities": {"num": num_entities, "word": self.word_entities(num_entities)},
+            "last": {"num": num_last, "word": self.word_entities(num_last)},
+        }
+
+    def word_entities(self, num):
+        return "entities" if num == 0 or num > 1 else "entity"

core/TimeKeeper.py

@@ -0,0 +1,12 @@
+import time
+
+
+class TimeKeeper:
+    def __init__(self):
+        self.__started = time.time()
+
+    def display(self):
+        print(self.get_display() + "\n")
+
+    def get_display(self):
+        return "[%ss]" % str(time.time() - self.__started)[0:7]

core/utils.py

@@ -0,0 +1,19 @@
+def utils_entity_name_to_class_name(entity_name):
+    parts = entity_name.split("_")
+
+    name = []
+    for part in parts:
+        name.append(part.title())
+
+    return "".join(name)
+
+
+def utils_extract_module_name(entity_name):
+    return entity_name.split("_")[0]
+
+
+def utils_is_ref_table(entity_name):
+    try:
+        return entity_name.split("_")[1] == "ref"
+    except IndexError:
+        return False

data/default-ref-table.tmpl

@@ -0,0 +1,4 @@
+create table $entity_name(
+    id bigint not null auto_increment primary key,
+    value varchar(100) default null unique
+)

data/default-table.tmpl

@@ -0,0 +1,6 @@
+create table $entity_name(
+    id bigint not null auto_increment primary key,
+    uuid varchar(36) not null unique,
+    date_created datetime not null default current_timestamp,
+    date_updated datetime default null on update current_timestamp
+)

db/TableExceptions.py

@@ -0,0 +1,6 @@
+class TableExceptions:
+    def mysql(self):
+        return self.universal()
+
+    def universal(self):
+        return ["alembic_version"]

db/tests/test_db_TableExceptions.py

@@ -0,0 +1,9 @@
+from db.TableExceptions import TableExceptions
+
+
+def test_universal():
+    assert TableExceptions().universal() == ["alembic_version"]
+
+
+def test_mysql():
+    assert TableExceptions().mysql() == ["alembic_version"]

dev/Dev.py

@@ -0,0 +1,92 @@
+import os
+
+from core.Configuration import Configuration
+from core.utils import (
+    utils_entity_name_to_class_name,
+    utils_extract_module_name,
+    utils_is_ref_table,
+)
+
+
+class Dev:
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+
+    def api_component(self, file_name, code):
+        self.__write_code(
+            self.configuration.project.dev.api.path,
+            f"{self.configuration.project.dev.api.version}/{file_name}",
+            code,
+        )
+
+        if file_name == "authenticators/DenyAll.py":
+            self.link(
+                os.path.expandvars(self.configuration.project.dev.api.path),
+                self.configuration.project.dev.api.version
+                + "/authenticators/DenyAll.py",
+                self.configuration.project.dev.api.version + "/Authenticator.py",
+            )
+
+        return self
+
+    def base_component(self, file_name, code):
+        self.__write_code(self.configuration.project.dev.base.path, file_name, code)
+
+    def link(self, base_path, source_file, target_file, overwrite=False):
+        target = f"{base_path}/{target_file}"
+        if overwrite is False:
+            if os.path.isfile(target):
+                return self
+
+        os.symlink(f"{base_path}/{source_file}", target)
+
+        return self
+
+    def __mkdirs(self, path):
+        os.makedirs(path, exist_ok=True)
+        return path
+
+    def model(self, entity_name, code):
+        if utils_is_ref_table(entity_name) is True:
+            return self
+
+        module = utils_extract_module_name(entity_name)
+        file = utils_entity_name_to_class_name(entity_name) + ".py"
+
+        return self.__write_code(
+            self.configuration.project.dev.model.path, f"{module}/{file}", code
+        )
+
+    def schema(self, entity_name, code):
+        if utils_is_ref_table(entity_name) is True:
+            return self
+
+        module = utils_extract_module_name(entity_name)
+        file = utils_entity_name_to_class_name(entity_name) + ".py"
+
+        return self.__write_code(
+            self.configuration.project.dev.schema.path,
+            f"{module}/{file}",
+            code,
+        )
+
+    def tests(self, entity_name, code):
+        if utils_is_ref_table(entity_name) is True:
+            return self
+
+        module = utils_extract_module_name(entity_name)
+        file = "test_" + utils_entity_name_to_class_name(entity_name) + "Base.py"
+
+        return self.__write_code(
+            self.configuration.project.dev.model.path, f"{module}/tests/{file}", code
+        )
+
+    def __write_code(self, path, file, code):
+        if self.configuration.project.dev.active is True:
+            full_path = f"{os.path.expandvars(path)}/{file}"
+
+            self.__mkdirs("/".join(full_path.split("/")[0:-1]))
+            with open(full_path, "w") as f:
+                f.write(code)
+
+        return self

display/Header.py

@@ -0,0 +1,6 @@
+class Header:
+    def render(self, text):
+        header = "+--------------------------------------------------------------+\n"
+        header += "| " + text + " " * (61 - len(text)) + "|\n"
+        header += "+--------------------------------------------------------------+"
+        return header

display/WorkspaceFooter.py

@@ -0,0 +1,10 @@
+class WorkspaceFooter:
+    def render(self):
+        return (
+            "=" * 79
+            + "\n"
+            + "[. + enter = exit] "
+            + "[:q + enter = abort] "
+            + "[:w + enter = merge + write code]\n"
+            + "Using natural language, tell me how I can modify this entity."
+        )

display/WorkspaceHeader.py

@@ -0,0 +1,8 @@
+class WorkspaceHeader:
+    def render(self, project_name):
+        return (
+            f"Workspace {project_name}".ljust(50)
+            + " " * 13
+            + "[CONTEXT LOADED]\n"
+            + "=" * 79
+        )

display/tests/test_display_Header.py

@@ -0,0 +1,9 @@
+from display.Header import Header
+
+
+def test_render():
+    assert Header().render("abc def ghi") == (
+        """+--------------------------------------------------------------+
+| abc def ghi                                                  |
++--------------------------------------------------------------+"""
+    )

display/tests/test_display_WorkspaceFooter.py

@@ -0,0 +1,9 @@
+from display.WorkspaceFooter import WorkspaceFooter
+
+
+def test_render():
+    assert WorkspaceFooter().render() == (
+        """===============================================================================
+[. + enter = exit] [:q + enter = abort] [:w + enter = merge + write code]
+Using natural language, tell me how I can modify this entity."""
+    )

display/tests/test_display_WorkspaceHeader.py

@@ -0,0 +1,8 @@
+from display.WorkspaceHeader import WorkspaceHeader
+
+
+def test_render():
+    assert WorkspaceHeader().render("abc def ghi") == (
+        """Workspace abc def ghi                                          [CONTEXT LOADED]
+==============================================================================="""
+    )

gibson_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,306 @@
+Metadata-Version: 2.1
+Name: gibson-cli
+Version: 0.1.0
+Summary: Gibson Command Line Interface
+Author-email: GibsonAI <noc@gibsonai.com>
+Project-URL: Homepage, https://gibsonai.com/
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Gibson CLI
+
+v.0.1.0
+
+## Prerequisites
+
+Gibson currently works on projects that use Python 3.9 or greater, MySQL, SQLAlchemy, Pydantic, Alembic, FastAPI and pytest. It is capable of building a complete application, from database to API end points, using these frameworks. Future enhancements of Gibson will include support for more languages and frameworks.
+
+Portions of the Gibson backend code are written by Gibson.  So far, versus a human developer, it has coded 66% of the software and did so in seconds. To get started, read the instructions here.
+
+## Installation
+
+- Clone this repository somewhere in your environment
+- Modify your `PYTHONPATH` to include a reference to the top level directory here
+- `pip3 install -r requirements.txt`
+- Add the `bin/` directory to your `PATH`
+
+## Key Terms
+
+- Dev Mode
+  - Turn dev mode on to have Gibson write code for you as you execute commands.
+
+- Entity | Entities
+  - Synonymous with a table name or data structure.
+
+- Memory
+  - There are two types of memory: stored (long term) and last (the last action taken).
+
+- Merge
+  - Merge the entities in the last memory into the stored memory.
+
+## Memory Concepts
+
+There are two types of memory maintained by the Gibson CLI:
+
+- `stored` (long term)
+- `last` (short term)
+
+When you import a datastore or API project into Gibson it stores the schema and all of its entities in stored memory. Stored memory is long term. It contains a copy of your database schema and represents the currently stable version of it.
+
+Each time you ask Gibson to do something that results in a new or modified entity it will store it in last memory. Any time you ask the CLI to perform a coding task it will prefer last memory first, then stored memory.
+
+Let's consider a more concrete example. You imported your datastore into the CLI and one of the tables is called "user". You execute:
+
+`gibson modify user I want to add nickname`
+
+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 models`
+
+The CLI will write the code for what is sitting in last memory.
+
+This means you can make changes, try things out and decide if you want to make the changes permanent before merging the changes from last to stored.  You can easily forget the last changes you made by executing:
+
+`gibson forget last`
+
+When you're ready to commit, just execute:
+
+`gibson merge`
+
+Everything in last will be moved to stored and last will be forgotten. Finally, if you want Gibson to recreate your database schema with all the recent changes, just execute:
+
+`gibson build datastore`
+
+Just note, build will first drop all of the tables in the datastore then recreate the database from scratch.
+
+## Logging in
+
+Run `gibson auth login` to login to Gibson with your Google account.
+
+## Acquiring an API Key
+
+While in beta, you have to acquire an API manually:
+
+- Go to <https://staging.gibsonai.com/>.
+- 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]
+
+## Usage
+
+The main command is located in `bin/gibson`. Executing this command with no parameters will provide a help style menu to guide you.
+
+## Configuration
+
+All of Gibson's configuration files and caches are stored in `$HOME/.gibson`. Use `gibson conf` for updating the configuration and `gibson forget` for clearing caches.
+
+### For Windows Users
+
+- Make sure that you have an environment variable called HOME set. Gibson will store its configuration files and caches in this directory. We recommend you keep this directory outside of any repository to which you might be committing.
+- To execute the `gibson` command, follow these instructions:
+  - Assuming the gibson executable is in `c:\Users\\[me]\projects\gibson\bin`
+  - Run `python c:\Users\\[me]\projects\gibson\bin\gibson`
+
+## Editor Integration
+
+### vim
+
+- Make sure the `gibson` command is in your path by editing the `PATH` environment variable
+- Edit `~/.vimrc`
+- Add the following:
+  - `:command! -nargs=* Gibson r ! gibson <args>`
+- Open a file and execute commands:
+  - `:Gibson module abc`
+  - `:Gibson models`
+  - `:Gibson schemas`
+
+## Currently Supported Software
+
+- Python 3.9 or greater
+- MySQL
+- SQLAlchemy
+- Pydantic
+- Alembic
+- FastAPI
+- pytest
+
+More languages and frameworks are in active development. If you do not see a version that you need let us know and we will get on it.
+
+## Coming Very Soon
+
+- pytest based unit tests for all of the code Gibson writes.
+  - We know this is critical for Gibson to prove that its code is production-grade and bug free. As a development team, we need this too. It is coming in short order.
+- Enhanced AI commands at your finger tips with code output and scratch storage.
+  - [DONE] See "Asking Gibson Questions With Context"
+- Context aware coding from your Github repository.
+  - gibson scan
+- AI based feedback directly to Gibson's creator:
+  - `gibson tell mike [hopefully nice things]`
+    - e.g. `gibson tell mike we need support for postgres`
+    - or, `gibson tell mike to hire me, I want to work on gibson`
+- Significant data modeling improvements.
+- The ability to integrate and download Function code using `gibson`.
+  - Along with a number of new Functions.
+- Full FastAPI coding including module and entity specific dispatchers.
+
+## Detailed How-To
+
+### First Step
+
+- Just run `gibson`. He will say hello and walk you through set up.
+
+### Configuring Your API Key
+
+`gibson conf api::key [API key]`
+
+### Configuring Your Datastore
+
+`gibson conf datastore::uri mysql+pymysql://[user]:[password]@[host]/[database name]`
+
+Note: Gibson currently only supports MySQL. Let us know if you need something else.
+
+### Turning On Dev Mode
+
+`gibson dev on`
+
+- We suggest you turn dev mode on and leave it on. With it enabled, Gibson will act like your coworker and write code as you execute commands.
+
+- You will need to provide 3 paths: `base` (where you want project base code to go), `model` (where you want SQLAlchemy models to go) and `schema` (where you want Pydantic schemas to go).
+
+### Importing Your Datastore
+
+`gibson import datastore`
+
+- 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
+
+You may be using a custom SQLAlchemy BaseModel and you do not want Gibson to use the one it has written.
+
+```sh
+gibson conf code::custom::model::class [class name]
+gibson conf code::custom::path [import path]
+```
+
+For example, you might provide class name = `MyBaseModel` and import path = `project.model.MyBaseModel`
+
+### Writing the Base Code
+
+`gibson base`
+
+### Writing the Code for a Single Model
+
+`gibson model [table name]`
+
+### Writing the Code for a Single Schema
+
+`gibson schema [table name]`
+
+### Writing the Code for All Models
+
+`gibson models`
+
+### Writing the Code for All Schemas
+
+`gibson 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 models
+- This will write the code for the entities it just created.
+- gibson merge
+- This will merge the new entities into your project.
+- Note, at the moment Gibson does not build the tables into your datastore.
+
+### Making Changes to the Software Using AI
+
+- `gibson modify [table 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 models`
+- This will write the code for the modified entity.
+- `gibson merge`
+- This will merge the modified entity into your project.
+- Note, at the moment Gibson does not build the modified table into your datastore.
+
+### Forgetting Things Stored in Memory
+
+- `gibson forget stored`
+- `gibson forget last`
+- `gibson forget all`
+
+### Building All of the Entities in Stored Memory into the Datastore
+
+`gibson build`
+
+### Showing an Entity that is Stored in Memory
+
+`gibson show [entity name]`
+
+### Building a Project End-to-End Using AI
+
+- Go to <https://staging.gibsonai.com/>.
+- 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`
+- Magic, no?
+
+### Integrating a Model into Your Code
+
+Gibson creates base-level SQLAlchemy models. To integrate them just do this:
+
+```py
+from my_project.gibsonai.model.Module import ModuleBase
+
+class MyModule(ModuleBase):
+    pass
+```
+
+- When you need to add custom business logic to the model, just modify your version of the model:
+
+```py
+from my_project.gibsonai.model.Module import ModuleBase
+
+class MyModule(ModuleBase):
+    def my_custom_business_logic(self):
+        return 1 + 1
+```
+
+We strongly suggest you do not reference the base-level SQLAlchemy models directly. By sub-classing you won't have to refactor your code if you decide to add custom code.
+
+### Integrating a Schema into Your Code
+
+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.
+
+### Asking Gibson Questions With Context
+
+- `gibson ? [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`).