danielutils 0.9.62__tar.gz → 0.9.94__tar.gz

danielutils-0.9.94/MANIFEST.in

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

{danielutils-0.9.62 → danielutils-0.9.94}/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.62
+Version: 0.9.94
 Summary: A python utils library for things I find useful
-Home-page: https://github.com/danielnachumdev/danielutils
-Author: danielnachumdev
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
         
@@ -28,14 +26,13 @@ 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
-Platform: All
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Microsoft :: Windows
-Requires-Python: >=3.8.17
+Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
+License-File: LICENSE
 
 
 [![Python package](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml)
@@ -43,12 +40,15 @@ Description-Content-Type: text/markdown
 [![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.62
+# danielutils v=0.9.92
 A utils library for things that I find useful for my coding workflow.\
 Feel free to use and / or contribute / improve my code :)
 
 THIS PACKAGE IS IN DEVELOPMENT AND SUBJECT TO CHANGE, USE AT YOUR OWN RISK!
 
+**Tested python versions**: `3.8.0`*, `3.9.0`, `3.10.13` 
+
+Versions marked with * are partially working
 # Showcase
 In [this](./READMES/) folder you can check out some more in depth showcase of some of the topics I have covered in this package
 

{danielutils-0.9.62 → danielutils-0.9.94}/README.md

@@ -4,12 +4,15 @@
 [![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.62
+# danielutils v=0.9.92
 A utils library for things that I find useful for my coding workflow.\
 Feel free to use and / or contribute / improve my code :)
 
 THIS PACKAGE IS IN DEVELOPMENT AND SUBJECT TO CHANGE, USE AT YOUR OWN RISK!
 
+**Tested python versions**: `3.8.0`*, `3.9.0`, `3.10.13` 
+
+Versions marked with * are partially working
 # Showcase
 In [this](./READMES/) folder you can check out some more in depth showcase of some of the topics I have covered in this package
 

danielutils-0.9.94/danielutils/__init__.py

@@ -0,0 +1,47 @@
+"""danielutils is a convenience library of functions decorators
+    data-structures and more that make my development workflow faster
+"""
+# =================================================================
+# ============================= LEAFS =============================
+# =================================================================
+from .path import *
+from .date_time import *
+from .aliases import *
+from .exceptions import PrintCatchOne
+from .snippets import *
+from .abstractions import *
+from .protocols import *
+# =================================================================
+# ========================= ORDER MATTERS =========================
+# =================================================================
+
+from .reflection import *
+from .decorators import *
+# ========== NEEDS REFLECTION ==========
+# ========== NEEDS DECORATORS ==========
+from .colors import *
+# ========== NEEDS BOTH ==========
+
+from .progress_bar import *
+from .functions import *
+from .io_ import *
+from .system import *
+from .text import *
+from .conversions import *
+from .better_builtins import *
+from .time import *
+from .date import *
+from .data_structures import *
+from .math_ import *
+from .system import *
+from .print_ import *
+from .metaclasses import *
+from .generators import *
+from .university import *
+from .mock_ import *
+from .context_managers import *
+from .file_specifications import *
+from .testing import *
+from .retry_executor import *
+from .java import *
+from .random_ import *

danielutils-0.9.94/danielutils/abstractions/__init__.py

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

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

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

danielutils-0.9.94/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.94/danielutils/abstractions/database/database.py

@@ -0,0 +1,104 @@
+from abc import ABC, abstractmethod
+from typing import Any, TypeVar, Generic, Optional, Set
+
+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.94/danielutils/abstractions/database/redis_database.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional, TypeVar
+
+from danielutils import serialize, deserialize
+
+try:
+    import redis
+except ImportError:
+    from ...mock_ import MockImportObject
+
+    redis = MockImportObject("`redis` is not installed")  # type:ignore
+from .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 deserialize(self._db.get(serialize(key)))  # type: ignore
+
+    def set(self, key: K, value: V) -> None:
+        self._db.set(serialize(key), serialize(value))
+
+    def delete(self, key: K) -> None:
+        self._db.delete(serialize(key))
+
+    def contains(self, key: K) -> bool:
+        return bool(self._db.exists(serialize(key)))
+
+
+__all__ = [
+    "RedisDatabase"
+]

{danielutils-0.9.62/danielutils/threads → danielutils-0.9.94/danielutils/abstractions/multiprogramming}/__init__.py

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

danielutils-0.9.94/danielutils/abstractions/multiprogramming/multi_id.py

@@ -0,0 +1,26 @@
+import os
+import threading
+
+
+def process_id() -> int:
+    """
+    will return the current process' id
+    Returns:
+        int
+    """
+    return os.getpid()
+
+
+def thread_id() -> int:
+    """
+    will return the current thread's id
+    Returns:
+        int
+    """
+    return threading.get_ident()
+
+
+__all__ = [
+    "process_id",
+    "thread_id"
+]

{danielutils-0.9.62/danielutils/threads → danielutils-0.9.94/danielutils/abstractions/multiprogramming}/worker.py

@@ -1,20 +1,20 @@
 from threading import Thread
 from abc import ABC, abstractmethod
-from typing import Optional, Any
+from typing import Optional, Any, Tuple as Tuple
 from logging import error
-import danielutils
-from ..reflection import get_python_version
+import danielutils  # this is explicitly this way to prevent circular import
+from ...reflection import get_python_version
+
 if get_python_version() >= (3, 9):
-    from builtins import tuple as t_tuple  # type:ignore
-else:
-    from typing import Tuple as t_tuple
+    from builtins import tuple as Tuple  # type:ignore
 
 
 class Worker(ABC):
     """A Worker Interface
     """
 
-    def __init__(self, id: int, pool: "danielutils.Threading.worker_pool.WorkerPool") -> None:  # pylint: disable=redefined-builtin #noqa
+    def __init__(self, id: int,
+                 pool: "danielutils.abstractions.multiprogramming.worker_pool.WorkerPool") -> None:  # pylint: disable=redefined-builtin #noqa
         self.id = id
         self.pool = pool
         self.thread: Thread = Thread(target=self._loop)
@@ -59,9 +59,10 @@ class Worker(ABC):
         to signal actions if needed
         will call 'notification_function'
         """
-        self.pool._notify()  # pylint: disable=protected-access
+        # TODO
+        self.pool._notify_subscribers()  # type:ignore  # pylint: disable=protected-access
 
-    def acquire(self) -> Optional[t_tuple[Any]]:
+    def acquire(self) -> Optional[Tuple[Any]]:
         """acquire a new job object to work on from the pool
         will return a tuple of only one object (the job) or None if there are no more jobs
         Returns:

{danielutils-0.9.62/danielutils/threads → danielutils-0.9.94/danielutils/abstractions/multiprogramming}/worker_pool.py

@@ -1,12 +1,11 @@
 from queue import Queue
-from typing import Optional, Any
+from typing import Optional, Any, Type as t_type, Tuple as Tuple, List as 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
-else:
-    from typing import Type as t_type, Tuple as t_tuple, List as t_list
+    from builtins import type as t_type, tuple as Tuple, list as List  # type:ignore
 
 
 class WorkerPool:
@@ -16,9 +15,9 @@ class WorkerPool:
     def __init__(self, num_workers: int, worker_class: t_type[Worker], w_kwargs: dict, global_variables: dict) -> None:
         self.num_workers = num_workers
         self.global_variables: dict = global_variables
-        self.q: Queue[t_tuple[Any]] = Queue()
+        self.q: Queue[Tuple[Any]] = Queue()
         self.worker_class = worker_class
-        self.workers: t_list[Worker] = []
+        self.workers: List[Worker] = []
         self.sem = Semaphore(0)
         self.w_kwargs = w_kwargs
 
@@ -35,7 +34,7 @@ class WorkerPool:
         self.q.put((job,))
         self.sem.release()
 
-    def _acquire(self) -> Optional[t_tuple[Any]]:
+    def _acquire(self) -> Optional[Tuple[Any]]:
         """acquire a new job from the pool
 
         Returns:
@@ -63,6 +62,11 @@ class WorkerPool:
             self.sem.release(self.num_workers)
 
     def join(self) -> None:
+        """
+        waits for all the workers to finish and will return afterwards
+        Returns:
+            None
+        """
         for w in self.workers:
             w.thread.join()
 

{danielutils-0.9.62/danielutils/Classes → danielutils-0.9.94/danielutils/abstractions}/repl.py

@@ -1,8 +1,9 @@
-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
+import copy, re
+from typing import Any, Callable, Union, Tuple as Tuple, List as List, Dict as Dict
+from ..reflection import get_python_version  # pylint :disable=relative-beyond-top-level
+
 if get_python_version() >= (3, 9):
-    from builtins import tuple as t_tuple, list as t_list, dict as t_dict  # type:ignore
+    from builtins import tuple as Tuple, list as List, dict as Dict  # type:ignore
 
 
 class Argument:
@@ -19,7 +20,7 @@ class Command:
     """
 
     def __init__(self, command: Union[Argument, str], callback: Callable,
-                 explanation: str = "", *, options: t_tuple[Argument, ...] = tuple()) -> None:
+                 explanation: str = "", *, options: Tuple[Argument, ...] = tuple()) -> None:
         self.command = command if isinstance(
             command, Argument) else Argument(command)
         self.callback = callback
@@ -39,10 +40,11 @@ class REPL:
     """a class to easily create a shell application and get functionality for free
     """
 
-    def __init__(self, routes: t_list[Command], *, prompt_symbol: str = ">>> ", exit_keywords: set = {"exit", "quit"}):
+    # pylint: disable=dangerous-default-value
+    def __init__(self, routes: List[Command], *, prompt_symbol: str = ">>> ", exit_keywords: set = {"exit", "quit"}):
         self.prompt_symbol = prompt_symbol
-        self.exit_keywords = exit_keywords
-        self.routes: t_dict[str, Command] = {
+        self.exit_keywords = copy.copy(exit_keywords)
+        self.routes: Dict[str, Command] = {
             com.command.name: com for com in routes}
 
     def run(self) -> None:
@@ -58,7 +60,7 @@ class REPL:
 
             if prompt == "help":
                 print("Available commands:")
-                for com in list(self.routes.keys())+list(self.exit_keywords):
+                for com in list(self.routes.keys()) + list(self.exit_keywords):
                     print(f"\t{com}")
                 continue
 
@@ -70,9 +72,9 @@ class REPL:
                 except TypeError as e:
                     msg = str(e)
                     if re.match(r".*missing.*required.*argument.*", msg):
-                        print(f"'{command}' "+msg[msg.find("missing"):])
+                        print(f"'{command}' " + msg[msg.find("missing"):])
                     elif re.match(r".*takes.*arguments but.*given", msg):
-                        print(f"'{command}' "+msg[msg.find("takes"):])
+                        print(f"'{command}' " + msg[msg.find("takes"):])
                     else:
                         raise e
 

danielutils-0.9.62/danielutils/Aliases.py → danielutils-0.9.94/danielutils/aliases.py

@@ -150,16 +150,15 @@ T = TypeVar("T")
 
 Supplier = Callable[[], T]
 Runnable = Supplier[None]
-
+Consumer = Callable[[T], None]
 UnaryFunction = Callable[[U], T]
-UnaryOperator = UnaryFunction[T, T]
-Predicate = UnaryFunction[T, bool]
-Consumer = UnaryFunction[T, None]
+UnaryOperator = Callable[[T], T]
+Predicate = Callable[[T], bool]
 
 BinaryFunction = Callable[[A, B], T]
-BinaryOperator = BinaryFunction[T, T, T]
-Comparator = BinaryFunction[A, B, int]
-BinaryConsumer = BinaryFunction[T, T, None]
+BinaryOperator = Callable[[T, T], T]
+Comparator = Callable[[A, B], int]
+BinaryConsumer = Callable[[T, T], None]
 
 __all__ = [
     "UnaryFunction",

danielutils-0.9.94/danielutils/better_builtins/__init__.py

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