danielutils 1.0.37__tar.gz → 1.0.39__tar.gz

{danielutils-1.0.37/danielutils.egg-info → danielutils-1.0.39}/PKG-INFO

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

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/async_/__init__.py

@@ -1,5 +1,6 @@
-from .async_worker_pool import *
+from .async_cmd import *
+from .async_layered_command import *
+from .async_retry_executor import *
 from .async_worker_pool import *
 from .time_strategy import *
 from .utils import *
-from .async_cmd import *

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/async_/async_layered_command.py

@@ -1,9 +1,7 @@
-import sys, os
+import sys
 from typing import Optional, Tuple, List
 
 from .async_cmd import async_cmd
-from danielutils.context_managers import TemporaryFile
-import random
 
 
 class AsyncLayeredCommand:

danielutils-1.0.39/danielutils/async_/async_worker_pool.py

@@ -0,0 +1,100 @@
+import asyncio
+import json
+from collections import defaultdict
+from datetime import datetime
+from typing import Callable, Literal, Optional, Coroutine, List, Iterable, Any, Mapping, Tuple
+from tqdm import tqdm
+
+
+class AsyncWorkerPool:
+    DEFAULT_ORDER_IF_KEY_EXISTS = (
+        "pool", "timestamp", "worker_id", "task_id", "task_name", "num_tasks", "tasks", "level", "message", "exception"
+    )
+
+    def __init__(self, pool_name: str, num_workers: int = 5, show_pbar: bool = False) -> None:
+        self._num_workers: int = num_workers
+        self._pool_name: str = pool_name
+        self._show_pbar: bool = show_pbar
+        self._pbar: Optional[tqdm] = None
+        self._queue: asyncio.Queue[
+            Optional[Tuple[Callable, Iterable[Any], Mapping[Any, Any], Optional[str]]]] = asyncio.Queue()
+        self._workers: List = []
+
+    async def worker(self, worker_id) -> None:
+        """Worker coroutine that continuously fetches and executes tasks from the queue."""
+        task_index = 0
+        tasks = defaultdict(list)
+        while True:
+            task = await self._queue.get()
+            if task is None:  # Sentinel value to shut down the worker
+                break
+            func, args, kwargs, name = task
+            task_index += 1
+            self._info(f"Started", task_id=task_index, task_name=name, worker_id=worker_id)
+            try:
+                await func(*args, **kwargs)
+                tasks["success"].append(name)
+                self._info(f"Finished", task_id=task_index, worker_id=worker_id, task_name=name)
+            except Exception as e:
+                self._error(f"Failed", task_id=task_index, exception=e, worker_id=worker_id,
+                            task_name=name)
+                tasks["failure"].append(name)
+
+            if self._pbar:
+                self._pbar.update(1)
+            self._queue.task_done()
+        self._info(f"Done", worker_id=worker_id, tasks=tasks, num_tasks=task_index)
+
+    async def start(self) -> None:
+        """Starts the worker pool."""
+        if self._show_pbar:
+            self._pbar = tqdm(total=self._queue.qsize(), desc="#Tasks")
+        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: Optional[Iterable[Any]] = None,
+            kwargs: Optional[Mapping[Any, Any]] = None,
+            name: Optional[str] = None
+    ) -> None:
+        """Submit a new task to the queue."""
+        await self._queue.put((func, args or (), kwargs or {}, name))
+
+    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
+
+    @classmethod
+    def log(
+            self,
+            level: Literal["INFO", "WARNING", "ERROR"],
+            message: str,
+            order: Optional[Iterable[str]] = DEFAULT_ORDER_IF_KEY_EXISTS,
+            **kwargs
+    ) -> None:
+        kwargs["level"] = level
+        kwargs["message"] = message
+        kwargs["timestamp"] = datetime.now().isoformat()
+        ordered_kwargs = kwargs
+        if order:
+            ordered_kwargs = {key: kwargs[key] for key in order if key in kwargs}
+            ordered_kwargs.update(kwargs)
+        print(json.dumps(ordered_kwargs, default=str))
+
+    def _info(self, message: str, **kwargs) -> None:
+        self.log("INFO", message, pool=self._pool_name, **kwargs)
+
+    def _warn(self, message: str, **kwargs) -> None:
+        self.log("WARNING", message, pool=self._pool_name, **kwargs)
+
+    def _error(self, message: str, **kwargs) -> None:
+        self.log("ERROR", message, pool=self._pool_name, **kwargs)
+
+
+__all__ = [
+    "AsyncWorkerPool",
+]

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/async_/utils.py

@@ -1,6 +1,6 @@
 import asyncio
 from asyncio import Task
-from typing import List, Coroutine, Any, Tuple, Optional, Set
+from typing import List, Coroutine, Any, Tuple, Optional, Set, AsyncIterator, Iterator, TypeVar
 
 
 async def return_first(coros: List[Coroutine], timeout: Optional[int] = None) -> List[Tuple[int, Any]]:
@@ -26,7 +26,23 @@ async def return_all(coros: List[Coroutine], timeout: Optional[int] = None) -> L
     return [task.result() for task in done]
 
 
+async def cast_aiter(itr: Iterator) -> AsyncIterator:
+    for x in itr:
+        yield x
+
+
+T = TypeVar("T")
+
+
+async def async_enumerate(iterable: AsyncIterator[T], start: int = 0) -> AsyncIterator[Tuple[int, T]]:
+    index = start
+    async for item in iterable:
+        yield index, item
+        index += 1
+
+
 __all__ = [
     "return_first",
     "return_all",
+    'cast_aiter'
 ]

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/functions/isoftype.py

@@ -352,6 +352,12 @@ def __handle_type(params: tuple) -> bool:
     return False
 
 
+def __handle_unpack(params: tuple) -> bool:
+    # TODO see test_tlist.py -> test_wrong_values ->    with self.assertRaises(TypeError):
+    #             tlist[Tuple[int]]([[1], [2], [3], ["4"]])
+    raise NotImplemented
+
+
 HANDLERS: Dict[type, Callable] = {
     list: __handle_list_set_iterable,
     tuple: __handle_tuple,
@@ -371,6 +377,13 @@ HANDLERS: Dict[type, Callable] = {
     Callable: __handle_callable,
     Protocol: __handle_protocol,
 }
+try:
+    # This exists only from python version 3.11 onwards
+    from typing import Unpack
+
+    HANDLERS[Unpack] = __handle_unpack
+except:
+    pass
 
 
 def isoftype(V: Any, T: Any, /, strict: bool = True) -> bool:
@@ -431,4 +444,4 @@ def isoftype(V: Any, T: Any, /, strict: bool = True) -> bool:
 
 __all__ = [
     "isoftype"
-]
+]

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/java/__init__.py

@@ -1,7 +1,7 @@
 try:
-    from reflection import get_python_version
-except ImportError:
     from ..reflection import get_python_version  # type:ignore
+except ImportError:
+    from reflection import get_python_version
 
 if get_python_version() >= (3, 10):
     from .interfaces import *

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/java/java_interface.py

@@ -26,7 +26,7 @@ class JavaInterface(ABC):
             print(set(info.inherited_methods))
             actual_func_names = set(f.name for f in info.functions)
             for to_remove in {"__class_getitem__", "__init_subclass__"}:
-                if getattr(cls, to_remove, None) is getattr(JavaInterface, to_remove, None):
+                if hasattr(cls, to_remove) and getattr(cls, to_remove, None) is getattr(JavaInterface, to_remove, None):
                     actual_func_names.remove(to_remove)
             for interface in (base for base in cls.__mro__ if getattr(base, "__is_interface__", False)):
                 expected_func_names = set(f.name for f in ClassInfo(interface).abstract_methods)

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/logging_/builtin_impls/file_logger.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from danielutils import delete_file, directory_exists, create_directory
+from ...io_ import delete_file, directory_exists, create_directory
 
 from ..logger_strategy_impl_base import LoggerStrategyImplBase
 

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/reflection/class_info.py

@@ -5,7 +5,7 @@ from typing import Optional, List, Iterable, Type, TypeVar, Generic, get_origin
 from .function_info import FunctionInfo
 from .decoration_info import DecorationInfo
 from .argument_info import ArgumentInfo
-from danielutils.functions import isoftype
+from ..functions import isoftype
 
 T = TypeVar("T")
 
@@ -20,7 +20,7 @@ del T, _A
 
 class ClassInfo:
     CLASS_DEFINITION_REGEX: re.Pattern = re.compile(
-        r"(?P<decorations>[\s\S]*)?^class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)", re.MULTILINE)
+        r"(?P<decorations>[\s\S]*)?(^)?class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)", re.MULTILINE)
 
     # r"(?P<decorations>[\s\S]*)?^class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)"
 
@@ -42,7 +42,7 @@ class ClassInfo:
         m = ClassInfo.CLASS_DEFINITION_REGEX.match(self._src_code)
         if m is None:
             raise SyntaxError()
-        decorators, name, bases, _ = m.groups()
+        decorators, name, bases, _ = m.groupdict().values()
         self._name = name
         self._bases = ArgumentInfo.from_str(bases)
         self._parse_body()

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/retry_executor/backoff_strategy.py

@@ -1,4 +1,4 @@
-from danielutils import Supplier
+from ..aliases import Supplier
 
 
 class BackOffStrategy:

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/retry_executor/retry_executor.py

@@ -1,7 +1,7 @@
 import time
 from typing import Generic, TypeVar, Optional
 
-from danielutils import Supplier, Consumer
+from ..aliases import Supplier, Consumer
 from .backoff_strategies import ConstantBackOffStrategy
 
 from .backoff_strategy import BackOffStrategy

{danielutils-1.0.37 → danielutils-1.0.39}/danielutils/testing/unittest_/auto_cwd_testcase.py

@@ -2,11 +2,12 @@ import asyncio
 import functools
 import os
 import unittest
-import inspect
-from inspect import iscoroutine, iscoroutinefunction
+from inspect import iscoroutinefunction
 from typing import Callable, Type, Coroutine, Union, Any
 
-from danielutils import create_directory, get_current_working_directory, set_current_working_directory, delete_directory
+from ...random_ import RandomDataGenerator
+from ...io_ import create_directory, delete_directory, directory_exists
+from ...path import get_current_working_directory, set_current_working_directory
 
 
 def dispatch_function(func: Union[Callable, Coroutine], *args, **kwargs) -> Any:
@@ -18,10 +19,17 @@ def dispatch_function(func: Union[Callable, Coroutine], *args, **kwargs) -> Any:
         return func(*args, **kwargs)
 
 
+def get_available_folder_name(prefix_path: str, random_suffix_length: int = 15) -> str:
+    res = f"{prefix_path}_{RandomDataGenerator.name(random_suffix_length)}"
+    while directory_exists(res):
+        res = f"{prefix_path}_{RandomDataGenerator.name(random_suffix_length)}"
+    return res
+
+
 def improved_setup(func: Callable) -> Callable:
     @functools.wraps(func)
     def wrapper(self):
-        self.cwd = f"./{self.__class__.__name__}_test_folder"
+        self.cwd = get_available_folder_name(f"./{self.__class__.__name__}_test_folder")
         create_directory(self.cwd)
         self.prev_cwd = get_current_working_directory()
         set_current_working_directory(os.path.join(self.prev_cwd, self.cwd))
@@ -30,7 +38,7 @@ def improved_setup(func: Callable) -> Callable:
 
     @functools.wraps(func)
     async def async_wrapper(self):
-        self.cwd = f"./{self.__class__.__name__}_test_folder"
+        self.cwd = get_available_folder_name(f"./{self.__class__.__name__}_test_folder")
         create_directory(self.cwd)
         self.prev_cwd = get_current_working_directory()
         set_current_working_directory(os.path.join(self.prev_cwd, self.cwd))

{danielutils-1.0.37 → danielutils-1.0.39/danielutils.egg-info}/PKG-INFO

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

{danielutils-1.0.37 → danielutils-1.0.39}/pyproject.toml

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

danielutils-1.0.37/danielutils/async_/async_worker_pool.py

@@ -1,66 +0,0 @@
-import asyncio
-import json
-from typing import Callable, Literal, Optional, Coroutine
-
-
-class AsyncWorkerPool:
-    def __init__(self, pool_name: str, num_workers: int = 5) -> None:
-        self.num_workers = num_workers
-        self.pool_name = pool_name
-        self.queue = asyncio.Queue()
-        self.workers = []
-
-    async def worker(self, worker_id) -> None:
-        """Worker coroutine that continuously fetches and executes tasks from the queue."""
-        task_count = 0
-        while True:
-            task = await self.queue.get()
-            if task is None:  # Sentinel value to shut down the worker
-                break
-            task_count += 1
-            func, args, kwargs = task
-            self.info(f"Worker {worker_id} started with task {task_count}")
-
-            try:
-                await func(*args, **kwargs)
-            except Exception as e:
-                self.error(f"Worker {worker_id} failed task {task_count}", exception=e)
-
-            self.info(f"Worker {worker_id} finished with task {task_count}")
-            self.queue.task_done()
-        self.info(f"Worker {worker_id} done executed {task_count} tasks.")
-
-    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
-        kwargs["pool"] = self.pool_name
-        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__ = [
-    "AsyncWorkerPool",
-]