dycw-utilities 0.126.5__tar.gz → 0.126.7__tar.gz

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/PKG-INFO

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

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/pyproject.toml

@@ -95,7 +95,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.126.5"
+version = "0.126.7"
 
 [project.optional-dependencies]
 test = [
@@ -336,7 +336,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.126.5"
+current_version = "0.126.7"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/src/tests/test_click.py

@@ -31,6 +31,7 @@ import utilities.click
 import utilities.datetime
 import utilities.types
 from utilities.click import (
+    CONTEXT_SETTINGS_HELP_OPTION_NAMES,
     Date,
     DirPath,
     Enum,
@@ -86,6 +87,16 @@ if TYPE_CHECKING:
 _T = TypeVar("_T")
 
 
+class TestContextSettingsHelpOptionNames:
+    @given(help_=sampled_from(["-h", "--help"]))
+    def test_main(self, *, help_: str) -> None:
+        @command(**CONTEXT_SETTINGS_HELP_OPTION_NAMES)
+        def cli() -> None: ...
+
+        result = CliRunner().invoke(cli, [help_])
+        assert result.exit_code == 0
+
+
 class TestFileAndDirPaths:
     def test_existing_dir_path(self, *, tmp_path: Path) -> None:
         @command()

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/src/tests/test_redis.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from asyncio import Queue, sleep
 from contextlib import asynccontextmanager
+from itertools import chain
 from re import search
 from typing import TYPE_CHECKING, Any
 
@@ -13,6 +14,7 @@ from hypothesis.strategies import (
     data,
     dictionaries,
     lists,
+    permutations,
     sampled_from,
 )
 from pytest import LogCaptureFixture, mark, param, raises
@@ -525,6 +527,38 @@ class TestSubscribe:
         for result, obj in zip(results, objs, strict=True):
             assert is_equal(result, obj)
 
+    @given(
+        channel=unique_strs(),
+        data=data(),
+        short_messages=lists(text_ascii(max_size=4), min_size=1, max_size=5),
+        long_messages=lists(text_ascii(min_size=6), min_size=1, max_size=5),
+    )
+    @settings_with_reduced_examples(phases={Phase.generate})
+    @SKIPIF_CI_AND_NOT_LINUX
+    async def test_filter(
+        self,
+        *,
+        channel: str,
+        data: DataObject,
+        short_messages: Sequence[str],
+        long_messages: Sequence[str],
+    ) -> None:
+        messages = data.draw(permutations(list(chain(short_messages, long_messages))))
+        queue: Queue[str] = Queue()
+        async with (
+            yield_redis() as redis,
+            subscribe(redis, channel, queue, filter_=lambda text: len(text) >= 6),
+        ):
+            await sleep(_PUB_SUB_SLEEP)
+            for message in messages:
+                await redis.publish(channel, message)
+            await sleep(_PUB_SUB_SLEEP)  # keep in context
+        assert queue.qsize() == len(long_messages)
+        results = get_items_nowait(queue)
+        for result in results:
+            assert isinstance(result, str)
+            assert len(result) >= 3
+
     @given(
         channel=unique_strs(),
         messages=lists(text_ascii(min_size=1), min_size=1, max_size=5),
@@ -577,26 +611,22 @@ class TestSubscribe:
 
 
 class TestSubscribeService:
-    @given(
-        channel=unique_strs(),
-        messages=lists(text_ascii(min_size=1), min_size=1, max_size=5),
-    )
+    @given(channel=unique_strs(), objects=lists(make_objects(), min_size=1, max_size=5))
     @settings_with_reduced_examples(phases={Phase.generate})
     @SKIPIF_CI_AND_NOT_LINUX
-    async def test_main(self, *, channel: str, messages: list[str]) -> None:
+    async def test_main(self, *, channel: str, objects: list[str]) -> None:
         async with (
             yield_redis() as redis,
             SubscribeService(timeout=1.0, redis=redis, channel=channel) as service,
         ):
             await sleep(_PUB_SUB_SLEEP)
-            for message in messages:
-                await redis.publish(channel, message)
+            for obj in objects:
+                await redis.publish(channel, serialize(obj))
             await sleep(_PUB_SUB_SLEEP)  # keep in context
-        assert service.qsize() == len(messages)
+        assert service.qsize() == len(objects)
         results = service.get_all_nowait()
-        for result, message in zip(results, messages, strict=True):
-            assert isinstance(result, str)
-            assert result == message
+        for result, obj in zip(results, objects, strict=True):
+            assert is_equal(result, obj)
 
     @given(channel=unique_strs())
     @settings(

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.126.5"
+__version__ = "0.126.7"

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/src/utilities/click.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import datetime as dt
 import pathlib
-from typing import TYPE_CHECKING, Generic, TypeVar, override
+from typing import TYPE_CHECKING, Generic, TypedDict, TypeVar, override
 from uuid import UUID
 
 import click
@@ -49,6 +49,19 @@ ExistingDirPath = click.Path(
 )
 
 
+class _HelpOptionNames(TypedDict):
+    help_option_names: Sequence[str]
+
+
+class _ContextSettings(TypedDict):
+    context_settings: _HelpOptionNames
+
+
+CONTEXT_SETTINGS_HELP_OPTION_NAMES = _ContextSettings(
+    context_settings=_HelpOptionNames(help_option_names=["-h", "--help"])
+)
+
+
 # parameters
 
 
@@ -480,6 +493,7 @@ def _make_metavar(param: Parameter, desc: str, /) -> str:
 
 
 __all__ = [
+    "CONTEXT_SETTINGS_HELP_OPTION_NAMES",
     "Date",
     "DirPath",
     "Duration",

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/src/utilities/hypothesis.py

@@ -24,6 +24,7 @@ from typing import (
     overload,
     override,
 )
+from uuid import uuid4
 
 from hypothesis import HealthCheck, Phase, Verbosity, assume, settings
 from hypothesis.errors import InvalidArgument
@@ -1415,9 +1416,10 @@ def unique_strs(draw: DrawFn, /) -> str:
     """Strategy for generating unique strings."""
     now = get_now_local()
     pid = getpid()
-    ident = get_ident()
-    key = str(draw(uuids())).replace("-", "")
-    return f"{now:%Y%m%d%H%M%S%f}_{pid}_{ident}_{key}"
+    ident = just(get_ident())
+    key = str(uuid4()).replace("-", "")
+    full = f"{now:%Y%m%d%H%M%S%f}_{pid}_{ident}_{key}"
+    return draw(just(full))
 
 
 ##

{dycw_utilities-0.126.5 → dycw_utilities-0.126.7}/src/utilities/redis.py

@@ -35,6 +35,7 @@ from utilities.datetime import (
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int, get_class_name, identity
 from utilities.iterables import always_iterable, one
+from utilities.orjson import deserialize, serialize
 
 if TYPE_CHECKING:
     from collections.abc import (
@@ -557,7 +558,7 @@ async def publish(
     data: _T,
     /,
     *,
-    serializer: Callable[[bytes | str | _T], EncodableT],
+    serializer: Callable[[_T], EncodableT],
     timeout: Duration = _PUBLISH_TIMEOUT,
 ) -> ResponseT: ...
 @overload
@@ -577,7 +578,7 @@ async def publish(
     data: bytes | str | _T,
     /,
     *,
-    serializer: Callable[[bytes | str | _T], EncodableT] | None = None,
+    serializer: Callable[[_T], EncodableT] | None = None,
     timeout: Duration = _PUBLISH_TIMEOUT,
 ) -> ResponseT: ...
 async def publish(
@@ -586,18 +587,19 @@ async def publish(
     data: bytes | str | _T,
     /,
     *,
-    serializer: Callable[[bytes | str | _T], EncodableT] | None = None,
+    serializer: Callable[[_T], EncodableT] | None = None,
     timeout: Duration = _PUBLISH_TIMEOUT,
 ) -> ResponseT:
     """Publish an object to a channel."""
-    if isinstance(data, bytes | str) and (  # skipif-ci-and-not-linux
-        serializer is None
-    ):
-        data_use = data
-    elif serializer is not None:  # skipif-ci-and-not-linux
-        data_use = serializer(data)
-    else:  # skipif-ci-and-not-linux
-        raise PublishError(data=data, serializer=serializer)
+    match data, serializer:  # skipif-ci-and-not-linux
+        case bytes() | str() as data_use, _:
+            ...
+        case _, None:
+            raise PublishError(data=data, serializer=serializer)
+        case _, Callable():
+            data_use = serializer(data)
+        case _ as never:
+            assert_never(never)
     async with timeout_dur(duration=timeout):  # skipif-ci-and-not-linux
         return await redis.publish(channel, data_use)  # skipif-ci-and-not-linux
 
@@ -654,7 +656,7 @@ class PublisherError(Exception):
 
 
 @dataclass(kw_only=True)
-class PublishService(Looper[tuple[str, bytes | str | _T]]):
+class PublishService(Looper[tuple[str, _T]]):
     """Service to publish items to Redis."""
 
     # base
@@ -663,7 +665,7 @@ class PublishService(Looper[tuple[str, bytes | str | _T]]):
     empty_upon_exit: bool = field(default=True, repr=False)
     # self
     redis: Redis
-    serializer: Callable[[Any], EncodableT] | None = None
+    serializer: Callable[[_T], EncodableT] = serialize
     publish_timeout: Duration = SECOND
 
     @override
@@ -698,6 +700,7 @@ def subscribe(
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
     output: Literal["raw"],
+    filter_: Callable[[_RedisMessage], bool] | None = None,
 ) -> AsyncIterator[Task[None]]: ...
 @overload
 @asynccontextmanager
@@ -710,6 +713,7 @@ def subscribe(
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
     output: Literal["bytes"],
+    filter_: Callable[[bytes], bool] | None = None,
 ) -> AsyncIterator[Task[None]]: ...
 @overload
 @asynccontextmanager
@@ -722,6 +726,7 @@ def subscribe(
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
     output: Literal["text"] = "text",
+    filter_: Callable[[str], bool] | None = None,
 ) -> AsyncIterator[Task[None]]: ...
 @overload
 @asynccontextmanager
@@ -734,6 +739,7 @@ def subscribe(
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
     output: Callable[[bytes], _T],
+    filter_: Callable[[_T], bool] | None = None,
 ) -> AsyncIterator[Task[None]]: ...
 @asynccontextmanager
 async def subscribe(
@@ -745,6 +751,7 @@ async def subscribe(
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
     output: Literal["raw", "bytes", "text"] | Callable[[bytes], _T] = "text",
+    filter_: Callable[[Any], bool] | None = None,
 ) -> AsyncIterator[Task[None]]:
     """Subscribe to the data of a given channel(s)."""
     channels = list(always_iterable(channels))  # skipif-ci-and-not-linux
@@ -767,7 +774,15 @@ async def subscribe(
             assert_never(never)
 
     task = create_task(  # skipif-ci-and-not-linux
-        _subscribe_core(redis, channels, transform, queue, timeout=timeout, sleep=sleep)
+        _subscribe_core(
+            redis,
+            channels,
+            transform,
+            queue,
+            timeout=timeout,
+            sleep=sleep,
+            filter_=filter_,
+        )
     )
     try:  # skipif-ci-and-not-linux
         yield task
@@ -786,6 +801,7 @@ async def _subscribe_core(
     *,
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
+    filter_: Callable[[Any], bool] | None = None,
 ) -> None:
     timeout_use = (  # skipif-ci-and-not-linux
         None if timeout is None else datetime_duration_to_float(timeout)
@@ -798,10 +814,12 @@ async def _subscribe_core(
         while True:
             message = await pubsub.get_message(timeout=timeout_use)
             if is_subscribe_message(message):
-                if isinstance(queue, EnhancedQueue):
-                    queue.put_right_nowait(transform(message))
-                else:
-                    queue.put_nowait(transform(message))
+                transformed = transform(message)
+                if (filter_ is None) or filter_(transformed):
+                    if isinstance(queue, EnhancedQueue):
+                        queue.put_right_nowait(transformed)
+                    else:
+                        queue.put_nowait(transformed)
             else:
                 await asyncio.sleep(sleep_use)
 
@@ -843,9 +861,10 @@ class SubscribeService(Looper[_T]):
     # self
     redis: Redis
     channel: str
-    deserializer: Callable[[bytes], _T] | None = None
-    subscribe_sleep: Duration = _SUBSCRIBE_SLEEP
+    deserializer: Callable[[bytes], _T] = deserialize
     subscribe_timeout: Duration | None = _SUBSCRIBE_TIMEOUT
+    subscribe_sleep: Duration = _SUBSCRIBE_SLEEP
+    filter_: Callable[[_T], bool] | None = None
     _is_subscribed: Event = field(default_factory=Event, init=False, repr=False)
 
     @override
@@ -864,12 +883,10 @@ class SubscribeService(Looper[_T]):
                         self.redis,
                         self.channel,
                         self._queue,
-                        sleep=self.subscribe_sleep,
                         timeout=self.subscribe_timeout,
-                        output=cast(
-                            "Any",
-                            "text" if self.deserializer is None else self.deserializer,
-                        ),
+                        sleep=self.subscribe_sleep,
+                        output=self.deserializer,
+                        filter_=self.filter_,
                     )
                 )
             case _ as never: