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

argenta/app/__init__.py

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

argenta/app/defaults.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PredeterminedMessages:
+    USAGE = '[b dim]Usage[/b dim]: [i]<command> <[green]flags[/green]>[/i]'
+    HELP = '[b dim]Help[/b dim]: [i]<command>[/i] [b red]--help[/b red]'
+

argenta/app/exceptions.py

@@ -23,13 +23,3 @@ class NoRegisteredHandlersException(Exception):
         self.router_name = router_name
     def __str__(self):
         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/models.py

@@ -0,0 +1,214 @@
+from typing import Callable
+from rich.console import Console
+from art import text2art
+import re
+
+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,
+                                        BaseInputCommandException)
+from argenta.app.exceptions import (InvalidRouterInstanceException,
+                                    InvalidDescriptionMessagePatternException,
+                                    NoRegisteredRoutersException,
+                                    NoRegisteredHandlersException)
+from argenta.app.registered_routers.entity import RegisteredRouters
+
+
+
+class BaseApp:
+    def __init__(self,
+                 prompt: str = '[italic dim bold]What do you want to do?\n',
+                 initial_message: str = 'Argenta',
+                 farewell_message: str = 'See you',
+                 exit_command: str = 'Q',
+                 exit_command_description: str = 'Exit command',
+                 system_points_title: str = 'System points:',
+                 ignore_command_register: bool = True,
+                 line_separate: str = '-----',
+                 repeat_command_groups: bool = True,
+                 print_func: Callable[[str], None] = Console().print) -> None:
+        self._prompt = prompt
+        self._print_func = print_func
+        self._exit_command = exit_command
+        self._exit_command_description = exit_command_description
+        self._system_points_title = system_points_title
+        self._line_separate = line_separate
+        self._ignore_command_register = ignore_command_register
+        self._repeat_command_groups_description = repeat_command_groups
+
+        self.farewell_message = farewell_message
+        self.initial_message = initial_message
+
+        self._description_message_pattern: str = '[bold red][{command}][/bold red] [blue dim]*=*=*[/blue dim] [bold yellow italic]{description}'
+        self._registered_routers: RegisteredRouters = RegisteredRouters()
+        self._messages_on_startup = []
+
+        self.invalid_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'[red bold]Incorrect flag syntax: {raw_command}')
+        self.repeated_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'[red bold]Repeated input flags: {raw_command}')
+        self.empty_input_command_handler: Callable[[], None] = lambda: print_func('[red bold]Empty input command')
+        self.unknown_command_handler: Callable[[InputCommand], None] = lambda command: print_func(f"[red bold]Unknown command: {command.get_trigger()}")
+        self.exit_command_handler: Callable[[], None] = lambda: print_func(self.farewell_message)
+
+        self._setup_default_view(is_initial_message_default=initial_message == 'Argenta',
+                                 is_farewell_message_default=farewell_message == 'See you',
+                                 is_line_separate_default=line_separate == '-----')
+
+
+    def _setup_default_view(self, is_initial_message_default: bool,
+                            is_farewell_message_default: bool,
+                            is_line_separate_default: bool):
+        if is_initial_message_default:
+            self.initial_message = f'\n[bold red]{text2art('Argenta', font='tarty1')}\n\n'
+        if is_farewell_message_default:
+            self.farewell_message = (f'[bold red]\n{text2art('\nSee   you\n', font='chanky')}[/bold red]\n'
+                                     f'[red i]github.com/koloideal/Argenta[/red i] | '
+                                     f'[red bold i]made by kolo[/red bold i]\n')
+        if is_line_separate_default:
+            self._line_separate = f'\n[dim]{"-" * 50}\n'
+
+
+    def _validate_number_of_routers(self) -> None:
+        if not self._registered_routers:
+            raise NoRegisteredRoutersException()
+
+
+    def _validate_included_routers(self) -> None:
+        for router in self._registered_routers:
+            if not router.get_command_handlers():
+                raise NoRegisteredHandlersException(router.get_name())
+
+
+    def _is_exit_command(self, command: InputCommand):
+        if command.get_trigger().lower() == self._exit_command.lower():
+            if self._ignore_command_register:
+                system_router.input_command_handler(command)
+                return True
+            elif command.get_trigger() == self._exit_command:
+                system_router.input_command_handler(command)
+                return True
+        return False
+
+
+    def _is_unknown_command(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() and self._ignore_command_register:
+                    return False
+                elif handled_command_trigger == command.get_trigger():
+                    return False
+        self.unknown_command_handler(command)
+        return True
+
+
+    def _print_command_group_description(self):
+        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_handler.get_handled_command().get_trigger(),
+                        description=command_handler.get_handled_command().get_description()))
+            self._print_func('')
+
+
+    def _error_handler(self, error: BaseInputCommandException, 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()
+
+
+
+class App(BaseApp):
+    def start_polling(self) -> None:
+        self._setup_system_router()
+        self._validate_number_of_routers()
+        self._validate_included_routers()
+
+        self._print_func(self.initial_message)
+
+        for message in self._messages_on_startup:
+            self._print_func(message)
+
+        if not self._repeat_command_groups_description:
+            self._print_command_group_description()
+
+        while True:
+            if self._repeat_command_groups_description:
+                self._print_command_group_description()
+
+            raw_command: str = Console().input(self._prompt)
+
+            try:
+                input_command: InputCommand = InputCommand.parse(raw_command=raw_command)
+            except BaseInputCommandException as error:
+                self._print_func(self._line_separate)
+                self._error_handler(error, raw_command)
+                self._print_func(self._line_separate)
+
+                if not self._repeat_command_groups_description:
+                    self._print_func(self._prompt)
+                continue
+
+            if self._is_exit_command(input_command):
+                return
+
+            self._print_func(self._line_separate)
+
+            if self._is_unknown_command(input_command):
+                self._print_func(self._line_separate)
+                if not self._repeat_command_groups_description:
+                    self._print_func(self._prompt)
+                continue
+
+            for registered_router in self._registered_routers:
+                registered_router.input_command_handler(input_command)
+
+            self._print_func(self._line_separate)
+            if not self._repeat_command_groups_description:
+                self._print_func(self._prompt)
+
+
+    def include_router(self, router: Router) -> None:
+        if not isinstance(router, Router):
+            raise InvalidRouterInstanceException()
+
+        router.set_ignore_command_register(self._ignore_command_register)
+        self._registered_routers.add_registered_router(router)
+
+
+    def include_routers(self, *routers: Router) -> None:
+        for router in routers:
+            self.include_router(router)
+
+
+    def add_message_on_startup(self, message: str) -> None:
+        self._messages_on_startup.append(message)
+
+
+    def set_description_message_pattern(self, pattern: str) -> None:
+        first_check = re.match(r'.*{command}.*', pattern)
+        second_check = re.match(r'.*{description}.*', pattern)
+
+        if bool(first_check) and bool(second_check):
+            self._description_message_pattern: str = pattern
+        else:
+            raise InvalidDescriptionMessagePatternException(pattern)
+
+
+    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 self._registered_routers.get_registered_routers():
+            self.include_router(system_router)
+
+

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,19 +1,23 @@
-from argenta.command.flag.entity import Flag
+from argenta.command.flag.models import InputFlag, Flag
 
 
-class UnprocessedInputFlagException(Exception):
+class BaseInputCommandException(Exception):
+    pass
+
+
+class UnprocessedInputFlagException(BaseInputCommandException):
     def __str__(self):
         return "Unprocessed Input Flags"
 
 
-class RepeatedInputFlagsException(Exception):
-    def __init__(self, flag: Flag):
+class RepeatedInputFlagsException(BaseInputCommandException):
+    def __init__(self, flag: Flag | InputFlag):
         self.flag = flag
     def __str__(self):
         return ("Repeated Input Flags\n"
                 f"Duplicate flag was detected in the input: '{self.flag.get_string_entity()}'")
 
 
-class EmptyInputCommandException(Exception):
+class EmptyInputCommandException(BaseInputCommandException):
     def __str__(self):
-        return "Input Command is empty"
+        return "Input Command is empty"

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,106 @@
+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 = None):
+        if input_flags is not None:
+            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))