extend arguments

src/argenta/orchestrator/argparser/entity.py

@@ -1,12 +1,11 @@
 from argparse import ArgumentParser, Namespace
-from typing import Self
+from typing import Never, Self
 
 from argenta.orchestrator.argparser.arguments.models import (
     BaseArgument,
     BooleanArgument,
     InputArgument,
-    ValueArgument,
-    RequiredArgument,
+    ValueArgument
 )
 
         
@@ -16,19 +15,30 @@ class ArgSpace:
     
     @classmethod
     def from_namespace(cls, namespace: Namespace, 
-                            processed_args: list[RequiredArgument | ValueArgument | BooleanArgument]) -> Self:
+                            processed_args: list[ValueArgument | BooleanArgument]) -> Self:
         name_type_paired_args: dict[str, type[BaseArgument]] = {
             arg.name: type(arg)
             for arg in processed_args   
         }
-        return cls([InputArgument(name, value, name_type_paired_args[name]) 
+        return cls([InputArgument(name=name, 
+                                  value=value, 
+                                  founder_class=name_type_paired_args[name]) 
                     for name, value in vars(namespace).items()])
-
+        
+    def get_by_name(self, name: str) -> InputArgument | None:
+        for arg in self.all_arguments:
+            if arg.name == name:
+                return arg
+        return None
+        
+    def get_by_type(self, arg_type: type[BaseArgument]) -> list[InputArgument] | list[Never]:
+        return [arg for arg in self.all_arguments if arg.founder_class is arg_type]
+        
 
 class ArgParser:
     def __init__(
         self,
-        processed_args: list[RequiredArgument | ValueArgument | BooleanArgument], *,
+        processed_args: list[ValueArgument | BooleanArgument], *,
         name: str = "Argenta",
         description: str = "Argenta available arguments",
         epilog: str = "github.com/koloideal/Argenta | made by kolo",
@@ -40,22 +50,21 @@ class ArgParser:
         :param epilog: the epilog of the ArgParse instance
         :param processed_args: registered and processed arguments
         """
-        self._name: str = name
-        self._description: str = description
-        self._epilog: str = epilog
+        self.name: str = name
+        self.description: str = description
+        self.epilog: str = epilog
+        self.processed_args: list[ValueArgument | BooleanArgument] = processed_args
 
-        self._entity: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
-        self._processed_args: list[RequiredArgument | ValueArgument | BooleanArgument] = processed_args
+        self._core: ArgumentParser = ArgumentParser(prog=name, description=description, epilog=epilog)
         
         for arg in processed_args:
             if isinstance(arg, BooleanArgument):
-                _ = self._entity.add_argument(arg.name,    
+                _ = self._core.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.name,    
+                _ = self._core.add_argument(arg.string_entity,    
                                             action=arg.action,
                                             help=arg.help,
                                             default=arg.default,
@@ -64,6 +73,6 @@ class ArgParser:
                                             deprecated=arg.is_deprecated)
 
     def parse_args(self) -> ArgSpace:
-        return ArgSpace.from_namespace(namespace=self._entity.parse_args(),
-                                       processed_args=self._processed_args)
+        return ArgSpace.from_namespace(namespace=self._core.parse_args(),
+                                       processed_args=self.processed_args)