fix

.github/workflows/ruff.yml

@@ -0,0 +1,30 @@
+name: ruff
+
+on:
+  push:
+    branches: [ "kolo" ]
+  pull_request:
+    branches: [ "kolo" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - uses: actions/setup-python@v3
+      with:
+        python-version: "3.13"
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install ruff
+
+    - name: Run linter
+      run: ruff check ./argenta

.github/workflows/tests.yml

@@ -0,0 +1,31 @@
+name: tests
+
+on:
+  push:
+    branches: [ "kolo" ]
+  pull_request:
+    branches: [ "kolo" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - uses: actions/setup-python@v3
+      with:
+        python-version: "3.13"
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install poetry
+        poetry install
+
+    - name: Run tests
+      run: poetry run python -m unittest discover

.gitignore

@@ -1,6 +1,9 @@
 .venv
 .idea
-argenta/router/__pycache__/
-argenta/app/__pycache__/
-argenta/__pycache__/
 dist
+uv.lock
+*__pycache__/
+*.hist*
+build
+source
+

argenta/__init__.py

@@ -1,2 +0,0 @@
-from .router import *
-from .app import *

argenta/app/entity.py

@@ -1,145 +0,0 @@
-from typing import Callable
-from ..router.entity import Router
-from .exceptions import (InvalidRouterInstanceException,
-                         InvalidDescriptionMessagePatternException,
-                         OnlyOneMainRouterIsAllowedException,
-                         MissingMainRouterException,
-                         MissingHandlersForUnknownCommandsOnMainRouterException,
-                         HandlerForUnknownCommandsCanOnlyBeDeclaredForMainRouterException)
-
-
-class App:
-    def __init__(self,
-                 prompt: str = 'Enter a command',
-                 exit_command: str = 'q',
-                 ignore_exit_command_register: bool = True,
-                 initial_greeting: str = 'Hello',
-                 goodbye_message: str = 'GoodBye',
-                 line_separate: str = '\n',
-                 command_group_description_separate: str = '\n',
-                 print_func: Callable[[str], None] = print) -> None:
-        self.prompt = prompt
-        self.print_func = print_func
-        self.exit_command = exit_command
-        self.ignore_exit_command_register = ignore_exit_command_register
-        self.goodbye_message = goodbye_message
-        self.initial_greeting = initial_greeting
-        self.line_separate = line_separate
-        self.command_group_description_separate = command_group_description_separate
-
-        self.routers: list[Router] = []
-        self.registered_commands: list[dict[str, str | list[dict[str, Callable[[], None] | str]] | Router]] = []
-        self.main_app_router: Router | None = None
-        self._description_message_pattern = '[{command}] *=*=* {description}'
-
-
-    def start_polling(self) -> None:
-        self.print_func(self.initial_greeting)
-        self.validate_main_router()
-
-        while True:
-            self.print_command_group_description()
-            self.print_func(self.prompt)
-
-            command: str = input()
-
-            self.checking_command_for_exit_command(command)
-            self.print_func(self.line_separate)
-
-            is_unknown_command: bool = self.check_is_command_unknown(command)
-
-            if is_unknown_command:
-                continue
-
-            for router in self.routers:
-                router.input_command_handler(command)
-            self.print_func(self.line_separate)
-            self.print_func(self.command_group_description_separate)
-
-
-    def set_initial_greeting(self, greeting: str) -> None:
-        self.initial_greeting = greeting
-
-
-    def set_goodbye_message(self, message: str) -> None:
-        self.goodbye_message = message
-
-
-    def set_description_message_pattern(self, pattern: str) -> None:
-        try:
-            pattern.format(command='command',
-                           description='description')
-        except KeyError:
-            raise InvalidDescriptionMessagePatternException(pattern)
-        self._description_message_pattern = pattern
-
-
-    def validate_main_router(self):
-        if not self.main_app_router:
-            raise MissingMainRouterException()
-
-        if not self.main_app_router.unknown_command_func:
-            raise MissingHandlersForUnknownCommandsOnMainRouterException()
-
-        for router in self.routers:
-            if router.unknown_command_func and self.main_app_router is not router:
-                raise HandlerForUnknownCommandsCanOnlyBeDeclaredForMainRouterException()
-
-
-    def checking_command_for_exit_command(self, command: str):
-        if command.lower() == self.exit_command.lower():
-            if self.ignore_exit_command_register:
-                self.print_func(self.goodbye_message)
-                exit(0)
-            else:
-                if command == self.exit_command:
-                    self.print_func(self.goodbye_message)
-                    exit(0)
-
-
-    def check_is_command_unknown(self, command: str):
-        registered_commands = self.registered_commands
-        for router in registered_commands:
-            for command_entity in router['commands']:
-                if command_entity['command'].lower() == command.lower():
-                    if router['router'].ignore_command_register:
-                        return False
-                    else:
-                        if command_entity['command'] == command:
-                            return False
-        self.main_app_router.unknown_command_handler(command)
-        self.print_func(self.line_separate)
-        self.print_func(self.command_group_description_separate)
-        return True
-
-
-    def print_command_group_description(self):
-        for router in self.registered_commands:
-            self.print_func(router['name'])
-            for command_entity in router['commands']:
-                self.print_func(self._description_message_pattern.format(
-                        command=command_entity['command'],
-                        description=command_entity['description']
-                    )
-                )
-            self.print_func(self.command_group_description_separate)
-
-
-    def include_router(self, router: Router, is_main: bool = False) -> None:
-        if not isinstance(router, Router):
-            raise InvalidRouterInstanceException()
-
-        if is_main:
-            if not self.main_app_router:
-                self.main_app_router = router
-                router.set_router_as_main()
-            else:
-                raise OnlyOneMainRouterIsAllowedException(router)
-
-        self.routers.append(router)
-
-        registered_commands: list[dict[str, Callable[[], None] | str]] = router.get_registered_commands()
-        self.registered_commands.append({'name': router.get_name(),
-                                         'router': router,
-                                         'commands': registered_commands})
-

argenta/app/exceptions.py

@@ -1,39 +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 OnlyOneMainRouterIsAllowedException(Exception):
-    def __init__(self, existing_main_router):
-        self.existing_main_router = existing_main_router
-
-    def __str__(self):
-        return ("Only One Main Router Allowed\n"
-                f"Existing main router is: {self.existing_main_router}")
-
-
-class MissingMainRouterException(Exception):
-    def __str__(self):
-        return ("Missing Main Router\n"
-                "One of the registered routers must be the main one")
-
-
-class MissingHandlersForUnknownCommandsOnMainRouterException(Exception):
-    def __str__(self):
-        return ("Missing Handlers For Unknown Commands On The Main Router\n"
-                "The main router must have a declared handler for unknown commands")
-
-
-class HandlerForUnknownCommandsCanOnlyBeDeclaredForMainRouterException(Exception):
-    def __str__(self):
-        return '\nThe handler for unknown commands can only be declared for the main router'

argenta/router/entity.py

@@ -1,70 +0,0 @@
-from typing import Callable, Any
-from ..router.exceptions import (InvalidCommandInstanceException,
-                                 UnknownCommandHandlerHasAlreadyBeenCreatedException,
-                                 InvalidDescriptionInstanceException)
-
-
-class Router:
-    def __init__(self,
-                 name: str,
-                 ignore_command_register: bool = False):
-
-        self.ignore_command_register: bool = ignore_command_register
-        self._name = name
-
-        self.processed_commands: list[dict[str, Callable[[], None] | str]] = []
-        self.unknown_command_func: Callable[[str], None] | None = None
-        self._is_main_router: bool = False
-
-
-    def command(self, command: str, description: str) -> Callable[[Any], Any]:
-        if not isinstance(command, str):
-            raise InvalidCommandInstanceException()
-        if not isinstance(description, str):
-            raise InvalidDescriptionInstanceException()
-        else:
-            def command_decorator(func):
-                self.processed_commands.append({'func': func,
-                                                'command': command,
-                                                'description': description})
-                def wrapper(*args, **kwargs):
-                    return func(*args, **kwargs)
-                return wrapper
-            return command_decorator
-
-
-    def unknown_command(self, func):
-        if self.unknown_command_func is not None:
-            raise UnknownCommandHandlerHasAlreadyBeenCreatedException()
-
-        self.unknown_command_func = func
-
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-        return wrapper
-
-
-    def input_command_handler(self, input_command):
-        for command_entity in self.processed_commands:
-            if input_command.lower() == command_entity['command'].lower():
-                if self.ignore_command_register:
-                    return command_entity['func']()
-                else:
-                    if input_command == command_entity['command']:
-                        return command_entity['func']()
-
-    def unknown_command_handler(self, unknown_command):
-        self.unknown_command_func(unknown_command)
-
-
-    def set_router_as_main(self):
-        self._is_main_router = True
-
-
-    def get_registered_commands(self) -> list[dict[str, Callable[[], None] | str]]:
-        return self.processed_commands
-
-
-    def get_name(self) -> str:
-        return self._name
-

argenta/router/exceptions.py

@@ -1,13 +0,0 @@
-class InvalidCommandInstanceException(Exception):
-    def __str__(self):
-        return "Invalid Command Instance"
-
-
-class InvalidDescriptionInstanceException(Exception):
-    def __str__(self):
-        return "Invalid Description Instance"
-
-
-class UnknownCommandHandlerHasAlreadyBeenCreatedException(Exception):
-    def __str__(self):
-        return "Only one unknown command handler can be declared"

mock/default_mock_app/main.py

@@ -0,0 +1,7 @@
+from argenta.app import App
+from argenta.orchestrator import Orchestrator
+
+app = App(repeat_command_groups=True)
+
+orchestrator = Orchestrator()
+orchestrator.start_polling(app)

mock/local_test.py

@@ -0,0 +1,6 @@
+from argenta.app import App
+from argenta.command.models import InputCommand
+
+app = App()
+app._all_registered_triggers_in_lower = ['fr', 'Tre', 'Pre']
+print(app._is_unknown_command(InputCommand('fr')))

mock/mock_app/handlers/handlers_implementation/help_command.py

@@ -0,0 +1,10 @@
+from rich.console import Console
+
+
+console = Console()
+
+
+def help_command():
+    console.print("[italic bold]The main functionality of the script is to convert an expression from a string "
+                  "to a mathematical one and then calculate this expression. "
+                  "Project GitHub: https://github.com/koloideal/WordMath[/italic bold]")

mock/mock_app/handlers/routers.py

@@ -0,0 +1,22 @@
+from rich.console import Console
+
+from argenta.command import Command
+from argenta.router import Router
+
+
+work_router: Router = Router(title='Work points:')
+
+console = Console()
+
+
+@work_router.command(Command('get', 'Get Help', aliases=['help', 'Get_help']))
+def command_help():
+    pass
+
+
+@work_router.command(Command('run', 'Run All'))
+def command_start_solving():
+    pass
+
+
+

mock/mock_app/main.py

@@ -0,0 +1,28 @@
+from mock.mock_app.handlers.routers import work_router
+
+from argenta.app import App
+from argenta.app.defaults import PredefinedMessages
+from argenta.app.dividing_line import DynamicDividingLine
+from argenta.app.autocompleter import AutoCompleter
+from argenta.orchestrator import Orchestrator
+from argenta.orchestrator.argparser import ArgParser
+from argenta.orchestrator.argparser.arguments import BooleanArgument
+
+
+arg_parser = ArgParser(processed_args=[BooleanArgument('repeat')])
+app: App = App(dividing_line=DynamicDividingLine(),
+               autocompleter=AutoCompleter('./mock/.hist'))
+orchestrator: Orchestrator = Orchestrator(arg_parser)
+
+
+def main():
+    app.include_router(work_router)
+
+    app.add_message_on_startup(PredefinedMessages.USAGE)
+    app.add_message_on_startup(PredefinedMessages.AUTOCOMPLETE)
+    app.add_message_on_startup(PredefinedMessages.HELP)
+
+    orchestrator.start_polling(app)
+
+if __name__ == "__main__":
+    main()

poetry.lock

@@ -1,7 +0,0 @@
-# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
-package = []
-
-[metadata]
-lock-version = "2.1"
-python-versions = ">=3.11"
-content-hash = "f5666f5625d676c506924a57dc0520a1f3ed2b2c774baed3dc85353594f8473d"

pyproject.toml

@@ -1,17 +1,33 @@
 [project]
 name = "argenta"
-version = "0.1.1"
+version = "1.0.0-alpha4"
-description = "python library for creating cli apps"
+description = "Python library for creating TUI"
-authors = [
+authors = [{ name = "kolo", email = "kolo.is.main@gmail.com" }]
-    {name = "kolo",email = "kolo.is.main@gmail.com"}
+requires-python = ">=3.11, <4.0"
-]
-license = {text = "MIT"}
 readme = "README.md"
-requires-python = ">=3.11"
+license = { text = "MIT" }
 dependencies = [
+    "rich (>=14.0.0,<15.0.0)",
+    "art (>=6.4,<7.0)",
+    "pyreadline3 (>=3.5.4,<4.0.0)",
 ]
 
+[dependency-groups]
+dev = [
+    "pydoc-markdown>=4.8.2,<5",
+]
+
+[tool.ruff]
+exclude = [
+    ".idea",
+    "venv",
+    ".git",
+    "poetry.lock",
+    ".__pycache__",
+    "tests"
+    ]
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
+requires = ["hatchling"]
-build-backend = "poetry.core.masonry.api"
+build-backend = "hatchling.build"
+

setup.py

@@ -1,23 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="argenta",
-    version="0.1.1",
-    author="kolo",
-    author_email="kolo.is.main@gmail.com",
-    description="Python library for creating CLI apps",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    packages=find_packages(),
-    install_requires=[
-        "requests",
-    ],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "Operating System :: OS Independent",
-    ],
-    python_requires='>=3.11',
-)

src/argenta/app/__init__.py

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

src/argenta/app/autocompleter/__init__.py

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

src/argenta/app/autocompleter/entity.py

@@ -0,0 +1,72 @@
+import os
+import readline
+
+
+class AutoCompleter:
+    def __init__(self, history_filename: str = False, autocomplete_button: str = 'tab') -> None:
+        """
+        Public. Configures and implements auto-completion of input command
+        :param history_filename: the name of the file for saving the history of the autocompleter
+        :param autocomplete_button: the button for auto-completion
+        :return: None
+        """
+        self.history_filename = history_filename
+        self.autocomplete_button = autocomplete_button
+        self.matches: list[str] = []
+
+    def _complete(self, text, state) -> str | None:
+        """
+        Private. Auto-completion function
+        :param text: part of the command being entered
+        :param state: the current cursor position is relative to the beginning of the line
+        :return: the desired candidate as str or None
+        """
+        matches: list[str] = 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]) -> None:
+        """
+        Private. Initial setup function
+        :param all_commands: Registered commands for adding them to the autocomplete history
+        :return: None
+        """
+        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) -> None:
+        """
+        Private. Exit setup function
+        :return: None
+        """
+        if self.history_filename:
+            readline.write_history_file(self.history_filename)
+
+    @staticmethod
+    def get_history_items() -> list[str] | list:
+        """
+        Private. Returns a list of all commands entered by the user
+        :return: all commands entered by the user as list[str]
+        """
+        return [readline.get_history_item(i) for i in range(1, readline.get_current_history_length() + 1)]

src/argenta/app/defaults.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PredefinedMessages:
+    """
+    Public. A dataclass with predetermined messages for quick use
+    """
+    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>'
+

src/argenta/app/dividing_line/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["StaticDividingLine", "DynamicDividingLine"]
+
+
+from argenta.app.dividing_line.models import StaticDividingLine, DynamicDividingLine

src/argenta/app/dividing_line/models.py

@@ -0,0 +1,68 @@
+from abc import ABC
+
+
+class BaseDividingLine(ABC):
+    def __init__(self, unit_part: str = '-') -> None:
+        """
+        Private. The basic dividing line
+        :param unit_part: the single part of the dividing line
+        :return: None
+        """
+        self._unit_part = unit_part
+
+    def get_unit_part(self) -> str:
+        """
+        Private. Returns the unit part of the dividing line
+        :return: unit_part of dividing line as str
+        """
+        if len(self._unit_part) == 0:
+            return ' '
+        else:
+            return self._unit_part[0]
+
+
+class StaticDividingLine(BaseDividingLine):
+    def __init__(self, unit_part: str = '-', length: int = 25) -> None:
+        """
+        Public. The static dividing line
+        :param unit_part: the single part of the dividing line
+        :param length: the length of the dividing line
+        :return: None
+        """
+        super().__init__(unit_part)
+        self.length = length
+
+    def get_full_static_line(self, is_override: bool) -> str:
+        """
+        Private. Returns the full line of the dividing line
+        :param is_override: has the default text layout been redefined
+        :return: full line of dividing line as str
+        """
+        if is_override:
+            return f'\n{self.length * self.get_unit_part()}\n'
+        else:
+            return f'\n[dim]{self.length * self.get_unit_part()}[/dim]\n'
+
+
+class DynamicDividingLine(BaseDividingLine):
+    def __init__(self, unit_part: str = '-') -> None:
+        """
+        Public. The dynamic dividing line
+        :param unit_part: the single part of the dividing line
+        :return: None
+        """
+        super().__init__(unit_part)
+
+    def get_full_dynamic_line(self, length: int, is_override: bool) -> str:
+        """
+        Private. Returns the full line of the dividing line
+        :param length: the length of the dividing line
+        :param is_override: has the default text layout been redefined
+        :return: full line of dividing line as str
+        """
+        if is_override:
+            return f'\n{length * self.get_unit_part()}\n'
+        else:
+            return f'\n[dim]{self.get_unit_part() * length}[/dim]\n'
+
+

src/argenta/app/models.py

@@ -0,0 +1,380 @@
+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
+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.registered_routers.entity import RegisteredRouters
+
+
+
+class BaseApp:
+    def __init__(self,
+                 prompt: str,
+                 initial_message: str,
+                 farewell_message: str,
+                 exit_command: Command,
+                 system_router_title: str | None,
+                 ignore_command_register: bool,
+                 dividing_line: StaticDividingLine | DynamicDividingLine,
+                 repeat_command_groups: bool,
+                 override_system_messages: bool,
+                 autocompleter: AutoCompleter,
+                 print_func: Callable[[str], None]) -> None:
+
+        self._prompt = prompt
+        self._print_func = print_func
+        self._exit_command = exit_command
+        self._system_router_title = system_router_title
+        self._dividing_line = dividing_line
+        self._ignore_command_register = ignore_command_register
+        self._repeat_command_groups_description = repeat_command_groups
+        self._override_system_messages = override_system_messages
+        self._autocompleter = autocompleter
+
+        self._farewell_message = farewell_message
+        self._initial_message = initial_message
+
+
+        self._description_message_gen: Callable[[str, str], str] = lambda command, description: f'[{command}] *=*=* {description}'
+        self._registered_routers: RegisteredRouters = RegisteredRouters()
+        self._messages_on_startup: list[str] = []
+
+        self._all_registered_triggers_in_lower: list[str] = []
+        self._all_registered_triggers_in_default_case: list[str] = []
+
+        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('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)
+
+
+    def set_description_message_pattern(self, _: Callable[[str, str], str]) -> None:
+        """
+        Public. Sets the output pattern of the available commands
+        :param _: output pattern of the available commands
+        :return: None
+        """
+        self._description_message_gen: Callable[[str, str], str] = _
+
+
+    def set_invalid_input_flags_handler(self, _: Callable[[str], None]) -> None:
+        """
+        Public. Sets the handler for incorrect flags when entering a command
+        :param _: handler for incorrect flags when entering a command
+        :return: None
+        """
+        self._invalid_input_flags_handler = _
+
+
+    def set_repeated_input_flags_handler(self, _: Callable[[str], None]) -> None:
+        """
+        Public. Sets the handler for repeated flags when entering a command
+        :param _: handler for repeated flags when entering a command
+        :return: None
+        """
+        self._repeated_input_flags_handler = _
+
+
+    def set_unknown_command_handler(self, _: Callable[[str], None]) -> None:
+        """
+        Public. Sets the handler for unknown commands when entering a command
+        :param _: handler for unknown commands when entering a command
+        :return: None
+        """
+        self._unknown_command_handler = _
+
+
+    def set_empty_command_handler(self, _: Callable[[], None]) -> None:
+        """
+        Public. Sets the handler for empty commands when entering a command
+        :param _: handler for empty commands when entering a command
+        :return: None
+        """
+        self._empty_input_command_handler = _
+
+
+    def set_exit_command_handler(self, _: Callable[[], None]) -> None:
+        """
+        Public. Sets the handler for exit command when entering a command
+        :param _: handler for exit command when entering a command
+        :return: None
+        """
+        self._exit_command_handler = _
+
+
+    def _print_command_group_description(self) -> None:
+        """
+        Private. Prints the description of the available commands
+        :return: None
+        """
+        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(self, text: str) -> None:
+        """
+        Private. Outputs text by framing it in a static or dynamic split strip
+        :param text: framed text
+        :return: None
+        """
+        if isinstance(self._dividing_line, StaticDividingLine):
+            self._print_func(self._dividing_line.get_full_static_line(self._override_system_messages))
+            self._print_func(text)
+            self._print_func(self._dividing_line.get_full_static_line(self._override_system_messages))
+
+        elif isinstance(self._dividing_line, DynamicDividingLine):
+            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_dynamic_line(max_length_line, self._override_system_messages))
+            print(text.strip('\n'))
+            self._print_func(self._dividing_line.get_full_dynamic_line(max_length_line, self._override_system_messages))
+
+
+    def _is_exit_command(self, command: InputCommand) -> bool:
+        """
+        Private. Checks if the given command is an exit command
+        :param command: command to check
+        :return: is it an exit command or not as bool
+        """
+        if self._ignore_command_register:
+            if command.get_trigger().lower() == self._exit_command.get_trigger().lower():
+                return True
+            elif command.get_trigger().lower() in [x.lower() for x in self._exit_command.get_aliases()]:
+                return True
+        else:
+            if command.get_trigger() == self._exit_command.get_trigger():
+                return True
+            elif command.get_trigger() in self._exit_command.get_aliases():
+                return True
+        return False
+
+
+    def _is_unknown_command(self, command: InputCommand) -> bool:
+        """
+        Private. Checks if the given command is an unknown command
+        :param command: command to check
+        :return: is it an unknown command or not as bool
+        """
+        input_command_trigger = command.get_trigger()
+        if self._ignore_command_register:
+            if input_command_trigger.lower() in self._all_registered_triggers_in_lower:
+                return False
+        else:
+            if input_command_trigger in self._all_registered_triggers_in_default_case:
+                return False
+        return True
+
+
+    def _error_handler(self, error: BaseInputCommandException, raw_command: str) -> None:
+        """
+        Private. Handles parsing errors of the entered command
+        :param error: error being handled
+        :param raw_command: the raw input command
+        :return: 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()
+
+
+    def _setup_system_router(self) -> None:
+        """
+        Private. Sets up system router
+        :return: None
+        """
+        system_router.set_title(self._system_router_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_command_register_ignore(self._ignore_command_register)
+            self._registered_routers.add_registered_router(system_router)
+
+
+    def _setup_default_view(self) -> None:
+        """
+        Private. Sets up default app view
+        :return: None
+        """
+        if not self._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')
+            self._description_message_gen = lambda command, description: (f'[bold red]{escape("[" + command + "]")}[/bold red] '
+                                                                          f'[blue dim]*=*=*[/blue dim] '
+                                                                          f'[bold yellow italic]{escape(description)}')
+            self._invalid_input_flags_handler = lambda raw_command: self._print_func(f'[red bold]Incorrect flag syntax: {escape(raw_command)}')
+            self._repeated_input_flags_handler = lambda raw_command: self._print_func(f'[red bold]Repeated input flags: {escape(raw_command)}')
+            self._empty_input_command_handler = lambda: self._print_func('[red bold]Empty input command')
+            self._unknown_command_handler = lambda command: self._print_func(f"[red bold]Unknown command: {escape(command.get_trigger())}")
+
+
+    def _pre_cycle_setup(self) -> None:
+        """
+        Private. Configures various aspects of the application before the start of the cycle
+        :return: None
+        """
+        self._setup_default_view()
+        self._setup_system_router()
+
+        for router_entity in self._registered_routers:
+            self._all_registered_triggers_in_default_case.extend(router_entity.get_triggers())
+            self._all_registered_triggers_in_default_case.extend(router_entity.get_aliases())
+
+            self._all_registered_triggers_in_lower.extend([x.lower() for x in router_entity.get_triggers()])
+            self._all_registered_triggers_in_lower.extend([x.lower() for x in router_entity.get_aliases()])
+
+        self._autocompleter.initial_setup(self._all_registered_triggers_in_lower)
+
+        self._print_func(self._initial_message)
+
+        for message in self._messages_on_startup:
+            self._print_func(message)
+        if self._messages_on_startup:
+            print('\n\n')
+
+        if not self._repeat_command_groups_description:
+            self._print_command_group_description()
+
+
+
+class App(BaseApp):
+    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: Command = Command('Q', 'Exit command'),
+                 system_router_title: str | None = 'System points:',
+                 ignore_command_register: bool = True,
+                 dividing_line: StaticDividingLine | DynamicDividingLine = StaticDividingLine(),
+                 repeat_command_groups: bool = True,
+                 override_system_messages: bool = False,
+                 autocompleter: AutoCompleter = AutoCompleter(),
+                 print_func: Callable[[str], None] = Console().print) -> None:
+        """
+        Public. The essence of the application itself.
+        Configures and manages all aspects of the behavior and presentation of the user interacting with the user
+        :param prompt: displayed before entering the command
+        :param initial_message: displayed at the start of the app
+        :param farewell_message: displayed at the end of the app
+        :param exit_command: the entity of the command that will be terminated when entered
+        :param system_router_title: system router title
+        :param ignore_command_register: whether to ignore the case of the entered commands
+        :param dividing_line: the entity of the dividing line
+        :param repeat_command_groups: whether to repeat the available commands and their description
+        :param override_system_messages: whether to redefine the default formatting of system messages
+        :param autocompleter: the entity of the autocompleter
+        :param print_func: system messages text output function
+        :return: None
+        """
+        super().__init__(prompt=prompt,
+                         initial_message=initial_message,
+                         farewell_message=farewell_message,
+                         exit_command=exit_command,
+                         system_router_title=system_router_title,
+                         ignore_command_register=ignore_command_register,
+                         dividing_line=dividing_line,
+                         repeat_command_groups=repeat_command_groups,
+                         override_system_messages=override_system_messages,
+                         autocompleter=autocompleter,
+                         print_func=print_func)
+
+
+    def run_polling(self) -> None:
+        """
+        Private. Starts the user input processing cycle
+        :return: None
+        """
+        self._pre_cycle_setup()
+        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:
+                with redirect_stdout(io.StringIO()) as f:
+                    self._error_handler(error, raw_command)
+                    res: str = f.getvalue()
+                self._print_framed_text(res)
+                continue
+
+            if self._is_exit_command(input_command):
+                system_router.finds_appropriate_handler(input_command)
+                self._autocompleter.exit_setup()
+                return
+
+            if self._is_unknown_command(input_command):
+                with redirect_stdout(io.StringIO()) as f:
+                    self._unknown_command_handler(input_command)
+                    res: str = f.getvalue()
+                self._print_framed_text(res)
+                continue
+
+            with redirect_stdout(io.StringIO()) as f:
+                for registered_router in self._registered_routers:
+                    registered_router.finds_appropriate_handler(input_command)
+                res: str = f.getvalue()
+            self._print_framed_text(res)
+
+            if not self._repeat_command_groups_description:
+                self._print_func(self._prompt)
+
+
+    def include_router(self, router: Router) -> None:
+        """
+        Public. Registers the router in the application
+        :param router: registered router
+        :return: None
+        """
+        router.set_command_register_ignore(self._ignore_command_register)
+        self._registered_routers.add_registered_router(router)
+
+
+    def include_routers(self, *routers: Router) -> None:
+        """
+        Public. Registers the routers in the application
+        :param routers: registered routers
+        :return: None
+        """
+        for router in routers:
+            self.include_router(router)
+
+
+    def add_message_on_startup(self, message: str) -> None:
+        """
+        Public. Adds a message that will be displayed when the application is launched
+        :param message: the message being added
+        :return: None
+        """
+        self._messages_on_startup.append(message)
+

src/argenta/app/registered_routers/entity.py

@@ -0,0 +1,34 @@
+from typing import Iterator
+
+from argenta.router import Router
+
+
+class RegisteredRouters:
+    def __init__(self, registered_routers: list[Router] = None) -> None:
+        """
+        Private. Combines registered routers
+        :param registered_routers: list of the registered routers
+        :return: None
+        """
+        self._registered_routers = registered_routers if registered_routers else []
+
+    def get_registered_routers(self) -> list[Router]:
+        """
+        Private. Returns the registered routers
+        :return: registered routers as list[Router]
+        """
+        return self._registered_routers
+
+    def add_registered_router(self, router: Router) -> None:
+        """
+        Private. Adds a new registered router
+        :param router: registered router
+        :return: None
+        """
+        self._registered_routers.append(router)
+
+    def __iter__(self) -> Iterator[Router]:
+        return iter(self._registered_routers)
+
+    def __next__(self) -> Router:
+        return next(iter(self._registered_routers))

src/argenta/command/__init__.py

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

src/argenta/command/exceptions.py

@@ -0,0 +1,35 @@
+from argenta.command.flag.models import InputFlag, Flag
+
+
+class BaseInputCommandException(Exception):
+    """
+    Private. Base exception class for all exceptions raised when parse input command
+    """
+    pass
+
+
+class UnprocessedInputFlagException(BaseInputCommandException):
+    """
+    Private. Raised when an unprocessed input flag is detected
+    """
+    def __str__(self):
+        return "Unprocessed Input Flags"
+
+
+class RepeatedInputFlagsException(BaseInputCommandException):
+    """
+    Private. Raised when repeated input flags are detected
+    """
+    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(BaseInputCommandException):
+    """
+    Private. Raised when an empty input command is detected
+    """
+    def __str__(self):
+        return "Input Command is empty"

src/argenta/command/flag/__init__.py

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

src/argenta/command/flag/defaults.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from argenta.command.flag.models import Flag
+import re
+
+
+@dataclass
+class PredefinedFlags:
+    """
+    Public. A dataclass with predefined flags and most frequently used flags for quick use
+    """
+    HELP = Flag(name='help', possible_values=False)
+    SHORT_HELP = Flag(name='H', prefix='-', possible_values=False)
+
+    INFO = Flag(name='info', possible_values=False)
+    SHORT_INFO = Flag(name='I', prefix='-', possible_values=False)
+
+    ALL = Flag(name='all', possible_values=False)
+    SHORT_ALL = Flag(name='A', prefix='-', possible_values=False)
+
+    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(name='port', possible_values=re.compile(r'^\d{1,5}$'))
+    SHORT_PORT = Flag(name='P', prefix='-', possible_values=re.compile(r'^\d{1,5}$'))

src/argenta/command/flag/models.py

@@ -0,0 +1,218 @@
+from typing import Literal, Pattern
+from abc import ABC, abstractmethod
+
+
+class BaseFlag(ABC):
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--') -> None:
+        """
+        Private. Base class for flags
+        :param name: the name of the flag
+        :param prefix: the prefix of the flag
+        :return: None
+        """
+        self._name = name
+        self._prefix = prefix
+
+    def get_string_entity(self) -> str:
+        """
+        Public. Returns a string representation of the flag
+        :return: string representation of the flag as str
+        """
+        string_entity: str = self._prefix + self._name
+        return string_entity
+
+    def get_name(self) -> str:
+        """
+        Public. Returns the name of the flag
+        :return: the name of the flag as str
+        """
+        return self._name
+
+    def get_prefix(self) -> str:
+        """
+        Public. Returns the prefix of the flag
+        :return: the prefix of the flag as str
+        """
+        return self._prefix
+
+
+
+class InputFlag(BaseFlag):
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--',
+                 value: str = None):
+        """
+        Public. The entity of the flag of the entered command
+        :param name: the name of the input flag
+        :param prefix: the prefix of the input flag
+        :param value: the value of the input flag
+        :return: None
+        """
+        super().__init__(name, prefix)
+        self._flag_value = value
+
+    def get_value(self) -> str | None:
+        """
+        Public. Returns the value of the flag
+        :return: the value of the flag as str
+        """
+        return self._flag_value
+
+    def set_value(self, value):
+        """
+        Private. Sets the value of the flag
+        :param value: the fag value to set
+        :return: None
+        """
+        self._flag_value = value
+
+
+
+class Flag(BaseFlag):
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--',
+                 possible_values: list[str] | Pattern[str] | False = True) -> None:
+        """
+        Public. The entity of the flag being registered for subsequent processing
+        :param name: The name of the flag
+        :param prefix: The prefix of the flag
+        :param possible_values: The possible values of the flag, if False then the flag cannot have a value
+        :return: None
+        """
+        super().__init__(name, prefix)
+        self.possible_values = possible_values
+
+    def validate_input_flag_value(self, input_flag_value: str | None):
+        """
+        Private. Validates the input flag value
+        :param input_flag_value: The input flag value to validate
+        :return: whether the entered flag is valid as bool
+        """
+        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):
+    """
+    Private. Base class for groups of flags
+    """
+    __slots__ = ('_flags',)
+
+    @abstractmethod
+    def get_flags(self):
+        """
+        Public. Returns a list of flags
+        :return: list of flags
+        """
+        pass
+
+    @abstractmethod
+    def add_flag(self, flag: Flag | InputFlag):
+        """
+        Public. Adds a flag to the list of flags
+        :param flag: flag to add
+        :return: None
+        """
+        pass
+
+    @abstractmethod
+    def add_flags(self, flags: list[Flag] | list[InputFlag]):
+        """
+        Public. Adds a list of flags to the list of flags
+        :param flags: list of flags to add
+        :return: None
+        """
+        pass
+
+    @abstractmethod
+    def get_flag(self, name: str):
+        """
+        Public. Returns the flag entity by its name or None if not found
+        :param name: the name of the flag to get
+        :return: entity of the flag or None
+        """
+        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):
+        """
+        Public. A model that combines the registered flags
+        :param flags: the flags that will be registered
+        :return: None
+        """
+        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):
+        """
+        Public. A model that combines the input flags of the input command
+        :param flags: all input flags
+        :return: None
+        """
+        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
+

src/argenta/command/models.py

@@ -0,0 +1,164 @@
+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) -> None:
+        """
+        Private. Base class for all commands
+        :param trigger: A string trigger, which, when entered by the user, indicates that the input corresponds to the command
+        """
+        self._trigger = trigger
+
+    def get_trigger(self) -> str:
+        """
+        Public. Returns the trigger of the command
+        :return: the trigger of the command as str
+        """
+        return self._trigger
+
+
+class Command(BaseCommand):
+    def __init__(self, trigger: str,
+                 description: str = None,
+                 flags: Flag | Flags = None,
+                 aliases: list[str] = None):
+        """
+        Public. The command that can and should be registered in the Router
+        :param trigger: A string trigger, which, when entered by the user, indicates that the input corresponds to the command
+        :param description: the description of the command
+        :param flags: processed commands
+        :param aliases: string synonyms for the main trigger
+        """
+        super().__init__(trigger)
+        self._registered_flags: Flags = flags if isinstance(flags, Flags) else Flags(flags) if isinstance(flags, Flag) else Flags()
+        self._description = f'Description for "{self._trigger}" command' if not description else description
+        self._aliases = aliases if isinstance(aliases, list) else []
+
+    def get_registered_flags(self) -> Flags:
+        """
+        Private. Returns the registered flags
+        :return: the registered flags as Flags
+        """
+        return self._registered_flags
+
+    def get_aliases(self) -> list[str] | list:
+        """
+        Public. Returns the aliases of the command
+        :return: the aliases of the command as list[str] | list
+        """
+        return self._aliases
+
+    def validate_input_flag(self, flag: InputFlag) -> bool:
+        """
+        Private. Validates the input flag
+        :param flag: input flag for validation
+        :return: is input flag valid as bool
+        """
+        registered_flags: Flags | None = self.get_registered_flags()
+        if registered_flags:
+            if isinstance(registered_flags, Flag):
+                if registered_flags.get_string_entity() == flag.get_string_entity():
+                    is_valid = registered_flags.validate_input_flag_value(flag.get_value())
+                    if is_valid:
+                        return 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:
+        """
+        Private. Returns the description of the command
+        :return: the description of the command as str
+        """
+        return self._description
+
+
+
+class InputCommand(BaseCommand, Generic[InputCommandType]):
+    def __init__(self, trigger: str,
+                 input_flags: InputFlag | InputFlags = None):
+        """
+        Private. The model of the input command, after parsing
+        :param trigger:the trigger of the command
+        :param input_flags: the input flags
+        :return: None
+        """
+        super().__init__(trigger)
+        self._input_flags: InputFlags = input_flags if isinstance(input_flags, InputFlags) else InputFlags(input_flags) if isinstance(input_flags, InputFlag) else InputFlags()
+
+    def _set_input_flags(self, input_flags: InputFlags) -> None:
+        """
+        Private. Sets the input flags
+        :param input_flags: the input flags to set
+        :return: None
+        """
+        self._input_flags = input_flags
+
+    def get_input_flags(self) -> InputFlags:
+        """
+        Private. Returns the input flags
+        :return: the input flags as InputFlags
+        """
+        return self._input_flags
+
+
+    @staticmethod
+    def parse(raw_command: str) -> InputCommandType:
+        """
+        Private. Parse the raw input command
+        :param raw_command: raw input command
+        :return: model of the input command, after parsing as InputCommand
+        """
+        if not raw_command:
+            raise EmptyInputCommandException()
+
+        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)
+

src/argenta/orchestrator/__init__.py

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

src/argenta/orchestrator/argparser/__init__.py

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

src/argenta/orchestrator/argparser/arguments/__init__.py

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

src/argenta/orchestrator/argparser/arguments/models.py

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from typing import Literal
+
+
+class BaseArgument(ABC):
+    """
+    Private. Base class for all arguments
+    """
+    @abstractmethod
+    def get_string_entity(self) -> str:
+        """
+        Public. Returns the string representation of the argument
+        :return: the string representation as a str
+        """
+        pass
+
+
+class PositionalArgument(BaseArgument):
+    def __init__(self, name: str):
+        """
+        Public. Required argument at startup
+        :param name: name of the argument, must not start with minus (-)
+        """
+        self.name = name
+
+    def get_string_entity(self):
+        return self.name
+
+
+class OptionalArgument(BaseArgument):
+    def __init__(self, name: str, prefix: Literal['-', '--', '---'] = '--'):
+        """
+        Public. Optional argument, must have the value
+        :param name: name of the argument
+        :param prefix: prefix of the argument
+        """
+        self.name = name
+        self.prefix = prefix
+
+    def get_string_entity(self):
+        return self.prefix + self.name
+
+
+class BooleanArgument(BaseArgument):
+    def __init__(self, name: str, prefix: Literal['-', '--', '---'] = '--'):
+        """
+        Public. Boolean argument, does not require a value
+        :param name: name of the argument
+        :param prefix: prefix of the argument
+        """
+        self.name = name
+        self.prefix = prefix
+
+    def get_string_entity(self):
+        return self.prefix + self.name

src/argenta/orchestrator/argparser/entity.py

@@ -0,0 +1,49 @@
+from argparse import ArgumentParser
+
+from argenta.orchestrator.argparser.arguments.models import (BooleanArgument,
+                                                             OptionalArgument,
+                                                             PositionalArgument)
+
+
+class ArgParser:
+    def __init__(self,
+                 processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument],
+                 name: str = 'Argenta',
+                 description: str = 'Argenta available arguments',
+                 epilog: str = 'github.com/koloideal/Argenta | made by kolo') -> None:
+        """
+        Public. Cmd argument parser and configurator at startup
+        :param name: the name of the ArgParse instance
+        :param description: the description of the ArgParse instance
+        :param epilog: the epilog of the ArgParse instance
+        :param processed_args: registered and processed arguments
+        """
+        self.name = name
+        self.description = description
+        self.epilog = epilog
+
+        self.entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
+        self.args: list[PositionalArgument | OptionalArgument | BooleanArgument] | None = processed_args
+
+    def set_args(self, *args: PositionalArgument | OptionalArgument | BooleanArgument) -> None:
+        """
+        Public. Sets the arguments to be processed
+        :param args: processed arguments
+        :return: None
+        """
+        self.args.extend(args)
+
+    def register_args(self) -> None:
+        """
+        Private. Registers initialized command line arguments
+        :return: None
+        """
+        if not self.args:
+            return
+        for arg in self.args:
+            if type(arg) is PositionalArgument:
+                self.entity.add_argument(arg.get_string_entity())
+            elif type(arg) is OptionalArgument:
+                self.entity.add_argument(arg.get_string_entity())
+            elif type(arg) is BooleanArgument:
+                self.entity.add_argument(arg.get_string_entity(), action='store_true')

src/argenta/orchestrator/entity.py

@@ -0,0 +1,36 @@
+from argparse import Namespace
+
+from argenta.app import App
+from argenta.orchestrator.argparser import ArgParser
+
+
+class Orchestrator:
+    def __init__(self, arg_parser: ArgParser = False):
+        """
+        Public. An orchestrator and configurator that defines the behavior of an integrated system, one level higher than the App
+        :param arg_parser: Cmd argument parser and configurator at startup
+        :return: None
+        """
+        self.arg_parser: ArgParser | False = arg_parser
+        if arg_parser:
+            self.arg_parser.register_args()
+
+    @staticmethod
+    def start_polling(app: App) -> None:
+        """
+        Public. Starting the user input processing cycle
+        :param app: a running application
+        :return: None
+        """
+        app.run_polling()
+
+    def get_input_args(self) -> Namespace | None:
+        """
+        Public. Returns the arguments parsed
+        :return: None
+        """
+        if self.arg_parser:
+            return self.arg_parser.entity.parse_args()
+        else:
+            return None
+        

src/argenta/router/__init__.py

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

src/argenta/router/command_handler/entity.py

@@ -0,0 +1,71 @@
+from typing import Callable, Iterator
+
+from argenta.command import Command
+from argenta.command.flag import InputFlags
+
+
+
+class CommandHandler:
+    def __init__(self, handler: Callable[[], None] | Callable[[InputFlags], None], handled_command: Command):
+        """
+        Private. Entity of the model linking the handler and the command being processed
+        :param handler: the handler being called
+        :param handled_command: the command being processed
+        """
+        self._handler = handler
+        self._handled_command = handled_command
+
+    def handling(self, input_flags: InputFlags = None) -> None:
+        """
+        Private. Direct processing of an input command
+        :param input_flags: the flags of the input command
+        :return: None
+        """
+        if input_flags is not None:
+            self._handler(input_flags)
+        else:
+            self._handler()
+
+    def get_handler(self) -> Callable[[], None] | Callable[[InputFlags], None]:
+        """
+        Private. Returns the handler being called
+        :return: the handler being called as Callable[[], None] or Callable[[InputFlags], None]
+        """
+        return self._handler
+
+    def get_handled_command(self) -> Command:
+        """
+        Private. Returns the command being processed
+        :return: the command being processed as Command
+        """
+        return self._handled_command
+
+
+class CommandHandlers:
+    def __init__(self, command_handlers: list[CommandHandler] = None):
+        """
+        Private. The model that unites all CommandHandler of the routers
+        :param command_handlers: list of CommandHandlers for register
+        """
+        self.command_handlers = command_handlers if command_handlers else []
+
+    def get_handlers(self) -> list[CommandHandler]:
+        """
+        Private. Returns the list of CommandHandlers
+        :return: the list of CommandHandlers as list[CommandHandler]
+        """
+        return self.command_handlers
+
+    def add_handler(self, command_handler: CommandHandler) -> None:
+        """
+        Private. Adds a CommandHandler to the list of CommandHandlers
+        :param command_handler: CommandHandler to be added
+        :return: None
+        """
+        self.command_handlers.append(command_handler)
+
+    def __iter__(self) -> Iterator[CommandHandler]:
+        return iter(self.command_handlers)
+
+    def __next__(self) -> CommandHandler:
+        return next(iter(self.command_handlers))

src/argenta/router/defaults.py

@@ -0,0 +1,4 @@
+from argenta.router import Router
+
+
+system_router = Router(title='System points:')

src/argenta/router/entity.py

@@ -0,0 +1,204 @@
+from typing import Callable
+from inspect import getfullargspec
+from argenta.command import Command
+from argenta.command.models import InputCommand
+from argenta.router.command_handler.entity import CommandHandlers, CommandHandler
+from argenta.command.flag.models import Flag, Flags, InputFlags
+from argenta.router.exceptions import (RepeatedFlagNameException,
+                                       TooManyTransferredArgsException,
+                                       RequiredArgumentNotPassedException,
+                                       TriggerContainSpacesException)
+
+
+class Router:
+    def __init__(self,
+                 title: str = None):
+        """
+        Public. Directly configures and manages handlers
+        :param title: the title of the router, displayed when displaying the available commands
+        :return: None
+        """
+        self._title = title
+
+        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 ''}")
+
+
+    def command(self, command: Command) -> Callable:
+        """
+        Public. Registers handler
+        :param command: Registered command
+        :return: decorated handler as Callable[[Any], Any]
+        """
+        self._validate_command(command)
+
+        def command_decorator(func):
+            Router._validate_func_args(command, func)
+            self._command_handlers.add_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: Callable[[Flag], None]) -> None:
+        """
+        Public. Registers handler for invalid input flag
+        :param func: registered handler
+        :return: None
+        """
+        self._not_valid_flag_handler = func
+
+
+    def finds_appropriate_handler(self, input_command: InputCommand) -> None:
+        """
+        Private. Finds the appropriate handler for given input command and passes control to it
+        :param input_command: input command as InputCommand
+        :return: None
+        """
+        input_command_name: str = input_command.get_trigger()
+        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():
+                self.process_input_command(input_command_flags, command_handler)
+            if input_command_name.lower() in handle_command.get_aliases():
+                self.process_input_command(input_command_flags, command_handler)
+
+
+    def process_input_command(self, input_command_flags: InputFlags, command_handler: CommandHandler) -> None:
+        """
+        Private. Processes input command with the appropriate handler
+        :param input_command_flags: input command flags as InputFlags
+        :param command_handler: command handler for input command as CommandHandler
+        :return: None
+        """
+        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, handled_command: Command, input_flags: InputFlags) -> bool:
+        """
+        Private. Validates flags of input command
+        :param handled_command: entity of the handled command
+        :param input_flags:
+        :return: is flags of input command valid as bool
+        """
+        for flag in input_flags:
+            is_valid: bool = handled_command.validate_input_flag(flag)
+            if not is_valid:
+                self._not_valid_flag_handler(flag)
+                return False
+        return True
+
+
+    @staticmethod
+    def _validate_command(command: Command) -> None:
+        """
+        Private. Validates the command registered in handler
+        :param command: validated command
+        :return: None if command is valid else raise exception
+        """
+        command_name: str = command.get_trigger()
+        if command_name.find(' ') != -1:
+            raise TriggerContainSpacesException()
+
+        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):
+                raise RepeatedFlagNameException()
+
+
+    @staticmethod
+    def _validate_func_args(command: Command, func: Callable) -> None:
+        """
+        Private. Validates the arguments of the handler
+        :param command: registered command in handler
+        :param func: entity of the handler func
+        :return: None if func is valid else raise exception
+        """
+        registered_args = command.get_registered_flags()
+        transferred_args = getfullargspec(func).args
+        if registered_args.get_flags() and transferred_args:
+           if len(transferred_args) != 1:
+                raise TooManyTransferredArgsException()
+        elif registered_args.get_flags() and not transferred_args:
+            raise RequiredArgumentNotPassedException()
+        elif not registered_args.get_flags() and transferred_args:
+            raise TooManyTransferredArgsException()
+
+
+    def set_command_register_ignore(self, _: bool) -> None:
+        """
+        Private. Sets the router behavior on the input commands register
+        :param _: is command register ignore
+        :return: None
+        """
+        self._ignore_command_register = _
+
+
+    def get_triggers(self) -> list[str]:
+        """
+        Public. Gets registered triggers
+        :return: registered in router triggers as list[str]
+        """
+        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) -> list[str]:
+        """
+        Public. Gets registered aliases
+        :return: registered in router aliases as list[str]
+        """
+        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:
+        """
+        Private. Gets registered command handlers
+        :return: registered command handlers as CommandHandlers
+        """
+        return self._command_handlers
+
+
+    def get_title(self) -> str | None:
+        """
+        Public. Gets title of the router
+        :return: the title of the router as str or None
+        """
+        return self._title
+
+
+    def set_title(self, title: str) -> None:
+        """
+        Public. Sets the title of the router
+        :param title: title that will be setted
+        :return: None
+        """
+        self._title = title

src/argenta/router/exceptions.py

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

tests/main_test.py

@@ -1,5 +0,0 @@
-from argenta.app.entity import *
-
-
-def test():
-    assert App().exit_command == 'q'

tests/system_tests/test_system_handling_non_standard_behavior.py

@@ -0,0 +1,216 @@
+import _io
+from unittest.mock import patch, MagicMock
+import unittest
+import io
+import re
+
+from argenta.app import App
+from argenta.command import Command
+from argenta.router import Router
+from argenta.command.flag.models import Flags, InputFlags
+from argenta.command.flag.defaults import PredefinedFlags
+
+
+
+class TestSystemHandlerNormalWork(unittest.TestCase):
+    @patch("builtins.input", side_effect=["help", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_incorrect_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print('test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_unknown_command_handler(lambda command: print(f'Unknown command: {command.get_trigger()}'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn("\nUnknown command: help\n", output)
+
+
+    @patch("builtins.input", side_effect=["TeSt", "Q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_incorrect_command2(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print('test command')
+
+        app = App(ignore_command_register=False,
+                  override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_unknown_command_handler(lambda command: print(f'Unknown command: {command.get_trigger()}'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nUnknown command: TeSt\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --help", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_unregistered_flag(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nUndefined or incorrect input flag: --help\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --port 22", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_unregistered_flag2(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print('test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nUndefined or incorrect input flag: --port 22\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --host 192.168.32.1 --port 132", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_one_correct_flag_an_one_incorrect_flag(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flags = Flags(PredefinedFlags.HOST)
+
+        @router.command(Command('test', flags=flags))
+        def test(args: InputFlags):
+            print(f'connecting to host {args.get_flag('host').get_value()}')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nUndefined or incorrect input flag: --port 132\n', output)
+
+
+    @patch("builtins.input", side_effect=["test", "some", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_one_correct_command_and_one_incorrect_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_unknown_command_handler(lambda command: print(f'Unknown command: {command.get_trigger()}'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertRegex(output, re.compile(r'\ntest command\n(.|\n)*\nUnknown command: some'))
+
+
+    @patch("builtins.input", side_effect=["test", "some", "more", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_two_correct_commands_and_one_incorrect_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        @router.command(Command('more'))
+        def test():
+            print(f'more command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_unknown_command_handler(lambda command: print(f'Unknown command: {command.get_trigger()}'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertRegex(output, re.compile(r'\ntest command\n(.|\n)*\nUnknown command: some\n(.|\n)*\nmore command'))
+
+
+    @patch("builtins.input", side_effect=["test 535 --port", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_incorrect_flag(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_invalid_input_flags_handler(lambda command: print(f'Incorrect flag syntax: "{command}"'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn("\nIncorrect flag syntax: \"test 535 --port\"\n", output)
+
+
+    @patch("builtins.input", side_effect=["", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_empty_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_empty_command_handler(lambda: print('Empty input command'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn("\nEmpty input command\n", output)
+
+
+    @patch("builtins.input", side_effect=["test --port 22 --port 33", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_repeated_flags(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test', flags=PredefinedFlags.PORT))
+        def test(args: InputFlags):
+            print('test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.set_repeated_input_flags_handler(lambda command: print(f'Repeated input flags: "{command}"'))
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn("\nRepeated input flags: \"test --port 22 --port 33\"\n", output)

tests/system_tests/test_system_handling_normal_behavior.py

@@ -0,0 +1,222 @@
+import _io
+from unittest.mock import patch, MagicMock
+import unittest
+import io
+import re
+
+from argenta.app import App
+from argenta.command.models import Command
+from argenta.router import Router
+from argenta.command.flag.models import Flag, Flags, InputFlags
+from argenta.command.flag.defaults import PredefinedFlags
+
+
+
+class TestSystemHandlerNormalWork(unittest.TestCase):
+    @patch("builtins.input", side_effect=["test", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print('test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\ntest command\n', output)
+
+
+    @patch("builtins.input", side_effect=["TeSt", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command2(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print('test command')
+
+        app = App(ignore_command_register=True,
+                  override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\ntest command\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --help", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_custom_flag(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flag = Flag('help', '--', False)
+
+        @router.command(Command('test', flags=flag))
+        def test(args: InputFlags):
+            print(f'\nhelp for {args.get_flag('help').get_name()} flag\n')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nhelp for help flag\n', output)
+
+    @patch("builtins.input", side_effect=["test --port 22", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_custom_flag2(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flag = Flag('port', '--', re.compile(r'^\d{1,5}$'))
+
+        @router.command(Command('test', flags=flag))
+        def test(args: InputFlags):
+            print(f'flag value for {args.get_flag('port').get_name()} flag : {args.get_flag('port').get_value()}')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nflag value for port flag : 22\n', output)
+
+
+    @patch("builtins.input", side_effect=["test -H", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_default_flag(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flag = PredefinedFlags.SHORT_HELP
+
+        @router.command(Command('test', flags=flag))
+        def test(args: InputFlags):
+            print(f'help for {args.get_flag('H').get_name()} flag')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nhelp for H flag\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --info", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_default_flag2(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flag = PredefinedFlags.INFO
+
+        @router.command(Command('test', flags=flag))
+        def test(args: InputFlags):
+            if args.get_flag('info'):
+                print('info about test command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\ninfo about test command\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --host 192.168.0.1", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_default_flag3(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flag = PredefinedFlags.HOST
+
+        @router.command(Command('test', flags=flag))
+        def test(args: InputFlags):
+            print(f'connecting to host {args[0].get_value()}')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nconnecting to host 192.168.0.1\n', output)
+
+
+    @patch("builtins.input", side_effect=["test --host 192.168.32.1 --port 132", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_correct_command_with_two_flags(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+        flags = Flags(PredefinedFlags.HOST, PredefinedFlags.PORT)
+
+        @router.command(Command('test', flags=flags))
+        def test(args: InputFlags):
+            print(f'connecting to host {args[0].get_value()} and port {args[1].get_value()}')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertIn('\nconnecting to host 192.168.32.1 and port 132\n', output)
+
+
+    @patch("builtins.input", side_effect=["test", "some", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_two_correct_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        @router.command(Command('some'))
+        def test2():
+            print(f'some command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertRegex(output, re.compile(r'\ntest command\n(.|\n)*\nsome command\n'))
+
+
+    @patch("builtins.input", side_effect=["test", "some", "more", "q"])
+    @patch("sys.stdout", new_callable=io.StringIO)
+    def test_input_three_correct_command(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
+        router = Router()
+
+        @router.command(Command('test'))
+        def test():
+            print(f'test command')
+
+        @router.command(Command('some'))
+        def test():
+            print(f'some command')
+
+        @router.command(Command('more'))
+        def test():
+            print(f'more command')
+
+        app = App(override_system_messages=True,
+                  print_func=print)
+        app.include_router(router)
+        app.run_polling()
+
+        output = mock_stdout.getvalue()
+
+        self.assertRegex(output, re.compile(r'\ntest command\n(.|\n)*\nsome command\n(.|\n)*\nmore command'))

tests/unit_tests/test_app.py

@@ -0,0 +1,73 @@
+from argenta.command.models import InputCommand, Command
+from argenta.app import App
+
+import unittest
+
+
+class MyTestCase(unittest.TestCase):
+    def test_is_exit_command1(self):
+        app = App()
+        self.assertEqual(app._is_exit_command(InputCommand('q')), True)
+
+    def test_is_exit_command5(self):
+        app = App()
+        self.assertEqual(app._is_exit_command(InputCommand('Q')), True)
+
+    def test_is_exit_command2(self):
+        app = App(ignore_command_register=False)
+        self.assertEqual(app._is_exit_command(InputCommand('q')), False)
+
+    def test_is_exit_command3(self):
+        app = App(exit_command=Command('quit'))
+        self.assertEqual(app._is_exit_command(InputCommand('quit')), True)
+
+    def test_is_exit_command4(self):
+        app = App(exit_command=Command('quit'))
+        self.assertEqual(app._is_exit_command(InputCommand('qUIt')), True)
+
+    def test_is_exit_command6(self):
+        app = App(ignore_command_register=False,
+                  exit_command=Command('quit'))
+        self.assertEqual(app._is_exit_command(InputCommand('qUIt')), False)
+
+    def test_is_unknown_command1(self):
+        app = App()
+        app.set_unknown_command_handler(lambda command: None)
+        app._all_registered_triggers_in_lower = ['fr', 'tr', 'de']
+        self.assertEqual(app._is_unknown_command(InputCommand('fr')), False)
+
+    def test_is_unknown_command2(self):
+        app = App()
+        app.set_unknown_command_handler(lambda command: None)
+        app._all_registered_triggers_in_lower = ['fr', 'tr', 'de']
+        self.assertEqual(app._is_unknown_command(InputCommand('cr')), True)
+
+    def test_is_unknown_command3(self):
+        app = App(ignore_command_register=False)
+        app.set_unknown_command_handler(lambda command: None)
+        app._all_registered_triggers_in_default_case = ['Pr', 'tW', 'deQW']
+        self.assertEqual(app._is_unknown_command(InputCommand('pr')), True)
+
+    def test_is_unknown_command4(self):
+        app = App(ignore_command_register=False)
+        app.set_unknown_command_handler(lambda command: None)
+        app._all_registered_triggers_in_default_case = ['Pr', 'tW', 'deQW']
+        self.assertEqual(app._is_unknown_command(InputCommand('tW')), False)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tests/unit_tests/test_command.py

@@ -0,0 +1,49 @@
+from argenta.command.flag import Flag, InputFlag, Flags
+from argenta.command.models import InputCommand, Command
+from argenta.command.exceptions import (UnprocessedInputFlagException,
+                                        RepeatedInputFlagsException,
+                                        EmptyInputCommandException)
+
+import unittest
+
+
+class TestInputCommand(unittest.TestCase):
+    def test_parse_correct_raw_command(self):
+        self.assertEqual(InputCommand.parse('ssh --host 192.168.0.3').get_trigger(), 'ssh')
+
+    def test_parse_raw_command_without_flag_name_with_value(self):
+        with self.assertRaises(UnprocessedInputFlagException):
+            InputCommand.parse('ssh 192.168.0.3')
+
+    def test_parse_raw_command_with_repeated_flag_name(self):
+        with self.assertRaises(RepeatedInputFlagsException):
+            InputCommand.parse('ssh --host 192.168.0.3 --host 172.198.0.43')
+
+    def test_parse_empty_raw_command(self):
+        with self.assertRaises(EmptyInputCommandException):
+            InputCommand.parse('')
+
+    def test_validate_correct_input_flag1(self):
+        command = Command('some', flags=Flag('test'))
+        self.assertEqual(command.validate_input_flag(InputFlag('test')), True)
+
+    def test_validate_correct_input_flag2(self):
+        command = Command('some', flags=Flags(Flag('test'), Flag('more')))
+        self.assertEqual(command.validate_input_flag(InputFlag('more')), True)
+
+    def test_validate_incorrect_input_flag1(self):
+        command = Command('some', flags=Flags(Flag('test')))
+        self.assertEqual(command.validate_input_flag(InputFlag('more')), False)
+
+    def test_validate_incorrect_input_flag2(self):
+        command = Command('some', flags=Flags(Flag('test'), Flag('more')))
+        self.assertEqual(command.validate_input_flag(InputFlag('case')), False)
+
+    def test_validate_incorrect_input_flag3(self):
+        command = Command('some')
+        self.assertEqual(command.validate_input_flag(InputFlag('case')), False)
+
+    def test_isinstance_parse_correct_raw_command(self):
+        cmd = InputCommand.parse('ssh --host 192.168.0.3')
+        self.assertIsInstance(cmd, InputCommand)
+

tests/unit_tests/test_dividing_line.py

@@ -0,0 +1,21 @@
+from argenta.app.dividing_line import DynamicDividingLine, StaticDividingLine
+
+import unittest
+
+
+class TestDividingLine(unittest.TestCase):
+    def test_get_static_dividing_line_full_line(self):
+        line = StaticDividingLine('-')
+        self.assertEqual(line.get_full_static_line(True).count('-'), 25)
+
+    def test_get_dynamic_dividing_line_full_line(self):
+        line = DynamicDividingLine()
+        self.assertEqual(line.get_full_dynamic_line(20, True).count('-'), 20)
+
+    def test_get_dividing_line_unit_part(self):
+        line = StaticDividingLine('')
+        self.assertEqual(line.get_unit_part(), ' ')
+
+    def test_get_dividing_line2_unit_part(self):
+        line = StaticDividingLine('+-0987654321!@#$%^&*()_')
+        self.assertEqual(line.get_unit_part(), '+')

tests/unit_tests/test_flag.py

@@ -0,0 +1,129 @@
+from argenta.command.flag.models import Flag, InputFlag, InputFlags, Flags
+
+import unittest
+import re
+
+
+class TestFlag(unittest.TestCase):
+    def test_get_string_entity(self):
+        self.assertEqual(Flag(name='test').get_string_entity(),
+                         '--test')
+
+    def test_get_string_entity2(self):
+        self.assertEqual(Flag(name='test',
+                              prefix='---').get_string_entity(),
+                         '---test')
+
+    def test_get_flag_name(self):
+        self.assertEqual(Flag(name='test').get_name(),
+                         'test')
+
+    def test_get_flag_prefix(self):
+        self.assertEqual(Flag(name='test').get_prefix(),
+                         '--')
+
+    def test_get_flag_prefix2(self):
+        self.assertEqual(Flag(name='test',
+                              prefix='--').get_prefix(),
+                         '--')
+
+    def test_get_flag_value_without_set(self):
+        self.assertEqual(InputFlag(name='test').get_value(),
+                         None)
+
+    def test_get_flag_value_with_set(self):
+        flag = InputFlag(name='test')
+        flag.set_value('example')
+        self.assertEqual(flag.get_value(), 'example')
+
+    def test_validate_incorrect_flag_value_with_list_of_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=['1', '2', '3'])
+        self.assertEqual(flag.validate_input_flag_value('bad value'), False)
+
+    def test_validate_correct_flag_value_with_list_of_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=['1', '2', '3'])
+        self.assertEqual(flag.validate_input_flag_value('1'), True)
+
+    def test_validate_incorrect_flag_value_with_pattern_of_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=re.compile(r'192.168.\d+.\d+'))
+        self.assertEqual(flag.validate_input_flag_value('152.123.9.8'), False)
+
+    def test_validate_correct_flag_value_with_pattern_of_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=re.compile(r'192.168.\d+.\d+'))
+        self.assertEqual(flag.validate_input_flag_value('192.168.9.8'), True)
+
+    def test_validate_correct_empty_flag_value_without_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=False)
+        self.assertEqual(flag.validate_input_flag_value(None), True)
+
+    def test_validate_correct_empty_flag_value_with_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=True)
+        self.assertEqual(flag.validate_input_flag_value(None), True)
+
+    def test_validate_incorrect_random_flag_value_without_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=False)
+        self.assertEqual(flag.validate_input_flag_value('random value'), False)
+
+    def test_validate_correct_random_flag_value_with_possible_flag_values(self):
+        flag = Flag(name='test', possible_values=True)
+        self.assertEqual(flag.validate_input_flag_value('random value'), True)
+
+    def test_get_input_flag1(self):
+        flag = InputFlag(name='test')
+        input_flags = InputFlags(flag)
+        self.assertEqual(input_flags.get_flag('test'), flag)
+
+    def test_get_input_flag2(self):
+        flag = InputFlag(name='test')
+        flag2 = InputFlag(name='some')
+        input_flags = InputFlags(flag, flag2)
+        self.assertEqual(input_flags.get_flag('some'), flag2)
+
+    def test_get_undefined_input_flag(self):
+        flag = InputFlag(name='test')
+        flag2 = InputFlag(name='some')
+        input_flags = InputFlags(flag, flag2)
+        self.assertEqual(input_flags.get_flag('case'), None)
+
+    def test_get_flags(self):
+        flags = Flags()
+        list_of_flags = [
+            Flag('test1'),
+            Flag('test2'),
+            Flag('test3'),
+        ]
+        flags.add_flags(list_of_flags)
+        self.assertEqual(flags.get_flags(),
+                         list_of_flags)
+
+    def test_add_flag(self):
+        flags = Flags()
+        flags.add_flag(Flag('test'))
+        self.assertEqual(len(flags.get_flags()), 1)
+
+    def test_add_flags(self):
+        flags = Flags()
+        flags.add_flags([Flag('test'), Flag('test2')])
+        self.assertEqual(len(flags.get_flags()), 2)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tests/unit_tests/test_router.py

@@ -0,0 +1,144 @@
+from argenta.command.flag import InputFlags, InputFlag, Flag, Flags
+from argenta.router import Router
+from argenta.command import Command
+from argenta.router.exceptions import (TriggerContainSpacesException,
+                                       RepeatedFlagNameException,
+                                       TooManyTransferredArgsException,
+                                       RequiredArgumentNotPassedException)
+
+import unittest
+import re
+
+
+class TestRouter(unittest.TestCase):
+    def test_get_router_title(self):
+        self.assertEqual(Router(title='test title').get_title(), 'test title')
+
+    def test_register_command_with_spaces_in_trigger(self):
+        router = Router()
+        with self.assertRaises(TriggerContainSpacesException):
+            router._validate_command(Command(trigger='command with spaces'))
+
+    def test_register_command_with_repeated_flags(self):
+        router = Router()
+        with self.assertRaises(RepeatedFlagNameException):
+            router._validate_command(Command(trigger='command', flags=Flags(Flag('test'), Flag('test'))))
+
+    def test_validate_incorrect_input_flag1(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        self.assertEqual(router._validate_input_flags(Command('cmd'), InputFlags(InputFlag('ssh'))), False)
+
+    def test_validate_incorrect_input_flag2(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        self.assertEqual(router._validate_input_flags(Command('cmd'), InputFlags(InputFlag('ssh', value='some'))), False)
+
+    def test_validate_incorrect_input_flag3(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        command = Command('cmd', flags=Flag('port'))
+        input_flags = InputFlags(InputFlag('ssh', value='some2'))
+        self.assertEqual(router._validate_input_flags(command, input_flags), False)
+
+    def test_validate_incorrect_input_flag4(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        command = Command('cmd', flags=Flag('ssh', possible_values=False))
+        input_flags = InputFlags(InputFlag('ssh', value='some3'))
+        self.assertEqual(router._validate_input_flags(command, input_flags), False)
+
+    def test_validate_incorrect_input_flag5(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        command = Command('cmd', flags=Flag('ssh', possible_values=re.compile(r'some[1-5]$')))
+        input_flags = InputFlags(InputFlag('ssh', value='some40'))
+        self.assertEqual(router._validate_input_flags(command, input_flags), False)
+
+    def test_validate_incorrect_input_flag6(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        command = Command('cmd', flags=Flag('ssh', possible_values=['example']))
+        input_flags = InputFlags(InputFlag('ssh', value='example2'))
+        self.assertEqual(router._validate_input_flags(command, input_flags), False)
+
+    def test_validate_incorrect_input_flag7(self):
+        router = Router()
+        router.set_invalid_input_flag_handler(lambda flag: None)
+        command = Command('cmd', flags=Flag('ssh', possible_values=['example']))
+        input_flags = InputFlags(InputFlag('ssh'))
+        self.assertEqual(router._validate_input_flags(command, input_flags), False)
+
+    def test_validate_correct_input_flag1(self):
+        command = Command('cmd', flags=Flag('port'))
+        input_flags = InputFlags(InputFlag('port', value='some2'))
+        self.assertEqual(Router()._validate_input_flags(command, input_flags), True)
+
+    def test_validate_correct_input_flag2(self):
+        command = Command('cmd', flags=Flag('port', possible_values=['some2', 'some3']))
+        input_flags = InputFlags(InputFlag('port', value='some2'))
+        self.assertEqual(Router()._validate_input_flags(command, input_flags), True)
+
+    def test_validate_correct_input_flag3(self):
+        command = Command('cmd', flags=Flag('ssh', possible_values=re.compile(r'more[1-5]$')))
+        input_flags = InputFlags(InputFlag('ssh', value='more5'))
+        self.assertEqual(Router()._validate_input_flags(command, input_flags), True)
+
+    def test_validate_correct_input_flag4(self):
+        command = Command('cmd', flags=Flag('ssh', possible_values=False))
+        input_flags = InputFlags(InputFlag('ssh'))
+        self.assertEqual(Router()._validate_input_flags(command, input_flags), True)
+
+    def test_validate_incorrect_func_args1(self):
+        command = Command('cmd', flags=Flag('port'))
+        def handler():
+            pass
+        with self.assertRaises(RequiredArgumentNotPassedException):
+            Router()._validate_func_args(command, handler)
+
+    def test_validate_incorrect_func_args2(self):
+        command = Command('cmd', flags=Flag('port'))
+        def handler(args, kwargs):
+            pass
+        with self.assertRaises(TooManyTransferredArgsException):
+            Router()._validate_func_args(command, handler)
+
+    def test_validate_incorrect_func_args3(self):
+        command = Command('cmd')
+        def handler(args):
+            pass
+        with self.assertRaises(TooManyTransferredArgsException):
+            Router()._validate_func_args(command, handler)
+
+    def test_get_router_aliases(self):
+        router = Router()
+        @router.command(Command('some', aliases=['test', 'case']))
+        def handler():
+            pass
+        self.assertListEqual(router.get_aliases(), ['test', 'case'])
+
+    def test_get_router_aliases2(self):
+        router = Router()
+        @router.command(Command('some', aliases=['test', 'case']))
+        def handler():
+            pass
+        @router.command(Command('ext', aliases=['more', 'foo']))
+        def handler2():
+            pass
+        self.assertListEqual(router.get_aliases(), ['test', 'case', 'more', 'foo'])
+
+    def test_get_router_aliases3(self):
+        router = Router()
+        @router.command(Command('some'))
+        def handler():
+            pass
+        self.assertListEqual(router.get_aliases(), [])
+
+
+
+
+
+
+
+
+