wexample-app 0.0.4__tar.gz

wexample-app-0.0.4/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: wexample-app
+Version: 0.0.4
+Summary: Helpers for building Python app or cli.
+Home-page: https://github.com/wexample/python-app
+Author: weeger
+Author-email: contact@wexample.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# app
+
+Helpers for building Python app or cli.

wexample-app-0.0.4/README.md

@@ -0,0 +1,3 @@
+# app
+
+Helpers for building Python app or cli.

wexample-app-0.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wexample-app-0.0.4/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='wexample-app',
+    version=open('version.txt').read(),
+    author='weeger',
+    author_email='contact@wexample.com',
+    description='Helpers for building Python app or cli.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/wexample/python-app',
+    packages=find_packages(),
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    install_requires=[
+        'python-dotenv',
+        'pydantic',
+        'wexample-filestate',
+        'wexample-helpers',
+        'wexample-prompt',
+    ],
+    python_requires='>=3.6',
+)

wexample-app-0.0.4/wexample_app/const/types.py

@@ -0,0 +1 @@
+CommandLineArgumentsList = list[str]

wexample-app-0.0.4/wexample_app/exception/kernel_exception.py

@@ -0,0 +1,2 @@
+class KernelException(Exception):
+    pass

wexample-app-0.0.4/wexample_app/response/abstract_response.py

@@ -0,0 +1,14 @@
+from abc import abstractmethod
+
+from wexample_app.utils.abstract_kernel_child import AbstractKernelChild
+
+
+class AbstractResponse(AbstractKernelChild):
+    @abstractmethod
+    def print(self) -> str:
+        # For now, simple placeholder.
+        pass
+
+# Enforce importing for rebuild
+from wexample_app.utils.abstract_kernel import AbstractKernel
+AbstractResponse.model_rebuild()

wexample-app-0.0.4/wexample_app/response/default_response.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from wexample_app.response.abstract_response import AbstractResponse
+
+
+class DefaultResponse(AbstractResponse):
+    content: Any
+
+    def print(self) -> str:
+        # For now consider every output as a string
+        return str(self.content)
+
+DefaultResponse.model_rebuild()

wexample-app-0.0.4/wexample_app/utils/abstract_command_resolver.py

@@ -0,0 +1,25 @@
+from abc import abstractmethod
+
+from wexample_app.utils.abstract_kernel_child import AbstractKernelChild
+
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from wexample_app.utils.command_request import CommandRequest
+
+
+class AbstractCommandResolver(AbstractKernelChild):
+    @classmethod
+    @abstractmethod
+    def get_type(cls) -> str:
+        pass
+
+    def supports(self, request: "CommandRequest") -> bool:
+        # By default, resolver match with every command.
+        return True
+
+    def build_command_path(self, request: "CommandRequest") -> Optional[str]:
+        return None
+
+    def build_command_function_name(self, request: "CommandRequest") -> None:
+        return None

wexample-app-0.0.4/wexample_app/utils/abstract_kernel.py

@@ -0,0 +1,99 @@
+from typing import Any, Optional, Dict, Type
+
+from pydantic import BaseModel, Field
+from wexample_helpers.const.types import StringsList
+from wexample_app.exception.kernel_exception import KernelException
+from wexample_prompt.io_manager import IOManager
+from wexample_filestate.file_state_manager import FileStateManager
+from wexample_app.utils.abstract_command_resolver import AbstractCommandResolver
+from wexample_app.utils.runner.abstract_command_runner import AbstractCommandRunner
+from wexample_prompt.utils.prompt_response import PromptResponse
+from wexample_app.utils.command_request import CommandRequest
+
+
+class AbstractKernel(BaseModel):
+    io: Optional[IOManager] = None
+    entrypoint_path: str = Field(description="The main file placed at application root directory")
+    resolvers: Dict[str, "AbstractCommandResolver"] = None
+    runners: Dict[str, "AbstractCommandRunner"] = None
+    env_config: Dict[str, Optional[str]] = None
+    expected_env_items: Optional[StringsList] = [
+        "APP_ENV"
+    ]
+    workdir: FileStateManager = None
+
+    def __init__(self, /, **data: Any) -> None:
+        super().__init__(**data)
+
+        self.io = IOManager()
+
+        self._init_workdir()
+        self._init_env_values()
+        self._init_resolvers()
+        self._init_runners()
+
+        # Validate configuration.
+        self._check_env_values()
+
+    def _init_env_values(self):
+        from dotenv import dotenv_values
+
+        self.env_config = dotenv_values(f"{self.workdir.get_resolved()}{self._get_dotenv_file_name()}")
+
+    def _get_dotenv_file_name(self) -> str:
+        from wexample_helpers.const.globals import FILE_NAME_ENV
+        return FILE_NAME_ENV
+
+    def _init_workdir(self):
+        self.workdir = (self._get_workdir_state_manager_class()).create_from_path(
+            path=self.entrypoint_path,
+            config={},
+            io=self.io
+        )
+
+    def _init_resolvers(self):
+        self.resolvers = {
+            class_definition.get_type(): class_definition(kernel=self)
+            for class_definition in self._get_command_resolvers()
+        }
+
+    def _init_runners(self):
+        self.runners = {
+            class_definition.get_runner_name(): class_definition(kernel=self)
+            for class_definition in self._get_command_runners()
+        }
+
+    def _get_workdir_state_manager_class(self) -> Type[FileStateManager]:
+        return FileStateManager
+
+    def _get_command_request_class(self) -> Type["CommandRequest"]:
+        from wexample_app.utils.command_request import CommandRequest
+
+        return CommandRequest
+
+    def _check_env_values(self):
+        from wexample_helpers.helpers.dict_helper import dict_get_first_missing_key
+        first_missing_key = dict_get_first_missing_key(self.env_config, self.expected_env_items)
+        if first_missing_key:
+            raise KernelException(f"Missing {self._get_dotenv_file_name()} configuration {first_missing_key}")
+
+    def _get_core_configuration_arguments(self) -> list[dict[str, Any]]:
+        return []
+
+    def _get_command_resolvers(self) -> list[Type["AbstractCommandResolver"]]:
+        return []
+
+    def _get_command_runners(self) -> list[Type["AbstractCommandRunner"]]:
+        from wexample_app.utils.runner.python_command_runner import PythonCommandRunner
+
+        return [
+            # Default runner.
+            PythonCommandRunner
+        ]
+
+    def execute_kernel_command(self, request: "CommandRequest") -> PromptResponse:
+        return request.execute()
+
+from wexample_app.utils.command import Command
+Command.model_rebuild()
+CommandRequest.model_rebuild()

wexample-app-0.0.4/wexample_app/utils/abstract_kernel_child.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+from pydantic import BaseModel
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_app.utils.abstract_kernel import AbstractKernel
+
+
+class AbstractKernelChild(BaseModel):
+    kernel: "AbstractKernel"

wexample-app-0.0.4/wexample_app/utils/command.py

@@ -0,0 +1,13 @@
+from typing import Callable, Any
+
+from wexample_app.utils.abstract_kernel_child import AbstractKernelChild
+
+
+class Command(AbstractKernelChild):
+    function: Callable[..., Any] = None
+
+    def execute(self, arguments):
+        return self.function(
+            kernel=self.kernel,
+            arguments=arguments
+        )

wexample-app-0.0.4/wexample_app/utils/command_request.py

@@ -0,0 +1,44 @@
+from wexample_app.utils.abstract_kernel_child import AbstractKernelChild
+from typing import TYPE_CHECKING, Optional, Any, List, Union
+
+if TYPE_CHECKING:
+    from wexample_prompt.utils.prompt_response import PromptResponse
+    from wexample_app.utils.abstract_command_resolver import AbstractCommandResolver
+    from wexample_app.utils.runner.abstract_command_runner import AbstractCommandRunner
+
+
+class CommandRequest(AbstractKernelChild):
+    name: str
+    arguments: List[Union[str | int]] = []
+    path: Optional[str] = None
+    type: Optional[str] = None
+    resolver: Optional["AbstractCommandResolver"] = None
+    runner: Optional["AbstractCommandRunner"] = None
+
+    def __init__(self, /, **data: Any) -> None:
+        super().__init__(**data)
+
+        self.type = self.guess_type()
+        self.path = self.get_resolver().build_command_path(self)
+        self.resolver = self.get_resolver()
+        self.runner = self.guess_runner()
+
+    def execute(self) -> "PromptResponse":
+        command = self.runner.build_command(request=self)
+
+        return command.execute(self.arguments)
+
+    def get_resolver(self) -> Optional["AbstractCommandResolver"]:
+        return self.kernel.resolvers[self.type]
+
+    def guess_runner(self) -> Optional["AbstractCommandRunner"]:
+        for runner_type in self.kernel.runners:
+            if self.kernel.runners[runner_type].will_run(self):
+                return self.kernel.runners[runner_type]
+        return None
+
+    def guess_type(self) -> Optional[str]:
+        for resolver_type in self.kernel.resolvers:
+            if self.kernel.resolvers[resolver_type].supports(self):
+                return resolver_type
+        return None

wexample-app-0.0.4/wexample_app/utils/mixins/command_line_kernel.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from wexample_helpers.helpers.args_helper import args_shift_one
+from wexample_app.const.types import CommandLineArgumentsList
+from wexample_app.utils.command_request import CommandRequest
+from wexample_app.response.abstract_response import AbstractResponse
+
+
+class CommandLineKernel:
+    _sys_argv: list[str]
+    _sys_argv_start_index: int | None = 1
+    _sys_argv_end_index: int | None = None
+    _core_argv: list[str]
+
+    def _init_command_line_kernel(self):
+        import sys
+
+        self._sys_argv: list[str] = sys.argv.copy()
+
+        self._handle_core_args()
+
+    def _get_core_args(self):
+        return {}
+
+    def _handle_core_args(self):
+        for arg_config in self._get_core_args():
+            if args_shift_one(self._sys_argv, arg_config["arg"], True) is not None:
+                setattr(self, arg_config["attr"], arg_config["value"])
+
+    def exec_argv(self):
+        """
+        Main entrypoint from command line calls.
+        May not be called by an internal script.
+        """
+
+        command_requests = self._build_command_requests_from_arguments(
+            self._sys_argv[self._sys_argv_start_index:self._sys_argv_end_index]
+        )
+
+        responses: list[AbstractResponse] = []
+        for command_request in command_requests:
+            responses.append(self.execute_kernel_command(command_request))
+
+        self.render_responses_to_prompt(responses)
+
+    def exec_single_command(self, command_request):
+        self.render_responses_to_prompt([
+            self.execute_kernel_command(command_request)
+        ])
+
+    def render_responses_to_prompt(self, responses: list[AbstractResponse]):
+        prompt_responses = []
+        from wexample_prompt.utils.prompt_response import PromptResponse
+
+        for response in responses:
+            prompt_responses.append(
+                # For now consider every output as a string
+                PromptResponse.from_multiline_message(
+                    response.print()
+                )
+            )
+
+        self.io.print_responses(prompt_responses)
+
+    def _build_command_requests_from_arguments(self, arguments: CommandLineArgumentsList) -> list[CommandRequest]:
+        return []
+
+    def _build_single_command_request_from_arguments(self, arguments: CommandLineArgumentsList):
+        return [
+            (self._get_command_request_class())(
+                kernel=self,
+                name=arguments[0],
+                arguments=arguments[1:])
+        ]

wexample-app-0.0.4/wexample_app/utils/runner/abstract_command_runner.py

@@ -0,0 +1,24 @@
+from abc import abstractmethod
+from typing import Optional
+
+from wexample_app.utils.abstract_kernel_child import AbstractKernelChild
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_app.utils.command import Command
+    from wexample_app.utils.command_request import CommandRequest
+
+
+class AbstractCommandRunner(AbstractKernelChild):
+    @classmethod
+    @abstractmethod
+    def get_runner_name(cls) -> str:
+        pass
+
+    @abstractmethod
+    def build_command(self, request: "CommandRequest") -> Optional["Command"]:
+        pass
+
+    def will_run(self, request: "CommandRequest") -> bool:
+        return False

wexample-app-0.0.4/wexample_app/utils/runner/python_command_runner.py

@@ -0,0 +1,48 @@
+import os.path
+from typing import Optional
+from typing import TYPE_CHECKING
+
+from wexample_app.utils.runner.abstract_command_runner import AbstractCommandRunner
+
+if TYPE_CHECKING:
+    from wexample_app.utils.command import Command
+    from wexample_app.utils.command_request import CommandRequest
+
+
+class PythonCommandRunner(AbstractCommandRunner):
+    @classmethod
+    def get_runner_name(cls) -> str:
+        return "python"
+
+    def will_run(self, request: "CommandRequest") -> bool:
+        from pathlib import Path
+        from wexample_helpers.const.globals import FILE_EXTENSION_PYTHON
+
+        file_path = Path(request.resolver.build_command_path(request))
+        file_extension = file_path.suffix.lower()
+
+        return file_extension == f".{FILE_EXTENSION_PYTHON}"
+
+    def build_command(self, request: "CommandRequest") -> Optional["Command"]:
+        import importlib.util
+        from wexample_app.utils.command import Command
+
+        path = request.resolver.build_command_path(request)
+
+        if not os.path.exists(path):
+            return None
+
+        # Import module and load function.
+        spec = importlib.util.spec_from_file_location(path, path)
+
+        if not spec or not spec.loader:
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        function = getattr(module, request.resolver.build_command_function_name(request), None)
+
+        return Command(
+            kernel=self.kernel,
+            function=function
+        ) if function is not None else None

wexample-app-0.0.4/wexample_app.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: wexample-app
+Version: 0.0.4
+Summary: Helpers for building Python app or cli.
+Home-page: https://github.com/wexample/python-app
+Author: weeger
+Author-email: contact@wexample.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# app
+
+Helpers for building Python app or cli.

wexample-app-0.0.4/wexample_app.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+README.md
+setup.py
+wexample_app/__init__.py
+wexample_app.egg-info/PKG-INFO
+wexample_app.egg-info/SOURCES.txt
+wexample_app.egg-info/__init__.py
+wexample_app.egg-info/dependency_links.txt
+wexample_app.egg-info/requires.txt
+wexample_app.egg-info/top_level.txt
+wexample_app/const/__init__.py
+wexample_app/const/types.py
+wexample_app/exception/__init__.py
+wexample_app/exception/kernel_exception.py
+wexample_app/response/__init__.py
+wexample_app/response/abstract_response.py
+wexample_app/response/default_response.py
+wexample_app/utils/__init__.py
+wexample_app/utils/abstract_command_resolver.py
+wexample_app/utils/abstract_kernel.py
+wexample_app/utils/abstract_kernel_child.py
+wexample_app/utils/command.py
+wexample_app/utils/command_request.py
+wexample_app/utils/file/__init__.py
+wexample_app/utils/mixins/__init__.py
+wexample_app/utils/mixins/command_line_kernel.py
+wexample_app/utils/runner/__init__.py
+wexample_app/utils/runner/abstract_command_runner.py
+wexample_app/utils/runner/python_command_runner.py

wexample-app-0.0.4/wexample_app.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wexample-app-0.0.4/wexample_app.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pydantic
+python-dotenv
+wexample-filestate
+wexample-helpers
+wexample-prompt

wexample-app-0.0.4/wexample_app.egg-info/top_level.txt

@@ -0,0 +1 @@
+wexample_app