danielutils 0.9.72__tar.gz → 0.9.73__tar.gz

{danielutils-0.9.72 → danielutils-0.9.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.72
+Version: 0.9.73
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -34,7 +34,6 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tqdm
 
 
 [![Python package](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml)

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/__init__.py

@@ -12,7 +12,8 @@ from .signals import *
 from .aliases import *
 from .exceptions import PrintCatchOne
 from .snippets import *
-
+from .abstractions import *
+from .imports import *
 # =================================================================
 # ========================= ORDER MATTERS =========================
 # =================================================================

danielutils-0.9.73/danielutils/classes/frange.py

@@ -0,0 +1,226 @@
+import math
+import decimal
+from typing import Callable, Optional, Iterator, Sequence, overload, Union
+
+
+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)
+
+    def __init__(self, start: float, stop: Optional[float] = None,
+                 step: float = 1, round_method: Callable[[float], float] = lambda f: round(f, 3)):
+        if stop is None:
+            stop = start
+            start = 0
+        self.start = start
+        self.stop = stop
+        self.step = step
+        self.method = round_method
+        self._is_finite = len(self) != float("inf")
+
+    @property
+    def is_finite(self) -> bool:
+        """
+        Returns `True` if the range is finite
+        inverse if `is_infinite`
+        Returns:
+            bool
+        """
+        return self._is_finite
+
+    @property
+    def is_infinite(self) -> bool:
+        """
+        Returns `True` if the range is infinite
+        inverse if `is_finite`
+        Returns:
+            bool
+        """
+        return not self.is_finite
+
+    @overload
+    def __getitem__(self, index: int) -> float:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> 'frange':
+        ...
+
+    def __getitem__(self, index: Union[float, slice]) -> Union[float, 'frange']:
+        if isinstance(index, slice):
+            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
+                return frange(start, stop, step)
+            s = slice(index.start, index.stop, abs(index.step))
+            return reversed(self[s])
+        if index < 0:
+            raise ValueError(f"At {self.__class__.__qualname__}.__getitem__ 'index' must be a positive integer")
+        return self.start + self.step * index
+
+    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]:
+        if self.stop < self.start:
+            return
+        if self.start > self.stop:
+            return
+        if abs(self.stop - self.start) < abs(self.step):
+            return
+        if self.stop > 0 and self.step < 0:
+            return
+        if self.stop < 0 and self.step > 0:
+            return
+
+        cur = self.start
+        while cur < self.stop:
+            yield self.method(cur)
+            cur += self.step
+
+    def __len__(self) -> int:
+        if self.stop in {float("inf"), -float("inf")}:
+            return float("inf")
+        return int((self.stop - self.start) // self.step)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.start}, {self.stop}, {self.step})"
+
+    @staticmethod
+    def _is_int(n: Union[int, float]) -> bool:
+        if isinstance(n, int):
+            return True
+
+        return n.is_integer()
+
+    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
+
+    def normalize(self) -> 'frange':
+        """
+        will normalize the `frange` object
+        Returns:
+            frange
+        """
+        return frange(self.start / self.step, self.stop / self.step, 1)
+
+    # def _normalize_with(self, other: 'frange') -> 'frange':
+    #     return frange(self.start / (self.step * other.step), self.stop / (self.step * other.step), 1)
+
+    @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 math.lcm(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 intersect(self, other: 'frange') -> 'frange':
+        if not isinstance(other, frange):
+            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)
+        if remainder1 == remainder2:
+            min_step = self._find_min_step(self.step, other.step)
+            if stop1 == float("inf") or stop2 == float("inf"):
+                return frange(start, float("inf"), min_step)
+            return frange(start, stop, min_step)
+        # find k; start1 + remainder1*k == start2 +remainder2*k
+        k = (start1 - start2) / (remainder2 - remainder1)
+        if k <= 0:
+            return frange(0)
+        if stop1 == float("inf") or stop2 == float("inf"):
+            raise NotImplementedError("this part is not implemented yet. one has inf")
+        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 my_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-0.9.72 → danielutils-0.9.73}/danielutils/classes/repl.py

@@ -1,6 +1,8 @@
+import copy
 from typing import Any, Callable, Union, Tuple as t_tuple, List as t_list, Dict as t_dict
 import re
-from ..reflection import get_python_version
+from ..reflection import get_python_version  # pylint :disable=relative-beyond-top-level
+
 if get_python_version() >= (3, 9):
     from builtins import tuple as t_tuple, list as t_list, dict as t_dict  # type:ignore
 
@@ -39,9 +41,10 @@ class REPL:
     """a class to easily create a shell application and get functionality for free
     """
 
+    # pylint: disable=dangerous-default-value
     def __init__(self, routes: t_list[Command], *, prompt_symbol: str = ">>> ", exit_keywords: set = {"exit", "quit"}):
         self.prompt_symbol = prompt_symbol
-        self.exit_keywords = exit_keywords
+        self.exit_keywords = copy.copy(exit_keywords)
         self.routes: t_dict[str, Command] = {
             com.command.name: com for com in routes}
 
@@ -58,7 +61,7 @@ class REPL:
 
             if prompt == "help":
                 print("Available commands:")
-                for com in list(self.routes.keys())+list(self.exit_keywords):
+                for com in list(self.routes.keys()) + list(self.exit_keywords):
                     print(f"\t{com}")
                 continue
 
@@ -70,9 +73,9 @@ class REPL:
                 except TypeError as e:
                     msg = str(e)
                     if re.match(r".*missing.*required.*argument.*", msg):
-                        print(f"'{command}' "+msg[msg.find("missing"):])
+                        print(f"'{command}' " + msg[msg.find("missing"):])
                     elif re.match(r".*takes.*arguments but.*given", msg):
-                        print(f"'{command}' "+msg[msg.find("takes"):])
+                        print(f"'{command}' " + msg[msg.find("takes"):])
                     else:
                         raise e
 

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/classes/typed_builtins/factory.py

@@ -3,6 +3,7 @@ from abc import abstractmethod
 from typing import Any, Iterable, List as t_list, Set as t_set, Dict as t_dict, Tuple as t_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 t_list, set as t_set, dict as t_dict, tuple as t_tuple  # type:ignore
 # needed for python 3.8
@@ -39,7 +40,6 @@ def create_typed_class(name: str, fallback_class: type = object) -> type:
 
     def __instancecheck__(self, instance: Any) -> bool:
         if isinstance(instance, cls):
-
             return types_subseteq(
                 instance.get_params(),  # type:ignore
                 self.get_params()
@@ -51,7 +51,7 @@ def create_typed_class(name: str, fallback_class: type = object) -> type:
         )
 
     def __init__(self, item) -> None:
-        if not get_caller_name(0) == "__class_getitem__":
+        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

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/colors.py

@@ -1,7 +1,6 @@
 from typing import Optional, IO
 from .decorators import validate
 
-
 RESET = "\033[0m"
 
 
@@ -16,15 +15,16 @@ class ColoredText:
         white,
         black
     """
-    @staticmethod
+
+    @staticmethod  # type:ignore
     @validate
     def from_rgb(red: int, green: int, blue: int, text: str) -> str:
         """Applies an RGB color to the given text.
 
         Args:
-            r (int): The red component of the color.
-            g (int): The green component of the color.
-            b (int): The blue component of the color.
+            red (int): The red component of the color.
+            green (int): The green component of the color.
+            blue (int): The blue component of the color.
             text (str): The text to apply the color to.
 
         Returns:
@@ -178,7 +178,7 @@ def error(*args, sep: str = " ", end: str = "\n"):
 
 
 def info(*args, sep: str = " ", end: str = "\n"):
-    """print an error message
+    """print an info message
 
     Args:
         sep (str, optional): print separator. Defaults to " ".

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/data_structures/Comparer.py

@@ -1,5 +1,5 @@
 """Comparer class"""
-from typing import Callable, Any, Union, Generic, TypeVar
+from typing import Callable,  Union, Generic, TypeVar
 from .functions import default_weight_function
 
 U = TypeVar("U")

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/data_structures/Stack.py

@@ -1,4 +1,4 @@
-from typing import Optional, Generator, Any, cast, TypeVar, Generic
+from typing import Optional, Generator, TypeVar, Generic
 from .graph import Node
 
 T = TypeVar('T')
@@ -12,7 +12,7 @@ class Stack(Generic[T]):
         self.head: Optional[Node[T]] = None
         self.size = 0
 
-    def push(self, value: Node[T]):
+    def push(self, value: T):
         """push an item to the stack
 
         Args:
@@ -25,23 +25,33 @@ class Stack(Generic[T]):
             self.head = new_head
         self.size += 1
 
-    def pop(self) -> Node[T]:
+    def pop(self) -> T:
         """pop an item from the stack
 
         Returns:
             Any: poped item
         """
         if not self.is_empty():
-            self.head = cast(Node, self.head)
-            res = self.head.data
+            res = self.head.data  # type:ignore
             self.size -= 1
-            self.head = self.head.next
+            self.head = self.head.next  # type:ignore
             return res
+        raise RuntimeError("Can't pop from an empty stack")
+
+    def peek(self) -> Optional[T]:
+        """
+        Returns the top element of the stack
+        Returns:
+            Optional[T]
+        """
+        if self.is_empty():
+            return None
+        return self.head.data
 
     def __len__(self) -> int:
         return self.size
 
-    def __iter__(self) -> Generator[Node[T], None, None]:
+    def __iter__(self) -> Generator[T, None, None]:
         while self:
             yield self.pop()
 
@@ -58,6 +68,7 @@ class Stack(Generic[T]):
         while curr is not None:
             if curr.data == value:
                 return True
+            curr = curr.next
         return False
 
     def __str__(self) -> str:

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/data_structures/__init__.py

@@ -4,4 +4,4 @@ from .comparer import *
 from .graph import *
 from .stack import *
 from .default_dict import *
-from .trees import *
+from .trees import *

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/data_structures/default_dict.py

@@ -1,9 +1,8 @@
-"""
-My implementation to collections.defaultdict
-"""
-
-
 class DefaultDict(dict):
+    """
+    My implementation to `collections.defaultdict`
+    """
+
     def __init__(self, cls):
         self._cls = cls
 

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/__init__.py

@@ -12,4 +12,5 @@ from .threadify import *
 from .delay_call import *
 from .deprecate import *
 from .processify import *
-from .singleton import *
+from .singleton import *
+from .total_ordering import *

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/attach.py

@@ -1,6 +1,5 @@
 import functools
 from typing import Callable, Optional, TypeVar
-import platform
 from .validate import validate
 from ..reflection import get_python_version
 if get_python_version() < (3, 9):

danielutils-0.9.73/danielutils/decorators/decorate_conditionally.py

@@ -0,0 +1,32 @@
+import functools
+from typing import Callable, Optional, Union
+from .validate import validate
+
+
+@validate(strict=False)
+def decorate_conditionally(decorator: Callable, predicate: Union[bool, Callable[[], bool]], *,
+                           decorator_args: Optional[list] = None, decorator_kwargs: Optional[dict] = None):
+    """will decorate a function iff the predicate is True or returns True
+
+    Args:
+        decorator (Callable): the decorator to use
+        predicate (bool | Callable[[], bool]): the predicate
+    """
+
+    def deco(func):
+        if (predicate() if callable(predicate) else predicate):
+            nonlocal decorator_args, decorator_kwargs, decorator
+            if decorator_args is None:
+                decorator_args = []
+            if decorator_kwargs is None:
+                decorator_kwargs = {}
+            decorator = functools.wraps(func)(decorator)
+            return decorator(*decorator_args, **decorator_kwargs)(func)
+        return func
+
+    return deco
+
+
+__all__ = [
+    "decorate_conditionally"
+]

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/delay_call.py

@@ -1,5 +1,4 @@
 from typing import Callable, TypeVar, Union
-import platform
 import time
 import functools
 from .decorate_conditionally import decorate_conditionally

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/deprecate.py

@@ -1,4 +1,3 @@
-import platform
 from typing import Callable, TypeVar
 from ..colors import warning, ColoredText
 

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/limit_recursion.py

@@ -1,7 +1,6 @@
 import functools
 import re
 import traceback
-import platform
 from typing import Any, Callable, TypeVar
 from .validate import validate
 from ..colors import warning

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/memo.py

@@ -1,6 +1,6 @@
-from typing import Callable, Any, TypeVar, Dict as t_dict
 import functools
-import platform
+from typing import Callable, Any, TypeVar, Dict as t_dict
+from copy import deepcopy
 from .validate import validate
 
 from ..reflection import get_python_version
@@ -9,7 +9,6 @@ if get_python_version() < (3, 9):
 else:
     from builtins import dict as t_dict
     from typing import ParamSpec  # type:ignore # pylint: disable=ungrouped-imports
-from copy import deepcopy
 T = TypeVar("T")
 P = ParamSpec("P")
 FuncT = Callable[P, T]  # type:ignore

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/overload.py

@@ -1,12 +1,12 @@
 from typing import Callable, cast, Any, TypeVar, Dict as t_dict, List as t_list
 import inspect
-import platform
 import functools
 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
+
 if get_python_version() < (3, 9):
     from typing_extensions import ParamSpec
 else:
@@ -79,7 +79,7 @@ def explicit_global_overload(*types) -> Callable:
 
         __overload_dict[name][types] = func
 
-        @ functools.wraps(func)
+        @functools.wraps(func)
         def wrapper(*args, **kwargs) -> Any:
             default_func = None
             # select correct overload
@@ -112,6 +112,7 @@ def explicit_global_overload(*types) -> Callable:
                 f"function {func.__module__}.{func.__qualname__} is not overloaded with {[type(v) for v in args]}")
 
         return wrapper
+
     return deco
 
 
@@ -160,31 +161,42 @@ class overload:
         return self
 
     def __call__(self, *args, **kwargs):
-        num_args = len(args)+len(kwargs.keys())
+        num_args = len(args) + len(kwargs.keys())
         if num_args not in self._functions:
             raise AttributeError(
                 f"No overload with {num_args} argument found for {self._moudle}.{self._qualname}")
-        selected_func = None
-        if len(self._functions[num_args]) == 1:
-            selected_func = self._functions[num_args][0]
-        else:
-            for func in self._functions[num_args]:
-                signature = inspect.signature(func)
-                for i, tup in enumerate(signature.parameters.items()):
-                    param_name, param_type = tup
-                    if param_name in overload.__SKIP_SET:
-                        continue
 
-                    if not isoftype(args[i], param_type.annotation):
-                        break
+        if num_args == 0:
+            return self._functions[num_args][0](*args, **kwargs)
+
+        max_score = 0
+        winner = self._functions[num_args][0]
+        EXACT_MATCH = 1 / num_args
+        SUBCLASS = 1 / num_args
+        for func in self._functions[num_args]:
+            score = 0
+            signature = inspect.signature(func)
+            for i, tup in enumerate(signature.parameters.items()):
+                param_name, param_type = tup
+                if param_name in overload.__SKIP_SET:
+                    continue
+
+                if type(args[i]) == param_type.annotation:  # pylint :disable=unidiomatic-typecheck
+                    score += EXACT_MATCH
+
+                elif isoftype(args[i], param_type.annotation):
+                    score += SUBCLASS
                 else:
-                    # reaching here means current function matches perfectly the annotation
-                    selected_func = func
                     break
+
             else:
-                raise AttributeError("No overload found")
+                # reaching here means current function matches perfectly the annotation
+                if score > max_score:
+                    max_score = score
+                    winner = func
+        # raise AttributeError("No overload found")
 
-        return selected_func(*args, **kwargs)
+        return winner(*args, **kwargs)
 
 
 __all__ = [

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/partially_implemented.py

@@ -1,6 +1,5 @@
 from typing import Callable, Any, TypeVar
 import functools
-import platform
 from .validate import validate
 from ..colors import warning
 

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/processify.py

@@ -2,7 +2,7 @@ import inspect
 import functools
 import multiprocessing
 
-from ..reflection import get_n_caller_func, get_current_frame, get_n_prev_frame
+from ..reflection import get_prev_frame
 from ..multi_x import process_id
 import pickle
 
@@ -24,7 +24,7 @@ def processify(func):
     def wrapper(*args, **kwargs):
         main_pid = kwargs.get("__main_pid", process_id())
         if process_id() == main_pid:
-            frame = get_n_prev_frame(2)
+            frame = get_prev_frame(2)
             dct = {k: v for k, v in frame.f_globals.items() if type(v) != type(inspect)}
             p = multiprocessing.Process(target=_run_func, args=(main_pid, dct, func.__name__, args, kwargs))
             p.start()
@@ -41,7 +41,7 @@ def _run_func(main_pid: int, dct: dict, func_name: str, args, kwargs) -> None:
     return dct[func_name](*args, __main_pid=main_pid, **kwargs)
 
 def debug_info(include_builtins: bool = False) -> dict:
-    f = get_n_prev_frame(2)
+    f = get_prev_frame(2)
     g = {k: v for k, v in f.f_globals.items() if k != "__builtins__"} if not include_builtins else dict(f.f_globals)
     return {
         "file": f.f_code.co_filename,

{danielutils-0.9.72 → danielutils-0.9.73}/danielutils/decorators/threadify.py

@@ -1,5 +1,4 @@
 from typing import Callable, TypeVar
-import platform
 import functools
 import threading