danielutils 1.0.36__tar.gz → 1.0.38__tar.gz

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

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

danielutils-1.0.38/danielutils/async_/__init__.py

@@ -0,0 +1,6 @@
+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 *

danielutils-1.0.38/danielutils/async_/async_cmd.py

@@ -0,0 +1,23 @@
+import asyncio
+from typing import Tuple, Optional
+
+
+async def async_cmd(
+        cmd: str,
+        *,
+        capture_stdout: bool = False,
+        capture_stderr: bool = False
+) -> Tuple[int, Optional[bytes], Optional[bytes]]:
+    kwargs = {}
+    if capture_stdout:
+        kwargs['stdout'] = asyncio.subprocess.PIPE
+    if capture_stderr:
+        kwargs['stderr'] = asyncio.subprocess.PIPE
+    process = await asyncio.create_subprocess_shell(cmd, **kwargs)  # type:ignore
+    stdout, stderr = await process.communicate()
+    return process.returncode, stdout, stderr
+
+
+__all__ = [
+    'async_cmd',
+]

danielutils-1.0.38/danielutils/async_/async_layered_command.py

@@ -0,0 +1,107 @@
+import sys
+from typing import Optional, Tuple, List
+
+from .async_cmd import async_cmd
+
+
+class AsyncLayeredCommand:
+    class_capture_stdout: bool = True
+    class_capture_stderr: bool = True
+    class_raise_on_fail: bool = False
+    class_verbose: bool = False
+    _class_prev_instance: Optional['AsyncLayeredCommand'] = None
+    _id: int = 0
+
+    @property
+    def prev(self):
+        return self._prev_instance
+
+    @prev.setter
+    def prev(self, value: Optional['AsyncLayeredCommand'] = None):
+        self._prev_instance = value
+
+    def __init__(
+            self,
+            command: Optional[str] = None,
+            *,
+            prev_instance: Optional['AsyncLayeredCommand'] = None,
+            instance_capture_stdout: Optional[bool] = None,
+            instance_capture_stderr: Optional[bool] = None,
+            instance_raise_on_fail: Optional[bool] = None,
+            instance_verbose: Optional[bool] = None
+    ):
+        self._command = command if command is not None else ""
+        self._instance_capture_stdout = instance_capture_stdout
+        self._instance_capture_stderr = instance_capture_stderr
+        self._instance_raise_on_fail = instance_raise_on_fail
+        self._instance_verbose = instance_verbose
+        self._prev_instance = prev_instance if prev_instance is not None else AsyncLayeredCommand._class_prev_instance
+        self._cur_class_prev_instance = AsyncLayeredCommand._class_prev_instance
+        AsyncLayeredCommand._class_prev_instance = self
+        self._has_entered: bool = False
+
+    def __enter__(self):
+        self._open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.prev is self._cur_class_prev_instance:
+            AsyncLayeredCommand._class_prev_instance = self.prev
+
+    def _open(self) -> None:
+        self._has_entered = True
+
+    def _build_command(self, *commands: str) -> str:
+        res = ""
+        if self.prev is not None:
+            prev = self.prev._build_command()
+            res += f"{prev} & " if prev != "" else ""
+        if self._command != "":
+            return res + " & ".join([self._command, *commands])
+        return res + " & ".join(commands)
+
+    def _error(self, predicate: bool, command: str, code: int, command_verbose: Optional[bool]) -> None:
+        if predicate:
+            verbose = self._merge_values(command_verbose, self._instance_verbose, AsyncLayeredCommand.class_verbose)
+            if verbose:
+                raise RuntimeError(f"command '{command}' failed with exit code {code}")
+            sys.exit(1)
+
+    @staticmethod
+    def _merge_values(command: Optional[bool], instance: Optional[bool], class_: bool) -> bool:
+        return command if command is not None else (instance if instance is not None else class_)
+
+    async def execute(
+            self,
+            *commands: str,
+            command_capture_stdout: Optional[bool] = None,
+            command_capture_stderr: Optional[bool] = None,
+            command_raise_on_fail: Optional[bool] = None,
+            command_verbose: Optional[bool] = None
+    ) -> Tuple[int, List[str], List[str]]:
+        if not self._has_entered:
+            raise RuntimeError(
+                "LayeredCommand must be used with a context manager. Use as: `with LayeredCommand(...) as l1:`")
+        capture_stdout = self._merge_values(command_capture_stdout, self._instance_capture_stdout,
+                                            self.class_capture_stdout)
+        capture_stderr = self._merge_values(command_capture_stderr, self._instance_capture_stderr,
+                                            self.class_capture_stderr)
+        raise_on_fail = self._merge_values(command_raise_on_fail, self._instance_raise_on_fail,
+                                           self.class_raise_on_fail)
+
+        command = self._build_command(*commands)
+        if not capture_stdout and not capture_stderr:
+            code = (await async_cmd(command))[0]
+            self._error(raise_on_fail and code != 0, command, code, command_verbose)
+            return code, [], []
+
+        code, stdout, stderr = await async_cmd(command, capture_stdout=True, capture_stderr=True)
+        return code, stdout.decode().splitlines(), stderr.decode().splitlines()
+
+    async def __call__(self, *args, **kwargs) -> Tuple[int, List[str], List[str]]:
+        return await self.execute(*args, **kwargs)
+
+
+__all__ = [
+    'AsyncLayeredCommand'
+]

danielutils-1.0.38/danielutils/async_/async_worker_pool.py

@@ -0,0 +1,89 @@
+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",
+]

{danielutils-1.0.36 → danielutils-1.0.38}/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.36 → danielutils-1.0.38}/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.36 → danielutils-1.0.38}/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.36 → danielutils-1.0.38}/danielutils/reflection/class_/class_reflection.py

@@ -115,7 +115,7 @@ class FunctionDeclaration:
             generics=self.generics,
         )
         dct.update(override_kwargs)
-        return FunctionDeclaration(**dct)
+        return FunctionDeclaration(**dct)  # type:ignore
 
     @property
     def has_generics(self) -> bool:
@@ -141,13 +141,13 @@ class FunctionDeclaration:
                         parameters.append(arg)
         res = []
         for code, name, args, ret in func_pattern.findall(src):
-            name: str = name.strip()
-            args: Optional[str] = remove_whitespace(args) if args is not None else None
+            name: str = name.strip()  # type:ignore
+            args: Optional[str] = remove_whitespace(args) if args is not None else None  # type:ignore
             arguments = []
             if args is not None:
                 for arg in split_args(args):
                     arguments.append(Argument(*arg_pattern.match(remove_whitespace(arg)).groups()))
-            ret: Optional[str] = ret.strip() if ret is not None and len(ret) != 0 else None
+            ret: Optional[str] = ret.strip() if ret is not None and len(ret) != 0 else None # type:ignore
             res.append(FunctionDeclaration(name, tuple(arguments), ret, decorators=None, generics=tuple(parameters)))
 
         return res

{danielutils-1.0.36 → danielutils-1.0.38}/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")
 

{danielutils-1.0.36 → danielutils-1.0.38}/danielutils/retry_executor/backoff_strategy.py

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

{danielutils-1.0.36 → danielutils-1.0.38}/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.36 → danielutils-1.0.38}/danielutils/testing/unittest_/auto_cwd_testcase.py

@@ -2,11 +2,11 @@ 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 ...io_ import create_directory, delete_directory
+from ...path import get_current_working_directory, set_current_working_directory
 
 
 def dispatch_function(func: Union[Callable, Coroutine], *args, **kwargs) -> Any:

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

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

{danielutils-1.0.36 → danielutils-1.0.38}/danielutils.egg-info/SOURCES.txt

@@ -35,6 +35,8 @@ danielutils/abstractions/multiprogramming/multi_id.py
 danielutils/abstractions/multiprogramming/worker.py
 danielutils/abstractions/multiprogramming/worker_pool.py
 danielutils/async_/__init__.py
+danielutils/async_/async_cmd.py
+danielutils/async_/async_layered_command.py
 danielutils/async_/async_retry_executor.py
 danielutils/async_/async_worker_pool.py
 danielutils/async_/time_strategy.py

{danielutils-1.0.36 → danielutils-1.0.38}/pyproject.toml

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

danielutils-1.0.36/danielutils/async_/__init__.py

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

danielutils-1.0.36/danielutils/async_/async_worker_pool.py

@@ -1,65 +0,0 @@
-import asyncio
-import json
-from typing import Callable, Literal, Optional, Coroutine
-
-from .async_retry_executor import AsyncRetryExecutor
-
-
-class AsyncWorkerPool:
-    def __init__(self, num_workers: int, retry_executor: Optional[AsyncRetryExecutor] = 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__ = [
-    "AsyncWorkerPool",
-]