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

argenta/command/models.py

@@ -1,35 +1,28 @@
-from argenta.command.flag.models import Flag, InputFlag
+from argenta.command.flag.models import Flag, InputFlag, ValidationStatus
 from argenta.command.flag.flags.models import InputFlags, Flags
 from argenta.command.exceptions import (
     UnprocessedInputFlagException,
     RepeatedInputFlagsException,
     EmptyInputCommandException,
 )
-from typing import cast, Literal
+from typing import Never, Self, cast, Literal
 
 
-class BaseCommand:
-    def __init__(self, trigger: str) -> None:
-        """
-        Private. Base class for all commands
-        :param trigger: A string trigger, which, when entered by the user, indicates that the input corresponds to the command
-        """
-        self._trigger = trigger
+ParseFlagsResult = tuple[InputFlags, str | None, str | None]
+ParseResult = tuple[str, InputFlags]
 
-    def get_trigger(self) -> str:
-        """
-        Public. Returns the trigger of the command
-        :return: the trigger of the command as str
-        """
-        return self._trigger
+MIN_FLAG_PREFIX: str = "-"
+DEFAULT_WITHOUT_FLAGS: Flags = Flags()
+
+DEFAULT_WITHOUT_INPUT_FLAGS: InputFlags = InputFlags()
 
 
-class Command(BaseCommand):
+class Command:
     def __init__(
         self,
-        trigger: str,
+        trigger: str, *, 
         description: str | None = None,
-        flags: Flag | Flags | None = None,
+        flags: Flag | Flags = DEFAULT_WITHOUT_FLAGS,
         aliases: list[str] | None = None,
     ):
         """
@@ -39,157 +32,120 @@ class Command(BaseCommand):
         :param flags: processed commands
         :param aliases: string synonyms for the main trigger
         """
-        super().__init__(trigger)
-        self._registered_flags: Flags = (
-            flags
-            if isinstance(flags, Flags)
-            else Flags(flags)
-            if isinstance(flags, Flag)
-            else Flags()
-        )
-        self._description = "Very useful command" if not description else description
-        self._aliases = aliases if isinstance(aliases, list) else []
-
-    def get_registered_flags(self) -> Flags:
-        """
-        Private. Returns the registered flags
-        :return: the registered flags as Flags
-        """
-        return self._registered_flags
-
-    def get_aliases(self) -> list[str] | list:
-        """
-        Public. Returns the aliases of the command
-        :return: the aliases of the command as list[str] | list
-        """
-        return self._aliases
+        self.registered_flags: Flags = flags if isinstance(flags, Flags) else Flags([flags])
+        self.trigger: str = trigger
+        self.description: str = description if description else "Command without description"
+        self.aliases: list[str] = aliases if aliases else []
 
     def validate_input_flag(
         self, flag: InputFlag
-    ) -> Literal["Undefined", "Valid", "Invalid"]:
+    ) -> ValidationStatus:
         """
         Private. Validates the input flag
         :param flag: input flag for validation
         :return: is input flag valid as bool
         """
-        registered_flags: Flags | None = self.get_registered_flags()
-        if registered_flags:
-            if isinstance(registered_flags, Flag):
-                if registered_flags.get_string_entity() == flag.get_string_entity():
-                    is_valid = registered_flags.validate_input_flag_value(
-                        flag.get_value()
-                    )
-                    if is_valid:
-                        return "Valid"
-                    else:
-                        return "Invalid"
+        registered_flags: Flags = self.registered_flags
+        for registered_flag in registered_flags:
+            if registered_flag.string_entity == flag.string_entity:
+                is_valid = registered_flag.validate_input_flag_value(flag.input_value)
+                if is_valid:
+                    return ValidationStatus.VALID
                 else:
-                    return "Undefined"
-            else:
-                for registered_flag in registered_flags:
-                    if registered_flag.get_string_entity() == flag.get_string_entity():
-                        is_valid = registered_flag.validate_input_flag_value(
-                            flag.get_value()
-                        )
-
-                        if is_valid:
-                            return "Valid"
-                        else:
-                            return "Invalid"
-                return "Undefined"
-        return "Undefined"
-
-    def get_description(self) -> str:
-        """
-        Private. Returns the description of the command
-        :return: the description of the command as str
-        """
-        return self._description
+                    return ValidationStatus.INVALID
+        return ValidationStatus.UNDEFINED
 
 
-class InputCommand(BaseCommand):
-    def __init__(self, trigger: str, input_flags: InputFlag | InputFlags | None = None):
+class InputCommand:
+    def __init__(self, trigger: str, *, 
+                 input_flags: InputFlag | InputFlags = DEFAULT_WITHOUT_INPUT_FLAGS):
         """
         Private. The model of the input command, after parsing
         :param trigger:the trigger of the command
         :param input_flags: the input flags
         :return: None
         """
-        super().__init__(trigger)
-        self._input_flags: InputFlags = (
-            input_flags
-            if isinstance(input_flags, InputFlags)
-            else InputFlags(input_flags)
-            if isinstance(input_flags, InputFlag)
-            else InputFlags()
-        )
-
-    def _set_input_flags(self, input_flags: InputFlags) -> None:
-        """
-        Private. Sets the input flags
-        :param input_flags: the input flags to set
-        :return: None
-        """
-        self._input_flags = input_flags
-
-    def get_input_flags(self) -> InputFlags:
-        """
-        Private. Returns the input flags
-        :return: the input flags as InputFlags
-        """
-        return self._input_flags
+        self.trigger: str = trigger
+        self.input_flags: InputFlags = input_flags if isinstance(input_flags, InputFlags) else InputFlags([input_flags])
 
-    @staticmethod
-    def parse(raw_command: str) -> "InputCommand":
+    @classmethod
+    def parse(cls, raw_command: str) -> Self:
         """
         Private. Parse the raw input command
         :param raw_command: raw input command
         :return: model of the input command, after parsing as InputCommand
         """
-        if not raw_command:
-            raise EmptyInputCommandException()
+        trigger, input_flags = CommandParser(raw_command).parse_raw_command()
 
-        list_of_tokens = raw_command.split()
-        command = list_of_tokens.pop(0)
-
-        input_flags: InputFlags = InputFlags()
-        current_flag_name, current_flag_value = None, None
-
-        for k, _ in enumerate(list_of_tokens):
-            if _.startswith("-"):
-                if len(_) < 2 or len(_[: _.rfind("-")]) > 3:
-                    raise UnprocessedInputFlagException()
-                current_flag_name = _
-            else:
-                if not current_flag_name or current_flag_value:
-                    raise UnprocessedInputFlagException()
-                current_flag_value = _
-
-            if current_flag_name:
-                if not len(list_of_tokens) == k + 1:
-                    if not list_of_tokens[k + 1].startswith("-"):
-                        continue
-
-                input_flag = InputFlag(
-                    name=current_flag_name[current_flag_name.rfind("-") + 1 :],
-                    prefix=cast(
-                        Literal["-", "--", "---"],
-                        current_flag_name[: current_flag_name.rfind("-") + 1],
-                    ),
-                    value=current_flag_value,
-                )
-
-                all_flags = [
-                    flag.get_string_entity() for flag in input_flags.get_flags()
-                ]
-                if input_flag.get_string_entity() not in all_flags:
-                    input_flags.add_flag(input_flag)
-                else:
-                    raise RepeatedInputFlagsException(input_flag)
+        return cls(trigger=trigger, input_flags=input_flags)
+        
+
+class CommandParser:
+    def __init__(self, raw_command: str) -> None:
+        self.raw_command: str = raw_command
+        self._parsed_input_flags: InputFlags = InputFlags()
+
+    def parse_raw_command(self) -> ParseResult:
+        if not self.raw_command:
+            raise EmptyInputCommandException()
 
-                current_flag_name, current_flag_value = None, None
+        input_flags, crnt_flag_name, crnt_flag_val = self._parse_flags(self.raw_command.split()[1:])
 
-        if any([current_flag_name, current_flag_value]):
+        if any([crnt_flag_name, crnt_flag_val]):
             raise UnprocessedInputFlagException()
         else:
-            return InputCommand(trigger=command, input_flags=input_flags)
+            return (self.raw_command.split()[0], input_flags)
+
+    def _parse_flags(self, _tokens: list[str] | list[Never]) -> ParseFlagsResult:
+        crnt_flg_name, crnt_flg_val = None, None
+        for index, token in enumerate(_tokens):
+            crnt_flg_name, crnt_flg_val = _parse_single_token(token, crnt_flg_name, crnt_flg_val)
+
+            if not crnt_flg_name or self._is_next_token_value(index, _tokens):
+                continue
+
+            input_flag = InputFlag(
+                name=crnt_flg_name[crnt_flg_name.rfind(MIN_FLAG_PREFIX) + 1:],
+                prefix=cast(
+                    Literal["-", "--", "---"],
+                    crnt_flg_name[:crnt_flg_name.rfind(MIN_FLAG_PREFIX) + 1],
+                ),
+                input_value=crnt_flg_val,
+                status=None
+            )
+            
+            if input_flag in self._parsed_input_flags:
+                raise RepeatedInputFlagsException(input_flag)
+            
+            self._parsed_input_flags.add_flag(input_flag)
+            crnt_flg_name, crnt_flg_val = None, None
+
+        return (self._parsed_input_flags, crnt_flg_name, crnt_flg_val)
+    
+    def _is_next_token_value(self, current_index: int,
+                                   _tokens: list[str] | list[Never]) -> bool:
+        next_index = current_index + 1
+        if next_index >= len(_tokens):
+            return False  
+        
+        next_token = _tokens[next_index]
+        return not next_token.startswith(MIN_FLAG_PREFIX)
+    
+def _parse_single_token(
+    token: str,
+    crnt_flag_name: str | None,
+    crnt_flag_val: str | None
+) -> tuple[str | None, str | None]:
+    if not token.startswith(MIN_FLAG_PREFIX):
+        if not crnt_flag_name or crnt_flag_val:
+            raise UnprocessedInputFlagException
+        return crnt_flag_name, token
+
+    prefix = token[:token.rfind(MIN_FLAG_PREFIX)]
+    if len(token) < 2 or len(prefix) > 2:
+        raise UnprocessedInputFlagException
+
+    new_flag_name = token
+    new_flag_value = None
+
+    return new_flag_name, new_flag_value

argenta/metrics/main.py

@@ -2,7 +2,7 @@ import io
 from contextlib import redirect_stdout
 from time import time
 
-from argenta.app import App
+from argenta import App
 
 
 def get_time_of_pre_cycle_setup(app: App) -> float:
@@ -13,6 +13,6 @@ def get_time_of_pre_cycle_setup(app: App) -> float:
     """
     start = time()
     with redirect_stdout(io.StringIO()):
-        app.pre_cycle_setup()
+        app._pre_cycle_setup() # pyright: ignore[reportPrivateUsage]
     end = time()
     return end - start

argenta/orchestrator/__init__.py

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

argenta/orchestrator/argparser/__init__.py

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

argenta/orchestrator/argparser/arguments/models.py

@@ -1,19 +1,19 @@
 from abc import ABC, abstractmethod
-from typing import Literal
+from typing import Literal, override
 
 
 class BaseArgument(ABC):
     """
     Private. Base class for all arguments
     """
-
+    @property
     @abstractmethod
-    def get_string_entity(self) -> str:
+    def string_entity(self) -> str:
         """
         Public. Returns the string representation of the argument
         :return: the string representation as a str
         """
-        pass
+        raise NotImplementedError
 
 
 class PositionalArgument(BaseArgument):
@@ -22,9 +22,11 @@ class PositionalArgument(BaseArgument):
         Public. Required argument at startup
         :param name: name of the argument, must not start with minus (-)
         """
-        self.name = name
+        self.name: str = name
 
-    def get_string_entity(self):
+    @property
+    @override
+    def string_entity(self) -> str:
         return self.name
 
 
@@ -35,10 +37,12 @@ class OptionalArgument(BaseArgument):
         :param name: name of the argument
         :param prefix: prefix of the argument
         """
-        self.name = name
-        self.prefix = prefix
+        self.name: str = name
+        self.prefix: Literal["-", "--", "---"] = prefix
 
-    def get_string_entity(self):
+    @property
+    @override
+    def string_entity(self) -> str:
         return self.prefix + self.name
 
 
@@ -49,8 +53,10 @@ class BooleanArgument(BaseArgument):
         :param name: name of the argument
         :param prefix: prefix of the argument
         """
-        self.name = name
-        self.prefix = prefix
+        self.name: str = name
+        self.prefix: Literal["-", "--", "---"] = prefix
 
-    def get_string_entity(self):
+    @property
+    @override
+    def string_entity(self) -> str:
         return self.prefix + self.name

argenta/orchestrator/argparser/entity.py

@@ -1,4 +1,4 @@
-from argparse import ArgumentParser
+from argparse import ArgumentParser, Namespace
 
 from argenta.orchestrator.argparser.arguments.models import (
     BooleanArgument,
@@ -10,7 +10,7 @@ from argenta.orchestrator.argparser.arguments.models import (
 class ArgParser:
     def __init__(
         self,
-        processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument],
+        processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument], *,
         name: str = "Argenta",
         description: str = "Argenta available arguments",
         epilog: str = "github.com/koloideal/Argenta | made by kolo",
@@ -22,38 +22,18 @@ class ArgParser:
         :param epilog: the epilog of the ArgParse instance
         :param processed_args: registered and processed arguments
         """
-        self.name = name
-        self.description = description
-        self.epilog = epilog
+        self._name: str = name
+        self._description: str = description
+        self._epilog: str = epilog
 
-        self.entity: ArgumentParser = ArgumentParser(
-            prog=name, description=description, epilog=epilog
-        )
-        self.args: (
-            list[PositionalArgument | OptionalArgument | BooleanArgument] | None
-        ) = processed_args
+        self._entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
+        self._processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument] = processed_args
+        
+        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")
 
-    def set_args(
-        self, *args: PositionalArgument | OptionalArgument | BooleanArgument
-    ) -> None:
-        """
-        Public. Sets the arguments to be processed
-        :param args: processed arguments
-        :return: None
-        """
-        self.args.extend(args)
-
-    def register_args(self) -> None:
-        """
-        Private. Registers initialized command line arguments
-        :return: None
-        """
-        if not self.args:
-            return
-        for arg in self.args:
-            if type(arg) is PositionalArgument:
-                self.entity.add_argument(arg.get_string_entity())
-            elif type(arg) is OptionalArgument:
-                self.entity.add_argument(arg.get_string_entity())
-            elif type(arg) is BooleanArgument:
-                self.entity.add_argument(arg.get_string_entity(), action="store_true")
+    def parse_args(self) -> Namespace:
+        return self._entity.parse_args()

argenta/orchestrator/entity.py

@@ -11,12 +11,9 @@ class Orchestrator:
         :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 | None = arg_parser
 
-    @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
@@ -29,7 +26,7 @@ class Orchestrator:
         Public. Returns the arguments parsed
         :return: None
         """
-        if self.arg_parser:
-            return self.arg_parser.entity.parse_args()
+        if self._arg_parser:
+            return self._arg_parser.parse_args()
         else:
             return None

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,23 @@
-from argenta.response.status import Status
-from argenta.command.flag.flags import (
-    ValidInputFlags,
-    UndefinedInputFlags,
-    InvalidValueInputFlags,
-)
+from typing import Literal
+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")
+    __slots__: tuple[Literal['status', 'input_flags'], ...] = ("status", "input_flags")
 
     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

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[[Response], 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[[Response], 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,7 @@ 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:
         """