danielutils 0.9.76__tar.gz → 0.9.77__tar.gz

{danielutils-0.9.76/danielutils.egg-info → danielutils-0.9.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.76
+Version: 0.9.77
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -47,6 +47,9 @@ Feel free to use and / or contribute / improve my code :)
 
 THIS PACKAGE IS IN DEVELOPMENT AND SUBJECT TO CHANGE, USE AT YOUR OWN RISK!
 
+**Tested python versions**: `3.8.0`*, `3.9.0`, `3.10.13` 
+
+Versions marked with * are partially working
 # Showcase
 In [this](./READMES/) folder you can check out some more in depth showcase of some of the topics I have covered in this package
 

{danielutils-0.9.76 → danielutils-0.9.77}/README.md

@@ -10,6 +10,9 @@ Feel free to use and / or contribute / improve my code :)
 
 THIS PACKAGE IS IN DEVELOPMENT AND SUBJECT TO CHANGE, USE AT YOUR OWN RISK!
 
+**Tested python versions**: `3.8.0`*, `3.9.0`, `3.10.13` 
+
+Versions marked with * are partially working
 # Showcase
 In [this](./READMES/) folder you can check out some more in depth showcase of some of the topics I have covered in this package
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/abstractions/database/redis_database.py

@@ -3,10 +3,10 @@ from typing import Any, Optional, TypeVar
 try:
     import redis
 except ImportError:
-    from mock_ import MockImportObject
+    from ...mock_ import MockImportObject
 
     redis = MockImportObject("`redis` is not installed")
-from abstractions.database.database import Database
+from .database import Database
 
 K = TypeVar('K')
 V = TypeVar('V')

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/data_structures/trees/binary_syntax_tree.py

@@ -1,7 +1,9 @@
-from typing import Union, Any, Callable
+from typing import Union, Any, Callable,Dict as t_dict
 from .binary_tree import BinaryTree
 from ..graph import BinaryNode
-
+from ...reflection import get_python_version
+if get_python_version()>=(3,9):
+    from builtins import dict as t_dict
 
 class BinarySyntaxTree(BinaryTree):
     """
@@ -9,7 +11,7 @@ class BinarySyntaxTree(BinaryTree):
     """
 
     @staticmethod
-    def _evaluate_node(v: BinaryNode, operator_func_dict: dict[Any, Callable[[Any, Any], Any]]):
+    def _evaluate_node(v: BinaryNode, operator_func_dict: t_dict[Any, Callable[[Any, Any], Any]]):
         if not isinstance(v, BinaryNode) or v.left is None and v.right is None:
             return v
 
@@ -72,7 +74,7 @@ class BinarySyntaxTree(BinaryTree):
     def __reversed__(self) -> "BinarySyntaxTree":
         return self.reverse()
 
-    def evaluate(self, operator_func_dict: dict[Any, Callable[[Any, Any], Any]]) -> Any:
+    def evaluate(self, operator_func_dict: t_dict[Any, Callable[[Any, Any], Any]]) -> Any:
         return BinarySyntaxTree._evaluate_node(self.root, operator_func_dict)
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/__init__.py

@@ -14,3 +14,4 @@ from .deprecate import *
 from .processify import *
 from .singleton import *
 from .total_ordering import *
+from .final import *

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/atomic.py

@@ -3,11 +3,8 @@ from typing import Callable, Any, TypeVar
 import threading
 from .validate import validate
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
+from ..versioned_imports import ParamSpec
+
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -26,10 +23,11 @@ def atomic(func: FuncT) -> FuncT:
     """
     lock = threading.Lock()
 
-    @ functools.wraps(func)
+    @functools.wraps(func)
     def wrapper(*args, **kwargs) -> Any:
         with lock:
             return func(*args, **kwargs)
+
     return wrapper
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/attach.py

@@ -1,11 +1,8 @@
 import functools
 from typing import Callable, Optional, TypeVar
 from .validate import validate
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
+from ..versioned_imports import ParamSpec
+
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -41,7 +38,9 @@ def attach(before: Optional[Callable] = None, after: Optional[Callable] = None)
             if after is not None:
                 after()
             return res
+
         return wrapper
+
     return attach_deco
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/delay_call.py

@@ -3,12 +3,8 @@ import time
 import functools
 from .decorate_conditionally import decorate_conditionally
 from .threadify import threadify
+from ..versioned_imports import ParamSpec
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore# pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -22,13 +18,16 @@ def delay_call(seconds: Union[float, int], blocking: bool = True) -> Callable[[F
         blocking (bool, optional): whether to block the main thread
         when waiting or to wait in a different thread. Defaults to True.
     """
+
     def deco(func: FuncT) -> FuncT:
         @decorate_conditionally(threadify, not blocking)
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
             time.sleep(seconds)
             func(*args, **kwargs)
+
         return wrapper
+
     return deco
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/deprecate.py

@@ -1,11 +1,7 @@
 from typing import Callable, TypeVar
 from ..colors import warning, ColoredText
+from ..versioned_imports import ParamSpec
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -13,13 +9,16 @@ FuncT = Callable[P, T]  # type:ignore
 
 def deprecate_with(replacement_func) -> Callable[[FuncT], FuncT]:
     """will replace a deprecated function with the replacement func and will print a warning"""
+
     def deco(func: FuncT) -> FuncT:
         warning(f"{func.__module__}.{func.__qualname__} is deprecated,"
                 f" using {replacement_func.__module__}.{replacement_func.__qualname__} instead")
 
         def wrapper(*args, **kwargs):
             return replacement_func(*args, **kwargs)
+
         return wrapper
+
     return deco
 
 
@@ -29,12 +28,15 @@ def deprecate(deprecation_message: str) -> Callable[[FuncT], FuncT]:
     Args:
         deprecation_message (str): deprecation message
     """
+
     def deco(func: FuncT) -> FuncT:
         def wrapper(*args, **kwargs):
             print(ColoredText.orange("Deprecation Warning") +
                   ":", deprecation_message)
             return func(*args, **kwargs)
+
         return wrapper
+
     return deco
 
 

danielutils-0.9.77/danielutils/decorators/final.py

@@ -0,0 +1,37 @@
+def final(cls: type) -> type:
+    """
+    A class Decorator to mark a class as final and add expected behavior
+    Args:
+        cls: the class to mark
+
+    Returns:
+        marked class
+    """
+    def __init__subclass__(*args, **kwargs):
+        raise TypeError(f"'{cls.__qualname__}' is final. Can't create subclasses")
+
+    setattr(cls, "__init_subclass__", __init__subclass__)
+    return cls
+
+
+class Final:
+    """
+    A parent class to make direct child a Final class. will add expected behaviour.
+    """
+    def __new__(cls, *args, **kwargs):
+        if cls is Final:
+            raise TypeError("Can't instantiate 'Final'")
+        return super().__new__(cls, *args, **kwargs)
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        def __init__subclass__(*args, **kwargs):
+            raise TypeError(f"'{cls.__qualname__}' is final. Can't create subclasses")
+
+        setattr(cls, "__init_subclass__", __init__subclass__)
+
+
+__all__ = [
+    "final",
+    "Final"
+]

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/limit_recursion.py

@@ -4,12 +4,8 @@ import traceback
 from typing import Any, Callable, TypeVar
 from .validate import validate
 from ..colors import warning
+from ..versioned_imports import ParamSpec
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -27,12 +23,12 @@ def limit_recursion(max_depth: int, return_value: Any = None, quiet: bool = True
     """
 
     def deco(func: FuncT) -> FuncT:
-        @ functools.wraps(func)
+        @functools.wraps(func)
         def wrapper(*args, **kwargs):
             depth = functools.reduce(
                 lambda count, line:
-                    count + 1 if re.search(rf"{func.__name__}\(.*\)$", line)
-                    else count,
+                count + 1 if re.search(rf"{func.__name__}\(.*\)$", line)
+                else count,
                 traceback.format_stack(), 0
             )
             if depth >= max_depth:
@@ -44,7 +40,9 @@ def limit_recursion(max_depth: int, return_value: Any = None, quiet: bool = True
                     return return_value
                 return args, kwargs
             return func(*args, **kwargs)
+
         return wrapper
+
     return deco
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/memo.py

@@ -2,13 +2,8 @@ import functools
 from typing import Callable, Any, TypeVar, Dict as t_dict
 from copy import deepcopy
 from .validate import validate
+from ..versioned_imports import ParamSpec, t_dict
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from builtins import dict as t_dict
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -23,11 +18,12 @@ def memo(func: FuncT) -> FuncT:
     """
     cache: t_dict[tuple, Any] = {}
 
-    @ functools.wraps(func)
+    @functools.wraps(func)
     def wrapper(*args, **kwargs):
         if (args, *kwargs.items()) not in cache:
             cache[(args, *kwargs.items())] = func(*args, **kwargs)
         return deepcopy(cache[(args, *kwargs.items())])
+
     return wrapper
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/overload.py

@@ -5,13 +5,8 @@ from ..reflection import is_function_annotated_properly
 from ..functions import isoftype, isoneof, isoneof_strict
 from ..exceptions import OverloadDuplication, OverloadNotFound
 from .deprecate import deprecate
-from ..reflection import get_python_version
+from ..versioned_imports import ParamSpec, t_dict, t_list
 
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore# pylint: disable=ungrouped-imports
-    from builtins import dict as t_dict, list as t_list
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/partially_implemented.py

@@ -2,12 +2,8 @@ from typing import Callable, Any, TypeVar
 import functools
 from .validate import validate
 from ..colors import warning
+from ..versioned_imports import ParamSpec
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -21,12 +17,13 @@ def PartiallyImplemented(func: FuncT) -> FuncT:
         func (Callable): the function to decorate
     """
 
-    @ functools.wraps(func)
+    @functools.wraps(func)
     def wrapper(*args, **kwargs) -> Any:
         warning(
             f"As marked by the developer, {func.__module__}.{func.__qualname__} "
             "may not be fully implemented and might not work properly.")
         return func(*args, **kwargs)
+
     return wrapper
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/threadify.py

@@ -1,12 +1,8 @@
 from typing import Callable, TypeVar
 import functools
 import threading
+from ..versioned_imports import ParamSpec
 
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -22,9 +18,11 @@ def threadify(func: FuncT) -> FuncT:
     Returns:
         Callable: the modified function
     """
+
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         threading.Thread(target=func, args=args, kwargs=kwargs).start()
+
     return wrapper
 
 

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/timeout.py

@@ -2,12 +2,8 @@ import threading
 import functools
 from typing import Callable, TypeVar, Union
 from .validate import validate
-from ..reflection import get_python_version
+from ..versioned_imports import ParamSpec
 
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/decorators/validate.py

@@ -3,13 +3,10 @@ import inspect
 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,\
+from ..exceptions import EmptyAnnotationException, \
     InvalidDefaultValueException, ValidationException, InvalidReturnValueException
-from ..reflection import get_python_version
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
+from ..versioned_imports import ParamSpec
+
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore
@@ -106,7 +103,9 @@ def validate(strict: Union[FuncT, bool] = True) -> FuncT:
                     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
@@ -115,90 +114,90 @@ def validate(strict: Union[FuncT, bool] = True) -> FuncT:
 
 
 # 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
+# """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
 # def NotImplemented(func: Callable) -> Callable:

{danielutils-0.9.76 → danielutils-0.9.77}/danielutils/functions/isoftype.py

@@ -1,15 +1,9 @@
 from typing import get_args, get_origin, get_type_hints, Any, Union, TypeVar, \
-    ForwardRef, Literal, Optional, Tuple as t_tuple, Protocol
+    ForwardRef, Literal, Optional, Protocol
 from collections.abc import Callable, Generator, Iterable
 from ..reflection import get_python_version
+from ..versioned_imports import ParamSpec, Concatenate, t_tuple
 
-if get_python_version() < (3, 9):
-    from typing_extensions import ParamSpec, Concatenate
-else:
-
-    # pylint: disable=ungrouped-imports
-    from typing import ParamSpec, Concatenate  # type:ignore
-    from builtins import tuple as t_tuple  # type:ignore
 # implicit_union_type = type(int | str)
 concatenate_t = type(Concatenate[str, ParamSpec("P_")])
 ellipsis_ = ...
@@ -174,7 +168,7 @@ def __handle_callable(params: tuple) -> bool:
     if len(t_args) == 0:
         return True
 
-    if get_python_version() < (3, 9):
+    if get_python_version() < (3, 10):
         if isoftype(t_args[0][0], [ParamSpec, concatenate_t]):
             return True
     else: