danielutils 0.9.84__tar.gz → 0.9.90__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.84
+Version: 0.9.90
 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.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.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.84 → danielutils-0.9.90}/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.90}/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.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.84 → 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.84 → 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.84 → 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.84 → 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.84 → danielutils-0.9.90}/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.90}/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.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/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.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.84 → danielutils-0.9.90}/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,16 +18,16 @@ 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
+        self.iterator: Iterator = iterator
         self.pool: ProgressBarPool = pool
         self.num_bars: int = num_bars
         self.leave: bool = leave
@@ -47,16 +47,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,9 +81,19 @@ 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):
         self.prev_value = self.current_value

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

@@ -32,7 +32,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
         """
 

{danielutils-0.9.84 → danielutils-0.9.90}/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.84 → danielutils-0.9.90}/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.84 → danielutils-0.9.90}/danielutils/university/computability_and_complexity/__init__.py

@@ -1 +1,2 @@
 from .discreate_finite_automaton import *
+from .turing_machine import *

{danielutils-0.9.84 → danielutils-0.9.90}/danielutils/university/computability_and_complexity/discreate_finite_automaton.py

@@ -51,6 +51,27 @@ class DiscreteFiniteAutomaton(Generic[State, Symbol]):
     def random_word(self, k: int) -> Sequence[Symbol]:
         return tuple(random.choices(self.sigma, k=k))
 
+    def is_described_by(self, language_indicator: Callable[[Sequence[Symbol]], bool], max_word_length: int = 100,
+                        num_repeats_for_length: int = 1000) -> bool:
+        """
+        This function will randomly generate work of all lengths up to k and will check whether this DFA acceptance
+         of the word is the same as the result of a function that describes the behaviour of the language
+        Args:
+            language_indicator: An indicator function to check if a word is a member of a language
+            max_word_length: the maximum length of a word to check
+            num_repeats_for_length: how many times to repeat the check of any one length (as the words are randomly generated)
+
+        Returns:
+            A boolean result
+        """
+        for k in range(max_word_length):
+            for _ in range(num_repeats_for_length):
+                word = self.random_word(k)
+                if not (self.run(word) == language_indicator(word)):
+                    return False
+
+        return True
+
     @staticmethod
     def delta_from_dict(dct: Dict[Tuple[State, Symbol], State]) -> TransitionFunction:
         return lambda state, letter: dct[(state, letter)]

danielutils-0.9.90/danielutils/university/computability_and_complexity/languages/language.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import Protocol
+
+
+class LanguageItem(Protocol): ...
+
+
+class Language(ABC):
+
+    @abstractmethod
+    def __contains__(self, item: LanguageItem) -> bool: ...
+
+
+__all__ = [
+    "Language",
+    "LanguageItem"
+]

danielutils-0.9.90/danielutils/university/computability_and_complexity/languages/sat.py

@@ -0,0 +1,69 @@
+from typing import List, TypeVar
+
+from .language import Language
+
+CNFVariable_id_type = TypeVar('CNFVariable_id_type', bound=int)
+
+
+class CNFVariable:
+    __ID: int = 0
+
+    def __init__(self, value: bool):
+        self.value = value
+        self.id = CNFVariable.__ID
+        CNFVariable.__ID += 1
+
+    def __bool__(self):
+        return self.value
+
+    def get_id(self) -> CNFVariable_id_type:
+        pass
+
+
+class CNFLiteral:
+    def __init__(self, negation: bool):
+        self.negation = negation
+
+    def __call__(self, var: CNFVariable) -> bool:
+        return not bool(var) if self.negation else bool(var)
+
+    def get_corresponding_variable_id(self) -> CNFVariable_id_type:
+        pass
+
+
+class CNFClause:
+    def __bool__(self, literals: List[CNFLiteral] = None) -> None:
+        self.literals = literals or []
+
+    def add_literal(self, literal: CNFLiteral):
+        self.literals.append(literal)
+
+    def evaluate(self, variables: List[CNFVariable]) -> bool:
+        dct = {v.get_id(): v for v in variables}
+
+        for literal in self.literals:
+            if not literal.get_corresponding_variable_id() in dct.keys():
+                return False
+            if not literal(dct[literal.get_corresponding_variable_id()]):
+                return False
+        return True
+
+    def __len__(self) -> int:
+        return len(self.literals)
+
+
+class CNFFormula:
+    def __init__(self, clauses: List[CNFClause] = None) -> None:
+        self.clauses = clauses or []
+
+    def add_clause(self, clause: CNFClause) -> None:
+        self.clauses.append(clause)
+
+    def evaluate(self, variables: List[CNFVariable]) -> bool:
+        for clause in self.clauses:
+            if not clause.evaluate(variables):
+                return False
+        return True
+
+
+class SAT(Language): ...

danielutils-0.9.90/danielutils/university/computability_and_complexity/turing_machine.py

@@ -0,0 +1,47 @@
+from typing import TypeVar, Collection, Callable, Set, List, Sequence, Tuple, Union, Literal
+
+State = TypeVar('State')
+Symbol = TypeVar('Symbol')
+Alphabet = Collection[Symbol]
+Direction = Union[Literal["L"], Literal["R"]]
+TransitionFunction = Callable[[State, Symbol], Tuple[State, Symbol, Direction]]
+
+
+class TuringMachine:
+    def __init__(self, Q: Collection[State], Gamma: Alphabet, Sigma: Alphabet, delta: TransitionFunction, q0: State,
+                 F_acc: Collection[State], F_rej: Collection[State]) -> None:
+        self.Q: Set[State] = set(Q)
+        self.Gamma: List[State] = list(Gamma)
+        self.Sigma: List[State] = list(Sigma)
+        self.delta: TransitionFunction = delta
+        self.q0: State = q0
+        self.F_acc: Set[State] = set(F_acc)
+        self.F_rej: Set[State] = set(F_rej)
+        self.tape: List[Symbol] = []
+        self.head: int = 0
+
+    def _should_stop(self, cur_state: State) -> bool:
+        return cur_state in self.F_acc or cur_state in self.F_rej
+
+    def process(self, word: Sequence[Symbol]) -> State:
+        for letter in word:
+            self.tape.append(letter)
+        cur = self.q0
+        while not self._should_stop(cur):
+            state, symbol, direction = self.delta(cur, self.tape[self.head])
+            cur = state
+            self.tape[self.head] = symbol
+            self.head += 1 if direction == "R" else -1
+
+        return cur
+
+    def run(self, word: Sequence[Symbol]) -> bool:
+        return self.process(word) in self.F_acc
+
+    def __call__(self, word: Sequence[Symbol]) -> bool:
+        return self.run(word)
+
+
+__all__ = [
+    'TuringMachine'
+]

{danielutils-0.9.84 → danielutils-0.9.90}/danielutils/university/databases/all.py

@@ -417,9 +417,9 @@ class Relation:
         """
         # week 9 page 1 slide 3
         K: Attribute = self.find_key(F)
-        KeyQueue = Queue()
+        KeyQueue: Queue = Queue()
         KeyQueue.push(K)
-        Keys = set([K])
+        Keys: Set[Attribute] = set([K])
         while not KeyQueue.is_empty():
             K = KeyQueue.pop()
             for X, Y in F.tuples():

{danielutils-0.9.84 → danielutils-0.9.90}/danielutils/university/image_proccesing/encoding/lossless/run_length.py

@@ -1,4 +1,4 @@
-from typing import Generator, Sequence
+from typing import Generator, Sequence, List
 from .lossless_encoding import LosslessEncoding
 from ..encoding import Decodeable, Encodeable
 
@@ -6,7 +6,7 @@ from ..encoding import Decodeable, Encodeable
 class RunLengthEncoding(LosslessEncoding):
     @staticmethod
     def encode_online(obj: Encodeable) -> Generator[bytes, None, None]:
-        buffer: list[int] = []
+        buffer: List[int] = []
         for c in obj:
             if len(buffer) > 0:
                 if c != buffer[0]:
@@ -17,6 +17,7 @@ class RunLengthEncoding(LosslessEncoding):
 
     @staticmethod
     def decode_online(obj: Decodeable) -> Generator[bytes, None, None]:
+        # TODO
         pass
 
     SEPERATOR = b","