gibson-cli 0.1.0__py3-none-any.whl

command/Tree.py

@@ -0,0 +1,92 @@
+import os
+
+from .BaseCommand import BaseCommand
+
+
+class Tree(BaseCommand):
+    def execute(self):
+        self.conversation.display_project(self.configuration.project.name)
+
+        if self.configuration.project.dev.base.path is None:
+            self.conversation.configure_dev_mode()
+            self.conversation.newline()
+            exit(1)
+
+        print(self.configuration.project.dev.base.path)
+        base_path = os.path.expandvars(self.configuration.project.dev.base.path)
+
+        if os.path.isfile(f"{base_path}/BaseModel.py"):
+            self.render_file("BaseModel.py", 2, False)
+
+        if os.path.isfile(f"{base_path}/BaseSchema.py"):
+            self.render_file("BaseSchema.py", 2, False)
+
+        if os.path.isfile(f"{base_path}/Deps.py"):
+            self.render_file("Deps.py", 2, False)
+
+        if os.path.isfile(f"{base_path}/Enums.py"):
+            self.render_file("Enums.py", 2, False)
+
+        if os.path.isfile(f"{base_path}/Session.py"):
+            self.render_file("Session.py", 2, False)
+
+        if os.path.isdir(f"{base_path}/api"):
+            self.render_dir("api", 2, False, explanation="FastAPI Application")
+            self.list_dir(f"{base_path}/api", 6)
+
+        if os.path.isdir(f"{base_path}/lib"):
+            self.render_dir("lib", 2, False, explanation="GibsonAI Libraries")
+            self.list_dir(f"{base_path}/lib", 6)
+
+        if os.path.isdir(f"{base_path}/model"):
+            self.render_dir("model", 2, False, explanation="SQLAlchemy Models")
+            self.list_dir(f"{base_path}/model", 6)
+
+        if os.path.isdir(f"{base_path}/schema"):
+            self.render_dir("schema", 2, False, explanation="Pydantic Schemas")
+            self.list_dir(f"{base_path}/schema", 6)
+
+        if os.path.isfile(f"{base_path}/testing.py"):
+            self.render_file("testing.py", 2, True)
+
+        self.conversation.newline()
+
+    def list_dir(self, path, indent):
+        entries = []
+        for entry in os.listdir(path):
+            if entry not in [".pytest_cache"]:
+                if os.path.isdir(path + f"/{entry}"):
+                    entry += "/"
+
+                entries.append(entry)
+
+        entries.sort()
+
+        for i in range(len(entries)):
+            is_last = i == len(entries) - 1
+            if entries[i][-1] == "/":
+                self.render_dir(entries[i], indent, is_last)
+                self.list_dir(path + "/" + entries[i], indent + 4)
+            else:
+                self.render_file(entries[i], indent, is_last)
+
+    def render_dir(self, path, indent, is_last, explanation=None):
+        char = "-"
+        if is_last is True:
+            char = "_"
+
+        if path[-1] != "/":
+            path += "/"
+
+        explain = ""
+        if explanation is not None:
+            explain = f"<{explanation}> "
+
+        print(" " * indent + "|" + char * 2 + f" {explain}{path}")
+
+    def render_file(self, name, indent, is_last):
+        char = "-"
+        if is_last is True:
+            char = "_"
+
+        print(" " * indent + "|" + char + f" {name}")

command/WarGames.py

@@ -0,0 +1,35 @@
+import hashlib
+import sys
+
+from core.Conversation import Conversation
+
+from .BaseCommand import BaseCommand
+
+
+class WarGames(BaseCommand):
+    def execute(self):
+        if hashlib.sha256(" ".join(sys.argv[1:]).lower().encode()).hexdigest() != (
+            "17dca0c0f6b4fe47e18b34551e3e65d1b91b88c94011be4de552bb64e443f6fc"
+        ):
+            return False
+
+        self.conversation.newline()
+        self.conversation.type("FALKEN'S WEB\n")
+        self.conversation.type("BLACK JACK\n")
+        self.conversation.type("GIN RUMMY\n")
+        self.conversation.type("HEARTS\n")
+        self.conversation.type("BRIDGE\n")
+        self.conversation.type("CHECKERS\n")
+        self.conversation.type("CHESS\n")
+        self.conversation.type("POKER\n")
+        self.conversation.type("FIGHTER COMBAT\n")
+        self.conversation.type("GUERRILLA ENGAGEMENT\n")
+        self.conversation.type("DESERT WARFARE\n")
+        self.conversation.type("AIR-TO-GROUND ACTIONS\n")
+        self.conversation.type("THEATERWIDE TACTICAL WARFARE\n")
+        self.conversation.type("THEATERWIDE BIOTOXIC AND CHEMICAL WARFARE\n")
+        self.conversation.newline()
+        self.conversation.type("GLOBAL THERMONUCLEAR WAR\n", delay=0.2)
+        self.conversation.newline()
+
+        return True

command/auth/Auth.py

@@ -0,0 +1,25 @@
+import sys
+
+from ..BaseCommand import BaseCommand
+from .Login import Login
+from .Logout import Logout
+
+
+class Auth(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+        elif sys.argv[2] == "login":
+            Login(self.configuration).execute()
+        elif sys.argv[2] == "logout":
+            Logout(self.configuration).execute()
+        else:
+            self.usage()
+
+    def usage(self):
+        self.conversation.type(
+            f"usage: {self.configuration.command} auth login\n"
+            + f"   or: {self.configuration.command} auth logout\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/auth/Login.py

@@ -0,0 +1,17 @@
+from api.Cli import Cli
+
+from ..BaseCommand import BaseCommand
+
+
+class Login(BaseCommand):
+    def execute(self):
+        cli = Cli(self.configuration)
+        token = cli.login()
+
+        if token is None:
+            self.conversation.type("Login failed, please try again.")
+        else:
+            self.configuration.set_access_token(token)
+            self.conversation.type(f"Welcome! You are now logged in.")
+
+        self.conversation.newline()

command/auth/Logout.py

@@ -0,0 +1,7 @@
+from ..BaseCommand import BaseCommand
+
+
+class Logout(BaseCommand):
+    def execute(self):
+        self.configuration.set_access_token(None)
+        self.conversation.type(f"You are now logged out.")

command/tests/test_command_BaseCommand.py

@@ -0,0 +1,10 @@
+from command.BaseCommand import BaseCommand
+from core.Configuration import Configuration
+
+
+def test_customization_management():
+    command = BaseCommand(Configuration())
+
+    assert command.customization_management_is_enabled() is True
+    command.disable_customization_management()
+    assert command.customization_management_is_enabled() is False

command/tests/test_command_Conf.py

@@ -0,0 +1,19 @@
+from command.Conf import Conf
+from core.Configuration import Configuration
+
+
+def test_get_configuration_keys():
+    assert Conf(Configuration()).get_configuration_keys() == [
+        "api::key",
+        "code::custom::model::class",
+        "code::custom::model::path",
+        "code::frameworks::api",
+        "code::frameworks::model",
+        "code::frameworks::revision",
+        "code::frameworks::schema",
+        "code::frameworks::test",
+        "code::language",
+        "datastore::type",
+        "datastore::uri",
+        "meta::project::description",
+    ]

conf/Api.py

@@ -0,0 +1,3 @@
+class Api:
+    def __init__(self):
+        self.key = None

conf/Code.py

@@ -0,0 +1,9 @@
+from .Custom import Custom
+from .Frameworks import Frameworks
+
+
+class Code:
+    def __init__(self):
+        self.custom = Custom()
+        self.frameworks = Frameworks()
+        self.language = None

conf/Custom.py

@@ -0,0 +1,4 @@
+class Custom:
+    def __init__(self):
+        self.model_class = None
+        self.model_path = None

conf/Datastore.py

@@ -0,0 +1,4 @@
+class Datastore:
+    def __init__(self):
+        self.type = None
+        self.uri = None

conf/Dependencies.py

@@ -0,0 +1,24 @@
+import importlib
+
+
+class Dependencies:
+    def __init__(self):
+        self.api = "fastapi==0.85"
+        self.model = "sqlalchemy==1.4"
+        self.revision = "alembic==1.12"
+        self.schema = "pydantic==2.6"
+        self.test = "pytest==7.1"
+
+    def compute(self):
+        self.api = f"fastapi=={self.get_package_version('fastapi', '0.85')}"
+        self.model = f"sqlalchemy=={self.get_package_version('sqlalchemy', '1.4')}"
+        self.revision = f"alembic=={self.get_package_version('alembic', '1.12')}"
+        self.schema = f"pydantic=={self.get_package_version('pydantic', '2.6')}"
+        self.test = f"pytest=={self.get_package_version('pytest', '7.1')}"
+        return self
+
+    def get_package_version(self, name, default):
+        try:
+            return importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            return default

conf/Dev.py

@@ -0,0 +1,15 @@
+import os
+
+from conf.dev.Api import Api
+from conf.dev.Base import Base
+from conf.dev.Model import Model
+from conf.dev.Schema import Schema
+
+
+class Dev:
+    def __init__(self):
+        self.active = False
+        self.api = Api()
+        self.base = Base()
+        self.model = Model()
+        self.schema = Schema()

conf/Frameworks.py

@@ -0,0 +1,7 @@
+class Frameworks:
+    def __init__(self):
+        self.api = None
+        self.model = None
+        self.revision = None
+        self.schema = None
+        self.test = None

conf/Modeler.py

@@ -0,0 +1,3 @@
+class Modeler:
+    def __init__(self):
+        self.version = None

conf/Paths.py

@@ -0,0 +1,10 @@
+class ConfigPaths:
+    def __init__(self):
+        self.auth = None
+
+
+class ProjectPaths:
+    def __init__(self):
+        self.config = None
+        self.memory = None
+        self.top = None

conf/Platform.py

@@ -0,0 +1,16 @@
+import os
+import platform
+import subprocess
+
+
+class Platform:
+    def __init__(self):
+        self.system = platform.system().lower()
+
+    def cmd_clear(self):
+        if self.system == "windows":
+            os.system("cls")
+        else:
+            subprocess.call("/usr/bin/clear")
+
+        return self

conf/Project.py

@@ -0,0 +1,18 @@
+from .Api import Api
+from .Code import Code
+from .Datastore import Datastore
+from .Dev import Dev
+from .Modeler import Modeler
+from .Paths import ProjectPaths
+
+
+class Project:
+    def __init__(self):
+        self.api = Api()
+        self.code = Code()
+        self.datastore = Datastore()
+        self.description = None
+        self.dev = Dev()
+        self.modeler = Modeler()
+        self.name = None
+        self.paths = ProjectPaths()

conf/Version.py

@@ -0,0 +1,2 @@
+class Version:
+    NUM = "0.1.0"

conf/dev/Api.py

@@ -0,0 +1,5 @@
+class Api:
+    def __init__(self, path=None, prefix=None, version=None):
+        self.path = path
+        self.prefix = prefix
+        self.version = version

conf/dev/Base.py

@@ -0,0 +1,3 @@
+class Base:
+    def __init__(self, path=None):
+        self.path = path

conf/dev/Model.py

@@ -0,0 +1,3 @@
+class Model:
+    def __init__(self, path=None):
+        self.path = path

conf/dev/Schema.py

@@ -0,0 +1,3 @@
+class Schema:
+    def __init__(self, path=None):
+        self.path = path

conf/tests/test_conf_Dependencies.py

@@ -0,0 +1,5 @@
+from conf.Dependencies import Dependencies
+
+
+def test_compute():
+    dependencies = Dependencies().compute()

conf/tests/test_conf_Platform.py

@@ -0,0 +1,7 @@
+import platform
+
+from conf.Platform import Platform
+
+
+def test_system():
+    assert Platform().system == platform.system().lower()

core/CommandRouter.py

@@ -0,0 +1,249 @@
+import sys
+
+from command.Api import Api
+from command.auth.Auth import Auth
+from command.Base import Base
+from command.Build import Build
+from command.Code import Code
+from command.Conf import Conf
+from command.Count import Count
+from command.Dev import Dev
+from command.Forget import Forget
+from command.Import import Import
+from command.List import List
+from command.Merge import Merge
+from command.Model import Model
+from command.Models import Models
+from command.Modify import Modify
+from command.Module import Module
+from command.New import New
+from command.OpenApi import OpenApi
+from command.Question import Question
+from command.Remove import Remove
+from command.Rename import Rename
+from command.Rewrite import Rewrite
+from command.Schema import Schema
+from command.Schemas import Schemas
+from command.Show import Show
+from command.Test import Test
+from command.Tests import Tests
+from command.Tree import Tree
+from command.WarGames import WarGames
+from .Configuration import Configuration
+from .Conversation import Conversation
+from .Env import Env
+from .Memory import Memory
+
+
+class CommandRouter:
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+        self.conversation = Conversation()
+
+    def help(self, exit_code=0):
+        dev_off = "*"
+        dev_on = ""
+        if self.configuration.project.dev.active is True:
+            dev_off = ""
+            dev_on = "*"
+
+        commands = {
+            "api": {
+                "description": "write the API code for the project",
+                "memory": "stored",
+            },
+            "auth": {
+                "description": "login | logout",
+                "memory": None,
+            },
+            "base": {
+                "description": "write the base code for the project",
+                "memory": "stored",
+            },
+            "build": {
+                "description": "create the entities in the datastore",
+                "memory": "stored",
+            },
+            "code": {"description": "pair program", "memory": None},
+            "conf": {"description": "set a configuration variable", "memory": None},
+            "count": {
+                "description": "show the number of entities stored",
+                "memory": "last | stored",
+            },
+            "dev": {
+                "description": f"mode off{dev_off} | on{dev_on}",
+                "memory": None,
+            },
+            "forget": {
+                "description": "delete memory",
+                "memory": "all | last | stored",
+            },
+            "help": {"description": "for help", "memory": None},
+            "import": {
+                "description": "configure from a data source",
+                "memory": "stored",
+            },
+            "list": {
+                "description": "show the names of entities in your project",
+                "memory": None,
+            },
+            "merge": {
+                "description": "move last changes into project",
+                "memory": "last -> stored",
+            },
+            "model": {
+                "description": "write the model code for an entity",
+                "memory": "stored",
+            },
+            "models": {
+                "description": "write all the model code",
+                "memory": "stored",
+            },
+            "modify": {
+                "description": "change an entity using natural language",
+                "memory": "last > stored",
+            },
+            "module": {"description": "create a new module", "memory": "last"},
+            "new": {"description": "start something new", "memory": None},
+            "openapi": {"description": "build from an OpenAPI spec", "memory": "last"},
+            "remove": {
+                "description": "remove an entity from the project",
+                "memory": "last > stored",
+            },
+            "rename": {
+                "description": "rename an entity",
+                "memory": "last > stored",
+            },
+            "rewrite": {
+                "description": "rewrite all code from scratch",
+                "memory": "stored",
+            },
+            "schema": {
+                "description": "write the schema code for an entity",
+                "memory": "stored",
+            },
+            "schemas": {
+                "description": "write all the schema code",
+                "memory": "stored",
+            },
+            "show": {"description": "display an entity", "memory": "last > stored"},
+            "test": {
+                "description": "write the unit tests for an entity",
+                "memory": "stored",
+            },
+            "tests": {
+                "description": "write all the unit tests",
+                "memory": "stored",
+            },
+            "tree": {"description": "illustrate the project layout", "memory": None},
+            "? | q": {"description": "ask a question", "memory": None},
+        }
+
+        self.conversation.set_delay(0.001)
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(f"usage: {self.configuration.command} [command]\n\n")
+        self.conversation.type(" command  description" + " " * 40 + "memory\n")
+        self.conversation.type(" -------  -----------" + " " * 40 + "------\n")
+
+        for command, config in commands.items():
+            memory = ""
+            if config["memory"] is not None:
+                memory = f"[{config['memory']}]"
+
+            spaces = 61 - (8 + 2 + len(config["description"]))
+
+            self.conversation.type(
+                f"{command.rjust(8)}"
+                + f"  {config['description']}"
+                + " " * spaces
+                + f"{memory}\n"
+            )
+
+        self.conversation.newline()
+        self.conversation.type("memory:\n\n")
+
+        stats = Memory(self.configuration).stats()
+        self.conversation.type(
+            f"{str(stats['entities']['num']).rjust(8)}"
+            + f"  {stats['entities']['word']}"
+            + " " * (43 if stats["entities"]["word"] == "entities" else 45)
+            + "[stored]\n"
+        )
+        self.conversation.type(
+            f"{str(stats['last']['num']).rjust(8)}"
+            + f"  {stats['last']['word']}"
+            + " " * (43 if stats["last"]["word"] == "entities" else 45)
+            + "[last]\n\n"
+        )
+
+        exit(exit_code)
+
+    def run(self):
+        if len(sys.argv) == 1 or sys.argv[1] == "help":
+            self.help()
+            return self
+
+        Env().verify(self.configuration)
+
+        command = None
+        if sys.argv[1] == "api":
+            command = Api(self.configuration)
+        elif sys.argv[1] == "auth":
+            command = Auth(self.configuration)
+        elif sys.argv[1] == "base":
+            command = Base(self.configuration)
+        elif sys.argv[1] == "build":
+            command = Build(self.configuration)
+        elif sys.argv[1] == "code":
+            command = Code(self.configuration)
+        elif sys.argv[1] == "conf":
+            command = Conf(self.configuration)
+        elif sys.argv[1] == "count":
+            command = Count(self.configuration)
+        elif sys.argv[1] == "dev":
+            command = Dev(self.configuration)
+        elif sys.argv[1] == "forget":
+            command = Forget(self.configuration)
+        elif sys.argv[1] == "import":
+            command = Import(self.configuration)
+        elif sys.argv[1] == "list":
+            command = List(self.configuration)
+        elif sys.argv[1] == "merge":
+            command = Merge(self.configuration)
+        elif sys.argv[1] == "model":
+            command = Model(self.configuration)
+        elif sys.argv[1] == "models":
+            command = Models(self.configuration)
+        elif sys.argv[1] == "modify":
+            command = Modify(self.configuration)
+        elif sys.argv[1] == "module":
+            command = Module(self.configuration)
+        elif sys.argv[1] == "new":
+            command = New(self.configuration)
+        elif sys.argv[1] == "openapi":
+            command = OpenApi(self.configuration)
+        elif sys.argv[1] == "remove":
+            command = Remove(self.configuration)
+        elif sys.argv[1] == "rename":
+            command = Rename(self.configuration)
+        elif sys.argv[1] == "rewrite":
+            command = Rewrite(self.configuration, with_header=True)
+        elif sys.argv[1] == "schema":
+            command = Schema(self.configuration)
+        elif sys.argv[1] == "schemas":
+            command = Schemas(self.configuration)
+        elif sys.argv[1] == "show":
+            command = Show(self.configuration)
+        elif sys.argv[1] == "test":
+            command = Test(self.configuration)
+        elif sys.argv[1] == "tests":
+            command = Tests(self.configuration)
+        elif sys.argv[1] == "tree":
+            command = Tree(self.configuration)
+        elif sys.argv[1] in ["?", "q"]:
+            command = Question(self.configuration)
+        else:
+            command = WarGames(self.configuration)
+
+        if command is None or command.execute() is False:
+            self.help(exit_code=1)