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

argenta/__init__.py

@@ -1,10 +1,6 @@
-__all__ = [
-    'App',
-    'Orchestrator',
-    'Router',
-]
+__all__ = ["App", "Orchestrator", "Router"]
 
 
-from argenta.app import App
-from argenta.orchestrator import Orchestrator
-from argenta.router import Router
+from argenta.orchestrator.entity import Orchestrator
+from argenta.app.models import App
+from argenta.router.entity import Router

argenta/app/models.py

@@ -31,17 +31,21 @@ Matches: TypeAlias = list[str] | list[Never]
 
 
 class BaseApp:
-    def __init__(self, *, prompt: str,
-                 initial_message: str,
-                 farewell_message: str,
-                 exit_command: Command,
-                 system_router_title: str | None,
-                 ignore_command_register: bool,
-                 dividing_line: StaticDividingLine | DynamicDividingLine,
-                 repeat_command_groups: bool,
-                 override_system_messages: bool,
-                 autocompleter: AutoCompleter,
-                 print_func: Printer) -> None:
+    def __init__(
+        self,
+        *,
+        prompt: str,
+        initial_message: str,
+        farewell_message: str,
+        exit_command: Command,
+        system_router_title: str | None,
+        ignore_command_register: bool,
+        dividing_line: StaticDividingLine | DynamicDividingLine,
+        repeat_command_groups: bool,
+        override_system_messages: bool,
+        autocompleter: AutoCompleter,
+        print_func: Printer,
+    ) -> None:
         self._prompt: str = prompt
         self._print_func: Printer = print_func
         self._exit_command: Command = exit_command
@@ -55,22 +59,40 @@ class BaseApp:
         self._farewell_message: str = farewell_message
         self._initial_message: str = initial_message
 
-        self._description_message_gen: DescriptionMessageGenerator = lambda command, description: f"{command} *=*=* {description}"
-        self._registered_routers: RegisteredRouters = RegisteredRouters()
+        self._description_message_gen: DescriptionMessageGenerator = (
+            lambda command, description: f"{command} *=*=* {description}"
+        )
+        self.registered_routers: RegisteredRouters = RegisteredRouters()
         self._messages_on_startup: list[str] = []
 
         self._matching_lower_triggers_with_routers: dict[str, Router] = {}
         self._matching_default_triggers_with_routers: dict[str, Router] = {}
 
-        self._current_matching_triggers_with_routers: dict[str, Router] = self._matching_lower_triggers_with_routers if self._ignore_command_register else self._matching_default_triggers_with_routers
+        self._current_matching_triggers_with_routers: dict[str, Router] = (
+            self._matching_lower_triggers_with_routers
+            if self._ignore_command_register
+            else self._matching_default_triggers_with_routers
+        )
 
-        self._incorrect_input_syntax_handler: NonStandardBehaviorHandler[str] = lambda _: print_func(f"Incorrect flag syntax: {_}")
-        self._repeated_input_flags_handler: NonStandardBehaviorHandler[str] = lambda _: print_func(f"Repeated input flags: {_}")
-        self._empty_input_command_handler: EmptyCommandHandler = lambda: print_func("Empty input command")
-        self._unknown_command_handler: NonStandardBehaviorHandler[InputCommand] = lambda _: print_func(f"Unknown command: {_.trigger}")
-        self._exit_command_handler: NonStandardBehaviorHandler[Response] = lambda _: print_func(self._farewell_message)
+        self._incorrect_input_syntax_handler: NonStandardBehaviorHandler[str] = (
+            lambda _: print_func(f"Incorrect flag syntax: {_}")
+        )
+        self._repeated_input_flags_handler: NonStandardBehaviorHandler[str] = (
+            lambda _: print_func(f"Repeated input flags: {_}")
+        )
+        self._empty_input_command_handler: EmptyCommandHandler = lambda: print_func(
+            "Empty input command"
+        )
+        self._unknown_command_handler: NonStandardBehaviorHandler[InputCommand] = (
+            lambda _: print_func(f"Unknown command: {_.trigger}")
+        )
+        self._exit_command_handler: NonStandardBehaviorHandler[Response] = (
+            lambda _: print_func(self._farewell_message)
+        )
 
-    def set_description_message_pattern(self, _: DescriptionMessageGenerator, /) -> None:
+    def set_description_message_pattern(
+        self, _: DescriptionMessageGenerator, /
+    ) -> None:
         """
         Public. Sets the output pattern of the available commands
         :param _: output pattern of the available commands
@@ -78,7 +100,9 @@ class BaseApp:
         """
         self._description_message_gen = _
 
-    def set_incorrect_input_syntax_handler(self, _: NonStandardBehaviorHandler[str], /) -> None:
+    def set_incorrect_input_syntax_handler(
+        self, _: NonStandardBehaviorHandler[str], /
+    ) -> None:
         """
         Public. Sets the handler for incorrect flags when entering a command
         :param _: handler for incorrect flags when entering a command
@@ -86,7 +110,9 @@ class BaseApp:
         """
         self._incorrect_input_syntax_handler = _
 
-    def set_repeated_input_flags_handler(self, _: NonStandardBehaviorHandler[str], /) -> None:
+    def set_repeated_input_flags_handler(
+        self, _: NonStandardBehaviorHandler[str], /
+    ) -> None:
         """
         Public. Sets the handler for repeated flags when entering a command
         :param _: handler for repeated flags when entering a command
@@ -94,7 +120,9 @@ class BaseApp:
         """
         self._repeated_input_flags_handler = _
 
-    def set_unknown_command_handler(self, _: NonStandardBehaviorHandler[InputCommand], /) -> None:
+    def set_unknown_command_handler(
+        self, _: NonStandardBehaviorHandler[InputCommand], /
+    ) -> None:
         """
         Public. Sets the handler for unknown commands when entering a command
         :param _: handler for unknown commands when entering a command
@@ -110,7 +138,9 @@ class BaseApp:
         """
         self._empty_input_command_handler = _
 
-    def set_exit_command_handler(self, _: NonStandardBehaviorHandler[Response], /) -> None:
+    def set_exit_command_handler(
+        self, _: NonStandardBehaviorHandler[Response], /
+    ) -> None:
         """
         Public. Sets the handler for exit command when entering a command
         :param _: handler for exit command when entering a command
@@ -123,7 +153,7 @@ class BaseApp:
         Private. Prints the description of the available commands
         :return: None
         """
-        for registered_router in self._registered_routers:
+        for registered_router in self.registered_routers:
             if registered_router.title:
                 self._print_func(registered_router.title)
             for command_handler in registered_router.command_handlers:
@@ -164,14 +194,18 @@ class BaseApp:
                     length=max_length_line, is_override=self._override_system_messages
                 )
             )
-        
-        elif isinstance(self._dividing_line, StaticDividingLine): # pyright: ignore[reportUnnecessaryIsInstance]
+
+        elif isinstance(self._dividing_line, StaticDividingLine):  # pyright: ignore[reportUnnecessaryIsInstance]
             self._print_func(
-                self._dividing_line.get_full_static_line(is_override=self._override_system_messages)
+                self._dividing_line.get_full_static_line(
+                    is_override=self._override_system_messages
+                )
             )
             print(text.strip("\n"))
             self._print_func(
-                self._dividing_line.get_full_static_line(is_override=self._override_system_messages)
+                self._dividing_line.get_full_static_line(
+                    is_override=self._override_system_messages
+                )
             )
 
         else:
@@ -186,13 +220,9 @@ class BaseApp:
         trigger = command.trigger
         exit_trigger = self._exit_command.trigger
         if self._ignore_command_register:
-            if (
-                trigger.lower() == exit_trigger.lower()
-            ):
+            if trigger.lower() == exit_trigger.lower():
                 return True
-            elif trigger.lower() in [
-                x.lower() for x in self._exit_command.aliases
-            ]:
+            elif trigger.lower() in [x.lower() for x in self._exit_command.aliases]:
                 return True
         else:
             if trigger == exit_trigger:
@@ -209,16 +239,18 @@ class BaseApp:
         """
         input_command_trigger = command.trigger
         if self._ignore_command_register:
-            if input_command_trigger.lower() in list(self._current_matching_triggers_with_routers.keys()):
+            if input_command_trigger.lower() in list(
+                self._current_matching_triggers_with_routers.keys()
+            ):
                 return False
         else:
-            if input_command_trigger in list(self._current_matching_triggers_with_routers.keys()):
+            if input_command_trigger in list(
+                self._current_matching_triggers_with_routers.keys()
+            ):
                 return False
         return True
 
-    def _error_handler(
-        self, error: InputCommandException, raw_command: str
-    ) -> None:
+    def _error_handler(self, error: InputCommandException, raw_command: str) -> None:
         """
         Private. Handles parsing errors of the entered command
         :param error: error being handled
@@ -243,13 +275,13 @@ class BaseApp:
         def _(response: Response) -> None:
             self._exit_command_handler(response)
 
-        if system_router not in self._registered_routers.registered_routers:
+        if system_router not in self.registered_routers.registered_routers:
             system_router.command_register_ignore = self._ignore_command_register
-            self._registered_routers.add_registered_router(system_router)
+            self.registered_routers.add_registered_router(system_router)
 
     def _most_similar_command(self, unknown_command: str) -> str | None:
         all_commands = list(self._current_matching_triggers_with_routers.keys())
-        
+
         matches_startswith_unknown_command: Matches = sorted(
             cmd for cmd in all_commands if cmd.startswith(unknown_command)
         )
@@ -272,26 +304,36 @@ class BaseApp:
         :return: None
         """
         self._prompt = f"[italic dim bold]{self._prompt}"
-        self._initial_message = ("\n" + f"[bold red]{text2art(self._initial_message, font='tarty1')}" + "\n")
+        self._initial_message = (
+            "\n" + f"[bold red]{text2art(self._initial_message, font='tarty1')}" + "\n"
+        )
         self._farewell_message = (
-            "[bold red]\n\n" +
-            str(text2art(self._farewell_message, font="chanky")) + # pyright: ignore[reportUnknownArgumentType]
-            "\n[/bold red]\n" +
-            "[red i]github.com/koloideal/Argenta[/red i] | [red bold i]made by kolo[/red bold i]\n"
+            "[bold red]\n\n"
+            + str(text2art(self._farewell_message, font="chanky"))  # pyright: ignore[reportUnknownArgumentType]
+            + "\n[/bold red]\n"
+            + "[red i]github.com/koloideal/Argenta[/red i] | [red bold i]made by kolo[/red bold i]\n"
         )
         self._description_message_gen = lambda command, description: (
             f"[bold red]{escape('[' + command + ']')}[/bold red] "
             f"[blue dim]*=*=*[/blue dim] "
             f"[bold yellow italic]{escape(description)}"
         )
-        self._incorrect_input_syntax_handler = lambda raw_command: self._print_func(f"[red bold]Incorrect flag syntax: {escape(raw_command)}")
-        self._repeated_input_flags_handler = lambda raw_command: self._print_func(f"[red bold]Repeated input flags: {escape(raw_command)}")
-        self._empty_input_command_handler = lambda: self._print_func("[red bold]Empty input command")
+        self._incorrect_input_syntax_handler = lambda raw_command: self._print_func(
+            f"[red bold]Incorrect flag syntax: {escape(raw_command)}"
+        )
+        self._repeated_input_flags_handler = lambda raw_command: self._print_func(
+            f"[red bold]Repeated input flags: {escape(raw_command)}"
+        )
+        self._empty_input_command_handler = lambda: self._print_func(
+            "[red bold]Empty input command"
+        )
 
         def unknown_command_handler(command: InputCommand) -> None:
             cmd_trg: str = command.trigger
             mst_sim_cmd: str | None = self._most_similar_command(cmd_trg)
-            first_part_of_text = f"[red]Unknown command:[/red] [blue]{escape(cmd_trg)}[/blue]"
+            first_part_of_text = (
+                f"[red]Unknown command:[/red] [blue]{escape(cmd_trg)}[/blue]"
+            )
             second_part_of_text = (
                 ("[red], most similar:[/red] " + ("[blue]" + mst_sim_cmd + "[/blue]"))
                 if mst_sim_cmd
@@ -308,21 +350,27 @@ class BaseApp:
         """
         self._setup_system_router()
 
-        for router_entity in self._registered_routers:
+        for router_entity in self.registered_routers:
             router_triggers = router_entity.triggers
             router_aliases = router_entity.aliases
             combined = router_triggers + router_aliases
 
             for trigger in combined:
                 self._matching_default_triggers_with_routers[trigger] = router_entity
-                self._matching_lower_triggers_with_routers[trigger.lower()] = router_entity
+                self._matching_lower_triggers_with_routers[trigger.lower()] = (
+                    router_entity
+                )
 
-        self._autocompleter.initial_setup(list(self._current_matching_triggers_with_routers.keys()))
+        self._autocompleter.initial_setup(
+            list(self._current_matching_triggers_with_routers.keys())
+        )
 
         seen = {}
         for item in list(self._current_matching_triggers_with_routers.keys()):
             if item in seen:
-                Console().print(f"\n[b red]WARNING:[/b red] Overlapping trigger or alias: [b blue]{item}[/b blue]")
+                Console().print(
+                    f"\n[b red]WARNING:[/b red] Overlapping trigger or alias: [b blue]{item}[/b blue]"
+                )
             else:
                 seen[item] = True
 
@@ -349,7 +397,8 @@ DEFAULT_EXIT_COMMAND: Command = Command("Q", description="Exit command")
 
 class App(BaseApp):
     def __init__(
-        self, *,
+        self,
+        *,
         prompt: str = "What do you want to do?\n\n",
         initial_message: str = "Argenta\n",
         farewell_message: str = "\nSee you\n",
@@ -405,7 +454,9 @@ class App(BaseApp):
             raw_command: str = Console().input(self._prompt)
 
             try:
-                input_command: InputCommand = InputCommand.parse(raw_command=raw_command)
+                input_command: InputCommand = InputCommand.parse(
+                    raw_command=raw_command
+                )
             except InputCommandException as error:
                 with redirect_stdout(io.StringIO()) as stderr:
                     self._error_handler(error, raw_command)
@@ -415,7 +466,9 @@ class App(BaseApp):
 
             if self._is_exit_command(input_command):
                 system_router.finds_appropriate_handler(input_command)
-                self._autocompleter.exit_setup(list(self._current_matching_triggers_with_routers.keys()))
+                self._autocompleter.exit_setup(
+                    list(self._current_matching_triggers_with_routers.keys())
+                )
                 return
 
             if self._is_unknown_command(input_command):
@@ -425,18 +478,40 @@ class App(BaseApp):
                 self._print_framed_text(stdout_res)
                 continue
 
-            processing_router = self._current_matching_triggers_with_routers[input_command.trigger.lower()]
+            processing_router = self._current_matching_triggers_with_routers[
+                input_command.trigger.lower()
+            ]
 
             if processing_router.disable_redirect_stdout:
                 if isinstance(self._dividing_line, StaticDividingLine):
-                    self._print_func(self._dividing_line.get_full_static_line(is_override=self._override_system_messages))
+                    self._print_func(
+                        self._dividing_line.get_full_static_line(
+                            is_override=self._override_system_messages
+                        )
+                    )
                     processing_router.finds_appropriate_handler(input_command)
-                    self._print_func(self._dividing_line.get_full_static_line(is_override=self._override_system_messages))
+                    self._print_func(
+                        self._dividing_line.get_full_static_line(
+                            is_override=self._override_system_messages
+                        )
+                    )
                 else:
                     dividing_line_unit_part: str = self._dividing_line.get_unit_part()
-                    self._print_func(StaticDividingLine(dividing_line_unit_part).get_full_static_line(is_override=self._override_system_messages))
+                    self._print_func(
+                        StaticDividingLine(
+                            dividing_line_unit_part
+                        ).get_full_static_line(
+                            is_override=self._override_system_messages
+                        )
+                    )
                     processing_router.finds_appropriate_handler(input_command)
-                    self._print_func(StaticDividingLine(dividing_line_unit_part).get_full_static_line(is_override=self._override_system_messages))
+                    self._print_func(
+                        StaticDividingLine(
+                            dividing_line_unit_part
+                        ).get_full_static_line(
+                            is_override=self._override_system_messages
+                        )
+                    )
             else:
                 with redirect_stdout(io.StringIO()) as stdout:
                     processing_router.finds_appropriate_handler(input_command)
@@ -451,7 +526,7 @@ class App(BaseApp):
         :return: None
         """
         router.command_register_ignore = self._ignore_command_register
-        self._registered_routers.add_registered_router(router)
+        self.registered_routers.add_registered_router(router)
 
     def include_routers(self, *routers: Router) -> None:
         """

argenta/di/__init__.py

@@ -0,0 +1,2 @@
+from argenta.di.integration import inject as inject
+from argenta.di.integration import FromDishka as FromDishka

argenta/di/integration.py

@@ -0,0 +1,45 @@
+__all__ = ["inject", "setup_dishka", "FromDishka"]
+
+from typing import Any, Callable, TypeVar
+
+from dishka import Container, FromDishka
+from dishka.integrations.base import wrap_injection, is_dishka_injected
+
+from argenta.response import Response
+from argenta.app import App
+
+
+T = TypeVar("T")
+
+
+def inject(func: Callable[..., T]) -> Callable[..., T]:
+    return wrap_injection(
+        func=func,
+        is_async=False,
+        container_getter=_get_container_from_response,
+    )
+
+
+def setup_dishka(app: App, *, auto_inject: bool = False) -> None:
+    if auto_inject:
+        _auto_inject_handlers(app)
+
+
+def _get_container_from_response(
+    args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> Container:
+    for arg in args:
+        if isinstance(arg, Response):
+            if hasattr(arg, "_dishka_container"):
+                return arg._dishka_container  # pyright: ignore[reportPrivateUsage]
+            break
+
+    raise RuntimeError("dishka container not found in Response")
+
+
+def _auto_inject_handlers(app: App) -> None:
+    for router in app.registered_routers:
+        for command_handler in router.command_handlers:
+            if not is_dishka_injected(command_handler.handler_as_func):
+                injected_handler = inject(command_handler.handler_as_func)
+                command_handler.handler_as_func = injected_handler

argenta/di/providers.py

@@ -0,0 +1,14 @@
+from argenta.orchestrator.argparser import ArgParser
+from dishka import Provider, provide, Scope
+
+from argenta.orchestrator.argparser.entity import ArgSpace
+
+
+class SystemProvider(Provider):
+    def __init__(self, arg_parser: ArgParser):
+        super().__init__()
+        self._arg_parser: ArgParser = arg_parser
+
+    @provide(scope=Scope.APP)
+    def get_argspace(self) -> ArgSpace:
+        return self._arg_parser.parse_args()

argenta/orchestrator/__init__.py

@@ -1,8 +1,4 @@
-__all__ = [
-    "Orchestrator",
-    "ArgParser"
-]
+__all__ = ["ArgParser", "Orchestrator"]
 
-
-from argenta.orchestrator.entity import Orchestrator
 from argenta.orchestrator.argparser.entity import ArgParser
+from argenta.orchestrator.entity import Orchestrator

argenta/orchestrator/argparser/__init__.py

@@ -1,12 +1,9 @@
 __all__ = [
     "ArgParser",
-    "PositionalArgument",
-    "OptionalArgument",
-    "BooleanArgument"
+    "BooleanArgument",
+    "ValueArgument"
 ]
 
 
 from argenta.orchestrator.argparser.entity import ArgParser
-from argenta.orchestrator.argparser.arguments import (BooleanArgument,
-                                                      PositionalArgument,
-                                                      OptionalArgument)
+from argenta.orchestrator.argparser.arguments import BooleanArgument, ValueArgument

argenta/orchestrator/argparser/arguments/__init__.py

@@ -1,8 +1,8 @@
-__all__ = ["BooleanArgument", "PositionalArgument", "OptionalArgument"]
+__all__ = ["BooleanArgument", "ValueArgument", "InputArgument"]
 
 
 from argenta.orchestrator.argparser.arguments.models import (
     BooleanArgument,
-    PositionalArgument,
-    OptionalArgument,
+    ValueArgument,
+    InputArgument
 )

argenta/orchestrator/argparser/arguments/models.py

@@ -1,62 +1,82 @@
-from abc import ABC, abstractmethod
-from typing import Literal, override
+from typing import Literal
 
 
-class BaseArgument(ABC):
+class BaseArgument:
     """
     Private. Base class for all arguments
     """
-    @property
-    @abstractmethod
-    def string_entity(self) -> str:
-        """
-        Public. Returns the string representation of the argument
-        :return: the string representation as a str
-        """
-        raise NotImplementedError
-
-
-class PositionalArgument(BaseArgument):
-    def __init__(self, name: str):
+    def __init__(self, name: str, *,
+                       help: str,
+                       is_deprecated: bool,
+                       prefix: Literal["-", "--", "---"]):
         """
-        Public. Required argument at startup
-        :param name: name of the argument, must not start with minus (-)
+        Public. Boolean argument, does not require a value
+        :param name: name of the argument
+        :param help: help message for the argument
+        :param is_required: whether the argument is required
+        :param is_deprecated: whether the argument is deprecated
         """
         self.name: str = name
-
+        self.help: str = help
+        self.is_deprecated: bool = is_deprecated
+        self.prefix: Literal["-", "--", "---"] = prefix
+        
     @property
-    @override
     def string_entity(self) -> str:
-        return self.name
+        return self.prefix + self.name
 
 
-class OptionalArgument(BaseArgument):
-    def __init__(self, name: str, prefix: Literal["-", "--", "---"] = "--"):
+class ValueArgument(BaseArgument):
+    def __init__(self, name: str, *,
+                prefix: Literal["-", "--", "---"] = "--",
+                help: str = "Help message for the value argument", 
+                possible_values: list[str] | None = None,
+                default: str | None = None,
+                is_required: bool = False,
+                is_deprecated: bool = False):
         """
-        Public. Optional argument, must have the value
+        Public. Value argument, must have the value
         :param name: name of the argument
-        :param prefix: prefix of the argument
+        :param prefix: prefix for the argument
+        :param help: help message for the argument
+        :param possible_values: list of possible values for the argument
+        :param default: default value for the argument
+        :param is_required: whether the argument is required
+        :param is_deprecated: whether the argument is deprecated
         """
-        self.name: str = name
-        self.prefix: Literal["-", "--", "---"] = prefix
-
-    @property
-    @override
-    def string_entity(self) -> str:
-        return self.prefix + self.name
+        self.default: str | None = default
+        self.possible_values: list[str] | None = possible_values
+        self.is_required: bool = is_required
+        self.action: str = "store"
+        super().__init__(name, prefix=prefix, help=help, is_deprecated=is_deprecated)
 
 
 class BooleanArgument(BaseArgument):
-    def __init__(self, name: str, prefix: Literal["-", "--", "---"] = "--"):
+    def __init__(self, name: str, *,
+                prefix: Literal["-", "--", "---"] = "--",
+                help: str = "Help message for the boolean argument",
+                is_deprecated: bool = False):
         """
         Public. Boolean argument, does not require a value
         :param name: name of the argument
-        :param prefix: prefix of the argument
+        :param help: help message for the argument
+        :param is_required: whether the argument is required
+        :param is_deprecated: whether the argument is deprecated
         """
-        self.name: str = name
-        self.prefix: Literal["-", "--", "---"] = prefix
+        self.action: str = "store_true"
+        super().__init__(name, prefix=prefix, help=help, is_deprecated=is_deprecated)
 
-    @property
-    @override
-    def string_entity(self) -> str:
-        return self.prefix + self.name
+
+class InputArgument:
+    def __init__(self, name: str,
+                       value: str | None,
+                       founder_class: type[BaseArgument]) -> None:
+        self.name: str = name
+        self.value: str | None = value
+        self.founder_class: type[BaseArgument] = founder_class
+    
+    def __str__(self) -> str:
+        return f"InputArgument({self.name}={self.value})"
+       
+    def __repr__(self) -> str:
+        return f"InputArgument<name={self.name}, value={self.value}, founder_class={self.founder_class.__name__}>"

argenta/orchestrator/argparser/entity.py

@@ -1,16 +1,44 @@
 from argparse import ArgumentParser, Namespace
+from typing import Never, Self
 
 from argenta.orchestrator.argparser.arguments.models import (
+    BaseArgument,
     BooleanArgument,
-    OptionalArgument,
-    PositionalArgument,
+    InputArgument,
+    ValueArgument
 )
 
+        
+class ArgSpace:
+    def __init__(self, all_arguments: list[InputArgument]) -> None:
+        self.all_arguments = all_arguments
+    
+    @classmethod
+    def from_namespace(cls, namespace: Namespace, 
+                            processed_args: list[ValueArgument | BooleanArgument]) -> Self:
+        name_type_paired_args: dict[str, type[BaseArgument]] = {
+            arg.name: type(arg)
+            for arg in processed_args   
+        }
+        return cls([InputArgument(name=name, 
+                                  value=value, 
+                                  founder_class=name_type_paired_args[name]) 
+                    for name, value in vars(namespace).items()])
+        
+    def get_by_name(self, name: str) -> InputArgument | None:
+        for arg in self.all_arguments:
+            if arg.name == name:
+                return arg
+        return None
+        
+    def get_by_type(self, arg_type: type[BaseArgument]) -> list[InputArgument] | list[Never]:
+        return [arg for arg in self.all_arguments if arg.founder_class is arg_type]
+        
 
 class ArgParser:
     def __init__(
         self,
-        processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument], *,
+        processed_args: list[ValueArgument | BooleanArgument], *,
         name: str = "Argenta",
         description: str = "Argenta available arguments",
         epilog: str = "github.com/koloideal/Argenta | made by kolo",
@@ -22,18 +50,29 @@ class ArgParser:
         :param epilog: the epilog of the ArgParse instance
         :param processed_args: registered and processed arguments
         """
-        self._name: str = name
-        self._description: str = description
-        self._epilog: str = epilog
+        self.name: str = name
+        self.description: str = description
+        self.epilog: str = epilog
+        self.processed_args: list[ValueArgument | BooleanArgument] = processed_args
 
-        self._entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
-        self._processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument] = processed_args
+        self._core: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
         
         for arg in processed_args:
-            if isinstance(arg, PositionalArgument) or isinstance(arg, OptionalArgument):
-                _ = self._entity.add_argument(arg.string_entity)
-            else: 
-                _ = self._entity.add_argument(arg.string_entity, action="store_true")
+            if isinstance(arg, BooleanArgument):
+                _ = self._core.add_argument(arg.string_entity,    
+                                            action=arg.action,
+                                            help=arg.help,
+                                            deprecated=arg.is_deprecated)
+            else:
+                _ = self._core.add_argument(arg.string_entity,    
+                                            action=arg.action,
+                                            help=arg.help,
+                                            default=arg.default,
+                                            choices=arg.possible_values,
+                                            required=arg.is_required,
+                                            deprecated=arg.is_deprecated)
 
-    def parse_args(self) -> Namespace:
-        return self._entity.parse_args()
+    def parse_args(self) -> ArgSpace:
+        return ArgSpace.from_namespace(namespace=self._core.parse_args(),
+                                       processed_args=self.processed_args)
+        

argenta/orchestrator/entity.py

@@ -1,17 +1,28 @@
-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
+        self._arg_parser: ArgParser = arg_parser
+        self._custom_providers: list[Provider] = custom_providers
+        self._auto_inject_handlers: bool = auto_inject_handlers
 
     def start_polling(self, app: App) -> None:
         """
@@ -19,14 +30,8 @@ class Orchestrator:
         :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.parse_args()
-        else:
-            return None
+        app.run_polling()

argenta/response/entity.py

@@ -1,4 +1,5 @@
-from typing import Literal
+from dishka import Container
+
 from argenta.command.flag.flags.models import InputFlags
 from argenta.response.status import ResponseStatus
 
@@ -7,7 +8,7 @@ EMPTY_INPUT_FLAGS: InputFlags = InputFlags()
 
 
 class Response:
-    __slots__: tuple[Literal['status', 'input_flags'], ...] = ("status", "input_flags")
+    _dishka_container: Container
 
     def __init__(
         self,
@@ -21,3 +22,7 @@ class Response:
         """
         self.status: ResponseStatus = status
         self.input_flags: InputFlags = input_flags
+
+    @classmethod
+    def patch_by_container(cls, container: Container) -> None:
+        cls._dishka_container = container

argenta/router/command_handler/entity.py

@@ -6,13 +6,13 @@ from argenta.response import Response
 
 
 class CommandHandler:
-    def __init__(self, handler_as_func: 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_as_func: Callable[[Response], None] = handler_as_func
+        self.handler_as_func: Callable[..., None] = handler_as_func
         self.handled_command: Command = handled_command
 
     def handling(self, response: Response) -> None:
@@ -30,7 +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: list[CommandHandler] = command_handlers if command_handlers else []
+        self.command_handlers: list[CommandHandler] = (
+            command_handlers if command_handlers else []
+        )
 
     def add_handler(self, command_handler: CommandHandler) -> None:
         """

argenta/router/entity.py

@@ -6,25 +6,23 @@ 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
-)
+from argenta.command.flag.flags import Flags, InputFlags
 from argenta.router.exceptions import (
     RepeatedFlagNameException,
-    TooManyTransferredArgsException,
     RequiredArgumentNotPassedException,
     TriggerContainSpacesException,
 )
 
 
-HandlerFunc: TypeAlias = Callable[[Response], None]
+HandlerFunc: TypeAlias = Callable[..., None]
 
 
 class Router:
     def __init__(
-        self, *, title: str | None = "Default title",
-        disable_redirect_stdout: bool = False
+        self,
+        *,
+        title: str | None = "Default title",
+        disable_redirect_stdout: bool = False,
     ):
         """
         Public. Directly configures and manages handlers
@@ -58,7 +56,6 @@ class Router:
         def decorator(func: HandlerFunc) -> HandlerFunc:
             _validate_func_args(func)
             self.command_handlers.add_handler(CommandHandler(func, redefined_command))
-
             return func
 
         return decorator
@@ -91,7 +88,9 @@ class Router:
         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)
+                response: Response = _structuring_input_flags(
+                    handle_command, input_command_flags
+                )
                 command_handler.handling(response)
             else:
                 response = Response(ResponseStatus.ALL_FLAGS_VALID)
@@ -102,7 +101,9 @@ class Router:
                 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)
+                response = Response(
+                    ResponseStatus.UNDEFINED_FLAGS, input_flags=undefined_flags
+                )
                 command_handler.handling(response)
             else:
                 response = Response(ResponseStatus.ALL_FLAGS_VALID)
@@ -137,14 +138,17 @@ class CommandDecorator:
         self.router: Router = router_instance
         self.command: Command = command
 
-    def __call__(self, handler_func: Callable[[Response], None]) -> Callable[[Response], None]:
+    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))
+        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:
+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
@@ -154,45 +158,42 @@ def _structuring_input_flags(handled_command: Command,
     invalid_value_flags, undefined_flags = False, False
 
     for flag in input_flags:
-        flag_status: ValidationStatus = (handled_command.validate_input_flag(flag))
+        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
+    status = ResponseStatus.from_flags(
+        has_invalid_value_flags=invalid_value_flags, has_undefined_flags=undefined_flags
     )
 
-def _validate_func_args(func: Callable[[Response], None]) -> None:
+    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) > 1:
-        raise TooManyTransferredArgsException()
-    elif len(transferred_args) == 0:
+    if len(transferred_args) == 0:
         raise RequiredArgumentNotPassedException()
 
-    transferred_arg: str = transferred_args[0]
+    response_arg: str = transferred_args[0]
     func_annotations: dict[str, None] = get_annotations(func)
 
-    arg_annotation = func_annotations.get(transferred_arg)
+    response_arg_annotation = func_annotations.get(response_arg)
 
-    if arg_annotation is not None:
-        if arg_annotation is not Response:
+    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]{transferred_arg}[/green]) passed to the handler must be [/i][bold blue]{Response}[/bold blue]," +
-                f" [i]but[/i] [bold blue]{arg_annotation}[/bold blue] [i]is specified[/i]",
+                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,
             )
 

argenta/router/exceptions.py

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

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

@@ -1,13 +1,14 @@
 Metadata-Version: 2.4
 Name: argenta
-Version: 1.1.1
+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.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
 

{argenta-1.1.1.dist-info → argenta-1.1.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
-argenta/__init__.py,sha256=M46JPL55z0mJt7uA8kWAqILIQqfDZ26gexXQma5eyVg,179
+argenta/__init__.py,sha256=3WcEE8aozvDhboffaTi5LwR5oduFG3NLr7Z3WmlfHx4,181
 argenta/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argenta/app/__init__.py,sha256=eC03K3EN4L7XevITTy8Em_I_PihnSeTiWeMsElxeV-0,368
 argenta/app/defaults.py,sha256=TmpHGfEmJeefgJlgW90rfw9xTgssNANRds6JZqKdDrc,379
-argenta/app/models.py,sha256=QH9MC6cpn_8ukag9s8kALM0qlVNI0FH_091wFZe_04s,21058
+argenta/app/models.py,sha256=EdY7JzvDtHGumUaX9CaF3OTu6-nuwDbkF5JJdW_sSDM,22216
 argenta/app/protocols.py,sha256=G7xOmAzNII2S8PbbovrvibK0keJuyvFBQvqQAH_gEP4,614
 argenta/app/autocompleter/__init__.py,sha256=VT_p3QA78UnczV7pYR2NnwQ0Atd8mnDUnLazvUQNqJk,93
 argenta/app/autocompleter/entity.py,sha256=IMK69PUScwsomswig7mbr9NyJ_Ee-ACZqNxbcBcB-UM,3540
@@ -18,24 +18,27 @@ argenta/command/flag/defaults.py,sha256=jtIyEVmC2zHxBC2eZg_VNB537fv4bq5d1Ut7LeAT
 argenta/command/flag/models.py,sha256=6IThEBF-LpADF0HIoSJmFG08lJQ98buqcTo5HzKK500,3880
 argenta/command/flag/flags/__init__.py,sha256=jCJ_qGj-bnCa31Haqws44zQw315vyrfcOviIaLAeupU,132
 argenta/command/flag/flags/models.py,sha256=AgP9GcrhD2oY7RP39lpyjLQSzUGK9K4QZfsZt5R6hWk,3419
+argenta/di/__init__.py,sha256=z63m1yExyRS8mL_heaLmbIDxfvYCZXpqDW_mlF_4lHQ,114
+argenta/di/integration.py,sha256=S1v4VCJDg83EGyEqxckJw6IHyyMNnLqEkXFCJY3BoBE,1389
+argenta/di/providers.py,sha256=DgcseexOvFW0Co_3I_iso7uBcWMiphJiN7xyiBDP2Yc,444
 argenta/metrics/__init__.py,sha256=PPLFPxhe4j7r6hP1P1pk0A_gnXgylbTaHqopky872AU,109
 argenta/metrics/main.py,sha256=SRz25JZ85Kj3rVVwQi5jpuojumopB2ADJnEZ8CsmirI,507
-argenta/orchestrator/__init__.py,sha256=0l3AcpETwWwxob1BEBgpCinD5TgWURsniEjjdLi05DE,173
-argenta/orchestrator/entity.py,sha256=7D9d5T47YMg9JXWh-6dgtVji9jXUOEyDgd5VBfz70LI,1012
-argenta/orchestrator/argparser/__init__.py,sha256=XqNc7hYSeucOZPLH_pSwzaYTUUbXMuQX7YnRa_-cnmw,394
-argenta/orchestrator/argparser/entity.py,sha256=EgwgdHueeG5FEUgGgPoBDv9ew_cxLAHu5s_09ePKFhY,1579
-argenta/orchestrator/argparser/arguments/__init__.py,sha256=lRsKyJeiibPYhFZoeB3BRfIYM4mlUFp6nZpy9RdbgYg,213
-argenta/orchestrator/argparser/arguments/models.py,sha256=F1K8Sh_dFF00iDejkJ2eajBcA_pkM2pVNXHGzucW6pI,1756
+argenta/orchestrator/__init__.py,sha256=FcbPfws83FGtNb0bgU0X7BCNzGiVxJHpUeKgfRSOzUg,158
+argenta/orchestrator/entity.py,sha256=8l1SLRtvd7ADQheUARWQEJh074eMyJLVKHbUMlPQZ3w,1414
+argenta/orchestrator/argparser/__init__.py,sha256=WpDYIJtpls2kjbEbKcpVmqO8zXL77dD808uSd-pCpI4,229
+argenta/orchestrator/argparser/entity.py,sha256=KG0t3Z_jZNUK2tEMYmJoGHITR5AAyk76Ym9t8b6B3jw,3332
+argenta/orchestrator/argparser/arguments/__init__.py,sha256=k2atEfPmOAYUVChUgMbN31l4xJ5AaQ7diMF6U0LOLCU,196
+argenta/orchestrator/argparser/arguments/models.py,sha256=3IRLTA_RzxKSMgCPRwglLNr5Zkrwhu299_0GmRJmI3c,3285
 argenta/response/__init__.py,sha256=tbo5CC-nrVLlr13yiPHPNHdpSjxeSak_pC-NEXoyfqA,144
-argenta/response/entity.py,sha256=Tf1mXAUhpEKf3dfFHJ3W08MoHZRSSlTIOKad7h8F9ns,715
+argenta/response/entity.py,sha256=zZ_qiL-yth63j6v4DWODH2_W9KxoxQn67JukfJurQIk,791
 argenta/response/status.py,sha256=sX2qoqPSMDKF7zmCGjmmh29qEzP5Aoc4MMjo_Sz48bE,765
 argenta/router/__init__.py,sha256=CDhhu5aX4_vHlgX6PZvvbT5_x4-S1XieOPqWU9cwPIs,68
 argenta/router/defaults.py,sha256=vvkwFYCQdwjtMntfyrJuisxFX8XxeyhDMA-RwteHZGg,87
-argenta/router/entity.py,sha256=1LBnRp4yaso1tQqyGb1GQ-_4gSRcYE27R4UQrdWu71I,8806
-argenta/router/exceptions.py,sha256=DAkZBe7VAvBYE4wF-mbxSFbt51oZ-j3wbBpMY_xj740,973
+argenta/router/entity.py,sha256=tNURPfYZympY6s81Z7UXXdGJJpYXKB5C6qIbyNcyYHw,8699
+argenta/router/exceptions.py,sha256=EzUMPstySz66s1dFDInbet1Gda7Jw5wYzodPVjRTrQY,755
 argenta/router/command_handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argenta/router/command_handler/entity.py,sha256=3G-UaQZNqdIvl_R1AKfwJog1JUFTIflxpBWK-jI-fT4,1803
-argenta-1.1.1.dist-info/METADATA,sha256=DPDIvMvjzaFgZN8WC7rQoNVUlIdBztGLsOXyH26cIQE,1981
-argenta-1.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-argenta-1.1.1.dist-info/licenses/LICENSE,sha256=zmqoGh2n5rReBv4s8wPxF_gZEZDgauJYSPMuPczgOiU,1082
-argenta-1.1.1.dist-info/RECORD,,
+argenta/router/command_handler/entity.py,sha256=I4rWMjfHF5tw9VuCvMgFKt9Z5MziC-ifAXlK7n3zmj0,1815
+argenta-1.1.2.dist-info/METADATA,sha256=ypvicXr3aIufMvs4h89gL9lONBDwTDQyFrLHW8skDZo,2035
+argenta-1.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+argenta-1.1.2.dist-info/licenses/LICENSE,sha256=zmqoGh2n5rReBv4s8wPxF_gZEZDgauJYSPMuPczgOiU,1082
+argenta-1.1.2.dist-info/RECORD,,