gibson-cli 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

{core → gibson/core}/Configuration.py

@@ -5,15 +5,12 @@ import shutil
 import sys
 import time
 
-from conf.Dependencies import Dependencies
-from conf.dev.Api import Api
-from conf.dev.Base import Base
-from conf.dev.Model import Model
-from conf.dev.Schema import Schema
-from conf.Platform import Platform
-from conf.Project import Project
-from conf.Paths import ConfigPaths
-from .Conversation import Conversation
+from gibson.conf.Dependencies import Dependencies
+from gibson.conf.Platform import Platform
+from gibson.conf.Project import Project
+from gibson.conf.Paths import ConfigPaths
+from gibson.core.Completions import Completions
+from gibson.core.Conversation import Conversation
 
 
 class Configuration:
@@ -38,6 +35,8 @@ class Configuration:
 
         self.read_config()
 
+        Completions().write().install()
+
     def append_project_to_conf(self, project_name, project_description):
         self.project.api.key = "FIXME"
         self.project.name = project_name
@@ -351,14 +350,18 @@ class Configuration:
 
         return self
 
-    def set_access_token(self, token):
+    def set_auth_tokens(self, access_token, refresh_token):
         try:
             os.mkdir(self.paths.auth)
         except FileExistsError:
             pass
 
         with open(f"{self.paths.auth}/{self.API_ENV}", "w") as f:
-            f.write(json.dumps({"access_token": token}))
+            f.write(
+                json.dumps(
+                    {"access_token": access_token, "refresh_token": refresh_token}
+                )
+            )
 
     def set_config_paths(self, ignore_env_vars=False):
         user_home = os.environ.get("HOME")

{core → gibson/core}/Conversation.py

@@ -5,7 +5,7 @@ import time
 
 import pyfiglet
 
-from conf.Version import Version
+from gibson.conf.Version import Version
 
 
 class Conversation:
@@ -234,10 +234,13 @@ class Conversation:
             if self.__delay is not None:
                 delay = self.__delay
 
-        for char in message:
-            sys.stdout.write(char)
-            sys.stdout.flush()
-            time.sleep(delay)
+        try:
+            for char in message:
+                sys.stdout.write(char)
+                sys.stdout.flush()
+                time.sleep(delay)
+        except KeyboardInterrupt:
+            exit(1)
 
     def unmute(self):
         self.__mute = False

{core → gibson/core}/Env.py

@@ -1,5 +1,5 @@
-from .Configuration import Configuration
-from lang.Python import Python
+from gibson.core.Configuration import Configuration
+from gibson.lang.Python import Python
 
 
 class Env:

{core → gibson/core}/Memory.py

@@ -1,7 +1,7 @@
 import json
 import os
 
-from .Configuration import Configuration
+from gibson.core.Configuration import Configuration
 
 
 class Memory:

gibson/data/bash-completion.tmpl

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+
+# bash completion for Gibson CLI
+
+if ! command -v gibson &>/dev/null; then
+    return
+fi
+
+__gibson_generate_completion() {
+    declare current_word
+    current_word="${COMP_WORDS[COMP_CWORD]}"
+    # shellcheck disable=SC2207
+    COMPREPLY=($(compgen -W "$1" -- "${current_word}"))
+    return 0
+}
+
+__gibson_commands_and_options() {
+    declare current_word
+    declare command
+
+    current_word="${COMP_WORDS[COMP_CWORD]}"
+    COMMANDS='
+        auth
+        build
+        code
+        conf
+        count
+        create
+        dev
+        forget
+        help
+        import
+        list
+        merge
+        model
+        modify
+        new
+        openapi
+        project
+        question
+        remove
+        rename
+        rewrite
+        schema
+        show
+        test
+        tree
+        q
+    '
+
+    case "${current_word}" in
+    -*) __gibson_options ;;
+    *) __gibson_generate_completion "${COMMANDS}" ;;
+    esac
+}
+
+__gibson_options() {
+    OPTIONS='--version -v'
+    __gibson_generate_completion "${OPTIONS}"
+}
+
+__gibson_completions() {
+    declare previous_word
+    previous_word="${COMP_WORDS[COMP_CWORD - 1]}"
+
+    case "${previous_word}" in
+    gibson) __gibson_commands_and_options ;;
+    auth) __gibson_generate_completion "login logout" ;;
+    # config) __gibson_generate_completion "set get" ;;
+    # create) __gibson_generate_completion "project module entity" ;;
+    # new) __gibson_generate_completion "project module entity" ;;
+    # project) __gibson_generate_completion "create delete list" ;;
+    # rename) __gibson_generate_completion "entity" ;;
+    # rewrite) __gibson_generate_completion "api base models schemas tests" ;;
+    esac
+
+    return 0
+}
+
+# complete is a bash builtin, but recent versions of ZSH come with a function
+# called bashcompinit that will create a complete in ZSH. If the user is in
+# ZSH, load and run bashcompinit before calling the complete function.
+if [[ -n ${ZSH_VERSION-} ]]; then
+    # First calling compinit (only if not called yet!)
+    # and then bashcompinit as mentioned by zsh man page.
+    if ! command -v compinit >/dev/null; then
+        autoload -U +X compinit && if [[ ${ZSH_DISABLE_COMPFIX-} = true ]]; then
+            compinit -u
+        else
+            compinit
+        fi
+    fi
+    autoload -U +X bashcompinit && bashcompinit
+fi
+
+complete -o default -F __gibson_completions gibson

{db → gibson/db}/tests/test_db_TableExceptions.py

@@ -1,4 +1,4 @@
-from db.TableExceptions import TableExceptions
+from gibson.db.TableExceptions import TableExceptions
 
 
 def test_universal():

{dev → gibson/dev}/Dev.py

@@ -1,7 +1,7 @@
 import os
 
-from core.Configuration import Configuration
-from core.utils import (
+from gibson.core.Configuration import Configuration
+from gibson.core.utils import (
     utils_entity_name_to_class_name,
     utils_extract_module_name,
     utils_is_ref_table,
@@ -18,15 +18,6 @@ class Dev:
             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):

{display → gibson/display}/tests/test_display_Header.py

@@ -1,4 +1,4 @@
-from display.Header import Header
+from gibson.display.Header import Header
 
 
 def test_render():

{display → gibson/display}/tests/test_display_WorkspaceFooter.py

@@ -1,4 +1,4 @@
-from display.WorkspaceFooter import WorkspaceFooter
+from gibson.display.WorkspaceFooter import WorkspaceFooter
 
 
 def test_render():

{display → gibson/display}/tests/test_display_WorkspaceHeader.py

@@ -1,4 +1,4 @@
-from display.WorkspaceHeader import WorkspaceHeader
+from gibson.display.WorkspaceHeader import WorkspaceHeader
 
 
 def test_render():

{lang → gibson/lang}/Python.py

@@ -27,7 +27,7 @@ class Python:
 
         os_path = os.path.expandvars(os_path)
 
-        pythonpath = os.environ["PYTHONPATH"].split(":")
+        pythonpath = os.environ.get("PYTHONPATH", "").split(":")
         for entry in pythonpath:
             path = os_path.replace(entry, "")
             if path != os_path:

{lang → gibson/lang}/tests/test_lang_Python.py

@@ -2,7 +2,7 @@ import os
 
 import pytest
 
-from lang.Python import Python
+from gibson.lang.Python import Python
 
 
 def test_make_python_path_no_match():

{services → gibson/services}/auth/Server.py

@@ -11,10 +11,14 @@ class Handler(BaseHTTPRequestHandler):
     def do_GET(self):
         url = urlparse(self.path)
         params = parse_qs(url.query)
-        token = params.get("token", [""])[0]
+        access_token = params.get("access_token", [""])[0]
+        refresh_token = params.get("refresh_token", [""])[0]
 
-        if token:
-            self.server.token = token
+        if access_token and access_token != "null":
+            self.server.access_token = access_token
+
+        if refresh_token and refresh_token != "null":
+            self.server.refresh_token = refresh_token
 
         self.send_response(302)
         self.send_header("Location", f"{self.server.app_domain}/chat")
@@ -29,7 +33,8 @@ class Handler(BaseHTTPRequestHandler):
 # Temporary HTTP server to handle the login process
 class Server(HTTPServer):
     port = None
-    token = None
+    access_token = None
+    refresh_token = None
     thread = None
 
     def __init__(self, app_domain: str):
@@ -40,7 +45,7 @@ class Server(HTTPServer):
 
         self.app_domain = app_domain
 
-    def get_token(self):
+    def get_tokens(self):
         self._start()
         self._open_browser()
 
@@ -50,7 +55,7 @@ class Server(HTTPServer):
         except KeyboardInterrupt:
             self._stop()
 
-        return self.token
+        return self.access_token, self.refresh_token
 
     def _open_browser(self):
         webbrowser.open(f"{self.app_domain}/signup?cli={self.port}")

{services → gibson/services}/code/context/schema/EntityKeys.py

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

{services → gibson/services}/code/context/schema/Manager.py

@@ -1,5 +1,5 @@
-from services.code.context.schema.DataDictionary import DataDictionary
-from services.code.context.schema.EntityKeys import EntityKeys
+from gibson.services.code.context.schema.DataDictionary import DataDictionary
+from gibson.services.code.context.schema.EntityKeys import EntityKeys
 
 
 class Manager:

{services → gibson/services}/code/context/schema/tests/test_code_context_schema_DataDictionary.py

@@ -1,4 +1,4 @@
-from services.code.context.schema.DataDictionary import DataDictionary
+from gibson.services.code.context.schema.DataDictionary import DataDictionary
 
 
 def test_configure():

{services → gibson/services}/code/context/schema/tests/test_code_context_schema_EntityKeys.py

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

{services → gibson/services}/code/context/schema/tests/test_code_context_schema_Manager.py

@@ -1,5 +1,5 @@
-from services.code.context.schema.EntityKeys import EntityKeys
-from services.code.context.schema.Manager import Manager
+from gibson.services.code.context.schema.EntityKeys import EntityKeys
+from gibson.services.code.context.schema.Manager import Manager
 
 
 def test_get_entity_keys_no_such_entity_name():

{services → gibson/services}/code/customization/Authenticator.py

@@ -1,7 +1,7 @@
 import os
 
-from core.Configuration import Configuration
-from services.code.customization.BaseCustomization import BaseCustomization
+from gibson.core.Configuration import Configuration
+from gibson.services.code.customization.BaseCustomization import BaseCustomization
 
 
 class Authenticator(BaseCustomization):

{services → gibson/services}/code/customization/BaseCustomization.py

@@ -1,4 +1,4 @@
-from core.Configuration import Configuration
+from gibson.core.Configuration import Configuration
 
 
 class BaseCustomization:

{services → gibson/services}/code/customization/CustomizationManager.py

@@ -1,5 +1,5 @@
-from core.Configuration import Configuration
-from services.code.customization.Authenticator import Authenticator
+from gibson.core.Configuration import Configuration
+from gibson.services.code.customization.Authenticator import Authenticator
 
 
 class CustomizationManager:

{services → gibson/services}/code/customization/tests/test_code_customization_Authenticator.py

@@ -1,8 +1,8 @@
 import os
 import shutil
 
-from core.Configuration import Configuration
-from services.code.customization.Authenticator import Authenticator
+from gibson.core.Configuration import Configuration
+from gibson.services.code.customization.Authenticator import Authenticator
 
 
 def test_link_target():

{services → gibson/services}/code/customization/tests/test_code_customization_BaseCustomization.py

@@ -1,7 +1,7 @@
 import pytest
 
-from core.Configuration import Configuration
-from services.code.customization.BaseCustomization import BaseCustomization
+from gibson.core.Configuration import Configuration
+from gibson.services.code.customization.BaseCustomization import BaseCustomization
 
 
 def test_preserve_exception():

{structure → gibson/structure}/Entity.py

@@ -1,5 +1,5 @@
-from structure.keys.ForeignKey import ForeignKey
-from structure.keys.Index import Index
+from gibson.structure.keys.ForeignKey import ForeignKey
+from gibson.structure.keys.Index import Index
 
 
 class Entity:

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

@@ -1,4 +1,4 @@
-from structure.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
 
 
 class ForeignKey:

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

@@ -1,4 +1,4 @@
-from structure.keys.IndexAttribute import IndexAttribute
+from gibson.structure.keys.IndexAttribute import IndexAttribute
 
 
 class Index:

{structure → gibson/structure}/keys/tests/test_ForeignKey.py

@@ -1,7 +1,7 @@
 import pytest
 
-from structure.constraints.ReferenceConstraint import ReferenceConstraint
-from structure.keys.ForeignKey import ForeignKey
+from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.keys.ForeignKey import ForeignKey
 
 
 def test_sql_exceptions():

{structure → gibson/structure}/keys/tests/test_Index.py

@@ -1,6 +1,6 @@
 import pytest
 
-from structure.keys.Index import Index
+from gibson.structure.keys.Index import Index
 
 
 def test_sql_exceptions():

{structure → gibson/structure}/keys/tests/test_IndexAttribute.py

@@ -1,4 +1,4 @@
-from structure.keys.IndexAttribute import IndexAttribute
+from gibson.structure.keys.IndexAttribute import IndexAttribute
 
 
 def test_sql():

{structure → gibson/structure}/testing.py

@@ -1,4 +1,4 @@
-from structure.Entity import Entity
+from gibson.structure.Entity import Entity
 
 
 def structure_testing_get_entity():

{structure → gibson/structure}/tests/test_Entity.py

@@ -1,10 +1,10 @@
 import pytest
 
-from structure.constraints.ReferenceConstraint import ReferenceConstraint
-from structure.Entity import Entity
-from structure.keys.ForeignKey import ForeignKey
-from structure.keys.Index import Index
-from structure.testing import (
+from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.Entity import Entity
+from gibson.structure.keys.ForeignKey import ForeignKey
+from gibson.structure.keys.Index import Index
+from gibson.structure.testing import (
     structure_testing_get_entity,
     structure_testing_get_struct_data,
 )

gibson/tests/test_Env.py

@@ -0,0 +1,14 @@
+import pytest
+
+from gibson.core.Configuration import Configuration
+from gibson.core.Env import Env
+
+
+def test_verify_language_exception():
+    configuration = Configuration()
+    configuration.project.code.language = "invalid"
+
+    with pytest.raises(RuntimeError) as e:
+        Env().verify(configuration)
+
+    assert str(e.value) == 'unrecognized language "invalid"'

gibson/tests/test_Memory.py

@@ -0,0 +1,89 @@
+from gibson.core.Configuration import Configuration
+from gibson.core.Memory import Memory
+
+
+def test_recall_merged_no_entities():
+    memory = Memory(Configuration())
+    memory.entities = None
+    memory.last = None
+
+    assert memory.recall_merged() == []
+
+
+def test_recall_merged_entities_only():
+    memory = Memory(Configuration())
+    memory.entities = [{"definition": "abc", "name": "def"}]
+    memory.last = None
+
+    assert memory.recall_merged() == [{"definition": "abc", "name": "def"}]
+
+
+def test_recall_merged_last_only():
+    memory = Memory(Configuration())
+    memory.entities = None
+    memory.last = {"entities": [{"definition": "abc", "name": "def"}]}
+
+    assert memory.recall_merged() == [{"definition": "abc", "name": "def"}]
+
+
+def test_recall_merged_no_overlap():
+    memory = Memory(Configuration())
+    memory.entities = [{"definition": "abc", "name": "def"}]
+    memory.last = {"entities": [{"definition": "ghi", "name": "jkl"}]}
+
+    assert memory.recall_merged() == [
+        {"definition": "ghi", "name": "jkl"},
+        {"definition": "abc", "name": "def"},
+    ]
+
+
+def test_recall_merged_overlap():
+    memory = Memory(Configuration())
+    memory.entities = [
+        {"definition": "abc", "name": "def"},
+        {"definition": "ghi", "name": "jkl"},
+    ]
+    memory.last = {
+        "entities": [
+            {"definition": "xyz", "name": "def"},
+            {"definition": "mno", "name": "pqr"},
+        ]
+    }
+
+    assert memory.recall_merged() == [
+        {"definition": "xyz", "name": "def"},
+        {"definition": "mno", "name": "pqr"},
+        {"definition": "ghi", "name": "jkl"},
+    ]
+
+
+def test_recall_entity_none():
+    memory = Memory(Configuration())
+    memory.entities = None
+    memory.last = None
+
+    assert memory.recall_entity("abc") is None
+
+
+def test_recall_entity_entities():
+    memory = Memory(Configuration())
+    memory.entities = [{"definition": "abc", "name": "def"}]
+    memory.last = None
+
+    assert memory.recall_entity("def") == {"definition": "abc", "name": "def"}
+
+
+def test_recall_entity_last():
+    memory = Memory(Configuration())
+    memory.entities = None
+    memory.last = {"entities": [{"definition": "abc", "name": "def"}]}
+
+    assert memory.recall_entity("def") == {"definition": "abc", "name": "def"}
+
+
+def test_recall_entity_prefer_last():
+    memory = Memory(Configuration())
+    memory.entities = [{"definition": "abc", "name": "def"}]
+    memory.last = {"entities": [{"definition": "xyz", "name": "def"}]}
+
+    assert memory.recall_entity("def") == {"definition": "xyz", "name": "def"}

gibson/tests/test_utils.py

@@ -0,0 +1,20 @@
+from gibson.core.utils import (
+    utils_entity_name_to_class_name,
+    utils_extract_module_name,
+    utils_is_ref_table,
+)
+
+
+def test_entity_name_to_class_name():
+    assert utils_entity_name_to_class_name("abc_def_ghi") == "AbcDefGhi"
+
+
+def test_extract_module_name():
+    assert utils_extract_module_name("abc_def_ghi") == "abc"
+
+
+def test_is_ref_table():
+    assert utils_is_ref_table("abc") is False
+    assert utils_is_ref_table("abc_def") is False
+    assert utils_is_ref_table("abc_ref") is True
+    assert utils_is_ref_table("abc_ref_def") is True

{gibson_cli-0.1.2.dist-info → gibson_cli-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gibson-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/