UniversalFunctions 1.1.1__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UniversalFunctions
-Version: 1.1.1
+Version: 1.3.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.3.0}/UF/ClassToDict.py

@@ -3,17 +3,24 @@ This module contains a function that takes all functions in a class and make a d
 """
 
 from collections.abc import Callable
-from .Validators.QuantumFuncValidators import qtm_validation_decorator
+from .Validators import SequenceValidate
 
 
-@qtm_validation_decorator
-def classes_to_dict(*classes: tuple[type, ...]) -> dict[str, Callable]:
+def classes_to_dict(*classes: type) -> dict[str, Callable]:
     """
     Extracts callable objects from the given classes and returns them
     as a dictionary mapping their names to the corresponding objects
+
+    >>> class RandomClass:
+    ...     def get_item(self):
+    ...         pass
+    >>> result = classes_to_dict(RandomClass)
+    >>> list(result)
+    ['get_item']
     :param classes: Classes from which the callables are extracted
     :return: Dictionary of callable names and their objects
     """
+    SequenceValidate(type, ...)(classes, name="classes")
     dictionary = {}
     for cls in classes:
         dictionary.update({

{universalfunctions-1.1.1 → universalfunctions-1.3.0}/UF/DecoratorArchive.py

@@ -3,16 +3,16 @@ This module contains decorators which take any number of decorators and apply th
 """
 
 from collections.abc import Callable
-from .Validators.QuantumFuncValidators import qtm_validation_decorator
+from .Validators import SequenceValidate
 
 
-@qtm_validation_decorator
-def cls_deco_superposition(*decorators: tuple[Callable, ...]) -> Callable:
+def cls_deco_superposition(*decorators: Callable) -> Callable:
     """
     DECORATOR!!   Creates a class decorator that applies the given decorator to every user defined function
-    :param decorator: provided decorator function
+    :param decorators: provided decorator functions
     :return: a class decorator that transforms the class (& it's functions) and returns it
     """
+    SequenceValidate(Callable, ...)(decorators, name="decorators")
     deco_composer = deco_superposition(*decorators)
 
     def inner(cls):
@@ -22,13 +22,13 @@ def cls_deco_superposition(*decorators: tuple[Callable, ...]) -> Callable:
         return cls
     return inner
 
-@qtm_validation_decorator
-def deco_superposition(*decorators: tuple[Callable, ...]) -> Callable:
+def deco_superposition(*decorators: Callable) -> Callable:
     """
     DECORATOR! this decorator takes multiple decorators and applies them to the given function the same way python would naturally
     :param decorators: decorator functions
     :return: supplied function
     """
+    SequenceValidate(Callable, ...)(decorators, name="decorators")
     def inner_deco(func):
         for decorator in reversed(decorators):
             func = decorator(func)

{universalfunctions-1.1.1 → universalfunctions-1.3.0}/UF/GetVariable.py

@@ -5,7 +5,14 @@ This module contains an extremely important function: get_num, which takes a num
 from time import sleep as rest
 from typing import overload, Literal
 from numbers import Real
-from .Validators.ValidationClasses import LessThan, str_validate, real_validate, TypeValidate, GreaterOrEqual, LessOrEqual
+from .Validators import (
+    LessThan,
+    str_validate,
+    real_validate,
+    TypeValidate,
+    GreaterOrEqual,
+    LessOrEqual
+)
 
 
 type int_type = type[int]

{universalfunctions-1.1.1 → universalfunctions-1.3.0}/UF/HelperFunctions.py

@@ -15,14 +15,13 @@ from math import sqrt
 from .GetVariable import get_num
 from .DecoratorArchive import cls_deco_superposition
 from .ClassToDict import classes_to_dict
-from .Validators.QuantumFuncValidators import qtm_validation_decorator
-from .Validators.ValidationClasses import LessThan, Positive
+from .Validators import qtm_validation_decorator, LessThan, Positive
 from numbers import Real
 
 
 @cls_deco_superposition(staticmethod)
 class HelperFunctions:
-
+    """This class provides a collection of reusable helper functions"""
     def intervals_f() -> Real:
         """Asks the user for rational intervals"""
         interval_num: float = get_num(float, "Enter intervals(ℚ>0): ", MIN=0)
@@ -64,8 +63,6 @@ class HelperFunctions:
         Calculates the diameter of a square with given length
         :return: diameter, diameter/2
         """
-        if length <= 0:
-            raise ValueError("Length must be greater than 0")
 
         diameter: float = length*sqrt(2); d_half: Real = diameter / 2
         return diameter, d_half
@@ -90,7 +87,11 @@ class HelperFunctions:
 helper = HelperFunctions
 
 @qtm_validation_decorator
-def range_f(start: Real, stop: Real, step: Annotated[Real, Positive()]) -> Generator[Real,Any,None]:
+def range_f(
+        start: Real,
+        stop: Real,
+        step: Annotated[Real, Positive()]
+) -> Generator[Real,Any,None]:
     """
     Lets the user choose Real inputs for start, stop and step
     :param start: start value; Real number

{universalfunctions-1.1.1 → universalfunctions-1.3.0}/UF/StringCheck.py

@@ -3,7 +3,7 @@ This module contains an extremely important function: get_str, which takes a str
 """
 
 from time import sleep as rest
-from .Validators.ValidationClasses import TypeValidate, str_validate
+from .Validators import TypeValidate, str_validate
 
 
 def get_str(str_input: str, *check_values) -> str:

{universalfunctions-1.1.1 → universalfunctions-1.3.0}/UF/Trigonometry.py

@@ -6,32 +6,32 @@ from math import (
     asin,
 )
 from numbers import Real
-from .Validators.QuantumFuncValidators import qtm_validation_decorator
+from .Validators import real_validate
 
 
-@qtm_validation_decorator
 def sine(angle: Real) -> Real:
     """
     Calculates the sine of a given angle
     :param angle: value required in degrees
     :return: sine value
     """
+    real_validate()(angle, name="angle")
     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
     """
+    real_validate()(angle, name="angle")
     return cos(radians(angle))
 
-@qtm_validation_decorator
-def asine(angle: Real) -> Real:
+def asine(value: Real) -> Real:
     """
     Calculates the asine of a given angle
-    :param angle: real value
+    :param value: real value
     :return: asine value
     """
-    return degrees(asin(angle))
+    real_validate()(value, name="value")
+    return degrees(asin(value))

{universalfunctions-1.1.1 → universalfunctions-1.3.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.3.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.3.0/UF/Validators/__init__.py

@@ -0,0 +1,58 @@
+"""
+Welcome to the Quantum/Classical Dimension!
+
+Here you will find some of the most sensitive pieces of code, however you may gladly use the validators,
+no matter quantum or classic.
+But whatever you do, DO NOT change the actual functions, otherwise, the entire
+software will cease to function.
+Almost every single other module in this software relies on the quantum validation centers, if anything is changed
+inappropriately, the user shall face serious consequences.
+
+Abbreviations:
+    qtm = Quantum Turtle Mechanics
+    ctm = Classical Turtle Mechanics
+
+All functions with qtm belong to the Quantum Dimension whereas all functions with ctm belong to the Classical Dimension
+"""
+
+from .QuantumFuncValidators import qtm_validation_decorator, qtm_func_validator
+from .QuantumValidators import qtm_lt_validator, qtm_constr_validator
+from .ValidationClasses import (
+    TypeValidate,
+    int_validate,
+    str_validate,
+    real_validate,
+    Positive,
+    LessThan,
+    LessOrEqual,
+    GreaterThan,
+    GreaterOrEqual,
+    SequenceValidate,
+    RealValidationParent,
+)
+
+from . import QuantumFuncValidators
+from . import QuantumValidators
+from . import ValidationClasses
+
+__all__ = [
+    "qtm_validation_decorator",
+    "qtm_func_validator",
+    "qtm_lt_validator",
+    "qtm_constr_validator",
+    "TypeValidate",
+    "int_validate",
+    "str_validate",
+    "real_validate",
+    "Positive",
+    "LessThan",
+    "LessOrEqual",
+    "GreaterThan",
+    "GreaterOrEqual",
+    "SequenceValidate",
+    "RealValidationParent",
+
+    "QuantumFuncValidators",
+    "QuantumValidators",
+    "ValidationClasses",
+]

{universalfunctions-1.1.1 → universalfunctions-1.3.0}/UF/__init__.py

@@ -28,20 +28,15 @@ from .HelperFunctions import (
 )
 from .StringCheck import get_str
 from .Trigonometry import sine, cosine, asine
-from .Validators.ValidationClasses import (
-    TypeValidate,
-    Positive,
-    int_validate,
-    str_validate,
-    real_validate,
-    LessThan,
-    LessOrEqual,
-    GreaterThan,
-    GreaterOrEqual,
-    SequenceValidate,
-)
-from .Validators.QuantumFuncValidators import qtm_validation_decorator, qtm_func_validator
-from .Validators.QuantumValidators import qtm_constr_validator, qtm_lt_validator
+from .Validators import *
+
+from . import ClassToDict
+from . import DecoratorArchive
+from . import GetVariable
+from . import HelperFunctions as HelperFunctionsModule
+from . import StringCheck
+from . import Trigonometry
+from . import Validators
 
 __all__ = [
     "classes_to_dict",
@@ -68,5 +63,13 @@ __all__ = [
     "qtm_validation_decorator",
     "qtm_func_validator",
     "qtm_constr_validator",
-    "qtm_lt_validator"
+    "qtm_lt_validator",
+
+    "ClassToDict",
+    "DecoratorArchive",
+    "GetVariable",
+    "HelperFunctionsModule",
+    "StringCheck",
+    "Trigonometry",
+    "Validators",
 ]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UniversalFunctions
-Version: 1.1.1
+Version: 1.3.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.3.0}/pyproject.toml

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

universalfunctions-1.1.1/UF/Validators/__init__.py

@@ -1,16 +0,0 @@
-"""
-Welcome to the Quantum/Classical Dimension!
-
-Here you will find some of the most sensitive pieces of code, however you may gladly use the validators,
-no matter quantum or classic.
-But whatever you do, DO NOT change the actual functions, otherwise, the entire
-software will cease to function.
-Almost every single other module in this software relies on the quantum validation centers, if anything is changed
-inappropriately, the user shall face serious consequences.
-
-Abbreviations:
-    qtm = Quantum Turtle Mechanics
-    ctm = Classical Turtle Mechanics
-
-All functions with qtm belong to the Quantum Dimension whereas all functions with ctm belong to the Classical Dimension
-"""