argenta 0.4.1__py3-none-any.whl → 0.4.5__py3-none-any.whl

argenta/app/__init__.py

@@ -1 +1,3 @@
+__all__ = ["App"]
+
 from .entity import App

argenta/app/entity.py

@@ -2,18 +2,18 @@ from typing import Callable
 from inspect import getfullargspec
 import re
 
-from argenta.command import Command
+from argenta.command.models import Command, InputCommand
 from argenta.router import Router
 from argenta.router.defaults import system_router
 from argenta.command.exceptions import (UnprocessedInputFlagException,
                                   RepeatedInputFlagsException,
                                   EmptyInputCommandException)
-from .exceptions import (InvalidRouterInstanceException,
+from argenta.app.exceptions import (InvalidRouterInstanceException,
                          InvalidDescriptionMessagePatternException,
                          NoRegisteredRoutersException,
                          NoRegisteredHandlersException,
-                         RepeatedCommandInDifferentRoutersException,
                          IncorrectNumberOfHandlerArgsException)
+from argenta.app.registered_routers.entity import RegisteredRouters
 
 
 class App:
@@ -47,13 +47,12 @@ class App:
         self.repeat_command_groups = repeat_command_groups
         self.messages_on_startup = messages_on_startup if messages_on_startup else []
 
-        self._routers: list[Router] = []
         self._description_message_pattern: str = '[{command}] *=*=* {description}'
-        self._registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | Command]] | Router]] = []
+        self._registered_routers: RegisteredRouters = RegisteredRouters()
         self._invalid_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'Incorrect flag syntax: "{raw_command}"')
         self._repeated_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'Repeated input flags: "{raw_command}"')
-        self._empty_input_command_handler: Callable[[], None] = lambda: print_func(f'Empty input command')
-        self._unknown_command_handler: Callable[[Command], None] = lambda command: print_func(f"Unknown command: {command.get_trigger()}")
+        self._empty_input_command_handler: Callable[[], None] = lambda: print_func('Empty input command')
+        self._unknown_command_handler: Callable[[InputCommand], None] = lambda command: print_func(f"Unknown command: {command.get_trigger()}")
         self._exit_command_handler: Callable[[], None] = lambda: print_func(self.farewell_message)
 
 
@@ -61,7 +60,6 @@ class App:
         self._setup_system_router()
         self._validate_number_of_routers()
         self._validate_included_routers()
-        self._validate_all_router_commands()
 
         self.print_func(self.initial_message)
 
@@ -80,28 +78,12 @@ class App:
             raw_command: str = input()
 
             try:
-                input_command: Command = Command.parse_input_command(raw_command=raw_command)
-            except UnprocessedInputFlagException:
+                input_command: InputCommand = InputCommand.parse(raw_command=raw_command)
+            except (UnprocessedInputFlagException,
+                    RepeatedInputFlagsException,
+                    EmptyInputCommandException) as error:
                 self.print_func(self.line_separate)
-                self._invalid_input_flags_handler(raw_command)
-                self.print_func(self.line_separate)
-
-                if not self.repeat_command_groups:
-                    self.print_func(self.prompt)
-                continue
-
-            except RepeatedInputFlagsException:
-                self.print_func(self.line_separate)
-                self._repeated_input_flags_handler(raw_command)
-                self.print_func(self.line_separate)
-
-                if not self.repeat_command_groups:
-                    self.print_func(self.prompt)
-                continue
-
-            except EmptyInputCommandException:
-                self.print_func(self.line_separate)
-                self._empty_input_command_handler()
+                self._error_handler(error, raw_command)
                 self.print_func(self.line_separate)
 
                 if not self.repeat_command_groups:
@@ -122,8 +104,8 @@ class App:
                     self.print_func(self.prompt)
                 continue
 
-            for router in self._routers:
-                router.input_command_handler(input_command)
+            for registered_router in self._registered_routers:
+                registered_router.input_command_handler(input_command)
 
             self.print_func(self.line_separate)
             self.print_func(self.command_group_description_separate)
@@ -198,53 +180,35 @@ class App:
             raise InvalidRouterInstanceException()
 
         router.set_ignore_command_register(self.ignore_command_register)
-        self._routers.append(router)
+        self._registered_routers.add_registered_router(router)
 
-        command_entities: list[dict[str, Callable[[], None] | Command]] = router.get_command_entities()
-        self._registered_router_entities.append({'name': router.get_name(),
-                                                 'title': router.get_title(),
-                                                 'entity': router,
-                                                 'commands': command_entities})
+
+    def include_routers(self, *routers: Router) -> None:
+        for router in routers:
+            self.include_router(router)
 
 
     def _validate_number_of_routers(self) -> None:
-        if not self._routers:
+        if not self._registered_routers:
             raise NoRegisteredRoutersException()
 
 
     def _validate_included_routers(self) -> None:
-        for router in self._routers:
-            if not router.get_command_entities():
+        for router in self._registered_routers:
+            if not router.get_command_handlers():
                 raise NoRegisteredHandlersException(router.get_name())
 
 
-    def _validate_all_router_commands(self) -> None:
-        for idx in range(len(self._registered_router_entities)):
-            current_router: Router = self._registered_router_entities[idx]['entity']
-            routers_without_current_router = self._registered_router_entities.copy()
-            routers_without_current_router.pop(idx)
-
-            current_router_all_commands: list[str] = current_router.get_all_commands()
-
-            for router_entity in routers_without_current_router:
-                if len(set(current_router_all_commands).intersection(set(router_entity['entity'].get_all_commands()))) > 0:
-                    raise RepeatedCommandInDifferentRoutersException()
-                if self.ignore_command_register:
-                    if len(set([x.lower() for x in current_router_all_commands]).intersection(set([x.lower() for x in router_entity['entity'].get_all_commands()]))) > 0:
-                        raise RepeatedCommandInDifferentRoutersException()
-
-
     def _setup_system_router(self):
         system_router.set_title(self.system_points_title)
         @system_router.command(Command(self.exit_command, self.exit_command_description))
         def exit_command():
             self._exit_command_handler()
-
-        if system_router not in [router['entity'] for router in self._registered_router_entities]:
+        if system_router not in self._registered_routers.get_registered_routers():
             self.include_router(system_router)
 
 
-    def _is_exit_command(self, command: Command):
+    def _is_exit_command(self, command: InputCommand):
         if command.get_trigger().lower() == self.exit_command.lower():
             if self.ignore_exit_command_register:
                 system_router.input_command_handler(command)
@@ -256,27 +220,43 @@ class App:
         return False
 
 
-    def _check_is_command_unknown(self, command: Command):
-        registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | Command]] | Router]] = self._registered_router_entities
-        for router_entity in registered_router_entities:
-            for command_entity in router_entity['commands']:
-                if command_entity['command'].get_trigger().lower() == command.get_trigger().lower():
+    def _check_is_command_unknown(self, command: InputCommand):
+        for router_entity in self._registered_routers:
+            for command_handler in router_entity.get_command_handlers():
+                handled_command_trigger = command_handler.get_handled_command().get_trigger()
+                if handled_command_trigger.lower() == command.get_trigger().lower():
                     if self.ignore_command_register:
                         return False
                     else:
-                        if command_entity['command'].get_trigger() == command.get_trigger():
+                        if handled_command_trigger == command.get_trigger():
                             return False
         self._unknown_command_handler(command)
         return True
 
 
     def _print_command_group_description(self):
-        for router_entity in self._registered_router_entities:
-            self.print_func(router_entity['title'])
-            for command_entity in router_entity['commands']:
+        for registered_router in self._registered_routers:
+            self.print_func(registered_router.get_title())
+            for command_handler in registered_router.get_command_handlers():
                 self.print_func(self._description_message_pattern.format(
-                        command=command_entity['command'].get_trigger(),
-                        description=command_entity['command'].get_description()
+                        command=command_handler.get_handled_command().get_trigger(),
+                        description=command_handler.get_handled_command().get_description()
                     )
                 )
             self.print_func(self.command_group_description_separate)
+
+
+    def _error_handler(self,
+                       error: UnprocessedInputFlagException |
+                              RepeatedInputFlagsException |
+                              EmptyInputCommandException,
+                       raw_command: str) -> None:
+        match error:
+            case UnprocessedInputFlagException():
+                self._invalid_input_flags_handler(raw_command)
+            case RepeatedInputFlagsException():
+                self._repeated_input_flags_handler(raw_command)
+            case EmptyInputCommandException():
+                self._empty_input_command_handler()
+
+

argenta/app/exceptions.py

@@ -25,11 +25,6 @@ class NoRegisteredHandlersException(Exception):
         return f"No Registered Handlers Found For '{self.router_name}'"
 
 
-class RepeatedCommandInDifferentRoutersException(Exception):
-    def __str__(self):
-        return "Commands in different handlers cannot be repeated"
-
-
 class IncorrectNumberOfHandlerArgsException(Exception):
     def __str__(self):
         return "Incorrect Input Flags Handler has incorrect number of arguments"

argenta/app/registered_routers/entity.py

@@ -0,0 +1,21 @@
+from argenta.router import Router
+
+
+class RegisteredRouters:
+    def __init__(self, registered_routers: list[Router] = None) -> None:
+        self._registered_routers = registered_routers if registered_routers else []
+
+    def get_registered_routers(self) -> list[Router]:
+        return self._registered_routers
+
+    def add_registered_router(self, router: Router):
+        self._registered_routers.append(router)
+
+    def add_registered_routers(self, *routers: Router):
+        self._registered_routers.extend(routers)
+
+    def __iter__(self):
+        return iter(self._registered_routers)
+
+    def __next__(self):
+        return next(iter(self._registered_routers))

argenta/command/__init__.py

@@ -1 +1,3 @@
-from .entity import Command
+__all__ = ["Command"]
+
+from .models import Command

argenta/command/exceptions.py

@@ -1,4 +1,4 @@
-from argenta.command.flag.entity import Flag
+from argenta.command.flag.models import InputFlag, Flag
 
 
 class UnprocessedInputFlagException(Exception):
@@ -7,7 +7,7 @@ class UnprocessedInputFlagException(Exception):
 
 
 class RepeatedInputFlagsException(Exception):
-    def __init__(self, flag: Flag):
+    def __init__(self, flag: Flag | InputFlag):
         self.flag = flag
     def __str__(self):
         return ("Repeated Input Flags\n"

argenta/command/flag/__init__.py

@@ -1,2 +1,4 @@
-from .entity import Flag
-from .flags_group.entity import FlagsGroup
+__all__ = ('InputFlags', 'InputFlag', 'Flag', 'Flags')
+
+
+from .models import InputFlags, InputFlag, Flags, Flag

argenta/command/flag/defaults.py

@@ -1,21 +1,21 @@
 from dataclasses import dataclass
-from argenta.command.flag import Flag
+from argenta.command.flag.models import Flag
 import re
 
 
 @dataclass
-class DefaultFlags:
-    help_flag = Flag(flag_name='help', possible_flag_values=False)
-    short_help_flag = Flag(flag_name='h', flag_prefix='-', possible_flag_values=False)
+class PredeterminedFlags:
+    HELP = Flag(name='help', possible_values=False)
+    SHORT_HELP = Flag(name='h', prefix='-', possible_values=False)
 
-    info_flag = Flag(flag_name='info', possible_flag_values=False)
-    short_info_flag = Flag(flag_name='i', flag_prefix='-', possible_flag_values=False)
+    INFO = Flag(name='info', possible_values=False)
+    SHORT_INFO = Flag(name='i', prefix='-', possible_values=False)
 
-    all_flag = Flag(flag_name='all', possible_flag_values=False)
-    short_all_flag = Flag(flag_name='a', flag_prefix='-', possible_flag_values=False)
+    ALL = Flag(name='all', possible_values=False)
+    SHORT_ALL = Flag(name='a', prefix='-', possible_values=False)
 
-    host_flag = Flag(flag_name='host', possible_flag_values=re.compile(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'))
-    short_host_flag = Flag(flag_name='h', flag_prefix='-', possible_flag_values=re.compile(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'))
+    HOST = Flag(name='host', possible_values=re.compile(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'))
+    SHORT_HOST = Flag(name='h', prefix='-', possible_values=re.compile(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'))
 
-    port_flag = Flag(flag_name='port', possible_flag_values=re.compile(r'^\d{1,5}$'))
-    short_port_flag = Flag(flag_name='p', flag_prefix='-', possible_flag_values=re.compile(r'^\d{1,5}$'))
+    PORT = Flag(name='port', possible_values=re.compile(r'^\d{1,5}$'))
+    SHORT_PORT = Flag(name='p', prefix='-', possible_values=re.compile(r'^\d{1,5}$'))

argenta/command/flag/models.py

@@ -0,0 +1,140 @@
+from typing import Literal, Pattern
+from abc import ABC, abstractmethod
+
+
+class BaseFlag:
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--'):
+        self._name = name
+        self._prefix = prefix
+
+    def get_string_entity(self):
+        string_entity: str = self._prefix + self._name
+        return string_entity
+
+    def get_name(self):
+        return self._name
+
+    def get_prefix(self):
+        return self._prefix
+
+
+
+class InputFlag(BaseFlag):
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--',
+                 value: str = None):
+        super().__init__(name, prefix)
+        self._flag_value = value
+
+    def get_value(self):
+        return self._flag_value
+
+    def set_value(self, value):
+        self._flag_value = value
+
+
+
+class Flag(BaseFlag):
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--',
+                 possible_values: list[str] | Pattern[str] | False = True):
+        super().__init__(name, prefix)
+        self.possible_values = possible_values
+
+    def validate_input_flag_value(self, input_flag_value: str | None):
+        if self.possible_values is False:
+            if input_flag_value is None:
+                return True
+            else:
+                return False
+        elif isinstance(self.possible_values, Pattern):
+            if isinstance(input_flag_value, str):
+                is_valid = bool(self.possible_values.match(input_flag_value))
+                if bool(is_valid):
+                    return True
+                else:
+                    return False
+            else:
+                return False
+
+        elif isinstance(self.possible_values, list):
+            if input_flag_value in self.possible_values:
+                return True
+            else:
+                return False
+        else:
+            return True
+
+
+
+class BaseFlags(ABC):
+    __slots__ = ('_flags',)
+
+    @abstractmethod
+    def get_flags(self):
+        pass
+
+    @abstractmethod
+    def add_flag(self, flag: Flag | InputFlag):
+        pass
+
+    @abstractmethod
+    def add_flags(self, flags: list[Flag] | list[InputFlag]):
+        pass
+
+    @abstractmethod
+    def get_flag(self, name: str):
+        pass
+
+    def __iter__(self):
+        return iter(self._flags)
+
+    def __next__(self):
+        return next(iter(self))
+
+    def __getitem__(self, item):
+        return self._flags[item]
+
+
+
+class Flags(BaseFlags, ABC):
+    def __init__(self, *flags: Flag):
+        self._flags = flags if flags else []
+
+    def get_flags(self) -> list[Flag]:
+        return self._flags
+
+    def add_flag(self, flag: Flag):
+        self._flags.append(flag)
+
+    def add_flags(self, flags: list[Flag]):
+        self._flags.extend(flags)
+
+    def get_flag(self, name: str) -> Flag | None:
+        if name in [flag.get_name() for flag in self._flags]:
+            return list(filter(lambda flag: flag.get_name() == name, self._flags))[0]
+        else:
+            return None
+
+
+
+class InputFlags(BaseFlags, ABC):
+    def __init__(self, *flags: InputFlag):
+        self._flags = flags if flags else []
+
+    def get_flags(self) -> list[InputFlag]:
+        return self._flags
+
+    def add_flag(self, flag: InputFlag):
+        self._flags.append(flag)
+
+    def add_flags(self, flags: list[InputFlag]):
+        self._flags.extend(flags)
+
+    def get_flag(self, name: str) -> InputFlag | None:
+        if name in [flag.get_name() for flag in self._flags]:
+            return list(filter(lambda flag: flag.get_name() == name, self._flags))[0]
+        else:
+            return None
+

argenta/command/models.py

@@ -0,0 +1,105 @@
+from argenta.command.flag.models import Flag, InputFlag, Flags, InputFlags
+from argenta.command.exceptions import (UnprocessedInputFlagException,
+                                         RepeatedInputFlagsException,
+                                         EmptyInputCommandException)
+from typing import Generic, TypeVar, cast, Literal
+
+
+InputCommandType = TypeVar('InputCommandType')
+
+
+class BaseCommand:
+    def __init__(self, trigger: str):
+        self._trigger = trigger
+
+    def get_trigger(self) -> str:
+        return self._trigger
+
+
+class Command(BaseCommand):
+    def __init__(self, trigger: str,
+                 description: str = None,
+                 flags: Flag | Flags = None):
+        super().__init__(trigger)
+        self._registered_flags: Flags = flags if isinstance(flags, Flags) else Flags(flags) if isinstance(flags, Flag) else Flags()
+        self._description = f'description for "{self._trigger}" command' if not description else description
+
+    def get_registered_flags(self) -> Flags:
+        return self._registered_flags
+
+    def validate_input_flag(self, flag: InputFlag):
+        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 True
+            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 True
+        return False
+
+    def get_description(self) -> str:
+        return self._description
+
+
+
+class InputCommand(BaseCommand, Generic[InputCommandType]):
+    def __init__(self, trigger: str,
+                 input_flags: InputFlag | InputFlags = 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):
+        self._input_flags = input_flags
+
+    def get_input_flags(self) -> InputFlags:
+        return self._input_flags
+
+    @staticmethod
+    def parse(raw_command: str) -> InputCommandType:
+        if not raw_command:
+            raise EmptyInputCommandException()
+
+        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 current_flag_name or len(_) < 2 or len(_[:_.rfind('-')]) > 3:
+                    raise UnprocessedInputFlagException()
+                current_flag_name = _
+            else:
+                if not current_flag_name:
+                    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)
+
+                current_flag_name, current_flag_value = None, None
+
+        if any([current_flag_name, current_flag_value]):
+            raise UnprocessedInputFlagException()
+        else:
+            return InputCommand(trigger=command, input_flags=input_flags)
+

argenta/router/__init__.py

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

argenta/router/command_handler/entity.py

@@ -0,0 +1,21 @@
+from typing import Callable
+from argenta.command import Command
+from argenta.command.flag.models import InputFlags
+
+
+class CommandHandler:
+    def __init__(self, handler: Callable[[], None] | Callable[[InputFlags], None], handled_command: Command):
+        self.handler = handler
+        self.handled_command = handled_command
+
+    def handling(self, input_flags: InputFlags):
+        if input_flags.get_flags():
+            self.handler(input_flags)
+        else:
+            self.handler()
+
+    def get_handler(self):
+        return self.handler
+
+    def get_handled_command(self):
+        return self.handled_command

argenta/router/command_handlers/entity.py

@@ -0,0 +1,21 @@
+from argenta.router.command_handler.entity import CommandHandler
+
+
+class CommandHandlers:
+    def __init__(self, command_handlers: list[CommandHandler] = None):
+        self.command_handlers = command_handlers if command_handlers else []
+
+    def get_command_handlers(self) -> list[CommandHandler]:
+        return self.command_handlers
+
+    def add_command_handler(self, command_handler: CommandHandler):
+        self.command_handlers.append(command_handler)
+
+    def add_command_handlers(self, *command_handlers: CommandHandler):
+        self.command_handlers.extend(command_handlers)
+
+    def __iter__(self):
+        return iter(self.command_handlers)
+
+    def __next__(self):
+        return next(iter(self.command_handlers))

argenta/router/entity.py

@@ -1,26 +1,26 @@
 from typing import Callable, Any
 from inspect import getfullargspec
 
-from ..command.entity import Command
-from argenta.command.flag.entity import Flag
-from argenta.command.flag.flags_group import FlagsGroup
-from ..router.exceptions import (RepeatedCommandException,
-                                 RepeatedFlagNameException,
-                                 TooManyTransferredArgsException,
-                                 RequiredArgumentNotPassedException,
-                                 IncorrectNumberOfHandlerArgsException,
-                                 TriggerCannotContainSpacesException)
+from argenta.command import Command
+from argenta.command.models import InputCommand
+from argenta.router.command_handlers.entity import CommandHandlers
+from argenta.router.command_handler.entity import CommandHandler
+from argenta.command.flag.models import Flag, Flags, InputFlags
+from argenta.router.exceptions import (RepeatedFlagNameException,
+                                     TooManyTransferredArgsException,
+                                     RequiredArgumentNotPassedException,
+                                     IncorrectNumberOfHandlerArgsException,
+                                     TriggerCannotContainSpacesException)
 
 
 class Router:
     def __init__(self,
                  title: str = 'Commands group title:',
                  name: str = 'Default'):
-
         self._title = title
         self._name = name
 
-        self._command_entities: list[dict[str, Callable[[], None] | Command]] = []
+        self._command_handlers: CommandHandlers = CommandHandlers()
         self._ignore_command_register: bool = False
 
         self._not_valid_flag_handler: Callable[[Flag], None] = lambda flag: print(f"Undefined or incorrect input flag: {flag.get_string_entity()}{(' '+flag.get_value()) if flag.get_value() else ''}")
@@ -31,14 +31,15 @@ class Router:
 
         def command_decorator(func):
             Router._validate_func_args(command, func)
-            self._command_entities.append({'handler_func': func,
-                                           'command': command})
+            self._command_handlers.add_command_handler(CommandHandler(func, command))
+
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
             return wrapper
 
         return command_decorator
 
+
     def set_invalid_input_flag_handler(self, func):
         processed_args = getfullargspec(func).args
         if len(processed_args) != 1:
@@ -47,40 +48,40 @@ class Router:
             self._not_valid_flag_handler = func
 
 
-    def input_command_handler(self, input_command: Command):
+    def input_command_handler(self, input_command: InputCommand):
         input_command_name: str = input_command.get_trigger()
-        input_command_flags: FlagsGroup = input_command.get_input_flags()
-        for command_entity in self._command_entities:
-            if input_command_name.lower() == command_entity['command'].get_trigger().lower():
-                if command_entity['command'].get_registered_flags():
+        input_command_flags: InputFlags = input_command.get_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():
+                if handle_command.get_registered_flags():
                     if input_command_flags:
                         for flag in input_command_flags:
-                            is_valid = command_entity['command'].validate_input_flag(flag)
+                            is_valid = handle_command.validate_input_flag(flag)
                             if not is_valid:
                                 self._not_valid_flag_handler(flag)
                                 return
-                        return command_entity['handler_func'](input_command_flags.unparse_to_dict())
+                        command_handler.handling(input_command_flags)
+                        return
                     else:
-                        return command_entity['handler_func']({})
+                        command_handler.handling({})
+                        return
                 else:
                     if input_command_flags:
                         self._not_valid_flag_handler(input_command_flags[0])
                         return
                     else:
-                        return command_entity['handler_func']()
+                        command_handler.handling()
+                        return
 
 
-    def _validate_command(self, command: Command):
+    @staticmethod
+    def _validate_command(command: Command):
         command_name: str = command.get_trigger()
         if command_name.find(' ') != -1:
             raise TriggerCannotContainSpacesException()
-        if command_name in self.get_all_commands():
-            raise RepeatedCommandException()
-        if self._ignore_command_register:
-            if command_name.lower() in [x.lower() for x in self.get_all_commands()]:
-                raise RepeatedCommandException()
 
-        flags: FlagsGroup = command.get_registered_flags()
+        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):
@@ -91,12 +92,12 @@ class Router:
     def _validate_func_args(command: Command, func: Callable):
         registered_args = command.get_registered_flags()
         transferred_args = getfullargspec(func).args
-        if registered_args and transferred_args:
+        if registered_args.get_flags() and transferred_args:
            if len(transferred_args) != 1:
                 raise TooManyTransferredArgsException()
-        elif registered_args and not transferred_args:
+        elif registered_args.get_flags() and not transferred_args:
             raise RequiredArgumentNotPassedException()
-        elif not registered_args and transferred_args:
+        elif not registered_args.get_flags() and transferred_args:
             raise TooManyTransferredArgsException()
 
 
@@ -104,8 +105,8 @@ class Router:
         self._ignore_command_register = ignore_command_register
 
 
-    def get_command_entities(self) -> list[dict[str, Callable[[], None] | Command]]:
-        return self._command_entities
+    def get_command_handlers(self) -> CommandHandlers:
+        return self._command_handlers
 
 
     def get_name(self) -> str:
@@ -122,7 +123,7 @@ class Router:
 
     def get_all_commands(self) -> list[str]:
         all_commands: list[str] = []
-        for command_entity in self._command_entities:
-            all_commands.append(command_entity['command'].get_trigger())
+        for command_handler in self._command_handlers:
+            all_commands.append(command_handler.get_handled_command().get_trigger())
 
         return all_commands

argenta/router/exceptions.py

@@ -1,11 +1,6 @@
-class RepeatedCommandException(Exception):
-    def __str__(self):
-        return "Commands in handler cannot be repeated"
-
-
 class RepeatedFlagNameException(Exception):
     def __str__(self):
-        return "Repeated flag name in register command"
+        return "Repeated registered_flag name in register command"
 
 
 class TooManyTransferredArgsException(Exception):

{argenta-0.4.1.dist-info → argenta-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: argenta
-Version: 0.4.1
+Version: 0.4.5
 Summary: python library for creating custom shells
 License: MIT
 Author: kolo
@@ -71,14 +71,14 @@ if __name__ == '__main__':
 import re
 from argenta.router import Router
 from argenta.command import Command
-from argenta.command.flag import FlagsGroup, Flag
+from argenta.command.flag import Flags, Flag, InputFlags
 
 router = Router()
 
-registered_flags = FlagsGroup(
-    Flag(flag_name='host',
-         flag_prefix='--',
-         possible_flag_values=re.compile(r'^192.168.\d{1,3}.\d{1,3}$')),
+registered_flags = Flags(
+    Flag(name='host',
+         prefix='--',
+         possible_values=re.compile(r'^192.168.\d{1,3}.\d{1,3}$')),
     Flag('port', '--', re.compile(r'^[0-9]{1,4}$')))
 
 
@@ -90,10 +90,10 @@ def handler():
 @router.command(Command(trigger="ssh",
                         description='connect via ssh',
                         flags=registered_flags))
-def handler_with_flags(flags: dict):
+def handler_with_flags(flags: InputFlags):
     for flag in flags:
-        print(f'Flag name: {flag['name']}\n'
-              f'Flag value: {flag['value']}')
+        print(f'Flag name: {flag.get_name()}\n'
+              f'Flag value: {flag.get_value()}')
 ```
 
 ---
@@ -314,7 +314,6 @@ Router(title: str = 'Commands group title:',
 ---
 
 ### Исключения
-- `RepeatedCommandException` - Одна и та же команда зарегистрирована в одном роутере
 - `RepeatedFlagNameException` - Повторяющиеся зарегистрированные флаги в команде
 - `TooManyTransferredArgsException` - Слишком много зарегистрированных аргументов у обработчика команды
 - `RequiredArgumentNotPassedException` - Не зарегистрирован обязательный аргумент у обработчика команды(аргумент, через который будут переданы флаги введённой команды)
@@ -330,14 +329,14 @@ Router(title: str = 'Commands group title:',
 ```python
 Command(trigger: str,
         description: str = None,
-        flags: Flag | FlagsGroup = None)
+        flags: Flag | Flags = None)
 ```
 
 **Аргументы:**
 - **name : mean**
 - `trigger` (`str`): Строковый триггер
 - `description` (`str`): Описание команды, которое будет выведено в консоль при запуске оболочки
-- `flags` (`Flag | FlagsGroup`): Флаги, которые будут обработаны при их наличии во вводе юзера
+- `flags` (`Flag | Flags`): Флаги, которые будут обработаны при их наличии во вводе юзера
 
 ---
 
@@ -353,7 +352,7 @@ Command(trigger: str,
 
 ---
 
-#### **.get_registered_flags() -> `FlagsGroup | None`**  
+#### **.get_registered_flags() -> `Flags | None`**  
 
 *method mean* **::** возвращает зарегистрированные флаги экземпляра
 
@@ -417,14 +416,14 @@ Flag(flag_name: str,
 
 ---
 
-##  *class* :: `FlagsGroup` 
+##  *class* :: `Flags` 
 Класс, объединяющий список флагов в один объект, используется в качестве 
 передаваемого аргумента `flags` экземпляру класса `Command`, при регистрации
 хэндлера
 
 ### Конструктор
 ```python
-FlagsGroup(*flagы: Flag)
+Flags(*flagы: Flag)
 ```
 
 ---

argenta-0.4.5.dist-info/RECORD

@@ -0,0 +1,24 @@
+argenta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/app/__init__.py,sha256=5BZcyJqfexO8t43j1LkWUB5BtGtZXpkR7170YvfeM30,46
+argenta/app/entity.py,sha256=3oo3eCiUockvTQVjGnkt17yEno8aRshohGTGEox87P4,11195
+argenta/app/exceptions.py,sha256=hItqsh76Fq6FfeanHqX8dvF00ERHXbQYjap5UODwg3o,1095
+argenta/app/registered_routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/app/registered_routers/entity.py,sha256=OQZyrF4eoCoDHzRJ22zZxhNEx-bOUDu7NZIFDfO-fuY,688
+argenta/command/__init__.py,sha256=Yx5Zl5Diwhjs8SZrsYEBNJscTMxWkLP0nqPvAJZtu30,52
+argenta/command/exceptions.py,sha256=J3kNY6CFoOxJXsZ23Bfl6f5uVUSiKZfwiGPBmlOwN5M,578
+argenta/command/flag/__init__.py,sha256=Ew-ZRFVY7sC_PMvavN0AEcsvdYGHkLAPOYMrReY3NC0,116
+argenta/command/flag/defaults.py,sha256=ktKmDT0rSSBoFUghTlEQ6OletoFxCiD37hRzO73mUUc,875
+argenta/command/flag/models.py,sha256=X1MFpAtnUX6mi1huycAtwAPXPeh9YFO-lH91TNyD3G4,3755
+argenta/command/models.py,sha256=ZVgJjS2uZbO2YaRYaXeT8a-IfO1IOiylWJXOMsx6fJw,4409
+argenta/router/__init__.py,sha256=uP58EfcmtK2NuMBQaspD_Gmq3LqgDXus4rfB6hp9Uig,52
+argenta/router/command_handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/router/command_handler/entity.py,sha256=-qV_Ysw6WcklW0WN5nAD8U3QLbqBNGT-WeMFHuhfrf4,639
+argenta/router/command_handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/router/command_handlers/entity.py,sha256=KgFKjAMUr_mOcn9xahTxMUKB6lIxXgqCuAsuc4TgP6E,747
+argenta/router/defaults.py,sha256=huftOg1HMjrT_R2SHHOL4eJ5uZHspNEYBSg-mCq9xhU,126
+argenta/router/entity.py,sha256=-88RWF2IEKBUwM7zfUiN0rrDjVpU94m4y5nuspld5ao,5073
+argenta/router/exceptions.py,sha256=tdeaR8zDvnytgRYo_wQWKHt3if2brapgauIhhMIsTsA,678
+argenta-0.4.5.dist-info/LICENSE,sha256=zmqoGh2n5rReBv4s8wPxF_gZEZDgauJYSPMuPczgOiU,1082
+argenta-0.4.5.dist-info/METADATA,sha256=qI8PsEalTHJ7WYK4mB1Zer4n8rxafBMEO9rbp2qkcsg,18031
+argenta-0.4.5.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+argenta-0.4.5.dist-info/RECORD,,

argenta/command/entity.py

@@ -1,110 +0,0 @@
-from argenta.command.flag.entity import Flag
-from argenta.command.flag.flags_group import FlagsGroup
-from .exceptions import (UnprocessedInputFlagException,
-                         RepeatedInputFlagsException,
-                         EmptyInputCommandException)
-
-from typing import Generic, TypeVar, cast, Literal
-
-
-CommandType = TypeVar('CommandType')
-
-
-class Command(Generic[CommandType]):
-    def __init__(self, trigger: str,
-                 description: str = None,
-                 flags: Flag | FlagsGroup = None):
-        self._trigger = trigger
-        self._description = f'description for "{self._trigger}" command' if not description else description
-        self._registered_flags: FlagsGroup | None = flags if isinstance(flags, FlagsGroup) else FlagsGroup(flags) if isinstance(flags, Flag) else flags
-        self._input_flags: FlagsGroup | None = None
-
-
-    def get_trigger(self) -> str:
-        return self._trigger
-
-
-    def get_description(self) -> str:
-        return self._description
-
-
-    def get_registered_flags(self) -> FlagsGroup | None:
-        return self._registered_flags
-
-
-    def validate_input_flag(self, flag: Flag):
-        registered_flags: FlagsGroup | 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 True
-            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 True
-        return False
-
-
-    def _set_input_flags(self, input_flags: FlagsGroup):
-        self._input_flags = input_flags
-
-    def get_input_flags(self) -> FlagsGroup:
-        return self._input_flags
-
-    @staticmethod
-    def parse_input_command(raw_command: str) -> CommandType:
-        if not raw_command:
-            raise EmptyInputCommandException()
-        list_of_tokens = raw_command.split()
-        command = list_of_tokens[0]
-        list_of_tokens.pop(0)
-
-        flags: FlagsGroup = FlagsGroup()
-        current_flag_name = None
-        current_flag_value = None
-        for k, _ in enumerate(list_of_tokens):
-            if _.startswith('-'):
-                flag_prefix_last_symbol_index = _.rfind('-')
-                if current_flag_name or len(_) < 2 or len(_[:flag_prefix_last_symbol_index]) > 3:
-                    raise UnprocessedInputFlagException()
-                else:
-                    current_flag_name = _
-            else:
-                if not current_flag_name:
-                    raise UnprocessedInputFlagException()
-                else:
-                    current_flag_value = _
-            if current_flag_name:
-                if not len(list_of_tokens) == k+1:
-                    if not list_of_tokens[k+1].startswith('-'):
-                        continue
-                flag_prefix_last_symbol_index = current_flag_name.rfind('-')
-                flag_prefix = current_flag_name[:flag_prefix_last_symbol_index+1]
-                flag_name = current_flag_name[flag_prefix_last_symbol_index+1:]
-                input_flag = Flag(flag_name=flag_name,
-                                  flag_prefix=cast(Literal['-', '--', '---'], flag_prefix))
-                input_flag.set_value(current_flag_value)
-
-                all_flags = [x.get_string_entity() for x in flags.get_flags()]
-                if input_flag.get_string_entity() not in all_flags:
-                    flags.add_flag(input_flag)
-                else:
-                    raise RepeatedInputFlagsException(input_flag)
-
-                current_flag_name = None
-                current_flag_value = None
-        if any([current_flag_name, current_flag_value]):
-            raise UnprocessedInputFlagException()
-        if len(flags.get_flags()) == 0:
-            return Command(trigger=command)
-        else:
-            input_command = Command(trigger=command)
-            input_command._set_input_flags(flags)
-            return input_command
-
-
-

argenta/command/flag/entity.py

@@ -1,49 +0,0 @@
-from typing import Literal, Pattern
-
-
-class Flag:
-    def __init__(self, flag_name: str,
-                 flag_prefix: Literal['-', '--', '---'] = '--',
-                 possible_flag_values: list[str] | Pattern[str] | False = True):
-        self._flag_name = flag_name
-        self._flag_prefix = flag_prefix
-        self.possible_flag_values = possible_flag_values
-
-        self._flag_value = None
-
-    def get_string_entity(self):
-        string_entity: str = self._flag_prefix + self._flag_name
-        return string_entity
-
-    def get_flag_name(self):
-        return self._flag_name
-
-    def get_flag_prefix(self):
-        return self._flag_prefix
-
-    def get_value(self):
-        return self._flag_value
-
-    def set_value(self, value):
-        self._flag_value = value
-
-    def validate_input_flag_value(self, input_flag_value: str | None):
-        if self.possible_flag_values is False:
-            if input_flag_value is None:
-                return True
-            else:
-                return False
-        elif isinstance(self.possible_flag_values, Pattern):
-            is_valid = bool(self.possible_flag_values.match(input_flag_value))
-            if bool(is_valid):
-                return True
-            else:
-                return False
-
-        elif isinstance(self.possible_flag_values, list):
-            if input_flag_value in self.possible_flag_values:
-                return True
-            else:
-                return False
-        else:
-            return True

argenta/command/flag/flags_group/__init__.py

@@ -1 +0,0 @@
-from .entity import FlagsGroup

argenta/command/flag/flags_group/entity.py

@@ -1,35 +0,0 @@
-from argenta.command.flag import Flag
-
-
-class FlagsGroup:
-    def __init__(self, *flags: Flag):
-        self._flags: list[Flag] = [] if not flags else flags
-
-    def get_flags(self) -> list[Flag]:
-        return self._flags
-
-    def add_flag(self, flag: Flag):
-        self._flags.append(flag)
-
-    def add_flags(self, flags: list[Flag]):
-        self._flags.extend(flags)
-
-    def unparse_to_dict(self):
-        result_dict: dict[str, dict] = {}
-        for flag in self._flags:
-            result_dict[flag.get_flag_name()] = {
-                'name': flag.get_flag_name(),
-                'string_entity': flag.get_string_entity(),
-                'prefix': flag.get_flag_prefix(),
-                'value': flag.get_value()
-            }
-        return result_dict
-
-    def __iter__(self):
-        return iter(self._flags)
-
-    def __next__(self):
-        return next(iter(self))
-
-    def __getitem__(self, item):
-        return self._flags[item]

argenta-0.4.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-argenta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argenta/app/__init__.py,sha256=NoKJpO5inI4bEtptNj7BZtNpGQidCNoFSw2-JoK6P98,25
-argenta/app/entity.py,sha256=9vRk66GQD-3kC--alv21gM_rqyA9ZzKfzXy0jVD6cO0,12506
-argenta/app/exceptions.py,sha256=ruI_MwJQtBLrnWxJbKlSRE50c5FjnZ9qXJma34kPZhk,1253
-argenta/command/__init__.py,sha256=yRSj5CtLjxwjKiokUGdSmuBZPOF_qheRyG0NW1pv7vo,27
-argenta/command/entity.py,sha256=uICQk5zaD_IG52q2IpFTDiGkTK0G6guPR6Eb9Y-3n0E,4454
-argenta/command/exceptions.py,sha256=ZhJS_ThdmTgGnZqhSfCfkT_VcfkHTiAU7hAgrme6gQY,555
-argenta/command/flag/__init__.py,sha256=y6rJLdag5qxONg1CzcP7gi6rCeix9UsG1AVANX3fnJs,68
-argenta/command/flag/defaults.py,sha256=FjmqepLflYhp2yQcH2bCLi8nip9Bihb5d_HInuEWD4I,1037
-argenta/command/flag/entity.py,sha256=osMAh-PVP_1MhRhe4Zf1NmJu5NJWAyY6oOKT9mtZnWw,1542
-argenta/command/flag/flags_group/__init__.py,sha256=f1q3albNnoQYrY56Exb75oh62miTdxD0ALo5aBWW9_g,30
-argenta/command/flag/flags_group/entity.py,sha256=NcyKjC_N-8d4xARkVCLSK8-PoPrKjSlIbR4SHSa7_us,985
-argenta/router/__init__.py,sha256=vIU2o3JJ7misRm9mUzUQw5HdverdMDfvHNzkWuYFRBY,26
-argenta/router/defaults.py,sha256=huftOg1HMjrT_R2SHHOL4eJ5uZHspNEYBSg-mCq9xhU,126
-argenta/router/entity.py,sha256=w4_LO3jVbQPMu8GHjSW6q-_AdQ_IPQkGJHjYaCVXw-Q,5195
-argenta/router/exceptions.py,sha256=NseEKrhwvG-H5_qdN-hzq83eJ98jku-PzHspz4CG9PM,796
-argenta-0.4.1.dist-info/LICENSE,sha256=zmqoGh2n5rReBv4s8wPxF_gZEZDgauJYSPMuPczgOiU,1082
-argenta-0.4.1.dist-info/METADATA,sha256=r7hxvBwmXnaa3GDn3x3bvUlIode_EGFW1E2iCB6wkZY,18187
-argenta-0.4.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-argenta-0.4.1.dist-info/RECORD,,