danielutils 1.1.28__py3-none-any.whl

danielutils/metaclasses/overload_meta.py

@@ -0,0 +1,48 @@
+import logging
+import functools
+from typing import Callable
+from ..decorators import overload
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class OverloadMeta(type):
+    """A meta-class for overloading functions in a class
+    """
+
+    @staticmethod  # type:ignore
+    def overload(func: Callable) -> overload:
+        """overloads a function
+
+        Args:
+            func (Callable): function ot overload
+
+        Returns:
+            overload: _description_
+        """
+        return overload(func)  # type:ignore
+
+    def __new__(mcs, name, bases, namespace):
+        logger.info("Creating overload class: %s", name)
+        
+        def create_wrapper(v: overload):
+            @functools.wraps(next(iter(v._functions.values()))[0])  # type:ignore# pylint: disable=protected-access
+            def wrapper(*args, **kwargs):
+                return v(*args, **kwargs)
+
+            return wrapper
+
+        overloaded_functions = 0
+        for k, v in namespace.items():
+            if isinstance(v, overload):  # type:ignore
+                namespace[k] = create_wrapper(v)
+                overloaded_functions += 1
+
+        logger.info("OverloadMeta: %s created with %s overloaded functions", name, overloaded_functions)
+        return super().__new__(mcs, name, bases, namespace)
+
+
+__all__ = [
+    "OverloadMeta"
+]

danielutils/mock_/__init__.py

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

danielutils/mock_/mock_module.py

@@ -0,0 +1,27 @@
+import logging
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class MockImportObject:
+    """
+    A class to create a mock object that will raise an import error when you try to interact with it in some way
+    """
+
+    def __init__(self, msg: str):
+        logger.info("Initializing MockImportObject with message: %s", msg)
+        self._msg = msg
+
+    def __getattr__(self, item):
+        logger.warning("MockImportObject attribute access blocked: %s - %s", item, self._msg)
+        raise ImportError(self._msg)
+
+    def __call__(self, *args, **kwargs):
+        logger.warning("MockImportObject call blocked with %s args and %s kwargs - %s", len(args), len(kwargs), self._msg)
+        raise ImportError(self._msg)
+
+
+__all__ = [
+    "MockImportObject"
+]

danielutils/path.py

@@ -0,0 +1,55 @@
+import logging
+import os
+from .logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_current_working_directory() -> str:
+    """return the current working directory
+
+    Returns:
+        str: current working directory
+    """
+    return os.getcwd()
+
+
+def set_current_working_directory(path: str) -> None:
+    """sets the current working directory
+
+    Args:
+        path (str): directory to set to
+    """
+    os.chdir(path)
+
+
+def get_absolute_path(path: str) -> str:
+    """return the absolute path of given path
+
+    Args:
+        path (str): a path
+
+    Returns:
+        str: absolute version of that path
+    """
+    return os.path.abspath(path)
+
+
+def get_relative_path(path: str) -> str:
+    """return the relative path of given path
+
+    Args:
+        path (str): a path
+
+    Returns:
+        str: relative (to current working directory) version of that path
+    """
+    return os.path.realpath(path)
+
+
+__all__ = [
+    "get_current_working_directory",
+    "set_current_working_directory",
+    "get_absolute_path",
+    "get_relative_path"
+]

danielutils/print_.py

@@ -0,0 +1,123 @@
+import logging
+import sys
+from typing import IO, List
+from .functions.areoneof import areoneof
+from .math_.math_print import mprint_parse_one
+from .decorators import atomic, deprecate
+from .colors import warning
+from .logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+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")
+    logger.debug("Printing %d mathematical expressions to %s", len(args), stream)
+    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/progress_bar/__init__.py

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

danielutils/progress_bar/ascii_progress_bar.py

@@ -0,0 +1,161 @@
+import logging
+import time
+from typing import Optional, Iterable, Sized, Iterator
+
+from .progress_bar import ProgressBar
+from .progress_bar_pool import ProgressBarPool
+from ..print_ import bprint
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class AsciiProgressBar(ProgressBar):
+
+    def __init__(
+            self,
+            iterator: Iterator,
+            position: int,
+            *,
+            total: Optional[float] = None,
+            desc: str = "",
+            leave: bool = True,
+            num_bars: int = 1,
+            ncols: int = 50,
+            pool: Optional[ProgressBarPool] = None,
+            **kwargs
+    ):
+        total_ = 1
+        if isinstance(iterator, Sized):
+            total_ = len(iterator)
+        if total is not None:
+            total_ = total  # type:ignore
+        ProgressBar.__init__(self, total_, position, desc=desc)
+        self.iterator: Iterator = iterator
+        self.pool: ProgressBarPool = pool  # type:ignore
+        self.num_bars: int = num_bars
+        self.leave: bool = leave
+        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
+        logger.info("AsciiProgressBar initialized: %s (total=%s, position=%s)", desc, total_, position)
+
+    def __iter__(self):
+        logger.info("Starting iteration over AsciiProgressBar: %s", self.desc)
+        self.bprint_row_index = bprint.current_row
+        items_processed = 0
+        for v in self.iterator:
+            self.update(0)
+            yield v
+            bprint.move_up()
+            bprint.clear_line()
+            if len(bprint.rows) > 0:
+                bprint.rows.pop()
+            self.update(1)
+            items_processed += 1
+            bprint.move_up()
+            bprint.clear_line()
+            if len(bprint.rows) > 0:
+                bprint.rows.pop()
+        logger.info("Completed iteration: processed %s items", items_processed)
+        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:
+            i = bprint.rows.index(f"{self.prev_print}\n")  # type:ignore
+            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):  # type:ignore
+        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/progress_bar/progress_bar.py

@@ -0,0 +1,75 @@
+import logging
+import math
+import time
+from abc import ABC, abstractmethod
+from typing import Optional, Type, List, Iterable, Any
+from ..logging_.utils import get_logger
+
+try:
+    from tqdm import tqdm
+except ImportError:
+    from ..mock_ import MockImportObject
+
+    tqdm = MockImportObject("`tqdm` is not installed")  # type:ignore
+
+logger = get_logger(__name__)
+
+
+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, *, desc: str,
+                 **kwargs) -> None:
+        self.desc: str = desc
+        self.total = total
+        self.position = position
+        self.unit = unit
+        self.bar_format = bar_format
+        self.writes: List[str] = []
+        logger.info("ProgressBar initialized: %s (total=%s, position=%s, unit=%s)", desc, total, position, unit)
+
+    @property
+    def num_writes(self):
+        return len(self.writes)
+
+    @abstractmethod
+    def update(self, amount: float = 1, **kwargs) -> 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))
+        message = sep.join(processed) + end
+        self._write(*processed, sep=sep, end=end)
+        self.writes.append(message)
+
+    @abstractmethod
+    def reset(self) -> None:
+        """A function to reset the progress-bar's progress
+       """
+
+    @abstractmethod
+    def __iter__(self): ...
+
+
+try:
+    from tqdm import tqdm
+
+    ProgressBar.register(tqdm)
+except ImportError:
+    pass
+
+__all__ = [
+    'ProgressBar',
+]

danielutils/progress_bar/progress_bar_pool.py

@@ -0,0 +1,72 @@
+import logging
+from typing import Type, List, Optional, Iterator
+from .progress_bar import ProgressBar
+from ..print_ import bprint
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+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:
+        logger.info("Creating ProgressBarPool with %s bars using %s", num_of_bars, pbar_class.__name__)
+        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:
+            error_msg = "must supply the same number of options as there are bars"
+            logger.error("ProgressBarPool initialization failed: %s", error_msg)
+            raise ValueError(error_msg)
+        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] = []
+        logger.info("ProgressBarPool created successfully with %s progress bars", len(self.bars))
+
+    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/protocols/__init__.py

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

danielutils/protocols/dictable.py

@@ -0,0 +1,38 @@
+import logging
+from typing import Protocol, TypeVar, runtime_checkable,Dict as Dict
+from ..reflection import get_python_version
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+if get_python_version() >= (3, 9):
+    from builtins import dict as Dict
+
+K = TypeVar('K')
+V = TypeVar('V')
+
+@runtime_checkable
+class Dictable(Protocol[K, V]):
+    @classmethod
+    def from_dict(cls, d: Dict[K, V]) -> 'Dictable[K,V]':
+        """
+        Create a Dictable object from a dictionary.
+        
+        Note: This is a protocol method. Implementations should add logging
+        to track dictionary conversion operations.
+        """
+        ...
+
+    def to_dict(self) -> Dict[K, V]:
+        """
+        Convert the object to a dictionary.
+        
+        Note: This is a protocol method. Implementations should add logging
+        to track dictionary conversion operations.
+        """
+        ...
+
+
+__all__ = [
+    'Dictable'
+]

danielutils/protocols/evaluable.py

@@ -0,0 +1,26 @@
+import logging
+from abc import abstractmethod
+from typing import Protocol, TypeVar, runtime_checkable
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+T = TypeVar('T', covariant=True)
+
+
+@runtime_checkable
+class Evaluable(Protocol[T]):
+    @abstractmethod
+    def evaluate(self) -> T:
+        """
+        Evaluate the object and return a value of type T.
+        
+        Note: This is a protocol method. Implementations should add logging
+        to track evaluation operations.
+        """
+        ...
+
+
+__all__ = [
+    "Evaluable"
+]

danielutils/protocols/serializable.py

@@ -0,0 +1,51 @@
+import logging
+from typing import Protocol, runtime_checkable, Any
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+@runtime_checkable
+class Serializable(Protocol):
+    def serialize(self) -> bytes:
+        """
+        Serialize the object to bytes.
+        
+        Note: This is a protocol method. Implementations should add logging
+        to track serialization operations.
+        """
+        ...
+
+    def deserialize(self, serealized: bytes) -> 'Serializable':
+        """
+        Deserialize bytes back to a Serializable object.
+        
+        Note: This is a protocol method. Implementations should add logging
+        to track deserialization operations.
+        """
+        ...
+
+
+def serialize(obj: Any) -> bytes:
+    logger.info("Serializing object of type: %s", type(obj).__name__)
+    if isinstance(obj, Serializable):
+        result = obj.serialize()
+        logger.info("Serialization successful, returned %s bytes", len(result))
+        return result
+    logger.warning("Object %s does not implement Serializable protocol", type(obj).__name__)
+    #TODO
+    return b""
+
+
+def deserialize(obj: bytes) -> Any:
+    logger.info("Deserializing %s bytes", len(obj))
+    logger.warning("Deserialize function not implemented (TODO)")
+    #TODO
+    return None
+
+
+__all__ = [
+    'Serializable',
+    'serialize',
+    'deserialize',
+]