argenta 1.1.1rc0__py3-none-any.whl → 1.1.2__py3-none-any.whl

argenta/orchestrator/entity.py

@@ -1,35 +1,37 @@
-from argparse import Namespace
-
 from argenta.app import App
+from argenta.response import Response
+
 from argenta.orchestrator.argparser import ArgParser
+from argenta.di.integration import setup_dishka
+from argenta.di.providers import SystemProvider
+
+from dishka import Provider, make_container
+
+
+DEFAULT_ARGPARSER: ArgParser = ArgParser(processed_args=[])
 
 
 class Orchestrator:
-    def __init__(self, arg_parser: ArgParser | None = None):
+    def __init__(self, arg_parser: ArgParser = DEFAULT_ARGPARSER,
+                 custom_providers: list[Provider] = [],
+                 auto_inject_handlers: bool = True):
         """
         Public. An orchestrator and configurator that defines the behavior of an integrated system, one level higher than the App
         :param arg_parser: Cmd argument parser and configurator at startup
         :return: None
         """
-        self.arg_parser: ArgParser | None = arg_parser
-        if arg_parser:
-            self.arg_parser.register_args()
+        self._arg_parser: ArgParser = arg_parser
+        self._custom_providers: list[Provider] = custom_providers
+        self._auto_inject_handlers: bool = auto_inject_handlers
 
-    @staticmethod
-    def start_polling(app: App) -> None:
+    def start_polling(self, app: App) -> None:
         """
         Public. Starting the user input processing cycle
         :param app: a running application
         :return: None
         """
-        app.run_polling()
+        container = make_container(SystemProvider(self._arg_parser), *self._custom_providers)
+        Response.patch_by_container(container)
+        setup_dishka(app, auto_inject=self._auto_inject_handlers)
 
-    def get_input_args(self) -> Namespace | None:
-        """
-        Public. Returns the arguments parsed
-        :return: None
-        """
-        if self.arg_parser:
-            return self.arg_parser.entity.parse_args()
-        else:
-            return None
+        app.run_polling()

argenta/response/__init__.py

@@ -1,5 +1,5 @@
-__all__ = ["Response", "Status"]
+__all__ = ["Response", "ResponseStatus"]
 
 
 from argenta.response.entity import Response
-from argenta.response.status import Status
+from argenta.response.status import ResponseStatus

argenta/response/entity.py

@@ -1,29 +1,28 @@
-from argenta.response.status import Status
-from argenta.command.flag.flags import (
-    ValidInputFlags,
-    UndefinedInputFlags,
-    InvalidValueInputFlags,
-)
+from dishka import Container
+
+from argenta.command.flag.flags.models import InputFlags
+from argenta.response.status import ResponseStatus
+
+
+EMPTY_INPUT_FLAGS: InputFlags = InputFlags()
 
 
 class Response:
-    __slots__ = ("status", "valid_flags", "undefined_flags", "invalid_value_flags")
+    _dishka_container: Container
 
     def __init__(
         self,
-        status: Status | None = None,
-        valid_flags: ValidInputFlags = ValidInputFlags(),
-        undefined_flags: UndefinedInputFlags = UndefinedInputFlags(),
-        invalid_value_flags: InvalidValueInputFlags = InvalidValueInputFlags(),
+        status: ResponseStatus,
+        input_flags: InputFlags = EMPTY_INPUT_FLAGS,
     ):
         """
         Public. The entity of the user input sent to the handler
         :param status: the status of the response
-        :param valid_flags: valid input flags
-        :param undefined_flags: undefined input flags
-        :param invalid_value_flags: input flags with invalid values
+        :param input_flags: all input flags
         """
-        self.status = status
-        self.valid_flags = valid_flags
-        self.undefined_flags = undefined_flags
-        self.invalid_value_flags = invalid_value_flags
+        self.status: ResponseStatus = status
+        self.input_flags: InputFlags = input_flags
+
+    @classmethod
+    def patch_by_container(cls, container: Container) -> None:
+        cls._dishka_container = container

argenta/response/status.py

@@ -1,8 +1,19 @@
 from enum import Enum
 
 
-class Status(Enum):
+class ResponseStatus(Enum):
     ALL_FLAGS_VALID = "ALL_FLAGS_VALID"
     UNDEFINED_FLAGS = "UNDEFINED_FLAGS"
     INVALID_VALUE_FLAGS = "INVALID_VALUE_FLAGS"
     UNDEFINED_AND_INVALID_FLAGS = "UNDEFINED_AND_INVALID_FLAGS"
+
+    @classmethod
+    def from_flags(cls, *, has_invalid_value_flags: bool, has_undefined_flags: bool) -> 'ResponseStatus':
+        key = (has_invalid_value_flags, has_undefined_flags)
+        status_map: dict[tuple[bool, bool], ResponseStatus] = {
+            (True,  True):  cls.UNDEFINED_AND_INVALID_FLAGS,
+            (True,  False): cls.INVALID_VALUE_FLAGS,
+            (False, True):  cls.UNDEFINED_FLAGS,
+            (False, False): cls.ALL_FLAGS_VALID,
+        }
+        return status_map[key]

argenta/router/__init__.py

@@ -1,4 +1,4 @@
-__all__ = ["Router"]
+from argenta.router.entity import Router
 
 
-from argenta.router.entity import Router
+__all__ = ["Router"]

argenta/router/command_handler/entity.py

@@ -1,18 +1,19 @@
-from typing import Callable, Iterator
+from collections.abc import Iterator
+from typing import Callable
 
 from argenta.command import Command
 from argenta.response import Response
 
 
 class CommandHandler:
-    def __init__(self, handler: Callable[[Response], None], handled_command: Command):
+    def __init__(self, handler_as_func: Callable[..., None], handled_command: Command):
         """
         Private. Entity of the model linking the handler and the command being processed
         :param handler: the handler being called
         :param handled_command: the command being processed
         """
-        self._handler = handler
-        self._handled_command = handled_command
+        self.handler_as_func: Callable[..., None] = handler_as_func
+        self.handled_command: Command = handled_command
 
     def handling(self, response: Response) -> None:
         """
@@ -20,21 +21,7 @@ class CommandHandler:
         :param response: the entity of response: various groups of flags and status of response
         :return: None
         """
-        self._handler(response)
-
-    def get_handler(self) -> Callable[[Response], None]:
-        """
-        Private. Returns the handler being called
-        :return: the handler being called as Callable[[Response], None]
-        """
-        return self._handler
-
-    def get_handled_command(self) -> Command:
-        """
-        Private. Returns the command being processed
-        :return: the command being processed as Command
-        """
-        return self._handled_command
+        self.handler_as_func(response)
 
 
 class CommandHandlers:
@@ -43,14 +30,9 @@ class CommandHandlers:
         Private. The model that unites all CommandHandler of the routers
         :param command_handlers: list of CommandHandlers for register
         """
-        self.command_handlers = command_handlers if command_handlers else []
-
-    def get_handlers(self) -> list[CommandHandler]:
-        """
-        Private. Returns the list of CommandHandlers
-        :return: the list of CommandHandlers as list[CommandHandler]
-        """
-        return self.command_handlers
+        self.command_handlers: list[CommandHandler] = (
+            command_handlers if command_handlers else []
+        )
 
     def add_handler(self, command_handler: CommandHandler) -> None:
         """

argenta/router/entity.py

@@ -1,29 +1,28 @@
-from typing import Callable, Literal, Type
+from typing import Callable, TypeAlias
 from inspect import getfullargspec, get_annotations, getsourcefile, getsourcelines
 from rich.console import Console
 
-from argenta.command import Command
-from argenta.command.models import InputCommand
-from argenta.response import Response, Status
+from argenta.command import Command, InputCommand
+from argenta.command.flag import ValidationStatus
+from argenta.response import Response, ResponseStatus
 from argenta.router.command_handler.entity import CommandHandlers, CommandHandler
-from argenta.command.flag.flags import (
-    Flags,
-    InputFlags,
-    UndefinedInputFlags,
-    ValidInputFlags,
-    InvalidValueInputFlags,
-)
+from argenta.command.flag.flags import Flags, InputFlags
 from argenta.router.exceptions import (
     RepeatedFlagNameException,
-    TooManyTransferredArgsException,
     RequiredArgumentNotPassedException,
     TriggerContainSpacesException,
 )
 
 
+HandlerFunc: TypeAlias = Callable[..., None]
+
+
 class Router:
     def __init__(
-        self, title: str | None = "Awesome title", disable_redirect_stdout: bool = False
+        self,
+        *,
+        title: str | None = "Default title",
+        disable_redirect_stdout: bool = False,
     ):
         """
         Public. Directly configures and manages handlers
@@ -35,13 +34,13 @@ class Router:
                which is ambiguous behavior and can lead to unexpected work
         :return: None
         """
-        self.title = title
-        self.disable_redirect_stdout = disable_redirect_stdout
+        self.title: str | None = title
+        self.disable_redirect_stdout: bool = disable_redirect_stdout
 
-        self._command_handlers: CommandHandlers = CommandHandlers()
-        self._ignore_command_register: bool = False
+        self.command_handlers: CommandHandlers = CommandHandlers()
+        self.command_register_ignore: bool = False
 
-    def command(self, command: Command | str) -> Callable:
+    def command(self, command: Command | str) -> Callable[[HandlerFunc], HandlerFunc]:
         """
         Public. Registers handler
         :param command: Registered command
@@ -51,18 +50,15 @@ class Router:
             redefined_command = Command(command)
         else:
             redefined_command = command
-        self._validate_command(redefined_command)
-
-        def command_decorator(func):
-            Router._validate_func_args(func)
-            self._command_handlers.add_handler(CommandHandler(func, redefined_command))
 
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
+        _validate_command(redefined_command)
 
-            return wrapper
+        def decorator(func: HandlerFunc) -> HandlerFunc:
+            _validate_func_args(func)
+            self.command_handlers.add_handler(CommandHandler(func, redefined_command))
+            return func
 
-        return command_decorator
+        return decorator
 
     def finds_appropriate_handler(self, input_command: InputCommand) -> None:
         """
@@ -70,14 +66,14 @@ class Router:
         :param input_command: input command as InputCommand
         :return: None
         """
-        input_command_name: str = input_command.get_trigger()
-        input_command_flags: InputFlags = input_command.get_input_flags()
+        input_command_name: str = input_command.trigger
+        input_command_flags: InputFlags = input_command.input_flags
 
-        for command_handler in self._command_handlers:
-            handle_command = command_handler.get_handled_command()
-            if input_command_name.lower() == handle_command.get_trigger().lower():
+        for command_handler in self.command_handlers:
+            handle_command = command_handler.handled_command
+            if input_command_name.lower() == handle_command.trigger.lower():
                 self.process_input_command(input_command_flags, command_handler)
-            if input_command_name.lower() in handle_command.get_aliases():
+            if input_command_name.lower() in handle_command.aliases:
                 self.process_input_command(input_command_flags, command_handler)
 
     def process_input_command(
@@ -89,152 +85,129 @@ class Router:
         :param command_handler: command handler for input command as CommandHandler
         :return: None
         """
-        handle_command = command_handler.get_handled_command()
-        response: Response = Response()
-        if handle_command.get_registered_flags().get_flags():
-            if input_command_flags.get_flags():
-                response: Response = self._structuring_input_flags( handle_command, input_command_flags )
+        handle_command = command_handler.handled_command
+        if handle_command.registered_flags.flags:
+            if input_command_flags.flags:
+                response: Response = _structuring_input_flags(
+                    handle_command, input_command_flags
+                )
                 command_handler.handling(response)
             else:
-                response.status = Status.ALL_FLAGS_VALID
+                response = Response(ResponseStatus.ALL_FLAGS_VALID)
                 command_handler.handling(response)
         else:
-            if input_command_flags.get_flags():
-                response.status = Status.UNDEFINED_FLAGS
-                response.undefined_flags = UndefinedInputFlags()
-                response.undefined_flags.add_flags(input_command_flags.get_flags())
+            if input_command_flags.flags:
+                undefined_flags = InputFlags()
+                for input_flag in input_command_flags:
+                    input_flag.status = ValidationStatus.UNDEFINED
+                    undefined_flags.add_flag(input_flag)
+                response = Response(
+                    ResponseStatus.UNDEFINED_FLAGS, input_flags=undefined_flags
+                )
                 command_handler.handling(response)
             else:
-                response.status = Status.ALL_FLAGS_VALID
+                response = Response(ResponseStatus.ALL_FLAGS_VALID)
                 command_handler.handling(response)
 
-    @staticmethod
-    def _structuring_input_flags(
-        handled_command: Command, input_flags: InputFlags
-    ) -> Response:
-        """
-        Private. Validates flags of input command
-        :param handled_command: entity of the handled command
-        :param input_flags:
-        :return: entity of response as Response
-        """
-        valid_input_flags: ValidInputFlags = ValidInputFlags()
-        invalid_value_input_flags: InvalidValueInputFlags = InvalidValueInputFlags()
-        undefined_input_flags: UndefinedInputFlags = UndefinedInputFlags()
-        for flag in input_flags:
-            flag_status: Literal["Undefined", "Valid", "Invalid"] = (
-                handled_command.validate_input_flag(flag)
-            )
-            if flag_status == "Valid":
-                valid_input_flags.add_flag(flag)
-            elif flag_status == "Undefined":
-                undefined_input_flags.add_flag(flag)
-            elif flag_status == "Invalid":
-                invalid_value_input_flags.add_flag(flag)
-
-        if (
-            not invalid_value_input_flags.get_flags()
-            and not undefined_input_flags.get_flags()
-        ):
-            status = Status.ALL_FLAGS_VALID
-        elif (
-            invalid_value_input_flags.get_flags()
-            and not undefined_input_flags.get_flags()
-        ):
-            status = Status.INVALID_VALUE_FLAGS
-        elif (
-            not invalid_value_input_flags.get_flags()
-            and undefined_input_flags.get_flags()
-        ):
-            status = Status.UNDEFINED_FLAGS
-        else:
-            status = Status.UNDEFINED_AND_INVALID_FLAGS
-
-        return Response(
-            invalid_value_flags=invalid_value_input_flags,
-            valid_flags=valid_input_flags,
-            status=status,
-            undefined_flags=undefined_input_flags,
-        )
-
-    @staticmethod
-    def _validate_command(command: Command) -> None:
-        """
-        Private. Validates the command registered in handler
-        :param command: validated command
-        :return: None if command is valid else raise exception
-        """
-        command_name: str = command.get_trigger()
-        if command_name.find(" ") != -1:
-            raise TriggerContainSpacesException()
-        flags: Flags = command.get_registered_flags()
-        if flags:
-            flags_name: list = [x.get_string_entity().lower() for x in flags]
-            if len(set(flags_name)) < len(flags_name):
-                raise RepeatedFlagNameException()
-
-    @staticmethod
-    def _validate_func_args(func: Callable) -> None:
-        """
-        Private. Validates the arguments of the handler
-        :param func: entity of the handler func
-        :return: None if func is valid else raise exception
-        """
-        transferred_args = getfullargspec(func).args
-        if len(transferred_args) > 1:
-            raise TooManyTransferredArgsException()
-        elif len(transferred_args) == 0:
-            raise RequiredArgumentNotPassedException()
-
-        transferred_arg: str = transferred_args[0]
-        func_annotations: dict[str, Type] = get_annotations(func)
-
-        if arg_annotation := func_annotations.get(transferred_arg):
-            if arg_annotation is Response:
-                pass
-            else:
-                file_path: str | None = getsourcefile(func)
-                source_line: int = getsourcelines(func)[1]
-                fprint = Console().print
-                fprint(
-                    f'\nFile "{file_path}", line {source_line}\n[b red]WARNING:[/b red] [i]The typehint '
-                    f"of argument([green]{transferred_arg}[/green]) passed to the handler is [/i][bold blue]{Response}[/bold blue],"
-                    f" [i]but[/i] [bold blue]{arg_annotation}[/bold blue] [i]is specified[/i]",
-                    highlight=False,
-                )
-
-    def set_command_register_ignore(self, _: bool) -> None:
-        """
-        Private. Sets the router behavior on the input commands register
-        :param _: is command register ignore
-        :return: None
-        """
-        self._ignore_command_register = _
-
-    def get_triggers(self) -> list[str]:
+    @property
+    def triggers(self) -> list[str]:
         """
         Public. Gets registered triggers
         :return: registered in router triggers as list[str]
         """
         all_triggers: list[str] = []
-        for command_handler in self._command_handlers:
-            all_triggers.append(command_handler.get_handled_command().get_trigger())
+        for command_handler in self.command_handlers:
+            all_triggers.append(command_handler.handled_command.trigger)
         return all_triggers
 
-    def get_aliases(self) -> list[str]:
+    @property
+    def aliases(self) -> list[str]:
         """
         Public. Gets registered aliases
         :return: registered in router aliases as list[str]
         """
         all_aliases: list[str] = []
-        for command_handler in self._command_handlers:
-            if command_handler.get_handled_command().get_aliases():
-                all_aliases.extend(command_handler.get_handled_command().get_aliases())
+        for command_handler in self.command_handlers:
+            if command_handler.handled_command.aliases:
+                all_aliases.extend(command_handler.handled_command.aliases)
         return all_aliases
 
-    def get_command_handlers(self) -> CommandHandlers:
-        """
-        Private. Gets registered command handlers
-        :return: registered command handlers as CommandHandlers
-        """
-        return self._command_handlers
+
+class CommandDecorator:
+    def __init__(self, router_instance: Router, command: Command):
+        self.router: Router = router_instance
+        self.command: Command = command
+
+    def __call__(self, handler_func: Callable[..., None]) -> Callable[..., None]:
+        _validate_func_args(handler_func)
+        self.router.command_handlers.add_handler(
+            CommandHandler(handler_func, self.command)
+        )
+        return handler_func
+
+
+def _structuring_input_flags(
+    handled_command: Command, input_flags: InputFlags
+) -> Response:
+    """
+    Private. Validates flags of input command
+    :param handled_command: entity of the handled command
+    :param input_flags:
+    :return: entity of response as Response
+    """
+    invalid_value_flags, undefined_flags = False, False
+
+    for flag in input_flags:
+        flag_status: ValidationStatus = handled_command.validate_input_flag(flag)
+        flag.status = flag_status
+        if flag_status == ValidationStatus.INVALID:
+            invalid_value_flags = True
+        elif flag_status == ValidationStatus.UNDEFINED:
+            undefined_flags = True
+
+    status = ResponseStatus.from_flags(
+        has_invalid_value_flags=invalid_value_flags, has_undefined_flags=undefined_flags
+    )
+
+    return Response(status=status, input_flags=input_flags)
+
+
+def _validate_func_args(func: Callable[..., None]) -> None:
+    """
+    Private. Validates the arguments of the handler
+    :param func: entity of the handler func
+    :return: None if func is valid else raise exception
+    """
+    transferred_args = getfullargspec(func).args
+    if len(transferred_args) == 0:
+        raise RequiredArgumentNotPassedException()
+
+    response_arg: str = transferred_args[0]
+    func_annotations: dict[str, None] = get_annotations(func)
+
+    response_arg_annotation = func_annotations.get(response_arg)
+
+    if response_arg_annotation is not None:
+        if response_arg_annotation is not Response:
+            source_line: int = getsourcelines(func)[1]
+            Console().print(
+                f'\nFile "{getsourcefile(func)}", line {source_line}\n[b red]WARNING:[/b red] [i]The typehint '
+                + f"of argument([green]{response_arg}[/green]) passed to the handler must be [/i][bold blue]{Response}[/bold blue],"
+                + f" [i]but[/i] [bold blue]{response_arg_annotation}[/bold blue] [i]is specified[/i]",
+                highlight=False,
+            )
+
+
+def _validate_command(command: Command) -> None:
+    """
+    Private. Validates the command registered in handler
+    :param command: validated command
+    :return: None if command is valid else raise exception
+    """
+    command_name: str = command.trigger
+    if command_name.find(" ") != -1:
+        raise TriggerContainSpacesException()
+    flags: Flags = command.registered_flags
+    flags_name: list[str] = [flag.string_entity.lower() for flag in flags]
+    if len(set(flags_name)) < len(flags_name):
+        raise RepeatedFlagNameException()

argenta/router/exceptions.py

@@ -1,27 +1,23 @@
+from typing import override
+
+
 class RepeatedFlagNameException(Exception):
     """
     Private. Raised when a repeated flag name is registered
     """
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         return "Repeated registered flag names in register command"
 
 
-class TooManyTransferredArgsException(Exception):
-    """
-    Private. Raised when too many arguments are passed
-    """
-
-    def __str__(self):
-        return "Too many transferred arguments"
-
-
 class RequiredArgumentNotPassedException(Exception):
     """
     Private. Raised when a required argument is not passed
     """
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         return "Required argument not passed"
 
 
@@ -30,5 +26,6 @@ class TriggerContainSpacesException(Exception):
     Private. Raised when there is a space in the trigger being registered
     """
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         return "Command trigger cannot contain spaces"

{argenta-1.1.1rc0.dist-info → argenta-1.1.2.dist-info}/METADATA

@@ -1,13 +1,14 @@
 Metadata-Version: 2.4
 Name: argenta
-Version: 1.1.1rc0
+Version: 1.1.2
 Summary: Python library for building modular CLI applications
 Author-email: kolo <kolo.is.main@gmail.com>
 License: MIT
 License-File: LICENSE
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Requires-Dist: art<7.0,>=6.4
-Requires-Dist: pyreadline3>=3.5.4
+Requires-Dist: dishka>=1.7.2
+Requires-Dist: pyreadline3>=3.5.4; sys_platform == 'win32'
 Requires-Dist: rich<15.0.0,>=14.0.0
 Description-Content-Type: text/markdown
 
@@ -15,9 +16,15 @@ Description-Content-Type: text/markdown
 
 ### Library for creating modular CLI applications
 
-#### RU - [README.ru.md](https://github.com/koloideal/Argenta/blob/kolo/README.ru.md) • DE - [README.de.md](https://github.com/koloideal/Argenta/blob/kolo/README.de.md)
+#### RU - [README.ru.md](https://github.com/koloideal/Argenta/blob/main/README.ru.md) • DE - [README.de.md](https://github.com/koloideal/Argenta/blob/main/README.de.md)
 
-![preview](https://github.com/koloideal/Argenta/blob/kolo/imgs/mock_app_preview4.png?raw=True)  
+---
+
+Argenta allows you to encapsulate CLI functionality in isolated, abstracted environments. Eg: you are creating a utility similar to the Metasploit Framework, where the user first logs into a specific scope (for example, selects a module to scan), and then gets access to a set of commands specific only to that context. Argenta provides a simple and concise way to build such an architecture.
+
+---
+
+![preview](https://github.com/koloideal/Argenta/blob/main/imgs/mock_app_preview4.png?raw=True)  
 
 ---