pre-release v1.0.0

src/argenta/orchestrator/__init__.py

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

src/argenta/orchestrator/argparser/__init__.py

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

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

@@ -0,0 +1,6 @@
+__all__ = ["BooleanArgument", "PositionalArgument", "OptionalArgument"]
+
+
+from argenta.orchestrator.argparser.arguments.models import (BooleanArgument,
+                                                             PositionalArgument,
+                                                             OptionalArgument)

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

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from typing import Literal
+
+
+class BaseArgument(ABC):
+    """
+    Private. Base class for all arguments
+    """
+    @abstractmethod
+    def get_string_entity(self) -> str:
+        """
+        Public. Returns the string representation of the argument
+        :return: the string representation as a str
+        """
+        pass
+
+
+class PositionalArgument(BaseArgument):
+    def __init__(self, name: str):
+        """
+        Public. Required argument at startup
+        :param name: name of the argument, must not start with minus (-)
+        """
+        self.name = name
+
+    def get_string_entity(self):
+        return self.name
+
+
+class OptionalArgument(BaseArgument):
+    def __init__(self, name: str, prefix: Literal['-', '--', '---'] = '--'):
+        """
+        Public. Optional argument, must have the value
+        :param name: name of the argument
+        :param prefix: prefix of the argument
+        """
+        self.name = name
+        self.prefix = prefix
+
+    def get_string_entity(self):
+        return self.prefix + self.name
+
+
+class BooleanArgument(BaseArgument):
+    def __init__(self, name: str, prefix: Literal['-', '--', '---'] = '--'):
+        """
+        Public. Boolean argument, does not require a value
+        :param name: name of the argument
+        :param prefix: prefix of the argument
+        """
+        self.name = name
+        self.prefix = prefix
+
+    def get_string_entity(self):
+        return self.prefix + self.name

src/argenta/orchestrator/argparser/entity.py

@@ -0,0 +1,49 @@
+from argparse import ArgumentParser
+
+from argenta.orchestrator.argparser.arguments.models import (BooleanArgument,
+                                                             OptionalArgument,
+                                                             PositionalArgument)
+
+
+class ArgParser:
+    def __init__(self,
+                 processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument],
+                 name: str = 'Argenta',
+                 description: str = 'Argenta available arguments',
+                 epilog: str = 'github.com/koloideal/Argenta | made by kolo') -> None:
+        """
+        Public. Cmd argument parser and configurator at startup
+        :param name: the name of the ArgParse instance
+        :param description: the description of the ArgParse instance
+        :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.entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
+        self.args: list[PositionalArgument | OptionalArgument | BooleanArgument] | None = processed_args
+
+    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')

src/argenta/orchestrator/entity.py

@@ -0,0 +1,36 @@
+from argparse import Namespace
+
+from argenta.app import App
+from argenta.orchestrator.argparser import ArgParser
+
+
+class Orchestrator:
+    def __init__(self, arg_parser: ArgParser = False):
+        """
+        Public. An orchestrator and configurator that defines the behavior of an integrated system, one level higher than the App
+        :param arg_parser: Cmd argument parser and configurator at startup
+        :return: None
+        """
+        self.arg_parser: ArgParser | False = arg_parser
+        if arg_parser:
+            self.arg_parser.register_args()
+
+    @staticmethod
+    def start_polling(app: App) -> None:
+        """
+        Public. Starting the user input processing cycle
+        :param app: a running application
+        :return: None
+        """
+        app.run_polling()
+
+    def get_input_args(self) -> Namespace | None:
+        """
+        Public. Returns the arguments parsed
+        :return: None
+        """
+        if self.arg_parser:
+            return self.arg_parser.entity.parse_args()
+        else:
+            return None
+