UniversalFunctions 1.0.0__tar.gz → 1.1.0__tar.gz

{universalfunctions-1.0.0/UniversalFunctions.egg-info → universalfunctions-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UniversalFunctions
-Version: 1.0.0
+Version: 1.1.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.0.0 → universalfunctions-1.1.0}/UF/HelperFunctions.py

@@ -11,7 +11,7 @@ range_f -> acts like the conventional range function except for that this takes
 
 from typing import Any, Annotated
 from collections.abc import Generator
-from math import sqrt, sin, radians, cos, asin, degrees
+from math import sqrt
 from .GetVariable import get_num
 from .DecoratorArchive import cls_deco_superposition
 from .ClassToDict import classes_to_dict
@@ -89,33 +89,6 @@ class HelperFunctions:
 
 helper = HelperFunctions
 
-@qtm_validation_decorator
-def sine(angle: Real) -> Real:
-    """
-    Calculates the sine of a given angle
-    :param angle: value required in degrees
-    :return: sine value
-    """
-    return sin(radians(angle))
-
-@qtm_validation_decorator
-def cosine(angle: Real) -> Real:
-    """
-    Calculates the cosine of a given angle
-    :param angle: value required in degrees
-    :return: cosine value
-    """
-    return cos(radians(angle))
-
-@qtm_validation_decorator
-def asine(angle: Real) -> Real:
-    """
-    Calculates the asine of a given angle
-    :param angle: real value
-    :return: asine value
-    """
-    return degrees(asin(angle))
-
 @qtm_validation_decorator
 def range_f(start: Real, stop: Real, step: Annotated[Real, Positive()]) -> Generator[Real,Any,None]:
     """

universalfunctions-1.1.0/UF/Trigonometry.py

@@ -0,0 +1,37 @@
+from math import (
+    radians,
+    degrees,
+    sin,
+    cos,
+    asin,
+)
+from numbers import Real
+from .Validators.QuantumFuncValidators import qtm_validation_decorator
+
+
+@qtm_validation_decorator
+def sine(angle: Real) -> Real:
+    """
+    Calculates the sine of a given angle
+    :param angle: value required in degrees
+    :return: sine value
+    """
+    return sin(radians(angle))
+
+@qtm_validation_decorator
+def cosine(angle: Real) -> Real:
+    """
+    Calculates the cosine of a given angle
+    :param angle: value required in degrees
+    :return: cosine value
+    """
+    return cos(radians(angle))
+
+@qtm_validation_decorator
+def asine(angle: Real) -> Real:
+    """
+    Calculates the asine of a given angle
+    :param angle: real value
+    :return: asine value
+    """
+    return degrees(asin(angle))

{universalfunctions-1.0.0 → universalfunctions-1.1.0}/UF/Validators/ValidationClasses.py

@@ -1,5 +1,8 @@
 from typing import Any
 from numbers import Real
+from types import EllipsisType
+from itertools import cycle
+from collections.abc import Callable
 
 
 class TypeValidate:
@@ -17,7 +20,7 @@ class TypeValidate:
 
         else:
             raise TypeError(f"Parameter 'expected' MUST be a type object or a tuple of type objects!")
-    def __call__(self, value: Any, name: str | None = None) -> bool:
+    def __call__(self, value: Any, name: str | None = None) -> Any:
         """Validates the entered value, expected to be of expected type"""
         if name is not None and not isinstance(name, str):
             raise TypeError(f"Parameter 'name' MUST be a string object!")
@@ -31,7 +34,7 @@ class TypeValidate:
                 if name is not None:
                     raise TypeError(f"{name} is not of expected type {self.expected!r}!")
                 raise TypeError(f"{value!r} is not of expected type {self.expected!r}!")
-        return True
+        return value
 
 def int_validate() -> TypeValidate:
     """Makes sure the entered value is an integer with TypeValidate"""
@@ -53,7 +56,7 @@ class RealValidationParent:
 
 class Positive:
     """Makes sure the entered value is positive"""
-    def __call__(self, value: Real, name: str|None = None) -> bool:
+    def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be positive (0 included)"""
         if name is not None:
             real_validate()(value, name)
@@ -61,68 +64,99 @@ class Positive:
             real_validate()(value)
         if value <= 0:
             raise ValueError(f"Entered value is expected to be greater than 0!")
-        return True
+        return value
 
 class LessThan(RealValidationParent):
     """Makes sure the entered value is less than expected value"""
-    def __call__(self, value: Real, name: str|None = None) -> bool:
+    def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be less than expected value"""
         self._validator(value)
         if name is not None:
             str_validate()(name, "name")
         if value >= self.expected:
             raise ValueError(f"Entered value ({name}) is expected to be less than {self.expected!r}!")
-        return True
+        return value
 
 class LessOrEqual(RealValidationParent):
     """Makes sure the entered value is less than or equal to expected value"""
-    def __call__(self, value: Real, name: str|None = None) -> bool:
+    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)
         if name is not None:
             str_validate()(name, "name")
         if value > self.expected:
             raise ValueError(f"Entered value ({name}) is expected to be less than or equal to {self.expected!r}!")
-        return True
+        return value
 
 
 class GreaterThan(RealValidationParent):
     """Makes sure the entered value is greater than expected value"""
-    def __call__(self, value: Real, name: str|None = None) -> bool:
+    def __call__(self, value: Real, name: str|None = None) -> Real:
         """Validates the entered value, expected to be greater than expected value"""
         self._validator(value)
         if name is not None:
             str_validate()(name, "name")
         if self.expected >= value:
             raise ValueError(f"Entered value ({name}) is expected to be greater than {self.expected!r}!")
-        return True
+        return value
 
 class GreaterOrEqual(RealValidationParent):
     """Makes sure the entered value is greater than or equal to expected value"""
-    def __call__(self, value: Real, name: str|None = None) -> bool:
+    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)
         if name is not None:
             str_validate()(name, "name")
         if self.expected > value:
             raise ValueError(f"Entered value ({name}) is expected to be greater than or equal to {self.expected!r}!")
-        return True
+        return value
 
-class TupleValidate:
-    """Makes sure the entered value is a tuple of any value"""
-    def __init__(self, *expected: type) -> None:
+class SequenceValidate:
+    """Makes sure the entered value is a sequence of any value"""
+    def __init__(self, *expected: type | EllipsisType, **kwargs) -> None:
         """Validates and sets the tuple to a variable"""
         for item in expected:
-            TypeValidate(type)(item)
+            if item is not Ellipsis:
+                TypeValidate(type)(item)
+            else:
+                if expected[-1] is not Ellipsis:
+                    raise ValueError(f"Entered value ({expected[-1]}) is expected to be an ellipsis type!")
+
         self.expected = expected
 
-    def __call__(self, value: tuple, name: str|None = None) -> bool:
+        callable_name = "callable_items"
+        self.callables = ()
+
+        if callable_name in kwargs:
+            TypeValidate(tuple)(kwargs[callable_name], callable_name)
+            for func in kwargs[callable_name]:
+                TypeValidate(Callable)(func)
+
+            self.callables = kwargs[callable_name]
+
+    def __call__(self, value: tuple|list, name: str|None = None) -> tuple|list:
         """Validates the entered value, expected to be a tuple of expected value/s"""
-        TypeValidate(tuple)(value)
+        if not isinstance(value, (tuple, list)):
+            raise TypeError(f"Entered value ({name}) is expected to be a tuple or list!")
+
         if name is not None:
             str_validate()(name, "name")
-        if len(self.expected) != len(value):
-            raise ValueError(f"Entered value ({name}) must have the same number of elements as the provided expected tuple!")
-        for expected_type, actual_value in zip(self.expected, value):
-            TypeValidate(expected_type)(actual_value)
-        return True
+        type_store = []
+        if isinstance(self.expected[-1], EllipsisType):
+            for item in self.expected:
+                if not isinstance(item, EllipsisType):
+                    type_store.append(item)
+
+            for given_obj, expected_type in zip(value, cycle(type_store)):
+                TypeValidate(expected_type)(given_obj)
+                for func in self.callables:
+                    func(given_obj)
+
+        else:
+            if len(self.expected) != len(value):
+                raise ValueError(f"Entered value ({name}) must have the same number of elements as the provided expected tuple!")
+            for expected_type, actual_value in zip(self.expected, value):
+                TypeValidate(expected_type)(actual_value)
+                for func in self.callables:
+                    func(actual_value)
+        return value

{universalfunctions-1.0.0 → universalfunctions-1.1.0}/UF/__init__.py

@@ -24,12 +24,10 @@ from .GetVariable import get_num
 from .HelperFunctions import (
     helper,
     HelperFunctions,
-    sine,
-    cosine,
-    asine,
     range_f,
 )
 from .StringCheck import get_str
+from .Trigonometry import sine, cosine, asine
 from .Validators.ValidationClasses import (
     TypeValidate,
     Positive,

{universalfunctions-1.0.0 → universalfunctions-1.1.0/UniversalFunctions.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UniversalFunctions
-Version: 1.0.0
+Version: 1.1.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.0.0 → universalfunctions-1.1.0}/UniversalFunctions.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ UF/DecoratorArchive.py
 UF/GetVariable.py
 UF/HelperFunctions.py
 UF/StringCheck.py
+UF/Trigonometry.py
 UF/__init__.py
 UF/Validators/QuantumFuncValidators.py
 UF/Validators/QuantumValidators.py

{universalfunctions-1.0.0 → universalfunctions-1.1.0}/pyproject.toml

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