danielutils 0.9.82__tar.gz → 0.9.84__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.82
+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.82
+# 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.82 → 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.82
+# 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.82 → danielutils-0.9.84}/danielutils/__init__.py

@@ -17,13 +17,12 @@ from .protocols import *
 
 from .reflection import *
 from .decorators import *
-
 # ========== NEEDS REFLECTION ==========
-from .tqdm_ import *
 # ========== NEEDS DECORATORS ==========
 from .colors import *
 # ========== NEEDS BOTH ==========
 
+from .progress_bar import *
 from .functions import *
 from .io_ import *
 from .system import *
@@ -41,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.82 → 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.82 → 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.82 → danielutils-0.9.84}/danielutils/functions/__init__.py

@@ -7,3 +7,5 @@ from .powerset import *
 from .multiloop import *
 from .flatten import *
 from .subseteq 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.84/danielutils/functions/parallel_for.py

@@ -0,0 +1,37 @@
+import threading
+from typing import TypeVar, Callable
+
+T = TypeVar("T")
+Consumer = Callable[[T], None]
+
+
+def parallel_for(func: Consumer[T], *args: T, wait: bool = True) -> None:
+    """
+    This function will run 'func' in parallel with the given args individually
+    Args:
+        func: function to run in parallel
+        *args: args to call the function each time
+        wait: whether to wait for all the threads to join before returning
+
+    Returns:
+
+    """
+    # this is safer... What if some other threads that were running will also end in the meantime?
+    threads = [threading.Thread(target=func, args=[arg]) for arg in args]
+    for t in threads:
+        t.start()
+    if wait:
+        for t in threads:
+            t.join()
+    # before = threading.active_count()
+    # for arg in args:
+    #     threadify(func)(arg)
+    #
+    # if wait:
+    #     while threading.active_count() > before:
+    #         pass
+
+
+__all__ = [
+    'parallel_for'
+]

{danielutils-0.9.82 → danielutils-0.9.84}/danielutils/math_/__init__.py

@@ -1,3 +1,2 @@
 from .constants import *
 from .functions import *
-from .polynomial import *

danielutils-0.9.84/danielutils/print_.py

@@ -0,0 +1,118 @@
+import sys
+from typing import IO
+from .functions.areoneof import areoneof
+from .math_.math_print import mprint_parse_one
+from .decorators import atomic, deprecate
+from .colors import warning
+
+
+def mprint(*args, sep: str = " ", end: str = "\n", stream=sys.stdout) -> None:
+    """Prints a formatted representation of mathematical expressions to the specified stream.
+
+    Args:
+        *args: The mathematical expressions to print.
+        sep (str, optional): The separator to use between the expressions. Defaults to " ".
+        end (str, optional): The string to append to the end of the printed expressions. Defaults to "\n".
+        stream (file object, optional): The stream to write the output to. Defaults to sys.stdout.
+
+    Raises:
+        TypeError: If any of the arguments is not a string.
+
+    Returns:
+        None
+    """
+    if not areoneof(args, [str]):
+        raise TypeError("s must be a string")
+    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")  # 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.
+
+    Args:
+        *args: The arguments to print.
+        sep (str, optional): The separator to use between the arguments. Defaults to " ".
+        end (str, optional): The string to append to the end of the printed arguments. Defaults to "\n".
+        stream (file object, optional): The stream to write the output to. Defaults to sys.stdout.
+
+    Returns:
+        None
+    """
+    stream.write(sep.join(args) + end)
+
+
+@atomic  # type:ignore
+def aprint(*args, sep=" ", end="\n") -> None:
+    """Prints a string representation of the given arguments to the console.
+
+    Args:
+        *args: The arguments to print.
+        sep (str, optional): The separator to use between the arguments. Defaults to " ".
+        end (str, optional): The string to append to the end of the printed arguments. Defaults to "\n".
+
+    Returns:
+        None
+    """
+    print(*args, sep=sep, end=end)
+
+
+class BetterPrinter:
+    def __init__(self, stream: IO = sys.stdout, thread_safe: bool = False):
+        self.stream: IO = stream
+        if thread_safe:
+            self.__call__ = atomic(self.__call__)  # type:ignore
+        self._current_row: int = 0
+        self.rows: list[str] = []
+
+    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", flush=flush)
+        self.rows.pop()
+
+    def clear_line(self) -> None:
+        self.write("\033[2K", end="")
+        self.rows.pop()
+
+    def move_up(self, num_lines: int = 1) -> None:
+        self.write(f"\033[{num_lines}A", end="")
+        self.rows.pop()
+        self._current_row -= 1
+
+    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])
+        self.stream.write(text)
+        if flush:
+            self.stream.flush()
+
+    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 = len(self.rows)
+        self.write(*self.rows, end="")
+        for _ in range(num):
+            self.rows.pop()
+
+
+bprint = BetterPrinter()
+
+__all__ = [
+    "sprint",
+    "mprint",
+    "aprint",
+    "bprint",
+    'BetterPrinter'
+]

danielutils-0.9.84/danielutils/progress_bar/__init__.py

@@ -0,0 +1,3 @@
+from .progress_bar import *
+from .progress_bar_pool import *
+from .ascii_progress_bar import *

danielutils-0.9.84/danielutils/progress_bar/ascii_progress_bar.py

@@ -0,0 +1,141 @@
+import time
+from typing import Optional, Iterable, Sized
+
+from .progress_bar import ProgressBar
+from .progress_bar_pool import ProgressBarPool
+from ..print_ import bprint
+
+
+class AsciiProgressBar(ProgressBar):
+
+    def __init__(
+            self,
+            iterable: Iterable,
+            position: int,
+            *,
+            total: Optional[float] = None,
+            desc: str = "",
+            leave: bool = True,
+            num_bars: int = 1,
+            ncols: int = 50,
+            pool: Optional = None,
+            **kwargs
+    ):
+        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
+        self.initial_value: float = 0
+        self.current_value: float = 0
+        self.ncols: int = ncols
+        self.unit: str = "it"
+        self.pbar_format = "{l_bar} |{bar}| {n_fmt:.2f}/{total_fmt:.2f}{unit}" \
+                           " [{elapsed:.2f}<{remaining}, {rate_fmt:.2f}{unit}{postfix}]"
+        self.__dict__.update(kwargs)
+        self.initial_start_time = time.time()
+        self.prev_update: float = self.initial_start_time
+        self.delta: float = 0
+        self.prev_value: float = self.initial_value
+        self.bprint_row_index = bprint.current_row
+
+    def __iter__(self):
+        self.bprint_row_index = bprint.current_row
+        for v in self.iterable:
+            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, *, 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) * " "
+        to_print = self.pbar_format.format(
+            l_bar=self.desc,
+            bar=progress_str,
+            n_fmt=self.current_value,
+            total_fmt=self.total,
+            elapsed=self.prev_update - self.initial_start_time,
+            remaining="?",
+            rate_fmt=(self.current_value - self.prev_value) /
+                     self.delta if self.delta != 0 else 0,
+            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, 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(refresh=refresh)
+
+    def _write(self, *args: str, sep: str = " ", end: str = "\n") -> None:
+        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()
+
+    def reset(self) -> None:
+        self.current_value = self.initial_value
+        self.initial_start_time = time.time()
+        self.delta = 0
+        self.prev_value = self.initial_value
+        for _ in range(self.num_writes):
+            bprint.move_up()
+            bprint.clear_line()
+            bprint.rows.pop()
+        self.writes.clear()
+
+
+__all__ = [
+    'AsciiProgressBar'
+]

danielutils-0.9.84/danielutils/progress_bar/progress_bar.py

@@ -0,0 +1,64 @@
+import math
+import time
+from abc import ABC, abstractmethod
+from typing import Optional, Type, List, Iterable, Any
+
+try:
+    from tqdm import tqdm
+except ImportError:
+    from ..mock_ import MockImportObject
+
+    tqdm = MockImportObject("`tqdm` is not installed")  # type:ignore
+
+
+class ProgressBar(ABC):
+    """An interface
+
+    Args:
+        ABC (_type_): _description_
+    """
+    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:
+        self.total = total
+        self.position = position
+        self.unit = unit
+        self.bar_format = bar_format
+        self.writes: list[str] = []
+
+    @property
+    def num_writes(self):
+        return len(self.writes)
+
+    @abstractmethod
+    def update(self, amount: float = 1) -> None:
+        """A function to update the progress-bar's value by a positive relative amount
+        """
+
+    @abstractmethod
+    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
+        """
+        processed = list(map(str, args))
+        self._write(*processed, sep=sep, end=end)
+        self.writes.append(sep.join(processed) + end)
+
+    @abstractmethod
+    def reset(self) -> None:
+        """A function to reset the progress-bar's progress
+       """
+
+
+try:
+    from tqdm import tqdm
+
+    ProgressBar.register(tqdm)
+except ImportError:
+    pass
+
+__all__ = [
+    'ProgressBar',
+]

danielutils-0.9.84/danielutils/progress_bar/progress_bar_pool.py

@@ -0,0 +1,64 @@
+from typing import Type, List, Optional, Iterator
+from .progress_bar import ProgressBar
+from ..print_ import bprint
+
+
+class ProgressBarPool:
+    def __init__(
+            self,
+            pbar_class: Type[ProgressBar],
+            num_of_bars: int = 1,
+            global_options: Optional[dict] = None,
+            individual_options: Optional[List[Optional[dict]]] = None
+    ) -> None:
+        self.bars: List[ProgressBar] = []
+        if global_options is None:
+            global_options = {}
+        if individual_options is None:
+            individual_options = [{} for _ in range(num_of_bars)]
+        if len(individual_options) != num_of_bars:
+            raise ValueError(
+                "must supply the same number of options as there are bars")
+        for i in range(num_of_bars):
+            if individual_options[i] is None:
+                individual_options[i] = {}
+        max_desc_length: int = max([len(individual_options[i].get("desc", f"pbar {i}")) for i in range(num_of_bars)])
+        for i in range(num_of_bars):
+            final_options: dict = global_options.copy()
+            final_options.update(individual_options[i])  # type:ignore
+            if "desc" not in final_options:
+                final_options["desc"] = f"pbar {i}"
+            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, 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__ = [
+    "ProgressBarPool",
+]

danielutils-0.9.84/danielutils/protocols/__init__.py

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