danielutils 1.1.28__py3-none-any.whl

danielutils/decorators/validate.py

@@ -0,0 +1,227 @@
+import functools
+import inspect
+import logging
+from typing import Callable, get_type_hints, cast, TypeVar, Union
+from ..functions.isoftype import isoftype
+from ..reflection import get_function_return_type
+from ..exceptions import EmptyAnnotationException, \
+    InvalidDefaultValueException, ValidationException, InvalidReturnValueException
+from ..versioned_imports import ParamSpec
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+T = TypeVar("T")
+P = ParamSpec("P")
+FuncT = Callable[P, T]  # type:ignore
+
+
+def validate(strict: Union[FuncT, bool] = True) -> FuncT:
+    """A decorator that validates the annotations and types of the arguments and return
+    value of a function.
+
+        * 'None' is allowed as default value for everything
+        * Because of their wide known use, generally accepted keywords 'self', 'cls', 'args', 'kwargs'
+        are not validated.
+
+    Args:
+        func (Callable): The function to be decorated.
+
+    Raises:
+        TypeError: if the decorated object is nto a Callable
+        EmptyAnnotationException: If an argument is not annotated.
+        InvalidDefaultValueException: If an argument's default value is not of the annotated type.
+        ValidationException: If an argument's value is not of the expected type.
+        InvalidReturnValueException: If the return value is not of the expected type.
+
+    Returns:
+        Callable: A wrapper function that performs the validation and calls the original function.
+    """
+    logger.debug("Creating validate decorator with strict=%s", strict)
+    if not isoftype(strict, Union[bool, Callable]):
+        logger.error("Invalid strict parameter type: %s", type(strict))
+        raise TypeError(
+            "the argument for validate must be a Callable or a boolean to mark strict use")
+
+    def deco(func: FuncT) -> FuncT:
+        logger.debug("Applying validate decorator to function %s", func.__name__)
+        SKIP_SET = {"self", "cls", "args", "kwargs"}
+        if not callable(func):
+            logger.error("Object %s is not callable", func)
+            raise TypeError(
+                "The validate decorator must only decorate a function")
+        func_name = f"{func.__module__}.{func.__qualname__}"
+        logger.debug("Validating function: %s", func_name)
+        # get the signature of the function
+        signature = inspect.signature(func)
+        for arg_name, arg_param in signature.parameters.items():
+            if arg_name not in SKIP_SET:
+                arg_type = arg_param.annotation
+                # check if an annotation is missing
+                if arg_type == inspect.Parameter.empty:
+                    raise EmptyAnnotationException(
+                        f"In {func_name}, argument '{arg_name}' is not annotated")
+
+            # check if the argument has a default value
+            default_value = signature.parameters[arg_name].default
+            if default_value != inspect.Parameter.empty:
+                # allow everything to be set to None as default
+                if default_value is None:
+                    continue
+                # if it does, check the type of the default value
+                if not isoftype(default_value, arg_type):
+                    raise InvalidDefaultValueException(
+                        f"In {func_name}, argument '{arg_name}'s default value is annotated \
+                        as {arg_type} but got '{default_value}' which is {type(default_value)}")
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            """wrapper function for the type validating - will run on each call independently
+            """
+            nonlocal strict
+            strict = cast(bool, strict)
+            hints = None
+            # check all arguments
+            bound = signature.bind(*args, **kwargs)
+            for variable_name, variable_value in bound.arguments.items():
+                if variable_name in SKIP_SET:
+                    continue
+                expected_type = func.__annotations__[variable_name]
+
+                if isinstance(expected_type, str):
+                    # why does this even happen?
+                    if hints is None:
+                        hints = get_type_hints(func)
+                    expected_type = hints[variable_name]
+
+                if not isoftype(variable_value, expected_type, strict=strict):
+                    raise ValidationException(
+                        f"In {func_name}, argument '{variable_name}' is annotated as "
+                        f"{expected_type} but got '{variable_value}' which is {type(variable_value)}")
+
+            # call the function
+            result = func(*args, **kwargs)
+
+            # check the return type
+            return_type = get_function_return_type(func, signature)
+            if isinstance(return_type, str):
+                # why does this even happen?
+                return_type = get_type_hints(func)["return"]
+            if return_type is not type(None) and not isoftype(result, return_type):
+                raise InvalidReturnValueException(
+                    f"In function {func_name}, the return type is annotated as "
+                    f"{return_type} but got '{result}' which is {type(result)}")
+            return result
+
+        return wrapper
+
+    if callable(strict):
+        func = strict
+        strict = True
+        return deco(func)
+    return deco
+
+
+# def validate(func: Callable) -> Callable:
+# """A decorator that validates the annotations and types of the arguments and return
+# value of a function.
+
+#     * 'None' is allowed as default value for everything
+#     * Because of their use in better_builtins, the generally accepted keywords 'self' and 'cls'
+#     are not validated to not break intellisense when using 'Any'
+
+# Args:
+#     func (Callable): The function to be decorated.
+
+# Raises:
+#     TypeError: if the decorated object is nto a Callable
+#     EmptyAnnotationException: If an argument is not annotated.
+#     InvalidDefaultValueException: If an argument's default value is not of the annotated type.
+#     ValidationException: If an argument's value is not of the expected type.
+#     InvalidReturnValueException: If the return value is not of the expected type.
+
+# Returns:
+#     Callable: A wrapper function that performs the validation and calls the original function.
+# """
+# SKIP_SET = {"self", "cls"}
+# if not isinstance(func, Callable):
+#     raise TypeError("The validate decorator must only decorate a function")
+# func_name = f"{func.__module__}.{func.__qualname__}"
+# # get the signature of the function
+# signature = inspect.signature(func)
+# for arg_name, arg_param in signature.parameters.items():
+#     if arg_name not in SKIP_SET:
+#         arg_type = arg_param.annotation
+#         # check if an annotation is missing
+#         if arg_type == inspect.Parameter.empty:
+#             raise EmptyAnnotationException(
+#                 f"In {func_name}, argument '{arg_name}' is not annotated")
+
+#     # check if the argument has a default value
+#     default_value = signature.parameters[arg_name].default
+#     if default_value != inspect.Parameter.empty:
+#         # allow everything to be set to None as default
+#         if default_value is None:
+#             continue
+#         # if it does, check the type of the default value
+#         if not isoftype(default_value, arg_type):
+#             raise InvalidDefaultValueException(
+#                 f"In {func_name}, argument '{arg_name}'s default value is annotated \
+#                 as {arg_type} but got '{default_value}' which is {type(default_value)}")
+
+# @functools.wraps(func)
+# def wrapper(*args, **kwargs):
+#     """wrapper function for the type validating - will run on each call independently
+#     """
+#     hints = None
+#     # check all arguments
+#     bound = signature.bind(*args, **kwargs)
+#     for variable_name, variable_value in bound.arguments.items():
+#         if variable_name in SKIP_SET:
+#             continue
+#         expected_type = func.__annotations__[variable_name]
+
+#         if isinstance(expected_type, str):
+#             # why does this even happen?
+#             if hints is None:
+#                 hints = get_type_hints(func)
+#             expected_type = hints[variable_name]
+
+#         if not isoftype(variable_value, expected_type):
+#             raise ValidationException(
+#                 f"In {func_name}, argument '{variable_name}' is annotated as \
+#                     {expected_type} but got '{variable_value}' which is {type(variable_value)}")
+
+#     # call the function
+#     result = func(*args, **kwargs)
+
+#     # check the return type
+#     return_type = type(None) if ("inspect._empty" in str(signature.return_annotation)
+#                                  or signature.return_annotation is None) else signature.return_annotation
+#     if isinstance(return_type, str):
+#         # why does this even happen?
+#         return_type = get_type_hints(func)["return"]
+#     if return_type is not type(None) and not isoftype(result, return_type):
+#         raise InvalidReturnValueException(
+#             f"In function {func_name}, the return type is annotated as "
+#             f"{return_type} but got '{result}' which is {type(result)}")
+#     return result
+# return wrapper
+
+# @validate  # type:ignore
+# def NotImplemented(func: Callable) -> Callable:
+#     """decorator to mark function as not implemented for development purposes
+
+#     Args:
+#         func (Callable): the function to decorate
+#     """
+#     @ functools.wraps(func)
+#     def wrapper(*args, **kwargs) -> Any:
+#         raise NotImplementedError(
+#             f"As marked by the developer {func.__module__}.{func.__qualname__} is not implemented yet..")
+#     return wrapper
+
+
+__all__ = [
+    "validate"
+]

danielutils/exceptions.py

@@ -0,0 +1,90 @@
+
+import logging
+
+from .logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class OverloadException(Exception):
+    """Base exception for overload decorator
+    """
+
+
+class OverloadNotFound(OverloadException):
+    """Exception to raise if a function is called with certain
+    argument types but this function hasn't been overloaded with those types
+    """
+
+
+class OverloadDuplication(OverloadException):
+    """
+    Exception to raise if a function is overloaded twice with same argument types
+    """
+
+
+# class ValidationError(Exception):
+#     """_summary_
+
+#     Args:
+#         Exception (_type_): _description_
+
+#     Returns:
+#         _type_: _description_
+#     """
+
+
+# class ValidationTypeError(ValidationError, TypeError):
+#     pass
+
+
+# class ValidationReturnTypeError(ValidationError, TypeError):
+#     pass
+
+
+# class ValidationValueError(ValidationError, ValueError):
+#     pass
+
+
+# class ValidationDuplicationError(ValidationError):
+#     pass
+
+
+class ValidationException(Exception):
+    """generic validation exception for validate decorator
+    """
+
+
+class EmptyAnnotationException(ValidationException):
+    """exception for validate decorator to be used if a function needs to 
+    be validated but has an empty annotation for one of the arguments
+    """
+
+
+class InvalidDefaultValueException(ValidationException):
+    """exception for validate decorator to be used if a function has
+    a default value that doesn't conform to the annotated type
+    """
+
+
+class InvalidReturnValueException(ValidationException):
+    """exception for validate decorator to be used if a function has
+    an annotated return value but the actual return value doesn't conform to it
+    """
+
+
+class PrintCatchOne:
+    """a utility class to be used with a "with" block to print 
+    any exception that happens inside of it rather than exiting the program
+    """
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, cls, instance, traceback):
+        if instance:
+            logger.error("Exception caught in PrintCatchOne: %s %s", cls, instance)
+            from .colors import error  # pylint: disable=cyclic-import
+            error(f"{cls} {instance}")
+            return isinstance(instance, cls)
+        return False

danielutils/functions/__init__.py

@@ -0,0 +1,13 @@
+from .isoftype import *
+from .areoneof import *
+from .check_foreach import *
+from .types_subseteq import *
+from .isoneof import *
+from .powerset import *
+from .multiloop import *
+from .flatten import *
+from .subseteq import *
+from .parallel_for import *
+from .foreach import *
+from .factorial import *
+from .partition import *

danielutils/functions/areoneof.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Sequence, Any, Union
+from .isoneof import isoneof
+from ..reflection import get_python_version
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+if get_python_version() < (3, 9):
+    from typing import List as List, Tuple as Tuple
+else:
+    from builtins import list as List, tuple as Tuple  # type:ignore
+
+
+def areoneof(values: Sequence[Any], types: Union[List[type], Tuple[type]]) -> bool:
+    """performs 'isoneof(values[0],types) and ... and isoneof(values[...],types)'
+
+    Args:
+        values (Sequence[Any]): Sequence of values
+        types (Sequence[Type]): Sequence of types
+
+    Raises:
+        TypeError: if types is not a Sequence
+        TypeError: if values is not a Sequence
+
+    Returns:
+        bool: the result of the check
+    """
+    logger.debug("Checking if %s values are one of types: %s", len(values), types)
+    if not isinstance(types, Sequence):
+        logger.error("'types' parameter is not a Sequence")
+        raise TypeError("'types' must be of type Sequence")
+    if not isinstance(values, Sequence):
+        logger.error("'values' parameter is not a Sequence")
+        raise TypeError("'values' must be of type Sequence")
+    
+    for i, v in enumerate(values):
+        if not isoneof(v, types):
+            logger.debug("Value at index %s (%s) is not one of the specified types", i, v)
+            return False
+    
+    logger.debug("All values match one of the specified types")
+    return True
+
+
+__all__ = [
+    "areoneof"
+]

danielutils/functions/check_foreach.py

@@ -0,0 +1,39 @@
+import logging
+from typing import Sequence, Any, Callable
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def check_foreach(values: Sequence[Any], condition: Callable[[Any], bool]) -> bool:
+    """
+    Check if a condition is true for all values in a sequence.
+
+    Args:
+        values (Sequence[Any]): Values to perform check on
+        condition (Callable[[Any], bool]): Condition to check on all values
+
+    Returns:
+        bool: returns True iff condition return True for all values individually
+    """
+    logger.debug("Checking condition on %s values", len(values))
+    
+    if not isinstance(values, Sequence):
+        logger.warning("Values parameter is not a Sequence")
+        return False
+    if not callable(condition):
+        logger.warning("Condition parameter is not callable")
+        return False
+    
+    for i, v in enumerate(values):
+        if not condition(v):
+            logger.debug("Condition failed at index %s with value: %s", i, v)
+            return False
+    
+    logger.debug("All values passed the condition check")
+    return True
+
+
+__all__ = [
+    "check_foreach"
+]

danielutils/functions/factorial.py

@@ -0,0 +1,24 @@
+import logging
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def factorial(n: int) -> int:
+    logger.info("Computing factorial of %s", n)
+    if n < 0:
+        logger.error("Factorial not defined for negative numbers: %s", n)
+        raise ValueError("Factorial not defined for negative numbers")
+    if n == 0 or n == 1:
+        return 1
+    
+    res = 1
+    for i in range(2, n + 1):
+        res *= i
+    
+    logger.info("Factorial of %s computed: %s", n, res)
+    return res
+
+__all__ = [
+    "factorial"
+]

danielutils/functions/flatten.py

@@ -0,0 +1,33 @@
+import logging
+from typing import Iterable
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def flatten(iterable: Iterable) -> list:
+    """
+    Flattens a given iterable into a list.
+
+    This function takes as input an iterable that may contain nested iterables (like lists or tuples),
+    and returns a flat list where all elements of the input are expanded.
+    Non-iterable elements in the input iterable are appended as they are.
+
+    Args:
+        iterable (Iterable): The iterable to flatten. Can contain nested iterables.
+
+    Returns:
+        list: A flat list containing all elements of the input iterable.
+    """
+    result = []
+    for i in iterable:
+        if isinstance(i, Iterable):
+            result.extend(flatten(i))
+        else:
+            result.append(i)
+    
+    return result
+
+__all__=[
+    "flatten"
+]

danielutils/functions/foreach.py

@@ -0,0 +1,20 @@
+import logging
+from typing import TypeVar, Iterable
+from ..custom_types import Consumer
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+T = TypeVar('T')
+
+
+def foreach(iterable: Iterable[T], consumer: Consumer[T]) -> None:
+    logger.info("Applying consumer to iterable")
+    for v in iterable:
+        consumer(v)
+    logger.info("Foreach operation completed")
+
+
+__all__ = [
+    'foreach'
+]