argenta 0.5.0b2__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

argenta/router/entity.py

@@ -1,31 +1,36 @@
-from typing import Callable, Any
+from typing import Callable
 from inspect import getfullargspec
-
-from argenta.command import Command
-from argenta.command.models import InputCommand
-from argenta.router.command_handlers.entity import CommandHandlers
-from argenta.router.command_handler.entity import CommandHandler
-from argenta.command.flag.models import Flag, Flags, InputFlags
-from argenta.router.exceptions import (RepeatedFlagNameException,
-                                       TooManyTransferredArgsException,
-                                       RequiredArgumentNotPassedException,
-                                       IncorrectNumberOfHandlerArgsException,
-                                       TriggerCannotContainSpacesException)
+from src.argenta.command import Command
+from src.argenta.command.models import InputCommand
+from src.argenta.router.command_handler.entity import CommandHandlers, CommandHandler
+from src.argenta.command.flag.models import Flag, Flags, InputFlags
+from src.argenta.router.exceptions import (RepeatedFlagNameException,
+                                           TooManyTransferredArgsException,
+                                           RequiredArgumentNotPassedException,
+                                           TriggerContainSpacesException)
 
 
 class Router:
     def __init__(self,
-                 title: str = None,
-                 name: str = 'Default'):
+                 title: str = None):
+        """
+        Public. Directly configures and manages handlers
+        :param title: the title of the router, displayed when displaying the available commands
+        :return: None
+        """
         self._title = title
-        self._name = name
 
         self._command_handlers: CommandHandlers = CommandHandlers()
         self._ignore_command_register: bool = False
         self._not_valid_flag_handler: Callable[[Flag], None] = lambda flag: print(f"Undefined or incorrect input flag: {flag.get_string_entity()}{(' '+flag.get_value()) if flag.get_value() else ''}")
 
 
-    def command(self, command: Command) -> Callable[[Any],  Any]:
+    def command(self, command: Command) -> Callable:
+        """
+        Public. Registers handler
+        :param command: Registered command
+        :return: decorated handler as Callable[[Any], Any]
+        """
         self._validate_command(command)
 
         def command_decorator(func):
@@ -39,28 +44,39 @@ class Router:
         return command_decorator
 
 
-    def set_invalid_input_flag_handler(self, func):
-        processed_args = getfullargspec(func).args
-        if len(processed_args) != 1:
-            raise IncorrectNumberOfHandlerArgsException()
-        else:
-            self._not_valid_flag_handler = func
+    def set_invalid_input_flag_handler(self, func: Callable[[Flag], None]) -> None:
+        """
+        Public. Registers handler for invalid input flag
+        :param func: registered handler
+        :return: None
+        """
+        self._not_valid_flag_handler = func
 
 
-    def input_command_handler(self, input_command: InputCommand):
+    def finds_appropriate_handler(self, input_command: InputCommand) -> None:
+        """
+        Private. Finds the appropriate handler for given input command and passes control to it
+        :param input_command: input command as InputCommand
+        :return: None
+        """
         input_command_name: str = input_command.get_trigger()
         input_command_flags: InputFlags = input_command.get_input_flags()
 
         for command_handler in self._command_handlers:
             handle_command = command_handler.get_handled_command()
             if input_command_name.lower() == handle_command.get_trigger().lower():
-                self._validate_input_command(input_command_flags, command_handler)
-            elif handle_command.get_aliases():
-                if input_command_name.lower() in handle_command.get_aliases():
-                    self._validate_input_command(input_command_flags, command_handler)
-
-
-    def _validate_input_command(self, input_command_flags: InputFlags, command_handler: CommandHandler):
+                self.process_input_command(input_command_flags, command_handler)
+            if input_command_name.lower() in handle_command.get_aliases():
+                self.process_input_command(input_command_flags, command_handler)
+
+
+    def process_input_command(self, input_command_flags: InputFlags, command_handler: CommandHandler) -> None:
+        """
+        Private. Processes input command with the appropriate handler
+        :param input_command_flags: input command flags as InputFlags
+        :param command_handler: command handler for input command as CommandHandler
+        :return: None
+        """
         handle_command = command_handler.get_handled_command()
         if handle_command.get_registered_flags().get_flags():
             if input_command_flags.get_flags():
@@ -79,9 +95,15 @@ class Router:
                 return
 
 
-    def _validate_input_flags(self, handle_command: Command, input_flags: InputFlags):
+    def _validate_input_flags(self, handled_command: Command, input_flags: InputFlags) -> bool:
+        """
+        Private. Validates flags of input command
+        :param handled_command: entity of the handled command
+        :param input_flags:
+        :return: is flags of input command valid as bool
+        """
         for flag in input_flags:
-            is_valid = handle_command.validate_input_flag(flag)
+            is_valid: bool = handled_command.validate_input_flag(flag)
             if not is_valid:
                 self._not_valid_flag_handler(flag)
                 return False
@@ -89,10 +111,15 @@ class Router:
 
 
     @staticmethod
-    def _validate_command(command: Command):
+    def _validate_command(command: Command) -> None:
+        """
+        Private. Validates the command registered in handler
+        :param command: validated command
+        :return: None if command is valid else raise exception
+        """
         command_name: str = command.get_trigger()
         if command_name.find(' ') != -1:
-            raise TriggerCannotContainSpacesException()
+            raise TriggerContainSpacesException()
 
         flags: Flags = command.get_registered_flags()
         if flags:
@@ -102,7 +129,13 @@ class Router:
 
 
     @staticmethod
-    def _validate_func_args(command: Command, func: Callable):
+    def _validate_func_args(command: Command, func: Callable) -> None:
+        """
+        Private. Validates the arguments of the handler
+        :param command: registered command in handler
+        :param func: entity of the handler func
+        :return: None if func is valid else raise exception
+        """
         registered_args = command.get_registered_flags()
         transferred_args = getfullargspec(func).args
         if registered_args.get_flags() and transferred_args:
@@ -114,18 +147,31 @@ class Router:
             raise TooManyTransferredArgsException()
 
 
-    def set_ignore_command_register(self, ignore_command_register: bool):
-        self._ignore_command_register = ignore_command_register
+    def set_command_register_ignore(self, _: bool) -> None:
+        """
+        Private. Sets the router behavior on the input commands register
+        :param _: is command register ignore
+        :return: None
+        """
+        self._ignore_command_register = _
 
 
-    def get_triggers(self):
+    def get_triggers(self) -> list[str]:
+        """
+        Public. Gets registered triggers
+        :return: registered in router triggers as list[str]
+        """
         all_triggers: list[str] = []
         for command_handler in self._command_handlers:
             all_triggers.append(command_handler.get_handled_command().get_trigger())
         return all_triggers
 
 
-    def get_aliases(self):
+    def get_aliases(self) -> list[str]:
+        """
+        Public. Gets registered aliases
+        :return: registered in router aliases as list[str]
+        """
         all_aliases: list[str] = []
         for command_handler in self._command_handlers:
             if command_handler.get_handled_command().get_aliases():
@@ -134,16 +180,25 @@ class Router:
 
 
     def get_command_handlers(self) -> CommandHandlers:
+        """
+        Private. Gets registered command handlers
+        :return: registered command handlers as CommandHandlers
+        """
         return self._command_handlers
 
 
-    def get_name(self) -> str:
-        return self._name
-
-
     def get_title(self) -> str | None:
+        """
+        Public. Gets title of the router
+        :return: the title of the router as str or None
+        """
         return self._title
 
 
-    def set_title(self, title: str):
+    def set_title(self, title: str) -> None:
+        """
+        Public. Sets the title of the router
+        :param title: title that will be setted
+        :return: None
+        """
         self._title = title

argenta/router/exceptions.py

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