danielutils 1.1.28__py3-none-any.whl

danielutils/math_/math_symbols.py

@@ -0,0 +1,125 @@
+"""file with math_ symbols constants"""
+from typing import Union, Dict as Dict
+from ..reflection import get_python_version
+if get_python_version() >= (3, 9):
+    from builtins import dict as Dict
+# https://unicode-table.com/en/sets/mathematical-signs/
+SPECIAL_DOUBLE_N = "ℕ"
+SPECIAL_DOUBLE_Q = "ℚ"
+SPECIAL_DOUBLE_R = "ℝ"
+SPECIAL_DOUBLE_Z = "ℤ"
+SPECIAL_DOUBLE_C = "ℂ"
+SPECIAL_RPAB = "〉"  # right pointing angle bracket
+SPECIAL_LPAB = "〈"  # left pointing angle bracket
+SPECIAL_FORALL = "∀"
+SPECIAL_EXISTS = "∃"
+SPEICAL_VL = "|"
+SPECIAL_SIGMA = "∑"
+SPECIAL_PI = "∏"
+SPECIAL_CIRCLED_PLUS = "⊕"
+SPECIAL_NE = "≠"
+SPECIAL_EQUIV = "≡"
+SPECIAL_LAMBDA = "λ"
+SPECIAL_SQRT = "√"
+SPECIAL_CUBE_ROOT = "∛"
+SPECIAL_4TH_ROOT = "∜"
+
+
+SUPERSCRIPT_SMALL_LETTERS = ['ᵃ', 'ᵇ', 'ᶜ', 'ᵈ', 'ᵉ', 'ᶠ', 'ᵍ', 'ʰ', 'ⁱ', 'ʲ', 'ᵏ', 'ˡ', 'ᵐ', 'ⁿ',
+                             'ᵒ', 'ᵖ', '𐞥', 'ʳ', 'ˢ', 'ᵗ', 'ᵘ', 'ᵛ', 'ʷ', 'ˣ', 'ʸ', 'ᶻ']
+
+# superscript_big_case_a = 'ⁱ'
+# superscript_big_case_b = 'ⁱ'
+# superscript_big_case_c = 'ⁱ'
+# superscript_big_case_d = 'ⁱ'
+# superscript_big_case_e = 'ⁱ'
+# superscript_big_case_f = 'ⁱ'
+# superscript_big_case_g = 'ⁱ'
+# superscript_big_case_h = 'ⁱ'
+# superscript_big_case_i = 'ⁱ'
+# superscript_big_case_j = 'ⁱ'
+# superscript_big_case_k = 'ⁱ'
+# superscript_big_case_l = 'ⁱ'
+# superscript_big_case_m = 'ⁱ'
+# superscript_big_case_n = 'ⁱ'
+# superscript_big_case_o = 'ⁱ'
+# superscript_big_case_p = 'ⁱ'
+# superscript_big_case_q = 'ⁱ'
+# superscript_big_case_r = 'ⁱ'
+# superscript_big_case_s = 'ⁱ'
+# superscript_big_case_t = 'ⁱ'
+# superscript_big_case_u = 'ⁱ'
+# superscript_big_case_v = 'ⁱ'
+# superscript_big_case_w = 'ⁱ'
+# superscript_big_case_x = 'ⁱ'
+# superscript_big_case_y = 'ⁱ'
+# superscript_big_case_z = 'ⁱ'
+
+
+superscript_dict: Dict[Union[str, int], str] = {}
+superscript_dict.update(
+    {chr(i+ord('a')): SUPERSCRIPT_SMALL_LETTERS[i] for i in range(26)}
+)
+superscript_digits = ["⁰", "¹", "²", "³",
+                      "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"]
+superscript_dict.update(
+    {i: superscript_digits[i] for i in range(len(superscript_digits))}
+)
+superscript_dict.update({
+    "+": "⁺",
+    "-": "⁻",
+    "=": "⁼",
+    "(": "⁽",
+    ")": "⁾",
+})
+
+SUBSCRIPT_SMALL_LETTERS = ['ₐ', '', '', '', 'ₑ', '', '', 'ₕ', 'ᵢ', 'ⱼ', 'ₖ', 'ₗ', 'ₘ',
+                           'ₙ', 'ₒ', 'ₚ', '', 'ᵣ', 'ₛ', 'ₜ', 'ᵤ', 'ᵥ', '', 'ₓ', '', '']
+# subscript_big_case_a = 'ⁱ'
+# subscript_big_case_b = 'ⁱ'
+# subscript_big_case_c = 'ⁱ'
+# subscript_big_case_d = 'ⁱ'
+# subscript_big_case_e = 'ⁱ'
+# subscript_big_case_f = 'ⁱ'
+# subscript_big_case_g = 'ⁱ'
+# subscript_big_case_h = 'ⁱ'
+# subscript_big_case_i = 'ⁱ'
+# subscript_big_case_j = 'ⁱ'
+# subscript_big_case_k = 'ⁱ'
+# subscript_big_case_l = 'ⁱ'
+# subscript_big_case_m = 'ⁱ'
+# subscript_big_case_n = 'ⁱ'
+# subscript_big_case_o = 'ⁱ'
+# subscript_big_case_p = 'ⁱ'
+# subscript_big_case_q = 'ⁱ'
+# subscript_big_case_r = 'ⁱ'
+# subscript_big_case_s = 'ⁱ'
+# subscript_big_case_t = 'ⁱ'
+# subscript_big_case_u = 'ⁱ'
+# subscript_big_case_v = 'ⁱ'
+# subscript_big_case_w = 'ⁱ'
+# subscript_big_case_x = 'ⁱ'
+# subscript_big_case_y = 'ⁱ'
+# subscript_big_case_z = 'ⁱ'
+subscript_dict: Dict[Union[str, int], str] = {}
+subscript_dict.update(
+    {chr(i+ord('a')): SUBSCRIPT_SMALL_LETTERS[i]
+     for i in range(len(SUBSCRIPT_SMALL_LETTERS))}
+)
+
+subscript_digits = ["\u2080", "\u2081", "\u2082", "\u2083",
+                    "\u2084", "\u2085", "\u2086", "\u2087", "\u2088", "\u2089"]
+subscript_dict.update(
+    {f'{i}': subscript_digits[i] for i in range(len(subscript_digits))}
+)
+subscript_dict.update({
+    "+": "\u208A",
+    "-": "\u208B",
+    "=": "\u208C",
+    "(": "\u208D",
+    ")": "\u208E",
+})
+__all__ = [
+    "subscript_dict",
+    "subscript_dict",
+]

danielutils/metaclasses/__init__.py

@@ -0,0 +1,5 @@
+from .interface import *
+from .atomic_class_meta import *
+from .implicit_data_deleter_meta import *
+from .instance_cache_meta import *
+from .overload_meta import *

danielutils/metaclasses/atomic_class_meta.py

@@ -0,0 +1,36 @@
+import logging
+from ..decorators import atomic
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class AtomicClassMeta(type):
+    """will make all of the class's function atomic
+    """
+    def __new__(mcs, name, bases, namespace):
+        logger.info("Creating atomic class: %s", name)
+        
+        # Process class methods
+        class_methods_processed = 0
+        for k, v in namespace.items():
+            if callable(v):
+                namespace[k] = atomic(v)  # type:ignore
+                class_methods_processed += 1
+        
+        # Process inherited methods
+        inherited_methods_processed = 0
+        for base in bases:
+            for k, v in base.__dict__.items():
+                if callable(v):
+                    if k not in namespace:
+                        namespace[k] = atomic(v)  # type:ignore
+                        inherited_methods_processed += 1
+        
+        logger.info("AtomicClassMeta: %s created with %s class methods and %s inherited methods made atomic", name, class_methods_processed, inherited_methods_processed)
+        return super().__new__(mcs, name, bases, namespace)
+
+
+__all__ = [
+    "AtomicClassMeta"
+]

danielutils/metaclasses/implicit_data_deleter_meta.py

@@ -0,0 +1,87 @@
+import logging
+from typing import Optional
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class DeletedException(AttributeError):
+    """an exception to be raised if a function is deleted
+    """
+
+
+def deleted(func, cls_name: Optional[str] = None):
+    """replaces a function with a pre-scripted deleted function
+
+    Args:
+        func (_type_): _description_
+        cls_name (Optional[str], optional): _description_. Defaults to None.
+
+    Raises:
+        DeletedException: _description_
+
+    Returns:
+        _type_: _description_
+    """
+    msg = f"'{func.__qualname__}' has been marked as deleted"
+    if cls_name:
+        msg = f"'{cls_name}.{func.__name__}' has been marked as deleted"
+
+    def new_func(*args, **kwargs):  # pylint: disable=unused-argument
+        nonlocal func
+        logger.warning("Attempted to call deleted function: %s", func.__qualname__)
+        raise DeletedException(msg)
+    return new_func
+
+
+class ImplicitDataDeleterMeta(type):
+    """Inheriting from this metaclass will 'delete' all non builtin function 
+    and will replace them with a new function which will raise and error
+    """
+    def __new__(mcs, name, bases, namespace):
+        logger.info("Creating ImplicitDataDeleterMeta class: %s", name)
+        
+        cls_functions = set()
+        for k, v in namespace.items():
+            if callable(v):
+                if hasattr(v, "__objclass__"):
+                    if v.__objclass__ in {object}:
+                        continue
+
+                elif hasattr(v, "__module__"):
+                    if v.__module__ in {'builtins', None}:
+                        continue
+
+                cls_functions.add(v)
+
+        parent_functions = set()
+        for base in bases:
+            for k, v in base.__dict__.items():
+                if callable(v):
+                    parent_functions.add(v)
+
+        parent_dct = {func.__name__: func for func in parent_functions}
+        cls_dct = {func.__name__: func for func in cls_functions}
+        to_delete = set({k: v for k, v in parent_dct.items()
+                         if k not in cls_dct}.values())
+        
+        deleted_count = 0
+        for func in to_delete:
+            if func.__name__ in dir(object):
+                if func.__name__ in {"__init__"}:
+                    continue
+                namespace[func.__name__] = object.__dict__[func.__name__]
+            elif func.__name__ in {"__len__", "__bool__"}:
+                namespace[func.__name__] = lambda self: True
+            else:
+                namespace[func.__name__] = deleted(func, name)
+                deleted_count += 1
+
+        logger.info("ImplicitDataDeleterMeta: %s created with %s functions marked as deleted", name, deleted_count)
+        return super().__new__(mcs, name, bases, namespace)
+
+
+__all__ = [
+    "ImplicitDataDeleterMeta",
+    "DeletedException"
+]

danielutils/metaclasses/instance_cache_meta.py

@@ -0,0 +1,66 @@
+import logging
+from ..better_builtins.counter import Counter
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class InstanceCacheMeta(type):
+    """Adds automatic caching of all instances of the class
+
+        Adds the following API to the class
+        @staticmethod
+        instances() -> returns a generator of all of the instances
+
+        @staticmethod
+        get_id(instance) -> returns the id of the instance
+
+        @staticmethod
+        get_instance(id) -> return the id of an instance
+
+    """
+    def __new__(mcs, name, bases, namespace):
+        logger.info("Creating InstanceCacheMeta class: %s", name)
+        
+        INIT = "__init__"
+        instance_2_id: dict = {}
+        id_2_instance: dict = {}
+        counter = Counter()
+        original_init = None
+        if INIT in namespace:
+            original_init = namespace[INIT]
+
+        def new_init(*args, **kwargs):
+            instance_id = counter.get()
+            instance = args[0]
+            id_2_instance[instance_id] = instance
+            instance_2_id[instance] = instance_id
+            counter.increment()
+            if original_init:
+                original_init(*args, **kwargs)
+
+        def get_id(instance):
+            if instance not in instance_2_id:
+                logger.warning("Instance %s not found in cache", instance)
+                raise KeyError(f"Instance {instance} not found in cache")
+            return instance_2_id[instance]
+
+        def get_instance(id_: int):
+            if id_ not in id_2_instance:
+                logger.warning("Instance with ID %s not found in cache", id_)
+                raise KeyError(f"Instance with ID {id_} not found in cache")
+            return id_2_instance[id_]
+
+        def instances():
+            return instance_2_id.keys()
+
+        namespace["instances"] = staticmethod(instances)
+        namespace["get_id"] = staticmethod(get_id)
+        namespace["get_instance"] = staticmethod(get_instance)
+        namespace[INIT] = new_init
+
+        logger.info("InstanceCacheMeta: %s created with instance caching enabled", name)
+        return super().__new__(mcs, name, bases, namespace)
+__all__ =[
+    "InstanceCacheMeta"
+]

danielutils/metaclasses/interface.py

@@ -0,0 +1,328 @@
+import inspect
+import logging
+import re
+import traceback
+import functools
+from typing import Callable, Iterable, Any, Generator, Optional, Union, \
+    List as List, Set as Set, Type as t_type, Dict as Dict
+from ..logging_.utils import get_logger
+from ..reflection import get_python_version
+from ..reflection.declarations import _should_use_runtime_introspection, _source_matches_class
+if get_python_version() >= (3, 9):
+    from builtins import list as List, set as Set, type as t_type, dict as Dict  # type:ignore
+# from ..decorators.decorate_conditionally import decorate_conditionally
+
+logger = get_logger(__name__)
+
+
+class InterfaceHelper:
+    """a helper class for Interface metaclass
+    """
+    ORIGINAL_INIT = "__original_init__"
+
+    @staticmethod
+    def flatten_iterables(iterable: Iterable) -> list:
+        """will flatten and iterable recursively
+
+        Args:
+            iterable (Iterable): iterable to flatten
+
+        Returns:
+            list: the flattened result
+        """
+        res = []
+        for obj in iterable:
+            if isinstance(obj, Iterable) and not isinstance(obj, str):
+                res.extend(InterfaceHelper.flatten_iterables(obj))
+            else:
+                res.append(obj)
+        return res
+
+    @staticmethod
+    def is_func_implemented(func: Callable) -> bool:
+        """will check if a function is implemented
+
+        Args:
+            func (Callable): the function to check
+
+        Returns:
+            bool: will return true iff the function is not implemented according to Interface.IMPLICIT_ABSTRACT
+                or not decorated with Interface.abstractmethod 
+                or not an overridden instance of a default implementation of an Interface's function
+        """
+        if hasattr(func, Interface.FUNC_KEY):
+            return not func.__dict__[Interface.FUNC_KEY]
+
+        if getattr(func, "__is_interface_handler__", False):
+            return False
+
+        try:
+            src = inspect.getsource(func)
+        except (OSError, TypeError):
+            code = func.__code__
+            if code.co_code == b'd\x00S\x00' and code.co_consts == (None,):
+                return False
+            if code.co_code == (lambda: ...).__code__.co_code:
+                return False
+            return True
+
+        if re.match(Interface.IMPLICIT_ABSTRACT, src):
+            return False
+
+        is_default_override = (
+            func.__qualname__.startswith(InterfaceHelper.__name__))
+        return not is_default_override
+
+    @staticmethod
+    def unimplemented_functions(cls) -> Generator[str, None, None]:
+        """will yield all function that are unimplemented in a class according to InterfaceHelper.is_func_implemented
+
+        Yields:
+            Generator[str, None, None]: yields str which are function names
+        """
+        for func_name in InterfaceHelper.get_declared_function_names(cls):
+            if func_name not in cls.__dict__:
+                continue
+            func = cls.__dict__[func_name]
+            if not InterfaceHelper.is_func_implemented(func):
+                yield func_name
+
+    @staticmethod
+    def implemented_functions(cls) -> Generator[str, None, None]:
+        """will yield all function that are implemented in a class according to InterfaceHelper.is_func_implemented
+
+        Yields:
+            Generator[str, None, None]: yields str which are function names
+        """
+        for func_name in InterfaceHelper.get_declared_function_names(cls):
+            if func_name not in cls.__dict__:
+                continue
+            func = cls.__dict__[func_name]
+            if InterfaceHelper.is_func_implemented(func):
+                yield func_name
+
+    @staticmethod
+    def _runtime_declared_function_names(cls) -> Generator[str, None, None]:
+        expected_qualname_prefix = f"{cls.__qualname__}."
+        for name, value in cls.__dict__.items():
+            if not inspect.isfunction(value):
+                continue
+            if getattr(value, "__qualname__", "") != expected_qualname_prefix + name:
+                continue
+            yield name
+
+    @staticmethod
+    def get_declared_function_names(cls) -> Generator[str, None, None]:
+        """will yield the names of all the functions declared inside a class
+
+        Yields:
+            Generator[str, None, None]: yields str values which are names of declared functions
+        """
+        if _should_use_runtime_introspection(cls):
+            yield from InterfaceHelper._runtime_declared_function_names(cls)
+            return
+
+        try:
+            source = inspect.getsource(cls)
+            if not _source_matches_class(cls, source):
+                raise OSError("source does not match class")
+            source_lines = source.splitlines()
+        except (OSError, TypeError):
+            yield from InterfaceHelper._runtime_declared_function_names(cls)
+            return
+
+        for line in source_lines:
+            if re.match(r".*def \w+\(.*\).*:", line):
+                func_name = re.findall(r".*def (\w+)\(.*", line)[0]
+                if func_name in cls.__dict__:
+                    yield func_name
+
+    @staticmethod
+    def create_init_handler(cls_name, missing: Optional[Union[List[str],
+                            Set[str]]] = None, original: Optional[Callable] = None):
+        """this function will create the default interface __init__ function with the wanted behavior"""
+        # @decorate_conditionally(functools.wraps, original
+        # is not None, [original])  # TODO implement this decorator
+        def __interface_init__(*args, **kwargs):
+            instance = args[0]
+            caller_frame = traceback.format_stack()[-2]
+            is_super_call = bool(re.match(
+                fr"\s+File \".*\", line \d+, in __init__\n\s+(?:super\(\)|{cls_name})\.__init__\(.*\)\n", caller_frame))
+            
+            if is_super_call:
+                mro = instance.__class__.mro()
+                i = 0
+                for i, cls in enumerate(mro):
+                    if cls.__name__ == cls_name:
+                        break
+                mro = mro[i:]
+                for cls in mro:
+                    if hasattr(cls, InterfaceHelper.ORIGINAL_INIT):
+                        result = getattr(cls, InterfaceHelper.ORIGINAL_INIT)(
+                            *args, **kwargs)
+                        return result
+                logger.error("No original init found in MRO for %s", cls_name)
+                raise NotImplementedError(
+                    f"Can't use super().__init__(...) in {cls_name}.__init__(...) "
+                    "if the __init__ function is not defined a parent interface")
+
+            if missing:
+                logger.warning("Interface %s missing implementations: %s", cls_name, missing)
+                raise NotImplementedError(f"Can't instantiate '{cls_name}' because it is an interface."
+                                          f" It is missing implementations for {missing}")
+            logger.warning("Attempting to instantiate interface %s", cls_name)
+            raise NotImplementedError(
+                f"'{cls_name}' is an interface, Can't create instances")
+        return __interface_init__
+
+    @staticmethod
+    def create_generic_handler(cls: str, original: Callable):
+        """this function will create the generic function handler
+
+        Args:
+            func_name (_type_): the name of the interface
+        """
+        @functools.wraps(original)
+        def __interface_handler__(*args, **kwargs):
+            logger.warning("Generic handler called for unimplemented method in interface %s", cls)
+            raise NotImplementedError(
+                f"Interface {cls} must be implemented")
+        __interface_handler__.__is_interface_handler__ = True
+        return __interface_handler__
+
+
+class Interface(type):
+    """This is a metaclass that will enable better_builtins that inherit it directly (or indirectly)
+        to behave like interfaces in OOP languages like java
+    """
+    IMPLICIT_ABSTRACT = r"\s*def \w+\(.*?\)(?:\s*->\s*[\w\[\],\s]+)?:(?:[^\n]*)\n(?:\s*\"{3}.*\"{3}\n)?\s*\.{3}\n"
+    KEY = "__is_interface__"
+    FUNC_KEY = "__is_abstractmethod__"
+
+    @staticmethod
+    def abstractmethod(func):
+        """will explicitly mark a method as an abstract method"""
+        setattr(func, Interface.FUNC_KEY, True)
+        return func
+
+    def __new__(mcs: t_type['Interface'], name: str, bases: tuple, namespace: dict):
+        if len(bases) == 0:
+            return mcs._handle_new_interface(mcs, name, bases, namespace)
+        return mcs._handle_new_subclass(mcs, name, bases, namespace)
+
+    @staticmethod
+    def _handle_new_interface(mcs, name: str, bases: tuple, namespace: Dict[str, Any]) -> type:
+        logger.info("Handling new interface creation: %s", name)
+        namespace[InterfaceHelper.ORIGINAL_INIT] = None
+        if "__init__" in namespace:
+            namespace[InterfaceHelper.ORIGINAL_INIT] = namespace["__init__"]
+        namespace["__init__"] = InterfaceHelper.create_init_handler(
+            name, original=namespace[InterfaceHelper.ORIGINAL_INIT])
+        
+        abstract_methods = 0
+        for k, v in namespace.items():
+            if callable(v) and not k == "__init__":
+                if not InterfaceHelper.is_func_implemented(v):
+                    namespace[k] = InterfaceHelper.create_generic_handler(k, v)
+                    abstract_methods += 1
+        logger.info("Created interface %s with %s abstract methods", name, abstract_methods)
+        namespace[Interface.KEY] = True
+        return type.__new__(mcs, name, bases, namespace)
+
+    @staticmethod
+    def _handle_new_subclass(mcs: t_type['Interface'], name: str, bases: tuple, namespace: Dict[str, Any]) -> type:
+        need_to_be_implemented: set = set()
+        ancestry = set()
+        for base in bases:
+            cls_tree = inspect.getclasstree([base], unique=True)
+            ancestry.update(InterfaceHelper.flatten_iterables(cls_tree))
+            for item in cls_tree:
+                if isinstance(item, tuple):
+                    derived, parent = item
+                elif len(item) == 1:
+                    item = item[0]
+                    derived, parent = item
+                else:
+                    # multiple inheritance case - need to be implemented
+                    continue
+
+                if derived is object:
+                    continue
+
+                if isinstance(parent, tuple):
+                    if len(parent) != 1:
+                        pass
+                    parent = parent[0]
+
+                if parent is not object:
+                    need_to_be_implemented.update(
+                        InterfaceHelper.unimplemented_functions(parent))
+
+                need_to_be_implemented.difference_update(
+                    InterfaceHelper.implemented_functions(derived))
+                need_to_be_implemented.update(
+                    InterfaceHelper.unimplemented_functions(derived))
+
+        # cleanup
+        del cls_tree, derived, parent
+
+        if object in ancestry:
+            ancestry.remove(object)
+
+        missing: set = set()
+        for func_name in need_to_be_implemented:
+            has_been_declared = func_name in namespace
+            if not has_been_declared:
+                missing.add(func_name)
+                continue
+
+            is_implemented = InterfaceHelper.is_func_implemented(
+                namespace[func_name])
+            if is_implemented:
+                continue
+
+            for ancestor in ancestry:
+                if func_name in InterfaceHelper.implemented_functions(ancestor):
+                    break
+            else:
+                missing.add(func_name)
+
+        # cleanup
+        del ancestry
+
+        if "__init__" in namespace:
+            namespace[InterfaceHelper.ORIGINAL_INIT] = namespace["__init__"]
+        else:
+            if InterfaceHelper.ORIGINAL_INIT in namespace:
+                del namespace[InterfaceHelper.ORIGINAL_INIT]
+
+        if missing:
+            namespace[Interface.KEY] = True
+            # if "__init__" in need_to_be_implemented:
+            namespace["__init__"] = InterfaceHelper.create_init_handler(
+                name, missing)
+        else:
+            namespace[Interface.KEY] = False
+            if "__init__" not in namespace:
+                namespace["__init__"] = object.__init__
+
+        return type.__new__(mcs, name, bases, namespace)
+
+    @staticmethod
+    def is_cls_interface(cls_to_check: type) -> bool:
+        """will check if a class is an interface
+
+        Args:
+            cls_to_check (type): the class to check
+
+        Returns:
+            bool: will return true iff a class is an interface
+        """
+        if hasattr(cls_to_check, Interface.KEY):
+            return cls_to_check.__dict__[Interface.KEY]
+        return False
+
+
+__all__ = [
+    "Interface"
+]