gibson-cli 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

gibson/api/BaseApi.py

@@ -25,7 +25,15 @@ class BaseApi:
         return r.json()
 
     def headers(self):
-        raise NotImplementedError
+        headers = {
+            "X-Gibson-Client-ID": self.configuration.client_id(),
+        }
+
+        token = self.configuration.get_access_token()
+        if token is not None:
+            headers["Authorization"] = f"Bearer {token}"
+
+        return headers
 
     def post(self, endpoint, json: dict):
         r = requests.post(self.url(endpoint), headers=self.headers(), json=json)

gibson/api/Cli.py

@@ -1,16 +1,16 @@
+from gibson.api.BaseApi import BaseApi
 from gibson.core.Configuration import Configuration
 from gibson.core.Memory import Memory
 from gibson.lang.Python import Python
 
-from .BaseApi import BaseApi
-
 
 class Cli(BaseApi):
     PREFIX = "cli"
 
     def __init__(self, configuration: Configuration):
         self.configuration = configuration
-        self.configuration.ensure_project()
+        self.configuration.require_login()
+        self.configuration.require_project()
 
     def code_api(self):
         return self.post(
@@ -64,15 +64,8 @@ class Cli(BaseApi):
         ).json()
 
     def headers(self):
-        headers = {
-            "X-Gibson-Client-ID": self.configuration.client_id(),
-            "X-Gibson-API-Key": self.configuration.project.api.key,
-        }
-
-        token = self.configuration.get_access_token()
-        if token is not None:
-            headers["Authorization"] = f"Bearer {token}"
-
+        headers = super().headers()
+        headers["X-Gibson-API-Key"] = self.configuration.project.api.key
         return headers
 
     def import_(self):

gibson/api/ProjectApi.py

@@ -0,0 +1,13 @@
+from gibson.api.BaseApi import BaseApi
+from gibson.core.Configuration import Configuration
+
+
+class ProjectApi(BaseApi):
+    PREFIX = "project"
+
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+        self.configuration.require_login()
+
+    def all_projects(self):
+        return self.get("all")["projects"]

gibson/command/Build.py

@@ -3,8 +3,8 @@ import sys
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, subcommand
 from gibson.db.TableExceptions import TableExceptions
 
 
@@ -49,7 +49,7 @@ class Build(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] != "datastore":
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
 
         if self.memory.entities is None or len(self.memory.entities) == 0:
             self.no_entities()
@@ -72,7 +72,7 @@ class Build(BaseCommand):
             else ""
         )
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('build')} {argument('datastore')} {hint('build the datastore')} {datastore_uri}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('build')} {Colors.argument('datastore')} {Colors.hint('build the datastore')} {datastore_uri}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Conf.py

@@ -1,7 +1,7 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Conf(BaseCommand):
@@ -39,7 +39,7 @@ class Conf(BaseCommand):
         except KeyError:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
         self.conversation.type(f"{key}\n")
         self.conversation.type(f"  [old value] {old_value}\n")
@@ -61,12 +61,12 @@ class Conf(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('conf')} {argument('[key]')} {input('[value]')} {hint('set a configuration value')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('conf')} {Colors.argument('[key]')} {Colors.input('[value]')} {Colors.hint('set a configuration value')}\n"
         )
         self.conversation.newline()
 
         if self.configuration.project:
-            self.conversation.type(f"  where {argument('[key]')} is one of:\n")
+            self.conversation.type(f"  where {Colors.argument('[key]')} is one of:\n")
             self.conversation.set_delay(0.004)
 
             for key in self.get_configuration_keys():

gibson/command/Count.py

@@ -1,7 +1,7 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import arguments, command, hint, subcommand
 
 
 class Count(BaseCommand):
@@ -9,7 +9,7 @@ class Count(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] not in ["last", "stored"]:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
 
         if sys.argv[2] == "last":
             count = 0
@@ -31,7 +31,7 @@ class Count(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('count')} {arguments(['last', 'stored'])} {hint('display the number of entities')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('count')} {Colors.arguments(['last', 'stored'])} {Colors.hint('display the number of entities')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Dev.py

@@ -1,8 +1,8 @@
 import os
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import arguments, command, hint, subcommand
 from gibson.lang.Python import Python
 
 
@@ -30,7 +30,7 @@ class Dev(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] not in ["off", "on"]:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
 
         if sys.argv[2] == "off":
             if self.configuration.project.dev.active is True:
@@ -119,7 +119,7 @@ class Dev(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('dev')} {arguments(['off', 'on'])} {hint('turn dev mode on or off')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('dev')} {Colors.arguments(['off', 'on'])} {Colors.hint('turn dev mode on or off')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Forget.py

@@ -1,7 +1,7 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import arguments, command, hint, subcommand
 
 
 class Forget(BaseCommand):
@@ -9,7 +9,7 @@ class Forget(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] not in ["all", "last", "stored"]:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
         if sys.argv[2] in ["all", "last"]:
@@ -27,7 +27,7 @@ class Forget(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('forget')} {arguments(['all', 'last', 'stored'])} {hint('delete entities from memory')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('forget')} {Colors.arguments(['all', 'last', 'stored'])} {Colors.hint('delete entities from memory')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Import.py

@@ -3,10 +3,10 @@ import sys
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.rewrite.Rewrite import Rewrite
-from gibson.core.Colors import argument, arguments, command, hint, option, subcommand
 from gibson.db.TableExceptions import TableExceptions
 
 
@@ -15,7 +15,7 @@ class Import(BaseCommand):
         if len(sys.argv) != 3 and len(sys.argv) != 5:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         write_code = False
         if len(sys.argv) == 5:
             if sys.argv[3] != ".." or sys.argv[4] != "dev":
@@ -106,13 +106,13 @@ class Import(BaseCommand):
             else ""
         )
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('import')} {argument('api')} {hint('import all entities from your project created on GibsonAI.com')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('api')} {Colors.hint('import all entities from your project created on GibsonAI.com')}\n"
         )
         self.conversation.type(
-            f"   or: {command(self.configuration.command)} {subcommand('import')} {argument('datastore')} {hint('import all entities from your local datastore')} {datastore_uri}\n"
+            f"   or: {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('datastore')} {Colors.hint('import all entities from your local datastore')} {datastore_uri}\n"
         )
         self.conversation.type(
-            f"   or: {command(self.configuration.command)} {subcommand('import')} {arguments(['api', 'datastore'])} {option('.. dev')} {hint('have dev mode write all the code')}\n"
+            f"   or: {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.arguments(['api', 'datastore'])} {Colors.option('.. dev')} {Colors.hint('have dev mode write all the code')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Merge.py

@@ -3,7 +3,7 @@ from gibson.command.BaseCommand import BaseCommand
 
 class Merge(BaseCommand):
     def execute(self):
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
         if self.memory.last is None or "entities" not in self.memory.last:

gibson/command/Model.py

@@ -1,8 +1,8 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import command, hint, input, subcommand
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -12,7 +12,7 @@ class Model(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -35,7 +35,7 @@ class Model(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('model')} {input('[entity name]')} {hint('generate the model for an entity')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('model')} {Colors.input('[entity name]')} {Colors.hint('generate the model for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Modify.py

@@ -1,8 +1,8 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Modify(BaseCommand):
@@ -10,7 +10,7 @@ class Modify(BaseCommand):
         if len(sys.argv) < 4:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         entity = self.memory.recall_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -34,7 +34,7 @@ class Modify(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('modify')} {argument('[entity name]')} {input('[instructions]')} {hint('modify an entity with natural language instructions')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('modify')} {Colors.argument('[entity name]')} {Colors.input('[instructions]')} {Colors.hint('modify an entity with natural language instructions')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/OpenApi.py

@@ -2,9 +2,9 @@ import json
 import re
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import command, hint, input, subcommand
 
 
 class OpenApi(BaseCommand):
@@ -31,7 +31,7 @@ class OpenApi(BaseCommand):
         if "paths" not in contents:
             self.unrecognized_format()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
         if contents.get("info", None) is not None:
@@ -135,7 +135,7 @@ class OpenApi(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('openapi')} {input('[file path]')} {hint('import entities from an OpenAPI spec file')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('openapi')} {Colors.input('[file path]')} {Colors.hint('import entities from an OpenAPI spec file')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Question.py

@@ -1,9 +1,9 @@
 import os
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Question(BaseCommand):
@@ -15,7 +15,7 @@ class Question(BaseCommand):
         if len(sys.argv) < 3:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         instructions = ""
         has_file = False
         has_python = False
@@ -96,16 +96,16 @@ class Question(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('q')} {input('[instructions]')} {hint('ask a question or tell Gibson to do something using natural language')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('q')} {Colors.input('[instructions]')} {Colors.hint('ask a question or tell Gibson to do something using natural language')}\n"
         )
         self.conversation.type(
-            f"    use {argument(self.TOKEN_FILE+'[path]')} to import a file from the filesystem\n"
+            f"    use {Colors.argument(self.TOKEN_FILE+'[path]')} to import a file from the filesystem\n"
         )
         self.conversation.type(
-            f"    use {argument(self.TOKEN_PYTHON+'[import]')} to import a file from PYTHONPATH\n"
+            f"    use {Colors.argument(self.TOKEN_PYTHON+'[import]')} to import a file from PYTHONPATH\n"
         )
         self.conversation.type(
-            f"    use {argument(self.TOKEN_SQL+'[entity name]')} to import SQL\n"
+            f"    use {Colors.argument(self.TOKEN_SQL+'[entity name]')} to import SQL\n"
         )
 
         self.conversation.newline()

gibson/command/Remove.py

@@ -1,9 +1,9 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.rewrite.Rewrite import Rewrite
-from gibson.core.Colors import command, hint, input, subcommand
 
 
 class Remove(BaseCommand):
@@ -11,7 +11,7 @@ class Remove(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
         found = False
@@ -74,7 +74,7 @@ class Remove(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('remove')} {input('[entity name]')} {hint('remove an entity from the project')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('remove')} {Colors.input('[entity name]')} {Colors.hint('remove an entity from the project')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Schema.py

@@ -1,8 +1,8 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, subcommand
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -12,7 +12,7 @@ class Schema(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -35,7 +35,7 @@ class Schema(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('schema')} {argument('[entity name]')} {hint('write the schema code for an entity')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('schema')} {Colors.argument('[entity name]')} {Colors.hint('write the schema code for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Show.py

@@ -1,19 +1,19 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, subcommand
 
 
 class Show(BaseCommand):
     def execute(self):
         if len(sys.argv) == 2:
-            self.configuration.ensure_project()
+            self.configuration.require_project()
             entities = self.memory.recall_merged()
             if entities is None:
                 self.conversation.cant_no_entities(self.configuration.project.name)
                 exit(1)
         elif len(sys.argv) == 3:
-            self.configuration.ensure_project()
+            self.configuration.require_project()
             entity = self.memory.recall_entity(sys.argv[2])
             if entity is None:
                 self.conversation.not_sure_no_entity(
@@ -25,16 +25,19 @@ class Show(BaseCommand):
         else:
             self.usage()
 
-        for entity in entities:
-            print(entity["definition"])
+        for entity in sorted(entities, key=lambda x: x["name"]):
+            statement = entity["definition"].replace(
+                entity["name"], Colors.argument(entity["name"])
+            )
+            print(f"\n{statement}")
 
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('show')} {hint('display the entire schema')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('show')} {Colors.hint('display the entire schema')}\n"
         )
         self.conversation.type(
-            f"   or: {command(self.configuration.command)} {subcommand('show')} {argument('[entity name]')} {hint('display the schema for an entity')}\n"
+            f"   or: {Colors.command(self.configuration.command)} {Colors.subcommand('show')} {Colors.argument('[entity name]')} {Colors.hint('display the schema for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Test.py

@@ -1,8 +1,8 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, subcommand
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -12,7 +12,7 @@ class Test(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -35,7 +35,7 @@ class Test(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('test')} {argument('[entity name]')} {hint('write the unit tests for an entity')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('test')} {Colors.argument('[entity name]')} {Colors.hint('write the unit tests for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Tree.py

@@ -5,7 +5,7 @@ from .BaseCommand import BaseCommand
 
 class Tree(BaseCommand):
     def execute(self):
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
         if self.configuration.project.dev.base.path is None:

gibson/command/Version.py

@@ -1,8 +1,8 @@
 import requests
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
 from gibson.conf.Version import Version as VersionConf
-from gibson.core.Colors import Color, colorize, command, option, subcommand
 
 
 class Version(BaseCommand):
@@ -15,18 +15,15 @@ class Version(BaseCommand):
 
         if latest_version != VersionConf.num:
             self.conversation.type(
-                f"A new version of {command(self.configuration.command)} is available: {colorize(latest_version, Color.CYAN)}\n"
+                f"A new version of {Colors.command(self.configuration.command)} is available: {Colors.colorize(latest_version, Colors.Color.CYAN)}\n"
             )
             self.conversation.type(
-                f"You are currently using version: {colorize(VersionConf.num, Color.VIOLET)}\n"
+                f"You are currently using version: {Colors.colorize(VersionConf.num, Colors.Color.VIOLET)}\n"
             )
             self.conversation.type(
-                f"Please update to the latest version by running: {command('pip3')} {subcommand('install')} {option('--upgrade')} gibson-cli\n"
+                f"Please update to the latest version by running: {Colors.command('pip3')} {Colors.subcommand('install')} {Colors.option('--upgrade')} gibson-cli\n"
             )
         else:
             self.conversation.type(
-                f"Nice! You are using the latest version of {command(self.configuration.command)}: {colorize(VersionConf.num, Color.CYAN)}\n"
+                f"Nice! 🎉 You are using the latest version of {Colors.command(self.configuration.command)}: {Colors.colorize(VersionConf.num, Colors.Color.CYAN)}\n"
             )
-
-        self.conversation.newline()
-        return True

gibson/command/auth/Auth.py

@@ -1,9 +1,9 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.auth.Login import Login
 from gibson.command.auth.Logout import Logout
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, command, hint, subcommand
 
 
 class Auth(BaseCommand):
@@ -20,10 +20,10 @@ class Auth(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('auth')} {argument('login')} {hint('login to Gibson')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('auth')} {Colors.argument('login')} {Colors.hint('login to Gibson')}\n"
         )
         self.conversation.type(
-            f"   or: {command(self.configuration.command)} {subcommand('auth')} {argument('logout')} {hint('logout of Gibson')}\n"
+            f"   or: {Colors.command(self.configuration.command)} {Colors.subcommand('auth')} {Colors.argument('logout')} {Colors.hint('logout of Gibson')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/code/Code.py

@@ -0,0 +1,26 @@
+import sys
+
+import gibson.core.Colors as Colors
+from gibson.command.BaseCommand import BaseCommand
+from gibson.command.code.Entity import Entity
+
+
+class Code(BaseCommand):
+    def execute(self):
+        if len(sys.argv) == 4 and sys.argv[2] == "entity":
+            Entity(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.argument('entity')} {Colors.input('[entity name]')} {Colors.hint('create a new entity')}\n"
+        )
+        self.conversation.newline()
+        self.conversation.type(
+            '  To create a new entity named "user":\n'
+            f"      {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('entity')} {Colors.input('user')}\n"
+        )
+        self.conversation.newline()
+        exit(1)

gibson/command/{Code.py → code/Entity.py}

@@ -1,5 +1,4 @@
 import os
-import re
 import sys
 from string import Template
 
@@ -7,7 +6,6 @@ from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.Merge import Merge
 from gibson.command.rewrite.Rewrite import Rewrite
-from gibson.core.Colors import argument, command, hint, input, subcommand
 from gibson.core.Configuration import Configuration
 from gibson.display.Header import Header
 from gibson.display.WorkspaceFooter import WorkspaceFooter
@@ -18,7 +16,7 @@ from gibson.services.code.context.schema.Manager import (
 from gibson.structure.Entity import Entity
 
 
-class Code(BaseCommand):
+class Entity(BaseCommand):
     CODE_WRITER_ENTITY_MODIFIER_NOOP = ""
 
     def __init__(self, configuration: Configuration):
@@ -82,12 +80,9 @@ class Code(BaseCommand):
             return Template(f.read()).substitute({"entity_name": sys.argv[3]})
 
     def execute(self):
-        if len(sys.argv) != 4 or sys.argv[2] not in ["entity"]:
-            self.usage()
-
         cli = Cli(self.configuration)
 
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
         definition = self.configure_definition()
 
@@ -184,16 +179,3 @@ class Code(BaseCommand):
 
         print("")
         print(WorkspaceFooter().render())
-
-    def usage(self):
-        self.configuration.display_project()
-        self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('code')} {argument('entity')} {input('[entity name]')} {hint('create a new entity')}\n"
-        )
-        self.conversation.newline()
-        self.conversation.type(
-            '  To create a new entity named "user":\n'
-            f"      {command(self.configuration.command)} {subcommand('code')} {argument('entity')} {input('user')}\n"
-        )
-        self.conversation.newline()
-        exit(1)

gibson/command/{List.py → list/Entities.py}

@@ -1,16 +1,11 @@
 import sys
 
-from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import arguments, command, hint, subcommand
 
 
-class List(BaseCommand):
+class Entities(BaseCommand):
     def execute(self):
-        if len(sys.argv) != 3:
-            self.usage()
-
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
         entities = {"last": [], "stored": []}
@@ -54,11 +49,3 @@ class List(BaseCommand):
                     self.conversation.newline()
 
                 self.conversation.newline()
-
-    def usage(self):
-        self.configuration.display_project()
-        self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('list')} {arguments(['entities'])} {hint('list all entities')}\n"
-        )
-        self.conversation.newline()
-        exit(1)

gibson/command/list/List.py

@@ -0,0 +1,27 @@
+import sys
+
+import gibson.core.Colors as Colors
+from gibson.command.BaseCommand import BaseCommand
+from gibson.command.list.Entities import Entities
+from gibson.command.list.Projects import Projects
+
+
+class List(BaseCommand):
+    def execute(self):
+        if len(sys.argv) == 3 and sys.argv[2] == "entities":
+            Entities(self.configuration).execute()
+        elif len(sys.argv) == 3 and sys.argv[2] == "projects":
+            Projects(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('list')} {Colors.arguments(['entities'])} {Colors.hint('list all entities')}\n"
+        )
+        self.conversation.type(
+            f"   or: {Colors.command(self.configuration.command)} {Colors.subcommand('list')} {Colors.arguments(['projects'])} {Colors.hint('list all projects')}\n"
+        )
+        self.conversation.newline()
+        exit(1)

gibson/command/list/Projects.py

@@ -0,0 +1,25 @@
+import re
+
+import gibson.core.Colors as Colors
+from gibson.api.ProjectApi import ProjectApi
+from gibson.command.BaseCommand import BaseCommand
+
+
+class Projects(BaseCommand):
+    def execute(self):
+        self.configuration.require_login()
+        projects = ProjectApi(self.configuration).all_projects()
+
+        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()
+
+        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()

gibson/command/new/Module.py

@@ -1,15 +1,17 @@
+import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Colors import argument, arguments, command, hint, subcommand
 
 
 class Module(BaseCommand):
     def execute(self):
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         module_name = self.conversation.prompt_module()
 
         self.conversation.newline()
-        self.conversation.type(f"Generating new module: {argument(module_name)}\n")
+        self.conversation.type(
+            f"Generating new module: {Colors.argument(module_name)}\n"
+        )
 
         cli = Cli(self.configuration)
         response = cli.modeler_module(
@@ -22,7 +24,7 @@ class Module(BaseCommand):
 
         self.conversation.newline()
         self.conversation.type(
-            f"The following entities were created in your {argument('last')} memory:\n"
+            f"The following entities were created in your {Colors.argument('last')} memory:\n"
         )
 
         for entity in response["entities"]:
@@ -32,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"{command(self.configuration.command)} {subcommand('merge')}\n"
+            f"{Colors.command(self.configuration.command)} {Colors.subcommand('merge')}\n"
         )
 
         self.conversation.newline()
@@ -40,5 +42,5 @@ class Module(BaseCommand):
             f"Afterwards, you can modify any of these entities by running:\n"
         )
         self.conversation.type(
-            f"{command(self.configuration.command)} {subcommand('modify')} {argument('[entity name]')} {input('[instructions]')}\n"
+            f"{Colors.command(self.configuration.command)} {Colors.subcommand('modify')} {Colors.argument('[entity name]')} {Colors.input('[instructions]')}\n"
         )

gibson/command/new/New.py

@@ -1,9 +1,9 @@
 import sys
 
+import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.new.Module import Module
 from gibson.command.new.Project import Project
-from gibson.core.Colors import argument, arguments, command, hint, subcommand
 
 
 class New(BaseCommand):
@@ -20,13 +20,13 @@ class New(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('new')} {arguments(['project', 'module'])} {hint('create something new')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.arguments(['project', 'module'])} {Colors.hint('create something new')}\n"
         )
         self.conversation.type(
-            f"       {command(self.configuration.command)} {subcommand('new')} {argument('project')} {hint('create a new project')}\n"
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.argument('project')} {Colors.hint('create a new project')}\n"
         )
         self.conversation.type(
-            f"       {command(self.configuration.command)} {subcommand('new')} {argument('module')} {hint('create a new module')}\n"
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('new')} {Colors.argument('module')} {Colors.hint('create a new module')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/{Rename.py → rename/Entity.py}

@@ -3,27 +3,23 @@ import sys
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.rewrite.Rewrite import Rewrite
-from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
-class Rename(BaseCommand):
+class Entity(BaseCommand):
     def execute(self):
-        if len(sys.argv) != 4:
-            self.usage()
-
-        self.configuration.ensure_project()
+        self.configuration.require_project()
         self.configuration.display_project()
 
-        if self.memory.recall_entity(sys.argv[2]) is None:
+        if self.memory.recall_entity(sys.argv[3]) is None:
             self.conversation.type(
-                f'Nothing renamed, did not find entity named "{sys.argv[2]}".\n'
+                f'Nothing renamed, did not find entity named "{sys.argv[3]}".\n'
             )
             self.conversation.newline()
             return self
 
-        if self.memory.recall_entity(sys.argv[3]) is not None:
+        if self.memory.recall_entity(sys.argv[4]) is not None:
             self.conversation.type(
-                f'Cannot rename to "{sys.argv[3]}" because that entity already exists.\n'
+                f'Cannot rename to "{sys.argv[4]}" because that entity already exists.\n'
             )
             self.conversation.newline()
             return self
@@ -35,8 +31,8 @@ class Rename(BaseCommand):
             response = cli.modeler_entity_rename(
                 self.configuration.project.modeler.version,
                 last["entities"],
-                sys.argv[2],
                 sys.argv[3],
+                sys.argv[4],
             )
 
             self.memory.remember_last({"entities": response["entities"]})
@@ -46,13 +42,13 @@ class Rename(BaseCommand):
             response = cli.modeler_entity_rename(
                 self.configuration.project.modeler.version,
                 stored,
-                sys.argv[2],
                 sys.argv[3],
+                sys.argv[4],
             )
 
             self.memory.remember_entities(response["entities"])
 
-        self.conversation.type(f"[Renamed] {sys.argv[2]} -> {sys.argv[3]}\n")
+        self.conversation.type(f"[Renamed] {sys.argv[3]} -> {sys.argv[4]}\n")
         self.conversation.newline()
 
         Rewrite(self.configuration, header="Refactoring").write()
@@ -60,11 +56,3 @@ class Rename(BaseCommand):
         self.conversation.newline()
 
         return self
-
-    def usage(self):
-        self.configuration.display_project()
-        self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('rename')} {argument('[current]')} {input('[new]')} {hint('rename an entity')}\n"
-        )
-        self.conversation.newline()
-        exit(1)

gibson/command/rename/Rename.py

@@ -0,0 +1,21 @@
+import sys
+
+import gibson.core.Colors as Colors
+from gibson.command.BaseCommand import BaseCommand
+from gibson.command.rename.Entity import Entity
+
+
+class Rename(BaseCommand):
+    def execute(self):
+        if len(sys.argv) == 5 and sys.argv[2] == "entity":
+            Entity(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('rename')} {Colors.argument('entity')} {Colors.input('[existing name]')} {Colors.input('[new name]')} {Colors.hint('rename an entity')}\n"
+        )
+        self.conversation.newline()
+        exit(1)

gibson/command/rewrite/Rewrite.py

@@ -2,7 +2,7 @@ import os
 import shutil
 import sys
 
-from gibson.core.Colors import arguments, command, hint, subcommand
+import gibson.core.Colors as Colors
 from gibson.core.Configuration import Configuration
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.services.code.customization.CustomizationManager import CustomizationManager
@@ -37,7 +37,7 @@ class Rewrite(BaseCommand):
             self.usage()
 
     def write(self, argument=None):
-        self.configuration.ensure_project()
+        self.configuration.require_project()
 
         if len(self.memory.recall_merged()) == 0:
             self.conversation.cant_no_entities(self.configuration.project.name)
@@ -117,10 +117,10 @@ class Rewrite(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('rewrite')} {hint('rewrite all code')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('rewrite')} {Colors.hint('rewrite all code')}\n"
         )
         self.conversation.type(
-            f"   or: {command(self.configuration.command)} {subcommand('rewrite')} {arguments(self.arguments)} {hint('rewrite only the specified code')}\n"
+            f"   or: {Colors.command(self.configuration.command)} {Colors.subcommand('rewrite')} {Colors.arguments(self.arguments)} {Colors.hint('rewrite only the specified code')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/core/CommandRouter.py

@@ -2,14 +2,14 @@ import sys
 
 from gibson.command.auth.Auth import Auth
 from gibson.command.Build import Build
-from gibson.command.Code import Code
+from gibson.command.code.Code import Code
 from gibson.command.Conf import Conf
 from gibson.command.Count import Count
 from gibson.command.Dev import Dev
 from gibson.command.Forget import Forget
 from gibson.command.Help import Help
 from gibson.command.Import import Import
-from gibson.command.List import List
+from gibson.command.list.List import List
 from gibson.command.Merge import Merge
 from gibson.command.Model import Model
 from gibson.command.Modify import Modify
@@ -17,13 +17,8 @@ from gibson.command.new.New import New
 from gibson.command.OpenApi import OpenApi
 from gibson.command.Question import Question
 from gibson.command.Remove import Remove
-from gibson.command.Rename import Rename
-from gibson.command.rewrite.Api import Api
-from gibson.command.rewrite.Base import Base
-from gibson.command.rewrite.Models import Models
+from gibson.command.rename.Rename import Rename
 from gibson.command.rewrite.Rewrite import Rewrite
-from gibson.command.rewrite.Schemas import Schemas
-from gibson.command.rewrite.Tests import Tests
 from gibson.command.Schema import Schema
 from gibson.command.Show import Show
 from gibson.command.Test import Test

gibson/core/Configuration.py

@@ -248,7 +248,7 @@ class Configuration:
         return self
 
     def create_project_memory(self):
-        self.ensure_project()
+        self.require_project()
         try:
             os.makedirs(self.project.paths.memory)
         except OSError as e:
@@ -259,17 +259,6 @@ class Configuration:
         if self.project is not None:
             self.conversation.display_project(self.project.name)
 
-    def ensure_project(self):
-        if self.project is None:
-            self.conversation.gibsonai_project_not_set(self)
-            exit(1)
-
-        if self.project.name not in self.settings:
-            self.conversation.unrecognized_project(self, self.project.name)
-            exit(1)
-
-        return self
-
     def get_access_token(self):
         try:
             with open(f"{self.paths.auth}/{self.API_ENV}", "r") as f:
@@ -281,7 +270,7 @@ class Configuration:
         return token["access_token"]
 
     def get_my_settings(self):
-        self.ensure_project()
+        self.require_project()
         return self.settings[self.project.name]
 
     def get_refresh_token(self):
@@ -358,6 +347,24 @@ class Configuration:
 
         return self
 
+    def require_login(self):
+        if self.get_access_token() is None:
+            self.conversation.message_login_required()
+            exit(1)
+
+        return self
+
+    def require_project(self):
+        if self.project is None:
+            self.conversation.gibsonai_project_not_set(self)
+            exit(1)
+
+        if self.project.name not in self.settings:
+            self.conversation.unrecognized_project(self, self.project.name)
+            exit(1)
+
+        return self
+
     def set_auth_tokens(self, access_token, refresh_token):
         try:
             os.mkdir(self.paths.auth)
@@ -439,7 +446,7 @@ class Configuration:
         return self
 
     def turn_dev_off(self):
-        self.ensure_project()
+        self.require_project()
         self.settings[self.project.name]["dev"]["active"] = False
         self.write_config()
         return self
@@ -447,7 +454,7 @@ class Configuration:
     def turn_dev_on(
         self, api_path, api_prefix, api_version, base_path, model_path, schema_path
     ):
-        self.ensure_project()
+        self.require_project()
         self.settings[self.project.name]["dev"]["active"] = True
         self.settings[self.project.name]["dev"]["api"]["path"] = api_path
         self.settings[self.project.name]["dev"]["api"]["prefix"] = api_prefix

gibson/core/Conversation.py

@@ -5,8 +5,8 @@ import time
 
 import pyfiglet
 
+import gibson.core.Colors as Colors
 from gibson.conf.Version import Version
-from gibson.core.Colors import project
 
 
 class Conversation:
@@ -74,7 +74,7 @@ class Conversation:
             self.newline()
 
     def display_project(self, project_name):
-        self.type(f"<> Project {project(project_name)}\n\n")
+        self.type(f"<> Project {Colors.project(project_name)}\n\n")
 
     def entities_hijacked(self):
         self.type(
@@ -130,6 +130,13 @@ class Conversation:
         self.type("Login failed, please try again.\n")
         return self
 
+    def message_login_required(self):
+        self.type("You need to login before performing this action.\n")
+        self.type(
+            f"Run {Colors.command('gibson')} {Colors.subcommand('auth')} {Colors.argument('login')} and try again.\n"
+        )
+        return self
+
     def message_login_success(self):
         self.newline()
         self.type("Nice! You're now logged in.\n")

{gibson_cli-0.5.2.dist-info → gibson_cli-0.5.4.dist-info}/METADATA

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

{gibson_cli-0.5.2.dist-info → gibson_cli-0.5.4.dist-info}/RECORD

@@ -1,41 +1,46 @@
 bin/build.sh,sha256=H3TAd349BECbcK3_t_jW9VzoLInMNrXtaLnXMEVanew,49
 bin/release.sh,sha256=LxPqH5kxhLKvzHaPRLBlq_ApaK7FHEteH4SzeRenidk,49
-gibson/api/BaseApi.py,sha256=l_EsHdKRz-cXGXd3Ju5IFwmCRUkunba6ckB957S9DAk,2696
-gibson/api/Cli.py,sha256=JlioOwE3oob_OY_cr6qis0QEINU1H68ZjkWEQiGhZ-4,7897
+gibson/api/BaseApi.py,sha256=DYSo_AcJUwZ0NSsqeJbEorKa3LRQwU4EVqvoISRHvk8,2924
+gibson/api/Cli.py,sha256=KvlMDvcMh7i6p3yGeikGmfi4HjUWb49RncJyF-J-9lM,7752
+gibson/api/ProjectApi.py,sha256=T7TqtywJjrzFIfARenQUsrH-80x9Oo1pABbFAdlQkI0,356
 gibson/bin/gibson.py,sha256=N1mAWaww9pw8s5u0et87FC5cFHVU6JzN4Kls3lDn-xw,354
 gibson/command/BaseCommand.py,sha256=mmWUO0FxjMCbv3cHWnnasfAWnU_hTuGHUsRVJ4hUcqM,777
-gibson/command/Build.py,sha256=eypLUpZb3bw9LJ3s4uANZNbMNhshj90g94iQTreY74w,2851
-gibson/command/Code.py,sha256=Tb-eVAODHAbTqQldC2vR30YhrQvM2CtsiXt34RUoS3I,6913
-gibson/command/Conf.py,sha256=z7G-81GpPUGZxjuE0HJn3ltHBIScqy4-rzinLYCyiLA,2467
-gibson/command/Count.py,sha256=FInot7Wz-lClKM1gfKgZXwBVIsTR0Gde0cMjYrCitog,1086
-gibson/command/Dev.py,sha256=KXaWeAMGifrxb4uyBJ5W0v9XIYeG8_C1Dw8TiAeOlHE,4358
-gibson/command/Forget.py,sha256=2-XpPqzjqhdGvilMitZECVBegDzlV12kDiR0xrxEVyY,1064
+gibson/command/Build.py,sha256=KWGaTBF-_uChOmXQsaZChq--nXc4xJPpLfOG8K89vME,2849
+gibson/command/Conf.py,sha256=MbEPT-lRujRJMBjKRQlshA3T3pplQ-zzia8RY_muWU4,2472
+gibson/command/Count.py,sha256=Jh9_ImJibpiTitbllSl0xF6KUrOhrY7Bz7-5sx9cBVs,1083
+gibson/command/Dev.py,sha256=-kmRHpOApUXklaCs4bJVqCRft4ubcVjAL7S1-BGr-ps,4355
+gibson/command/Forget.py,sha256=5fszuq6oIe0unMbXpFtDpouJ1eYZIvsi2mLsa8RwN5U,1061
 gibson/command/Help.py,sha256=KoHukpEk_jLNxaNdM-n4R-dXj_VZub6x4xIXbTK1_wU,4794
-gibson/command/Import.py,sha256=4VeDtQNWf20j2tSvAMjU9r-gB05fD3hh6Mfxdp5B_oI,4174
-gibson/command/List.py,sha256=XNL0p3WvGCjuWeFD_24VO5d2sflXfkk_CvAbXrcOMYI,2318
-gibson/command/Merge.py,sha256=AKhyImy_MH8sy7m9Anh1SKBINvLrRmt91fFE4oVPg7k,1060
-gibson/command/Model.py,sha256=rare94DN7Cij4IizBscwl6TBQvQy_RkVt8SgnUBZW1I,1278
-gibson/command/Modify.py,sha256=jYx8ojVoecPAX_YasvpGGqq2d0dl2FfCB3WAlSxtdtM,1269
-gibson/command/OpenApi.py,sha256=mdjgzDgJTu8aMuI1bojExEAstCQuFzhFCnutNSm9z14,4313
-gibson/command/Question.py,sha256=KHFDLI3ItIFg3Qeeamy_zaXSZQyFBXdl3LEr4iq8FOg,3986
-gibson/command/Remove.py,sha256=i-ofK_uQfkgrP63vYaBxDTIhzs_-4p0FFaqd3f4fJvo,2435
-gibson/command/Rename.py,sha256=VUp8vrj3ugOG9i6CgXw8putbZAUsSw6iC8J1FBB05nQ,2245
-gibson/command/Schema.py,sha256=NAOp6RY4apSArPE7ZljT150AIQjpm88C6N_SRIophWo,1291
-gibson/command/Show.py,sha256=lGwguywp1lk4-E1T8iMFQR39mqir2rUqNXZES7H4WO4,1405
-gibson/command/Test.py,sha256=O0Ro3o_SAtNf0y7VwrVS7b2hrJ_sA-UepOxnfp8MEN4,1285
-gibson/command/Tree.py,sha256=pqVbebySThqJ-29izerScwaIb4XE40K3cYNA8bUpNkE,3055
-gibson/command/Version.py,sha256=LA162K8oPDJAwPEja6ppoHVU8tr7shA1gzkcWxV4XVs,1282
+gibson/command/Import.py,sha256=fD-PNsRk5qaOWmdmgLdFJ97wCYJDNFXzmHw_e68Lcv0,4216
+gibson/command/Merge.py,sha256=R5ybMC1tUR5_T8YyUfXutzFa_V9j1_flv0s7KTJRq0M,1061
+gibson/command/Model.py,sha256=eRAAvklZjXgstGbM-P9QeG85YQ80TRVZyYTIzzUPzsk,1279
+gibson/command/Modify.py,sha256=3_fEGvLfGpgoXQ77SFA9J2KQDe1GMaAUPWkl-yCwR1E,1267
+gibson/command/OpenApi.py,sha256=G1LGfco0PgMIBw4C_ksja2_0nKKnZzUoiNl2iY64QKw,4314
+gibson/command/Question.py,sha256=8mWumOFKBeS_Lw8_4vF6eDIEx3kdbIwz11mLtY6e9zo,3998
+gibson/command/Remove.py,sha256=mDDpfQV3ggppGSFf9v09exdr2ZG_Qat60CjSBwcvX4A,2436
+gibson/command/Schema.py,sha256=zg10N6uHL37CHQRx8fH00kKS6loSS9kpFe_yv1K6-j8,1289
+gibson/command/Show.py,sha256=5fzNtDJvnQm7-w8fbF8vu6pmH31vugVDEVi_VgRXRQ0,1586
+gibson/command/Test.py,sha256=HBwroaudQ1BSEsRDbv8MOOUiwXFjJgCUNnSFUi6uX3s,1283
+gibson/command/Tree.py,sha256=BeJ_13xrrRCK5FP2rQHWpDKrshVzte-_D1pNG1GXPIw,3056
+gibson/command/Version.py,sha256=YLd2c9eiVT6Xzj-ulRuL9QSiu21Fid2Jp_B7nD6k86o,1267
 gibson/command/WarGames.py,sha256=V0KIpz-Z546qtQaOPdIVHQ6wp2n3r3M3tgKx-GRQzzU,1300
-gibson/command/auth/Auth.py,sha256=JScajZ__oSo24jzFa5NccCgc4yKgxn0BI0dXPWE5bA4,1000
+gibson/command/auth/Auth.py,sha256=rkWhAast68jL-_XVRU-3mIx2_ntlgmAJuwYx37gNVEI,1025
 gibson/command/auth/Login.py,sha256=b43OfV76i6aGdOwj1NK64ZOdYlNyc08g3lZGQ_37KDw,437
 gibson/command/auth/Logout.py,sha256=V01q4TdbiBqCnIrM6IA4T25fO6ws0UpXp42I3pwHZVM,248
-gibson/command/new/Module.py,sha256=XTbfdWKiccEfuqjcCA2Fg1kfl2ngbHGjDhCrbTvevi4,1562
-gibson/command/new/New.py,sha256=o-LMZurujp6cp01xKCdHY02F0hakXG3N7qkxKm-ZN58,1214
+gibson/command/code/Code.py,sha256=9LUrenkSr51WjVaP11ebvKvgjs9fOl8ase-A6OS2aPE,977
+gibson/command/code/Entity.py,sha256=R-R4URE5XKkLN2oxsBSrkAmx3edO9FryYzTMxkDC6WQ,6170
+gibson/command/list/Entities.py,sha256=4qUxR5pBsUwnaW3SZQzCVbwyl_sCfM9lD9TWwipSyWw,1869
+gibson/command/list/List.py,sha256=r6YQdaeMRgFKcz-VyEQTE_I2lRaaJ4kew3E_RKKaaTU,1047
+gibson/command/list/Projects.py,sha256=FAPahdzMs-zkr43ULtrPmo_3OOxtoCnaASyJ9h5iJlU,899
+gibson/command/new/Module.py,sha256=MFbE4XY7YZz0I-SfxHxWe4FYiJHBssI2knATy1yuqs0,1599
+gibson/command/new/New.py,sha256=yAES_nhiZcv3Jo9kb2E_YfAiVAcnRoeE6Ftd1PqQbQ8,1256
 gibson/command/new/Project.py,sha256=sExmNYDKWMIohAoBiF73nkVubgy6iMleaknXW8fWZJA,657
+gibson/command/rename/Entity.py,sha256=SaAiN1bYsTOsqjyVzxghK8-N3sAKITThTzS5LEYgppY,1801
+gibson/command/rename/Rename.py,sha256=T6iTjo6KRArbT8wBgrn-ehtNlY7tRlovlEZfBOUKYlk,731
 gibson/command/rewrite/Api.py,sha256=sSvAqEJXdgQjYcu0uiM6ndHE3GnfkfVL6eqP2Otkbww,1002
 gibson/command/rewrite/Base.py,sha256=YJ2a5Hl0f9NXHUBBPvlt-dUIqEPWQz5vH6-1EHmbFbA,640
 gibson/command/rewrite/Models.py,sha256=eoUpZHpR0qwNgX60EWfcNz49GHmBw_FGfBuHH2ueZqY,799
-gibson/command/rewrite/Rewrite.py,sha256=jaoaruSCsOazZmDAytv9GD2YBrnBSonWO4jOd9C1B10,4666
+gibson/command/rewrite/Rewrite.py,sha256=2v5xhb6JYv-I7jF7B5CpQbw7KWBFHnXLWK5mMaL-N8k,4684
 gibson/command/rewrite/Schemas.py,sha256=zZ1gjmOJg77gh70t5y2WkzHWSAvEKx5-gqRN9OcsCXA,802
 gibson/command/rewrite/Tests.py,sha256=HO1WM6pSToVKsuJn7nUA_I5qrfBN0cgKgBzjlm2Qxt8,799
 gibson/command/tests/test_command_BaseCommand.py,sha256=hSbBfLFI3RTp_DdEHtm5oOLWoN6drI6ucFJypi7xxV8,364
@@ -59,10 +64,10 @@ gibson/conf/dev/Schema.py,sha256=kOSlX1jEyVb82xd8TO8jEAimLcaefIFJr6d2JYvyTqg,74
 gibson/conf/tests/test_conf_Dependencies.py,sha256=LITeeYiqXM5rKkyWFBqcnMvUR5pzDRuHVAngH372jWc,116
 gibson/conf/tests/test_conf_Platform.py,sha256=Zc53IsZmV-hT9VRrZEPNrsuehSdWnJXWKGMmOhEqWHo,138
 gibson/core/Colors.py,sha256=5XJdm9n5Sa75Hv0BYVaGVhnzsgpwfbB2pGXcbGh5EjU,1539
-gibson/core/CommandRouter.py,sha256=_CN9BVHDbBMy-o0RJ4NjZ8rHbZolqSEKYwWLCNRBMMw,3999
+gibson/core/CommandRouter.py,sha256=96Y38GvY14BtBNfb3LwBz-T0_qscyeo51q6xDxVjto0,3781
 gibson/core/Completions.py,sha256=Bsh25vnf0pjpJA6MJNR_2MA2s58Ujj8XolR8fm8AQ_s,1197
-gibson/core/Configuration.py,sha256=rJq6XFS-vV8elACYmbFdnzzW4PsQb1BjyWuajfx46KQ,15787
-gibson/core/Conversation.py,sha256=FjDeaDy7xZqSlY3Sb1VZlAyRnycjSR_8t9-84TvNcsM,8993
+gibson/core/Configuration.py,sha256=aKELMA524DULG4P7ynrlNGRM9KodLIJDuA39FPRINng,15962
+gibson/core/Conversation.py,sha256=ExZvefcbBZH69z0aYvQ9aLItnG_1v6EtZ6mK5h5_QYg,9275
 gibson/core/Env.py,sha256=08dZRHzzR0ahrbM4S0bXC7V1xhYQkT8Zefs00qUHf0U,498
 gibson/core/Memory.py,sha256=Yw6xmqtAsFwd5Q4VgmGDt4U2dUGLyFXZ_nO8c74Oo8E,4005
 gibson/core/PythonPath.py,sha256=p1q7n_5KnPvA8XbxJyvqC2vrIdEdTiMr6vRU9yj77Cs,1567
@@ -108,8 +113,8 @@ gibson/structure/tests/test_Entity.py,sha256=Gl9f1NcEKdpWCx4W3takFFzp18mLhCYWKrd
 gibson/tests/test_Env.py,sha256=DPWmP0-aEelducq9bAwv7rKoY2NjWXUeCrzfJDQkn2M,369
 gibson/tests/test_Memory.py,sha256=YP7owToABAk_-s7fD5UG0HTc4lamDjdA39JUlLnk3Fg,2574
 gibson/tests/test_utils.py,sha256=r_y-EG05YTCNtL8MWiAK1KmPsmeoMgypKsQC_lVgOtM,559
-gibson_cli-0.5.2.dist-info/METADATA,sha256=jMUs0Mfz7ffTyq0b4SQ-AsTqlSvFKCsuzagox03Lzvw,11605
-gibson_cli-0.5.2.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-gibson_cli-0.5.2.dist-info/entry_points.txt,sha256=j5VUvq3AzL21xPvVC24zMoXFt-I5lUWulr66nL3OAPM,50
-gibson_cli-0.5.2.dist-info/top_level.txt,sha256=RFaUY7VXGiqkMwo1Rj7pM4kGvxkhhnfo-2LmPpuL_fs,11
-gibson_cli-0.5.2.dist-info/RECORD,,
+gibson_cli-0.5.4.dist-info/METADATA,sha256=_4GEBjQAXRdXxote3GwcNk7JCyDGCfxLo_dPuJY3Vck,11605
+gibson_cli-0.5.4.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+gibson_cli-0.5.4.dist-info/entry_points.txt,sha256=j5VUvq3AzL21xPvVC24zMoXFt-I5lUWulr66nL3OAPM,50
+gibson_cli-0.5.4.dist-info/top_level.txt,sha256=RFaUY7VXGiqkMwo1Rj7pM4kGvxkhhnfo-2LmPpuL_fs,11
+gibson_cli-0.5.4.dist-info/RECORD,,

{gibson_cli-0.5.2.dist-info → gibson_cli-0.5.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any