danielutils 1.0.38__tar.gz → 1.0.39__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.38
+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.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.38 → 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.38 → 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.38 → danielutils-1.0.39}/danielutils/reflection/class_info.py

@@ -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.38 → danielutils-1.0.39}/danielutils/testing/unittest_/auto_cwd_testcase.py

@@ -5,7 +5,8 @@ import unittest
 from inspect import iscoroutinefunction
 from typing import Callable, Type, Coroutine, Union, Any
 
-from ...io_ import create_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
 
 
@@ -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.38 → danielutils-1.0.39/danielutils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.38
+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.38 → danielutils-1.0.39}/pyproject.toml

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

danielutils-1.0.38/danielutils/async_/async_worker_pool.py

@@ -1,89 +0,0 @@
-import asyncio
-import json
-from datetime import datetime
-from typing import Callable, Literal, Optional, Coroutine, List, Iterable, Any, Mapping
-
-
-class AsyncWorkerPool:
-    DEFAULT_ORDER_IF_KEY_EXISTS = (
-        "pool", "timestamp", "worker", "task", "tasks", "level", "message", "exception"
-    )
-
-    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_names = []
-        task_index = 0
-        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_names.append(name)
-            task_index = len(task_names)
-            self.info(f"Started task {task_index}", task=name, worker_id=worker_id)
-            try:
-                await func(*args, **kwargs)
-            except Exception as e:
-                self.error(f"Failed task {task_index}", exception=e, worker_id=worker_id, task=name)
-
-            self.info(f"Finished task {task_index}", worker_id=worker_id, task=name)
-            self.queue.task_done()
-        self.info(f"Done. Executed {task_index} tasks", worker_id=worker_id, tasks=task_names)
-
-    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: 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[List[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",
-]