UniversalFunctions 0.1.0__tar.gz

universalfunctions-0.1.0/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Miah M. Sabiq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, merge, publish, distribute, sublicense,  and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

universalfunctions-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: UniversalFunctions
+Version: 0.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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# UniversalFunctions
+
+UniversalFunctions is a Python utility library providing foundational functions, validators, decorators, type utilities, and infrastructure for building structured Python applications and domain-specific APIs.
+
+It is designed as an independent foundation layer that can be used on its own or as a dependency of larger projects such as GeometricalDomination.
+
+## Installation
+
+Install UniversalFunctions from PyPI:
+
+```bash
+pip install UniversalFunctions
+```
+
+The package requires Python 3.14 or later.
+
+## Usage
+
+UniversalFunctions is imported through the UF Python package:
+
+from UF.Validators import TypeValidate
+from numbers import Real
+
+TypeValidate(Real)(56)
+
+The distribution name is UniversalFunctions, while the Python import package is UF.
+
+## Package Structure
+
+UniversalFunctions is organized into several foundational components:
+
+### UF
+
+The main package containing the core infrastructure and utilities.
+
+### UF.Validators
+
+Provides runtime validation utilities and validation classes for enforcing types, ranges, relationships, and other constraints.
+
+#### Notable components include:
+
+* ``TypeValidate``
+* ``TupleValidate``
+* ``LessThan``
+* ``LessOrEqual``
+* ``GreaterOrEqual``
+* ``Positive``
+* ``real_validate``
+* ``str_validate``
+* Callable validation utilities
+
+The validation system also contains the Quantum Turtle Mechanics (QTM) validation infrastructure used for more structured runtime validation.
+
+### Decorators
+
+UniversalFunctions provides reusable decorator infrastructure, including decorator composition and class-level decorator utilities.
+
+#### Notable components include:
+
+* ``class_decorator``
+* ``deco_superposition``
+* ``cls_deco_superposition``
+* Quantum Turtle Mechanics validation decorators
+
+### Helper Functions
+
+The library contains foundational helper functions intended to be reused by higher-level applications and APIs.
+
+These utilities include mathematical and general-purpose functionality used throughout the surrounding ecosystem.
+
+### Design Philosophy
+
+UniversalFunctions exists as a foundational layer rather than as a standalone end-user application.
+
+Its purpose is to provide reusable infrastructure that higher-level projects can build upon without duplicating common functionality.
+
+The architecture separates foundational utilities from domain-specific functionality, allowing projects to depend on UniversalFunctions independently.
+
+In the GeometricalDomination ecosystem, UniversalFunctions acts as the bridge between the underlying infrastructure and higher-level systems.
+
+### Quantum Dimension
+
+UniversalFunctions contains several architectural concepts inspired by the internal terminology of GeometricalDomination.
+
+#### These include:
+
+* Quantum Turtle Mechanics (QTM)
+* Classical Turtle Mechanics (CTM)
+* Quantum Turtle String Theory (QTST)
+* The Quantum Dimension
+
+These names describe architectural concepts within the project's validation and infrastructure systems.
+
+## Requirements
+Python 3.14 or later
+
+UniversalFunctions is designed for modern Python and makes use of contemporary Python typing and language features.
+
+## Development
+
+Clone the repository and install it in editable mode:
+
+git clone https://github.com/Mangosaber2026/UniversalFunctions.git
+cd UniversalFunctions
+pip install -e .
+
+Editable installation allows changes to the source code to be reflected immediately without reinstalling the package.
+
+## License
+
+UniversalFunctions is distributed under the terms of the license included in this repository.
+
+## Author
+
+Miah M. Sabiq
+
+UniversalFunctions is developed as an independent Python package and serves as foundational infrastructure for larger projects within the author's software ecosystem.

universalfunctions-0.1.0/README.md

@@ -0,0 +1,117 @@
+# UniversalFunctions
+
+UniversalFunctions is a Python utility library providing foundational functions, validators, decorators, type utilities, and infrastructure for building structured Python applications and domain-specific APIs.
+
+It is designed as an independent foundation layer that can be used on its own or as a dependency of larger projects such as GeometricalDomination.
+
+## Installation
+
+Install UniversalFunctions from PyPI:
+
+```bash
+pip install UniversalFunctions
+```
+
+The package requires Python 3.14 or later.
+
+## Usage
+
+UniversalFunctions is imported through the UF Python package:
+
+from UF.Validators import TypeValidate
+from numbers import Real
+
+TypeValidate(Real)(56)
+
+The distribution name is UniversalFunctions, while the Python import package is UF.
+
+## Package Structure
+
+UniversalFunctions is organized into several foundational components:
+
+### UF
+
+The main package containing the core infrastructure and utilities.
+
+### UF.Validators
+
+Provides runtime validation utilities and validation classes for enforcing types, ranges, relationships, and other constraints.
+
+#### Notable components include:
+
+* ``TypeValidate``
+* ``TupleValidate``
+* ``LessThan``
+* ``LessOrEqual``
+* ``GreaterOrEqual``
+* ``Positive``
+* ``real_validate``
+* ``str_validate``
+* Callable validation utilities
+
+The validation system also contains the Quantum Turtle Mechanics (QTM) validation infrastructure used for more structured runtime validation.
+
+### Decorators
+
+UniversalFunctions provides reusable decorator infrastructure, including decorator composition and class-level decorator utilities.
+
+#### Notable components include:
+
+* ``class_decorator``
+* ``deco_superposition``
+* ``cls_deco_superposition``
+* Quantum Turtle Mechanics validation decorators
+
+### Helper Functions
+
+The library contains foundational helper functions intended to be reused by higher-level applications and APIs.
+
+These utilities include mathematical and general-purpose functionality used throughout the surrounding ecosystem.
+
+### Design Philosophy
+
+UniversalFunctions exists as a foundational layer rather than as a standalone end-user application.
+
+Its purpose is to provide reusable infrastructure that higher-level projects can build upon without duplicating common functionality.
+
+The architecture separates foundational utilities from domain-specific functionality, allowing projects to depend on UniversalFunctions independently.
+
+In the GeometricalDomination ecosystem, UniversalFunctions acts as the bridge between the underlying infrastructure and higher-level systems.
+
+### Quantum Dimension
+
+UniversalFunctions contains several architectural concepts inspired by the internal terminology of GeometricalDomination.
+
+#### These include:
+
+* Quantum Turtle Mechanics (QTM)
+* Classical Turtle Mechanics (CTM)
+* Quantum Turtle String Theory (QTST)
+* The Quantum Dimension
+
+These names describe architectural concepts within the project's validation and infrastructure systems.
+
+## Requirements
+Python 3.14 or later
+
+UniversalFunctions is designed for modern Python and makes use of contemporary Python typing and language features.
+
+## Development
+
+Clone the repository and install it in editable mode:
+
+git clone https://github.com/Mangosaber2026/UniversalFunctions.git
+cd UniversalFunctions
+pip install -e .
+
+Editable installation allows changes to the source code to be reflected immediately without reinstalling the package.
+
+## License
+
+UniversalFunctions is distributed under the terms of the license included in this repository.
+
+## Author
+
+Miah M. Sabiq
+
+UniversalFunctions is developed as an independent Python package and serves as foundational infrastructure for larger projects within the author's software ecosystem.

universalfunctions-0.1.0/UF/ClassToDict.py

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

universalfunctions-0.1.0/UF/DecoratorArchive.py

@@ -0,0 +1,37 @@
+"""
+This module contains decorators which take any number of decorators and apply them to the function they are assigned to.
+"""
+
+from collections.abc import Callable
+from .Validators.QuantumFuncValidators import qtm_validation_decorator
+
+
+@qtm_validation_decorator
+def cls_deco_superposition(*decorators: tuple[Callable, ...]) -> Callable:
+    """
+    DECORATOR!!   Creates a class decorator that applies the given decorator to every user defined function
+    :param decorator: provided decorator function
+    :return: a class decorator that transforms the class (& it's functions) and returns it
+    """
+    deco_composer = deco_superposition(*decorators)
+
+    def inner(cls):
+        for name, func in vars(cls).items():
+            if callable(func) and not name.startswith("_"):
+                setattr(cls, name, deco_composer(func))
+        return cls
+    return inner
+
+@qtm_validation_decorator
+def deco_superposition(*decorators: tuple[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
+    """
+    def inner_deco(func):
+        for decorator in reversed(decorators):
+            func = decorator(func)
+
+        return func
+    return inner_deco

universalfunctions-0.1.0/UF/GetVariable.py

@@ -0,0 +1,84 @@
+"""
+This module contains an extremely important function: get_num, which takes a numerical value from the user.
+"""
+
+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
+
+
+type int_type = type[int]
+type float_type = type[float]
+
+@overload
+def get_num(TYPE: int_type, entry: str, **options) -> int: ...
+
+@overload
+def get_num(TYPE: float_type, entry: str, **options) -> float: ...
+
+def get_num(TYPE: float_type|int_type, entry: str, **options) -> Real:
+    """
+    Gets a real numerical value from the user
+
+    :param TYPE: float or int;  which type of value to check for
+    :param entry: str; input string
+    :param options: MAX, MIN, store
+    :return: float or int
+    """
+    if TYPE not in (int, float):
+        raise TypeError("TYPE must be type float or int")
+
+    str_validate()(entry, name="entry")
+
+    for item in ("MAX", "MIN"):
+        if item in options:
+            real_validate()(options[item], name=item)
+
+    if "MIN" in options and "MAX" in options:
+        LessThan(options["MAX"])(options["MIN"])
+
+    if "store" in options:
+        TypeValidate((Real, type(None)))(options["store"], name="store")
+
+    if (
+        "store" in options
+        and "MIN" in options
+        and "MAX" in options
+        and options["store"] is not None
+        and (options["MIN"] > options["store"] or options["MAX"] < options["store"])
+    ):
+        raise ValueError("Stored value must be between MIN and MAX!")
+
+    while True:
+        try:
+            if "store" in options:
+                reserve: str = input(entry)
+                if reserve == "ans":
+                    if isinstance(options["store"], Real):
+                        value: Real = options["store"]
+                    else:
+                        print("\nThere is no value stored yet!")
+                        continue
+                else:
+                    value: Real = TYPE(reserve)
+            else:
+                value: Real = TYPE(input(entry))
+            value_name: Literal["value"] = "value"
+
+            if "MIN" in options and "MAX" in options:
+                GreaterOrEqual(options["MIN"])(value, name=value_name)
+                LessOrEqual(options["MAX"])(value, name=value_name)
+
+            elif "MIN" in options:
+                GreaterOrEqual(options["MIN"])(value, name=value_name)
+
+            elif "MAX" in options:
+                LessOrEqual(options["MAX"])(value, name=value_name)
+
+            elif "store" in options:
+                options["store"] = value
+            return value
+        except ValueError as error:
+            print(error)
+            rest(1.5)

universalfunctions-0.1.0/UF/HelperFunctions.py

@@ -0,0 +1,122 @@
+"""
+This module contains the HelperFunctions class which provides a collection of reusable helper functions
+so that the user can easily use them without having to write the code for them again.
+
+Some other functions:
+
+sine -> calculates sine value
+
+range_f -> acts like the conventional range function except for that this takes rational inputs
+"""
+
+from typing import Any, Annotated
+from collections.abc import Generator
+from math import sqrt, sin, radians, cos
+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 numbers import Real
+
+
+@cls_deco_superposition(staticmethod)
+class HelperFunctions:
+
+    def intervals_f() -> Real:
+        """Asks the user for rational intervals"""
+        interval_num: float = get_num(float, "Enter intervals(ℚ>0): ", MIN=0)
+        return interval_num
+
+    def length_float() -> Real:
+        """Asks the user for rational lengths"""
+        length: float = get_num(float, "Enter side length(ℚ>0): ", MIN=0)
+        return length
+
+    def radius_float() -> Real:
+        """Asks the user for rational radius"""
+        radius: float = get_num(float, "Enter radius(ℚ>0): ", MIN=0)
+        return radius
+
+    def object_num() -> int:
+        """Asks the user for the number of objects"""
+        object_count: int = get_num(int, "Enter object count(ℕ≥1): ", MIN=1)
+        return object_count
+
+    def sides_num() -> int:
+        """Asks the user for the number of sides"""
+        sides: int = get_num(int, "Enter sides count(ℕ≥3): ", MIN=3)
+        return sides
+
+    def row_num() -> int:
+        """Asks the user for the number of rows"""
+        row_count: int = get_num(int, "Enter row count(ℕ≥1): ", MIN=1)
+        return row_count
+
+    def row_pair() -> int:
+        """Asks the user for the number of pairs of rows"""
+        row_count: int = get_num(int, "Enter row pairs count(ℕ≥1): ", MIN=1)
+        return row_count
+
+    @qtm_validation_decorator
+    def diameter_sq(length: Annotated[Real, Positive()]) -> tuple[Real,Real]:
+        """
+        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
+
+    def x_ft() -> Real:
+        """Asks the user for the x value (on the coordinate system)"""
+        x_val: float = get_num(float, "Enter x value: ")
+        return x_val
+
+    def y_ft() -> Real:
+        """Asks the user for the y value (on the coordinate system)"""
+        y_val: float = get_num(float, "Enter y value: ")
+        return y_val
+
+    def list_helperfunctions() -> dict:
+        """
+        Creates a dictionary with all helper functions
+        :return: dictionary
+        """
+        return classes_to_dict(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 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
+    :param stop: stop value; Real number >= start
+    :param step: step value; Real number > 0
+    """
+    LessThan(stop)(start)
+
+    while start < stop:
+        yield start
+        start += step

universalfunctions-0.1.0/UF/StringCheck.py

@@ -0,0 +1,25 @@
+"""
+This module contains an extremely important function: get_str, which takes a string input from the user.
+"""
+
+from time import sleep as rest
+from .Validators.ValidationClasses import TypeValidate, str_validate
+
+
+def get_str(str_input: str, *check_values) -> str:
+    """
+    Checks whether the input string matches the allowed values (*check_values)
+    :param str_input: input string
+    :param check_values: allowed string values (all lowercase), options: str, dict, list, tuple
+    """
+    str_validate()(str_input, name="str_input")
+    while True:
+        value: str = input(str_input).lower()
+        for check in check_values:
+            TypeValidate((str, dict, list, tuple))(check, name="check")
+            if isinstance(check, str) and check == value:
+                return value
+            elif isinstance(check, (dict, list, tuple)) and value in check:
+                return value
+        print("Enter something VALID!")
+        rest(1.5)

universalfunctions-0.1.0/UF/Validators/QuantumFuncValidators.py

@@ -0,0 +1,59 @@
+"""
+This module contains a validator and decorator from the QTM Dimension.
+"""
+
+from collections.abc import Callable
+from inspect import signature
+from typing import get_origin, Annotated
+from .QuantumValidators import qtm_lt_validator, qtm_constr_validator
+from functools import wraps
+from .ValidationClasses import TypeValidate
+
+
+def qtm_func_validator(func: Callable, *args, **kwargs) -> bool:
+    """
+    Takes a function and compares the entered value with the expected type
+    :param func: given function
+    :param args: arguments
+    :param kwargs: keyword arguments
+    :return: True if the provided argument matches the expected type, raises an error if not
+    """
+    TypeValidate(Callable)(func, name=func.__name__)
+    sig = signature(func)
+    bound = sig.bind(*args, **kwargs)
+
+    for name, value in bound.arguments.items():
+        parameter = sig.parameters[name]
+        type_ = parameter.annotation
+
+        if type_ is parameter.empty:
+            continue
+
+        origin = get_origin(type_)
+
+        if origin in (list, tuple):
+            qtm_lt_validator(value, type_, name)
+
+        elif origin is Annotated:
+            qtm_constr_validator(value, type_, name)
+
+        else:
+            TypeValidate(type_)(value, name=name)
+
+    return True
+
+def qtm_validation_decorator(func: Callable) -> Callable:
+    """
+    DECORATOR!
+
+    Decorates a function with the quantum function validator and returns the function
+    :param func: provided function
+    :return: validated function
+    """
+    TypeValidate(Callable)(func, name=func.__name__)
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        qtm_func_validator(func, *args, **kwargs)
+        return func(*args, **kwargs)
+    return wrapper

universalfunctions-0.1.0/UF/Validators/QuantumValidators.py

@@ -0,0 +1,56 @@
+"""
+This module contains type validators for list and tuple which belong to the QTM Dimension.
+"""
+
+from typing import Any, get_args, get_origin, Annotated
+from .ValidationClasses import TypeValidate
+
+def qtm_lt_validator(value: list[Any] | tuple[Any, ...], TYPE: Any, name: str) -> bool:
+    """
+    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]
+    :param name: name of value
+    :return: True if the contents of value satisfy the expected type
+    """
+    origin = get_origin(TYPE)
+    if origin not in (list, tuple):
+        raise TypeError(f"{TYPE} must be a list or tuple for a specific type! e.g. list[int]")
+
+    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}!")
+
+    return True
+
+def qtm_constr_validator(value, annotation, name) -> bool:
+    """
+    Takes a value and its annotation and compares it against the expected type
+    :param value: given value
+    :param annotation: given annotation
+    :param name: name of value
+    :return: True, if validation succeeds
+    """
+
+    if get_origin(annotation) is not Annotated:
+        raise TypeError(f"{annotation} is not an Annotated type!")
+
+    type_obj, *constraints = get_args(annotation)
+
+    TypeValidate(type_obj)(value, name=name)
+
+    for constraint in constraints:
+        constraint(value)
+
+    return True

universalfunctions-0.1.0/UF/Validators/ValidationClasses.py

@@ -0,0 +1,128 @@
+from typing import Any
+from numbers import Real
+
+
+class TypeValidate:
+    """Makes sure the entered value is of correct type"""
+    def __init__(self, expected: type | tuple[type, ...]):
+        """Makes sure the entered value is a type object"""
+        if isinstance(expected, tuple):
+            for item in expected:
+                if not isinstance(item, type):
+                    raise TypeError(f"Entered value {item!r} is not a type object!")
+            self.expected = expected
+
+        elif isinstance(expected, type):
+            self.expected = expected
+
+        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:
+        """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!")
+
+        if not isinstance(value, self.expected):
+            if type(self.expected) is type:
+                if name is not None:
+                    raise TypeError(f"{name} is not of expected type {self.expected.__name__!r}!")
+                raise TypeError(f"{value!r} is not of expected type {self.expected.__name__!r}!")
+            elif type(self.expected) is tuple:
+                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
+
+def int_validate() -> TypeValidate:
+    """Makes sure the entered value is an integer with TypeValidate"""
+    return TypeValidate(int)
+
+def str_validate() -> TypeValidate:
+    """Makes sure the entered value is a string with TypeValidate"""
+    return TypeValidate(str)
+
+def real_validate() -> TypeValidate:
+    """Makes sure the entered value is a real number with TypeValidate"""
+    return TypeValidate(Real)
+
+class RealValidationParent:
+    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"""
+    def __call__(self, value: Real, name: str|None = None) -> bool:
+        """Validates the entered value, expected to be positive (0 included)"""
+        if name is not None:
+            real_validate()(value, name)
+        else:
+            real_validate()(value)
+        if value <= 0:
+            raise ValueError(f"Entered value is expected to be greater than 0!")
+        return True
+
+class LessThan(RealValidationParent):
+    """Makes sure the entered value is less than expected value"""
+    def __call__(self, value: Real, name: str|None = None) -> bool:
+        """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
+
+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:
+        """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
+
+
+class GreaterThan(RealValidationParent):
+    """Makes sure the entered value is greater than expected value"""
+    def __call__(self, value: Real, name: str|None = None) -> bool:
+        """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
+
+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:
+        """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
+
+class TupleValidate:
+    """Makes sure the entered value is a tuple of any value"""
+    def __init__(self, *expected: type) -> None:
+        """Validates and sets the tuple to a variable"""
+        for item in expected:
+            TypeValidate(type)(item)
+        self.expected = expected
+
+    def __call__(self, value: tuple, name: str|None = None) -> bool:
+        """Validates the entered value, expected to be a tuple of expected value/s"""
+        TypeValidate(tuple)(value)
+        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

universalfunctions-0.1.0/UF/Validators/__init__.py

@@ -0,0 +1,16 @@
+"""
+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
+"""

universalfunctions-0.1.0/UF/__init__.py

@@ -0,0 +1,19 @@
+"""
+Welcome to the bridge between the Quantum Dimension and Python
+
+Here you will be able to explore the lower floors of the upper software!
+
+Nevertheless, be aware, even though you may use the reusable functions as much as you want,
+not only do you have to credit the author, but also make sure you DO NOT change anything unless you
+have become an official contributor.
+
+__________ Quantum Dimension __________
+
+Quantum Turtle Mechanics:  an extremely specialized sector where the author decided to implement
+functions such as qtm_validation_decorator. This is a decorator which one can apply to a function to
+make sure the Wave Function of each entered variable collapses into one.
+
+Classical Turtle Mechanics: also a specialized sector, where the functions are closer to 'normal' Python
+functions. These are still extremely important to the rest of the main package and must therefore
+not be changed!
+"""

universalfunctions-0.1.0/UniversalFunctions.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: UniversalFunctions
+Version: 0.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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# UniversalFunctions
+
+UniversalFunctions is a Python utility library providing foundational functions, validators, decorators, type utilities, and infrastructure for building structured Python applications and domain-specific APIs.
+
+It is designed as an independent foundation layer that can be used on its own or as a dependency of larger projects such as GeometricalDomination.
+
+## Installation
+
+Install UniversalFunctions from PyPI:
+
+```bash
+pip install UniversalFunctions
+```
+
+The package requires Python 3.14 or later.
+
+## Usage
+
+UniversalFunctions is imported through the UF Python package:
+
+from UF.Validators import TypeValidate
+from numbers import Real
+
+TypeValidate(Real)(56)
+
+The distribution name is UniversalFunctions, while the Python import package is UF.
+
+## Package Structure
+
+UniversalFunctions is organized into several foundational components:
+
+### UF
+
+The main package containing the core infrastructure and utilities.
+
+### UF.Validators
+
+Provides runtime validation utilities and validation classes for enforcing types, ranges, relationships, and other constraints.
+
+#### Notable components include:
+
+* ``TypeValidate``
+* ``TupleValidate``
+* ``LessThan``
+* ``LessOrEqual``
+* ``GreaterOrEqual``
+* ``Positive``
+* ``real_validate``
+* ``str_validate``
+* Callable validation utilities
+
+The validation system also contains the Quantum Turtle Mechanics (QTM) validation infrastructure used for more structured runtime validation.
+
+### Decorators
+
+UniversalFunctions provides reusable decorator infrastructure, including decorator composition and class-level decorator utilities.
+
+#### Notable components include:
+
+* ``class_decorator``
+* ``deco_superposition``
+* ``cls_deco_superposition``
+* Quantum Turtle Mechanics validation decorators
+
+### Helper Functions
+
+The library contains foundational helper functions intended to be reused by higher-level applications and APIs.
+
+These utilities include mathematical and general-purpose functionality used throughout the surrounding ecosystem.
+
+### Design Philosophy
+
+UniversalFunctions exists as a foundational layer rather than as a standalone end-user application.
+
+Its purpose is to provide reusable infrastructure that higher-level projects can build upon without duplicating common functionality.
+
+The architecture separates foundational utilities from domain-specific functionality, allowing projects to depend on UniversalFunctions independently.
+
+In the GeometricalDomination ecosystem, UniversalFunctions acts as the bridge between the underlying infrastructure and higher-level systems.
+
+### Quantum Dimension
+
+UniversalFunctions contains several architectural concepts inspired by the internal terminology of GeometricalDomination.
+
+#### These include:
+
+* Quantum Turtle Mechanics (QTM)
+* Classical Turtle Mechanics (CTM)
+* Quantum Turtle String Theory (QTST)
+* The Quantum Dimension
+
+These names describe architectural concepts within the project's validation and infrastructure systems.
+
+## Requirements
+Python 3.14 or later
+
+UniversalFunctions is designed for modern Python and makes use of contemporary Python typing and language features.
+
+## Development
+
+Clone the repository and install it in editable mode:
+
+git clone https://github.com/Mangosaber2026/UniversalFunctions.git
+cd UniversalFunctions
+pip install -e .
+
+Editable installation allows changes to the source code to be reflected immediately without reinstalling the package.
+
+## License
+
+UniversalFunctions is distributed under the terms of the license included in this repository.
+
+## Author
+
+Miah M. Sabiq
+
+UniversalFunctions is developed as an independent Python package and serves as foundational infrastructure for larger projects within the author's software ecosystem.

universalfunctions-0.1.0/UniversalFunctions.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+UF/ClassToDict.py
+UF/DecoratorArchive.py
+UF/GetVariable.py
+UF/HelperFunctions.py
+UF/StringCheck.py
+UF/__init__.py
+UF/Validators/QuantumFuncValidators.py
+UF/Validators/QuantumValidators.py
+UF/Validators/ValidationClasses.py
+UF/Validators/__init__.py
+UniversalFunctions.egg-info/PKG-INFO
+UniversalFunctions.egg-info/SOURCES.txt
+UniversalFunctions.egg-info/dependency_links.txt
+UniversalFunctions.egg-info/top_level.txt

universalfunctions-0.1.0/UniversalFunctions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

universalfunctions-0.1.0/UniversalFunctions.egg-info/top_level.txt

@@ -0,0 +1 @@
+UF

universalfunctions-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "UniversalFunctions"
+version = "0.1.0"
+description = "A Python utility library providing foundational functions, validators, and infrastructure."
+readme = "README.md"
+requires-python = ">=3.14"
+
+authors = [
+    { name = "Miah M. Sabiq", email = "miah.sabiq@gibs.at"}
+]
+
+[tool.setuptools.packages.find]
+include = [
+    "UF*",
+]

universalfunctions-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+