dycw-utilities 0.135.0__py3-none-any.whl → 0.178.1__py3-none-any.whl

utilities/redis.py

@@ -1,16 +1,15 @@
 from __future__ import annotations
 
-from asyncio import CancelledError, Event, Queue, Task, create_task
-from collections.abc import AsyncIterator, Callable, Mapping
-from contextlib import asynccontextmanager, suppress
-from dataclasses import dataclass, field
+from asyncio import CancelledError, Queue, Task, TaskGroup, create_task
+from collections.abc import AsyncIterator, Callable, Mapping, Sequence
+from contextlib import suppress
+from dataclasses import dataclass
 from functools import partial
 from operator import itemgetter
 from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Self,
     TypedDict,
     TypeGuard,
     assert_never,
@@ -21,35 +20,27 @@ from typing import (
 
 from redis.asyncio import Redis
 
-from utilities.asyncio import EnhancedQueue, Looper, sleep_td, timeout_td
-from utilities.contextlib import suppress_super_object_attribute_error
+from utilities.asyncio import sleep_td, timeout_td
+from utilities.contextlib import enhanced_async_context_manager
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int, identity
 from utilities.iterables import always_iterable, one
-from utilities.orjson import deserialize, serialize
-from utilities.whenever import MILLISECOND, SECOND
+from utilities.os import is_pytest
+from utilities.typing import is_instance_gen
+from utilities.whenever import MILLISECOND, SECOND, to_milliseconds, to_nanoseconds
 
 if TYPE_CHECKING:
-    from collections.abc import (
-        AsyncIterator,
-        Awaitable,
-        Collection,
-        Iterable,
-        Iterator,
-        Sequence,
-    )
-    from types import TracebackType
+    from collections.abc import AsyncIterator, Awaitable, Collection, Iterable
 
     from redis.asyncio import ConnectionPool
     from redis.asyncio.client import PubSub
-    from redis.typing import EncodableT, ResponseT
-    from whenever import TimeDelta
+    from redis.typing import EncodableT
 
     from utilities.iterables import MaybeIterable
-    from utilities.types import MaybeType, TypeLike
+    from utilities.types import Delta, MaybeSequence, MaybeType, TypeLike
 
 
-_PUBLISH_TIMEOUT: TimeDelta = SECOND
+_PUBLISH_TIMEOUT: Delta = SECOND
 
 
 ##
@@ -66,9 +57,9 @@ class RedisHashMapKey[K, V]:
     value: TypeLike[V]
     value_serializer: Callable[[V], bytes] | None = None
     value_deserializer: Callable[[bytes], V] | None = None
-    timeout: TimeDelta | None = None
+    timeout: Delta | None = None
     error: MaybeType[BaseException] = TimeoutError
-    ttl: TimeDelta | None = None
+    ttl: Delta | None = None
 
     async def delete(self, redis: Redis, key: K, /) -> int:
         """Delete a key from a hashmap in `redis`."""
@@ -172,7 +163,7 @@ class RedisHashMapKey[K, V]:
                 "Awaitable[int]", redis.hset(self.name, mapping=cast("Any", ser))
             )
             if self.ttl is not None:
-                await redis.pexpire(self.name, self.ttl.py_timedelta())
+                await redis.pexpire(self.name, to_milliseconds(self.ttl))
         return result  # skipif-ci-and-not-linux
 
     async def values(self, redis: Redis, /) -> Sequence[V]:
@@ -197,9 +188,9 @@ def redis_hash_map_key[K, V](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V], bytes] | None = None,
     value_deserializer: Callable[[bytes], V] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K, V]: ...
 @overload
 def redis_hash_map_key[K, V1, V2](
@@ -212,9 +203,9 @@ def redis_hash_map_key[K, V1, V2](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K, V1 | V2]: ...
 @overload
 def redis_hash_map_key[K, V1, V2, V3](
@@ -227,9 +218,9 @@ def redis_hash_map_key[K, V1, V2, V3](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2 | V3] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K, V1 | V2 | V3]: ...
 @overload
 def redis_hash_map_key[K1, K2, V](
@@ -242,9 +233,9 @@ def redis_hash_map_key[K1, K2, V](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V], bytes] | None = None,
     value_deserializer: Callable[[bytes], V] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K1 | K2, V]: ...
 @overload
 def redis_hash_map_key[K1, K2, V1, V2](
@@ -257,9 +248,9 @@ def redis_hash_map_key[K1, K2, V1, V2](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K1 | K2, V1 | V2]: ...
 @overload
 def redis_hash_map_key[K1, K2, V1, V2, V3](
@@ -272,9 +263,9 @@ def redis_hash_map_key[K1, K2, V1, V2, V3](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2 | V3] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K1 | K2, V1 | V2 | V3]: ...
 @overload
 def redis_hash_map_key[K1, K2, K3, V](
@@ -287,9 +278,9 @@ def redis_hash_map_key[K1, K2, K3, V](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V], bytes] | None = None,
     value_deserializer: Callable[[bytes], V] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K1 | K2 | K3, V]: ...
 @overload
 def redis_hash_map_key[K1, K2, K3, V1, V2](
@@ -302,9 +293,9 @@ def redis_hash_map_key[K1, K2, K3, V1, V2](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K1 | K2 | K3, V1 | V2]: ...
 @overload
 def redis_hash_map_key[K1, K2, K3, V1, V2, V3](
@@ -317,9 +308,9 @@ def redis_hash_map_key[K1, K2, K3, V1, V2, V3](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2 | V3] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K1 | K2 | K3, V1 | V2 | V3]: ...
 @overload
 def redis_hash_map_key[K, K1, K2, K3, V, V1, V2, V3](
@@ -332,9 +323,9 @@ def redis_hash_map_key[K, K1, K2, K3, V, V1, V2, V3](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
     value_deserializer: Callable[[bytes], V1 | V2 | V3] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisHashMapKey[K, V]: ...
 def redis_hash_map_key[K, V](
     name: str,
@@ -346,9 +337,9 @@ def redis_hash_map_key[K, V](
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[Any], bytes] | None = None,
     value_deserializer: Callable[[bytes], Any] | None = None,
-    timeout: TimeDelta | None = None,
-    ttl: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
+    timeout: Delta | None = None,
+    ttl: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
 ) -> RedisHashMapKey[K, V]:
     """Create a redis key."""
     return RedisHashMapKey(  # skipif-ci-and-not-linux
@@ -376,16 +367,17 @@ class RedisKey[T]:
     type: TypeLike[T]
     serializer: Callable[[T], bytes] | None = None
     deserializer: Callable[[bytes], T] | None = None
-    timeout: TimeDelta | None = None
+    timeout: Delta | None = None
     error: MaybeType[BaseException] = TimeoutError
-    ttl: TimeDelta | None = None
+    ttl: Delta | None = None
 
     async def delete(self, redis: Redis, /) -> int:
         """Delete the key from `redis`."""
         async with timeout_td(  # skipif-ci-and-not-linux
             self.timeout, error=self.error
         ):
-            return ensure_int(await redis.delete(self.name))
+            response = await redis.delete(self.name)
+        return ensure_int(response)
 
     async def exists(self, redis: Redis, /) -> bool:
         """Check if the key exists in `redis`."""
@@ -396,7 +388,7 @@ class RedisKey[T]:
         match result:  # skipif-ci-and-not-linux
             case 0 | 1 as value:
                 return bool(value)
-            case _ as never:
+            case never:
                 assert_never(never)
 
     async def get(self, redis: Redis, /) -> T:
@@ -415,15 +407,15 @@ class RedisKey[T]:
         """Set a value in `redis`."""
         ser = _serialize(value, serializer=self.serializer)  # skipif-ci-and-not-linux
         ttl = (  # skipif-ci-and-not-linux
-            None if self.ttl is None else round(self.ttl.in_milliseconds())
+            None if self.ttl is None else to_milliseconds(self.ttl)
         )
         async with timeout_td(  # skipif-ci-and-not-linux
             self.timeout, error=self.error
         ):
-            result = await redis.set(  # skipif-ci-and-not-linux
+            response = await redis.set(  # skipif-ci-and-not-linux
                 self.name, ser, px=ttl
             )
-        return ensure_int(result)  # skipif-ci-and-not-linux
+        return ensure_int(response)  # skipif-ci-and-not-linux
 
 
 @overload
@@ -434,9 +426,9 @@ def redis_key[T](
     *,
     serializer: Callable[[T], bytes] | None = None,
     deserializer: Callable[[bytes], T] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T]: ...
 @overload
 def redis_key[T1, T2](
@@ -446,9 +438,9 @@ def redis_key[T1, T2](
     *,
     serializer: Callable[[T1 | T2], bytes] | None = None,
     deserializer: Callable[[bytes], T1 | T2] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T1 | T2]: ...
 @overload
 def redis_key[T1, T2, T3](
@@ -458,9 +450,9 @@ def redis_key[T1, T2, T3](
     *,
     serializer: Callable[[T1 | T2 | T3], bytes] | None = None,
     deserializer: Callable[[bytes], T1 | T2 | T3] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T1 | T2 | T3]: ...
 @overload
 def redis_key[T1, T2, T3, T4](
@@ -470,9 +462,9 @@ def redis_key[T1, T2, T3, T4](
     *,
     serializer: Callable[[T1 | T2 | T3 | T4], bytes] | None = None,
     deserializer: Callable[[bytes], T1 | T2 | T3 | T4] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T1 | T2 | T3 | T4]: ...
 @overload
 def redis_key[T1, T2, T3, T4, T5](
@@ -482,9 +474,9 @@ def redis_key[T1, T2, T3, T4, T5](
     *,
     serializer: Callable[[T1 | T2 | T3 | T4 | T5], bytes] | None = None,
     deserializer: Callable[[bytes], T1 | T2 | T3 | T4 | T5] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T1 | T2 | T3 | T4 | T5]: ...
 @overload
 def redis_key[T, T1, T2, T3, T4, T5](
@@ -494,9 +486,9 @@ def redis_key[T, T1, T2, T3, T4, T5](
     *,
     serializer: Callable[[T1 | T2 | T3 | T4 | T5], bytes] | None = None,
     deserializer: Callable[[bytes], T1 | T2 | T3 | T4 | T5] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T]: ...
 def redis_key[T](
     name: str,
@@ -505,9 +497,9 @@ def redis_key[T](
     *,
     serializer: Callable[[Any], bytes] | None = None,
     deserializer: Callable[[bytes], Any] | None = None,
-    timeout: TimeDelta | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: TimeDelta | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
 ) -> RedisKey[T]:
     """Create a redis key."""
     return RedisKey(  # skipif-ci-and-not-linux
@@ -532,8 +524,8 @@ async def publish[T](
     /,
     *,
     serializer: Callable[[T], EncodableT],
-    timeout: TimeDelta = _PUBLISH_TIMEOUT,
-) -> ResponseT: ...
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int: ...
 @overload
 async def publish(
     redis: Redis,
@@ -542,8 +534,8 @@ async def publish(
     /,
     *,
     serializer: None = None,
-    timeout: TimeDelta = _PUBLISH_TIMEOUT,
-) -> ResponseT: ...
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int: ...
 @overload
 async def publish[T](
     redis: Redis,
@@ -552,8 +544,8 @@ async def publish[T](
     /,
     *,
     serializer: Callable[[T], EncodableT] | None = None,
-    timeout: TimeDelta = _PUBLISH_TIMEOUT,
-) -> ResponseT: ...
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int: ...
 async def publish[T](
     redis: Redis,
     channel: str,
@@ -561,198 +553,173 @@ async def publish[T](
     /,
     *,
     serializer: Callable[[T], EncodableT] | None = None,
-    timeout: TimeDelta = _PUBLISH_TIMEOUT,
-) -> ResponseT:
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int:
     """Publish an object to a channel."""
     match data, serializer:  # skipif-ci-and-not-linux
         case bytes() | str() as data_use, _:
             ...
         case _, None:
-            raise PublishError(data=data, serializer=serializer)
+            raise PublishError(data=data)
         case _, Callable():
             data_use = serializer(data)
-        case _ as never:
+        case never:
             assert_never(never)
     async with timeout_td(timeout):  # skipif-ci-and-not-linux
-        return await redis.publish(channel, data_use)  # skipif-ci-and-not-linux
+        response = await redis.publish(channel, data_use)  # skipif-ci-and-not-linux
+    return ensure_int(response)  # skipif-ci-and-not-linux
 
 
 @dataclass(kw_only=True, slots=True)
 class PublishError(Exception):
     data: Any
-    serializer: Callable[[Any], EncodableT] | None = None
 
     @override
     def __str__(self) -> str:
-        return (
-            f"Unable to publish data {self.data!r} with serializer {self.serializer!r}"
-        )
+        return f"Unable to publish data {self.data!r} with no serializer"
 
 
 ##
 
 
-@dataclass(kw_only=True)
-class PublishService[T](Looper[tuple[str, T]]):
-    """Service to publish items to Redis."""
-
-    # base
-    freq: TimeDelta = field(default=MILLISECOND, repr=False)
-    backoff: TimeDelta = field(default=SECOND, repr=False)
-    empty_upon_exit: bool = field(default=True, repr=False)
-    # self
-    redis: Redis
-    serializer: Callable[[T], EncodableT] = serialize
-    publish_timeout: TimeDelta = _PUBLISH_TIMEOUT
-
-    @override
-    async def core(self) -> None:
-        await super().core()  # skipif-ci-and-not-linux
-        while not self.empty():  # skipif-ci-and-not-linux
-            channel, data = self.get_left_nowait()
-            _ = await publish(
-                self.redis,
-                channel,
-                data,
-                serializer=self.serializer,
-                timeout=self.publish_timeout,
+async def publish_many[T](
+    redis: Redis,
+    channel: str,
+    data: MaybeSequence[bytes | str | T],
+    /,
+    *,
+    serializer: Callable[[T], EncodableT] | None = None,
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> Sequence[bool]:
+    """Publish an object/multiple objects to a channel."""
+    async with TaskGroup() as tg:
+        tasks = [
+            tg.create_task(
+                _try_publish(
+                    redis,
+                    channel,
+                    d,
+                    serializer=cast("Callable[[Any], EncodableT]", serializer),
+                    timeout=timeout,
+                )
             )
+            for d in always_iterable(data)
+        ]
+    return [t.result() for t in tasks]
 
 
-##
-
-
-@dataclass(kw_only=True)
-class PublishServiceMixin[T]:
-    """Mix-in for the publish service."""
-
-    # base - looper
-    publish_service_freq: TimeDelta = field(default=MILLISECOND, repr=False)
-    publish_service_backoff: TimeDelta = field(default=SECOND, repr=False)
-    publish_service_empty_upon_exit: bool = field(default=False, repr=False)
-    publish_service_logger: str | None = field(default=None, repr=False)
-    publish_service_timeout: TimeDelta | None = field(default=None, repr=False)
-    publish_service_debug: bool = field(default=False, repr=False)
-    _is_pending_restart: Event = field(default_factory=Event, init=False, repr=False)
-    # base - publish service
-    publish_service_redis: Redis
-    publish_service_serializer: Callable[[T], EncodableT] = serialize
-    publish_service_publish_timeout: TimeDelta = _PUBLISH_TIMEOUT
-    # self
-    _publish_service: PublishService[T] = field(init=False, repr=False)
-
-    def __post_init__(self) -> None:
-        with suppress_super_object_attribute_error():  # skipif-ci-and-not-linux
-            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
-        self._publish_service = PublishService(  # skipif-ci-and-not-linux
-            # looper
-            freq=self.publish_service_freq,
-            backoff=self.publish_service_backoff,
-            empty_upon_exit=self.publish_service_empty_upon_exit,
-            logger=self.publish_service_logger,
-            timeout=self.publish_service_timeout,
-            _debug=self.publish_service_debug,
-            # publish service
-            redis=self.publish_service_redis,
-            serializer=self.publish_service_serializer,
-            publish_timeout=self.publish_service_publish_timeout,
-        )
-
-    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
-        with suppress_super_object_attribute_error():  # skipif-ci-and-not-linux
-            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
-        yield self._publish_service  # skipif-ci-and-not-linux
+async def _try_publish[T](
+    redis: Redis,
+    channel: str,
+    data: bytes | str | T,
+    /,
+    *,
+    serializer: Callable[[T], EncodableT] | None = None,
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> bool:
+    try:
+        _ = await publish(redis, channel, data, serializer=serializer, timeout=timeout)
+    except TimeoutError:
+        return False
+    return True
 
 
 ##
 
 
-_SUBSCRIBE_TIMEOUT: TimeDelta = SECOND
-_SUBSCRIBE_SLEEP: TimeDelta = MILLISECOND
+_SUBSCRIBE_TIMEOUT: Delta = SECOND
+_SUBSCRIBE_SLEEP: Delta = MILLISECOND
 
 
 @overload
-@asynccontextmanager
+@enhanced_async_context_manager
 def subscribe(
     redis: Redis,
     channels: MaybeIterable[str],
     queue: Queue[_RedisMessage],
     /,
     *,
-    timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT,
-    sleep: TimeDelta = _SUBSCRIBE_SLEEP,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
     output: Literal["raw"],
-    filter_: Callable[[_RedisMessage], bool] | None = None,
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
+    filter_: Callable[[bytes], bool] | None = None,
+    error_filter: Callable[[bytes, Exception], None] | None = None,
+    sleep: Delta = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[Task[None]]: ...
 @overload
-@asynccontextmanager
+@enhanced_async_context_manager
 def subscribe(
     redis: Redis,
     channels: MaybeIterable[str],
     queue: Queue[bytes],
     /,
     *,
-    timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT,
-    sleep: TimeDelta = _SUBSCRIBE_SLEEP,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
     output: Literal["bytes"],
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
     filter_: Callable[[bytes], bool] | None = None,
+    error_filter: Callable[[bytes, Exception], None] | None = None,
+    sleep: Delta = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[Task[None]]: ...
 @overload
-@asynccontextmanager
+@enhanced_async_context_manager
 def subscribe(
     redis: Redis,
     channels: MaybeIterable[str],
     queue: Queue[str],
     /,
     *,
-    timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT,
-    sleep: TimeDelta = _SUBSCRIBE_SLEEP,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
     output: Literal["text"] = "text",
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
     filter_: Callable[[str], bool] | None = None,
+    error_filter: Callable[[str, Exception], None] | None = None,
+    sleep: Delta = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[Task[None]]: ...
 @overload
-@asynccontextmanager
+@enhanced_async_context_manager
 def subscribe[T](
     redis: Redis,
     channels: MaybeIterable[str],
     queue: Queue[T],
     /,
     *,
-    timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT,
-    sleep: TimeDelta = _SUBSCRIBE_SLEEP,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
     output: Callable[[bytes], T],
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
     filter_: Callable[[T], bool] | None = None,
+    error_filter: Callable[[T, Exception], None] | None = None,
+    sleep: Delta = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[Task[None]]: ...
-@asynccontextmanager
+@enhanced_async_context_manager
 async def subscribe[T](
     redis: Redis,
     channels: MaybeIterable[str],
     queue: Queue[_RedisMessage] | Queue[bytes] | Queue[T],
     /,
     *,
-    timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT,
-    sleep: TimeDelta = _SUBSCRIBE_SLEEP,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
     output: Literal["raw", "bytes", "text"] | Callable[[bytes], T] = "text",
-    filter_: Callable[[Any], bool] | None = None,
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
+    filter_: Callable[[T], bool] | None = None,
+    error_filter: Callable[[T, Exception], None] | None = None,
+    sleep: Delta = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[Task[None]]:
     """Subscribe to the data of a given channel(s)."""
     channels = list(always_iterable(channels))  # skipif-ci-and-not-linux
     match output:  # skipif-ci-and-not-linux
         case "raw":
-            transform = cast("Any", identity)
+            transform = cast("Callable[[_RedisMessage], T]", identity)
         case "bytes":
-            transform = cast("Any", itemgetter("data"))
+            transform = cast("Callable[[_RedisMessage], T]", itemgetter("data"))
         case "text":
-
-            def transform(message: _RedisMessage, /) -> str:  # pyright: ignore[reportRedeclaration]
-                return message["data"].decode()
-
+            transform = cast("Callable[[_RedisMessage], T]", _decoded_data)
         case Callable() as deserialize:
 
             def transform(message: _RedisMessage, /) -> T:
                 return deserialize(message["data"])
 
-        case _ as never:
+        case never:
             assert_never(never)
 
     task = create_task(  # skipif-ci-and-not-linux
@@ -762,31 +729,43 @@ async def subscribe[T](
             transform,
             queue,
             timeout=timeout,
-            sleep=sleep,
+            error_transform=error_transform,
             filter_=filter_,
+            error_filter=error_filter,
+            sleep=sleep,
         )
     )
     try:  # skipif-ci-and-not-linux
         yield task
     finally:  # skipif-ci-and-not-linux
-        _ = task.cancel()
+        try:
+            _ = task.cancel()
+        except RuntimeError as error:  # pragma: no cover
+            if (not is_pytest()) or (error.args[0] != "Event loop is closed"):
+                raise
         with suppress(CancelledError):
             await task
 
 
-async def _subscribe_core(
+def _decoded_data(message: _RedisMessage, /) -> str:
+    return message["data"].decode()
+
+
+async def _subscribe_core[T](
     redis: Redis,
     channels: MaybeIterable[str],
-    transform: Callable[[_RedisMessage], Any],
+    transform: Callable[[_RedisMessage], T],
     queue: Queue[Any],
     /,
     *,
-    timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT,
-    sleep: TimeDelta = _SUBSCRIBE_SLEEP,
-    filter_: Callable[[Any], bool] | None = None,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
+    filter_: Callable[[T], bool] | None = None,
+    error_filter: Callable[[T, Exception], None] | None = None,
+    sleep: Delta = _SUBSCRIBE_SLEEP,
 ) -> None:
     timeout_use = (  # skipif-ci-and-not-linux
-        None if timeout is None else timeout.in_seconds()
+        None if timeout is None else (to_nanoseconds(timeout) / 1e9)
     )
     is_subscribe_message = partial(  # skipif-ci-and-not-linux
         _is_message, channels={c.encode() for c in channels}
@@ -795,12 +774,14 @@ async def _subscribe_core(
         while True:
             message = await pubsub.get_message(timeout=timeout_use)
             if is_subscribe_message(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)
+                _handle_message(
+                    message,
+                    transform,
+                    queue,
+                    error_transform=error_transform,
+                    filter_=filter_,
+                    error_filter=error_filter,
+                )
             else:
                 await sleep_td(sleep)
 
@@ -808,17 +789,34 @@ async def _subscribe_core(
 def _is_message(
     message: Any, /, *, channels: Collection[bytes]
 ) -> TypeGuard[_RedisMessage]:
-    return (
-        isinstance(message, Mapping)
-        and ("type" in message)
-        and (message["type"] in {"subscribe", "psubscribe", "message", "pmessage"})
-        and ("pattern" in message)
-        and ((message["pattern"] is None) or isinstance(message["pattern"], str))
-        and ("channel" in message)
-        and (message["channel"] in channels)
-        and ("data" in message)
-        and isinstance(message["data"], bytes)
-    )
+    return is_instance_gen(message, _RedisMessage) and (message["channel"] in channels)
+
+
+def _handle_message[T](
+    message: _RedisMessage,
+    transform: Callable[[_RedisMessage], T],
+    queue: Queue[Any],
+    /,
+    *,
+    error_transform: Callable[[_RedisMessage, Exception], None] | None = None,
+    filter_: Callable[[T], bool] | None = None,
+    error_filter: Callable[[T, Exception], None] | None = None,
+) -> None:
+    try:
+        transformed = transform(message)
+    except Exception as error:  # noqa: BLE001
+        if error_transform is not None:
+            error_transform(message, error)
+        return
+    if filter_ is None:
+        queue.put_nowait(transformed)
+        return
+    try:
+        if filter_(transformed):
+            queue.put_nowait(transformed)
+    except Exception as error:  # noqa: BLE001
+        if error_filter is not None:
+            error_filter(transformed, error)
 
 
 class _RedisMessage(TypedDict):
@@ -831,125 +829,7 @@ class _RedisMessage(TypedDict):
 ##
 
 
-@dataclass(kw_only=True)
-class SubscribeService[T](Looper[T]):
-    """Service to subscribe to Redis."""
-
-    # base
-    freq: TimeDelta = field(default=MILLISECOND, repr=False)
-    backoff: TimeDelta = field(default=SECOND, repr=False)
-    logger: str | None = field(default=__name__, repr=False)
-    # self
-    redis: Redis
-    channel: str
-    deserializer: Callable[[bytes], T] = deserialize
-    subscribe_timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT
-    subscribe_sleep: TimeDelta = _SUBSCRIBE_SLEEP
-    filter_: Callable[[T], bool] | None = None
-    _is_subscribed: Event = field(default_factory=Event, init=False, repr=False)
-
-    @override
-    async def __aenter__(self) -> Self:
-        _ = await super().__aenter__()  # skipif-ci-and-not-linux
-        match self._is_subscribed.is_set():  # skipif-ci-and-not-linux
-            case True:
-                _ = self._debug and self._logger.debug("%s: already subscribing", self)
-            case False:
-                _ = self._debug and self._logger.debug(
-                    "%s: starting subscription...", self
-                )
-                self._is_subscribed.set()
-                _ = await self._stack.enter_async_context(
-                    subscribe(
-                        self.redis,
-                        self.channel,
-                        self._queue,
-                        timeout=self.subscribe_timeout,
-                        sleep=self.subscribe_sleep,
-                        output=self.deserializer,
-                        filter_=self.filter_,
-                    )
-                )
-            case _ as never:
-                assert_never(never)
-        return self  # skipif-ci-and-not-linux
-
-    @override
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None = None,
-        exc_value: BaseException | None = None,
-        traceback: TracebackType | None = None,
-    ) -> None:
-        await super().__aexit__(  # skipif-ci-and-not-linux
-            exc_type=exc_type, exc_value=exc_value, traceback=traceback
-        )
-        match self._is_subscribed.is_set():  # skipif-ci-and-not-linux
-            case True:
-                _ = self._debug and self._logger.debug(
-                    "%s: stopping subscription...", self
-                )
-                self._is_subscribed.clear()
-            case False:
-                _ = self._debug and self._logger.debug(
-                    "%s: already stopped subscription", self
-                )
-            case _ as never:
-                assert_never(never)
-
-
-##
-
-
-@dataclass(kw_only=True)
-class SubscribeServiceMixin[T]:
-    """Mix-in for the subscribe service."""
-
-    # base - looper
-    subscribe_service_freq: TimeDelta = field(default=MILLISECOND, repr=False)
-    subscribe_service_backoff: TimeDelta = field(default=SECOND, repr=False)
-    subscribe_service_empty_upon_exit: bool = field(default=False, repr=False)
-    subscribe_service_logger: str | None = field(default=None, repr=False)
-    subscribe_service_timeout: TimeDelta | None = field(default=None, repr=False)
-    subscribe_service_debug: bool = field(default=False, repr=False)
-    # base - looper
-    subscribe_service_redis: Redis
-    subscribe_service_channel: str
-    subscribe_service_deserializer: Callable[[bytes], T] = deserialize
-    subscribe_service_subscribe_sleep: TimeDelta = _SUBSCRIBE_SLEEP
-    subscribe_service_subscribe_timeout: TimeDelta | None = _SUBSCRIBE_TIMEOUT
-    # self
-    _subscribe_service: SubscribeService[T] = field(init=False, repr=False)
-
-    def __post_init__(self) -> None:
-        with suppress_super_object_attribute_error():  # skipif-ci-and-not-linux
-            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
-        self._subscribe_service = SubscribeService(  # skipif-ci-and-not-linux
-            # looper
-            freq=self.subscribe_service_freq,
-            backoff=self.subscribe_service_backoff,
-            empty_upon_exit=self.subscribe_service_empty_upon_exit,
-            logger=self.subscribe_service_logger,
-            timeout=self.subscribe_service_timeout,
-            _debug=self.subscribe_service_debug,
-            # subscribe service
-            redis=self.subscribe_service_redis,
-            channel=self.subscribe_service_channel,
-            deserializer=self.subscribe_service_deserializer,
-            subscribe_sleep=self.subscribe_service_subscribe_sleep,
-            subscribe_timeout=self.subscribe_service_subscribe_timeout,
-        )
-
-    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
-        with suppress_super_object_attribute_error():  # skipif-ci-and-not-linux
-            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
-        yield self._subscribe_service  # skipif-ci-and-not-linux
-
-
-##
-
-
-@asynccontextmanager
+@enhanced_async_context_manager
 async def yield_pubsub(
     redis: Redis, channels: MaybeIterable[str], /
 ) -> AsyncIterator[PubSub]:
@@ -971,7 +851,7 @@ _HOST = "localhost"
 _PORT = 6379
 
 
-@asynccontextmanager
+@enhanced_async_context_manager
 async def yield_redis(
     *,
     host: str = _HOST,
@@ -1030,13 +910,10 @@ def _deserialize[T](
 
 
 __all__ = [
-    "PublishService",
-    "PublishServiceMixin",
     "RedisHashMapKey",
     "RedisKey",
-    "SubscribeService",
-    "SubscribeServiceMixin",
     "publish",
+    "publish_many",
     "redis_hash_map_key",
     "redis_key",
     "subscribe",