dycw-utilities 0.155.4__tar.gz → 0.157.0__tar.gz

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/PKG-INFO

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

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/pyproject.toml

@@ -144,7 +144,7 @@ psutil = [
   "psutil >=7.0.0, <7.1",
 ]
 pyinstrument = [
-  "pyinstrument >=5.0.3, <5.1",
+  "pyinstrument >=5.1.0, <5.2",
 ]
 pytest = [
   "pytest >=8.4.1, <8.5",
@@ -227,7 +227,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.155.4"
+version = "0.157.0"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -259,7 +259,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.155.4"
+current_version = "0.157.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/tests/test_asyncio.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from asyncio import Queue, TaskGroup, run
+from asyncio import Queue, run
 from collections.abc import ItemsView, KeysView, ValuesView
 from contextlib import asynccontextmanager
 from re import search
@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, ClassVar
 
 from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import booleans, dictionaries, integers, lists, none
-from pytest import LogCaptureFixture, RaisesGroup, mark, param, raises
+from pytest import RaisesGroup, raises
 
 from utilities.asyncio import (
     AsyncDict,
@@ -16,7 +16,6 @@ from utilities.asyncio import (
     get_coroutine_name,
     get_items,
     get_items_nowait,
-    loop_until_succeed,
     put_items,
     put_items_nowait,
     sleep_max,
@@ -29,7 +28,6 @@ from utilities.asyncio import (
 )
 from utilities.hypothesis import pairs, text_ascii
 from utilities.pytest import skipif_windows
-from utilities.text import unique_str
 from utilities.timer import Timer
 from utilities.whenever import MILLISECOND, SECOND, get_now
 
@@ -319,70 +317,6 @@ class TestGetItems:
         assert result == xs[:max_size]
 
 
-class TestLoopUntilSucceed:
-    @mark.parametrize("sleep", [param(MILLISECOND), param(None)])
-    @mark.parametrize("use_logger", [param(True), param(False)])
-    async def test_main(
-        self, *, caplog: LogCaptureFixture, sleep: TimeDelta | None, use_logger: bool
-    ) -> None:
-        class CustomError(Exception): ...
-
-        caplog.set_level("DEBUG", logger=(name := unique_str()))
-        counter = 0
-
-        async def func() -> None:
-            nonlocal counter
-            counter += 1
-            if counter <= 3:
-                raise CustomError
-
-        assert await loop_until_succeed(
-            lambda: func(), logger=name if use_logger else None, sleep=sleep
-        )
-        assert counter == 4
-
-        if use_logger:
-            messages = [r.message for r in caplog.records if r.name == name]
-            expected = 3 * (
-                ["Error running 'func'"]
-                + ([] if sleep is None else ["Sleeping for PT0.001S..."])
-                + ["Retrying 'func'..."]
-            )
-            assert messages == expected
-
-    async def test_error_flat(self) -> None:
-        class CustomError(Exception): ...
-
-        counter = 0
-
-        async def func() -> None:
-            nonlocal counter
-            counter += 1
-            if counter <= 3:
-                raise CustomError
-
-        assert not await loop_until_succeed(lambda: func(), errors=CustomError)
-        assert counter == 1
-
-    async def test_error_nested(self) -> None:
-        class CustomError(Exception): ...
-
-        counter = 0
-
-        async def func() -> None:
-            async with TaskGroup() as tg:
-                _ = tg.create_task(inner())
-
-        async def inner() -> None:
-            nonlocal counter
-            counter += 1
-            if counter <= 3:
-                raise CustomError
-
-        assert not await loop_until_succeed(lambda: func(), errors=CustomError)
-        assert counter == 1
-
-
 class TestPutItems:
     @given(xs=lists(integers(), min_size=1), wait=booleans())
     async def test_main(self, *, xs: list[int], wait: bool) -> None:

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/tests/test_click.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import enum
+import pathlib
 from dataclasses import dataclass
 from enum import auto
 from operator import attrgetter
@@ -30,11 +31,7 @@ from utilities.click import (
     Date,
     DateDelta,
     DateTimeDelta,
-    DirPath,
     Enum,
-    ExistingDirPath,
-    ExistingFilePath,
-    FilePath,
     FrozenSetChoices,
     FrozenSetEnums,
     FrozenSetInts,
@@ -46,6 +43,7 @@ from utilities.click import (
     ListInts,
     ListStrs,
     MonthDay,
+    Path,
     PlainDateTime,
     Time,
     TimeDelta,
@@ -57,6 +55,7 @@ from utilities.hypothesis import (
     date_time_deltas,
     dates,
     month_days,
+    paths,
     plain_date_times,
     text_ascii,
     time_deltas,
@@ -68,7 +67,6 @@ from utilities.text import join_strs, strip_and_dedent
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable
-    from pathlib import Path
 
 
 class TestContextSettingsHelpOptionNames:
@@ -81,91 +79,17 @@ class TestContextSettingsHelpOptionNames:
         assert result.exit_code == 0
 
 
-class TestFileAndDirPaths:
-    def test_existing_dir_path(self, *, tmp_path: Path) -> None:
-        @command()
-        @argument("path", type=ExistingDirPath)
-        def cli(*, path: Path) -> None:
-            from pathlib import Path
-
-            assert isinstance(path, Path)
+class TestPath:
+    def test_path(self, *, tmp_path: pathlib.Path) -> None:
+        path_use = pathlib.Path("~", tmp_path)
 
-        result = CliRunner().invoke(cli, [str(tmp_path)])
-        assert result.exit_code == 0
-
-        file_path = tmp_path.joinpath("file.txt")
-        file_path.touch()
-        result = CliRunner().invoke(cli, [str(file_path)])
-        assert result.exit_code == 2
-        assert search("is a file", result.stderr)
-
-        non_existent = tmp_path.joinpath("non-existent")
-        result = CliRunner().invoke(cli, [str(non_existent)])
-        assert result.exit_code == 2
-        assert search("does not exist", result.stderr)
-
-    def test_existing_file_path(self, *, tmp_path: Path) -> None:
         @command()
-        @argument("path", type=ExistingFilePath)
-        def cli(*, path: Path) -> None:
-            from pathlib import Path
-
-            assert isinstance(path, Path)
+        @argument("path", type=Path())
+        def cli(*, path: pathlib.Path) -> None:
+            assert isinstance(path, pathlib.Path)
+            assert path == path.expanduser()
 
-        result = CliRunner().invoke(cli, [str(tmp_path)])
-        assert result.exit_code == 2
-        assert search("is a directory", result.stderr)
-
-        file_path = tmp_path.joinpath("file.txt")
-        file_path.touch()
-        result = CliRunner().invoke(cli, [str(file_path)])
-        assert result.exit_code == 0
-
-        non_existent = tmp_path.joinpath("non-existent")
-        result = CliRunner().invoke(cli, [str(non_existent)])
-        assert result.exit_code == 2
-        assert search("does not exist", result.stderr)
-
-    def test_dir_path(self, *, tmp_path: Path) -> None:
-        @command()
-        @argument("path", type=DirPath)
-        def cli(*, path: Path) -> None:
-            from pathlib import Path
-
-            assert isinstance(path, Path)
-
-        result = CliRunner().invoke(cli, [str(tmp_path)])
-        assert result.exit_code == 0
-
-        file_path = tmp_path.joinpath("file.txt")
-        file_path.touch()
-        result = CliRunner().invoke(cli, [str(file_path)])
-        assert result.exit_code == 2
-        assert search("is a file", result.stderr)
-
-        non_existent = tmp_path.joinpath("non-existent")
-        result = CliRunner().invoke(cli, [str(non_existent)])
-        assert result.exit_code == 0
-
-    def test_file_path(self, *, tmp_path: Path) -> None:
-        @command()
-        @argument("path", type=FilePath)
-        def cli(*, path: Path) -> None:
-            from pathlib import Path
-
-            assert isinstance(path, Path)
-
-        result = CliRunner().invoke(cli, [str(tmp_path)])
-        assert result.exit_code == 2
-        assert search("is a directory", result.stderr)
-
-        file_path = tmp_path.joinpath("file.txt")
-        file_path.touch()
-        result = CliRunner().invoke(cli, [str(file_path)])
-        assert result.exit_code == 0
-
-        non_existent = tmp_path.joinpath("non-existent")
-        result = CliRunner().invoke(cli, [str(non_existent)])
+        result = CliRunner().invoke(cli, [str(path_use)])
         assert result.exit_code == 0
 
 
@@ -301,6 +225,9 @@ class TestParameters:
             serialize=whenever.MonthDay.format_common_iso,
             failable=True,
         ),
+        _Case(
+            param=Path(), name="path", strategy=paths(), serialize=str, failable=False
+        ),
         _Case(
             param=PlainDateTime(),
             name="plain date-time",

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/tests/test_eventkit.py

@@ -65,13 +65,17 @@ class TestAddListener:
 
                 def listener_sync() -> None: ...
 
-                _ = add_listener(event, listener_sync, logger=str(root))
+                _ = add_listener(
+                    event, listener_sync, logger=str(root), logger_allow_pytest=True
+                )
             case "async":
 
                 async def listener_async() -> None:
                     await sleep(0.01)
 
-                _ = add_listener(event, listener_async, logger=str(root))
+                _ = add_listener(
+                    event, listener_async, logger=str(root), logger_allow_pytest=True
+                )
 
         event.emit(None)
         await sleep(0.01)
@@ -233,7 +237,7 @@ class TestLiftListener:
             LiftListenerError,
             match="Synchronous listener .* cannot be paired with an asynchronous error handler .*",
         ):
-            _ = lift_listener(listener, Event(), error=error)
+            _ = lift_listener(listener, Event(), error=error, logger_allow_pytest=True)
 
 
 class TestLiftedEvent:

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/tests/test_logging.py

@@ -12,7 +12,7 @@ from hypothesis.strategies import booleans, integers
 from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
-from utilities.hypothesis import pairs, temp_paths, text_ascii, zoned_date_times
+from utilities.hypothesis import pairs, temp_paths, zoned_date_times
 from utilities.iterables import one
 from utilities.logging import (
     GetLoggingLevelNumberError,
@@ -78,7 +78,7 @@ class TestBasicConfig:
     ) -> None:
         name = unique_str()
         with set_log_factory:
-            basic_config(obj=name, filters=filters, plain=plain)
+            basic_config(obj=name, filters=filters, plain=plain, allow_pytest=True)
         getLogger(name).warning("message")
         record = one(r for r in caplog.records if r.name == name)
         assert record.message == "message"
@@ -527,13 +527,19 @@ class TestToLogger:
     def test_default(self) -> None:
         assert to_logger().name == "root"
 
-    @given(name=text_ascii(min_size=1))
-    def test_logger(self, *, name: str) -> None:
+    def test_logger(self) -> None:
+        name = unique_str()
         assert to_logger(getLogger(name)).name == name
 
-    @given(name=text_ascii(min_size=1))
-    def test_str(self, *, name: str) -> None:
+    def test_str(self) -> None:
+        name = unique_str()
         assert to_logger(name).name == name
 
+    @mark.parametrize(("allow_pytest", "expected"), [param(False, 1), param(True, 0)])
+    def test_allow_pytest(self, *, allow_pytest: bool, expected: int) -> None:
+        name = unique_str()
+        logger = to_logger(name, allow_pytest=allow_pytest)
+        assert len(logger.filters) == expected
+
     def test_none(self) -> None:
         assert to_logger(None).name == "root"

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/tests/test_os.py

@@ -22,6 +22,7 @@ from utilities.os import (
     get_cpu_use,
     get_env_var,
     is_debug,
+    is_pytest,
     temp_environ,
 )
 from utilities.pytest import skipif_windows
@@ -124,6 +125,11 @@ class TestIsDebug:
         assert isinstance(result, bool)
 
 
+class TestIsPytest:
+    def test_main(self) -> None:
+        assert is_pytest()
+
+
 class TestTempEnviron:
     @given(key=text.map(_prefix), value=text)
     def test_set(self, *, key: str, value: str) -> None:

dycw_utilities-0.157.0/src/tests/test_pottery.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from asyncio import TaskGroup
+from typing import TYPE_CHECKING, ClassVar
+
+from pottery import AIORedlock
+from pytest import mark, param, raises
+
+from utilities.asyncio import sleep_td
+from utilities.pottery import (
+    _YieldAccessNumLocksError,
+    _YieldAccessUnableToAcquireLockError,
+    extend_lock,
+    yield_access,
+)
+from utilities.text import unique_str
+from utilities.timer import Timer
+from utilities.whenever import SECOND
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+    from whenever import TimeDelta
+
+
+class TestExtendLock:
+    async def test_main(self, *, test_redis: Redis) -> None:
+        lock = AIORedlock(key=unique_str(), masters={test_redis})
+        async with lock:
+            await extend_lock(lock=lock)
+
+    async def test_none(self) -> None:
+        await extend_lock()
+
+
+class TestYieldAccess:
+    delta: ClassVar[TimeDelta] = 0.1 * SECOND
+
+    @mark.parametrize(
+        ("num_tasks", "num_locks", "min_multiple"),
+        [
+            param(1, 1, 1),
+            param(1, 2, 1),
+            param(1, 3, 1),
+            param(2, 1, 2),
+            param(2, 2, 1),
+            param(2, 3, 1),
+            param(2, 4, 1),
+            param(2, 5, 1),
+            param(3, 1, 3),
+            param(3, 2, 2),
+            param(3, 3, 1),
+            param(3, 4, 1),
+            param(3, 5, 1),
+            param(4, 1, 4),
+            param(4, 2, 2),
+            param(4, 3, 2),
+            param(4, 4, 1),
+            param(4, 5, 1),
+        ],
+    )
+    async def test_main(
+        self, *, test_redis: Redis, num_tasks: int, num_locks: int, min_multiple: int
+    ) -> None:
+        with Timer() as timer:
+            await self.func(test_redis, num_tasks, unique_str(), num_locks=num_locks)
+        assert (min_multiple * self.delta) <= timer <= (5 * min_multiple * self.delta)
+
+    async def test_error_num_locks(self, *, test_redis: Redis) -> None:
+        with raises(
+            _YieldAccessNumLocksError,
+            match=r"Number of locks for '\w+' must be positive; got 0",
+        ):
+            async with yield_access(test_redis, unique_str(), num=0):
+                ...
+
+    async def test_error_unable_to_acquire_lock(self, *, test_redis: Redis) -> None:
+        key = unique_str()
+        delta = 0.1 * SECOND
+
+        async def coroutine(key: str, /) -> None:
+            async with yield_access(
+                test_redis, key, num=1, timeout_acquire=delta, throttle=5 * delta
+            ):
+                await sleep_td(delta)
+
+        with raises(ExceptionGroup) as exc_info:
+            async with TaskGroup() as tg:
+                _ = tg.create_task(coroutine(key))
+                _ = tg.create_task(coroutine(key))
+        assert exc_info.group_contains(
+            _YieldAccessUnableToAcquireLockError,
+            match=r"Unable to acquire any 1 of 1 locks for '\w+' after .*",
+        )
+
+    async def func(
+        self, redis: Redis, num_tasks: int, key: str, /, *, num_locks: int = 1
+    ) -> None:
+        async def coroutine() -> None:
+            async with yield_access(redis, key, num=num_locks):
+                await sleep_td(self.delta)
+
+        async with TaskGroup() as tg:
+            _ = [tg.create_task(coroutine()) for _ in range(num_tasks)]

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/tests/test_pytest.py

@@ -9,7 +9,7 @@ from pytest import fixture, mark, param, raises
 
 from utilities.iterables import one
 from utilities.os import temp_environ
-from utilities.pytest import NodeIdToPathError, is_pytest, node_id_path, throttle
+from utilities.pytest import NodeIdToPathError, node_id_path, throttle
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -25,11 +25,6 @@ def set_asyncio_default_fixture_loop_scope(*, testdir: Testdir) -> None:
     """)
 
 
-class TestIsPytest:
-    def test_main(self) -> None:
-        assert is_pytest()
-
-
 class TestNodeIdPath:
     @mark.parametrize(
         ("node_id", "expected"),

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.155.4"
+__version__ = "0.157.0"

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/utilities/asyncio.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import sys
 from asyncio import (
     Lock,
     Queue,
@@ -36,9 +35,8 @@ from typing import (
     override,
 )
 
-from utilities.errors import ImpossibleCaseError, is_instance_error
 from utilities.functions import ensure_int, ensure_not_none
-from utilities.logging import to_logger
+from utilities.os import is_pytest
 from utilities.random import SYSTEM_RANDOM
 from utilities.sentinel import Sentinel, sentinel
 from utilities.shelve import yield_shelf
@@ -70,8 +68,6 @@ if TYPE_CHECKING:
     from utilities.types import (
         Coro,
         Delta,
-        ExceptionTypeLike,
-        LoggerLike,
         MaybeCallableBoolLike,
         MaybeType,
         PathLike,
@@ -369,8 +365,6 @@ async def get_items[T](queue: Queue[T], /, *, max_size: int | None = None) -> li
     try:
         items = [await queue.get()]
     except RuntimeError as error:  # pragma: no cover
-        from utilities.pytest import is_pytest
-
         if (not is_pytest()) or (error.args[0] != "Event loop is closed"):
             raise
         return []
@@ -400,43 +394,6 @@ def get_items_nowait[T](queue: Queue[T], /, *, max_size: int | None = None) -> l
 ##
 
 
-async def loop_until_succeed(
-    func: Callable[[], Coro[None]],
-    /,
-    *,
-    logger: LoggerLike | None = None,
-    errors: ExceptionTypeLike[Exception] | None = None,
-    sleep: Delta | None = None,
-) -> bool:
-    """Repeatedly call a coroutine until it succeeds."""
-    name = get_coroutine_name(func)
-    while True:
-        try:
-            await func()
-        except Exception as error:  # noqa: BLE001
-            if logger is not None:
-                to_logger(logger).error("Error running %r", name, exc_info=True)
-            exc_type, exc_value, traceback = sys.exc_info()
-            if (exc_type is None) or (exc_value is None):  # pragma: no cover
-                raise ImpossibleCaseError(
-                    case=[f"{exc_type=}", f"{exc_value=}"]
-                ) from None
-            sys.excepthook(exc_type, exc_value, traceback)
-            if (errors is not None) and is_instance_error(error, errors):
-                return False
-            if sleep is not None:
-                if logger is not None:
-                    to_logger(logger).info("Sleeping for %s...", sleep)
-                await sleep_td(sleep)
-            if logger is not None:
-                to_logger(logger).info("Retrying %r...", name)
-        else:
-            return True
-
-
-##
-
-
 async def put_items[T](items: Iterable[T], queue: Queue[T], /) -> None:
     """Put items into a queue; if full then wait."""
     for item in items:
@@ -589,7 +546,6 @@ __all__ = [
     "get_coroutine_name",
     "get_items",
     "get_items_nowait",
-    "loop_until_succeed",
     "put_items",
     "put_items_nowait",
     "sleep_max",

{dycw_utilities-0.155.4 → dycw_utilities-0.157.0}/src/utilities/click.py

@@ -6,7 +6,6 @@ import pathlib
 import uuid
 from typing import TYPE_CHECKING, TypedDict, assert_never, override
 
-import click
 import whenever
 from click import Choice, Context, Parameter, ParamType
 from click.types import IntParamType, StringParamType
@@ -29,6 +28,7 @@ if TYPE_CHECKING:
         IPv6AddressLike,
         MaybeStr,
         MonthDayLike,
+        PathLike,
         PlainDateTimeLike,
         TimeDeltaLike,
         TimeLike,
@@ -37,16 +37,6 @@ if TYPE_CHECKING:
     )
 
 
-FilePath = click.Path(file_okay=True, dir_okay=False, path_type=pathlib.Path)
-DirPath = click.Path(file_okay=False, dir_okay=True, path_type=pathlib.Path)
-ExistingFilePath = click.Path(
-    exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path
-)
-ExistingDirPath = click.Path(
-    exists=True, file_okay=False, dir_okay=True, path_type=pathlib.Path
-)
-
-
 class _HelpOptionNames(TypedDict):
     help_option_names: Sequence[str]
 
@@ -252,6 +242,32 @@ class MonthDay(ParamType):
                 assert_never(never)
 
 
+class Path(ParamType):
+    """A path-valued parameter."""
+
+    name = "path"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: PathLike, param: Parameter | None, ctx: Context | None
+    ) -> pathlib.Path:
+        """Convert a value into the `Path` type."""
+        match value:
+            case pathlib.Path():
+                return value.expanduser()
+            case str():
+                try:
+                    return pathlib.Path(value).expanduser()
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
 class PlainDateTime(ParamType):
     """A local-datetime-valued parameter."""
 
@@ -592,11 +608,7 @@ __all__ = [
     "Date",
     "DateDelta",
     "DateTimeDelta",
-    "DirPath",
     "Enum",
-    "ExistingDirPath",
-    "ExistingFilePath",
-    "FilePath",
     "FrozenSetChoices",
     "FrozenSetEnums",
     "FrozenSetParameter",
@@ -609,6 +621,8 @@ __all__ = [
     "ListParameter",
     "ListStrs",
     "MonthDay",
+    "Path",
+    "Path",
     "PlainDateTime",
     "Time",
     "TimeDelta",