danielutils 0.9.83__tar.gz → 0.9.90__tar.gz

{danielutils-0.9.83/danielutils.egg-info → danielutils-0.9.90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.83
+Version: 0.9.90
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -41,7 +41,7 @@ License-File: LICENSE
 [![Python 3.10.11](https://img.shields.io/badge/python-3.10.11-blue.svg)](https://www.python.org/downloads/release/python-31011/)
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
-# danielutils v=0.9.83
+# danielutils v=0.9.84
 A utils library for things that I find useful for my coding workflow.\
 Feel free to use and / or contribute / improve my code :)
 

{danielutils-0.9.83 → danielutils-0.9.90}/README.md

@@ -4,7 +4,7 @@
 [![Python 3.10.11](https://img.shields.io/badge/python-3.10.11-blue.svg)](https://www.python.org/downloads/release/python-31011/)
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
-# danielutils v=0.9.83
+# danielutils v=0.9.84
 A utils library for things that I find useful for my coding workflow.\
 Feel free to use and / or contribute / improve my code :)
 

{danielutils-0.9.83 → danielutils-0.9.90}/danielutils/__init__.py

@@ -18,11 +18,11 @@ from .protocols import *
 from .reflection import *
 from .decorators import *
 # ========== NEEDS REFLECTION ==========
-from .progress_bar import *
 # ========== NEEDS DECORATORS ==========
 from .colors import *
 # ========== NEEDS BOTH ==========
 
+from .progress_bar import *
 from .functions import *
 from .io_ import *
 from .system import *
@@ -40,3 +40,4 @@ from .generators import *
 from .university import *
 from .mock_ import *
 from .context_managers import *
+from .file_specifications import *

{danielutils-0.9.83 → danielutils-0.9.90}/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.90/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.83 → danielutils-0.9.90}/danielutils/context_managers/attr_context.py

@@ -1,4 +1,5 @@
-class AttrContext:
+from typing import ContextManager
+class AttrContext(ContextManager):
     def __init__(self, obj: object, attr: str, new_value: object, *, nonexistent_is_error: bool = True) -> None:
         self.obj = obj
         self.attr = attr

danielutils-0.9.90/danielutils/context_managers/multi_context.py

@@ -0,0 +1,23 @@
+from typing import ContextManager
+
+
+class MultiContext(ContextManager):
+    def __init__(self, *contexts: ContextManager):
+        self.contexts = contexts
+
+    def __enter__(self):
+        for context in self.contexts:
+            context.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        for context in self.contexts:
+            context.__exit__(exc_type, exc_val, exc_tb)
+
+    def __getitem__(self, index):
+        return self.contexts[index]
+
+
+__all__ = [
+    "MultiContext",
+]

danielutils-0.9.90/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.90/danielutils/context_managers/state_context.py

@@ -0,0 +1,16 @@
+from contextlib import contextmanager
+from ..custom_types import Procedure
+
+
+@contextmanager
+def StateContext(set_state: Procedure, restore_state: Procedure):
+    try:
+        set_state()
+        yield
+    finally:
+        restore_state()
+
+
+__all__ = [
+    'StateContext'
+]

{danielutils-0.9.83 → danielutils-0.9.90}/danielutils/context_managers/temporary_file.py

@@ -1,9 +1,10 @@
-from ..io_ import file_exists, delete_file
 import atexit
+from typing import ContextManager, Set, List
+from ..io_ import file_exists, delete_file
 
 
-class TemporaryFile:
-    _instances: set['TemporaryFile'] = set()
+class TemporaryFile(ContextManager):
+    _instances: Set['TemporaryFile'] = set()
 
     def __init__(self, path: str):
         if file_exists(path):
@@ -17,22 +18,16 @@ class TemporaryFile:
     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)
 
@@ -41,6 +36,12 @@ class TemporaryFile:
             pass
 
 
+@atexit.register
+def __close_all():
+    for inst in TemporaryFile._instances:  # type:ignore #pylint: disable=all
+        inst.close()
+
+
 __all__ = [
     'TemporaryFile'
 ]

danielutils-0.9.90/danielutils/custom_types.py

@@ -0,0 +1,22 @@
+from typing import Callable, TypeVar, Generic
+
+try:
+    from typing import TypeAlias
+except ImportError:
+    from typing_extensions import TypeAlias
+
+T = TypeVar('T')
+U = TypeVar('U')
+Procedure: TypeAlias = Callable[[], None]
+Supplier: TypeAlias = Callable[[], T]
+Consumer: TypeAlias = Callable[[T], None]
+Predicate: TypeAlias = Callable[[], bool]
+Mapper: TypeAlias = Callable[[T], U]
+
+__all__ = [
+    'Procedure',
+    'Supplier',
+    'Consumer',
+    'Predicate',
+    'Mapper'
+]

{danielutils-0.9.83 → danielutils-0.9.90}/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.90/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.83 → danielutils-0.9.90}/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.83 → danielutils-0.9.90}/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.83 → danielutils-0.9.90}/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.83 → danielutils-0.9.90}/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.90/danielutils/file_specifications/__init__.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Optional, List
+from enum import Enum
+
+
+@dataclass
+class Field:
+    """
+    A Field object for a Section in a file
+
+    Params:
+        name (str): The name of the field
+        size (int): The size of the field in bytes
+        type (Field.Type): The type of the field
+    """
+
+    class Type(Enum):
+        INTEGER = "INTEGER"
+        FLOAT = "FLOAT"
+        STRING = "STRING"
+        BOOL = "BOOL"
+
+    name: str
+    size: int
+    type: Type = Type.INTEGER
+
+
+@dataclass
+class Section:
+    name: str
+    prefix: bytes
+    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]) -> None:
+        """
+
+        Args:
+            long_name:
+            short_name:
+            extension:
+            specification:
+            sections:
+        """
+        self.long_name = long_name
+        self.short_name = short_name
+        self.extension = extension
+        self.specification = specification
+        self.sections = sections
+
+    def open(self, path: str):
+        if not path.endswith(self.extension):
+            raise ValueError(f"Invalid file extension, expected {self.extension}")
+        with open(path, "rb") as f:
+            lines = f.readlines()
+        for line in lines:
+            for b in line:
+                pass
+
+        return lines
+
+
+__all__ = [
+    "Field",
+    "Section",
+    "FileSpecification",
+    "FileSpecification",
+]

{danielutils-0.9.83 → danielutils-0.9.90}/danielutils/functions/__init__.py

@@ -7,4 +7,7 @@ from .powerset import *
 from .multiloop import *
 from .flatten import *
 from .subseteq import *
-from .parallel_for import *
+from .parallel_for import *
+from .foreach import *
+from .factorial import *
+from .partition import *

danielutils-0.9.90/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.90/danielutils/functions/foreach.py

@@ -0,0 +1,14 @@
+from typing import TypeVar, Iterable
+from ..custom_types import Consumer
+
+T = TypeVar('T')
+
+
+def foreach(iterable: Iterable[T], consumer: Consumer[T]) -> None:
+    for v in iterable:
+        consumer(v)
+
+
+__all__ = [
+    'foreach'
+]

danielutils-0.9.90/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.83 → danielutils-0.9.90}/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.83 → danielutils-0.9.90}/danielutils/print_.py

@@ -26,7 +26,7 @@ def mprint(*args, sep: str = " ", end: str = "\n", stream=sys.stdout) -> None:
     stream.write(sep.join([mprint_parse_one(s) for s in args]) + end)
 
 
-@deprecate("The built-in 'print' function has an argument called 'file', use this instead")
+@deprecate("The built-in 'print' function has an argument called 'file', use this instead")  # type:ignore
 def sprint(*args, sep: str = " ", end: str = "\n", stream=sys.stdout) -> None:
     """Writes a string representation of the given arguments to the specified stream.
 
@@ -42,7 +42,7 @@ def sprint(*args, sep: str = " ", end: str = "\n", stream=sys.stdout) -> None:
     stream.write(sep.join(args) + end)
 
 
-@atomic
+@atomic  # type:ignore
 def aprint(*args, sep=" ", end="\n") -> None:
     """Prints a string representation of the given arguments to the console.
 
@@ -58,17 +58,18 @@ def aprint(*args, sep=" ", end="\n") -> None:
 
 
 class BetterPrinter:
-    def __init__(self, thread_safe: bool = False):
+    def __init__(self, stream: IO = sys.stdout, thread_safe: bool = False):
+        self.stream: IO = stream
         if thread_safe:
-            self.__call__ = atomic(self.__call__)
+            self.__call__ = atomic(self.__call__)  # type:ignore
         self._current_row: int = 0
         self.rows: list[str] = []
 
-    def clear(self, stream: IO = sys.stdout, flush: bool = True) -> None:
-        if not stream.isatty():
-            warning(f"Cannot clear because {stream} is not a terminal stream")
+    def clear(self, flush: bool = True) -> None:
+        if not self.stream.isatty():
+            warning(f"Cannot clear because {self.stream} is not a terminal stream")
             return
-        self.write("\033[2J", stream=stream, flush=flush)
+        self.write("\033[2J", flush=flush)
         self.rows.pop()
 
     def clear_line(self) -> None:
@@ -80,27 +81,29 @@ class BetterPrinter:
         self.rows.pop()
         self._current_row -= 1
 
-    def write(self, *args, sep: str = " ", end: str = "\n", stream: IO = sys.stdout, flush: bool = True):
+    def write(self, *args, sep: str = " ", end: str = "\n", flush: bool = True):
         text = sep.join(args) + end
         self._current_row += text.count("\n")
         self.rows.extend([f"{s}\n" for s in text.splitlines() if len(s) > 0])
-        stream.write(text)
+        self.stream.write(text)
         if flush:
-            stream.flush()
+            self.stream.flush()
 
-    def __call__(self, *args, **kwargs) -> None:
-        self.write(*args, **kwargs)
+    def __call__(self, *args, sep: str = " ", end: str = "\n", flush: bool = True) -> None:
+        self.write(*args, sep=sep, end=end, flush=flush)
 
     @property
     def current_row(self) -> int:
         return self._current_row
 
     def insert(self, text: str, row: int) -> None:
+        for _ in range(len(self.rows)):
+            bprint.move_up()
+            bprint.clear_line()
         self.rows.insert(row, text)
-        num_rows = len(self.rows)
-        self.clear()
-        self.write(*self.rows)
-        for _ in range(num_rows):
+        num = len(self.rows)
+        self.write(*self.rows, end="")
+        for _ in range(num):
             self.rows.pop()