danielutils 0.9.81__tar.gz → 0.9.83__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.81
+Version: 0.9.83
 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.81
+# danielutils v=0.9.83
 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.81 → danielutils-0.9.83}/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.81
+# danielutils v=0.9.83
 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.81 → danielutils-0.9.83}/danielutils/__init__.py

@@ -17,9 +17,8 @@ from .protocols import *
 
 from .reflection import *
 from .decorators import *
-
 # ========== NEEDS REFLECTION ==========
-from .tqdm_ import *
+from .progress_bar import *
 # ========== NEEDS DECORATORS ==========
 from .colors import *
 # ========== NEEDS BOTH ==========

danielutils-0.9.83/danielutils/context_managers/__init__.py

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

danielutils-0.9.83/danielutils/context_managers/attr_context.py

@@ -0,0 +1,25 @@
+class AttrContext:
+    def __init__(self, obj: object, attr: str, new_value: object, *, nonexistent_is_error: bool = True) -> None:
+        self.obj = obj
+        self.attr = attr
+        self.new_value = new_value
+        self.old_value = None
+        self._has_attr: bool = hasattr(self.obj, self.attr)
+        if nonexistent_is_error and not self._has_attr:
+            raise RuntimeError(f"Nonexistent attribute '{self.attr}' in '{self.obj}'")
+
+    def __enter__(self) -> 'AttrContext':
+        self.old_value = getattr(self.obj, self.attr, None)
+        setattr(self.obj, self.attr, self.new_value)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._has_attr:
+            setattr(self.obj, self.attr, self.old_value)
+        else:
+            delattr(self.obj, self.attr)
+
+
+__all__ = [
+    'AttrContext'
+]

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

@@ -1,11 +1,15 @@
 from ..io_ import file_exists, delete_file
+import atexit
 
 
 class TemporaryFile:
+    _instances: set['TemporaryFile'] = set()
+
     def __init__(self, path: str):
         if file_exists(path):
             raise RuntimeError(f"Can't create a temporary file if file '{path}' already exists.")
         self.path = path
+        TemporaryFile._instances.add(self)
 
     def __enter__(self):
         return self
@@ -13,10 +17,18 @@ 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]:
+        if not file_exists(self.path):
+            return []
         with open(self.path, 'r') as f:
             return f.readlines()
 

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

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

danielutils-0.9.83/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.81 → danielutils-0.9.83}/danielutils/math_/__init__.py

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

{danielutils-0.9.81 → danielutils-0.9.83}/danielutils/print_.py

@@ -1,7 +1,9 @@
 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:
@@ -21,7 +23,7 @@ def mprint(*args, sep: str = " ", end: str = "\n", stream=sys.stdout) -> 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)
+    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")
@@ -37,7 +39,7 @@ def sprint(*args, sep: str = " ", end: str = "\n", stream=sys.stdout) -> None:
     Returns:
         None
     """
-    stream.write(sep.join(args)+end)
+    stream.write(sep.join(args) + end)
 
 
 @atomic
@@ -55,25 +57,59 @@ def aprint(*args, sep=" ", end="\n") -> None:
     print(*args, sep=sep, end=end)
 
 
-@atomic
-def bprint(*args, sep=" ", end="\n", stream=sys.stdout) -> None:
-    """A function that writes a string representation of the given arguments to the specified stream.
+class BetterPrinter:
+    def __init__(self, thread_safe: bool = False):
+        if thread_safe:
+            self.__call__ = atomic(self.__call__)
+        self._current_row: int = 0
+        self.rows: list[str] = []
 
-    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.
+    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")
+            return
+        self.write("\033[2J", stream=stream, 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", stream: IO = sys.stdout, 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)
+        if flush:
+            stream.flush()
+
+    def __call__(self, *args, **kwargs) -> None:
+        self.write(*args, **kwargs)
+
+    @property
+    def current_row(self) -> int:
+        return self._current_row
+
+    def insert(self, text: str, row: int) -> None:
+        self.rows.insert(row, text)
+        num_rows = len(self.rows)
+        self.clear()
+        self.write(*self.rows)
+        for _ in range(num_rows):
+            self.rows.pop()
 
-    Returns:
-        None
-    """
-    stream.write(sep.join(args)+end)
 
+bprint = BetterPrinter()
 
 __all__ = [
     "sprint",
     "mprint",
     "aprint",
-    "bprint"
+    "bprint",
+    'BetterPrinter'
 ]

danielutils-0.9.83/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.83/danielutils/progress_bar/ascii_progress_bar.py

@@ -0,0 +1,104 @@
+import time
+from typing import Optional, Iterable, Sized
+
+from .progress_bar import ProgressBar
+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,
+            **kwargs
+    ):
+        self.iterable: Iterable = iterable
+        if isinstance(self.iterable, Sized):
+            total_ = len(self.iterable)
+        if total is not None:
+            total_ = total
+        ProgressBar.__init__(self, total_, position)
+        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(1)
+            yield v
+            bprint.move_up()
+            bprint.clear_line()
+        if self.position > 0:
+            self.reset()
+        else:
+            self.draw()
+
+    def draw(self) -> 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
+        )
+        bprint(to_print)
+
+    def update(self, amount: float = 1):
+        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()
+
+    def _write(self, *args: str, sep: str = " ", end: str = "\n") -> None:
+        bprint.move_up()
+        bprint.clear_line()
+        if not end.endswith("\n"):
+            end += "\n"
+        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()
+        self.num_writes = 0
+
+
+__all__ = [
+    'AsciiProgressBar'
+]

danielutils-0.9.83/danielutils/progress_bar/progress_bar.py

@@ -0,0 +1,54 @@
+import math
+import time
+from abc import ABC, abstractmethod
+from typing import Optional, Type, List, Iterable
+
+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.num_writes = 0
+
+    @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: str, 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
+
+    @abstractmethod
+    def reset(self) -> None:
+        """A function to reset the progress-bar's progress
+       """
+
+
+ProgressBar.register(tqdm)
+
+__all__ = [
+    'ProgressBar',
+]

danielutils-0.9.81/danielutils/tqdm_.py → danielutils-0.9.83/danielutils/progress_bar/progress_bar_pool.py

@@ -1,51 +1,46 @@
-from typing import Optional, List as List
-from .reflection import get_python_version
-
-if get_python_version() >= (3, 9):
-    from builtins import list as List  # type:ignore
-try:
-    from tqdm import tqdm
-except ImportError:
-    from .mock_ import MockImportObject
-
-    tqdm = MockImportObject("`tqdm` is not installed")  # type:ignore
+from typing import Type, List, Optional
+from .progress_bar import ProgressBar
 
 
 class ProgressBarPool:
-    """
-    My attempt at creating a progress bar pool using tqdm
-    """
-
-    def __init__(self, num_of_bars: int = 1, *, global_options: Optional[dict] = None,
-                 individual_options: Optional[List[Optional[dict]]] = None) -> None:
-        self.bars: List[tqdm] = []
+    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("")
+            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}"
-            t = tqdm(
+            final_options["desc"] = final_options["desc"].ljust(max_desc_length, " ")
+            t = pbar_class(
                 position=i,
                 **final_options
             )
             self.bars.append(t)
 
+    def __getitem__(self, index: int) -> ProgressBar:
+        return self.bars[index]
+
     def write(self, *args, sep=" ", end="\n") -> None:
-        """
-        prints texts to the console **while** using tqdm progress bars
-        """
         self.bars[0].write(sep.join((str(a) for a in args)), end=end)
 
 
 __all__ = [
-    "ProgressBarPool"
+    "ProgressBarPool",
 ]

danielutils-0.9.83/danielutils/system/layered_command.py

@@ -0,0 +1,118 @@
+import sys, os
+from typing import Optional
+from ..context_managers import TemporaryFile
+import random
+
+
+class LayeredCommand:
+    class_flush_stdout: bool = True
+    class_flush_stderr: bool = True
+    class_raise_on_fail: bool = True
+    class_verbose: bool = False
+    _class_prev_instance: Optional['LayeredCommand'] = None
+    _id: int = 0
+
+    @property
+    def prev(self):
+        return self._prev_instance
+
+    @prev.setter
+    def prev(self, value: Optional['LayeredCommand'] = None):
+        self._prev_instance = value
+
+    def __init__(
+            self,
+            command: Optional[str] = None,
+            *,
+            prev_instance: Optional['LayeredCommand'] = None,
+            instance_flush_stdout: Optional[bool] = None,
+            instance_flush_stderr: Optional[bool] = None,
+            instance_raise_on_fail: Optional[bool] = None,
+            instance_verbose: Optional[bool] = None
+    ):
+        self._command = command if command is not None else ""
+        self._instance_flush_stdout = instance_flush_stdout
+        self._instance_flush_stderr = instance_flush_stderr
+        self._instance_raise_on_fail = instance_raise_on_fail
+        self._instance_verbose = instance_verbose
+        self._prev_instance = prev_instance if prev_instance is not None else LayeredCommand._class_prev_instance
+        self._cur_class_prev_instance = LayeredCommand._class_prev_instance
+        LayeredCommand._class_prev_instance = self
+        self._executor = os.system
+        self._has_entered: bool = False
+
+    def __enter__(self):
+        self._open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.prev is self._cur_class_prev_instance:
+            LayeredCommand._class_prev_instance = self.prev
+
+    def _open(self) -> None:
+        self._has_entered = True
+
+    def _build_command(self, *commands: str) -> str:
+        res = ""
+        if self.prev is not None:
+            prev = self.prev._build_command()
+            res += f"{prev} & " if prev != "" else ""
+        if self._command != "":
+            return res + " & ".join([self._command, *commands])
+        return res + " & ".join(commands)
+
+    def _error(self, predicate: bool, command: str, code: int, command_verbose: Optional[bool]) -> None:
+        if predicate:
+            verbose = self._merge_values(command_verbose, self._instance_verbose, LayeredCommand.class_verbose)
+            if verbose:
+                raise RuntimeError(f"command '{command}' failed with exit code {code}")
+            sys.exit(1)
+
+    @staticmethod
+    def _merge_values(command: Optional[bool], instance: Optional[bool], class_: bool) -> bool:
+        return command if command is not None else (instance if instance is not None else class_)
+
+    def execute(
+            self,
+            *commands: str,
+            command_flush_stdout: Optional[bool] = None,
+            command_flush_stderr: Optional[bool] = None,
+            command_raise_on_fail: Optional[bool] = None,
+            command_verbose: Optional[bool] = None
+    ) -> 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:`")
+        flush_stdout = self._merge_values(command_flush_stdout, self._instance_flush_stdout, self.class_flush_stdout)
+        flush_stderr = self._merge_values(command_flush_stderr, self._instance_flush_stderr, self.class_flush_stderr)
+        raise_on_fail = self._merge_values(command_raise_on_fail, self._instance_raise_on_fail,
+                                           self.class_raise_on_fail)
+
+        command = self._build_command(*commands)
+        if flush_stdout and flush_stderr:
+            code = self._executor(command)
+            self._error(raise_on_fail and code != 0, command, code, command_verbose)
+            return code, [], []
+
+        letters = "abcdefghijklmnopqrstuvwxyz"
+        temp_name = "".join(random.choices(letters, k=50)) + f"_{LayeredCommand._id}"
+        stdout_path = f"./{temp_name}_stdout.log"
+        stderr_path = f"./{temp_name}_stderr.log"
+        LayeredCommand._id += 1
+        with TemporaryFile(stdout_path) as stdout:
+            with TemporaryFile(stderr_path) as stderr:
+                if not flush_stdout:
+                    command += f" > {stdout_path}"
+                if not flush_stderr:
+                    command += f" 2> {stderr_path}"
+                code = self._executor(command)
+                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]]:
+        return self.execute(*args, **kwargs)
+
+
+__all__ = [
+    'LayeredCommand'
+]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.81
+Version: 0.9.83
 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.81
+# danielutils v=0.9.83
 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.81 → danielutils-0.9.83}/danielutils.egg-info/SOURCES.txt

@@ -17,7 +17,6 @@ danielutils/print_.py
 danielutils/py.typed
 danielutils/text.py
 danielutils/time.py
-danielutils/tqdm_.py
 danielutils/versioned_imports.py
 danielutils.egg-info/PKG-INFO
 danielutils.egg-info/SOURCES.txt
@@ -43,6 +42,7 @@ danielutils/better_builtins/typed_builtins/tlist.py
 danielutils/better_builtins/typed_builtins/tset.py
 danielutils/better_builtins/typed_builtins/ttuple.py
 danielutils/context_managers/__init__.py
+danielutils/context_managers/attr_context.py
 danielutils/context_managers/temporary_file.py
 danielutils/conversions/__init__.py
 danielutils/conversions/main_conversions.py
@@ -96,6 +96,7 @@ danielutils/functions/flatten.py
 danielutils/functions/isoftype.py
 danielutils/functions/isoneof.py
 danielutils/functions/multiloop.py
+danielutils/functions/parallel_for.py
 danielutils/functions/powerset.py
 danielutils/functions/subseteq.py
 danielutils/functions/types_subseteq.py
@@ -108,8 +109,6 @@ danielutils/math_/constants.py
 danielutils/math_/functions.py
 danielutils/math_/math_print.py
 danielutils/math_/math_symbols.py
-danielutils/math_/polynomial/__init__.py
-danielutils/math_/polynomial/polinomial.py
 danielutils/metaclasses/__init__.py
 danielutils/metaclasses/atomic_class_meta.py
 danielutils/metaclasses/implicit_data_deleter_meta.py
@@ -119,6 +118,10 @@ danielutils/metaclasses/overload_meta.py
 danielutils/mock_/__init__.py
 danielutils/mock_/mock_database.py
 danielutils/mock_/mock_module.py
+danielutils/progress_bar/__init__.py
+danielutils/progress_bar/ascii_progress_bar.py
+danielutils/progress_bar/progress_bar.py
+danielutils/progress_bar/progress_bar_pool.py
 danielutils/protocols/__init__.py
 danielutils/protocols/dictable.py
 danielutils/protocols/evaluable.py