danielutils 0.9.84__tar.gz → 0.9.91__tar.gz

{danielutils-0.9.84/danielutils.egg-info → danielutils-0.9.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.84
+Version: 0.9.91
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/__init__.py

@@ -40,4 +40,5 @@ from .generators import *
 from .university import *
 from .mock_ import *
 from .context_managers import *
-from .file_specifications import *
+from .file_specifications import *
+from .testing import *

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/abstractions/multiprogramming/worker.py

@@ -12,7 +12,7 @@ class Worker(ABC):
     """A Worker Interface
     """
 
-    def __init__(self, id: int, pool: "danielutils.Threading.worker_pool.WorkerPool") -> None:  # pylint: disable=redefined-builtin #noqa
+    def __init__(self, id: int, pool: "danielutils.abstractions.multiprogramming.worker_pool.WorkerPool") -> None:  # pylint: disable=redefined-builtin #noqa
         self.id = id
         self.pool = pool
         self.thread: Thread = Thread(target=self._loop)
@@ -57,6 +57,7 @@ class Worker(ABC):
         to signal actions if needed
         will call 'notification_function'
         """
+        # TODO
         self.pool._notify_subscribers()  # pylint: disable=protected-access
 
     def acquire(self) -> Optional[Tuple[Any]]:

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/aliases.py

@@ -150,16 +150,15 @@ T = TypeVar("T")
 
 Supplier = Callable[[], T]
 Runnable = Supplier[None]
-
+Consumer = Callable[[T], None]
 UnaryFunction = Callable[[U], T]
-UnaryOperator = UnaryFunction[T, T]
-Predicate = UnaryFunction[T, bool]
-Consumer = UnaryFunction[T, None]
+UnaryOperator = Callable[[T], T]
+Predicate = Callable[[T], bool]
 
 BinaryFunction = Callable[[A, B], T]
-BinaryOperator = BinaryFunction[T, T, T]
-Comparator = BinaryFunction[A, B, int]
-BinaryConsumer = BinaryFunction[T, T, None]
+BinaryOperator = Callable[[T, T], T]
+Comparator = Callable[[A, B], int]
+BinaryConsumer = Callable[[T, T], None]
 
 __all__ = [
     "UnaryFunction",

danielutils-0.9.91/danielutils/context_managers/__init__.py

@@ -0,0 +1,5 @@
+from .attr_context import *
+from .multi_context import *
+from .optional_context import *
+from .state_context import *
+from .temporary_file import *

danielutils-0.9.91/danielutils/context_managers/optional_context.py

@@ -0,0 +1,18 @@
+from typing import ContextManager
+class OptionalContext(ContextManager):
+    def __init__(self, predicate: bool, context: ContextManager):
+        self.predicate = predicate
+        self.context = context
+
+    def __enter__(self):
+        if self.predicate:
+            self.context.__enter__()
+
+    def __exit__(self, __exc_type, __exc_value, __traceback):
+        if self.predicate:
+            self.context.__exit__(__exc_type, __exc_value, __traceback)
+
+
+__all__=[
+    "OptionalContext"
+]

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/context_managers/temporary_file.py

@@ -1,10 +1,10 @@
-from typing import ContextManager
-from ..io_ import file_exists, delete_file
 import atexit
+from typing import ContextManager, Set, List
+from ..io_ import file_exists, delete_file
 
 
 class TemporaryFile(ContextManager):
-    _instances: set['TemporaryFile'] = set()
+    _instances: Set['TemporaryFile'] = set()
 
     def __init__(self, path: str):
         if file_exists(path):
@@ -18,22 +18,16 @@ class TemporaryFile(ContextManager):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-    @atexit.register
-    @staticmethod
-    def _global_close():
-        for inst in TemporaryFile._instances:
-            inst.close()
-
     def close(self) -> None:
         delete_file(self.path)
 
-    def read(self) -> list[str]:
+    def read(self) -> List[str]:
         if not file_exists(self.path):
             return []
         with open(self.path, 'r') as f:
             return f.readlines()
 
-    def write(self, lines: list[str]) -> None:
+    def write(self, lines: List[str]) -> None:
         with open(self.path, 'a') as f:
             f.writelines(lines)
 
@@ -42,6 +36,12 @@ class TemporaryFile(ContextManager):
             pass
 
 
+@atexit.register
+def __close_all():
+    for inst in TemporaryFile._instances:  # type:ignore #pylint: disable=all
+        inst.close()
+
+
 __all__ = [
     'TemporaryFile'
 ]

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/custom_types.py

@@ -1,4 +1,9 @@
-from typing import TypeAlias, Callable, TypeVar, Generic
+from typing import Callable, TypeVar, Generic
+
+try:
+    from typing import TypeAlias
+except ImportError:
+    from typing_extensions import TypeAlias
 
 T = TypeVar('T')
 U = TypeVar('U')

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/data_structures/__init__.py

@@ -5,3 +5,4 @@ from .graph import *
 from .stack import *
 from .default_dict import *
 from .trees import *
+from .algorithms import *

danielutils-0.9.91/danielutils/data_structures/algorithms.py

@@ -0,0 +1,44 @@
+from collections import defaultdict
+from typing import TypeVar, List, Callable, Dict
+from itertools import product
+from copy import deepcopy
+
+NodeT = TypeVar("NodeT")
+
+DistanceMatrix = Dict[NodeT, Dict[NodeT, float]]
+
+
+def bellman_ford(nodes: List[NodeT], weight_func: Callable[[NodeT, NodeT], float],
+                 iteration_callback: Callable[[DistanceMatrix], None],
+                 poisoned_reverse: bool = False) -> DistanceMatrix:
+    dist: Dict[NodeT, Dict[NodeT, float]] = defaultdict(defaultdict)
+    prev: Dict[NodeT, Dict[NodeT, NodeT]] = defaultdict(defaultdict)
+
+    for u, v in product(nodes, nodes):
+        dist[u][v] = weight_func(u, v)
+
+    iteration_callback(dist)
+
+    for _ in range(len(nodes) - 1):
+        tmp = deepcopy(dist)
+        for u, v in product(nodes, nodes):
+            if u == v:
+                continue
+
+            for mid in nodes:
+                if mid == u or mid == v:
+                    continue
+
+                if dist[u][v] > dist[u][mid] + dist[mid][v]:
+                    tmp[u][v] = dist[u][mid] + dist[mid][v]
+                    prev[u][v] = mid
+
+        dist = tmp
+        iteration_callback(dist)
+
+    iteration_callback(prev)
+
+
+__all__ = [
+    "bellman_ford"
+]

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/decorators/decorate_conditionally.py

@@ -3,7 +3,7 @@ from typing import Callable, Optional, Union
 from .validate import validate
 
 
-@validate  # type:ignore(strict=False)
+@validate(strict=False)  # type:ignore
 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

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/decorators/memo.py

@@ -1,5 +1,5 @@
 import functools
-from typing import Callable, Any, TypeVar, Dict
+from typing import Callable, Any, TypeVar, Dict, Generator, List, Set, Optional
 from copy import deepcopy
 from .validate import validate
 from ..versioned_imports import ParamSpec
@@ -27,6 +27,25 @@ def memo(func: FuncT) -> FuncT:
     return wrapper
 
 
+def memo_generator(func: Callable[P, Generator]) -> Callable[P, Generator]:
+    cache: Dict[tuple, Any] = {}
+
+    @functools.wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> Generator:
+        args = tuple(args)
+        if (args, *kwargs.items()) not in cache:
+            lst = []
+            for v in func(*args, **kwargs):
+                lst.append(v)
+                yield v
+            cache[(args, *kwargs.items())] = lst
+        else:
+            yield from cache[(args, *kwargs.items())]
+
+    return wrapper
+
+
 __all__ = [
-    "memo"
+    "memo",
+    "memo_generator"
 ]

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/decorators/overload.py

@@ -1,4 +1,4 @@
-from typing import Callable, cast, Any, TypeVar, Dict
+from typing import Callable, cast, Any, TypeVar, Dict, List
 import inspect
 import functools
 from ..reflection import is_function_annotated_properly
@@ -122,7 +122,7 @@ class overload:
         overload._validate(func)
         self._qualname = func.__qualname__
         self._moudle = func.__module__
-        self._functions: Dict[int, Dict[Callable]] = {}
+        self._functions: Dict[int, List[Callable]] = {}
         self._functions[overload._get_key(func)] = [func]
         functools.wraps(func)(self)
 

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/decorators/processify.py

@@ -35,12 +35,14 @@ def processify(func):
     return wrapper
 
 
-
 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_prev_frame(2)
+    if f is None:
+        raise RuntimeError("Failed to get frame")
     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.84 → danielutils-0.9.91}/danielutils/file_specifications/__init__.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, List
 from enum import Enum
 
 
@@ -29,12 +29,13 @@ class Field:
 class Section:
     name: str
     prefix: bytes
-    fields: Optional[list[Field]]
+    fields: Optional[List[Field]]
     is_optional: bool = False
 
 
 class FileSpecification:
-    def __init__(self, long_name: str, short_name: str, extension: str, specification: str, sections: list[Section]):
+    def __init__(self, long_name: str, short_name: str, extension: str, specification: str,
+                 sections: List[Section]) -> None:
         """
 
         Args:

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/functions/__init__.py

@@ -9,3 +9,5 @@ from .flatten import *
 from .subseteq import *
 from .parallel_for import *
 from .foreach import *
+from .factorial import *
+from .partition import *

danielutils-0.9.91/danielutils/functions/factorial.py

@@ -0,0 +1,5 @@
+def factorial(n: int) -> int:
+    res = 1
+    for i in range(2, n + 1):
+        res *= i
+    return res

danielutils-0.9.91/danielutils/functions/partition.py

@@ -0,0 +1,37 @@
+from typing import List, Generator, Tuple, Union
+
+
+def partitions(n: int, k: int) -> Generator[List[int], None, None]:
+    from ..decorators import memo_generator
+
+    @memo_generator()
+    def helper(n: int, target_sum: int, current_sum: int, topLevel: int, arr: Union[List[int], Tuple[int]]) -> \
+            Generator[List[int], None, None]:
+        arr = list(arr)
+        if n == 1:
+            if current_sum <= target_sum:
+                if topLevel == 1 or (target_sum - current_sum >= arr[-2]):
+                    arr[-1] = target_sum - current_sum
+                    yield tuple(arr)
+            return
+
+        start = 0
+        if n != topLevel:
+            start = arr[-1 * n - 1]
+
+        for i in range(start, target_sum + 1):
+            arr[-1 * n] = i
+            yield from helper(n - 1, target_sum, current_sum + i, topLevel, tuple(arr))
+
+    arr: List[int] = [0] * k
+    yield from helper(k, n, 0, k, tuple(arr))
+
+
+def num_partitions(n: int, k: int) -> int:
+    return len(list(partitions(n, k)))
+
+
+__all__ = [
+    "partitions",
+    "num_partitions"
+]

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/generators/join_generators.py

@@ -44,7 +44,7 @@ def join_generators(*generators) -> Generator[Tuple[int, Any], None, None]:
     Yields:
         Generator[Any, None, None]: one generator that combines all of the given ones
     """
-    queue = Queue()
+    queue: Queue = Queue()
     edit_queue_semaphore = Semaphore(1)
     queue_status_semaphore = Semaphore(0)
     finished_threads_counter = AtomicCounter()

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/progress_bar/ascii_progress_bar.py

@@ -1,5 +1,5 @@
 import time
-from typing import Optional, Iterable, Sized
+from typing import Optional, Iterable, Sized, Iterator
 
 from .progress_bar import ProgressBar
 from .progress_bar_pool import ProgressBarPool
@@ -10,7 +10,7 @@ class AsciiProgressBar(ProgressBar):
 
     def __init__(
             self,
-            iterable: Iterable,
+            iterator: Iterator,
             position: int,
             *,
             total: Optional[float] = None,
@@ -18,20 +18,19 @@ class AsciiProgressBar(ProgressBar):
             leave: bool = True,
             num_bars: int = 1,
             ncols: int = 50,
-            pool: Optional = None,
+            pool: Optional[ProgressBarPool] = None,
             **kwargs
     ):
         total_ = 1
-        if isinstance(iterable, Sized):
-            total_ = len(iterable)
+        if isinstance(iterator, Sized):
+            total_ = len(iterator)
         if total is not None:
             total_ = total
-        ProgressBar.__init__(self, total_, position)
-        self.iterable: Iterable = iterable
+        ProgressBar.__init__(self, total_, position, desc=desc)
+        self.iterator: Iterator = iterator
         self.pool: ProgressBarPool = pool
         self.num_bars: int = num_bars
         self.leave: bool = leave
-        self.desc: str = desc
         self.initial_value: float = 0
         self.current_value: float = 0
         self.ncols: int = ncols
@@ -47,16 +46,18 @@ class AsciiProgressBar(ProgressBar):
 
     def __iter__(self):
         self.bprint_row_index = bprint.current_row
-        for v in self.iterable:
+        for v in self.iterator:
             self.update(0)
             yield v
             bprint.move_up()
             bprint.clear_line()
-            bprint.rows.pop()
+            if len(bprint.rows) > 0:
+                bprint.rows.pop()
             self.update(1)
             bprint.move_up()
             bprint.clear_line()
-            bprint.rows.pop()
+            if len(bprint.rows) > 0:
+                bprint.rows.pop()
         if self.position > 0:
             self.reset()
         else:
@@ -79,11 +80,21 @@ class AsciiProgressBar(ProgressBar):
             unit=self.unit
         )
         if refresh and self.pool is not None and len(self.pool.bars) > 1:
-            for w in self.writes:
-                bprint(w, end="")
-        bprint(to_print)
+            i = bprint.rows.index(f"{self.prev_print}\n")
+            rows = [to_print]
+            for j, row in enumerate(bprint.rows[i + 1:]):
+                rows.append(row)
+            for row in rows:
+                bprint.move_up(1)
+                bprint.clear_line()
+                bprint.rows.pop()
+            for row in rows:
+                bprint(row)
+        else:
+            bprint(to_print)
+        self.prev_print = to_print
 
-    def update(self, amount: float = 1, refresh: bool = False):
+    def update(self, amount: float = 1, refresh: bool = False):  # type:ignore
         self.prev_value = self.current_value
         self.current_value = min(
             self.current_value + amount, self.total)  # type:ignore

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/progress_bar/progress_bar.py

@@ -20,7 +20,9 @@ class ProgressBar(ABC):
     DEFAULT_BAR_FORMAT = "{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}"
 
     @abstractmethod
-    def __init__(self, total, position: int, unit="it", bar_format: str = DEFAULT_BAR_FORMAT, **kwargs) -> None:
+    def __init__(self, total, position: int, unit="it", bar_format: str = DEFAULT_BAR_FORMAT, *, desc: str,
+                 **kwargs) -> None:
+        self.desc: str = desc
         self.total = total
         self.position = position
         self.unit = unit
@@ -32,7 +34,7 @@ class ProgressBar(ABC):
         return len(self.writes)
 
     @abstractmethod
-    def update(self, amount: float = 1) -> None:
+    def update(self, amount: float = 1, **kwargs) -> None:
         """A function to update the progress-bar's value by a positive relative amount
         """
 
@@ -51,6 +53,9 @@ class ProgressBar(ABC):
         """A function to reset the progress-bar's progress
        """
 
+    @abstractmethod
+    def __iter__(self): ...
+
 
 try:
     from tqdm import tqdm

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/reflection/interpreter/callstack.py

@@ -25,8 +25,10 @@ def get_prev_frame(n_steps: int = 1) -> Optional[FrameType]:
 
 def get_prev_line_of_code(n_steps: int = 1) -> Optional[str]:
     frame = get_prev_frame(n_steps + 1)
-    file = frame.f_back.f_code.co_filename
-    line_number = frame.f_back.f_lineno - 1
+    if frame is None:
+        return None
+    file = frame.f_back.f_code.co_filename  # type:ignore
+    line_number = frame.f_back.f_lineno - 1  # type:ignore
     with open(file, "r", encoding="utf-8") as f:
         lines = f.readlines()
     line = lines[line_number]

danielutils-0.9.91/danielutils/retry_executor/__init__.py

@@ -0,0 +1,3 @@
+from .backoff_strategies import *
+from .backoff_strategy import *
+from .retry_executor import *

danielutils-0.9.91/danielutils/retry_executor/backoff_strategies/__init__.py

@@ -0,0 +1,3 @@
+from .no_backoff import *
+from .constant_backoff import *
+from .exponential_backoff import *

danielutils-0.9.91/danielutils/retry_executor/backoff_strategies/constant_backoff.py

@@ -0,0 +1,19 @@
+from ..backoff_strategy import BackOffStrategy
+
+
+class ConstantBackOffStrategy(BackOffStrategy):
+    """
+    will always back off exactly the same amount of time
+
+    :param delay: The amount of milliseconds to sleep
+    """
+
+    def __init__(self, delay: int) -> None:
+        if not delay >= 0:
+            raise ValueError("delay must be positive")
+        super().__init__(lambda: delay)
+
+
+__all__ = [
+    "ConstantBackOffStrategy"
+]

danielutils-0.9.91/danielutils/retry_executor/backoff_strategies/exponential_backoff.py

@@ -0,0 +1,21 @@
+from ..backoff_strategy import BackOffStrategy
+
+
+class ExponentialBackOffStrategy(BackOffStrategy):
+    def __init__(self, initial: int, multiplier: float) -> None:
+        if not initial >= 0:
+            raise ValueError("initial must be positive")
+        if not multiplier >= 0:
+            raise ValueError("multiplier must be positive")
+        prev: float = 1.0
+
+        def inner() -> int:
+            nonlocal prev
+            return initial ** (prev := prev * multiplier)
+
+        super().__init__(inner)
+
+
+__all__ = [
+    "ExponentialBackOffStrategy"
+]

danielutils-0.9.91/danielutils/retry_executor/backoff_strategies/no_backoff.py

@@ -0,0 +1,12 @@
+from ..backoff_strategy import BackOffStrategy
+
+
+class NoBackOffStrategy(BackOffStrategy):
+
+    def __init__(self) -> None:
+        super().__init__(lambda: 0)
+
+
+__all__ = [
+    'NoBackOffStrategy',
+]

danielutils-0.9.91/danielutils/retry_executor/backoff_strategy.py

@@ -0,0 +1,22 @@
+from danielutils import Supplier
+
+
+class BackOffStrategy:
+    """
+    A class to create a common abstraction for backoff strategies
+    """
+
+    def __init__(self, supp: Supplier[int]) -> None:
+        self._supp = supp
+
+    def get_backoff(self) -> int:
+        """
+
+        :return: amount of milliseconds to sleep
+        """
+        return self._supp()
+
+
+__all__ = [
+    "BackOffStrategy"
+]

danielutils-0.9.91/danielutils/retry_executor/retry_executor.py

@@ -0,0 +1,37 @@
+import time
+from typing import Generic, TypeVar, Optional
+
+from danielutils import Supplier, Consumer
+from .backoff_strategies import ConstantBackOffStrategy
+
+from .backoff_strategy import BackOffStrategy
+
+T = TypeVar("T")
+
+
+class RetryExecutor(Generic[T]):
+    def __init__(self, backoff_strategy: BackOffStrategy = ConstantBackOffStrategy(200)) -> None:
+        self._backoff_strategy = backoff_strategy
+
+    def execute(self, supp: Supplier[T], max_retries: int = 5,
+                exception_callback: Optional[Consumer[Exception]] = None) -> Optional[T]:
+
+        for i in range(max_retries):
+
+            try:
+                return supp()
+            except Exception as e:
+                if exception_callback:
+                    exception_callback(e)
+
+            if i != max_retries - 1:
+                self._sleep()
+        return None
+
+    def _sleep(self) -> None:
+        time.sleep(self._backoff_strategy.get_backoff())
+
+
+__all__ = [
+    "RetryExecutor",
+]

{danielutils-0.9.84 → danielutils-0.9.91}/danielutils/system/layered_command.py

@@ -1,5 +1,5 @@
 import sys, os
-from typing import Optional
+from typing import Optional, Tuple, List
 from ..context_managers import TemporaryFile
 import random
 
@@ -79,7 +79,7 @@ class LayeredCommand:
             command_flush_stderr: Optional[bool] = None,
             command_raise_on_fail: Optional[bool] = None,
             command_verbose: Optional[bool] = None
-    ) -> tuple[int, list[str], list[str]]:
+    ) -> Tuple[int, List[str], List[str]]:
         if not self._has_entered:
             raise RuntimeError(
                 "LayeredCommand must be used with a context manager. Use as: `with LayeredCommand(...) as l1:`")
@@ -109,7 +109,7 @@ class LayeredCommand:
                 self._error(raise_on_fail and code != 0, command, code, command_verbose)
                 return code, stdout.read(), stderr.read()
 
-    def __call__(self, *args, **kwargs) -> tuple[int, list[str], list[str]]:
+    def __call__(self, *args, **kwargs) -> Tuple[int, List[str], List[str]]:
         return self.execute(*args, **kwargs)
 
 

danielutils-0.9.91/danielutils/testing/__init__.py

@@ -0,0 +1 @@
+from .unittest_ import *

danielutils-0.9.91/danielutils/testing/unittest_/__init__.py

@@ -0,0 +1,2 @@
+from .always_teardown_testcase import *
+from .auto_cwd_testcase import *