ref: typehints, enum instead of raw string, abc and other (#1)

Full code coverage with annotations, fixing errors in various linters: ruff, wps, etc. Fixing errors in type checkers: ty, mypy, pyright. Formatting and bringing code to a consistent style, applying best practices in various aspects.

src/argenta/orchestrator/__init__.py

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

src/argenta/orchestrator/argparser/__init__.py

@@ -1,4 +1,12 @@
-__all__ = ["ArgParser"]
+__all__ = [
+    "ArgParser",
+    "PositionalArgument",
+    "OptionalArgument",
+    "BooleanArgument"
+]
 
 
 from argenta.orchestrator.argparser.entity import ArgParser
+from argenta.orchestrator.argparser.arguments import (BooleanArgument,
+                                                      PositionalArgument,
+                                                      OptionalArgument)

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

@@ -1,19 +1,19 @@
 from abc import ABC, abstractmethod
-from typing import Literal
+from typing import Literal, override
 
 
 class BaseArgument(ABC):
     """
     Private. Base class for all arguments
     """
-
+    @property
     @abstractmethod
-    def get_string_entity(self) -> str:
+    def string_entity(self) -> str:
         """
         Public. Returns the string representation of the argument
         :return: the string representation as a str
         """
-        pass
+        raise NotImplementedError
 
 
 class PositionalArgument(BaseArgument):
@@ -22,9 +22,11 @@ class PositionalArgument(BaseArgument):
         Public. Required argument at startup
         :param name: name of the argument, must not start with minus (-)
         """
-        self.name = name
+        self.name: str = name
 
-    def get_string_entity(self):
+    @property
+    @override
+    def string_entity(self) -> str:
         return self.name
 
 
@@ -35,10 +37,12 @@ class OptionalArgument(BaseArgument):
         :param name: name of the argument
         :param prefix: prefix of the argument
         """
-        self.name = name
-        self.prefix = prefix
+        self.name: str = name
+        self.prefix: Literal["-", "--", "---"] = prefix
 
-    def get_string_entity(self):
+    @property
+    @override
+    def string_entity(self) -> str:
         return self.prefix + self.name
 
 
@@ -49,8 +53,10 @@ class BooleanArgument(BaseArgument):
         :param name: name of the argument
         :param prefix: prefix of the argument
         """
-        self.name = name
-        self.prefix = prefix
+        self.name: str = name
+        self.prefix: Literal["-", "--", "---"] = prefix
 
-    def get_string_entity(self):
+    @property
+    @override
+    def string_entity(self) -> str:
         return self.prefix + self.name

src/argenta/orchestrator/argparser/entity.py

@@ -1,4 +1,4 @@
-from argparse import ArgumentParser
+from argparse import ArgumentParser, Namespace
 
 from argenta.orchestrator.argparser.arguments.models import (
     BooleanArgument,
@@ -10,7 +10,7 @@ from argenta.orchestrator.argparser.arguments.models import (
 class ArgParser:
     def __init__(
         self,
-        processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument],
+        processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument], *,
         name: str = "Argenta",
         description: str = "Argenta available arguments",
         epilog: str = "github.com/koloideal/Argenta | made by kolo",
@@ -22,38 +22,18 @@ class ArgParser:
         :param epilog: the epilog of the ArgParse instance
         :param processed_args: registered and processed arguments
         """
-        self.name = name
-        self.description = description
-        self.epilog = epilog
+        self._name: str = name
+        self._description: str = description
+        self._epilog: str = epilog
 
-        self.entity: ArgumentParser = ArgumentParser(
-            prog=name, description=description, epilog=epilog
-        )
-        self.args: (
-            list[PositionalArgument | OptionalArgument | BooleanArgument] | None
-        ) = processed_args
+        self._entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
+        self._processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument] = processed_args
+        
+        for arg in processed_args:
+            if isinstance(arg, PositionalArgument) or isinstance(arg, OptionalArgument):
+                _ = self._entity.add_argument(arg.string_entity)
+            else: 
+                _ = self._entity.add_argument(arg.string_entity, action="store_true")
 
-    def set_args(
-        self, *args: PositionalArgument | OptionalArgument | BooleanArgument
-    ) -> None:
-        """
-        Public. Sets the arguments to be processed
-        :param args: processed arguments
-        :return: None
-        """
-        self.args.extend(args)
-
-    def register_args(self) -> None:
-        """
-        Private. Registers initialized command line arguments
-        :return: None
-        """
-        if not self.args:
-            return
-        for arg in self.args:
-            if type(arg) is PositionalArgument:
-                self.entity.add_argument(arg.get_string_entity())
-            elif type(arg) is OptionalArgument:
-                self.entity.add_argument(arg.get_string_entity())
-            elif type(arg) is BooleanArgument:
-                self.entity.add_argument(arg.get_string_entity(), action="store_true")
+    def parse_args(self) -> Namespace:
+        return self._entity.parse_args()

src/argenta/orchestrator/entity.py

@@ -11,12 +11,9 @@ class Orchestrator:
         :param arg_parser: Cmd argument parser and configurator at startup
         :return: None
         """
-        self.arg_parser: ArgParser | None = arg_parser
-        if arg_parser:
-            self.arg_parser.register_args()
+        self._arg_parser: ArgParser | None = arg_parser
 
-    @staticmethod
-    def start_polling(app: App) -> None:
+    def start_polling(self, app: App) -> None:
         """
         Public. Starting the user input processing cycle
         :param app: a running application
@@ -29,7 +26,7 @@ class Orchestrator:
         Public. Returns the arguments parsed
         :return: None
         """
-        if self.arg_parser:
-            return self.arg_parser.entity.parse_args()
+        if self._arg_parser:
+            return self._arg_parser.parse_args()
         else:
             return None