argenta 0.4.9__tar.gz → 0.5.0a0__tar.gz

{argenta-0.4.9 → argenta-0.5.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: argenta
-Version: 0.4.9
+Version: 0.5.0a0
 Summary: Python library for creating TUI
 License: MIT
 Author: kolo

argenta-0.5.0a0/argenta/app/__init__.py

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

argenta-0.5.0a0/argenta/app/autocompleter/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["AutoCompleter"]
+
+
+from argenta.app.autocompleter.entity import AutoCompleter

argenta-0.5.0a0/argenta/app/autocompleter/entity.py

@@ -0,0 +1,48 @@
+import os
+
+import readline
+
+
+class AutoCompleter:
+    def __init__(self, history_filename: str = False, autocomplete_button: str = 'tab'):
+        self.history_filename = history_filename
+        self.autocomplete_button = autocomplete_button
+        self.matches = []
+
+    def complete(self, text, state):
+        matches = sorted(cmd for cmd in self.get_history_items() if cmd.startswith(text))
+        if len(matches) > 1:
+            common_prefix = matches[0]
+            for match in matches[1:]:
+                i = 0
+                while i < len(common_prefix) and i < len(match) and common_prefix[i] == match[i]:
+                    i += 1
+                common_prefix = common_prefix[:i]
+            if state == 0:
+                readline.insert_text(common_prefix[len(text):])
+                readline.redisplay()
+            return None
+        elif len(matches) == 1:
+            return matches[0] if state == 0 else None
+        else:
+            return None
+
+    def initial_setup(self, all_commands: list[str]):
+        if self.history_filename:
+            if os.path.exists(self.history_filename):
+                readline.read_history_file(self.history_filename)
+            else:
+                for line in all_commands:
+                    readline.add_history(line)
+
+        readline.set_completer(self.complete)
+        readline.set_completer_delims(readline.get_completer_delims().replace(' ', ''))
+        readline.parse_and_bind(f'{self.autocomplete_button}: complete')
+
+    def exit_setup(self):
+        if self.history_filename:
+            readline.write_history_file(self.history_filename)
+
+    @staticmethod
+    def get_history_items():
+        return [readline.get_history_item(i) for i in range(1, readline.get_current_history_length() + 1)]

{argenta-0.4.9 → argenta-0.5.0a0}/argenta/app/defaults.py

@@ -5,4 +5,5 @@ from dataclasses import 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]'
+    AUTOCOMPLETE = '[b dim]Autocomplete[/b dim]: [i]<part>[/i] [bold]<tab>'
 

argenta-0.5.0a0/argenta/app/exceptions.py

@@ -0,0 +1,15 @@
+class InvalidRouterInstanceException(Exception):
+    def __str__(self):
+        return "Invalid Router Instance"
+
+
+class NoRegisteredRoutersException(Exception):
+    def __str__(self):
+        return "No Registered Router Found"
+
+
+class NoRegisteredHandlersException(Exception):
+    def __init__(self, router_name):
+        self.router_name = router_name
+    def __str__(self):
+        return f"No Registered Handlers Found For '{self.router_name}'"

{argenta-0.4.9 → argenta-0.5.0a0}/argenta/app/models.py

@@ -1,5 +1,6 @@
 from typing import Callable
 from rich.console import Console
+from rich.markup import escape
 from art import text2art
 from contextlib import redirect_stdout
 import io
@@ -8,78 +9,106 @@ import re
 from argenta.command.models import Command, InputCommand
 from argenta.router import Router
 from argenta.router.defaults import system_router
+from argenta.app.autocompleter import AutoCompleter
 from argenta.app.dividing_line.models import StaticDividingLine, DynamicDividingLine
 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:
+class AppInit:
     def __init__(self,
                  prompt: str = '[italic dim bold]What do you want to do?\n',
                  initial_message: str = '\nArgenta\n',
                  farewell_message: str = '\nSee you\n',
-                 exit_command: str = 'Q',
-                 exit_command_description: str = 'Exit command',
-                 system_points_title: str = 'System points:',
+                 exit_command: Command = Command('Q', 'Exit command'),
+                 system_points_title: str | None = 'System points:',
                  ignore_command_register: bool = True,
                  dividing_line: StaticDividingLine | DynamicDividingLine = StaticDividingLine(),
                  repeat_command_groups: bool = True,
                  full_override_system_messages: bool = False,
+                 autocompleter: AutoCompleter = AutoCompleter(),
                  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._dividing_line = dividing_line
         self._ignore_command_register = ignore_command_register
         self._repeat_command_groups_description = repeat_command_groups
         self._full_override_system_messages = full_override_system_messages
+        self._autocompleter = autocompleter
 
-        self.farewell_message = farewell_message
-        self.initial_message = initial_message
+        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._description_message_gen: Callable[[str, str], str] = lambda command, description: f'[bold red]{escape('['+command+']')}[/bold red] [blue dim]*=*=*[/blue dim] [bold yellow italic]{escape(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._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()
 
+class AppSetters(AppInit):
+    def set_description_message_pattern(self, pattern: Callable[[str, str], str]) -> None:
+        self._description_message_gen: Callable[[str, str], str] = pattern
 
-    def _setup_default_view(self):
-        if not self._full_override_system_messages:
-            self.initial_message = f'\n[bold red]{text2art(self.initial_message, font='tarty1')}\n\n'
-            self.farewell_message = (f'[bold red]\n{text2art(f'\n{self.farewell_message}\n', font='chanky')}[/bold red]\n'
-                                     f'[red i]github.com/koloideal/Argenta[/red i] | [red bold i]made by kolo[/red bold i]\n')
 
+    def set_invalid_input_flags_handler(self, handler: Callable[[str], None]) -> None:
+        self._invalid_input_flags_handler = handler
 
-    def _validate_number_of_routers(self) -> None:
-        if not self._registered_routers:
-            raise NoRegisteredRoutersException()
 
+    def set_repeated_input_flags_handler(self, handler: Callable[[str], None]) -> None:
+        self._repeated_input_flags_handler = handler
 
-    def _validate_included_routers(self) -> None:
-        for router in self._registered_routers:
-            if not router.get_command_handlers():
-                raise NoRegisteredHandlersException(router.get_name())
+
+    def set_unknown_command_handler(self, handler: Callable[[str], None]) -> None:
+        self._unknown_command_handler = handler
+
+
+    def set_empty_command_handler(self, handler: Callable[[], None]) -> None:
+        self._empty_input_command_handler = handler
+
+
+    def set_exit_command_handler(self, handler: Callable[[], None]) -> None:
+        self._exit_command_handler = handler
+
+
+class AppPrinters(AppInit):
+    def _print_command_group_description(self):
+        for registered_router in self._registered_routers:
+            if registered_router.get_title():
+                self._print_func(registered_router.get_title())
+            for command_handler in registered_router.get_command_handlers():
+                self._print_func(self._description_message_gen(
+                        command_handler.get_handled_command().get_trigger(),
+                        command_handler.get_handled_command().get_description()))
+            self._print_func('')
+
+
+    def _print_framed_text_with_dynamic_line(self, text: str):
+        clear_text = re.sub(r'\u001b\[[0-9;]*m', '', text)
+        max_length_line = max([len(line) for line in clear_text.split('\n')])
+        max_length_line = max_length_line if 10 <= max_length_line <= 80 else 80 if max_length_line > 80 else 10
+        self._print_func(self._dividing_line.get_full_line(max_length_line))
+        print(text.strip('\n'))
+        self._print_func(self._dividing_line.get_full_line(max_length_line))
 
 
+class AppNonStandardHandlers(AppPrinters):
     def _is_exit_command(self, command: InputCommand):
-        if command.get_trigger().lower() == self._exit_command.lower():
+        if command.get_trigger().lower() == self._exit_command.get_trigger().lower():
             if self._ignore_command_register:
                 system_router.input_command_handler(command)
                 return True
@@ -93,59 +122,82 @@ class BaseApp:
         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()
+                handled_command_aliases = command_handler.get_handled_command().get_aliases()
                 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
+                elif handled_command_aliases:
+                    if command.get_trigger().lower() in [x.lower() for x in handled_command_aliases] and self._ignore_command_register:
+                        return False
+                    elif command.get_trigger() in handled_command_trigger:
+                        return False
         if isinstance(self._dividing_line, StaticDividingLine):
             self._print_func(self._dividing_line.get_full_line())
-            self.unknown_command_handler(command)
+            self._unknown_command_handler(command)
             self._print_func(self._dividing_line.get_full_line())
         elif isinstance(self._dividing_line, DynamicDividingLine):
             with redirect_stdout(io.StringIO()) as f:
-                self.unknown_command_handler(command)
+                self._unknown_command_handler(command)
                 res: str = f.getvalue()
             self._print_framed_text_with_dynamic_line(res)
         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)
+                self._invalid_input_flags_handler(raw_command)
             case RepeatedInputFlagsException():
-                self.repeated_input_flags_handler(raw_command)
+                self._repeated_input_flags_handler(raw_command)
             case EmptyInputCommandException():
-                self.empty_input_command_handler()
+                self._empty_input_command_handler()
 
 
-    def _print_framed_text_with_dynamic_line(self, text: str):
-        clear_text = re.sub(r'\u001b\[[0-9;]*m', '', text)
-        max_length_line = max([len(line) for line in clear_text.split('\n')])
-        max_length_line = max_length_line if 10 <= max_length_line <= 80 else 80 if max_length_line > 80 else 10
-        self._print_func(self._dividing_line.get_full_line(max_length_line))
-        print(text.strip('\n'))
-        self._print_func(self._dividing_line.get_full_line(max_length_line))
+class AppValidators(AppInit):
+    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())
+
+
+class AppSetups(AppValidators, AppPrinters):
+    def _setup_system_router(self):
+        system_router.set_title(self._system_points_title)
 
+        @system_router.command(self._exit_command)
+        def exit_command():
+            self._exit_command_handler()
 
+        if system_router not in self._registered_routers.get_registered_routers():
+            system_router.set_ignore_command_register(self._ignore_command_register)
+            self._registered_routers.add_registered_router(system_router)
 
-class App(BaseApp):
-    def start_polling(self) -> None:
+    def _setup_default_view(self):
+        if not self._full_override_system_messages:
+            self._initial_message = f'\n[bold red]{text2art(self._initial_message, font='tarty1')}\n\n'
+            self._farewell_message = (
+                f'[bold red]\n{text2art(f'\n{self._farewell_message}\n', font='chanky')}[/bold red]\n'
+                f'[red i]github.com/koloideal/Argenta[/red i] | [red bold i]made by kolo[/red bold i]\n')
+
+    def _pre_cycle_setup(self):
+        self._setup_default_view()
         self._setup_system_router()
         self._validate_number_of_routers()
         self._validate_included_routers()
 
-        self._print_func(self.initial_message)
+        all_triggers: list[str] = []
+        for router_entity in self._registered_routers:
+            all_triggers.extend(router_entity.get_triggers())
+            all_triggers.extend(router_entity.get_aliases())
+        self._autocompleter.initial_setup(all_triggers)
+
+        self._print_func(self._initial_message)
 
         for message in self._messages_on_startup:
             self._print_func(message)
@@ -153,6 +205,10 @@ class App(BaseApp):
         if not self._repeat_command_groups_description:
             self._print_command_group_description()
 
+
+class App(AppSetters, AppNonStandardHandlers, AppSetups):
+    def start_polling(self) -> None:
+        self._pre_cycle_setup()
         while True:
             if self._repeat_command_groups_description:
                 self._print_command_group_description()
@@ -174,6 +230,7 @@ class App(BaseApp):
                 continue
 
             if self._is_exit_command(input_command):
+                self._autocompleter.exit_setup()
                 return
 
             if self._is_unknown_command(input_command):
@@ -211,24 +268,3 @@ class App(BaseApp):
     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-0.5.0a0/argenta/command/__init__.py

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

argenta-0.5.0a0/argenta/command/flag/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ('InputFlags', 'InputFlag', 'Flag', 'Flags')
+
+
+from argenta.command.flag.models import InputFlags, InputFlag, Flags, Flag

{argenta-0.4.9 → argenta-0.5.0a0}/argenta/command/models.py

@@ -19,14 +19,19 @@ class BaseCommand:
 class Command(BaseCommand):
     def __init__(self, trigger: str,
                  description: str = None,
-                 flags: Flag | Flags = None):
+                 flags: Flag | Flags = None,
+                 aliases: list[str] = 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
+        self._description = f'Description for "{self._trigger}" command' if not description else description
+        self._aliases = aliases
 
     def get_registered_flags(self) -> Flags:
         return self._registered_flags
 
+    def get_aliases(self) -> list[str] | None:
+        return self._aliases
+
     def validate_input_flag(self, flag: InputFlag):
         registered_flags: Flags | None = self.get_registered_flags()
         if registered_flags:

{argenta-0.4.9 → argenta-0.5.0a0}/argenta/router/command_handler/entity.py

@@ -5,17 +5,17 @@ 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
+        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)
+            self._handler(input_flags)
         else:
-            self.handler()
+            self._handler()
 
     def get_handler(self):
-        return self.handler
+        return self._handler
 
     def get_handled_command(self):
-        return self.handled_command
+        return self._handled_command

{argenta-0.4.9 → argenta-0.5.0a0}/argenta/router/entity.py

@@ -7,15 +7,15 @@ 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)
+                                       TooManyTransferredArgsException,
+                                       RequiredArgumentNotPassedException,
+                                       IncorrectNumberOfHandlerArgsException,
+                                       TriggerCannotContainSpacesException)
 
 
 class Router:
     def __init__(self,
-                 title: str = 'Commands group title:',
+                 title: str = None,
                  name: str = 'Default'):
         self._title = title
         self._name = name
@@ -54,21 +54,29 @@ class Router:
         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().get_flags():
-                    if input_command_flags.get_flags():
-                        if self._validate_input_flags(handle_command, input_command_flags):
-                            command_handler.handling(input_command_flags)
-                            return
-                    else:
-                        command_handler.handling(input_command_flags)
-                        return
-                else:
-                    if input_command_flags.get_flags():
-                        self._not_valid_flag_handler(input_command_flags[0])
-                        return
-                    else:
-                        command_handler.handling()
-                        return
+                self._validate_input_command(input_command_flags, command_handler)
+            elif handle_command.get_aliases():
+                if input_command_name.lower() in handle_command.get_aliases():
+                    self._validate_input_command(input_command_flags, command_handler)
+
+
+    def _validate_input_command(self, input_command_flags: InputFlags, command_handler: CommandHandler):
+        handle_command = command_handler.get_handled_command()
+        if handle_command.get_registered_flags().get_flags():
+            if input_command_flags.get_flags():
+                if self._validate_input_flags(handle_command, input_command_flags):
+                    command_handler.handling(input_command_flags)
+                    return
+            else:
+                command_handler.handling(input_command_flags)
+                return
+        else:
+            if input_command_flags.get_flags():
+                self._not_valid_flag_handler(input_command_flags[0])
+                return
+            else:
+                command_handler.handling()
+                return
 
 
     def _validate_input_flags(self, handle_command: Command, input_flags: InputFlags):
@@ -110,6 +118,21 @@ class Router:
         self._ignore_command_register = ignore_command_register
 
 
+    def get_triggers(self):
+        all_triggers: list[str] = []
+        for command_handler in self._command_handlers:
+            all_triggers.append(command_handler.get_handled_command().get_trigger())
+        return all_triggers
+
+
+    def get_aliases(self):
+        all_aliases: list[str] = []
+        for command_handler in self._command_handlers:
+            if command_handler.get_handled_command().get_aliases():
+                all_aliases.extend(command_handler.get_handled_command().get_aliases())
+        return all_aliases
+
+
     def get_command_handlers(self) -> CommandHandlers:
         return self._command_handlers
 
@@ -118,7 +141,7 @@ class Router:
         return self._name
 
 
-    def get_title(self) -> str:
+    def get_title(self) -> str | None:
         return self._title
 
 

{argenta-0.4.9 → argenta-0.5.0a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "argenta"
-version = "0.4.9"
+version = "0.5.0-alpha"
 description = "Python library for creating TUI"
 authors = [
     {name = "kolo", email = "kolo.is.main@gmail.com"}

argenta-0.4.9/argenta/app/__init__.py

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

argenta-0.4.9/argenta/app/exceptions.py

@@ -1,25 +0,0 @@
-class InvalidRouterInstanceException(Exception):
-    def __str__(self):
-        return "Invalid Router Instance"
-
-
-class InvalidDescriptionMessagePatternException(Exception):
-    def __init__(self, pattern: str):
-        self.pattern = pattern
-    def __str__(self):
-        return ("Invalid Description Message Pattern\n"
-                "Correct pattern example: [{command}] *=*=* {description}\n"
-                "The pattern must contain two variables: `command` and `description` - description of the command\n"
-                f"Your pattern: {self.pattern}")
-
-
-class NoRegisteredRoutersException(Exception):
-    def __str__(self):
-        return "No Registered Router Found"
-
-
-class NoRegisteredHandlersException(Exception):
-    def __init__(self, router_name):
-        self.router_name = router_name
-    def __str__(self):
-        return f"No Registered Handlers Found For '{self.router_name}'"

argenta-0.4.9/argenta/command/__init__.py

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

argenta-0.4.9/argenta/command/flag/__init__.py

@@ -1,4 +0,0 @@
-__all__ = ('InputFlags', 'InputFlag', 'Flag', 'Flags')
-
-
-from .models import InputFlags, InputFlag, Flags, Flag