dycw-utilities 0.149.9__tar.gz → 0.149.11__tar.gz

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.149.9
+Version: 0.149.11
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/pyproject.toml

@@ -103,7 +103,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.149.9"
+version = "0.149.11"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -136,7 +136,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.149.9"
+current_version = "0.149.11"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/tests/test_asyncio.py

@@ -6,7 +6,7 @@ from contextlib import asynccontextmanager
 from re import search
 from typing import TYPE_CHECKING, ClassVar
 
-from hypothesis import given
+from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import booleans, dictionaries, integers, lists, none
 from pytest import LogCaptureFixture, RaisesGroup, mark, param, raises
 
@@ -25,6 +25,7 @@ from utilities.asyncio import (
     sleep_until,
     stream_command,
     timeout_td,
+    yield_locked_shelf,
 )
 from utilities.hypothesis import pairs, text_ascii
 from utilities.pytest import skipif_windows
@@ -34,6 +35,7 @@ from utilities.whenever import MILLISECOND, SECOND, get_now
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
+    from pathlib import Path
 
     from whenever import TimeDelta
 
@@ -477,6 +479,20 @@ class TestTimeoutTD:
                 await sleep_td(2 * self.delta)
 
 
+class TestYieldLockedShelf:
+    @given(key=text_ascii(), value=integers())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    async def test_main(self, *, key: str, value: int, tmp_path: Path) -> None:
+        path = tmp_path.joinpath("shelf")
+        async with yield_locked_shelf(path) as shelf:
+            shelf[key] = value
+        async with yield_locked_shelf(path) as shelf:
+            result = shelf[key]
+        assert result == value
+
+
 if __name__ == "__main__":
     _ = run(
         stream_command('echo "stdout message" && sleep 2 && echo "stderr message" >&2')

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/tests/test_pottery.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from asyncio import TaskGroup
+from contextvars import ContextVar
 from typing import TYPE_CHECKING, ClassVar
 
 from pottery import AIORedlock
@@ -39,16 +40,27 @@ class TestTryYieldCoroutineLooper:
     delta: ClassVar[TimeDelta] = 0.1 * SECOND
 
     @mark.parametrize("use_logger", [param(True), param(False)])
+    @mark.parametrize("use_context", [param(True), param(False)])
     async def test_main(
-        self, *, caplog: LogCaptureFixture, use_logger: bool, test_redis: Redis
+        self,
+        *,
+        caplog: LogCaptureFixture,
+        use_logger: bool,
+        use_context: bool,
+        test_redis: Redis,
     ) -> None:
         caplog.set_level("DEBUG", logger=(name := unique_str()))
         lst: list[None] = []
         logger = name if use_logger else None
+        context = ContextVar(unique_str(), default=False) if use_context else None
 
         async with TaskGroup() as tg:
-            _ = tg.create_task(self.now(test_redis, name, lst, logger=logger))
-            _ = tg.create_task(self.delayed(test_redis, name, lst, logger=logger))
+            _ = tg.create_task(
+                self.now(test_redis, name, lst, logger=logger, context=context)
+            )
+            _ = tg.create_task(
+                self.delayed(test_redis, name, lst, logger=logger, context=context)
+            )
 
         assert len(lst) == 1
         if use_logger:
@@ -68,9 +80,10 @@ class TestTryYieldCoroutineLooper:
         /,
         *,
         logger: LoggerOrName | None = None,
+        context: ContextVar[bool] | None = None,
     ) -> None:
         async with try_yield_coroutine_looper(
-            redis, key, timeout_acquire=self.delta, logger=logger
+            redis, key, timeout_acquire=self.delta, logger=logger, context=context
         ) as looper:
             if looper is not None:
                 assert await looper(self.func_main, lst)
@@ -83,9 +96,10 @@ class TestTryYieldCoroutineLooper:
         /,
         *,
         logger: LoggerOrName | None = None,
+        context: ContextVar[bool] | None = None,
     ) -> None:
         await sleep_td(self.delta)
-        await self.now(redis, key, lst, logger=logger)
+        await self.now(redis, key, lst, logger=logger, context=context)
 
     @mark.parametrize("use_logger", [param(True), param(False)])
     async def test_error(

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/tests/test_shelve.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from hypothesis import given
+from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import integers
 
-from utilities.hypothesis import temp_paths, text_ascii
+from utilities.hypothesis import text_ascii
 from utilities.shelve import yield_shelf
 
 if TYPE_CHECKING:
@@ -13,9 +13,12 @@ if TYPE_CHECKING:
 
 
 class TestYieldShelf:
-    @given(root=temp_paths(), key=text_ascii(), value=integers())
-    def test_main(self, *, root: Path, key: str, value: int) -> None:
-        path = root.joinpath("shelf")
+    @given(key=text_ascii(), value=integers())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_main(self, *, key: str, value: int, tmp_path: Path) -> None:
+        path = tmp_path.joinpath("shelf")
         with yield_shelf(path) as shelf:
             shelf[key] = value
         with yield_shelf(path) as shelf:

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.149.9"
+__version__ = "0.149.11"

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/utilities/asyncio.py

@@ -22,6 +22,7 @@ from contextlib import (
 )
 from dataclasses import dataclass
 from io import StringIO
+from pathlib import Path
 from subprocess import PIPE
 from sys import stderr, stdout
 from typing import (
@@ -40,6 +41,7 @@ from utilities.functions import ensure_int, ensure_not_none, to_bool
 from utilities.logging import get_logger
 from utilities.random import SYSTEM_RANDOM
 from utilities.sentinel import Sentinel, sentinel
+from utilities.shelve import yield_shelf
 from utilities.warnings import suppress_warnings
 from utilities.whenever import get_now, round_date_or_date_time, to_nanoseconds
 
@@ -58,10 +60,12 @@ if TYPE_CHECKING:
     )
     from contextvars import Context
     from random import Random
+    from shelve import Shelf
     from types import TracebackType
 
     from whenever import ZonedDateTime
 
+    from utilities.shelve import _Flag
     from utilities.types import (
         Coro,
         Delta,
@@ -69,6 +73,7 @@ if TYPE_CHECKING:
         LoggerOrName,
         MaybeCallableBool,
         MaybeType,
+        PathLike,
         SupportsKeysAndGetItem,
     )
 
@@ -547,6 +552,35 @@ async def timeout_td(
         raise error from None
 
 
+##
+
+
+_LOCKS: AsyncDict[Path, Lock] = AsyncDict()
+
+
+@asynccontextmanager
+async def yield_locked_shelf(
+    path: PathLike,
+    /,
+    *,
+    flag: _Flag = "c",
+    protocol: int | None = None,
+    writeback: bool = False,
+) -> AsyncIterator[Shelf[Any]]:
+    """Yield a shelf, behind a lock."""
+    path = Path(path)
+    try:
+        lock = _LOCKS[path]
+    except KeyError:
+        lock = Lock()
+        await _LOCKS.set(path, lock)
+    async with lock:
+        with yield_shelf(
+            path, flag=flag, protocol=protocol, writeback=writeback
+        ) as shelf:
+            yield shelf
+
+
 __all__ = [
     "AsyncDict",
     "EnhancedTaskGroup",
@@ -563,4 +597,5 @@ __all__ = [
     "sleep_until",
     "stream_command",
     "timeout_td",
+    "yield_locked_shelf",
 ]

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/utilities/pottery.py

@@ -12,12 +12,14 @@ from redis.asyncio import Redis
 
 from utilities.asyncio import loop_until_succeed, sleep_td, timeout_td
 from utilities.contextlib import enhanced_async_context_manager
+from utilities.contextvars import yield_set_context
 from utilities.iterables import always_iterable
 from utilities.logging import get_logger
 from utilities.whenever import MILLISECOND, SECOND, to_seconds
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Callable, Iterable
+    from contextvars import ContextVar
 
     from whenever import Delta
 
@@ -57,6 +59,7 @@ async def try_yield_coroutine_looper(
     throttle: Delta | None = None,
     logger: LoggerOrName | None = None,
     sleep_error: Delta | None = None,
+    context: ContextVar[bool] | None = None,
 ) -> AsyncIterator[CoroutineLooper | None]:
     """Try acquire access to a coroutine looper."""
     try:  # skipif-ci-and-not-linux
@@ -70,7 +73,12 @@ async def try_yield_coroutine_looper(
             sleep=sleep_acquire,
             throttle=throttle,
         ) as lock:
-            yield CoroutineLooper(lock=lock, logger=logger, sleep=sleep_error)
+            looper = CoroutineLooper(lock=lock, logger=logger, sleep=sleep_error)
+            if context is None:
+                yield looper
+            else:
+                with yield_set_context(context):
+                    yield looper
     except _YieldAccessUnableToAcquireLockError as error:  # skipif-ci-and-not-linux
         if logger is not None:
             get_logger(logger=logger).info("%s", error)

{dycw_utilities-0.149.9 → dycw_utilities-0.149.11}/src/utilities/shelve.py

@@ -12,12 +12,15 @@ if TYPE_CHECKING:
     from utilities.types import PathLike
 
 
+type _Flag = Literal["r", "w", "c", "n"]
+
+
 @contextmanager
 def yield_shelf(
     path: PathLike,
     /,
     *,
-    flag: Literal["r", "w", "c", "n"] = "c",
+    flag: _Flag = "c",
     protocol: int | None = None,
     writeback: bool = False,
 ) -> Iterator[Shelf[Any]]: