last steps work on new docs, full complete write docstring for all objects

argenta/router/command_handler/entity.py

@@ -7,33 +7,69 @@ from argenta.command.flag import InputFlags
 
 class CommandHandler:
     def __init__(self, handler: Callable[[], None] | Callable[[InputFlags], None], handled_command: Command):
+        """
+        Private. Entity of the model linking the handler and the command being processed
+        :param handler: the handler being called
+        :param handled_command: the command being processed
+        """
         self._handler = handler
         self._handled_command = handled_command
 
-    def handling(self, input_flags: InputFlags = None):
+    def handling(self, input_flags: InputFlags = None) -> None:
+        """
+        Private. Direct processing of an input command
+        :param input_flags: the flags of the input command
+        :return: None
+        """
         if input_flags is not None:
             self._handler(input_flags)
         else:
             self._handler()
 
-    def get_handler(self):
+    def get_handler(self) -> Callable[[], None] | Callable[[InputFlags], None]:
+        """
+        Private. Returns the handler being called
+        :return: the handler being called as Callable[[], None] or Callable[[InputFlags], None]
+        """
         return self._handler
 
-    def get_handled_command(self):
+    def get_handled_command(self) -> Command:
+        """
+        Private. Returns the command being processed
+        :return: the command being processed as Command
+        """
         return self._handled_command
 
 
 class CommandHandlers:
     def __init__(self, command_handlers: list[CommandHandler] = None):
+        """
+        Private. The model that unites all CommandHandler of the routers
+        :param command_handlers: list of CommandHandlers for register
+        """
         self.command_handlers = command_handlers if command_handlers else []
 
     def get_command_handlers(self) -> list[CommandHandler]:
+        """
+        Private. Returns the list of CommandHandlers
+        :return: the list of CommandHandlers as list[CommandHandler]
+        """
         return self.command_handlers
 
-    def add_command_handler(self, command_handler: CommandHandler):
+    def add_command_handler(self, command_handler: CommandHandler) -> None:
+        """
+        Private. Adds a CommandHandler to the list of CommandHandlers
+        :param command_handler: CommandHandler to be added
+        :return: None
+        """
         self.command_handlers.append(command_handler)
 
-    def add_command_handlers(self, *command_handlers: CommandHandler):
+    def add_command_handlers(self, *command_handlers: CommandHandler) -> None:
+        """
+        Private. Extend a many CommandHandler to the list of CommandHandlers
+        :param command_handlers: many CommandHandler to be added
+        :return: None
+        """
         self.command_handlers.extend(command_handlers)
 
     def __iter__(self):

argenta/router/defaults.py

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

argenta/router/entity.py

@@ -1,6 +1,5 @@
 from typing import Callable
 from inspect import getfullargspec
-
 from argenta.command import Command
 from argenta.command.models import InputCommand
 from argenta.router.command_handler.entity import CommandHandlers, CommandHandler
@@ -9,21 +8,18 @@ from argenta.router.exceptions import (RepeatedFlagNameException,
                                        TooManyTransferredArgsException,
                                        RequiredArgumentNotPassedException,
                                        IncorrectNumberOfHandlerArgsException,
-                                       TriggerCannotContainSpacesException)
+                                       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
-        :param name: the name of the router
+        :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
@@ -105,9 +101,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
@@ -115,10 +117,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:
@@ -128,7 +135,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:
@@ -140,18 +153,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():
@@ -160,16 +186,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

@@ -30,7 +30,7 @@ class IncorrectNumberOfHandlerArgsException(Exception):
         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
     """