danielutils 0.9.73__tar.gz → 0.9.76__tar.gz

danielutils-0.9.76/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include danielutils *.py

{danielutils-0.9.73 → danielutils-0.9.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.73
+Version: 0.9.76
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
 Project-URL: Homepage, https://github.com/danielnachumdev/danielutils
 Project-URL: Bug Tracker, https://github.com/danielnachumdev/danielutils/issues
-Keywords: functions,decorators,methods,classes,metaclasses
+Keywords: functions,decorators,methods,better_builtins,metaclasses
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -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.68
+# danielutils v=0.9.75
 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.73 → danielutils-0.9.76}/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.68
+# danielutils v=0.9.75
 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.73 → danielutils-0.9.76}/danielutils/__init__.py

@@ -6,14 +6,11 @@
 # =================================================================
 from .path import *
 from .date_time import *
-from .multi_x import *
-from .loops import *
-from .signals import *
 from .aliases import *
 from .exceptions import PrintCatchOne
 from .snippets import *
 from .abstractions import *
-from .imports import *
+from .protocols import *
 # =================================================================
 # ========================= ORDER MATTERS =========================
 # =================================================================
@@ -22,25 +19,24 @@ from .reflection import *
 from .decorators import *
 
 # ========== NEEDS REFLECTION ==========
-from .threads import *
-from .my_tqdm import *
+from .tqdm_ import *
 # ========== NEEDS DECORATORS ==========
 from .colors import *
 # ========== NEEDS BOTH ==========
 
 from .functions import *
-from .files_and_folders import *
+from .io_ import *
 from .system import *
 from .text import *
 from .conversions import *
-from .classes import *
+from .better_builtins import *
 from .time import *
 from .date import *
 from .data_structures import *
-from .math import *
+from .math_ import *
 from .system import *
-from .d_print import *
+from .print_ import *
 from .metaclasses import *
 from .generators import *
 from .university import *
-from .package_utils import *
+from .mock_ import *

danielutils-0.9.76/danielutils/abstractions/__init__.py

@@ -0,0 +1,3 @@
+from .database import *
+from .repl import *
+from .multiprogramming import *

danielutils-0.9.76/danielutils/abstractions/database/__init__.py

@@ -0,0 +1,2 @@
+from .database import *
+from .cached_database import *

danielutils-0.9.76/danielutils/abstractions/database/cached_database.py

@@ -0,0 +1,75 @@
+from typing import Any, TypeVar, Optional
+
+from .database import Database
+
+K = TypeVar('K')
+V = TypeVar('V')
+
+class CachedDatabase(Database[K, V]):
+    """
+    A database that is composed of two types of databases.
+    Args:
+        primary (Database): is intended to be the "real" database which is usually slower than the `cache`
+        cache (Database): is intended to be a cache layer over `primary` which will be faster when reading
+        *
+        notify_primary (bool): if a single Database instance is as `primary` for multiple CachedDatabase and the
+            current CachedDatabase instance 'set' method is used, it will also update the cache on different
+            CachedDatabase instances. Defaults to False
+        notify_cache (bool): same as `notify_primary` but will update other primaries on different
+            CachedDatabase instances
+    Returns:
+        None
+    """
+
+    def _on_notify(self, updater: 'Database', obj: Any) -> None:
+        key, value = obj
+        if self._cache is not updater:
+            if not self._cache == updater:
+                self._cache.set(key, value)
+
+        if self._primary is not updater:
+            if not self._primary == updater:
+                self._primary.set(key, value)
+
+    def __init__(self, primary: Database, cache: Database, *, notify_primary: bool = False, notify_cache: bool = False):
+        super().__init__()
+        primary._register_subscriber(self)
+        cache._register_subscriber(self)
+        self._primary = primary
+        self._cache = cache
+        self._notify_primary = notify_primary
+        self._notify_cache = notify_cache
+
+    def get(self, key: K, default: Any = Database.DEFAULT) -> Optional[V]:
+        res = self._cache.get(key, default)
+        if res is not default:
+            return res
+        res = self._primary.get(key, default)
+        if res is not default:
+            self._cache.set(key, res)
+        return res
+
+    def set(self, key: K, value: V) -> None:
+        self._cache.set(key, value)
+        if self._notify_cache:
+            self._cache._notify_subscribers((key, value))  # pylint: disable=protected-access
+        self._primary.set(key, value)
+        if self._notify_primary:
+            self._primary._notify_subscribers((key, value))  # pylint: disable=protected-access
+
+    def delete(self, key: K) -> None:
+        self._cache.delete(key)
+        self._primary.delete(key)
+
+    def contains(self, key: K) -> bool:
+        if self._cache.contains(key):
+            return True
+        if (res := self.get(key)) is not Database.DEFAULT:
+            self._cache.set(key, res)
+            return True
+        return False
+
+
+__all__ = [
+    "CachedDatabase"
+]

danielutils-0.9.76/danielutils/abstractions/database/database.py

@@ -0,0 +1,104 @@
+from abc import ABC, abstractmethod
+from typing import Any, TypeVar, Generic, Optional
+
+K = TypeVar('K')
+V = TypeVar('V')
+
+
+class Database(ABC, Generic[K, V]):
+    """
+    Abstract base class for database objects.
+    """
+    DEFAULT = None
+
+    def __init__(self) -> None:
+        self._subscribers: set[Database] = set()
+
+    def _register_subscriber(self, subscriber: 'Database') -> None:
+        self._subscribers.add(subscriber)
+
+    def _notify_subscribers(self, obj: Any) -> None:
+        for subscriber in self._subscribers:
+            subscriber._notify(self, obj)  # pylint: disable=protected-access
+
+    def _notify(self, updater: 'Database', obj: Any) -> None:
+        """
+        Notify all subscribers of an object.
+        Args:
+            updater: the object calling this method.
+            obj: the event to notify.
+
+        Returns:
+            None
+        """
+        self._on_notify(updater, obj)
+
+    @abstractmethod
+    def _on_notify(self, updater: 'Database', obj: Any) -> None:
+        ...
+
+    @abstractmethod
+    def get(self, key: K, default: Any = DEFAULT) -> Optional[V]:
+        """
+        Get a value from the database by key.
+        Args:
+            key (K): The key to get the value from.:
+            default (Any): The default value to return if the key is not found. Defaults to Database.DEFAULT.
+
+        Returns:
+            Optional[V]
+        """
+
+    @abstractmethod
+    def set(self, key: K, value: V) -> None:
+        """
+        Set a value in the database.
+        Args:
+            key (K): The key to set.
+            value (V): The value to set.
+
+        Returns:
+            None
+        """
+
+    @abstractmethod
+    def delete(self, key: K) -> None:
+        """
+        Delete an item from the database.
+        Args:
+            key (K): The key to delete.:
+
+        Returns:
+            None
+        """
+
+    @abstractmethod
+    def contains(self, key: K) -> bool:
+        """
+        Check if a key is contained in this database.
+        Args:
+            key (K): Key to be checked.:
+
+        Returns:
+            bool
+        """
+
+    def __getitem__(self, key: K) -> V:
+        res = self.get(key)
+        if res is Database.DEFAULT:
+            raise KeyError(key)
+        return res
+
+    def __setitem__(self, key: K, value: V) -> None:
+        self.set(key, value)
+
+    def __delitem__(self, key: K) -> None:
+        self.delete(key)
+
+    def __contains__(self, key: K) -> bool:
+        return self.contains(key)
+
+
+__all__ = [
+    "Database",
+]

danielutils-0.9.76/danielutils/abstractions/database/redis_database.py

@@ -0,0 +1,44 @@
+from typing import Any, Optional, TypeVar
+
+try:
+    import redis
+except ImportError:
+    from mock_ import MockImportObject
+
+    redis = MockImportObject("`redis` is not installed")
+from abstractions.database.database import Database
+
+K = TypeVar('K')
+V = TypeVar('V')
+
+
+class RedisDatabase(Database[K, V]):
+    """
+    An implementation of the `Database` interface using Redis.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._db = redis.StrictRedis(host='localhost', port=6379, db=0)
+
+    def _on_notify(self, updater: 'Database', obj: Any) -> None:
+        pass
+
+    def get(self, key: K, default: Any = Database.DEFAULT) -> Optional[V]:
+        if key not in self:
+            return default
+        return self._db.get(key)
+
+    def set(self, key: K, value: V) -> None:
+        self._db.set(key, value)
+
+    def delete(self, key: K) -> None:
+        self._db.delete(key)
+
+    def contains(self, key: K) -> bool:
+        return self._db.exists(key)
+
+
+__all__ = [
+    "RedisDatabase"
+]

{danielutils-0.9.73/danielutils/threads → danielutils-0.9.76/danielutils/abstractions/multiprogramming}/__init__.py

@@ -1,2 +1,3 @@
 from .worker import *
 from .worker_pool import *
+from .multi_id import *

{danielutils-0.9.73/danielutils/threads → danielutils-0.9.76/danielutils/abstractions/multiprogramming}/worker.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from typing import Optional, Any,Tuple as t_tuple
 from logging import error
 import danielutils # this is explicitly this way to prevent circular import
-from ..reflection import get_python_version
+from ...reflection import get_python_version
 if get_python_version() >= (3, 9):
     from builtins import tuple as t_tuple  # type:ignore
 

{danielutils-0.9.73/danielutils/threads → danielutils-0.9.76/danielutils/abstractions/multiprogramming}/worker_pool.py

@@ -2,7 +2,7 @@ from queue import Queue
 from typing import Optional, Any, Type as t_type, Tuple as t_tuple, List as t_list
 from threading import Semaphore
 from .worker import Worker
-from ..reflection import get_python_version
+from ...reflection import get_python_version
 
 if get_python_version() >= (3, 9):
     from builtins import type as t_type, tuple as t_tuple, list as t_list  # type:ignore

{danielutils-0.9.73/danielutils/classes → danielutils-0.9.76/danielutils/abstractions}/repl.py

@@ -1,6 +1,5 @@
-import copy
+import copy, re
 from typing import Any, Callable, Union, Tuple as t_tuple, List as t_list, Dict as t_dict
-import re
 from ..reflection import get_python_version  # pylint :disable=relative-beyond-top-level
 
 if get_python_version() >= (3, 9):

danielutils-0.9.76/danielutils/better_builtins/__init__.py

@@ -0,0 +1,3 @@
+from .typed_builtins import *
+from .frange import *
+from .counter import *

{danielutils-0.9.73/danielutils/classes → danielutils-0.9.76/danielutils/better_builtins}/frange.py

@@ -12,6 +12,37 @@ class frange(Sequence[float]):
         """will "downcast" `range` to `frange` correctly"""
         return frange(r.start, r.stop, r.step)
 
+    @staticmethod
+    def _is_int(n: Union[int, float]) -> bool:
+        if isinstance(n, int):
+            return True
+
+        return n.is_integer()
+
+    @staticmethod
+    def _lcm_float(a: float, b: float) -> float:
+        prec = min(5, max(decimal.getcontext().prec, 10))
+        a = round(a, prec)
+        b = round(b, prec)
+        return math.lcm(int(a * 10 ** prec), int(b * 10 ** prec)) / 10 ** prec
+
+    @staticmethod
+    def _find_min_step(s1: float, s2: float) -> float:
+        """
+        returns the minimum LCM for two step values
+        Args:
+            s1 (float): first step value:
+            s2 (float): second step value:
+
+        Returns:
+            float: minimum LCM
+        """
+        M = max(s1, s2)
+        m = min(s1, s2)
+        if float.is_integer(M / m):
+            return M
+        return frange._lcm_float(s1, s2)
+
     def __init__(self, start: float, stop: Optional[float] = None,
                  step: float = 1, round_method: Callable[[float], float] = lambda f: round(f, 3)):
         if stop is None:
@@ -21,27 +52,6 @@ class frange(Sequence[float]):
         self.stop = stop
         self.step = step
         self.method = round_method
-        self._is_finite = len(self) != float("inf")
-
-    @property
-    def is_finite(self) -> bool:
-        """
-        Returns `True` if the range is finite
-        inverse if `is_infinite`
-        Returns:
-            bool
-        """
-        return self._is_finite
-
-    @property
-    def is_infinite(self) -> bool:
-        """
-        Returns `True` if the range is infinite
-        inverse if `is_finite`
-        Returns:
-            bool
-        """
-        return not self.is_finite
 
     @overload
     def __getitem__(self, index: int) -> float:
@@ -78,9 +88,9 @@ class frange(Sequence[float]):
         return self.start == other.start and self.stop == other.stop and self.step == other.step
 
     def __iter__(self) -> Iterator[float]:
-        if self.stop < self.start:
+        if self.stop < self.start and self.step > 0:
             return
-        if self.start > self.stop:
+        if self.start > self.stop and self.step > 0:
             return
         if abs(self.stop - self.start) < abs(self.step):
             return
@@ -90,14 +100,14 @@ class frange(Sequence[float]):
             return
 
         cur = self.start
-        while cur < self.stop:
+        while (cur < self.stop and self.step > 0) or (cur > self.stop and self.step < 0):
             yield self.method(cur)
             cur += self.step
 
     def __len__(self) -> int:
         if self.stop in {float("inf"), -float("inf")}:
             return float("inf")
-        return int((self.stop - self.start) // self.step)
+        return int(abs(self.stop - self.start) // abs(self.step))
 
     def __str__(self) -> str:
         return repr(self)
@@ -105,13 +115,6 @@ class frange(Sequence[float]):
     def __repr__(self):
         return f"{self.__class__.__name__}({self.start}, {self.stop}, {self.step})"
 
-    @staticmethod
-    def _is_int(n: Union[int, float]) -> bool:
-        if isinstance(n, int):
-            return True
-
-        return n.is_integer()
-
     def __contains__(self, item):
         if item < self.start:
             return False
@@ -124,40 +127,33 @@ class frange(Sequence[float]):
 
         return item / self.step - item // self.step == 0
 
-    def normalize(self) -> 'frange':
+    @property
+    def is_finite(self) -> bool:
         """
-        will normalize the `frange` object
+        Returns `True` if the range is finite
+        inverse if `is_infinite`
         Returns:
-            frange
+            bool
         """
-        return frange(self.start / self.step, self.stop / self.step, 1)
-
-    # def _normalize_with(self, other: 'frange') -> 'frange':
-    #     return frange(self.start / (self.step * other.step), self.stop / (self.step * other.step), 1)
-
-    @staticmethod
-    def _lcm_float(a: float, b: float) -> float:
-        prec = min(5, max(decimal.getcontext().prec, 10))
-        a = round(a, prec)
-        b = round(b, prec)
-        return math.lcm(int(a * 10 ** prec), int(b * 10 ** prec)) / 10 ** prec
+        return len(self) != float("inf")
 
-    @staticmethod
-    def _find_min_step(s1: float, s2: float) -> float:
+    @property
+    def is_infinite(self) -> bool:
         """
-        returns the minimum LCM for two step values
-        Args:
-            s1 (float): first step value:
-            s2 (float): second step value:
+        Returns `True` if the range is infinite
+        inverse if `is_finite`
+        Returns:
+            bool
+        """
+        return not self.is_finite
 
+    def normalize(self) -> 'frange':
+        """
+        will normalize the `frange` object
         Returns:
-            float: minimum LCM
+            frange
         """
-        M = max(s1, s2)
-        m = min(s1, s2)
-        if float.is_integer(M / m):
-            return M
-        return frange._lcm_float(s1, s2)
+        return frange(self.start / self.step, self.stop / self.step, 1)
 
     def intersect(self, other: 'frange') -> 'frange':
         if not isinstance(other, frange):
@@ -214,7 +210,7 @@ class brange(frange):
     def __iter__(self):
         itr = super().__iter__()
         try:
-            from my_tqdm import tqdm  # type:ignore  # pylint: disable=import-error
+            from tqdm_ import tqdm  # type:ignore  # pylint: disable=import-error
             return iter(tqdm(itr, desc=f"{self}", total=len(self)))
         except:
             return itr

danielutils-0.9.76/danielutils/data_structures/graph/__init__.py

@@ -0,0 +1,4 @@
+from .graph import *
+from .node import *
+from .multinode import *
+from .binary_node import *

danielutils-0.9.76/danielutils/data_structures/graph/binary_node.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import Optional, TypeVar
+from .multinode import MultiNode
+from ...metaclasses import ImplicitDataDeleterMeta
+
+T = TypeVar("T")
+
+
+class BinaryNode(MultiNode[T], metaclass=ImplicitDataDeleterMeta):
+    """A 'classic' node class with only one child
+    """
+
+    def __init__(self, data: T, l: Optional[BinaryNode[T]] = None,
+                 r: Optional[BinaryNode[T]] = None):  # pylint: disable=redefined-builtin
+        # intentionally can be None
+        super().__init__(data, [l, r])  # type:ignore
+
+    def __str__(self):
+        return MultiNode.__str__(self).replace(
+            self.__class__.__mro__[1].__name__,
+            self.__class__.__name__
+        ).replace("[", "").replace("]", "")
+
+    def __repr__(self):
+        return str(self)
+
+    def __reversed__(self) -> 'BinaryNode[T]':
+        return self.reverse()
+
+    def __eq__(self, other):
+        return MultiNode.__eq__(self, other)
+
+    def __iter__(self):
+        return MultiNode.__iter__(self)
+
+    @property
+    def left(self) -> "BinaryNode[T]":
+        """return the next node after self
+        """
+        return self._children[0]  # type:ignore
+
+    @left.setter
+    def left(self, value: "BinaryNode[T]") -> None:
+        self._children[0] = value
+
+    @property
+    def right(self) -> "BinaryNode[T]":
+        """return the next node after self
+        """
+        return self._children[1]  # type:ignore
+
+    @right.setter
+    def right(self, value: "BinaryNode[T]") -> None:
+        self._children[1] = value
+
+    @property
+    def is_leaf(self) -> bool:
+        return self.left is None and self.right is None
+
+    def reverse(self) -> 'BinaryNode[T]':
+        new_left = self.right.reverse() if self.right is not None else None
+        new_right = self.left.reverse() if self.left is not None else None
+        return BinaryNode(self.data, new_left, new_right)
+
+    def depth(self) -> int:
+        return MultiNode.depth(self)
+
+
+__all__ = [
+    "BinaryNode"
+]