dycw-utilities 0.126.9__tar.gz → 0.126.11__tar.gz

{dycw_utilities-0.126.9 → dycw_utilities-0.126.11}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.126.9
+Version: 0.126.11
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: typing-extensions<4.14,>=4.13.1
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.133,>=6.132.0; extra == 'test'
+Requires-Dist: hypothesis<6.134,>=6.133.0; extra == 'test'
 Requires-Dist: pytest-asyncio<1.1,>=1.0.0; extra == 'test'
 Requires-Dist: pytest-cov<6.2,>=6.1.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
@@ -77,7 +77,7 @@ Provides-Extra: zzz-test-hypothesis
 Requires-Dist: aiosqlite<0.22,>=0.21.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: asyncpg<0.31,>=0.30.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: greenlet<3.3,>=3.2.0; extra == 'zzz-test-hypothesis'
-Requires-Dist: hypothesis<6.133,>=6.132.0; extra == 'zzz-test-hypothesis'
+Requires-Dist: hypothesis<6.134,>=6.133.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: numpy<2.3,>=2.2.6; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'

{dycw_utilities-0.126.9 → dycw_utilities-0.126.11}/pyproject.toml

@@ -25,7 +25,7 @@ dev = [
   "fpdf2 >= 2.8.3, < 2.9",
   "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
   "httpx >= 0.28.1, < 0.29",  # for fastapi
-  "hypothesis >= 6.132.0, < 6.133",
+  "hypothesis >= 6.133.0, < 6.134",
   "img2pdf >= 0.6.0, < 0.7",
   "lightweight-charts >= 2.1, < 2.2",
   "loguru >= 0.7.3, < 0.8",
@@ -94,12 +94,12 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.126.9"
+version = "0.126.11"
 
 [project.optional-dependencies]
 test = [
   "dycw-pytest-only >= 2.1.1, < 2.2",
-  "hypothesis >= 6.132.0, < 6.133",
+  "hypothesis >= 6.133.0, < 6.134",
   "pytest >= 8.3.5, < 8.4",
   "pytest-asyncio >= 1.0.0, < 1.1",
   "pytest-cov >= 6.1.1, < 6.2",
@@ -174,7 +174,7 @@ zzz-test-hypothesis = [
   "aiosqlite >= 0.21.0, < 0.22",
   "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
   "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
-  "hypothesis >= 6.132.0, < 6.133",
+  "hypothesis >= 6.133.0, < 6.134",
   "luigi >= 3.6.0, < 3.7",
   "numpy >= 2.2.6, < 2.3",
   "pathvalidate >= 3.2.3, < 3.3",
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.126.9"
+current_version = "0.126.11"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -436,6 +436,7 @@ addopts = [
   "--strict-markers",
   "--timeout=300",
 ]
+asyncio_default_fixture_loop_scope = "function"
 asyncio_mode = "auto"
 filterwarnings = [
   "error",

{dycw_utilities-0.126.9 → dycw_utilities-0.126.11}/src/tests/test_asyncio.py

@@ -21,16 +21,20 @@ from hypothesis.strategies import (
     permutations,
     sampled_from,
 )
-from pytest import LogCaptureFixture, approx, mark, param, raises
+from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.test_asyncio_classes.loopers import (
+    _REL,
     CountingLooper,
     CountingLooperError,
     LooperWithCounterMixin,
+    LooperWithCounterMixins,
     MultipleSubLoopers,
     Outer2CountingLooper,
     OuterCountingLooper,
     QueueLooper,
+    assert_looper_full,
+    assert_looper_stats,
 )
 from utilities.asyncio import (
     EnhancedQueue,
@@ -864,6 +868,7 @@ class TestInfiniteQueueLooper:
         assert looper.empty()
 
     @given(logger=just("logger") | none())
+    @mark.flaky
     @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
     async def test_error_process_items(
         self, *, logger: str | None, caplog: LogCaptureFixture
@@ -1007,6 +1012,70 @@ class TestLooper:
                 ...
             self._assert_stats_half(looper._counter, stops=1)
 
+    @mark.parametrize("counter_auto_start", [param(True), param(False)])
+    async def test_mixin_in_task_group(self, *, counter_auto_start: bool) -> None:
+        looper = LooperWithCounterMixin(
+            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+        )
+        with raises(ExceptionGroup) as exc_info:
+            async with EnhancedTaskGroup(timeout=looper.timeout) as tg:
+                _ = tg.create_task_context(looper)
+        error = one(exc_info.value.exceptions)
+        assert isinstance(error, TimeoutError)
+        self._assert_stats_half(looper._counter)
+
+    @mark.parametrize("counter1_auto_start", [param(True), param(False)])
+    @mark.parametrize("counter2_auto_start", [param(True), param(False)])
+    async def test_mixins(
+        self, *, counter1_auto_start: bool, counter2_auto_start: bool
+    ) -> None:
+        looper = LooperWithCounterMixins(
+            auto_start=True,
+            timeout=1.0,
+            counter1_auto_start=counter1_auto_start,
+            counter2_auto_start=counter2_auto_start,
+        )
+        match counter1_auto_start, counter2_auto_start:
+            case _, True:
+                with raises(TimeoutError):
+                    async with timeout(1.0), looper:
+                        ...
+                assert_looper_full(looper)
+                self._assert_stats_no_runs(looper._counter1)
+                self._assert_stats_third(looper._counter2)
+            case True, False:
+                with raises(TimeoutError):
+                    async with timeout(1.0), looper:
+                        ...
+                assert_looper_full(looper)
+                self._assert_stats_half(looper._counter1)
+                self._assert_stats_third(looper._counter2)
+            case False, False:
+                async with looper:
+                    ...
+                assert_looper_full(looper, stops=1)
+                self._assert_stats_half(looper._counter1, stops=1)
+                self._assert_stats_third(looper._counter2, stops=1)
+
+    @mark.parametrize("counter_auto_start", [param(True), param(False)])
+    async def test_mixins_in_task_group(self, *, counter_auto_start: bool) -> None:
+        looper1 = LooperWithCounterMixin(
+            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+        )
+        looper2 = LooperWithCounterMixin(
+            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+        )
+        with raises(ExceptionGroup) as exc_info:  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=1.0) as tg:
+                _ = tg.create_task_context(looper1)
+                _ = tg.create_task_context(looper2)
+        errors = exc_info.value.exceptions
+        assert 1 <= len(errors) <= 2
+        for error in errors:
+            assert isinstance(error, TimeoutError)
+        self._assert_stats_half(looper1._counter)
+        self._assert_stats_half(looper2._counter)
+
     def test_replace(self) -> None:
         looper = CountingLooper().replace(freq=10.0)
         assert looper.freq == 10.0
@@ -1024,7 +1093,7 @@ class TestLooper:
         looper = Example(auto_start=True, timeout=1.0)
         async with looper:
             ...
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=79,
@@ -1058,7 +1127,7 @@ class TestLooper:
         looper = Example(auto_start=True, timeout=1.0)
         async with looper:
             ...
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=14,
@@ -1098,7 +1167,7 @@ class TestLooper:
                     looper.put_right_nowait(i)
         async with looper:
             ...
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=25,
@@ -1301,47 +1370,6 @@ class TestLooper:
         assert not looper.auto_start
         assert looper.with_auto_start.auto_start
 
-    def _assert_stats(
-        self,
-        looper: Looper[Any],
-        /,
-        *,
-        entries: int = 0,
-        core_successes: int = 0,
-        core_failures: int = 0,
-        initialization_successes: int = 0,
-        initialization_failures: int = 0,
-        tear_down_successes: int = 0,
-        tear_down_failures: int = 0,
-        restart_successes: int = 0,
-        restart_failures: int = 0,
-        stops: int = 0,
-        rel: float = 0.5,
-    ) -> None:
-        stats = looper.stats
-        assert stats.entries == entries
-        assert stats.core_attempts == (stats.core_successes + stats.core_failures)
-        assert stats.core_successes == approx(core_successes, rel=rel)
-        assert stats.core_failures == approx(core_failures, rel=rel)
-        assert stats.initialization_attempts == (
-            stats.initialization_successes + stats.initialization_failures
-        )
-        assert stats.initialization_successes == approx(
-            initialization_successes, rel=rel
-        )
-        assert stats.initialization_failures == approx(initialization_failures, rel=rel)
-        assert stats.tear_down_attempts == (
-            stats.tear_down_successes + stats.tear_down_failures
-        )
-        assert stats.tear_down_successes == approx(tear_down_successes, rel=rel)
-        assert stats.tear_down_failures == approx(tear_down_failures, rel=rel)
-        assert stats.restart_attempts == (
-            stats.restart_successes + stats.restart_failures
-        )
-        assert stats.restart_successes == approx(restart_successes, rel=rel)
-        assert stats.restart_failures == approx(restart_failures, rel=rel)
-        assert stats.stops == stops
-
     def _assert_stats_no_runs(
         self,
         looper: Looper[Any],
@@ -1349,14 +1377,14 @@ class TestLooper:
         *,
         entries: int = 0,
         stops: int = 0,
-        rel: float = 0.75,
+        rel: float = _REL,
     ) -> None:
-        self._assert_stats(looper, entries=entries, stops=stops, rel=rel)
+        assert_looper_stats(looper, entries=entries, stops=stops, rel=rel)
 
     def _assert_stats_full(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=45,
@@ -1369,9 +1397,9 @@ class TestLooper:
         )
 
     def _assert_stats_half(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=56,
@@ -1384,9 +1412,9 @@ class TestLooper:
         )
 
     def _assert_stats_third(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=49,
@@ -1399,9 +1427,9 @@ class TestLooper:
         )
 
     def _assert_stats_quarter(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=35,

dycw_utilities-0.126.11/src/tests/test_asyncio_classes/loopers.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Literal, override
+
+from pytest import approx
+
+from utilities.asyncio import Looper
+from utilities.contextlib import suppress_super_object_attribute_error
+from utilities.datetime import MILLISECOND
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from utilities.types import Duration
+
+_FREQ: Duration = 10 * MILLISECOND
+_BACKOFF: Duration = 100 * MILLISECOND
+_REL: float = 0.75
+
+
+# assert
+
+
+def assert_looper_stats(
+    looper: Looper[Any],
+    /,
+    *,
+    entries: int = 0,
+    core_successes: int | tuple[Literal[">="], int] = 0,
+    core_failures: int = 0,
+    initialization_successes: int = 0,
+    initialization_failures: int = 0,
+    tear_down_successes: int = 0,
+    tear_down_failures: int = 0,
+    restart_successes: int = 0,
+    restart_failures: int = 0,
+    stops: int = 0,
+    rel: float = _REL,
+) -> None:
+    stats = looper.stats
+    assert stats.entries == entries, f"{stats=}, {entries=}"
+    assert stats.core_attempts == (stats.core_successes + stats.core_failures), (
+        f"{stats=}"
+    )
+    match core_successes:
+        case int():
+            assert stats.core_successes == approx(core_successes, rel=rel), (
+                f"{stats=}, {core_successes=}"
+            )
+        case ">=", int() as min_successes:
+            assert stats.core_successes >= min_successes, f"{stats=}, {min_successes=}"
+    assert stats.core_failures == approx(core_failures, rel=rel), (
+        f"{stats=}, {core_failures=}"
+    )
+    assert stats.initialization_attempts == (
+        stats.initialization_successes + stats.initialization_failures
+    ), f"{stats=}"
+    assert stats.initialization_successes == approx(
+        initialization_successes, rel=rel
+    ), f"{stats=}, {initialization_successes=}"
+    assert stats.initialization_failures == approx(initialization_failures, rel=rel), (
+        f"{stats=}, {initialization_failures=}"
+    )
+    assert stats.tear_down_attempts == (
+        stats.tear_down_successes + stats.tear_down_failures
+    ), f"{stats=}"
+    assert stats.tear_down_successes == approx(tear_down_successes, rel=rel), (
+        f"{stats=}, {tear_down_successes=}"
+    )
+    assert stats.tear_down_failures == approx(tear_down_failures, rel=rel), (
+        f"{stats=}, {initialization_failures=}"
+    )
+    assert stats.restart_attempts == (
+        stats.restart_successes + stats.restart_failures
+    ), f"{stats=}"
+    assert stats.restart_successes == approx(restart_successes, rel=rel), (
+        f"{stats=}, {restart_successes=}"
+    )
+    assert stats.restart_failures == approx(restart_failures, rel=rel), (
+        f"{stats=}, {restart_failures=}"
+    )
+    assert stats.stops == stops, f"{stats=}, {stops=}"
+
+
+def assert_looper_full(
+    looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
+) -> None:
+    assert_looper_stats(
+        looper,
+        entries=1,
+        core_successes=99,
+        initialization_successes=1,
+        stops=stops,
+        rel=rel,
+    )
+
+
+# counting looper
+
+
+@dataclass(kw_only=True)
+class CountingLooper(Looper[Any]):
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+
+    @override
+    async def _initialize_core(self) -> None:
+        await super()._initialize_core()
+        self.count = 0
+
+    @override
+    async def core(self) -> None:
+        await super().core()
+        self.count += 1
+        if self.count >= self.max_count:
+            raise CountingLooperError
+
+
+class CountingLooperError(Exception): ...
+
+
+# one sub looper
+
+
+@dataclass(kw_only=True)
+class OuterCountingLooper(CountingLooper):
+    inner: CountingLooper = field(init=False, repr=False)
+    inner_auto_start: bool = False
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.inner = CountingLooper(
+            auto_start=self.inner_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+
+    @override
+    def _yield_sub_loopers(self) -> Iterator[Looper]:
+        yield from super()._yield_sub_loopers()
+        yield self.inner
+
+
+# two sub loopers
+
+
+@dataclass(kw_only=True)
+class MultipleSubLoopers(CountingLooper):
+    inner1: CountingLooper = field(init=False, repr=False)
+    inner2: CountingLooper = field(init=False, repr=False)
+    inner1_auto_start: bool = False
+    inner2_auto_start: bool = False
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.inner1 = CountingLooper(
+            auto_start=self.inner1_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+        self.inner2 = CountingLooper(
+            auto_start=self.inner2_auto_start,
+            freq=self.freq / 3,
+            backoff=self.backoff / 3,
+            max_count=round(self.max_count / 3),
+        )
+
+    @override
+    def _yield_sub_loopers(self) -> Iterator[Looper]:
+        yield from super()._yield_sub_loopers()
+        yield self.inner1
+        yield self.inner2
+
+
+# nested sub loopers
+
+
+@dataclass(kw_only=True)
+class Outer2CountingLooper(CountingLooper):
+    middle: OuterCountingLooper = field(init=False, repr=False)
+    middle_auto_start: bool = False
+    inner_auto_start: bool = False
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.middle = OuterCountingLooper(
+            auto_start=self.middle_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+            inner_auto_start=self.inner_auto_start,
+        )
+
+    @override
+    def _yield_sub_loopers(self) -> Iterator[Looper]:
+        yield from super()._yield_sub_loopers()
+        yield self.middle
+
+
+# one mixin
+
+
+@dataclass(kw_only=True)
+class CounterMixin:
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+    counter_auto_start: bool = False
+    _counter: CountingLooper = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        with suppress_super_object_attribute_error():
+            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
+        self._counter = CountingLooper(
+            auto_start=self.counter_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+
+    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
+        with suppress_super_object_attribute_error():
+            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
+        yield self._counter
+
+
+@dataclass(kw_only=True)
+class LooperWithCounterMixin(CounterMixin, Looper): ...
+
+
+# two mixins
+
+
+@dataclass(kw_only=True)
+class CounterMixin1:
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+    counter1_auto_start: bool = False
+    _counter1: CountingLooper = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        with suppress_super_object_attribute_error():
+            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
+        self._counter1 = CountingLooper(
+            auto_start=self.counter1_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+
+    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
+        with suppress_super_object_attribute_error():
+            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
+        yield self._counter1
+
+
+@dataclass(kw_only=True)
+class CounterMixin2:
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+    counter2_auto_start: bool = False
+    _counter2: CountingLooper = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        with suppress_super_object_attribute_error():
+            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
+        self._counter2 = CountingLooper(
+            auto_start=self.counter2_auto_start,
+            freq=self.freq / 3,
+            backoff=self.backoff / 3,
+            max_count=round(self.max_count / 3),
+        )
+
+    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
+        with suppress_super_object_attribute_error():
+            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
+        yield self._counter2
+
+
+@dataclass(kw_only=True)
+class LooperWithCounterMixins(CounterMixin1, CounterMixin2, Looper): ...
+
+
+# queue looper
+
+
+@dataclass(kw_only=True)
+class QueueLooper(Looper[int]):
+    @override
+    async def core(self) -> None:
+        await super().core()
+        if not self.empty():
+            _ = self.get_left_nowait()

dycw_utilities-0.126.11/src/tests/test_asyncio_classes/redis.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from tests.test_asyncio_classes.loopers import _BACKOFF, _FREQ
+from utilities.asyncio import Looper
+from utilities.redis import PublishServiceMixin, SubscribeServiceMixin
+from utilities.text import unique_str
+
+if TYPE_CHECKING:
+    from utilities.types import Duration
+
+
+@dataclass(kw_only=True)
+class LooperWithPublishAndSubscribeMixins(
+    PublishServiceMixin[Any], SubscribeServiceMixin[Any], Looper[Any]
+):
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    publish_service_freq: Duration = field(default=_FREQ, repr=False)
+    publish_service_backoff: Duration = field(default=_BACKOFF, repr=False)
+    publish_service_debug: bool = field(default=True, repr=False)
+    subscribe_service_freq: Duration = field(default=_FREQ, repr=False)
+    subscribe_service_backoff: Duration = field(default=_BACKOFF, repr=False)
+    subscribe_service_debug: bool = field(default=True, repr=False)
+    subscribe_service_channel: str = field(default_factory=unique_str)

{dycw_utilities-0.126.9 → dycw_utilities-0.126.11}/src/tests/test_hypothesis.py

@@ -99,7 +99,6 @@ from utilities.hypothesis import (
     triples,
     uint32s,
     uint64s,
-    unique_strs,
     versions,
     zoned_datetimes,
 )
@@ -1171,13 +1170,6 @@ class TestUInt64s:
         assert max(min_value, MIN_UINT64) <= x <= min(max_value, MAX_UINT64)
 
 
-class TestUniqueStrs:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
-        first, second = data.draw(pairs(unique_strs()))
-        assert first != second
-
-
 class TestVersions:
     @given(data=data(), suffix=booleans())
     def test_main(self, *, data: DataObject, suffix: bool) -> None:

{dycw_utilities-0.126.9 → dycw_utilities-0.126.11}/src/tests/test_orjson.py

@@ -234,7 +234,7 @@ class TestGetLogRecords:
         handler.setFormatter(OrjsonFormatter())
         for level_, message_, extra_ in items:
             _ = assume(set(extra_) & set(_LOG_RECORD_DEFAULT_ATTRS) == set())
-            logger.log(get_logging_level_number(level_), message_, extra=extra_)
+            logger.log(get_logging_level_number(level_), "%s", message_, extra=extra_)
         output = get_log_records(root, parallelism="threads")
         output = output.filter(
             index=index,