extend arguments

mock/mock_app/main.py

@@ -3,26 +3,27 @@ from mock.mock_app.routers import work_router
 from argenta import App, Orchestrator
 from argenta.app import PredefinedMessages, DynamicDividingLine, AutoCompleter
 from argenta.orchestrator import ArgParser
-from argenta.orchestrator.argparser import BooleanArgument
+from argenta.orchestrator.argparser import BooleanArgument, ValueArgument, RequiredArgument
 
 
-arg_parser = ArgParser(processed_args=[BooleanArgument("repeat")])
+arg_parser: ArgParser = ArgParser(processed_args=[BooleanArgument(name="repeat", is_deprecated=True),
+                                                  ValueArgument(name="value", possible_values=["cat", "dog"]),
+                                                  RequiredArgument(name="required", is_required=True)])
 app: App = App(
     dividing_line=DynamicDividingLine(),
     autocompleter=AutoCompleter(),
 )
 orchestrator: Orchestrator = Orchestrator(arg_parser)
 
+print(orchestrator.get_input_args())
 
 def main():
     app.include_router(work_router)
-    print(f"\n\n{orchestrator.get_input_args()}")
 
     app.add_message_on_startup(PredefinedMessages.USAGE)
     app.add_message_on_startup(PredefinedMessages.AUTOCOMPLETE)
     app.add_message_on_startup(PredefinedMessages.HELP)
-
+    # orchestrator.start_polling(app)
-    orchestrator.start_polling(app)
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -22,6 +22,9 @@ exclude = [
     "tests"
 ]
 
+[tool.pyright]
+typeCheckingMode = "strict"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

src/argenta/orchestrator/argparser/__init__.py

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

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

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

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

@@ -16,29 +16,65 @@ class BaseArgument(ABC):
         raise NotImplementedError
 
 
-class PositionalArgument(BaseArgument):
+class RequiredArgument(BaseArgument):
-    def __init__(self, name: str):
+    def __init__(self, name: str, *,
+                       prefix: Literal["-", "--", "---"] = "--",
+                       help: str = "Help for required argument",
+                       default: str | None = None,
+                       possible_values: list[str] | None = None,
+                       is_required: bool = True,
+                       is_deprecated: bool = False):
         """
         Public. Required argument at startup
         :param name: name of the argument, must not start with minus (-)
+        :param prefix: prefix of the argument
+        :param help: help message for the argument
+        :param default: default value for the argument
+        :param possible_values: list of possible values for the argument
+        :param is_required: whether the argument is required
+        :param is_deprecated: whether the argument is deprecated
         """
         self.name: str = name
+        self.prefix: Literal["-", "--", "---"] = prefix
+        self.help: str = help
+        self.default: str | None = default
+        self.possible_values: list[str] | None = possible_values
+        self.is_required: bool = is_required
+        self.is_deprecated: bool = is_deprecated
+        self.action: str = "store"
 
     @property
     @override
     def string_entity(self) -> str:
-        return self.name
+        return self.prefix + self.name
 
 
-class OptionalArgument(BaseArgument):
+class ValueArgument(BaseArgument):
-    def __init__(self, name: str, prefix: Literal["-", "--", "---"] = "--"):
+    def __init__(self, name: str, *,
+                       prefix: Literal["-", "--", "---"] = "--", 
+                       help: str = "Help message for the value argument", 
+                       possible_values: list[str] | None = None,
+                       default: str | None = None,
+                       is_required: bool = False,
+                       is_deprecated: bool = False):
         """
-        Public. Optional argument, must have the value
+        Public. Value argument, must have the value
         :param name: name of the argument
         :param prefix: prefix of the argument
+        :param help: help message for the argument
+        :param possible_values: list of possible values for the argument
+        :param default: default value for the argument
+        :param is_required: whether the argument is required
+        :param is_deprecated: whether the argument is deprecated
         """
         self.name: str = name
         self.prefix: Literal["-", "--", "---"] = prefix
+        self.help: str = help
+        self.possible_values: list[str] | None = possible_values
+        self.default: str | None = default
+        self.is_required: bool = is_required
+        self.is_deprecated: bool = is_deprecated
+        self.action: str = "store"
 
     @property
     @override
@@ -47,14 +83,25 @@ class OptionalArgument(BaseArgument):
 
 
 class BooleanArgument(BaseArgument):
-    def __init__(self, name: str, prefix: Literal["-", "--", "---"] = "--"):
+    def __init__(self, name: str, *,
+                       prefix: Literal["-", "--", "---"] = "--",
+                       help: str = "Help message for the boolean argument",
+                       is_required: bool = False,
+                       is_deprecated: bool = False):
         """
         Public. Boolean argument, does not require a value
         :param name: name of the argument
         :param prefix: prefix of the argument
+        :param help: help message for the argument
+        :param is_required: whether the argument is required
+        :param is_deprecated: whether the argument is deprecated
         """
         self.name: str = name
         self.prefix: Literal["-", "--", "---"] = prefix
+        self.help: str = help
+        self.is_required: bool = is_required
+        self.is_deprecated: bool = is_deprecated
+        self.action: str = "store_true"
 
     @property
     @override

src/argenta/orchestrator/argparser/entity.py

@@ -2,15 +2,15 @@ from argparse import ArgumentParser, Namespace
 
 from argenta.orchestrator.argparser.arguments.models import (
     BooleanArgument,
-    OptionalArgument,
+    ValueArgument,
-    PositionalArgument,
+    RequiredArgument,
 )
 
 
 class ArgParser:
     def __init__(
         self,
-        processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument], *,
+        processed_args: list[RequiredArgument | ValueArgument | BooleanArgument], *,
         name: str = "Argenta",
         description: str = "Argenta available arguments",
         epilog: str = "github.com/koloideal/Argenta | made by kolo",
@@ -27,13 +27,23 @@ class ArgParser:
         self._epilog: str = epilog
 
         self._entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
-        self._processed_args: list[PositionalArgument | OptionalArgument | BooleanArgument] = processed_args
+        self._processed_args: list[RequiredArgument | ValueArgument | BooleanArgument] = processed_args
         
         for arg in processed_args:
-            if isinstance(arg, PositionalArgument) or isinstance(arg, OptionalArgument):
+            if isinstance(arg, BooleanArgument):
-                _ = self._entity.add_argument(arg.string_entity)
+                _ = self._entity.add_argument(arg.string_entity,    
+                                            action=arg.action,
+                                            help=arg.help,
+                                            required=arg.is_required,
+                                            deprecated=arg.is_deprecated)
             else:
-                _ = self._entity.add_argument(arg.string_entity, action="store_true")
+                _ = self._entity.add_argument(arg.string_entity,    
+                                            action=arg.action,
+                                            help=arg.help,
+                                            default=arg.default,
+                                            choices=arg.possible_values,
+                                            required=arg.is_required,
+                                            deprecated=arg.is_deprecated)
 
     def parse_args(self) -> Namespace:
         return self._entity.parse_args()