danielutils 1.0.31__tar.gz → 1.0.35__tar.gz

{danielutils-1.0.31/danielutils.egg-info → danielutils-1.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.31
+Version: 1.0.35
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils/__init__.py

@@ -46,4 +46,5 @@ from .retry_executor import *
 from .java import *
 from .random_ import *
 from .lombok import *
-from .logging_ import *
+from .logging_ import *
+from .async_ import *

danielutils-1.0.35/danielutils/async_/__init__.py

@@ -0,0 +1,4 @@
+from .async_worker_pool_base import *
+from .async_worker_pool_base import *
+from .time_strategy import *
+from .utils import *

danielutils-1.0.35/danielutils/async_/async_retry_executor_base.py

@@ -0,0 +1,90 @@
+import asyncio
+import functools
+import json
+from datetime import datetime
+from typing import Literal, Optional, Any, Mapping, Iterable, Callable, Coroutine
+
+from ..custom_types import Supplier
+from ..decorators import normalize_decorator
+from .time_strategy import LinearTimeStrategy, ConstantTimeStrategy
+from ..versioned_imports import ParamSpec
+
+P = ParamSpec("P")
+
+
+class AsyncRetryExecutorBase:
+    def __init__(
+            self,
+            timeout_strategy: Supplier[float] = LinearTimeStrategy(30, 5),
+            delay_strategy: Supplier[float] = ConstantTimeStrategy(0)
+    ) -> None:
+        self.timeout_strategy = timeout_strategy
+        self.delay_strategy = delay_strategy
+
+    def is_transient(self, e: Exception) -> bool:
+        """
+        This function will return true if the exception that was raised at a specific attempt should be ignored and we should try again with respet to the amount of retries left
+        Args:
+            e: exception caught
+
+        Returns:
+            boolean
+        """
+        return False
+
+    async def execute(
+            self,
+            func: Callable[P, Coroutine],
+            *,
+            args: Optional[Iterable] = None,
+            kwargs: Optional[Mapping] = None,
+            max_tries: int = 5
+    ) -> Optional[Any]:
+        args = list(args) if args else []
+        kwargs = dict(kwargs) if kwargs else {}
+        for i in range(1, max_tries + 1):
+            timeout = self.timeout_strategy()
+            delay = self.delay_strategy()
+            try:
+                return await asyncio.wait_for(func(*args, **kwargs), timeout=timeout)
+            except Exception as e:
+                if self.is_transient(e):
+                    self.warn(f"Failed attempt {i}/{max_tries}", function=func, args=args, kwargs=kwargs, exception=e,
+                              timestamp=datetime.now().isoformat())
+                    if i < max_tries - 1 and delay > 0:
+                        await asyncio.sleep(delay)
+                else:
+                    raise e
+        self.error("Failed all attempts", function=func, args=args, kwargs=kwargs, timestamp=datetime.now().isoformat())
+        raise RuntimeError(f"Failed all attempts")
+
+    def log(self, level: Literal["INFO", "WARNING", "ERROR"], message: str, **kwargs) -> None:
+        kwargs["level"] = level
+        kwargs["message"] = message
+        print(json.dumps(kwargs, default=str))
+
+    def info(self, message: str, **kwargs) -> None:
+        self.log("INFO", message, **kwargs)
+
+    def warn(self, message: str, **kwargs) -> None:
+        self.log("WARNING", message, **kwargs)
+
+    def error(self, message: str, **kwargs) -> None:
+        self.log("ERROR", message, **kwargs)
+
+
+@normalize_decorator
+def with_async_retry(func, *retry_executor_args, max_tries: int = 5, **retry_executor_kwargs):
+    retry_executor = AsyncRetryExecutorBase(*retry_executor_args, **retry_executor_kwargs)
+
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        return await retry_executor.execute(func, args=args, kwargs=kwargs, max_tries=max_tries)
+
+    return wrapper
+
+
+__all__ = [
+    "AsyncRetryExecutorBase",
+    "with_async_retry"
+]

danielutils-1.0.35/danielutils/async_/async_worker_pool_base.py

@@ -0,0 +1,65 @@
+import asyncio
+import json
+from typing import Callable, Literal, Optional, Coroutine
+
+from .async_retry_executor_base import AsyncRetryExecutorBase
+
+
+class AsyncWorkerPoolBase:
+    def __init__(self, num_workers: int, retry_executor: Optional[AsyncRetryExecutorBase] = None) -> None:
+        self.num_workers = num_workers
+        self.queue = asyncio.Queue()
+        self.workers = []
+        self.retry_executor = retry_executor
+
+    async def worker(self, worker_id) -> None:
+        """Worker coroutine that continuously fetches and executes tasks from the queue."""
+        count = 0
+        while True:
+            task = await self.queue.get()
+            if task is None:  # Sentinel value to shut down the worker
+                break
+            count += 1
+            func, args, kwargs = task
+            self.info(f"Worker {worker_id} started with task {count}")
+            if self.retry_executor:
+                await self.retry_executor.execute(func, args=args, kwargs=kwargs)
+            else:
+                await func(*args, **kwargs)
+            self.info(f"Worker {worker_id} finished with task {count}")
+            self.queue.task_done()
+        self.info(f"Worker {worker_id} done.")
+
+    async def start(self) -> None:
+        """Starts the worker pool."""
+        self.workers = [asyncio.create_task(self.worker(i + 1)) for i in range(self.num_workers)]
+
+    async def submit(self, func: Callable[..., Coroutine[None, None, None]], *args, **kwargs) -> None:
+        """Submit a new task to the queue."""
+        await self.queue.put((func, args, kwargs))
+
+    async def join(self) -> None:
+        """Stops the worker pool by waiting for all tasks to complete and shutting down workers."""
+        await self.queue.join()  # Wait until all tasks are processed
+        for _ in range(self.num_workers):
+            await self.queue.put(None)  # Send sentinel values to stop workers
+        await asyncio.gather(*self.workers)  # Wait for workers to finish
+
+    def log(self, level: Literal["INFO", "WARNING", "ERROR"], message: str, **kwargs) -> None:
+        kwargs["level"] = level
+        kwargs["message"] = message
+        print(json.dumps(kwargs, default=str))
+
+    def info(self, message: str, **kwargs) -> None:
+        self.log("INFO", message, **kwargs)
+
+    def warn(self, message: str, **kwargs) -> None:
+        self.log("WARNING", message, **kwargs)
+
+    def error(self, message: str, **kwargs) -> None:
+        self.log("ERROR", message, **kwargs)
+
+
+__all__ = [
+    "AsyncWorkerPoolBase",
+]

danielutils-1.0.35/danielutils/async_/time_strategy.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+
+
+class TimeStrategy(ABC):
+    @abstractmethod
+    def next(self): ...
+
+    def __call__(self, *args, **kwargs):
+        return self.next()
+
+    @abstractmethod
+    def reset(self): ...
+
+
+class ConstantTimeStrategy(TimeStrategy):
+    def __init__(self, timeout: float):
+        self.timeout = timeout
+
+    def next(self) -> float:
+        return self.timeout
+
+    def reset(self) -> None:
+        pass  # No state to reset
+
+
+class LinearTimeStrategy(TimeStrategy):
+    def __init__(self, base_timeout: float, step: float):
+        self.base_timeout = base_timeout
+        self.step = step
+        self.current_timeout = base_timeout
+
+    def next(self) -> float:
+        timeout = self.current_timeout
+        self.current_timeout += self.step
+        return timeout
+
+    def reset(self) -> None:
+        self.current_timeout = self.base_timeout
+
+
+class MultiplicativeTimeStrategy(TimeStrategy):
+    def __init__(self, base_timeout: float, factor: float):
+        self.base_timeout = base_timeout
+        self.factor = factor
+        self.current_timeout = base_timeout
+
+    def next(self) -> float:
+        timeout = self.current_timeout
+        self.current_timeout *= self.factor
+        return timeout
+
+    def reset(self) -> None:
+        self.current_timeout = self.base_timeout
+
+
+__all__ = [
+    "TimeStrategy",
+    "ConstantTimeStrategy",
+    "LinearTimeStrategy",
+    "MultiplicativeTimeStrategy"
+]

danielutils-1.0.35/danielutils/async_/utils.py

@@ -0,0 +1,32 @@
+import asyncio
+from asyncio import Task
+from typing import List, Coroutine, Any, Tuple, Optional, Set
+
+
+async def return_first(coros: List[Coroutine], timeout: Optional[int] = None) -> List[Tuple[int, Any]]:
+    tasks: List[Task] = [asyncio.create_task(coro) for coro in coros]
+    result: Tuple[Set[Task], Set[Task]] = await asyncio.wait(tasks, timeout=timeout,
+                                                             return_when=asyncio.FIRST_COMPLETED)
+    done: Set[Task] = result[0]
+    # pending: Set[Task] = result[1]
+
+    res = []
+    for task in done:
+        res.append((tasks.index(task), task.result()))
+
+    return res
+
+
+async def return_all(coros: List[Coroutine], timeout: Optional[int] = None) -> List[Any]:
+    tasks: List[Task] = [asyncio.create_task(coro) for coro in coros]
+    result: Tuple[Set[Task], Set[Task]] = await asyncio.wait(tasks, timeout=timeout,
+                                                             return_when=asyncio.ALL_COMPLETED)
+    done: Set[Task] = result[0]
+
+    return [task.result() for task in done]
+
+
+__all__ = [
+    "return_first",
+    "return_all",
+]

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils/decorators/__init__.py

@@ -14,4 +14,5 @@ from .deprecate import *
 from .processify import *
 from .singleton import *
 from .total_ordering import *
-from .final import *
+from .final import *
+from .normalize_decorator import *

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils/decorators/final.py

@@ -7,6 +7,7 @@ def final(cls: type) -> type:
     Returns:
         marked class
     """
+
     def __init__subclass__(*args, **kwargs):
         raise TypeError(f"'{cls.__qualname__}' is final. Can't create subclasses")
 
@@ -18,6 +19,7 @@ class Final:
     """
     A parent class to make direct child a Final class. will add expected behaviour.
     """
+
     def __new__(cls, *args, **kwargs):
         if cls is Final:
             raise TypeError("Can't instantiate 'Final'")

danielutils-1.0.35/danielutils/decorators/normalize_decorator.py

@@ -0,0 +1,55 @@
+import functools
+from typing import Callable, Any
+
+
+def normalize_decorator(decorator: Callable[..., Any]) -> Callable[..., Any]:
+    """
+
+    Args:
+        decorator: a function that is used as a decorator and you want to be used with "normalized" arguments
+
+    Returns:
+        object: 
+        The normalized version of the decorator
+
+    Example:
+
+        Do
+        ```python
+        @normalize_decorator
+        def validate(func, strict:bool = False):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                # do stuff
+                return func(*args, **kwargs)
+            return wrapper
+        ```
+
+        instead of
+        ```python
+        def validate(strict_or_func: Optional[Union[bool,Callable]] = None):
+            strict = False # default value
+            def deco(func):
+                @functools.wraps(func)
+                def wrapper(*args, **kwargs):
+                    # do stuff
+                    return func(*args, **kwargs)
+                return wrapper
+            if isinstance(strict_or_func, bool):
+                strict = strict_or_func
+                return deco
+            return deco(strict_or_func)
+    """
+    @functools.wraps(decorator)
+    def wrapper(*args, **kwargs):
+        if args and callable(args[0]):
+            return decorator(args[0], *args[1:], **kwargs)
+        else:
+            return lambda func: decorator(func, *args, **kwargs)
+
+    return wrapper
+
+
+__all__ = [
+    "normalize_decorator",
+]

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils/functions/partition.py

@@ -4,7 +4,7 @@ from typing import List, Generator, Tuple, Union
 def partitions(n: int, k: int) -> Generator[List[int], None, None]:
     from ..decorators import memo_generator
 
-    @memo_generator()
+    @memo_generator
     def helper(n: int, target_sum: int, current_sum: int, topLevel: int, arr: Union[List[int], Tuple[int]]) -> \
             Generator[List[int], None, None]:
         arr = list(arr)

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils/reflection/class_info.py

@@ -1,4 +1,5 @@
 import inspect
+import json
 import re
 from typing import Optional, List, Iterable, Type, TypeVar, Generic, get_origin
 from .function_info import FunctionInfo
@@ -67,7 +68,15 @@ class ClassInfo:
             self._functions.append(FunctionInfo(obj, self._cls))
 
     def __str__(self) -> str:
-        return f"{self.__class__.__name__}(name=\"{self.name}\", bases={self.bases}, decorations={self.decorations}, static_methods={self.static_methods}, class_methods={self.class_methods}, isntance_methods={self.instance_methods})"
+        body = json.dumps({
+            "name": self.name,
+            "bases": self.bases,
+            "decorations": self.decorations,
+            "static_methods": self.static_methods,
+            "class_methods": self.class_methods,
+            "instance_methods": self.instance_methods
+        }, default=str, indent=4)[1:-1]
+        return f"{self.__class__.__name__}({body})"
 
     def __repr__(self):
         return f"{self.__class__.__name__}(name=\"{self.name}\")"
@@ -97,7 +106,7 @@ class ClassInfo:
         return sorted(filter(lambda f: f.is_instance_method, self._functions), key=lambda f: f.name)
 
     @property
-    def inherited_methods(self)->Iterable[FunctionInfo]:
+    def inherited_methods(self) -> Iterable[FunctionInfo]:
         return sorted(filter(lambda f: f.is_inherited, self._functions), key=lambda f: f.name)
 
     @property

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils/reflection/function_info.py

@@ -1,4 +1,5 @@
 import inspect
+import json
 import re
 from typing import Type, Optional, List, Callable
 from .decoration_info import DecorationInfo
@@ -46,6 +47,11 @@ class FunctionInfo:
             self._return_type = return_type
 
     def __str__(self) -> str:
+        # body = json.dumps({
+        #     "name": self.name,
+        #     "decorators": self.decorators,
+        #     "arguments": self.arguments
+        # }, default=str, indent=4)
         return f"{self.__class__.__name__}(name=\"{self.name}\", decorators={self.decorators}, arguments={self.arguments})"
 
     def __repr__(self) -> str:

{danielutils-1.0.31 → danielutils-1.0.35/danielutils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.31
+Version: 1.0.35
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.0.31 → danielutils-1.0.35}/danielutils.egg-info/SOURCES.txt

@@ -3,8 +3,6 @@ MANIFEST.in
 README.md
 pyproject.toml
 setup.py
-./LICENSE
-./README.md
 danielutils/__init__.py
 danielutils/aliases.py
 danielutils/colors.py
@@ -36,6 +34,11 @@ danielutils/abstractions/multiprogramming/__init__.py
 danielutils/abstractions/multiprogramming/multi_id.py
 danielutils/abstractions/multiprogramming/worker.py
 danielutils/abstractions/multiprogramming/worker_pool.py
+danielutils/async_/__init__.py
+danielutils/async_/async_retry_executor_base.py
+danielutils/async_/async_worker_pool_base.py
+danielutils/async_/time_strategy.py
+danielutils/async_/utils.py
 danielutils/better_builtins/__init__.py
 danielutils/better_builtins/counter.py
 danielutils/better_builtins/frange.py
@@ -88,6 +91,7 @@ danielutils/decorators/deprecate.py
 danielutils/decorators/final.py
 danielutils/decorators/limit_recursion.py
 danielutils/decorators/memo.py
+danielutils/decorators/normalize_decorator.py
 danielutils/decorators/overload.py
 danielutils/decorators/partially_implemented.py
 danielutils/decorators/processify.py

{danielutils-1.0.31 → danielutils-1.0.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "danielutils"
-version = "1.0.31"
+version = "1.0.35"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]