UniversalFunctions 1.1.1__tar.gz → 1.2.0__tar.gz

{universalfunctions-1.1.1/UniversalFunctions.egg-info → universalfunctions-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UniversalFunctions
-Version: 1.1.1
+Version: 1.2.0
 Summary: A Python utility library providing foundational functions, validators, and infrastructure.
 Author-email: "Miah M. Sabiq" <miah.sabiq@gibs.at>
 Requires-Python: >=3.14

{universalfunctions-1.1.1 → universalfunctions-1.2.0}/UF/Validators/QuantumValidators.py

@@ -3,15 +3,19 @@ This module contains type validators for list and tuple which belong to the QTM
 """
 
 from typing import Any, get_args, get_origin, Annotated
-from .ValidationClasses import TypeValidate
+from .ValidationClasses import TypeValidate, SequenceValidate
 
-def qtm_lt_validator(value: list[Any] | tuple[Any, ...], TYPE: Any, name: str) -> bool:
+def qtm_lt_validator(value: list[Any] | tuple[Any, ...], TYPE: Any, name: str) -> tuple | list:
     """
-    Takes a list of ONE specific element and validates its contents against the expected type
-    :param value: list of elements
-    :param TYPE: list[expected type]
+    Takes a list/tuple of specific elements and validates its contents against the expected type
+
+    >>> qtm_lt_validator([1, 2, 3], list[int, ...], "random list")
+    [1, 2, 3]
+
+    :param value: list/tuple of elements
+    :param TYPE: list[expected type] for example
     :param name: name of value
-    :return: True if the contents of value satisfy the expected type
+    :return: validated list/tuple of elements
     """
     origin = get_origin(TYPE)
     if origin not in (list, tuple):
@@ -20,21 +24,11 @@ def qtm_lt_validator(value: list[Any] | tuple[Any, ...], TYPE: Any, name: str) -
     TypeValidate(origin)(value)
 
     element_type = get_args(TYPE)
-    if origin is list:
-        if len(element_type) != 1:
-            raise TypeError("TYPE must contain only ONE type!")
-
-    elif origin is tuple:
-        if len(element_type) != 2 or element_type[1] is not Ellipsis:
-            raise TypeError("tuple TYPE must contain only ONE type with the form tuple[T, ...]!")
-
-    for index, element in enumerate(value):
-        if not isinstance(element, element_type[0]):
-            raise TypeError(f"{name}[{index}] must be of type {element_type[0].__name__!r}!")
+    validator = SequenceValidate(*element_type)
 
-    return True
+    return validator(value, name=name)
 
-def qtm_constr_validator(value, annotation, name) -> bool:
+def qtm_constr_validator(value: Any, annotation, name: str) -> Any:
     """
     Takes a value and its annotation and compares it against the expected type
     :param value: given value
@@ -48,9 +42,10 @@ def qtm_constr_validator(value, annotation, name) -> bool:
 
     type_obj, *constraints = get_args(annotation)
 
+    TypeValidate(str)(name, name="name")
     TypeValidate(type_obj)(value, name=name)
 
     for constraint in constraints:
         constraint(value)
 
-    return True
+    return value

{universalfunctions-1.1.1 → universalfunctions-1.2.0}/UF/Validators/ValidationClasses.py

@@ -6,7 +6,18 @@ from collections.abc import Callable
 
 
 class TypeValidate:
-    """Makes sure the entered value is of correct type"""
+    """
+    Makes sure the entered value is of correct type.
+
+    >>> TypeValidate(float)(-30.9)
+    -30.9
+    >>> TypeValidate(str)('Hello World')
+    'Hello World'
+    >>> TypeValidate(int)(-10)
+    -10
+    >>> TypeValidate((list, int))([1, "2"])
+    [1, '2']
+    """
     def __init__(self, expected: type | tuple[type, ...]):
         """Makes sure the entered value is a type object"""
         if isinstance(expected, tuple):
@@ -37,27 +48,50 @@ class TypeValidate:
         return value
 
 def int_validate() -> TypeValidate:
-    """Makes sure the entered value is an integer with TypeValidate"""
+    """
+    Makes sure the entered value is an integer with TypeValidate.
+
+    >>> int_validate()(-39)
+    -39
+    """
     return TypeValidate(int)
 
 def str_validate() -> TypeValidate:
-    """Makes sure the entered value is a string with TypeValidate"""
+    """
+    Makes sure the entered value is a string with TypeValidate.
+
+    >>> str_validate()('Hello World')
+    'Hello World'
+    """
     return TypeValidate(str)
 
 def real_validate() -> TypeValidate:
-    """Makes sure the entered value is a real number with TypeValidate"""
+    """
+    Makes sure the entered value is a real number with TypeValidate.
+
+    >>> real_validate()(-10.5)
+    -10.5
+    """
     return TypeValidate(Real)
 
 class RealValidationParent:
+    """
+    Parent class for classes which require an expected real number value when an instance is made of them.
+    """
     def __init__(self, expected: Real) -> None:
         self._validator = real_validate()
         self._validator(expected)
         self.expected = expected
 
 class Positive:
-    """Makes sure the entered value is positive"""
+    """
+    Makes sure the entered value is positive.
+
+    >>> Positive()(50)
+    50
+    """
     def __call__(self, value: Real, name: str|None = None) -> Real:
-        """Validates the entered value, expected to be positive (0 included)"""
+        """Validates the entered value, expected to be positive (above 0)"""
         if name is not None:
             real_validate()(value, name)
         else:
@@ -67,7 +101,12 @@ class Positive:
         return value
 
 class LessThan(RealValidationParent):
-    """Makes sure the entered value is less than expected value"""
+    """
+    Makes sure the entered value is less than expected value.
+
+    >>> LessThan(75)(10)
+    10
+    """
     def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be less than expected value"""
         self._validator(value)
@@ -78,7 +117,14 @@ class LessThan(RealValidationParent):
         return value
 
 class LessOrEqual(RealValidationParent):
-    """Makes sure the entered value is less than or equal to expected value"""
+    """
+    Makes sure the entered value is less than or equal to expected value.
+
+    >>> LessOrEqual(100)(90)
+    90
+    >>> LessOrEqual(50)(50)
+    50
+    """
     def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be less than or equal to expected value"""
         self._validator(value)
@@ -90,7 +136,12 @@ class LessOrEqual(RealValidationParent):
 
 
 class GreaterThan(RealValidationParent):
-    """Makes sure the entered value is greater than expected value"""
+    """
+    Makes sure the entered value is greater than expected value.
+
+    >>> GreaterThan(5)(10)
+    10
+    """
     def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be greater than expected value"""
         self._validator(value)
@@ -101,7 +152,14 @@ class GreaterThan(RealValidationParent):
         return value
 
 class GreaterOrEqual(RealValidationParent):
-    """Makes sure the entered value is greater than or equal to expected value"""
+    """
+    Makes sure the entered value is greater than or equal to expected value.
+
+    >>> GreaterOrEqual(5)(10)
+    10
+    >>> GreaterOrEqual(5)(5)
+    5
+    """
     def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be greater than or equal to expected value"""
         self._validator(value)
@@ -112,7 +170,17 @@ class GreaterOrEqual(RealValidationParent):
         return value
 
 class SequenceValidate:
-    """Makes sure the entered value is a sequence of any value"""
+    """
+    Makes sure the entered value is a sequence of any value.
+
+    >>> validator = SequenceValidate(
+    ...     list,
+    ...     list,
+    ...     callable_items=(SequenceValidate(Real, ...),)
+    ... )
+    >>> validator([[1, 2], [3, 4]])
+    [[1, 2], [3, 4]]
+    """
     def __init__(self, *expected: type | EllipsisType, **kwargs) -> None:
         """Validates and sets the tuple to a variable"""
         for item in expected:

{universalfunctions-1.1.1 → universalfunctions-1.2.0/UniversalFunctions.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UniversalFunctions
-Version: 1.1.1
+Version: 1.2.0
 Summary: A Python utility library providing foundational functions, validators, and infrastructure.
 Author-email: "Miah M. Sabiq" <miah.sabiq@gibs.at>
 Requires-Python: >=3.14

{universalfunctions-1.1.1 → universalfunctions-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "UniversalFunctions"
-version = "1.1.1"
+version = "1.2.0"
 description = "A Python utility library providing foundational functions, validators, and infrastructure."
 readme = "README.md"
 requires-python = ">=3.14"