mm-std 0.3.17__py3-none-any.whl → 0.3.19__py3-none-any.whl

mm_std/__init__.py

@@ -2,6 +2,7 @@ from .command import CommandResult as CommandResult
 from .command import run_command as run_command
 from .command import run_ssh_command as run_ssh_command
 from .concurrency.async_decorators import async_synchronized as async_synchronized
+from .concurrency.async_decorators import async_synchronized_parameter as async_synchronized_parameter
 from .concurrency.async_scheduler import AsyncScheduler as AsyncScheduler
 from .concurrency.async_task_runner import AsyncTaskRunner as AsyncTaskRunner
 from .concurrency.sync_decorators import synchronized as synchronized

mm_std/concurrency/async_decorators.py

@@ -1,5 +1,6 @@
 import asyncio
 import functools
+from collections import defaultdict
 from collections.abc import Awaitable, Callable
 from typing import ParamSpec, TypeVar
 
@@ -16,3 +17,38 @@ def async_synchronized(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable
             return await func(*args, **kwargs)
 
     return wrapper
+
+
+T = TypeVar("T")
+
+
+def async_synchronized_parameter[T, **P](
+    arg_index: int = 0, skip_if_locked: bool = False
+) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Awaitable[T | None]]]:
+    locks: dict[object, asyncio.Lock] = defaultdict(asyncio.Lock)
+
+    def outer(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T | None]]:
+        @functools.wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
+            if len(args) <= arg_index:
+                raise ValueError(f"Function called with fewer than {arg_index + 1} positional arguments")
+
+            key = args[arg_index]
+
+            if skip_if_locked and locks[key].locked():
+                return None
+
+            try:
+                async with locks[key]:
+                    return await func(*args, **kwargs)
+            finally:
+                # Clean up the lock if no one is waiting
+                # TODO: I'm not sure if the next like is OK
+                if not locks[key].locked() and not locks[key]._waiters:  # noqa: SLF001
+                    locks.pop(key, None)
+
+        # Store locks for potential external access
+        wrapper.locks = locks  # type: ignore[attr-defined]
+        return wrapper
+
+    return outer

mm_std/concurrency/async_scheduler.py

@@ -1,11 +1,15 @@
 import asyncio
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 from logging import Logger
 from typing import Any
 
 from mm_std.date import utc_now
-from mm_std.types_ import Args, AsyncFunc, Kwargs
+
+type AsyncFunc = Callable[..., Awaitable[object]]
+type Args = tuple[object, ...]
+type Kwargs = dict[str, object]
 
 
 class AsyncScheduler:
@@ -30,18 +34,14 @@ class AsyncScheduler:
         last_run: datetime | None = None
         running: bool = False
 
-    def __init__(self, logger: Logger) -> None:
-        """
-        Initialize the async scheduler.
-
-        Args:
-            logger: Logger instance for recording scheduler events
-        """
+    def __init__(self, logger: Logger, name: str = "AsyncScheduler") -> None:
+        """Initialize the async scheduler."""
         self.tasks: dict[str, AsyncScheduler.TaskInfo] = {}
         self._running: bool = False
         self._tasks: list[asyncio.Task[Any]] = []
         self._main_task: asyncio.Task[Any] | None = None
         self._logger = logger
+        self._name = name
 
     def add_task(self, task_id: str, interval: float, func: AsyncFunc, args: Args = (), kwargs: Kwargs | None = None) -> None:
         """
@@ -100,7 +100,7 @@ class AsyncScheduler:
         self._tasks = []
 
         for task_id in self.tasks:
-            task = asyncio.create_task(self._run_task(task_id))
+            task = asyncio.create_task(self._run_task(task_id), name=self._name + "-" + task_id)
             self._tasks.append(task)
 
         try:
@@ -151,3 +151,20 @@ class AsyncScheduler:
             self._main_task.cancel()
 
         self._logger.debug("AsyncScheduler stopped")
+
+    def is_running(self) -> bool:
+        """
+        Check if the scheduler is currently running.
+
+        Returns:
+            True if the scheduler is running, False otherwise
+        """
+        return self._running
+
+    def clear_tasks(self) -> None:
+        """Clear all tasks from the scheduler."""
+        if self._running:
+            self._logger.warning("Cannot clear tasks while scheduler is running")
+            return
+        self.tasks.clear()
+        self._logger.debug("Cleared all tasks from the scheduler")

mm_std/concurrency/async_task_runner.py

@@ -67,6 +67,9 @@ class AsyncTaskRunner:
         self._task_ids.add(task_id)
         self._tasks.append(AsyncTaskRunner.Task(task_id, awaitable))
 
+    def _task_name(self, task_id: str) -> str:
+        return f"{self.name}-{task_id}" if self.name else task_id
+
     async def run(self) -> AsyncTaskRunner.Result:
         """
         Executes all added tasks with concurrency limited by the semaphore.
@@ -92,7 +95,7 @@ class AsyncTaskRunner:
                     exceptions[task.task_id] = e
 
         # Create asyncio tasks for all runner tasks
-        tasks = [asyncio.create_task(run_task(task)) for task in self._tasks]
+        tasks = [asyncio.create_task(run_task(task), name=self._task_name(task.task_id)) for task in self._tasks]
 
         try:
             if self.timeout is not None:

{mm_std-0.3.17.dist-info → mm_std-0.3.19.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.17
+Version: 0.3.19
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
 Requires-Dist: aiohttp~=3.11.14
 Requires-Dist: cryptography~=44.0.2
 Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: pydantic~=2.10.6
+Requires-Dist: pydantic~=2.11.0
 Requires-Dist: pydash~=8.0.5
 Requires-Dist: python-dotenv~=1.1.0
 Requires-Dist: requests[socks]~=2.32.3

{mm_std-0.3.17.dist-info → mm_std-0.3.19.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mm_std/__init__.py,sha256=wQywfba2Uxe5-IKqz3pvaR-p5miYM9DRQ0Qsdq23GTQ,2881
+mm_std/__init__.py,sha256=yxfH7ROIU5jwRQEeFIloTlDPZm_8443PKk50xzmQq7c,2984
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
 mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
@@ -19,12 +19,12 @@ mm_std/toml.py,sha256=CNznWKR0bpOxS6e3VB5LGS-Oa9lW-wterkcPUFtPcls,610
 mm_std/types_.py,sha256=9FGd2q47a8M9QQgsWJR1Kq34jLxBAkYSoJuwih4PPqg,257
 mm_std/zip.py,sha256=axzF1BwcIygtfNNTefZH7hXKaQqwe-ZH3ChuRWr9dnk,396
 mm_std/concurrency/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_std/concurrency/async_decorators.py,sha256=srJXjngf7InLSyD4sazDPNNtZBx9JddxDmH9WZi7s7g,452
-mm_std/concurrency/async_scheduler.py,sha256=bqC43svC_vIPV3U6iUxUzB6tdmEC2OZ2kYKld5sf9QE,5015
-mm_std/concurrency/async_task_runner.py,sha256=zYC2Jv5taUh8dnyDfWwh394SkzTXtdE9hOhvjV2FWKc,4493
+mm_std/concurrency/async_decorators.py,sha256=xEpyipzp3ZhaPHtdeTE-Ikrt67SUTFKBE6LQPeoeh6Q,1735
+mm_std/concurrency/async_scheduler.py,sha256=qS3QKMA0xpoxCZWjDW1ItAwKMTQ5h8esXMMRA0eXtxE,5644
+mm_std/concurrency/async_task_runner.py,sha256=hO_8umGGKVKfQW_hCzy6Nt0OIBDj7Yfjb8d7CCkmtJU,4643
 mm_std/concurrency/sync_decorators.py,sha256=syCQBOmN7qPO55yzgJB2rbkh10CVww376hmyvs6e5tA,1080
 mm_std/concurrency/sync_scheduler.py,sha256=j4tBL_cBI1spr0cZplTA7N2CoYsznuORMeRN8rpR6gY,2407
 mm_std/concurrency/sync_task_runner.py,sha256=s5JPlLYLGQGHIxy4oDS-PN7O9gcy-yPZFoNm8RQwzcw,1780
-mm_std-0.3.17.dist-info/METADATA,sha256=R2m2TLzehKG-9kPy56CyRhOL_ndpu_aUMjx6eSsH3PY,415
-mm_std-0.3.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.17.dist-info/RECORD,,
+mm_std-0.3.19.dist-info/METADATA,sha256=DXiV1MyhCD0Hn5tRZYdA9wQPoLutkvLX-d_q_CjJ-Co,415
+mm_std-0.3.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.19.dist-info/RECORD,,