argenta 0.1.2__tar.gz → 0.2.0__tar.gz

{argenta-0.1.2 → argenta-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: argenta
-Version: 0.1.2
+Version: 0.2.0
 Summary: python library for creating cli apps
 License: MIT
 Author: kolo

argenta-0.2.0/argenta/app/entity.py

@@ -0,0 +1,200 @@
+from typing import Callable
+from ..router.entity import Router
+from .exceptions import (InvalidRouterInstanceException,
+                         InvalidDescriptionMessagePatternException,
+                         OnlyOneMainRouterIsAllowedException,
+                         MissingMainRouterException,
+                         MissingHandlersForUnknownCommandsOnMainRouterException,
+                         HandlerForUnknownCommandsCanOnlyBeDeclaredForMainRouterException,
+                         NoRegisteredRoutersException,
+                         NoRegisteredHandlersException,
+                         RepeatedCommandInDifferentRoutersException)
+
+
+class App:
+    def __init__(self,
+                 prompt: str = 'Enter a command',
+                 exit_command: str = 'q',
+                 ignore_exit_command_register: bool = True,
+                 initial_greeting: str = '\nHello, I am Argenta\n',
+                 farewell_message: str = '\nGoodBye\n',
+                 line_separate: str = '',
+                 command_group_description_separate: str = '',
+                 ignore_command_register: bool = False,
+                 print_func: Callable[[str], None] = print) -> None:
+        self.prompt = prompt
+        self.print_func = print_func
+        self.exit_command = exit_command
+        self.ignore_exit_command_register = ignore_exit_command_register
+        self.farewell_message = farewell_message
+        self.initial_greeting = initial_greeting
+        self.line_separate = line_separate
+        self.command_group_description_separate = command_group_description_separate
+        self.ignore_command_register = ignore_command_register
+
+        self._routers: list[Router] = []
+        self._registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | str]] | Router]] = []
+        self._app_main_router: Router | None = None
+        self._description_message_pattern: str = '[{command}] *=*=* {description}'
+
+
+    def start_polling(self) -> None:
+        self._validate_number_of_routers()
+        self._validate_included_routers()
+        self._validate_main_router()
+        self._validate_all_router_commands()
+
+        self.print_func(self.initial_greeting)
+
+        while True:
+            self._print_command_group_description()
+            self.print_func(self.prompt)
+
+            command: str = input()
+
+            self._checking_command_for_exit_command(command)
+            self.print_func(self.line_separate)
+
+            is_unknown_command: bool = self._check_is_command_unknown(command)
+            if is_unknown_command:
+                continue
+
+            for router in self._routers:
+                router.input_command_handler(command)
+
+            self.print_func(self.line_separate)
+            self.print_func(self.command_group_description_separate)
+
+
+    def set_initial_greeting(self, greeting: str) -> None:
+        self.initial_greeting: str = greeting
+
+
+    def set_farewell_message(self, message: str) -> None:
+        self.farewell_message: str = message
+
+
+    def set_description_message_pattern(self, pattern: str) -> None:
+        try:
+            pattern.format(command='command',
+                           description='description')
+        except KeyError:
+            raise InvalidDescriptionMessagePatternException(pattern)
+        self._description_message_pattern: str = pattern
+
+
+    def get_main_router(self) -> Router:
+        return self._app_main_router
+
+
+    def get_all_app_commands(self) -> list[str]:
+        all_commands: list[str] = []
+        for router in self._routers:
+            all_commands.extend(router.get_all_commands())
+
+        return all_commands
+
+
+    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_main_router(self):
+        if not self._app_main_router:
+            if len(self._routers) > 1:
+                raise MissingMainRouterException()
+            else:
+                router = self._routers[0]
+                router.set_router_as_main()
+                self._app_main_router = router
+
+        if not self._app_main_router.unknown_command_func:
+            raise MissingHandlersForUnknownCommandsOnMainRouterException()
+
+        for router in self._routers:
+            if router.unknown_command_func and self._app_main_router is not router:
+                raise HandlerForUnknownCommandsCanOnlyBeDeclaredForMainRouterException()
+
+
+    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 _checking_command_for_exit_command(self, command: str):
+        if command.lower() == self.exit_command.lower():
+            if self.ignore_exit_command_register:
+                self.print_func(self.farewell_message)
+                exit(0)
+            else:
+                if command == self.exit_command:
+                    self.print_func(self.farewell_message)
+                    exit(0)
+
+
+    def _check_is_command_unknown(self, command: str):
+        registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | str]] | Router]] = self._registered_router_entities
+        for router_entity in registered_router_entities:
+            for command_entity in router_entity['commands']:
+                if command_entity['command'].lower() == command.lower():
+                    if self.ignore_command_register:
+                        return False
+                    else:
+                        if command_entity['command'] == command:
+                            return False
+        self._app_main_router.unknown_command_handler(command)
+        self.print_func(self.line_separate)
+        self.print_func(self.command_group_description_separate)
+        return True
+
+
+    def _print_command_group_description(self):
+        for router_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'],
+                        description=command_entity['description']
+                    )
+                )
+            self.print_func(self.command_group_description_separate)
+
+
+    def include_router(self, router: Router, is_main: True | False = False) -> None:
+        if not isinstance(router, Router):
+            raise InvalidRouterInstanceException()
+
+        if is_main:
+            if not self._app_main_router:
+                self._app_main_router = router
+                router.set_router_as_main()
+            else:
+                raise OnlyOneMainRouterIsAllowedException(self._app_main_router.get_name())
+
+        router.set_ignore_command_register(self.ignore_command_register)
+        self._routers.append(router)
+
+        command_entities: list[dict[str, Callable[[], None] | str]] = router.get_command_entities()
+        self._registered_router_entities.append({'name': router.get_name(),
+                                                 'title': router.get_title(),
+                                                 'entity': router,
+                                                 'commands': command_entities})
+

{argenta-0.1.2 → argenta-0.2.0}/argenta/app/exceptions.py

@@ -37,3 +37,20 @@ class MissingHandlersForUnknownCommandsOnMainRouterException(Exception):
 class HandlerForUnknownCommandsCanOnlyBeDeclaredForMainRouterException(Exception):
     def __str__(self):
         return '\nThe handler for unknown commands can only be declared for the main router'
+
+
+class NoRegisteredRoutersException(Exception):
+    def __str__(self):
+        return "No Registered Router Found"
+
+
+class NoRegisteredHandlersException(Exception):
+    def __init__(self, router_name):
+        self.router_name = router_name
+    def __str__(self):
+        return f"No Registered Handlers Found For '{self.router_name}'"
+
+
+class RepeatedCommandInDifferentRoutersException(Exception):
+    def __str__(self):
+        return "Commands in different handlers cannot be repeated"

argenta-0.2.0/argenta/router/entity.py

@@ -0,0 +1,123 @@
+from typing import Callable, Any
+from ..router.exceptions import (InvalidCommandInstanceException,
+                                 UnknownCommandHandlerHasAlreadyBeenCreatedException,
+                                 InvalidDescriptionInstanceException,
+                                 RepeatedCommandException)
+
+
+class Router:
+    def __init__(self,
+                 title: str = 'Commands group title:',
+                 name: str = 'subordinate'):
+
+        self.title = title
+        self.name = name
+
+        self._command_entities: list[dict[str, Callable[[], None] | str]] = []
+        self.unknown_command_func: Callable[[str], None] | None = None
+        self._is_main_router: bool = False
+        self.ignore_command_register: bool = False
+
+
+    def command(self, command: str, description: str = None) -> Callable[[Any],  Any]:
+        processed_description = Router._validate_description(command, description)
+        self._validate_command(command)
+
+        def command_decorator(func):
+            self._command_entities.append({'handler_func': func,
+                                           'command': command,
+                                           'description': processed_description})
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+            return wrapper
+
+        return command_decorator
+
+
+    def unknown_command(self, func):
+        if self.unknown_command_func is not None:
+            raise UnknownCommandHandlerHasAlreadyBeenCreatedException()
+
+        self.unknown_command_func: Callable = func
+
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        return wrapper
+
+
+    def input_command_handler(self, input_command):
+        for command_entity in self._command_entities:
+            if input_command.lower() == command_entity['command'].lower():
+                if self.ignore_command_register:
+                    return command_entity['handler_func']()
+                else:
+                    if input_command == command_entity['command']:
+                        return command_entity['handler_func']()
+
+
+    def unknown_command_handler(self, unknown_command):
+        self.unknown_command_func(unknown_command)
+
+
+    def _validate_command(self, command: str):
+        if not isinstance(command, str):
+            raise InvalidCommandInstanceException()
+        if command in self.get_all_commands():
+            raise RepeatedCommandException()
+        if self.ignore_command_register:
+            if command.lower() in [x.lower() for x in self.get_all_commands()]:
+                raise RepeatedCommandException()
+
+
+    @staticmethod
+    def _validate_description(command: str, description: str):
+        if not isinstance(description, str):
+            if description is None:
+                description = f'description for "{command}" command'
+            else:
+                raise InvalidDescriptionInstanceException()
+        return description
+
+
+    def set_router_as_main(self):
+        if self.name == 'subordinate':
+            self.name = 'main'
+        self._is_main_router = True
+
+
+    def set_ignore_command_register(self, ignore_command_register: bool):
+        self.ignore_command_register = ignore_command_register
+
+
+    def get_command_entities(self) -> list[dict[str, Callable[[], None] | str]]:
+        return self._command_entities
+
+
+    def get_name(self) -> str:
+        return self.name
+
+
+    def get_title(self) -> str:
+        return self.title
+
+
+    def get_router_info(self) -> dict:
+        return {
+            'title': self.title,
+            'name': self.name,
+            'ignore_command_register': self.ignore_command_register,
+            'attributes': {
+                'command_entities': self._command_entities,
+                'unknown_command_func': self.unknown_command_func,
+                'is_main_router': self._is_main_router
+            }
+
+        }
+
+
+    def get_all_commands(self) -> list[str]:
+        all_commands: list[str] = []
+        for command_entity in self._command_entities:
+            all_commands.append(command_entity['command'])
+
+        return all_commands

{argenta-0.1.2 → argenta-0.2.0}/argenta/router/exceptions.py

@@ -11,3 +11,8 @@ class InvalidDescriptionInstanceException(Exception):
 class UnknownCommandHandlerHasAlreadyBeenCreatedException(Exception):
     def __str__(self):
         return "Only one unknown command handler can be declared"
+
+
+class RepeatedCommandException(Exception):
+    def __str__(self):
+        return "Commands in handler cannot be repeated"

{argenta-0.1.2 → argenta-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "argenta"
-version = "0.1.2"
+version = "0.2.0"
 description = "python library for creating cli apps"
 authors = [
     {name = "kolo",email = "kolo.is.main@gmail.com"}
@@ -15,3 +15,14 @@ dependencies = [
 [build-system]
 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"
+tqdm = "^4.67.1"
+setuptools = "^75.8.0"
+

argenta-0.1.2/argenta/app/entity.py

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

argenta-0.1.2/argenta/router/entity.py

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