feat: Add verbosity class

Author: caffeine-addictt

src/thread/utils/config.py

@@ -11,13 +11,99 @@
 }
 
 
+class Verbosity:
+    """
+    # Verbosity
+
+    Can be instantiated with and compared against a number or an enum.
+    """
+
+    level_number: _Verbosity_Num
+    level_string: _Verbosity_Enum
+
+    def __init__(self, level: VerbosityLevel) -> None:
+        """
+        Initializes the verbosity object.
+
+        Parameters
+        ----------
+        :param level: The level of verbosity. Can be a number or an enum.
+
+        Raises
+        ------
+        ValueError: If the level is not a valid number or enum.
+        ValueError: If the level is not of a valid type.
+        """
+        if isinstance(level, str):
+            if level not in ['quiet', 'normal', 'verbose']:
+                raise ValueError('Invalid verbosity level')
+            self.level_string = level
+            self.level_number = VerbosityMapping[level]
+        elif isinstance(level, int):
+            if level not in [0, 1, 2]:
+                raise ValueError('Invalid verbosity level')
+            self.level_number = level
+            self.level_string = list(VerbosityMapping.keys())[level]
+        else:
+            raise ValueError(f'{type(level)} is not a valid verbosity level')
+
+    def __str__(self) -> str:
+        return self.level_string
+
+    def __eq__(self, other: Any) -> bool:
+        try:
+            return self._compare(other, lambda a, b: a == b)
+        except ValueError:
+            return False
+
+    def __lt__(self, other: Any) -> bool:
+        return self._compare(other, lambda a, b: a < b)
+
+    def __le__(self, other: Any) -> bool:
+        return self._compare(other, lambda a, b: a <= b)
+
+    def __gt__(self, other: Any) -> bool:
+        return self._compare(other, lambda a, b: a > b)
+
+    def __ge__(self, other: Any) -> bool:
+        return self._compare(other, lambda a, b: a >= b)
+
+    def __ne__(self, other: Any) -> bool:
+        return not self.__eq__(other)
+
+    def _compare(
+        self, other: Any, operator: Callable[[VerbosityLevel, Any], bool]
+    ) -> bool:
+        if isinstance(other, Verbosity):
+            return operator(self.level_number, other.level_number)
+        if isinstance(other, int):
+            return operator(self.level_number, other)
+        if isinstance(other, str):
+            if Verbosity.is_valid_level(other):
+                return operator(self.level_number, VerbosityMapping[other])
+            return operator(self.level_string, other)
+        raise ValueError('Cannot compare Verbosity with other types')
+
+    @staticmethod
+    def is_valid_level(level: Any) -> bool:
+        if isinstance(level, int):
+            return level in VerbosityMapping.values()
+        if isinstance(level, str):
+            return level in VerbosityMapping.keys()
+        return False
+
+
 class Settings:
     """
     # Settings
     `Non Instantiable`
     """
 
-    VERBOSITY: bool = True
+    # Verbosity
+    VerbosityLevel = VerbosityLevel
+    VERBOSITY: Verbosity = Verbosity(1)
+
+    # Graceful Exit
     GRACEFUL_EXIT_ENABLED: bool = True
 
     def __init__(self):