danielutils 0.9.83__tar.gz → 0.9.84__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.83
+Version: 0.9.84
 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.84}/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.84}/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.84/danielutils/context_managers/__init__.py

@@ -0,0 +1,3 @@
+from .temporary_file import *
+from .attr_context import *
+from .multi_context import *

{danielutils-0.9.83 → danielutils-0.9.84}/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.84/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.84/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.84}/danielutils/context_managers/temporary_file.py

@@ -1,8 +1,9 @@
+from typing import ContextManager
 from ..io_ import file_exists, delete_file
 import atexit
 
 
-class TemporaryFile:
+class TemporaryFile(ContextManager):
     _instances: set['TemporaryFile'] = set()
 
     def __init__(self, path: str):

danielutils-0.9.84/danielutils/custom_types.py

@@ -0,0 +1,17 @@
+from typing import TypeAlias, Callable, TypeVar, Generic
+
+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.84/danielutils/file_specifications/__init__.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass
+from typing import Optional
+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]):
+        """
+
+        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.84}/danielutils/functions/__init__.py

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

danielutils-0.9.84/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.83 → danielutils-0.9.84}/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()
 
 

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

@@ -2,6 +2,7 @@ import time
 from typing import Optional, Iterable, Sized
 
 from .progress_bar import ProgressBar
+from .progress_bar_pool import ProgressBarPool
 from ..print_ import bprint
 
 
@@ -17,14 +18,17 @@ class AsciiProgressBar(ProgressBar):
             leave: bool = True,
             num_bars: int = 1,
             ncols: int = 50,
+            pool: Optional = None,
             **kwargs
     ):
-        self.iterable: Iterable = iterable
-        if isinstance(self.iterable, Sized):
-            total_ = len(self.iterable)
+        total_ = 1
+        if isinstance(iterable, Sized):
+            total_ = len(iterable)
         if total is not None:
             total_ = total
         ProgressBar.__init__(self, total_, position)
+        self.iterable: Iterable = iterable
+        self.pool: ProgressBarPool = pool
         self.num_bars: int = num_bars
         self.leave: bool = leave
         self.desc: str = desc
@@ -44,16 +48,21 @@ class AsciiProgressBar(ProgressBar):
     def __iter__(self):
         self.bprint_row_index = bprint.current_row
         for v in self.iterable:
-            self.update(1)
+            self.update(0)
             yield v
             bprint.move_up()
             bprint.clear_line()
+            bprint.rows.pop()
+            self.update(1)
+            bprint.move_up()
+            bprint.clear_line()
+            bprint.rows.pop()
         if self.position > 0:
             self.reset()
         else:
             self.draw()
 
-    def draw(self) -> None:
+    def draw(self, *, refresh: bool = False) -> None:
         percent = self.current_value / self.total
         num_to_fill = int(percent * self.ncols)
         progress_str = num_to_fill * "#" + (self.ncols - num_to_fill) * " "
@@ -69,22 +78,49 @@ class AsciiProgressBar(ProgressBar):
             postfix="/s",
             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)
 
-    def update(self, amount: float = 1):
+    def update(self, amount: float = 1, refresh: bool = False):
         self.prev_value = self.current_value
         self.current_value = min(
             self.current_value + amount, self.total)  # type:ignore
         current_time = time.time()
         self.delta = current_time - self.prev_update
         self.prev_update = current_time
-        self.draw()
+        self.draw(refresh=refresh)
 
     def _write(self, *args: str, sep: str = " ", end: str = "\n") -> None:
-        bprint.move_up()
-        bprint.clear_line()
         if not end.endswith("\n"):
             end += "\n"
+        if self.pool is not None and len(self.pool.bars) > 0:
+            succeeding_bars = self.pool.bars[self.position + 1:]
+            if succeeding_bars:
+                for succeeding_bar in succeeding_bars:
+                    # clear child
+                    bprint.move_up()
+                    bprint.clear_line()
+                    bprint.rows.pop()
+                    for _ in range(succeeding_bar.num_writes):
+                        # clear child's writes
+                        bprint.move_up()
+                        bprint.clear_line()
+                        bprint.rows.pop()
+                # clear self
+                bprint.move_up()
+                bprint.clear_line()
+                bprint.rows.pop()
+                bprint(sep.join(map(str, args)), end=end)
+                self.draw()
+                for succeeding_bar in succeeding_bars:
+                    succeeding_bar.update(0, refresh=True)
+                return
+
+        bprint.move_up()
+        bprint.clear_line()
+        bprint.rows.pop()
         bprint(sep.join(map(str, args)), end=end)
         self.draw()
 
@@ -96,7 +132,8 @@ class AsciiProgressBar(ProgressBar):
         for _ in range(self.num_writes):
             bprint.move_up()
             bprint.clear_line()
-        self.num_writes = 0
+            bprint.rows.pop()
+        self.writes.clear()
 
 
 __all__ = [

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

@@ -1,7 +1,7 @@
 import math
 import time
 from abc import ABC, abstractmethod
-from typing import Optional, Type, List, Iterable
+from typing import Optional, Type, List, Iterable, Any
 
 try:
     from tqdm import tqdm
@@ -25,7 +25,11 @@ class ProgressBar(ABC):
         self.position = position
         self.unit = unit
         self.bar_format = bar_format
-        self.num_writes = 0
+        self.writes: list[str] = []
+
+    @property
+    def num_writes(self):
+        return len(self.writes)
 
     @abstractmethod
     def update(self, amount: float = 1) -> None:
@@ -35,11 +39,12 @@ class ProgressBar(ABC):
     @abstractmethod
     def _write(self, *args: str, sep: str = " ", end: str = "\n") -> None: ...
 
-    def write(self, *args: str, sep: str = " ", end: str = "\n") -> None:
+    def write(self, *args: Any, sep: str = " ", end: str = "\n") -> None:
         """A function to write additional text with the progress bar
         """
-        self._write(*args, sep=sep, end=end)
-        self.num_writes += 1
+        processed = list(map(str, args))
+        self._write(*processed, sep=sep, end=end)
+        self.writes.append(sep.join(processed) + end)
 
     @abstractmethod
     def reset(self) -> None:
@@ -47,7 +52,12 @@ class ProgressBar(ABC):
        """
 
 
-ProgressBar.register(tqdm)
+try:
+    from tqdm import tqdm
+
+    ProgressBar.register(tqdm)
+except ImportError:
+    pass
 
 __all__ = [
     'ProgressBar',

{danielutils-0.9.83 → danielutils-0.9.84}/danielutils/progress_bar/progress_bar_pool.py

@@ -1,5 +1,6 @@
-from typing import Type, List, Optional
+from typing import Type, List, Optional, Iterator
 from .progress_bar import ProgressBar
+from ..print_ import bprint
 
 
 class ProgressBarPool:
@@ -30,15 +31,32 @@ class ProgressBarPool:
             final_options["desc"] = final_options["desc"].ljust(max_desc_length, " ")
             t = pbar_class(
                 position=i,
+                pool=self,
                 **final_options
             )
             self.bars.append(t)
+        self.writes: list[str] = []
 
     def __getitem__(self, index: int) -> ProgressBar:
         return self.bars[index]
 
-    def write(self, *args, sep=" ", end="\n") -> None:
-        self.bars[0].write(sep.join((str(a) for a in args)), end=end)
+    def write(self, msg: str, end: str = "\n") -> None:
+        prev_rows = bprint.rows.copy()
+        for w in self.writes:
+            prev_rows.remove(w)
+        self.writes.append(msg + end)
+        rows = self.writes.copy() + prev_rows
+        for _ in bprint.rows:
+            bprint.move_up()
+            bprint.clear_line()
+        bprint.rows.clear()
+
+        for row in rows:
+            bprint(row, end="")
+        pass
+
+    def __iter__(self) -> Iterator[ProgressBar]:
+        return iter(self.bars)
 
 
 __all__ = [

danielutils-0.9.84/danielutils/protocols/__init__.py

@@ -0,0 +1,3 @@
+from .evaluable import *
+from .dictable import *
+from .serializable import *

danielutils-0.9.84/danielutils/protocols/serializable.py

@@ -0,0 +1,28 @@
+from typing import Protocol, runtime_checkable, Any
+
+
+@runtime_checkable
+class Serializable(Protocol):
+    def serialize(self) -> bytes: ...
+
+    def deserialize(self, serealized: bytes) -> 'Serializable': ...
+
+
+def serialize(obj: Any) -> bytes:
+    if isinstance(obj, Serializable):
+        return obj.serialize()
+
+    pass
+
+
+def deserialize(obj: bytes) -> Any:
+    if isinstance(obj, Serializable):
+        return obj.deserialize()
+    pass
+
+
+__all__ = [
+    'Serializable',
+    'serialize',
+    'deserialize',
+]

danielutils-0.9.84/danielutils/university/__init__.py

@@ -0,0 +1,7 @@
+from .databases import *
+from .probability import *
+from .oop import *
+from .image_proccesing import *
+from .linear_algebra import *
+from .machine_learning import *
+from .computability_and_complexity import *

danielutils-0.9.84/danielutils/university/computability_and_complexity/__init__.py

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

danielutils-0.9.84/danielutils/university/computability_and_complexity/discreate_finite_automaton.py

@@ -0,0 +1,68 @@
+import random
+from typing import Set, Callable, Sequence, Collection, Tuple, Dict, TypeVar, Generic
+
+State = TypeVar('State')
+Symbol = TypeVar('Symbol')
+Alphabet = Collection[Symbol]
+TransitionFunction = Callable[[State, Symbol], State]
+
+
+class DiscreteFiniteAutomaton(Generic[State, Symbol]):
+    def __init__(self, Q: Collection[State], sigma: Alphabet, delta: TransitionFunction, q0: State,
+                 F: Collection[State]):
+        """
+
+        Args:
+            Q: set of possible states
+            sigma: the alphabet
+            delta: the transition function
+            q0: the initial state
+            F: the accept states
+        """
+        self.Q: Set[State] = set(Q)
+        self.sigma: Sequence[Symbol] = list(sigma)
+        self.delta: TransitionFunction = delta
+        self.q0: State = q0
+        self.F: Set[State] = set(F)
+        self._verify()
+
+    def process(self, word: Sequence[Symbol]) -> State:
+        cur = self.q0
+        for letter in word:
+            cur = self.delta(cur, letter)
+        return cur
+
+    def run(self, word: Sequence[Symbol]) -> bool:
+        return self.process(word) in self.F
+
+    def __call__(self, word: Sequence[Symbol]) -> bool:
+        return self.run(word)
+
+    def _verify(self) -> None:
+        for letter in self.sigma:
+            for state in self.Q:
+                try:
+                    res = self.delta(state, letter)
+                except Exception as e:
+                    raise ValueError(f'delta({state}, {letter}) raised an exception') from e
+                if not res in self.Q:
+                    raise ValueError(f'delta({state}, {letter}) = {state} which is not in F = {self.Q}')
+
+    def random_word(self, k: int) -> Sequence[Symbol]:
+        return tuple(random.choices(self.sigma, k=k))
+
+    @staticmethod
+    def delta_from_dict(dct: Dict[Tuple[State, Symbol], State]) -> TransitionFunction:
+        return lambda state, letter: dct[(state, letter)]
+
+
+DFA = DiscreteFiniteAutomaton
+
+__all__ = [
+    "State",
+    "Symbol",
+    "Alphabet",
+    "TransitionFunction",
+    "DiscreteFiniteAutomaton",
+    "DFA"
+]

danielutils-0.9.84/danielutils/university/image_proccesing/__init__.py

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

danielutils-0.9.84/danielutils/university/image_proccesing/encoding/__init__.py

@@ -0,0 +1,3 @@
+from .encoding import *
+from .lossy import *
+from .lossless import *

danielutils-0.9.84/danielutils/university/image_proccesing/encoding/encoding.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Iterable, Generator, Union
+
+Encodeable = Union[bytes, Iterable[bytes]]
+Decodeable = Encodeable
+
+
+class Encoding(ABC):
+    class EncodingType(Enum):
+        LOSSY = "LOSSY"
+        LOSSLESS = "LOSSLESS"
+
+    encoding_type: EncodingType
+
+    @staticmethod
+    @abstractmethod
+    def encode_online(obj: Encodeable) -> Generator[bytes, None, None]: ...
+
+    @staticmethod
+    @abstractmethod
+    def encode_offline(obj: Encodeable) -> bytes: ...
+
+    @staticmethod
+    @abstractmethod
+    def decode_online(obj: Decodeable) -> Generator[bytes, None, None]: ...
+
+    @staticmethod
+    @abstractmethod
+    def decode_offline(obj: Decodeable) -> bytes: ...
+
+
+__all__ = [
+    'Encoding'
+]