argenta 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

argenta/command/exceptions.py

@@ -1,42 +1,49 @@
 from argenta.command.flag.models import Flag, InputFlag
+from abc import ABC, abstractmethod
+from typing import override
 
 
-class BaseInputCommandException(Exception):
+class InputCommandException(ABC, Exception):
     """
     Private. Base exception class for all exceptions raised when parse input command
     """
+    @override
+    @abstractmethod
+    def __str__(self) -> str:
+        raise NotImplementedError
 
-    pass
 
-
-class UnprocessedInputFlagException(BaseInputCommandException):
+class UnprocessedInputFlagException(InputCommandException):
     """
     Private. Raised when an unprocessed input flag is detected
     """
-
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         return "Unprocessed Input Flags"
 
 
-class RepeatedInputFlagsException(BaseInputCommandException):
+class RepeatedInputFlagsException(InputCommandException):
     """
     Private. Raised when repeated input flags are detected
     """
 
     def __init__(self, flag: Flag | InputFlag):
-        self.flag = flag
+        self.flag: Flag | InputFlag = flag
+        super().__init__()
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
+        string_entity: str = self.flag.string_entity
         return (
             "Repeated Input Flags\n"
-            f"Duplicate flag was detected in the input: '{self.flag.get_string_entity()}'"
+            f"Duplicate flag was detected in the input: '{string_entity}'"
         )
 
 
-class EmptyInputCommandException(BaseInputCommandException):
+class EmptyInputCommandException(InputCommandException):
     """
     Private. Raised when an empty input command is detected
     """
-
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         return "Input Command is empty"

argenta/command/flag/__init__.py

@@ -1,7 +1,11 @@
-__all__ = ["Flag", "InputFlag", "UndefinedInputFlags", "ValidInputFlags", "InvalidValueInputFlags", "Flags"]
+__all__ = [
+    "Flag",
+    "InputFlag",
+    "Flags", 
+    "PossibleValues",
+    "ValidationStatus"
+]
 
 
-from argenta.command.flag.models import Flag, InputFlag
-from argenta.command.flag.flags.models import (UndefinedInputFlags,
-                                               ValidInputFlags, Flags,
-                                               InvalidValueInputFlags)
+from argenta.command.flag.models import Flag, InputFlag, PossibleValues, ValidationStatus
+from argenta.command.flag.flags.models import Flags

argenta/command/flag/defaults.py

@@ -1,31 +1,27 @@
-from dataclasses import dataclass
-from argenta.command.flag.models import Flag
-import re
+from typing import Literal
+from argenta.command.flag.models import Flag, PossibleValues
+import re    
 
 
-@dataclass
-class PredefinedFlags:
-    """
-    Public. A dataclass with predefined flags and most frequently used flags for quick use
-    """
+DEFAULT_PREFIX: Literal["-", "--", "---"] = "-"
 
-    HELP = Flag(name="help", possible_values=False)
-    SHORT_HELP = Flag(name="H", prefix="-", possible_values=False)
+HELP = Flag(name="help", possible_values=PossibleValues.NEITHER)
+SHORT_HELP = Flag(name="H", prefix=DEFAULT_PREFIX, possible_values=PossibleValues.NEITHER)
 
-    INFO = Flag(name="info", possible_values=False)
-    SHORT_INFO = Flag(name="I", prefix="-", possible_values=False)
+INFO = Flag(name="info", possible_values=PossibleValues.NEITHER) # noqa: WPS110
+SHORT_INFO = Flag(name="I", prefix=DEFAULT_PREFIX, possible_values=PossibleValues.NEITHER)
 
-    ALL = Flag(name="all", possible_values=False)
-    SHORT_ALL = Flag(name="A", prefix="-", possible_values=False)
+ALL = Flag(name="all", possible_values=PossibleValues.NEITHER)
+SHORT_ALL = Flag(name="A", prefix=DEFAULT_PREFIX, possible_values=PossibleValues.NEITHER)
 
-    HOST = Flag(
-        name="host", possible_values=re.compile(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$")
-    )
-    SHORT_HOST = Flag(
-        name="H",
-        prefix="-",
-        possible_values=re.compile(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$"),
-    )
+HOST = Flag(
+    name="host", possible_values=re.compile(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$")
+)
+SHORT_HOST = Flag(
+    name="H",
+    prefix=DEFAULT_PREFIX,
+    possible_values=re.compile(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$"),
+)
 
-    PORT = Flag(name="port", possible_values=re.compile(r"^\d{1,5}$"))
-    SHORT_PORT = Flag(name="P", prefix="-", possible_values=re.compile(r"^\d{1,5}$"))
+PORT = Flag(name="port", possible_values=re.compile(r"^\d{1,5}$"))
+SHORT_PORT = Flag(name="P", prefix=DEFAULT_PREFIX, possible_values=re.compile(r"^\d{1,5}$"))

argenta/command/flag/flags/__init__.py

@@ -1,16 +1,10 @@
 __all__ = [
     "Flags",
-    "InputFlags",
-    "UndefinedInputFlags",
-    "InvalidValueInputFlags",
-    "ValidInputFlags",
+    "InputFlags"
 ]
 
 
 from argenta.command.flag.flags.models import (
     Flags,
-    InputFlags,
-    UndefinedInputFlags,
-    InvalidValueInputFlags,
-    ValidInputFlags,
+    InputFlags
 )

argenta/command/flag/flags/models.py

@@ -1,90 +1,106 @@
 from argenta.command.flag.models import InputFlag, Flag
-from typing import Generic, TypeVar
+from typing import Generic, TypeVar, override
+from collections.abc import Iterator
 
 
 FlagType = TypeVar("FlagType")
 
 
 class BaseFlags(Generic[FlagType]):
-    def __init__(self, *flags: FlagType):
+    def __init__(self, flags: list[FlagType] | None = None) -> None:
         """
         Public. A model that combines the registered flags
         :param flags: the flags that will be registered
         :return: None
         """
-        self._flags = flags if flags else []
+        self.flags: list[FlagType] = flags if flags else []
 
-    def get_flags(self) -> list[FlagType]:
-        """
-        Public. Returns a list of flags
-        :return: list of flags as list[FlagType]
-        """
-        return self._flags
-
-    def add_flag(self, flag: FlagType):
+    def add_flag(self, flag: FlagType) -> None:
         """
         Public. Adds a flag to the list of flags
         :param flag: flag to add
         :return: None
         """
-        self._flags.append(flag)
+        self.flags.append(flag)
 
-    def add_flags(self, flags: list[FlagType]):
+    def add_flags(self, flags: list[FlagType]) -> None:
         """
         Public. Adds a list of flags to the list of flags
         :param flags: list of flags to add
         :return: None
         """
-        self._flags.extend(flags)
+        self.flags.extend(flags)
+
+    def __iter__(self) -> Iterator[FlagType]:
+        return iter(self.flags)
+
+    def __next__(self) -> FlagType:
+        return next(iter(self))
+
+    def __getitem__(self, flag_index: int) -> FlagType:
+        return self.flags[flag_index]
+
+    def __bool__(self) -> bool:
+        return bool(self.flags)
 
-    def get_flag(self, name: str) -> FlagType | None:
+
+class Flags(BaseFlags[Flag]):
+    def get_flag_by_name(self, name: str) -> Flag | None:
         """
         Public. Returns the flag entity by its name or None if not found
         :param name: the name of the flag to get
         :return: entity of the flag or None
         """
-        if name in [flag.get_name() for flag in self._flags]:
-            return list(filter(lambda flag: flag.get_name() == name, self._flags))[0]
-        else:
-            return None
-
-    def __iter__(self):
-        return iter(self._flags)
-
-    def __next__(self):
-        return next(iter(self))
-
-    def __getitem__(self, item):
-        return self._flags[item]
+        return next((flag for flag in self.flags if flag.name == name), None)
+    
+    @override
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Flags):
+            return NotImplemented
+
+        if len(self.flags) != len(other.flags):
+            return False
 
-    def __bool__(self):
-        return bool(self._flags)
+        flag_pairs: zip[tuple[Flag, Flag]] = zip(self.flags, other.flags)
+        return all(s_flag == o_flag for s_flag, o_flag in flag_pairs)
 
-    def __eq__(self, other):
-        if len(self.get_flags()) != len(other.get_flags()):
+    def __contains__(self, flag_to_check: object) -> bool:
+        if isinstance(flag_to_check, Flag):
+            for flag in self.flags:
+                if flag == flag_to_check:
+                    return True
             return False
         else:
-            for flag, other_flag in zip(self.get_flags(), other.get_flags()):
-                if not flag == other_flag:
-                    return False
-        return True
-
-
-class Flags(BaseFlags[Flag]):
-    pass
+            raise TypeError
 
 
 class InputFlags(BaseFlags[InputFlag]):
-    pass
-
-
-class ValidInputFlags(InputFlags):
-    pass
+    def get_flag_by_name(self, name: str) -> InputFlag | None:
+        """
+        Public. Returns the flag entity by its name or None if not found
+        :param name: the name of the flag to get
+        :return: entity of the flag or None
+        """
+        return next((flag for flag in self.flags if flag.name == name), None)
+    
+    @override
+    def __eq__(self, other: object) -> bool: 
+        if not isinstance(other, InputFlags):
+            raise NotImplementedError
+
+        if len(self.flags) != len(other.flags):
+            return False
 
+        paired_flags: zip[tuple[InputFlag, InputFlag]] = zip(self.flags, other.flags)
 
-class UndefinedInputFlags(InputFlags):
-    pass
+        return all(my_flag == other_flag for my_flag, other_flag in paired_flags)
 
+    def __contains__(self, ingressable_item: object) -> bool:
+        if isinstance(ingressable_item, InputFlag):
+            for flag in self.flags:
+                if flag == ingressable_item:
+                    return True
+            return False
+        else:
+            raise TypeError
 
-class InvalidValueInputFlags(InputFlags):
-    pass

argenta/command/flag/models.py

@@ -1,49 +1,24 @@
-from typing import Literal, Pattern
+from enum import Enum
+from re import Pattern
+from typing import Literal, override
 
 
-class BaseFlag:
-    def __init__(self, name: str, prefix: Literal["-", "--", "---"] = "--") -> None:
-        """
-        Private. Base class for flags
-        :param name: the name of the flag
-        :param prefix: the prefix of the flag
-        :return: None
-        """
-        self._name = name
-        self._prefix = prefix
+class PossibleValues(Enum):
+    NEITHER = 'NEITHER'
+    ALL = 'ALL'
 
-    def get_string_entity(self) -> str:
-        """
-        Public. Returns a string representation of the flag
-        :return: string representation of the flag as str
-        """
-        string_entity: str = self._prefix + self._name
-        return string_entity
 
-    def get_name(self) -> str:
-        """
-        Public. Returns the name of the flag
-        :return: the name of the flag as str
-        """
-        return self._name
+class ValidationStatus(Enum):
+    VALID = 'VALID'
+    INVALID = 'INVALID'
+    UNDEFINED = 'UNDEFINED'
 
-    def get_prefix(self) -> str:
-        """
-        Public. Returns the prefix of the flag
-        :return: the prefix of the flag as str
-        """
-        return self._prefix
 
-    def __eq__(self, other) -> bool:
-        return self.get_string_entity() == other.get_string_entity()
-
-
-class Flag(BaseFlag):
+class Flag:
     def __init__(
-        self,
-        name: str,
+        self, name: str, *, 
         prefix: Literal["-", "--", "---"] = "--",
-        possible_values: list[str] | Pattern[str] | False = True,
+        possible_values: list[str] | Pattern[str] | PossibleValues = PossibleValues.ALL,
     ) -> None:
         """
         Public. The entity of the flag being registered for subsequent processing
@@ -52,42 +27,58 @@ class Flag(BaseFlag):
         :param possible_values: The possible values of the flag, if False then the flag cannot have a value
         :return: None
         """
-        super().__init__(name, prefix)
-        self.possible_values = possible_values
+        self.name: str = name
+        self.prefix: Literal["-", "--", "---"] = prefix
+        self.possible_values: list[str] | Pattern[str] | PossibleValues = possible_values
 
-    def validate_input_flag_value(self, input_flag_value: str | None):
+    def validate_input_flag_value(self, input_flag_value: str | None) -> bool:
         """
         Private. Validates the input flag value
         :param input_flag_value: The input flag value to validate
         :return: whether the entered flag is valid as bool
         """
-        if self.possible_values is False:
-            if input_flag_value is None:
-                return True
-            else:
-                return False
-        elif isinstance(self.possible_values, Pattern):
-            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
+        if self.possible_values == PossibleValues.NEITHER:
+            return input_flag_value is None
+
+        if isinstance(self.possible_values, Pattern):
+            return isinstance(input_flag_value, str) and bool(self.possible_values.match(input_flag_value))
 
-        elif isinstance(self.possible_values, list):
-            if input_flag_value in self.possible_values:
-                return True
-            else:
-                return False
+        if isinstance(self.possible_values, list):
+            return input_flag_value in self.possible_values
+
+        return True
+    
+    @property
+    def string_entity(self) -> str:
+        """
+        Public. Returns a string representation of the flag
+        :return: string representation of the flag as str
+        """
+        string_entity: str = self.prefix + self.name
+        return string_entity
+    
+    @override
+    def __str__(self) -> str:
+        return self.string_entity
+    
+    @override
+    def __repr__(self) -> str:
+        return f'Flag<name={self.name}, prefix={self.prefix}>'
+        
+    @override
+    def __eq__(self, other: object) -> bool: 
+        if isinstance(other, Flag):
+            return self.string_entity == other.string_entity
         else:
-            return True
+            raise NotImplementedError
 
 
-class InputFlag(BaseFlag):
+class InputFlag:
     def __init__(
-        self, name: str, prefix: Literal["-", "--", "---"] = "--", value: str | None = None
+        self, name: str, *,
+        prefix: Literal['-', '--', '---'] = '--',
+        input_value: str | None,
+        status: ValidationStatus | None
     ):
         """
         Public. The entity of the flag of the entered command
@@ -96,26 +87,33 @@ class InputFlag(BaseFlag):
         :param value: the value of the input flag
         :return: None
         """
-        super().__init__(name, prefix)
-        self._flag_value = value
-
-    def get_value(self) -> str | None:
+        self.name: str = name
+        self.prefix: Literal['-', '--', '---'] = prefix
+        self.input_value: str | None = input_value
+        self.status: ValidationStatus | None = status
+    
+    @property
+    def string_entity(self) -> str:
         """
-        Public. Returns the value of the flag
-        :return: the value of the flag as str
+        Public. Returns a string representation of the flag
+        :return: string representation of the flag as str
         """
-        return self._flag_value
+        string_entity: str = self.prefix + self.name
+        return string_entity
 
-    def set_value(self, value):
-        """
-        Private. Sets the value of the flag
-        :param value: the fag value to set
-        :return: None
-        """
-        self._flag_value = value
+    @override
+    def __str__(self) -> str:
+        return f'{self.string_entity} {self.input_value}'
+    
+    @override
+    def __repr__(self) -> str:
+        return f'InputFlag<name={self.name}, prefix={self.prefix}, value={self.input_value}, status={self.status}>'
 
-    def __eq__(self, other) -> bool:
-        return (
-            self.get_string_entity() == other.get_string_entity()
-            and self.get_value() == other.get_value()
-        )
+    @override
+    def __eq__(self, other: object) -> bool: 
+        if isinstance(other, InputFlag):
+            return (
+                self.name == other.name
+            )
+        else:
+            raise NotImplementedError