more working

argenta/command/flag/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ('InputFlags', 'InputFlag', 'Flag', 'Flags')
+
+
+from .models import InputFlags, InputFlag, Flags, Flag

argenta/command/flag/defaults.py

@@ -4,7 +4,7 @@ import re
 
 
 @dataclass
-class DefaultFlags:
+class PredeterminedFlags:
     HELP = Flag(name='help', possible_values=False)
     SHORT_HELP = Flag(name='h', prefix='-', possible_values=False)
 

argenta/command/flag/models.py

@@ -4,11 +4,9 @@ from abc import ABC, abstractmethod
 
 class BaseFlag:
     def __init__(self, name: str,
-                 prefix: Literal['-', '--', '---'] = '--',
-                 possible_values: list[str] | Pattern[str] | False = True):
+                 prefix: Literal['-', '--', '---'] = '--'):
         self._name = name
         self._prefix = prefix
-        self.possible_values = possible_values
 
     def get_string_entity(self):
         string_entity: str = self._prefix + self._name
@@ -25,9 +23,9 @@ class BaseFlag:
 class InputFlag(BaseFlag):
     def __init__(self, name: str,
                  prefix: Literal['-', '--', '---'] = '--',
-                 possible_values: list[str] | Pattern[str] | False = True):
-        super().__init__(name, prefix, possible_values)
-        self._flag_value = None
+                 value: str = None):
+        super().__init__(name, prefix)
+        self._flag_value = value
 
     def get_value(self):
         return self._flag_value
@@ -38,6 +36,12 @@ class InputFlag(BaseFlag):
 
 
 class Flag(BaseFlag):
+    def __init__(self, name: str,
+                 prefix: Literal['-', '--', '---'] = '--',
+                 possible_values: list[str] | Pattern[str] | False = True):
+        super().__init__(name, prefix)
+        self.possible_values = possible_values
+
     def validate_input_flag_value(self, input_flag_value: str | None):
         if self.possible_values is False:
             if input_flag_value is None:
@@ -45,9 +49,12 @@ class Flag(BaseFlag):
             else:
                 return False
         elif isinstance(self.possible_values, Pattern):
-            is_valid = bool(self.possible_values.match(input_flag_value))
-            if bool(is_valid):
-                return True
+            if isinstance(input_flag_value, str):
+                is_valid = bool(self.possible_values.match(input_flag_value))
+                if bool(is_valid):
+                    return True
+                else:
+                    return False
             else:
                 return False
 

argenta/command/models.py

@@ -5,30 +5,24 @@ from argenta.command.exceptions import (UnprocessedInputFlagException,
 from typing import Generic, TypeVar, cast, Literal
 
 
-BaseCommandType = TypeVar('BaseCommandType')
+InputCommandType = TypeVar('InputCommandType')
 
 
-class BaseCommand(Generic[BaseCommandType]):
-    def __init__(self, trigger: str,
-                 description: str = None,
-                 flags: Flag | Flags = None):
+class BaseCommand:
+    def __init__(self, trigger: str):
         self._trigger = trigger
-        self._description = f'description for "{self._trigger}" command' if not description else description
 
     def get_trigger(self) -> str:
         return self._trigger
 
-    def get_description(self) -> str:
-        return self._description
-
-
 
 class Command(BaseCommand):
     def __init__(self, trigger: str,
                  description: str = None,
                  flags: Flag | Flags = None):
-        super().__init__(trigger, description)
+        super().__init__(trigger)
         self._registered_flags: Flags = flags if isinstance(flags, Flags) else Flags(flags) if isinstance(flags, Flag) else Flags()
+        self._description = f'description for "{self._trigger}" command' if not description else description
 
     def get_registered_flags(self) -> Flags:
         return self._registered_flags
@@ -49,13 +43,15 @@ class Command(BaseCommand):
                             return True
         return False
 
+    def get_description(self) -> str:
+        return self._description
 
 
-class InputCommand(BaseCommand):
+
+class InputCommand(BaseCommand, Generic[InputCommandType]):
     def __init__(self, trigger: str,
-                 description: str = None,
                  input_flags: InputFlag | InputFlags = None):
-        super().__init__(trigger, description)
+        super().__init__(trigger)
         self._input_flags: InputFlags = input_flags if isinstance(input_flags, InputFlags) else InputFlags(input_flags) if isinstance(input_flags, InputFlag) else InputFlags()
 
     def _set_input_flags(self, input_flags: InputFlags):
@@ -65,53 +61,45 @@ class InputCommand(BaseCommand):
         return self._input_flags
 
     @staticmethod
-    def parse_input_command(raw_command: str) -> BaseCommandType:
+    def parse(raw_command: str) -> InputCommandType:
         if not raw_command:
             raise EmptyInputCommandException()
+
         list_of_tokens = raw_command.split()
-        command = list_of_tokens[0]
-        list_of_tokens.pop(0)
+        command = list_of_tokens.pop(0)
 
         input_flags: InputFlags = InputFlags()
-        current_flag_name = None
-        current_flag_value = None
+        current_flag_name, current_flag_value = None, None
+
         for k, _ in enumerate(list_of_tokens):
             if _.startswith('-'):
-                flag_prefix_last_symbol_index = _.rfind('-')
-                if current_flag_name or len(_) < 2 or len(_[:flag_prefix_last_symbol_index]) > 3:
+                if current_flag_name or len(_) < 2 or len(_[:_.rfind('-')]) > 3:
                     raise UnprocessedInputFlagException()
-                else:
-                    current_flag_name = _
+                current_flag_name = _
             else:
                 if not current_flag_name:
                     raise UnprocessedInputFlagException()
-                else:
-                    current_flag_value = _
-            if current_flag_name:
-                if not len(list_of_tokens) == k + 1:
-                    if not list_of_tokens[k + 1].startswith('-'):
-                        continue
-                flag_prefix_last_symbol_index = current_flag_name.rfind('-')
-                flag_prefix = current_flag_name[:flag_prefix_last_symbol_index + 1]
-                flag_name = current_flag_name[flag_prefix_last_symbol_index + 1:]
-                input_flag = InputFlag(name=flag_name,
-                                       prefix=cast(Literal['-', '--', '---'], flag_prefix))
-                input_flag.set_value(current_flag_value)
+                current_flag_value = _
 
-                all_flags = [x.get_string_entity() for x in input_flags.get_flags()]
+            if current_flag_name:
+                if not len(list_of_tokens) == k+1:
+                    if not list_of_tokens[k+1].startswith('-'): continue
+
+                input_flag = InputFlag(name=current_flag_name[current_flag_name.rfind('-')+1:],
+                                       prefix=cast(Literal['-', '--', '---'],
+                                                   current_flag_name[:current_flag_name.rfind('-')+1]),
+                                       value=current_flag_value)
+
+                all_flags = [flag.get_string_entity() for flag in input_flags.get_flags()]
                 if input_flag.get_string_entity() not in all_flags:
                     input_flags.add_flag(input_flag)
                 else:
                     raise RepeatedInputFlagsException(input_flag)
 
-                current_flag_name = None
-                current_flag_value = None
+                current_flag_name, current_flag_value = None, None
+
         if any([current_flag_name, current_flag_value]):
             raise UnprocessedInputFlagException()
-        if len(input_flags.get_flags()) == 0:
-            return InputCommand(trigger=command)
         else:
-            input_command = InputCommand(trigger=command)
-            input_command._set_input_flags(input_flags)
-            return input_command
+            return InputCommand(trigger=command, input_flags=input_flags)