danielutils 1.1.28__py3-none-any.whl

danielutils/better_builtins/frange.py

@@ -0,0 +1,266 @@
+import math
+import decimal
+import logging
+from typing import Callable, Optional, Iterator, Sequence, overload, Union
+from ..logging_.utils import get_logger
+logger = get_logger(__name__)
+
+
+class frange(Sequence[float]):
+    """This class is the same like the builtin range but with float values
+    """
+
+    @staticmethod
+    def from_range(r: range) -> 'frange':
+        """will "downcast" `range` to `frange` correctly"""
+        return frange(r.start, r.stop, r.step)
+
+    @staticmethod
+    def _is_int(n: Union[int, float]) -> bool:
+        if isinstance(n, int):
+            return True
+
+        return n.is_integer()
+
+    @staticmethod
+    def _lcm_int(a: int, b: int) -> int:
+        if hasattr(math, "lcm"):
+            return math.lcm(a, b)
+        return abs(a * b) // math.gcd(a, b)
+
+    @staticmethod
+    def _lcm_float(a: float, b: float) -> float:
+        prec = min(5, max(decimal.getcontext().prec, 10))
+        a = round(a, prec)
+        b = round(b, prec)
+        return frange._lcm_int(int(a * 10 ** prec), int(b * 10 ** prec)) / 10 ** prec
+
+    @staticmethod
+    def _find_min_step(s1: float, s2: float) -> float:
+        """
+        returns the minimum LCM for two step values
+        Args:
+            s1 (float): first step value:
+            s2 (float): second step value:
+
+        Returns:
+            float: minimum LCM
+        """
+        M = max(s1, s2)
+        m = min(s1, s2)
+        if float.is_integer(M / m):
+            return M
+        return frange._lcm_float(s1, s2)
+
+    def __init__(self, start: float, stop: Optional[float] = None,
+                 step: float = 1, round_method: Callable[[float], float] = lambda f: round(f, 3)):
+        logger.debug("Initializing frange with start=%s, stop=%s, step=%s", start, stop, step)
+        if stop is None:
+            stop = start
+            start = 0
+        self.start = start
+        self.stop = stop
+        self.step = step
+        self.method = round_method
+        logger.debug("frange initialized: start=%s, stop=%s, step=%s", self.start, self.stop, self.step)
+
+    @overload
+    def __getitem__(self, index: int) -> float:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> 'frange':
+        ...
+
+    def __getitem__(self, index: Union[float, slice]) -> Union[float, 'frange']:
+        logger.debug("Getting item at index %s from frange", index)
+        if isinstance(index, slice):
+            logger.debug("Processing slice: start=%s, stop=%s, step=%s", index.start, index.stop, index.step)
+            index = slice(
+                index.start if index.start is not None else 0,
+                index.stop if index.stop is not None else len(self),
+                index.step if index.step is not None else 1,
+            )
+            if index.step > 0:
+                step = self.step * index.step
+                start = self.start + step * index.start
+                stop = self.start + step * index.stop
+                logger.debug("Creating new frange from slice: start=%s, stop=%s, step=%s", start, stop, step)
+                return frange(start, stop, step)
+            s = slice(index.start, index.stop, abs(index.step))
+            logger.debug("Reversing slice result")
+            return reversed(self[s])
+        if index < 0:
+            logger.error("Negative index %s not allowed in frange", index)
+            raise ValueError(f"At {self.__class__.__qualname__}.__getitem__ 'index' must be a positive integer")
+        result = self.start + self.step * index
+        logger.debug("Returning value %s for index %s", result, index)
+        return result
+
+    def __reversed__(self) -> 'frange':
+        return frange(self.stop - 1, self.start - 1, -self.step)
+
+    def __eq__(self, other):
+        if not isinstance(other, frange):
+            raise NotImplementedError
+        return self.start == other.start and self.stop == other.stop and self.step == other.step
+
+    def __iter__(self) -> Iterator[float]:
+        logger.debug("Starting iteration over frange: start=%s, stop=%s, step=%s", self.start, self.stop, self.step)
+        if self.stop < self.start and self.step > 0:
+            logger.debug("Empty range: stop < start with positive step")
+            return
+        if self.start > self.stop and self.step > 0:
+            logger.debug("Empty range: start > stop with positive step")
+            return
+        if abs(self.stop - self.start) < abs(self.step):
+            logger.debug("Empty range: step larger than range")
+            return
+        if self.stop > 0 and self.step < 0:
+            logger.debug("Empty range: positive stop with negative step")
+            return
+        if self.stop < 0 and self.step > 0:
+            logger.debug("Empty range: negative stop with positive step")
+            return
+
+        cur = self.start
+        count = 0
+        while (cur < self.stop and self.step > 0) or (cur > self.stop and self.step < 0):
+            yield self.method(cur)
+            cur += self.step
+            count += 1
+        logger.debug("Iteration completed, yielded %s values", count)
+
+    def __len__(self) -> int:
+        if self.stop in {float("inf"), -float("inf")}:
+            return float("inf")
+        return int(abs(self.stop - self.start) // abs(self.step))
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.start}, {self.stop}, {self.step})"
+
+    def __contains__(self, item):
+        if item < self.start:
+            return False
+        if item >= self.stop:
+            return False
+
+        if frange._is_int(self.step):
+            if not frange._is_int(item):
+                return False
+
+        return item / self.step - item // self.step == 0
+
+    @property
+    def is_finite(self) -> bool:
+        """
+        Returns `True` if the range is finite
+        inverse if `is_infinite`
+        Returns:
+            bool
+        """
+        if self.stop in (float("inf"), float("-inf")):
+            return False
+        if self.start in (float("inf"), float("-inf")):
+            return False
+        try:
+            return len(self) != float("inf")
+        except TypeError:
+            return False
+
+    @property
+    def is_infinite(self) -> bool:
+        """
+        Returns `True` if the range is infinite
+        inverse if `is_finite`
+        Returns:
+            bool
+        """
+        return not self.is_finite
+
+    def normalize(self) -> 'frange':
+        """
+        will normalize the `frange` object
+        Returns:
+            frange
+        """
+        return frange(self.start / self.step, self.stop / self.step, 1)
+
+    def intersect(self, other: 'frange') -> 'frange':
+        logger.debug("Computing intersection of frange %s with %s", self, other)
+        if not isinstance(other, frange):
+            logger.error("intersect only accepts frange objects, got %s", type(other))
+            raise ValueError("frange.intercept only accepts frange objects")
+        a, b = self.normalize(), other.normalize()
+        start1, stop1 = a.start, a.stop
+        start2, stop2 = b.start, b.stop
+        remainder1, remainder2 = start1 - int(start1), start2 - int(start2)
+        start = max(self.start, other.start)
+        stop = min(self.stop, other.stop)
+        logger.debug("Normalized ranges: a=%s, b=%s, remainders: %s, %s", a, b, remainder1, remainder2)
+        if remainder1 == remainder2:
+            min_step = self._find_min_step(self.step, other.step)
+            logger.debug("Remainders match, min_step=%s", min_step)
+            if stop1 == float("inf") or stop2 == float("inf"):
+                logger.debug("One range is infinite, returning infinite result")
+                return frange(start, float("inf"), min_step)
+            logger.debug("Returning finite intersection: start=%s, stop=%s, step=%s", start, stop, min_step)
+            return frange(start, stop, min_step)
+        # find k; start1 + remainder1*k == start2 +remainder2*k
+        k = (start1 - start2) / (remainder2 - remainder1)
+        logger.debug("Computing k=%s for remainder intersection", k)
+        if k <= 0:
+            logger.debug("k <= 0, returning empty range")
+            return frange(0)
+        if stop1 == float("inf") or stop2 == float("inf"):
+            logger.error("Infinite range intersection not implemented")
+            raise NotImplementedError("this part is not implemented yet. one has inf")
+        logger.error("Complex remainder intersection not implemented")
+        raise NotImplementedError("this part is not implemented yet")
+
+
+class frange_iterator(Iterator[float]):
+    def __init__(self, obj: frange):
+        self.r = obj
+
+    def __next__(self):
+        if self.r.stop < self.r.start:
+            return
+        if self.r.start > self.r.stop:
+            return
+        if abs(self.r.stop - self.r.start) < abs(self.r.step):
+            return
+        if self.r.stop > 0 and self.r.step < 0:
+            return
+        if self.r.stop < 0 and self.r.step > 0:
+            return
+
+        cur = self.r.start
+        while cur < self.r.stop:
+            yield self.r.method(cur)
+            cur += self.r.step
+
+    def __iter__(self):
+        return self
+
+
+class brange(frange):
+    """like frange but with tqdm
+    """
+
+    def __iter__(self):
+        itr = super().__iter__()
+        try:
+            from tqdm import tqdm  # type:ignore  # pylint: disable=import-error
+            return iter(tqdm(itr, desc=f"{self}", total=len(self)))
+        except:
+            return itr
+
+
+__all__ = [
+    "frange",
+    "brange"
+]

danielutils/better_builtins/typed_builtins/__init__.py

@@ -0,0 +1,4 @@
+from .tlist import *
+from .tdict import *
+from .tset import *
+from .ttuple import *

danielutils/better_builtins/typed_builtins/factory.py

@@ -0,0 +1,126 @@
+import types
+from abc import abstractmethod
+from typing import Any, Iterable, List as List, Set as Set, Dict as Dict, Tuple as Tuple
+from ...functions import types_subseteq, isoftype
+from ...reflection import get_caller_name, get_python_version
+
+if get_python_version() >= (3, 9):
+    from builtins import list as List, set as Set, dict as Dict, tuple as Tuple  # type:ignore
+# needed for python 3.8
+class_to_type = {
+    list: List,
+    set: Set,
+    dict: Dict,
+    Tuple: Tuple,
+}
+
+
+def create_typed_class(name: str, fallback_class: type = object) -> type:
+    """will create a base class to inherit from which will enable enforcing runtime type safety.
+
+    ### The following functions are added for use:
+
+    * get_params()->tuple which return the supplied type hins from the generic creation of the class
+    * subscribable_init(self,*args,**kwargs) which is the new "__init__"
+    * on_call(self,*args,**kwargs) which is the new "__call__"
+
+    Args:
+        name (str): name of class (can be the same of the derived?)
+        fallback_class (type): the fallback class to handle __str__, __repr__
+        and such. e.g for a typed version of list ('tlist') the fallback class would be 'list'
+        bases (tuple, optional): another additional bases that this class should inherit from. Defaults to None.
+
+    Returns:
+        type: new class type
+    """
+    cls = types.new_class(name, (fallback_class,), {})
+
+    def __class_getitem__(cls, item: type):
+        return cls(item)
+
+    def __instancecheck__(self, instance: Any) -> bool:
+        if isinstance(instance, cls):
+            return types_subseteq(
+                instance.get_params(),  # type:ignore
+                self.get_params()
+            )
+
+        return isoftype(
+            instance,
+            class_to_type[fallback_class][self.get_params()]  # type:ignore
+        )
+
+    def __init__(self, item) -> None:
+        if not get_caller_name(1) == "__class_getitem__":
+            raise ValueError(
+                f"Can't instantiate {self.__class__.__name__} without a supplied type")
+        fallback_class.__init__(self)  # type: ignore
+        # pylint: disable=protected-access
+        self._params = (item,) if not isinstance(
+            item, Iterable) else tuple(item)
+        self._inited = False
+
+    def subscribable_init(self, *args, **kwargs) -> None:
+        raise NotImplementedError(
+            "'subscribable_init(self,*args,**kwargs) is an abstract method that must be implemented.")
+
+    def on_call(self, *args, **kwargs) -> Any:
+        raise NotImplementedError(
+            "'on_call(self,*args,**kwargs) is an abstract method that must be implemented.")
+
+    def __call__(self, *args, **kwargs):
+        # pylint: disable=protected-access
+        if not self._inited:
+            self_inited = True
+            # to work with overloading
+            type(self).subscribable_init(self, *args, **kwargs)
+            # self.subscribable_init(*args, **kwargs)
+            return self
+        return self.on_call(self, *args, **kwargs)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        return f"{name} {fallback_class.__repr__(self)}"  # type:ignore
+
+    def get_params(self) -> tuple:
+        # pylint: disable=protected-access
+        return self._params
+
+    def __eq__(self, other: Any) -> bool:
+        if isoftype(other, cls):   # type:ignore
+            return self.get_params() == other.get_params()
+        return False
+
+    # pylint: disable=unused-argument
+    def __init_subclass__(subcls, **kwargs):
+        if hasattr(subcls, "__init__"):
+            curr_init = getattr(subcls, "__init__")
+            if curr_init is not __init__:
+                raise ValueError(
+                    "Can't override '__init__', use 'subscribable_init(self,*args,**kwargs)' instead.")
+
+    for func, tup in [
+        (__class_getitem__, ["__class_getitem__", classmethod]),
+        (__instancecheck__, ["__instancecheck__", None]),
+        (subscribable_init, ["subscribable_init", abstractmethod]),
+        (__init__, ["__init__", None]),
+        (__call__, ["__call__", None]),
+        (__str__, ["__str__", None]),
+        (__repr__, ["__repr__", None]),
+        (__eq__, ["__eq__", None]),
+        (get_params, ["get_params", None]),
+        (__init_subclass__, ["__init_subclass__", classmethod])
+    ]:
+        name, decorator = tup  # type:ignore
+        if decorator is not None:  # type:ignore
+            func = decorator(func)  # type:ignore
+        setattr(cls, name, func)
+
+    return cls
+
+
+__all__ = [
+    "create_typed_class"
+]

danielutils/better_builtins/typed_builtins/tdict.py

@@ -0,0 +1,36 @@
+from typing import Generic, TypeVar
+from .factory import create_typed_class
+from ...functions import isoftype
+parent: type = create_typed_class("tdict", dict)
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class tdict(parent, Generic[K, V]):
+    """like 'dict' but with runtime type safety
+    """
+
+    def subscribable_init(self, *args, **kwargs):  # pylint: disable=unused-argument
+        """the "real" __init__ function
+        """
+        print(self.get_params())
+
+    @property
+    def _key_t(self):
+        return self.get_params()[0]
+
+    @property
+    def _value_t(self):
+        return self.get_params()[1]
+
+    def __setitem__(self, key: K, value: V):
+        if not isoftype(key, self._key_t):  # type:ignore
+            raise TypeError("")
+        if not isoftype(value, self._value_t):  # type:ignore
+            raise TypeError("")
+        dict.__setitem__(self, key, value)
+
+
+__all__ = [
+    "tdict"
+]

danielutils/better_builtins/typed_builtins/tlist.py

@@ -0,0 +1,223 @@
+from typing import Generic, TypeVar, Any, Union, Iterable, SupportsIndex
+# from ...metaclasses.OverloadMeta import OverloadMeta
+from ...functions import isoftype, types_subseteq
+# from ...reflection import get_caller_name
+from ...decorators import overload
+from .factory import create_typed_class
+T = TypeVar("T", bound=Any)
+
+
+# class ptlist(List[T], Generic[T]):
+#     """like 'list' but with runtime type safety
+#     """
+
+#     @classmethod
+#     def __class_getitem__(cls, item: type):
+#         return cls(item)
+
+#     def __instancecheck__(self, instance: Any) -> bool:
+#         if isinstance(instance, ptlist):
+#             return types_subseteq(instance._params, self._params)
+#         return isoftype(instance, List[self._params])  # type: ignore
+
+#     def __init__(self, item) -> None:
+#         if not get_caller_name(0) == "__class_getitem__":
+#             raise ValueError(
+#                 f"Can't instantiate {self.__class__.__name__} without a supplied type")
+#         list.__init__(self)
+#         self._params = item
+
+#     def __call__(self, *args, **kwargs):
+#         # to work with the overloading
+#         type(self)._additional_init(self, *args, **kwargs)
+#         return self
+
+#     @OverloadMeta.overload
+#     def _additional_init(self, lst: Union[list, "ptlist"]):
+#         self.extend(lst)
+
+#     @_additional_init.overload
+#     def _init_empty(self) -> None:
+#         """inits an empty tlist
+#         """
+
+#     @_additional_init.overload
+#     def _init_from_set_and_dict(self, obj: Union[set, dict]):
+#         """inits the tlist from a set or a dict object
+#         Args:
+#             obj (set | dict): the set or dict instance
+#         """
+#         self.extend(list(obj))
+
+#     def extend(self, other: Iterable) -> None:
+#         """extends a tlist from a list or a tlist
+
+#         Args:
+#             other (list | tlist): the list to extend from
+
+#         Returns:
+#             tlist: Self
+#         """
+#         if isinstance(other, ptlist):
+#             if types_subseteq(other._params, self._params):
+#                 list.extend(self, other)
+#                 return
+#         for value in other:
+#             self.append(value)
+
+#     def append(self, value: T) -> None:
+#         """appends a value to the list
+
+#         Args:
+#             value (T): the value to append
+
+#         Raises:
+#             ValueError: if a value is not of the correct type
+
+#         Returns:
+#             tlist: self
+#         """
+#         if not isoftype(value, self._params):
+#             raise TypeError(
+#                 f"In tlist.append: values must be of type {self._params}, but '{value}' is of type {type(value)}")
+#         list.append(self, value)
+
+#     def __str__(self) -> str:
+#         return "tlist "+list.__str__(self)
+
+#     def __repr__(self) -> str:
+#         return "tlist "+list.__repr__(self)
+
+#     def __setitem__(self, index: SupportsIndex, value: T):  # type:ignore
+#         if not isoftype(value, self._params):
+#             raise TypeError(
+#                 "Can't add value to tlist because it is of the wrong type")
+#         list.__setitem__(self, index, value)
+
+#     def __eq__(self, other: Any) -> bool:
+#         if not isoftype(other, Union[ptlist, list]):
+#             return list.__eq__(self, other)
+#         if isinstance(other, ptlist):
+#             if self._params != other._params:
+#                 return False
+#         if len(self) != len(other):
+#             return False
+#         for a, b in zip(iter(self), iter(other)):
+#             if a != b:
+#                 return False
+#         return True
+
+#     def __add__(self, other: Any) -> "ptlist":
+#         if not isoftype(other, Union[ptlist, list]):
+#             raise NotImplementedError()
+
+#         # no need to check because the error handling
+#         # will be done inside extend so the error will
+#         # propagate up
+#         res = ptlist[self._params](self)  # type:ignore
+#         res.extend(other)
+#         return res
+
+#     def __mul__(self, other: Any) -> "ptlist":
+#         if not isinstance(other, int):
+#             raise NotImplementedError()
+
+#         res = ptlist[self._params](self)  # type:ignore
+#         for _ in range(other-1):
+#             res.extend(self)
+#         return res
+
+
+parent: type = create_typed_class("tlist", list)
+
+
+class tlist(parent, Generic[T]):
+    """like 'list' but with runtime type safety
+    """
+
+    def subscribable_init(self, *args, **kwargs):
+        """the "real" __init__ function
+        """
+        type(self)._additional_init(self, *args, **kwargs)
+
+    @overload  # type:ignore
+    def _additional_init(self, lst: Union[list, "tlist"]):
+        self.extend(lst)
+
+    @_additional_init.overload
+    def _init_empty(self) -> None:
+        """inits an empty tlist
+        """
+
+    @_additional_init.overload
+    def _init_from_set_and_dict(self, obj: Union[set, dict]):
+        """inits the tlist from a set or a dict object
+        Args:
+            obj (set | dict): the set or dict instance
+        """
+        self.extend(list(obj))
+
+    def extend(self, other: Iterable) -> None:
+        """extends a tlist from a list or a tlist
+
+        Args:
+            other (list | tlist): the list to extend from
+
+        Returns:
+            tlist: Self
+        """
+        if isinstance(other, tlist):
+            if types_subseteq(other.get_params(), self.get_params()):
+                list.extend(self, other)
+                return
+        for value in other:
+            self.append(value)
+
+    def append(self, value: T) -> None:
+        """appends a value to the list
+
+        Args:
+            value (T): the value to append
+
+        Raises:
+            ValueError: if a value is not of the correct type
+
+        Returns:
+            tlist: self
+        """
+        if not isoftype(value, self.get_params()[0]):
+            raise TypeError(
+                f"In tlist.append: values must be of type {self.get_params()[0]},"
+                " but '{value}' is of type {type(value)}")
+        list.append(self, value)
+
+    def __add__(self, other: Any) -> "tlist":
+        if not isoftype(other, Union[list, tlist]):
+            raise NotImplementedError()
+
+        # no need to check because the error handling
+        # will be done inside extend so the error will
+        # propagate up
+        res = tlist[self._params](self)  # type:ignore
+        res.extend(other)
+        return res
+
+    def __mul__(self, other: Any) -> "tlist":
+        if not isinstance(other, int):
+            raise NotImplementedError()
+
+        res = tlist[self.get_params()[0]](self)  # type:ignore
+        for _ in range(other-1):
+            res.extend(self)
+        return res
+
+    def __setitem__(self, index: SupportsIndex, value: T):  # type:ignore
+        if not isoftype(value, self._params):
+            raise TypeError(
+                "Can't add value to tlist because it is of the wrong type")
+        list.__setitem__(self, index, value)
+
+
+__all__ = [
+    "tlist"
+]