some 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

@@ -3,4 +3,5 @@
 dist
 poetry.lock
 *__pycache__/
+*.hist*
 

README.md

@@ -3,7 +3,10 @@
 ---
 
 ## Описание
-**Argenta** — Python library for creating custom shells
+**Argenta** — Python library for creating TUI
+
+![preview](https://github.com/koloideal/Argenta/blob/kolo/imgs/mock_app_preview_last.png?raw=True)  
+Пример внешнего вида TUI, написанного с помощью Argenta  
 
 ---
 
@@ -56,14 +59,14 @@ if __name__ == '__main__':
 import re
 from argenta.router import Router
 from argenta.command import Command
-from argenta.command.flag import FlagsGroup, Flag
+from argenta.command.flag import Flags, Flag, InputFlags
 
 router = Router()
 
-registered_flags = FlagsGroup(
+registered_flags = Flags(
-    Flag(flag_name='host',
+    Flag(name='host',
-         flag_prefix='--',
+         prefix='--',
-         possible_flag_values=re.compile(r'^192.168.\d{1,3}.\d{1,3}$')),
+         possible_values=re.compile(r'^192.168.\d{1,3}.\d{1,3}$')),
     Flag('port', '--', re.compile(r'^[0-9]{1,4}$')))
 
 
@@ -75,10 +78,10 @@ def handler():
 @router.command(Command(trigger="ssh",
                         description='connect via ssh',
                         flags=registered_flags))
-def handler_with_flags(flags: dict):
+def handler_with_flags(flags: InputFlags):
     for flag in flags:
-        print(f'Flag name: {flag['name']}\n'
+        print(f'Flag name: {flag.get_name()}\n'
-              f'Flag value: {flag['value']}')
+              f'Flag value: {flag.get_value()}')
 ```
 
 ---
@@ -92,33 +95,31 @@ def handler_with_flags(flags: dict):
 
 ### Конструктор
 ```python
-App(prompt: str = 'Enter a command',
+App(prompt: str = '[italic dim bold]What do you want to do?\n',
-    initial_greeting: str = '\nHello, I am Argenta\n',
+    initial_message: str = '\nArgenta\n',
-    farewell_message: str = '\nGoodBye\n',
+    farewell_message: str = '\nSee you\n',
-    exit_command: str = 'Q',
+    exit_command: Command = Command('Q', 'Exit command'),
-    exit_command_description: str = 'Exit command',
+    system_points_title: str | None = 'System points:',
-    system_points_title: str = 'System points:',
+    ignore_command_register: bool = True,
-    ignore_exit_command_register: bool = True,
+    dividing_line: StaticDividingLine | DynamicDividingLine = StaticDividingLine(),
-    ignore_command_register: bool = False,
-    line_separate: str = '',
-    command_group_description_separate: str = '',
     repeat_command_groups: bool = True,
-    print_func: Callable[[str], None] = print)
+    override_system_messages: bool = False,
+    autocompleter: AutoCompleter = AutoCompleter(),
+    print_func: Callable[[str], None] = Console().print)
 ```
 **Аргументы:**
 - **name : mean**
 - `prompt` (`str`): Сообщение перед вводом команды.
-- `initial_greeting` (`str`): Приветственное сообщение при запуске.
+- `initial_message` (`str`): Приветственное сообщение при запуске.
 - `farewell_message` (`str`): Сообщение при выходе.
-- `exit_command` (`str`): Команда выхода (по умолчанию `'Q'`).
+- `exit_command` (`Command`): Сущность команды, которая будет отвечать за завершение работы.
-- `exit_command_description` (`str`): Описание команды выхода.
 - `system_points_title` (`str`): Заголовок перед списком системных команд.
-- `ignore_exit_command_register` (`bool`): Игнорировать регистр команды выхода.
 - `ignore_command_register` (`bool`): Игнорировать регистр всех команд.
-- `line_separate` (`str`): Разделительная строка между командами.
+- `dividing_line` (`StaticDividingLine | DynamicDividingLine`): Разделительная строка.
-- `command_group_description_separate` (`str`): Разделитель между группами команд.
 - `repeat_command_groups` (`bool`): Повторять описание команд перед вводом.
-- `print_func` (`Callable[[str], None]`): Функция вывода текста в терминал (по умолчанию `print`).
+- `override_system_messages` (`bool`): Переопределить ли дефолтное оформление сообщений ([подробнее см.](#override_defaults))
+- `autocompleter` (`AutoCompleter`): Сущность автодополнителя ввода.
+- `print_func` (`Callable[[str], None]`): Функция вывода текста в терминал.
 
 ---
 
@@ -128,94 +129,83 @@ App(prompt: str = 'Enter a command',
 
 #### **.start_polling() -> `None`**  
 
-*method mean* **::** запускает цикл обработки ввода
+*method mean* **::** Запускает цикл обработки ввода
 
 ---
 
 #### **.include_router(router: Router) -> `None`**  
 
-*param* `router: Router` **::** регистрируемый роутер  
+*param* `router: Router` **::** Регистрируемый роутер  
 *required* **::** True
 
-*method mean* **::** регистрирует роутер в оболочке
+*method mean* **::** Регистрирует роутер в оболочке
 
 ---
 
-#### **.set_initial_message(message: str) -> `None`**  
+#### **.include_routers(\*routers: Router) -> `None`**  
 
-*param* `message: str` **::** устанавливаемое приветственное сообщение  
+*param* `routers: Router` **::** Неограниченное количество регистрируемых роутеров    
-*required* **::** True  
+*required* **::** True
-*example* **::** `"Hello, I'm a example app"`
 
-*method mean* **::** устанавливает сообщение, которое будет отображено при запуске программы
+*method mean* **::** Регистрирует роутер в оболочке
-
----
-
-#### **.set_farewell_message(message: str) -> `None`**  
-
-*param* `message: str` **::** устанавливаемое сообщение при выходе  
-*required* **::** True  
-*example* **::** `"GoodBye !"`
-
-*method mean* **::** устанавливает сообщение, которое будет отображено при выходе
 
 ---
 
 #### **.set_description_message_pattern(pattern: str) -> `None`**  
 
-*param* `pattern: str` **::** паттерн описания команды при её выводе в консоль  
+*param* `pattern: str` **::** Паттерн описания команды при её выводе в консоль  
 *required* **::** True  
 *example* **::** `"[{command}] *=*=* {description}"`
 
-*method mean* **::** устанавливает паттерн описания команд, который будет использован
+*method mean* **::** Устанавливает паттерн описания команд, который будет использован
 при выводе в консоль
 
 ---
-<a name="custom_handler"></a>
-#### **.set_repeated_input_flags_handler(handler: Callable[[str], None]) -> `None`**  
 
-*param* `handler: Callable[[str], None]` **::** функция или лямбда функция, которой будет передано управление при
+#### **.add_message_on_startup(message: str) -> `None`**  
-вводе юзером повторяющихся флагов  
+
+*param* `message: str` **::** Сообщение, которое будет выведено при запуске приложения 
 *required* **::** True  
+*example* **::** `Message on startup`
+
+*method mean* **::** Устанавливает паттерн описания команд, который будет использован
+при выводе в консоль
+
+---
+
+<a name="custom_handler"></a>
+#### **.repeated_input_flags_handler: `Callable[[str], None])`**
+
 *example* **::** `lambda raw_command: print_func(f'Repeated input flags: "{raw_command}"')`
 
-*method mean* **::** устанавливает функцию, которой будет передано управление при
+*attr mean* **::** Устанавливает функцию, которой будет передано управление при
 вводе юзером повторяющихся флагов
 
 ---
 
-#### **.set_invalid_input_flags_handler(self, handler: Callable[[str], None]) -> `None`**  
+#### **.invalid_input_flags_handler: `Callable[[str], None])`**  
 
-*param* `handler: Callable[[str], None]` **::** функция или лямбда функция, которой будет передано управление при
-вводе юзером команды с некорректным синтаксисом флагов
-*required* **::** True  
 *example* **::** `lambda raw_command: print_func(f'Incorrect flag syntax: "{raw_command}"')`
 
-*method mean* **::** устанавливает функцию, которой будет передано управление при
+*attr mean* **::** Устанавливает функцию, которой будет передано управление при
 вводе юзером команды с некорректным синтаксисом флагов
 
 ---
 
-#### **.set_unknown_command_handler(self, handler: Callable[[str], None]) -> `None`**  
+#### **.unknown_command_handler: `Callable[[str], None]`**  
 
-*param* `handler: Callable[[str], None]` **::** функция или лямбда функция, которой будет передано управление при
-вводе юзером неизвестной команды
-*required* **::** True  
 *example* **::** `lambda command: print_func(f"Unknown command: {command.get_string_entity()}")`
 
-*method mean* **::** устанавливает функцию, которой будет передано управление при
+*attr mean* **::** Устанавливает функцию, которой будет передано управление при
 вводе юзером неизвестной команды
 
 ---
 
-#### **.set_empty_command_handler(self, handler: Callable[[str], None]) -> `None`**  
+#### **.empty_command_handler: `Callable[[str], None])`**  
 
-*param* `handler: Callable[[str], None]` **::** функция или лямбда функция, которой будет передано управление при
-вводе юзером пустой команды  
-*required* **::** True  
 *example* **::** `lambda: print_func(f'Empty input command')`
 
-*method mean* **::** устанавливает функцию, которой будет передано управление при
+*attr mean* **::** Устанавливает функцию, которой будет передано управление при
 вводе юзером пустой команды
 
 ---
@@ -233,6 +223,14 @@ App(prompt: str = 'Enter a command',
 `RepeatedCommandInDifferentRoutersException`. Исключение вызывается только при наличии пересекающихся команд 
 у __<u>разных</u>__ роутеров
 
+- Наиболее частые сообщение при запуске предопределены и доступны для быстрого
+использования: `argenta.app.defaults.PredeterminedMessages`
+
+<a name="override_defaults"></a>
+- Если `override_system_messages`=`False`, то при переопределении таких атрибутов как `initial_message` и
+`farawell_message` будет использовано дефолтное оформление текста, в виде красного ascii арта, при значении
+`override_system_messages`=`True` системные сообщения будут отображены в точности какими были переданы
+
 
 
 
@@ -241,9 +239,57 @@ App(prompt: str = 'Enter a command',
 - `InvalidRouterInstanceException` — Переданный объект в метод `App().include_router()` не является экземпляром класса `Router`.
 - `InvalidDescriptionMessagePatternException` — Неправильный формат паттерна описания команд.
 - `IncorrectNumberOfHandlerArgsException` — У обработчика нестандартного поведения зарегистрировано неверное количество аргументов(в большинстве случаев у него должен быть один аргумент).
-- `NoRegisteredRoutersException` — Отсутствуют зарегистрированные роутеры.
 - `NoRegisteredHandlersException` — У роутера нет ни одного обработчика команд.
-- `RepeatedCommandInDifferentRoutersException` — Одна и та же команда зарегистрирована в разных роутерах.
+
+---
+
+##  *class* :: `AutoCompleter` 
+Класс, экземпляр которого представляет собой автодополнитель ввода
+
+### Конструктор
+```python
+AutoCompleter(history_filename: str = False, 
+              autocomplete_button: str = 'tab')
+```
+
+**Аргументы:**
+- **name : mean**
+- `history_filename` (`str` | `False`): Путь к файлу, который будет являться или является 
+историй пользовательского ввода, в последующем эти команды будут автодополняться, файл
+может не существовать при инициализации, тогда он будет создан, при значении аргумента `False`
+история пользовательского ввода будет существовать только в пределах сессии и не сохраняться в файл
+- `autocomplete_button` (`str`): Строковое обозначение кнопки на клавиатуре, которая будет
+использоваться для автодополнения при вводе, по умолчанию `tab`
+
+---
+
+##  *class* :: `StaticDivideLine` 
+Класс, экземпляр которого представляет собой строковый разделитель фиксированной длины
+
+### Конструктор
+```python
+StaticDivideLine(unit_part: str = '-', 
+                 length: int = 25)
+```
+
+**Аргументы:**
+- **name : mean**
+- `unit_part` (`str`): Единичная часть строкового разделителя
+- `length` (`int`): Длина строкового разделителя
+
+---
+
+##  *class* :: `DinamicDivideLine` 
+Строковый разделитель динамической длины, которая определяется длиной обрамляемого вывода команды
+
+### Конструктор
+```python
+DinamicDivideLine(unit_part: str = '-')
+```
+
+**Аргументы:**
+- **name : mean**
+- `unit_part` (`str`): Единичная часть строкового разделителя
 
 ---
 
@@ -252,7 +298,7 @@ App(prompt: str = 'Enter a command',
 
 ### Конструктор
 ```python
-Router(title: str = 'Commands group title:',
+Router(title: str | None = None,
        name: str = 'Default')
 ```
 
@@ -271,35 +317,29 @@ Router(title: str = 'Commands group title:',
 
 #### **command(command: Command)**  
 
-*param* `command: Command` **::** экземпляр класса `Command`, который определяет строковый триггер команды,
+*param* `command: Command` **::** Экземпляр класса `Command`, который определяет строковый триггер команды,
 допустимые флаги команды и другое  
 *required* **::** True  
 *example* **::** `Command(command='ssh', description='connect via ssh')`
 
-*method mean* **::** декоратор, который регистрирует функцию как обработчик команды
+*method mean* **::** Декоратор, который регистрирует функцию как обработчик команды
 
 ---
 
 #### **.get_name() -> `str`**  
 
-*method mean* **::** возвращает установленное название роутера
+*method mean* **::** Возвращает установленное название роутера
 
 ---
 
 #### **.get_title() -> `str`**  
 
-*method mean* **::** возвращает установленный заголовок группы команд данного роутера
+*method mean* **::** Возвращает установленный заголовок группы команд данного роутера
 
 ---
 
-#### **.get_all_commands() -> `list[str]`**  
-
-*method mean* **::** возвращает все зарегистрированные команды для данного роутера
-
----
 
 ### Исключения
-- `RepeatedCommandException` - Одна и та же команда зарегистрирована в одном роутере
 - `RepeatedFlagNameException` - Повторяющиеся зарегистрированные флаги в команде
 - `TooManyTransferredArgsException` - Слишком много зарегистрированных аргументов у обработчика команды
 - `RequiredArgumentNotPassedException` - Не зарегистрирован обязательный аргумент у обработчика команды(аргумент, через который будут переданы флаги введённой команды)
@@ -315,32 +355,32 @@ Router(title: str = 'Commands group title:',
 ```python
 Command(trigger: str,
         description: str = None,
-        flags: Flag | FlagsGroup = None)
+        flags: Flag | Flags = None)
 ```
 
 **Аргументы:**
 - **name : mean**
 - `trigger` (`str`): Строковый триггер
 - `description` (`str`): Описание команды, которое будет выведено в консоль при запуске оболочки
-- `flags` (`Flag | FlagsGroup`): Флаги, которые будут обработаны при их наличии во вводе юзера
+- `flags` (`Flag | Flags`): Флаги, которые будут обработаны при их наличии во вводе юзера
 
 ---
 
 #### **.get_trigger() -> `str`**  
 
-*method mean* **::** возвращает строковый триггер экземпляра
+*method mean* **::** Возвращает строковый триггер экземпляра
 
 ---
 
 #### **.get_description() -> `str`**  
 
-*method mean* **::** возвращает описание команды
+*method mean* **::** Возвращает описание команды
 
 ---
 
-#### **.get_registered_flags() -> `FlagsGroup | None`**  
+#### **.get_registered_flags() -> `Flags | None`**  
 
-*method mean* **::** возвращает зарегистрированные флаги экземпляра
+*method mean* **::** Возвращает зарегистрированные флаги экземпляра
 
 ---
 
@@ -362,18 +402,18 @@ Command(trigger: str,
 
 ### Конструктор
 ```python
-Flag(flag_name: str,
+Flag(name: str,
-     flag_prefix: typing.Literal['-', '--', '---'] = '-',
+     prefix: typing.Literal['-', '--', '---'] = '-',
-     possible_flag_values: list[str] | typing.Pattern[str] | False = True)
+     possible_values: list[str] | typing.Pattern[str] | False = True)
 ```
 
 ---
 
 **Аргументы:**
 - **name : mean**
-- `flag_name` (`str`): Имя флага
+- `name` (`str`): Имя флага
-- `flag_prefix` (`Literal['-', '--', '---']`): Префикс команды, допустимым значением является от одного до трёх минусов
+- `prefix` (`Literal['-', '--', '---']`): Префикс команды, допустимым значением является от одного до трёх минусов
-- `possible_flag_values` (`list[str] | Pattern[str] | bool`): Множество допустимых значений флага, может быть задано
+- `possible_values` (`list[str] | Pattern[str] | bool`): Множество допустимых значений флага, может быть задано
 списком с допустимыми значениями или регулярным выражением (рекомендуется `re.compile(r'example exspression')`), при значении
 аргумента `False` у введённого флага не может быть значения, иначе будет вызвано исключение и обработано соответствующим 
 еррор-хэндлером
@@ -386,30 +426,71 @@ Flag(flag_name: str,
 
 #### **.get_string_entity() -> `str`**  
 
-*method mean* **::** возвращает строковое представление флага(префикс + имя)
+*method mean* **::** Возвращает строковое представление флага(префикс + имя)
 
 ---
 
-#### **.get_flag_name() -> `str`**  
+#### **.get_name() -> `str`**  
 
-*method mean* **::** возвращает имя флага
+*method mean* **::** Возвращает имя флага
 
 ---
 
-#### **.get_flag_prefix() -> `str`**  
+#### **.get_prefix() -> `str`**  
 
-*method mean* **::** возвращает префикс флага
+*method mean* **::** Возвращает префикс флага
 
 ---
 
-##  *class* :: `FlagsGroup` 
+##  *class* :: `InputFlag` 
+Класс, экземпляры которого являются введёнными флагами команды, передаётся в хэндлер команды
+через `InputFlags`
+
+---
+
+### Примечания  
+
+- Наиболее часто используемые флаги предопределены и доступны для быстрого использования:
+`argenta.command.flag.defaults.PredeterminedFlags` 
+
+---
+
+
+### Конструктор
+```python
+InputFlag(name: str,
+         prefix: typing.Literal['-', '--', '---'] = '-',
+         value: str = None)
+```
+
+---
+
+**Аргументы:**
+- **name : mean**
+- `name` (`str`): Имя флага
+- `prefix` (`Literal['-', '--', '---']`): Префикс команды, допустимым значением является от одного до трёх минусов
+- `value` (`str`): Значение введённого флага, если оно есть
+
+---
+
+### ***methods***     
+
+---
+
+#### **.get_value() -> `str | None`**  
+
+*method mean* **::** Возвращает значение введённого флага
+
+---
+
+##  *class* :: `Flags` 
 Класс, объединяющий список флагов в один объект, используется в качестве 
 передаваемого аргумента `flags` экземпляру класса `Command`, при регистрации
 хэндлера
 
 ### Конструктор
 ```python
-FlagsGroup(*flagы: Flag)
+Flags(*flags: Flag)
 ```
 
 ---
@@ -426,7 +507,66 @@ FlagsGroup(*flagы: Flag)
 
 #### **.get_flags() -> `list[Flag]`**  
 
-*method mean* **::** возвращает зарегистрированные флаги
+*method mean* **::** Возвращает зарегистрированные флаги
+
+---
+
+#### **.add_flag(flag: Flag) -> `None`**  
+
+*method mean* **::** Добавляет флаг в группу
+
+---
+
+#### **.add_flags(flags: list[Flag]) -> `None`**  
+
+*method mean* **::** Добавляет флаги в группу
+
+---
+
+#### **.get_flag(name: str) -> `Flag | None`**  
+
+*param* `name: str` **::** Строковый триггер флага без префикса
+*required* **::** True  
+*example* **::** `'host'`
+
+*method mean* **::** Возвращает флаг по его триггеру или `None`, если флаг не найден
+
+---
+
+##  *class* :: `InputFlags` 
+Класс, объединяющий список введённых флагов в один объект, передаётся соответствующему хэндлеру
+в качестве аргумента
+
+### Конструктор
+```python
+InputFlags(*flags: Flag)
+```
+
+---
+
+**Аргументы:**
+- **name : mean**
+- `*flags` (`InputFlag`): Неограниченное количество передаваемых флагов
+
+---
+
+### ***methods***     
+
+---
+
+#### **.get_flags() -> `list[Flag]`**  
+
+*method mean* **::** Возвращает введённые флаги
+
+---
+
+#### **.get_flag(name: str) -> `InputFlag | None`**  
+
+*param* `name: str` **::** Строковый триггер флага без префикса
+*required* **::** True  
+*example* **::** `'host'`
+
+*method mean* **::** Возвращает введённый флаг по его триггеру или `None`, если флаг не найден
 
 ---
 

argenta/app/__init__.py

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

argenta/app/autocompleter/__init__.py

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

argenta/app/autocompleter/entity.py

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

argenta/app/defaults.py

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

argenta/app/dividing_line/__init__.py

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

argenta/app/dividing_line/models.py

@@ -0,0 +1,24 @@
+class BaseDividingLine:
+    def __init__(self, unit_part: str = '-'):
+        self.unit_part = unit_part
+
+    def get_unit_part(self):
+        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):
+        super().__init__(unit_part)
+        self.length = length
+
+    def get_full_line(self):
+        return f'\n[dim]{self.length * self.get_unit_part()}[/dim]\n'
+
+
+class DynamicDividingLine(BaseDividingLine):
+    def get_full_line(self, length: int):
+        return f'\n[dim]{self.get_unit_part() * length}[/dim]\n'
+
+

argenta/app/entity.py

@@ -1,261 +0,0 @@
-from typing import Callable
-from inspect import getfullargspec
-import re
-
-from ..command.entity import Command
-from ..router.entity import Router
-from ..command.exceptions import (UnprocessedInputFlagException,
-                                  RepeatedInputFlagsException,
-                                  EmptyInputCommandException)
-from .exceptions import (InvalidRouterInstanceException,
-                         InvalidDescriptionMessagePatternException,
-                         NoRegisteredRoutersException,
-                         NoRegisteredHandlersException,
-                         RepeatedCommandInDifferentRoutersException,
-                         IncorrectNumberOfHandlerArgsException)
-
-
-class App:
-    def __init__(self,
-                 prompt: str = 'Enter a command',
-                 initial_message: str = '\nHello, I am Argenta\n',
-                 farewell_message: str = '\nGoodBye\n',
-                 invalid_input_flags_message: str = 'Invalid input flags',
-                 exit_command: str = 'Q',
-                 exit_command_description: str = 'Exit command',
-                 system_points_title: str = 'System points:',
-                 ignore_exit_command_register: bool = True,
-                 ignore_command_register: bool = False,
-                 line_separate: str = '',
-                 command_group_description_separate: str = '',
-                 repeat_command_groups: bool = True,
-                 print_func: Callable[[str], None] = print) -> None:
-        self.prompt = prompt
-        self.print_func = print_func
-        self.exit_command = exit_command
-        self.exit_command_description = exit_command_description
-        self.system_points_title = system_points_title
-        self.ignore_exit_command_register = ignore_exit_command_register
-        self.farewell_message = farewell_message
-        self.initial_message = initial_message
-        self.invalid_input_flags_message = invalid_input_flags_message
-        self.line_separate = line_separate
-        self.command_group_description_separate = command_group_description_separate
-        self.ignore_command_register = ignore_command_register
-        self.repeat_command_groups = repeat_command_groups
-
-        self._routers: list[Router] = []
-        self._description_message_pattern: str = '[{command}] *=*=* {description}'
-        self._registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | Command]] | Router]] = []
-        self._invalid_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'Incorrect flag syntax: "{raw_command}"')
-        self._repeated_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'Repeated input flags: "{raw_command}"')
-        self._empty_input_command_handler: Callable[[], None] = lambda: print_func(f'Empty input command')
-        self._unknown_command_handler: Callable[[Command], None] = lambda command: print_func(f"Unknown command: {command.get_trigger()}")
-
-
-    def start_polling(self) -> None:
-        self._validate_number_of_routers()
-        self._validate_included_routers()
-        self._validate_all_router_commands()
-
-        self.print_func(self.initial_message)
-
-        if not self.repeat_command_groups:
-            self._print_command_group_description()
-            self.print_func(self.prompt)
-
-        while True:
-            if self.repeat_command_groups:
-                self._print_command_group_description()
-                self.print_func(self.prompt)
-
-            raw_command: str = input()
-
-            try:
-                input_command: Command = Command.parse_input_command(raw_command=raw_command)
-            except UnprocessedInputFlagException:
-                self.print_func(self.line_separate)
-                self._invalid_input_flags_handler(raw_command)
-                self.print_func(self.line_separate)
-
-                if not self.repeat_command_groups:
-                    self.print_func(self.prompt)
-                continue
-
-            except RepeatedInputFlagsException:
-                self.print_func(self.line_separate)
-                self._repeated_input_flags_handler(raw_command)
-                self.print_func(self.line_separate)
-
-                if not self.repeat_command_groups:
-                    self.print_func(self.prompt)
-                continue
-
-            except EmptyInputCommandException:
-                self.print_func(self.line_separate)
-                self._empty_input_command_handler()
-                self.print_func(self.line_separate)
-
-                if not self.repeat_command_groups:
-                    self.print_func(self.prompt)
-                continue
-
-            is_exit = self._is_exit_command(input_command.get_trigger())
-            if is_exit:
-                return
-
-            self.print_func(self.line_separate)
-            is_unknown_command: bool = self._check_is_command_unknown(input_command)
-
-            if is_unknown_command:
-                self.print_func(self.line_separate)
-                self.print_func(self.command_group_description_separate)
-                if not self.repeat_command_groups:
-                    self.print_func(self.prompt)
-                continue
-
-            for router in self._routers:
-                router.input_command_handler(input_command)
-
-            self.print_func(self.line_separate)
-            self.print_func(self.command_group_description_separate)
-            if not self.repeat_command_groups:
-                self.print_func(self.prompt)
-
-
-    def set_initial_message(self, message: str) -> None:
-        self.initial_message: str = message
-
-
-    def set_farewell_message(self, message: str) -> None:
-        self.farewell_message: str = message
-
-
-    def set_description_message_pattern(self, pattern: str) -> None:
-        first_check = re.match(r'.*{command}.*', pattern)
-        second_check = re.match(r'.*{description}.*', pattern)
-
-        if bool(first_check) and bool(second_check):
-            self._description_message_pattern: str = pattern
-        else:
-            raise InvalidDescriptionMessagePatternException(pattern)
-
-
-    def set_invalid_input_flags_handler(self, handler: Callable[[str], None]) -> None:
-        args = getfullargspec(handler).args
-        if len(args) != 1:
-            raise IncorrectNumberOfHandlerArgsException()
-        else:
-            self._invalid_input_flags_handler = handler
-
-
-    def set_repeated_input_flags_handler(self, handler: Callable[[str], None]) -> None:
-        args = getfullargspec(handler).args
-        if len(args) != 1:
-            raise IncorrectNumberOfHandlerArgsException()
-        else:
-            self._repeated_input_flags_handler = handler
-
-
-    def set_unknown_command_handler(self, handler: Callable[[str], None]) -> None:
-        args = getfullargspec(handler).args
-        if len(args) != 1:
-            raise IncorrectNumberOfHandlerArgsException()
-        else:
-            self._unknown_command_handler = handler
-
-
-    def set_empty_command_handler(self, handler: Callable[[str], None]) -> None:
-        args = getfullargspec(handler).args
-        if len(args) != 1:
-            raise IncorrectNumberOfHandlerArgsException()
-        else:
-            self._empty_input_command_handler = handler
-
-
-    def include_router(self, router: Router) -> None:
-        if not isinstance(router, Router):
-            raise InvalidRouterInstanceException()
-
-        router.set_ignore_command_register(self.ignore_command_register)
-        self._routers.append(router)
-
-        command_entities: list[dict[str, Callable[[], None] | Command]] = router.get_command_entities()
-        self._registered_router_entities.append({'name': router.get_name(),
-                                                 'title': router.get_title(),
-                                                 'entity': router,
-                                                 'commands': command_entities})
-
-
-    def _validate_number_of_routers(self) -> None:
-        if not self._routers:
-            raise NoRegisteredRoutersException()
-
-
-    def _validate_included_routers(self) -> None:
-        for router in self._routers:
-            if not router.get_command_entities():
-                raise NoRegisteredHandlersException(router.get_name())
-
-
-    def _validate_all_router_commands(self) -> None:
-        for idx in range(len(self._registered_router_entities)):
-            current_router: Router = self._registered_router_entities[idx]['entity']
-            routers_without_current_router = self._registered_router_entities.copy()
-            routers_without_current_router.pop(idx)
-
-            current_router_all_commands: list[str] = current_router.get_all_commands()
-
-            for router_entity in routers_without_current_router:
-                if len(set(current_router_all_commands).intersection(set(router_entity['entity'].get_all_commands()))) > 0:
-                    raise RepeatedCommandInDifferentRoutersException()
-                if self.ignore_command_register:
-                    if len(set([x.lower() for x in current_router_all_commands]).intersection(set([x.lower() for x in router_entity['entity'].get_all_commands()]))) > 0:
-                        raise RepeatedCommandInDifferentRoutersException()
-
-
-    def _is_exit_command(self, command: str):
-        if command.lower() == self.exit_command.lower():
-            if self.ignore_exit_command_register:
-                self.print_func(self.farewell_message)
-                return True
-            else:
-                if command == self.exit_command:
-                    self.print_func(self.farewell_message)
-                    return True
-        return False
-
-
-    def _check_is_command_unknown(self, command: Command):
-        registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | Command]] | Router]] = self._registered_router_entities
-        for router_entity in registered_router_entities:
-            for command_entity in router_entity['commands']:
-                if command_entity['command'].get_trigger().lower() == command.get_trigger().lower():
-                    if self.ignore_command_register:
-                        return False
-                    else:
-                        if command_entity['command'].get_trigger() == command.get_trigger():
-                            return False
-        self._unknown_command_handler(command)
-        return True
-
-
-    def _print_command_group_description(self):
-        for router_entity in self._registered_router_entities:
-            self.print_func(router_entity['title'])
-            for command_entity in router_entity['commands']:
-                self.print_func(self._description_message_pattern.format(
-                        command=command_entity['command'].get_trigger(),
-                        description=command_entity['command'].get_description()
-                    )
-                )
-            self.print_func(self.command_group_description_separate)
-
-        self.print_func(self.system_points_title)
-        self.print_func(self._description_message_pattern.format(
-                command=self.exit_command,
-                description=self.exit_command_description
-            )
-        )
-        self.print_func(self.command_group_description_separate)
-

argenta/app/exceptions.py

@@ -1,18 +1,3 @@
-class InvalidRouterInstanceException(Exception):
-    def __str__(self):
-        return "Invalid Router Instance"
-
-
-class InvalidDescriptionMessagePatternException(Exception):
-    def __init__(self, pattern: str):
-        self.pattern = pattern
-    def __str__(self):
-        return ("Invalid Description Message Pattern\n"
-                "Correct pattern example: [{command}] *=*=* {description}\n"
-                "The pattern must contain two variables: `command` and `description` - description of the command\n"
-                f"Your pattern: {self.pattern}")
-
-
 class NoRegisteredRoutersException(Exception):
     def __str__(self):
         return "No Registered Router Found"
@@ -23,13 +8,3 @@ class NoRegisteredHandlersException(Exception):
         self.router_name = router_name
     def __str__(self):
         return f"No Registered Handlers Found For '{self.router_name}'"
-
-
-class RepeatedCommandInDifferentRoutersException(Exception):
-    def __str__(self):
-        return "Commands in different handlers cannot be repeated"
-
-
-class IncorrectNumberOfHandlerArgsException(Exception):
-    def __str__(self):
-        return "Incorrect Input Flags Handler has incorrect number of arguments"

argenta/app/models.py

@@ -0,0 +1,265 @@
+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.exceptions import (NoRegisteredRoutersException,
+                                    NoRegisteredHandlersException)
+from argenta.app.registered_routers.entity import RegisteredRouters
+
+
+
+class AppInit:
+    def __init__(self,
+                 prompt: str = '[italic dim bold]What do you want to do?\n',
+                 initial_message: str = '\nArgenta\n',
+                 farewell_message: str = '\nSee you\n',
+                 exit_command: Command = Command('Q', 'Exit command'),
+                 system_points_title: str | None = 'System points:',
+                 ignore_command_register: bool = True,
+                 dividing_line: StaticDividingLine | DynamicDividingLine = StaticDividingLine(),
+                 repeat_command_groups: bool = True,
+                 override_system_messages: bool = False,
+                 autocompleter: AutoCompleter = AutoCompleter(),
+                 print_func: Callable[[str], None] = Console().print) -> None:
+        self._prompt = prompt
+        self._print_func = print_func
+        self._exit_command = exit_command
+        self._system_points_title = system_points_title
+        self._dividing_line = dividing_line
+        self._ignore_command_register = ignore_command_register
+        self._repeat_command_groups_description = repeat_command_groups
+        self._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'[bold red]{escape('['+command+']')}[/bold red] [blue dim]*=*=*[/blue dim] [bold yellow italic]{escape(description)}'
+        self._registered_routers: RegisteredRouters = RegisteredRouters()
+        self._messages_on_startup = []
+
+        self._invalid_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'[red bold]Incorrect flag syntax: {escape(raw_command)}')
+        self._repeated_input_flags_handler: Callable[[str], None] = lambda raw_command: print_func(f'[red bold]Repeated input flags: {escape(raw_command)}')
+        self._empty_input_command_handler: Callable[[], None] = lambda: print_func('[red bold]Empty input command')
+        self._unknown_command_handler: Callable[[InputCommand], None] = lambda command: print_func(f"[red bold]Unknown command: {escape(command.get_trigger())}")
+        self._exit_command_handler: Callable[[], None] = lambda: print_func(self._farewell_message)
+
+
+class AppSetters(AppInit):
+    def set_description_message_pattern(self, pattern: Callable[[str, str], str]) -> None:
+        self._description_message_gen: Callable[[str, str], str] = pattern
+
+
+    def set_invalid_input_flags_handler(self, handler: Callable[[str], None]) -> None:
+        self._invalid_input_flags_handler = handler
+
+
+    def set_repeated_input_flags_handler(self, handler: Callable[[str], None]) -> None:
+        self._repeated_input_flags_handler = handler
+
+
+    def set_unknown_command_handler(self, handler: Callable[[str], None]) -> None:
+        self._unknown_command_handler = handler
+
+
+    def set_empty_command_handler(self, handler: Callable[[], None]) -> None:
+        self._empty_input_command_handler = handler
+
+
+    def set_exit_command_handler(self, handler: Callable[[], None]) -> None:
+        self._exit_command_handler = handler
+
+
+class AppPrinters(AppInit):
+    def _print_command_group_description(self):
+        for registered_router in self._registered_routers:
+            if registered_router.get_title():
+                self._print_func(registered_router.get_title())
+            for command_handler in registered_router.get_command_handlers():
+                self._print_func(self._description_message_gen(
+                        command_handler.get_handled_command().get_trigger(),
+                        command_handler.get_handled_command().get_description()))
+            self._print_func('')
+
+
+    def _print_framed_text_with_dynamic_line(self, text: str):
+        clear_text = re.sub(r'\u001b\[[0-9;]*m', '', text)
+        max_length_line = max([len(line) for line in clear_text.split('\n')])
+        max_length_line = max_length_line if 10 <= max_length_line <= 80 else 80 if max_length_line > 80 else 10
+        self._print_func(self._dividing_line.get_full_line(max_length_line))
+        print(text.strip('\n'))
+        self._print_func(self._dividing_line.get_full_line(max_length_line))
+
+
+    def _print_framed_text(self, text: str):
+        if isinstance(self._dividing_line, StaticDividingLine):
+            self._print_func(self._dividing_line.get_full_line())
+            self._print_func(text)
+            self._print_func(self._dividing_line.get_full_line())
+        elif isinstance(self._dividing_line, DynamicDividingLine):
+            self._print_framed_text_with_dynamic_line(text)
+
+
+class AppNonStandardHandlers(AppPrinters):
+    def _is_exit_command(self, command: InputCommand):
+        if command.get_trigger().lower() == self._exit_command.get_trigger().lower():
+            if self._ignore_command_register:
+                system_router.input_command_handler(command)
+                return True
+            elif command.get_trigger() == self._exit_command.get_trigger():
+                system_router.input_command_handler(command)
+                return True
+        return False
+
+
+    def _is_unknown_command(self, command: InputCommand):
+        for router_entity in self._registered_routers:
+            for command_handler in router_entity.get_command_handlers():
+                handled_command_trigger = command_handler.get_handled_command().get_trigger()
+                handled_command_aliases = command_handler.get_handled_command().get_aliases()
+                if handled_command_trigger.lower() == command.get_trigger().lower() and self._ignore_command_register:
+                    return False
+                elif handled_command_trigger == command.get_trigger():
+                    return False
+                elif handled_command_aliases:
+                    if (command.get_trigger().lower() in [x.lower() for x in handled_command_aliases]) and self._ignore_command_register:
+                        return False
+                    elif command.get_trigger() in handled_command_trigger:
+                        return False
+        if isinstance(self._dividing_line, StaticDividingLine):
+            self._print_func(self._dividing_line.get_full_line())
+            self._unknown_command_handler(command)
+            self._print_func(self._dividing_line.get_full_line())
+        elif isinstance(self._dividing_line, DynamicDividingLine):
+            with redirect_stdout(io.StringIO()) as f:
+                self._unknown_command_handler(command)
+                res: str = f.getvalue()
+            self._print_framed_text_with_dynamic_line(res)
+        return True
+
+
+    def _error_handler(self, error: BaseInputCommandException, raw_command: str) -> None:
+        match error:
+            case UnprocessedInputFlagException():
+                self._invalid_input_flags_handler(raw_command)
+            case RepeatedInputFlagsException():
+                self._repeated_input_flags_handler(raw_command)
+            case EmptyInputCommandException():
+                self._empty_input_command_handler()
+
+
+class AppValidators(AppInit):
+    def _validate_number_of_routers(self) -> None:
+        if not self._registered_routers:
+            raise NoRegisteredRoutersException()
+
+
+    def _validate_included_routers(self) -> None:
+        for router in self._registered_routers:
+            if not router.get_command_handlers():
+                raise NoRegisteredHandlersException(router.get_name())
+
+
+class AppSetups(AppValidators, AppPrinters):
+    def _setup_system_router(self):
+        system_router.set_title(self._system_points_title)
+
+        @system_router.command(self._exit_command)
+        def exit_command():
+            self._exit_command_handler()
+
+        if system_router not in self._registered_routers.get_registered_routers():
+            system_router.set_ignore_command_register(self._ignore_command_register)
+            self._registered_routers.add_registered_router(system_router)
+
+    def _setup_default_view(self):
+        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')
+
+    def _pre_cycle_setup(self):
+        self._setup_default_view()
+        self._setup_system_router()
+        self._validate_number_of_routers()
+        self._validate_included_routers()
+
+        all_triggers: list[str] = []
+        for router_entity in self._registered_routers:
+            all_triggers.extend(router_entity.get_triggers())
+            all_triggers.extend(router_entity.get_aliases())
+        self._autocompleter.initial_setup(all_triggers)
+
+        self._print_func(self._initial_message)
+
+        for message in self._messages_on_startup:
+            self._print_func(message)
+        print('\n\n')
+
+        if not self._repeat_command_groups_description:
+            self._print_command_group_description()
+
+
+class App(AppSetters, AppNonStandardHandlers, AppSetups):
+    def start_polling(self) -> None:
+        self._pre_cycle_setup()
+        while True:
+            if self._repeat_command_groups_description:
+                self._print_command_group_description()
+
+            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):
+                self._autocompleter.exit_setup()
+                return
+
+            if self._is_unknown_command(input_command):
+                continue
+
+            with redirect_stdout(io.StringIO()) as f:
+                for registered_router in self._registered_routers:
+                    registered_router.input_command_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:
+        router.set_ignore_command_register(self._ignore_command_register)
+        self._registered_routers.add_registered_router(router)
+
+
+    def include_routers(self, *routers: Router) -> None:
+        for router in routers:
+            self.include_router(router)
+
+
+    def add_message_on_startup(self, message: str) -> None:
+        self._messages_on_startup.append(message)
+

argenta/app/registered_routers/entity.py

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

argenta/command/__init__.py

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

argenta/command/entity.py

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

argenta/command/exceptions.py

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

argenta/command/flag/__init__.py

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

argenta/command/flag/defaults.py

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

argenta/command/flag/entity.py

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

argenta/command/flag/flags_group/__init__.py

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

argenta/command/flag/flags_group/entity.py

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

argenta/command/flag/models.py

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

argenta/command/models.py

@@ -0,0 +1,112 @@
+from argenta.command.flag.models import Flag, InputFlag, Flags, InputFlags
+from argenta.command.exceptions import (UnprocessedInputFlagException,
+                                         RepeatedInputFlagsException,
+                                         EmptyInputCommandException)
+from typing import Generic, TypeVar, cast, Literal
+
+
+InputCommandType = TypeVar('InputCommandType')
+
+
+class BaseCommand:
+    def __init__(self, trigger: str):
+        self._trigger = trigger
+
+    def get_trigger(self) -> str:
+        return self._trigger
+
+
+class Command(BaseCommand):
+    def __init__(self, trigger: str,
+                 description: str = None,
+                 flags: Flag | Flags = None,
+                 aliases: list[str] = None):
+        super().__init__(trigger)
+        self._registered_flags: Flags = flags if isinstance(flags, Flags) else Flags(flags) if isinstance(flags, Flag) else Flags()
+        self._description = f'Description for "{self._trigger}" command' if not description else description
+        self._aliases = aliases
+
+    def get_registered_flags(self) -> Flags:
+        return self._registered_flags
+
+    def get_aliases(self) -> list[str] | None:
+        return self._aliases
+
+    def validate_input_flag(self, flag: InputFlag):
+        registered_flags: Flags | None = self.get_registered_flags()
+        if registered_flags:
+            if isinstance(registered_flags, Flag):
+                if registered_flags.get_string_entity() == flag.get_string_entity():
+                    is_valid = registered_flags.validate_input_flag_value(flag.get_value())
+                    if is_valid:
+                        return True
+            else:
+                for registered_flag in registered_flags:
+                    if registered_flag.get_string_entity() == flag.get_string_entity():
+                        is_valid = registered_flag.validate_input_flag_value(flag.get_value())
+                        if is_valid:
+                            return True
+        return False
+
+    def get_description(self) -> str:
+        return self._description
+
+
+
+class InputCommand(BaseCommand, Generic[InputCommandType]):
+    def __init__(self, trigger: str,
+                 input_flags: InputFlag | InputFlags = None):
+        super().__init__(trigger)
+        self._input_flags: InputFlags = input_flags if isinstance(input_flags, InputFlags) else InputFlags(input_flags) if isinstance(input_flags, InputFlag) else InputFlags()
+
+    def _set_input_flags(self, input_flags: InputFlags):
+        self._input_flags = input_flags
+
+    def get_input_flags(self) -> InputFlags:
+        return self._input_flags
+
+
+    @staticmethod
+    def parse(raw_command: str) -> InputCommandType:
+        if not raw_command:
+            raise EmptyInputCommandException()
+
+        list_of_tokens = raw_command.split()
+        command = list_of_tokens.pop(0)
+
+        input_flags: InputFlags = InputFlags()
+        current_flag_name, current_flag_value = None, None
+
+        for k, _ in enumerate(list_of_tokens):
+            if _.startswith('-'):
+                if current_flag_name or len(_) < 2 or len(_[:_.rfind('-')]) > 3:
+                    raise UnprocessedInputFlagException()
+                current_flag_name = _
+            else:
+                if not current_flag_name:
+                    raise UnprocessedInputFlagException()
+                current_flag_value = _
+
+            if current_flag_name:
+                if not len(list_of_tokens) == k+1:
+                    if not list_of_tokens[k+1].startswith('-'):
+                        continue
+
+                input_flag = InputFlag(name=current_flag_name[current_flag_name.rfind('-')+1:],
+                                       prefix=cast(Literal['-', '--', '---'],
+                                                   current_flag_name[:current_flag_name.rfind('-')+1]),
+                                       value=current_flag_value)
+
+                all_flags = [flag.get_string_entity() for flag in input_flags.get_flags()]
+                if input_flag.get_string_entity() not in all_flags:
+                    input_flags.add_flag(input_flag)
+                else:
+                    raise RepeatedInputFlagsException(input_flag)
+
+                current_flag_name, current_flag_value = None, None
+
+        if any([current_flag_name, current_flag_value]):
+            raise UnprocessedInputFlagException()
+        else:
+            return InputCommand(trigger=command, input_flags=input_flags)
+

argenta/router/__init__.py

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

argenta/router/command_handler/entity.py

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

argenta/router/command_handlers/entity.py

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

argenta/router/defaults.py

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

argenta/router/entity.py

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

argenta/router/exceptions.py

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

mock/default_mock_app/main.py

@@ -0,0 +1,9 @@
+from argenta.app import App
+from argenta.app.defaults import PredeterminedMessages
+
+
+app = App(repeat_command_groups=True)
+
+app.add_message_on_startup(PredeterminedMessages.USAGE + '\n\n')
+
+app.start_polling()

mock/local_test.py

@@ -1,7 +1,14 @@
-import re
+from argenta.app import App
+from argenta.command import Command
+from argenta.router import Router
 
+router = Router()
 
-def test(string):
+@router.command(Command('test'))
-    return bool(re.match(r'\ntest command\n(.|\s)*\nsome command\n', string))
+def test():
+    print('test command')
 
-print(test('test command tpgm4tigm4tigmt\n i0hhmi6h some command'))
+app = App(ignore_command_register=False)
+app.include_router(router)
+app.set_unknown_command_handler(lambda command: print(f'Unknown command: {command.get_trigger()}'))
+app.start_polling()

mock/mock_app/handlers/routers.py

@@ -1,38 +1,35 @@
-import re
-from pprint import pprint
 from rich.console import Console
 
 from argenta.command import Command
-from argenta.command.flag import Flag, FlagsGroup
+from argenta.command.flag import Flags, InputFlags
-from argenta.command.flag.defaults import DefaultFlags
+from argenta.command.flag.defaults import PredeterminedFlags
 from argenta.router import Router
 from .handlers_implementation.help_command import help_command
 
 
-work_router: Router = Router(title='Work nts:')
+work_router: Router = Router(title='Work points:')
-work_router.set_invalid_input_flag_handler(lambda flag: print(f'Invalid input flag: {flag.get_string_entity()} {flag.get_value() if flag.get_value() else ''}'))
-
-settings_router: Router = Router(title='Settings points:')
 
+settings_router: Router = Router()
 
 console = Console()
 
 
-@work_router.command(Command(trigger='0', description='Get Help'))
+@work_router.command(Command('get', 'Get Help', aliases=['help', 'Get_help']))
 def command_help():
     help_command()
 
 
-@work_router.command(Command(trigger='P', description='Start Solving', flags=FlagsGroup(DefaultFlags.host_flag, DefaultFlags.port_flag)))
+@work_router.command(Command('start', 'Start Solving',
-def command_start_solving(args: dict):
+                             flags=Flags(PredeterminedFlags.HOST, PredeterminedFlags.PORT),
-    print('Solving...')
+                             aliases=['starting']))
-    pprint(args)
+def command_start_solving(args: InputFlags):
-    #start_solving_command()
+    print(args.get_flag('host'))
 
 
-@settings_router.command(Command(trigger='G', description='Update WordMath'))
+@settings_router.command(Command('update', 'Update WordMath'))
 def command_update():
-    print('Command update')
+    print('eeeeeee')
+
 
 
 

mock/mock_app/main.py

@@ -1,35 +1,22 @@
 from mock.mock_app.handlers.routers import work_router, settings_router
-from art import text2art
-from rich.console import Console
 
 from argenta.app import App
+from argenta.app.defaults import PredeterminedMessages
+from argenta.app.dividing_line import DynamicDividingLine
+from argenta.app.autocompleter import AutoCompleter
 
-app: App = App(prompt='[italic white bold]What do you want to do(enter number of action)?',
+
-               line_separate=f'\n{"[bold green]-[/bold green][bold red]-[/bold red]"*25}\n',
+autocompleter = AutoCompleter('./mock/.hist')
-               print_func=Console().print,
+app: App = App(dividing_line=DynamicDividingLine(),
-               command_group_description_separate='',
+               autocompleter=autocompleter)
-               repeat_command_groups=True,
-               ignore_exit_command_register=False)
 
 
 def main():
-    ascii_name: str = text2art('WordMath', font='nancyj')
+    app.include_routers(work_router, settings_router)
-    initial_greeting: str = f'[bold red]\n\n{ascii_name}'
 
-    ascii_goodbye_message: str = text2art('GoodBye', font='small')
+    app.add_message_on_startup(PredeterminedMessages.USAGE)
-    goodbye_message: str = f'[bold red]\n{ascii_goodbye_message}{' '*12}made by kolo\n'
+    app.add_message_on_startup(PredeterminedMessages.AUTOCOMPLETE)
-
+    app.add_message_on_startup(PredeterminedMessages.HELP)
-    app.include_router(work_router)
-    app.include_router(settings_router)
-
-    app.set_initial_message(initial_greeting)
-    app.set_farewell_message(goodbye_message)
-
-    app.set_invalid_input_flags_handler(lambda raw_command: print(f"Invalid input flags: {raw_command}"))
-    app.set_unknown_command_handler(lambda command: print(f"Unknown command: {command.get_trigger()}"))
-    app.set_repeated_input_flags_handler(lambda raw_command: print(f"Repeated input flags: {raw_command}"))
-
-    app.set_description_message_pattern('[bold red][{command}][/bold red] [blue]*=*=*[/blue] [bold yellow italic]{description}')
 
     app.start_polling()
 

pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "argenta"
-version = "0.4.0"
+version = "0.5.0"
-description = "python library for creating custom shells"
+description = "Python library for creating TUI"
 authors = [
     {name = "kolo", email = "kolo.is.main@gmail.com"}
 ]
 license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.11"
-dependencies = [] # no dependencies
+dependencies = ["rich (>=14.0.0,<15.0.0)", "art (>=6.4,<7.0)"]
 
 
 [tool.ruff]
@@ -27,11 +27,5 @@ requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.group.dev.dependencies]
-art = "^6.4"
-rich = "^13.9.4"
-numpy = "^2.2.2"
-word2number = "^1.1"
-numexpr = "^2.10.2"
-requests = "^2.32.3"
 pyreadline3 = "^3.5.4"
 

tests/system_tests/test_system_handling_non_standard_behavior.py

@@ -7,8 +7,8 @@ import re
 from argenta.app import App
 from argenta.command import Command
 from argenta.router import Router
-from argenta.command.flag import Flag, FlagsGroup
+from argenta.command.flag.models import Flags, InputFlags
-from argenta.command.flag.defaults import DefaultFlags
+from argenta.command.flag.defaults import PredeterminedFlags
 
 
 
@@ -22,8 +22,10 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print('test command')
 
-        app = App()
+        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.start_polling()
 
         output = mock_stdout.getvalue()
@@ -31,7 +33,7 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         self.assertIn("\nUnknown command: help\n", output)
 
 
-    @patch("builtins.input", side_effect=["TeSt", "q"])
+    @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()
@@ -40,8 +42,11 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print('test command')
 
-        app = App(ignore_command_register=False)
+        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.start_polling()
 
         output = mock_stdout.getvalue()
@@ -58,7 +63,8 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print(f'test command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -76,7 +82,8 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print('test command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -89,13 +96,14 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
     @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 = FlagsGroup(DefaultFlags.host_flag)
+        flags = Flags(PredeterminedFlags.HOST)
 
         @router.command(Command('test', flags=flags))
-        def test(args: dict):
+        def test(args: InputFlags):
-            print(f'connecting to host {args["host"]["value"]}')
+            print(f'connecting to host {args.get_flag('host').get_value()}')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -113,13 +121,15 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print(f'test command')
 
-        app = App()
+        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.start_polling()
 
         output = mock_stdout.getvalue()
 
-        self.assertRegex(output, re.compile(r'\ntest command\n(.|\n)*\nUnknown command: some\n'))
+        self.assertRegex(output, re.compile(r'\ntest command\n(.|\n)*\nUnknown command: some'))
 
 
     @patch("builtins.input", side_effect=["test", "some", "more", "q"])
@@ -135,8 +145,10 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print(f'more command')
 
-        app = App()
+        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.start_polling()
 
         output = mock_stdout.getvalue()
@@ -153,8 +165,10 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print(f'test command')
 
-        app = App()
+        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.start_polling()
 
         output = mock_stdout.getvalue()
@@ -171,8 +185,10 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print(f'test command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
+        app.set_empty_command_handler(lambda: print('Empty input command'))
         app.start_polling()
 
         output = mock_stdout.getvalue()
@@ -185,14 +201,16 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
     def test_input_correct_command_with_repeated_flags(self, mock_stdout: _io.StringIO, magick_mock: MagicMock):
         router = Router()
 
-        @router.command(Command('test', flags=DefaultFlags.port_flag))
+        @router.command(Command('test', flags=PredeterminedFlags.PORT))
-        def test(args):
+        def test(args: InputFlags):
             print('test command')
 
-        app = App()
+        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.start_polling()
 
         output = mock_stdout.getvalue()
 
-        self.assertIn("\nRepeated input flags: \"test --port 22 --port 33\"", output)
+        self.assertIn("\nRepeated input flags: \"test --port 22 --port 33\"\n", output)

tests/system_tests/test_system_handling_normal_behavior.py

@@ -5,10 +5,10 @@ import io
 import re
 
 from argenta.app import App
-from argenta.command import Command
+from argenta.command.models import Command
 from argenta.router import Router
-from argenta.command.flag import Flag, FlagsGroup
+from argenta.command.flag.models import Flag, Flags, InputFlags
-from argenta.command.flag.defaults import DefaultFlags
+from argenta.command.flag.defaults import PredeterminedFlags
 
 
 
@@ -22,7 +22,8 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print('test command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -40,7 +41,9 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print('test command')
 
-        app = App(ignore_command_register=True)
+        app = App(ignore_command_register=True,
+                  override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -56,10 +59,11 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         flag = Flag('help', '--', False)
 
         @router.command(Command('test', flags=flag))
-        def test(args: dict):
+        def test(args: InputFlags):
-            print(f'\nhelp for {args['help']['name']} flag\n')
+            print(f'\nhelp for {args.get_flag('help').get_name()} flag\n')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -74,10 +78,11 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         flag = Flag('port', '--', re.compile(r'^\d{1,5}$'))
 
         @router.command(Command('test', flags=flag))
-        def test(args: dict):
+        def test(args: InputFlags):
-            print(f'flag value for {args['port']['name']} flag : {args["port"]["value"]}')
+            print(f'flag value for {args.get_flag('port').get_name()} flag : {args.get_flag('port').get_value()}')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -90,13 +95,14 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
     @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 = DefaultFlags.short_help_flag
+        flag = PredeterminedFlags.SHORT_HELP
 
         @router.command(Command('test', flags=flag))
-        def test(args: dict):
+        def test(args: InputFlags):
-            print(f'help for {args['h']['name']} flag')
+            print(f'help for {args.get_flag('h').get_name()} flag')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -109,14 +115,15 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
     @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 = DefaultFlags.info_flag
+        flag = PredeterminedFlags.INFO
 
         @router.command(Command('test', flags=flag))
-        def test(args: dict):
+        def test(args: InputFlags):
-            if args.get('info'):
+            if args.get_flag('info'):
                 print('info about test command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -129,13 +136,14 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
     @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 = DefaultFlags.host_flag
+        flag = PredeterminedFlags.HOST
 
         @router.command(Command('test', flags=flag))
-        def test(args: dict):
+        def test(args: InputFlags):
-            print(f'connecting to host {args["host"]["value"]}')
+            print(f'connecting to host {args[0].get_value()}')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -148,13 +156,14 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
     @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 = FlagsGroup(DefaultFlags.host_flag, DefaultFlags.port_flag)
+        flags = Flags(PredeterminedFlags.HOST, PredeterminedFlags.PORT)
 
         @router.command(Command('test', flags=flags))
-        def test(args: dict):
+        def test(args: InputFlags):
-            print(f'connecting to host {args["host"]["value"]} and port {args["port"]["value"]}')
+            print(f'connecting to host {args[0].get_value()} and port {args[1].get_value()}')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -173,10 +182,11 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
             print(f'test command')
 
         @router.command(Command('some'))
-        def test():
+        def test2():
             print(f'some command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 
@@ -202,7 +212,8 @@ class TestSystemHandlerNormalWork(unittest.TestCase):
         def test():
             print(f'more command')
 
-        app = App()
+        app = App(override_system_messages=True,
+                  print_func=print)
         app.include_router(router)
         app.start_polling()
 

tests/unit_tests/test_app.py

@@ -1,20 +0,0 @@
-from argenta.app import App
-from argenta.app.exceptions import (InvalidDescriptionMessagePatternException,
-                                    NoRegisteredRoutersException)
-
-import unittest
-
-
-class TestApp(unittest.TestCase):
-    def test_set_invalid_description_message_pattern(self):
-        with self.assertRaises(InvalidDescriptionMessagePatternException):
-            App().set_description_message_pattern('Invalid description pattern')
-
-    def test_set_invalid_description_message_pattern2(self):
-        with self.assertRaises(InvalidDescriptionMessagePatternException):
-            App().set_description_message_pattern('Invalid {desription} description {comand} pattern')
-
-    def test_no_registered_router(self):
-        with self.assertRaises(NoRegisteredRoutersException):
-            App()._validate_number_of_routers()
-

tests/unit_tests/test_command.py

@@ -1,4 +1,4 @@
-from argenta.command import Command
+from argenta.command.models import InputCommand
 from argenta.command.exceptions import (UnprocessedInputFlagException,
                                         RepeatedInputFlagsException,
                                         EmptyInputCommandException)
@@ -6,22 +6,19 @@ from argenta.command.exceptions import (UnprocessedInputFlagException,
 import unittest
 
 
-class TestCommand(unittest.TestCase):
+class TestInputCommand(unittest.TestCase):
     def test_parse_correct_raw_command(self):
-        self.assertEqual(Command.parse_input_command('ssh --host 192.168.0.3').get_trigger(), 'ssh')
+        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):
-            Command.parse_input_command('ssh 192.168.0.3')
+            InputCommand.parse('ssh 192.168.0.3')
 
     def test_parse_raw_command_with_repeated_flag_name(self):
         with self.assertRaises(RepeatedInputFlagsException):
-            Command.parse_input_command('ssh --host 192.168.0.3 --host 172.198.0.43')
+            InputCommand.parse('ssh --host 192.168.0.3 --host 172.198.0.43')
 
     def test_parse_empty_raw_command(self):
         with self.assertRaises(EmptyInputCommandException):
-            Command.parse_input_command('')
+            InputCommand.parse('')
-
-    def test_get_command_description(self):
-        self.assertEqual(Command(trigger='test', description='test description').get_description(), 'test description')
 

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_line().count('-'), 25)
+
+    def test_get_dynamic_dividing_line_full_line(self):
+        line = DynamicDividingLine()
+        self.assertEqual(line.get_full_line(20).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

@@ -1,4 +1,4 @@
-from argenta.command.flag import Flag
+from argenta.command.flag.models import Flag, InputFlag
 
 import unittest
 import re
@@ -6,66 +6,66 @@ import re
 
 class TestFlag(unittest.TestCase):
     def test_get_string_entity(self):
-        self.assertEqual(Flag(flag_name='test').get_string_entity(),
+        self.assertEqual(Flag(name='test').get_string_entity(),
                          '--test')
 
     def test_get_string_entity2(self):
-        self.assertEqual(Flag(flag_name='test',
+        self.assertEqual(Flag(name='test',
-                              flag_prefix='---').get_string_entity(),
+                              prefix='---').get_string_entity(),
                          '---test')
 
     def test_get_flag_name(self):
-        self.assertEqual(Flag(flag_name='test').get_flag_name(),
+        self.assertEqual(Flag(name='test').get_name(),
                          'test')
 
     def test_get_flag_prefix(self):
-        self.assertEqual(Flag(flag_name='test').get_flag_prefix(),
+        self.assertEqual(Flag(name='test').get_prefix(),
                          '--')
 
     def test_get_flag_prefix2(self):
-        self.assertEqual(Flag(flag_name='test',
+        self.assertEqual(Flag(name='test',
-                              flag_prefix='--').get_flag_prefix(),
+                              prefix='--').get_prefix(),
                          '--')
 
     def test_get_flag_value_without_set(self):
-        self.assertEqual(Flag(flag_name='test').get_value(),
+        self.assertEqual(InputFlag(name='test').get_value(),
                          None)
 
     def test_get_flag_value_with_set(self):
-        flag = Flag(flag_name='test')
+        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(flag_name='test', possible_flag_values=['1', '2', '3'])
+        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(flag_name='test', possible_flag_values=['1', '2', '3'])
+        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(flag_name='test', possible_flag_values=re.compile(r'192.168.\d+.\d+'))
+        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(flag_name='test', possible_flag_values=re.compile(r'192.168.\d+.\d+'))
+        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(flag_name='test', possible_flag_values=False)
+        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(flag_name='test', possible_flag_values=True)
+        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(flag_name='test', possible_flag_values=False)
+        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(flag_name='test', possible_flag_values=True)
+        flag = Flag(name='test', possible_values=True)
         self.assertEqual(flag.validate_input_flag_value('random value'), True)
 
 

tests/unit_tests/test_flagsgroup.py

@@ -1,11 +1,11 @@
-from argenta.command.flag import Flag, FlagsGroup
+from argenta.command.flag.models import Flag, Flags
 
 import unittest
 
 
-class TestFlagsGroup(unittest.TestCase):
+class TestFlags(unittest.TestCase):
     def test_get_flags(self):
-        flags = FlagsGroup()
+        flags = Flags()
         list_of_flags = [
             Flag('test1'),
             Flag('test2'),
@@ -16,34 +16,11 @@ class TestFlagsGroup(unittest.TestCase):
                          list_of_flags)
 
     def test_add_flag(self):
-        flags = FlagsGroup()
+        flags = Flags()
         flags.add_flag(Flag('test'))
         self.assertEqual(len(flags.get_flags()), 1)
 
     def test_add_flags(self):
-        flags = FlagsGroup()
+        flags = Flags()
         flags.add_flags([Flag('test'), Flag('test2')])
         self.assertEqual(len(flags.get_flags()), 2)
-
-    def test_unparse_flags_to_dict(self):
-        list_of_flags = [
-            Flag('test1'),
-            Flag('test2'),
-            Flag('test3'),
-        ]
-        flags = FlagsGroup(*list_of_flags)
-        serialized_flags = flags.unparse_to_dict()
-        needed_result = {'test1': {'name': 'test1',
-                                   'prefix': '--',
-                                   'string_entity': '--test1',
-                                   'value': None},
-                         'test2': {'name': 'test2',
-                                   'prefix': '--',
-                                   'string_entity': '--test2',
-                                   'value': None},
-                         'test3': {'name': 'test3',
-                                   'prefix': '--',
-                                   'string_entity': '--test3',
-                                   'value': None}}
-
-        self.assertDictEqual(serialized_flags, needed_result)

tests/unit_tests/test_router.py

@@ -1,7 +1,6 @@
-from argenta.command.flag import FlagsGroup, Flag
 from argenta.router import Router
 from argenta.command import Command
-from argenta.router.exceptions import RepeatedCommandException, TriggerCannotContainSpacesException
+from argenta.router.exceptions import TriggerCannotContainSpacesException
 
 import unittest
 
@@ -13,102 +12,6 @@ class TestRouter(unittest.TestCase):
     def test_get_router_title(self):
         self.assertEqual(Router(title='test title').get_title(), 'test title')
 
-    def test_input_correct_command(self):
-        router = Router()
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        self.assertEqual(router.input_command_handler(Command(trigger='test')), 'correct result')
-
-    def test_input_command_with_invalid_flag(self):
-        router = Router()
-        router.set_invalid_input_flag_handler(lambda x: x)
-
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        input_command = Command(trigger='test')
-        input_command._set_input_flags(FlagsGroup([Flag('host')]))
-
-        self.assertEqual(router.input_command_handler(input_command), None)
-
-    def test_input_correct_command_with_one_register_and_ignore_command_register(self):
-        router = Router()
-        router.set_ignore_command_register(True)
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        self.assertEqual(router.input_command_handler(Command(trigger='test')), 'correct result')
-
-    def test_input_correct_command_with_different_register_and_ignore_command_register(self):
-        router = Router()
-        router.set_ignore_command_register(True)
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        self.assertEqual(router.input_command_handler(Command(trigger='TeSt')), 'correct result')
-
-    def test_input_incorrect_command_with_ignore_command_register(self):
-        router = Router()
-        router.set_ignore_command_register(True)
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        self.assertEqual(router.input_command_handler(Command(trigger='Test2')), None)
-
-    def test_register_repeated_commands_with_one_register(self):
-        router = Router()
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        with self.assertRaises(RepeatedCommandException):
-            @router.command(Command(trigger='test'))
-            def test():
-                return 'correct result'
-
-    def test_register_commands_with_different_register(self):
-        router = Router()
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        try:
-            @router.command(Command(trigger='Test'))
-            def test():
-                return 'correct result'
-        except RepeatedCommandException:
-            self.fail('RepeatedCommandException should not have been thrown')
-
-    def test_register_repeated_commands_with_one_register_and_set_ignore_command_register(self):
-        router = Router()
-        router.set_ignore_command_register(True)
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        with self.assertRaises(RepeatedCommandException):
-            @router.command(Command(trigger='test'))
-            def test():
-                return 'correct result'
-
-    def test_register_repeated_commands_with_different_register_and_set_ignore_command_register(self):
-        router = Router()
-        router.set_ignore_command_register(True)
-        @router.command(Command(trigger='test'))
-        def test():
-            return 'correct result'
-
-        with self.assertRaises(RepeatedCommandException):
-            @router.command(Command(trigger='Test'))
-            def test():
-                return 'correct result'
-
     def test_register_command_with_spaces_in_trigger(self):
         router = Router()
         with self.assertRaises(TriggerCannotContainSpacesException):