dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/redis.py

@@ -1,21 +1,17 @@
 from __future__ import annotations
 
-import asyncio
-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,
-    Generic,
     Literal,
-    Self,
     TypedDict,
     TypeGuard,
-    TypeVar,
     assert_never,
     cast,
     overload,
@@ -24,107 +20,79 @@ from typing import (
 
 from redis.asyncio import Redis
 
-from utilities.asyncio import EnhancedQueue, Looper, timeout_dur
-from utilities.contextlib import suppress_super_object_attribute_error
-from utilities.datetime import (
-    MILLISECOND,
-    SECOND,
-    datetime_duration_to_float,
-    datetime_duration_to_timedelta,
-)
+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.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 redis.typing import EncodableT
 
     from utilities.iterables import MaybeIterable
-    from utilities.types import Duration, TypeLike
-
+    from utilities.types import Delta, MaybeSequence, MaybeType, TypeLike
 
-_K = TypeVar("_K")
-_K1 = TypeVar("_K1")
-_K2 = TypeVar("_K2")
-_K3 = TypeVar("_K3")
-_T = TypeVar("_T")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
-_V = TypeVar("_V")
-_V1 = TypeVar("_V1")
-_V2 = TypeVar("_V2")
-_V3 = TypeVar("_V3")
 
-
-_PUBLISH_TIMEOUT: Duration = SECOND
+_PUBLISH_TIMEOUT: Delta = SECOND
 
 
 ##
 
 
 @dataclass(kw_only=True)
-class RedisHashMapKey(Generic[_K, _V]):
+class RedisHashMapKey[K, V]:
     """A hashmap key in a redis store."""
 
     name: str
-    key: TypeLike[_K]
-    key_serializer: Callable[[_K], bytes] | None = None
-    key_deserializer: Callable[[bytes], _K] | None = None
-    value: TypeLike[_V]
-    value_serializer: Callable[[_V], bytes] | None = None
-    value_deserializer: Callable[[bytes], _V] | None = None
-    timeout: Duration | None = None
-    error: type[Exception] = TimeoutError
-    ttl: Duration | None = None
-
-    async def delete(self, redis: Redis, key: _K, /) -> int:
+    key: TypeLike[K]
+    key_serializer: Callable[[K], bytes] | None = None
+    key_deserializer: Callable[[bytes], K] | None = None
+    value: TypeLike[V]
+    value_serializer: Callable[[V], bytes] | None = None
+    value_deserializer: Callable[[bytes], V] | None = None
+    timeout: Delta | None = None
+    error: MaybeType[BaseException] = TimeoutError
+    ttl: Delta | None = None
+
+    async def delete(self, redis: Redis, key: K, /) -> int:
         """Delete a key from a hashmap in `redis`."""
         ser = _serialize(  # skipif-ci-and-not-linux
             key, serializer=self.key_serializer
         ).decode()
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             return await cast("Awaitable[int]", redis.hdel(self.name, ser))
         raise ImpossibleCaseError(case=[f"{redis=}", f"{key=}"])  # pragma: no cover
 
-    async def exists(self, redis: Redis, key: _K, /) -> bool:
+    async def exists(self, redis: Redis, key: K, /) -> bool:
         """Check if the key exists in a hashmap in `redis`."""
         ser = _serialize(  # skipif-ci-and-not-linux
             key, serializer=self.key_serializer
         ).decode()
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             return await cast("Awaitable[bool]", redis.hexists(self.name, ser))
 
-    async def get(self, redis: Redis, key: _K, /) -> _V:
+    async def get(self, redis: Redis, key: K, /) -> V:
         """Get a value from a hashmap in `redis`."""
         result = one(await self.get_many(redis, [key]))  # skipif-ci-and-not-linux
         if result is None:  # skipif-ci-and-not-linux
             raise KeyError(self.name, key)
         return result  # skipif-ci-and-not-linux
 
-    async def get_all(self, redis: Redis, /) -> Mapping[_K, _V]:
+    async def get_all(self, redis: Redis, /) -> Mapping[K, V]:
         """Get a value from a hashmap in `redis`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = await cast(  # skipif-ci-and-not-linux
                 "Awaitable[Mapping[bytes, bytes]]", redis.hgetall(self.name)
@@ -136,9 +104,7 @@ class RedisHashMapKey(Generic[_K, _V]):
             for key, value in result.items()
         }
 
-    async def get_many(
-        self, redis: Redis, keys: Iterable[_K], /
-    ) -> Sequence[_V | None]:
+    async def get_many(self, redis: Redis, keys: Iterable[K], /) -> Sequence[V | None]:
         """Get multiple values from a hashmap in `redis`."""
         keys = list(keys)  # skipif-ci-and-not-linux
         if len(keys) == 0:  # skipif-ci-and-not-linux
@@ -146,8 +112,8 @@ class RedisHashMapKey(Generic[_K, _V]):
         ser = [  # skipif-ci-and-not-linux
             _serialize(key, serializer=self.key_serializer) for key in keys
         ]
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = await cast(  # skipif-ci-and-not-linux
                 "Awaitable[Sequence[bytes | None]]", redis.hmget(self.name, ser)
@@ -159,10 +125,10 @@ class RedisHashMapKey(Generic[_K, _V]):
             for data in result
         ]
 
-    async def keys(self, redis: Redis, /) -> Sequence[_K]:
+    async def keys(self, redis: Redis, /) -> Sequence[K]:
         """Get the keys of a hashmap in `redis`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = await cast("Awaitable[Sequence[bytes]]", redis.hkeys(self.name))
         return [  # skipif-ci-and-not-linux
@@ -171,16 +137,16 @@ class RedisHashMapKey(Generic[_K, _V]):
 
     async def length(self, redis: Redis, /) -> int:
         """Get the length of a hashmap in `redis`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             return await cast("Awaitable[int]", redis.hlen(self.name))
 
-    async def set(self, redis: Redis, key: _K, value: _V, /) -> int:
+    async def set(self, redis: Redis, key: K, value: V, /) -> int:
         """Set a value in a hashmap in `redis`."""
         return await self.set_many(redis, {key: value})  # skipif-ci-and-not-linux
 
-    async def set_many(self, redis: Redis, mapping: Mapping[_K, _V], /) -> int:
+    async def set_many(self, redis: Redis, mapping: Mapping[K, V], /) -> int:
         """Set multiple value(s) in a hashmap in `redis`."""
         if len(mapping) == 0:  # skipif-ci-and-not-linux
             return 0
@@ -190,20 +156,20 @@ class RedisHashMapKey(Generic[_K, _V]):
             )
             for key, value in mapping.items()
         }
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = await cast(
                 "Awaitable[int]", redis.hset(self.name, mapping=cast("Any", ser))
             )
             if self.ttl is not None:
-                await redis.pexpire(self.name, datetime_duration_to_timedelta(self.ttl))
+                await redis.pexpire(self.name, to_milliseconds(self.ttl))
         return result  # skipif-ci-and-not-linux
 
-    async def values(self, redis: Redis, /) -> Sequence[_V]:
+    async def values(self, redis: Redis, /) -> Sequence[V]:
         """Get the values of a hashmap in `redis`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = await cast("Awaitable[Sequence[bytes]]", redis.hvals(self.name))
         return [  # skipif-ci-and-not-linux
@@ -212,169 +178,169 @@ class RedisHashMapKey(Generic[_K, _V]):
 
 
 @overload
-def redis_hash_map_key(
+def redis_hash_map_key[K, V](
     name: str,
-    key: type[_K],
-    value: type[_V],
+    key: type[K],
+    value: type[V],
     /,
     *,
-    key_serializer: Callable[[_K], bytes] | None = None,
+    key_serializer: Callable[[K], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
-    value_serializer: Callable[[_V], bytes] | None = None,
-    value_deserializer: Callable[[bytes], _V] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K, _V]: ...
+    value_serializer: Callable[[V], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisHashMapKey[K, V]: ...
 @overload
-def redis_hash_map_key(
+def redis_hash_map_key[K, V1, V2](
     name: str,
-    key: type[_K],
-    value: tuple[type[_V1], type[_V2]],
+    key: type[K],
+    value: tuple[type[V1], type[V2]],
     /,
     *,
-    key_serializer: Callable[[_K], bytes] | None = None,
+    key_serializer: Callable[[K], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
-    value_serializer: Callable[[_V1 | _V2], bytes] | None = None,
-    value_deserializer: Callable[[bytes], _V1 | _V2] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K, _V1 | _V2]: ...
+    value_serializer: Callable[[V1 | V2], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisHashMapKey[K, V1 | V2]: ...
 @overload
-def redis_hash_map_key(
+def redis_hash_map_key[K, V1, V2, V3](
     name: str,
-    key: type[_K],
-    value: tuple[type[_V1], type[_V2], type[_V3]],
+    key: type[K],
+    value: tuple[type[V1], type[V2], type[V3]],
     /,
     *,
-    key_serializer: Callable[[_K], bytes] | None = None,
+    key_serializer: Callable[[K], bytes] | None = None,
     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: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K, _V1 | _V2 | _V3]: ...
+    value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2 | V3] | 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(
+def redis_hash_map_key[K1, K2, V](
     name: str,
-    key: tuple[type[_K1], type[_K2]],
-    value: type[_V],
+    key: tuple[type[K1], type[K2]],
+    value: type[V],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
-    value_serializer: Callable[[_V], bytes] | None = None,
-    value_deserializer: Callable[[bytes], _V] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K1 | _K2, _V]: ...
+    value_serializer: Callable[[V], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisHashMapKey[K1 | K2, V]: ...
 @overload
-def redis_hash_map_key(
+def redis_hash_map_key[K1, K2, V1, V2](
     name: str,
-    key: tuple[type[_K1], type[_K2]],
-    value: tuple[type[_V1], type[_V2]],
+    key: tuple[type[K1], type[K2]],
+    value: tuple[type[V1], type[V2]],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
-    value_serializer: Callable[[_V1 | _V2], bytes] | None = None,
-    value_deserializer: Callable[[bytes], _V1 | _V2] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K1 | _K2, _V1 | _V2]: ...
+    value_serializer: Callable[[V1 | V2], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2] | 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(
+def redis_hash_map_key[K1, K2, V1, V2, V3](
     name: str,
-    key: tuple[type[_K1], type[_K2]],
-    value: tuple[type[_V1], type[_V2], type[_V3]],
+    key: tuple[type[K1], type[K2]],
+    value: tuple[type[V1], type[V2], type[V3]],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2], bytes] | None = None,
     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: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K1 | _K2, _V1 | _V2 | _V3]: ...
+    value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2 | V3] | 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(
+def redis_hash_map_key[K1, K2, K3, V](
     name: str,
-    key: tuple[type[_K1], type[_K2], type[_K3]],
-    value: type[_V],
+    key: tuple[type[K1], type[K2], type[K3]],
+    value: type[V],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2 | _K3], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2 | K3], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
-    value_serializer: Callable[[_V], bytes] | None = None,
-    value_deserializer: Callable[[bytes], _V] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K1 | _K2 | _K3, _V]: ...
+    value_serializer: Callable[[V], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V] | 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(
+def redis_hash_map_key[K1, K2, K3, V1, V2](
     name: str,
-    key: tuple[type[_K1], type[_K2], type[_K3]],
-    value: tuple[type[_V1], type[_V2]],
+    key: tuple[type[K1], type[K2], type[K3]],
+    value: tuple[type[V1], type[V2]],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2 | _K3], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2 | K3], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
-    value_serializer: Callable[[_V1 | _V2], bytes] | None = None,
-    value_deserializer: Callable[[bytes], _V1 | _V2] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K1 | _K2 | _K3, _V1 | _V2]: ...
+    value_serializer: Callable[[V1 | V2], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2] | 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(
+def redis_hash_map_key[K1, K2, K3, V1, V2, V3](
     name: str,
-    key: tuple[type[_K1], type[_K2], type[_K3]],
-    value: tuple[type[_V1], type[_V2], type[_V3]],
+    key: tuple[type[K1], type[K2], type[K3]],
+    value: tuple[type[V1], type[V2], type[V3]],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2 | _K3], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2 | K3], bytes] | None = None,
     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: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K1 | _K2 | _K3, _V1 | _V2 | _V3]: ...
+    value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2 | V3] | 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(
+def redis_hash_map_key[K, K1, K2, K3, V, V1, V2, V3](
     name: str,
-    key: TypeLike[_K],
-    value: TypeLike[_V],
+    key: TypeLike[K],
+    value: TypeLike[V],
     /,
     *,
-    key_serializer: Callable[[_K1 | _K2 | _K3], bytes] | None = None,
+    key_serializer: Callable[[K1 | K2 | K3], bytes] | None = None,
     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: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisHashMapKey[_K, _V]: ...
-def redis_hash_map_key(
+    value_serializer: Callable[[V1 | V2 | V3], bytes] | None = None,
+    value_deserializer: Callable[[bytes], V1 | V2 | V3] | 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,
-    key: TypeLike[_K],
-    value: TypeLike[_V],
+    key: TypeLike[K],
+    value: TypeLike[V],
     /,
     *,
     key_serializer: Callable[[Any], bytes] | None = None,
     key_deserializer: Callable[[bytes], Any] | None = None,
     value_serializer: Callable[[Any], bytes] | None = None,
     value_deserializer: Callable[[bytes], Any] | None = None,
-    timeout: Duration | None = None,
-    ttl: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-) -> RedisHashMapKey[_K, _V]:
+    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
         name=name,
@@ -394,40 +360,41 @@ def redis_hash_map_key(
 
 
 @dataclass(kw_only=True)
-class RedisKey(Generic[_T]):
+class RedisKey[T]:
     """A key in a redis store."""
 
     name: str
-    type: TypeLike[_T]
-    serializer: Callable[[_T], bytes] | None = None
-    deserializer: Callable[[bytes], _T] | None = None
-    timeout: Duration | None = None
-    error: type[Exception] = TimeoutError
-    ttl: Duration | None = None
+    type: TypeLike[T]
+    serializer: Callable[[T], bytes] | None = None
+    deserializer: Callable[[bytes], T] | None = None
+    timeout: Delta | None = None
+    error: MaybeType[BaseException] = TimeoutError
+    ttl: Delta | None = None
 
     async def delete(self, redis: Redis, /) -> int:
         """Delete the key from `redis`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        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`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = cast("Literal[0, 1]", await redis.exists(self.name))
         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:
+    async def get(self, redis: Redis, /) -> T:
         """Get a value from `redis`."""
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        async with timeout_td(  # skipif-ci-and-not-linux
+            self.timeout, error=self.error
         ):
             result = cast("bytes | None", await redis.get(self.name))
         if result is None:  # skipif-ci-and-not-linux
@@ -436,106 +403,104 @@ class RedisKey(Generic[_T]):
             result, deserializer=self.deserializer
         )
 
-    async def set(self, redis: Redis, value: _T, /) -> int:
+    async def set(self, redis: Redis, value: T, /) -> int:
         """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(1000 * datetime_duration_to_float(self.ttl))
+            None if self.ttl is None else to_milliseconds(self.ttl)
         )
-        async with timeout_dur(  # skipif-ci-and-not-linux
-            duration=self.timeout, error=self.error
+        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
-def redis_key(
+def redis_key[T](
     name: str,
-    type_: type[_T],
+    type_: type[T],
     /,
     *,
-    serializer: Callable[[_T], bytes] | None = None,
-    deserializer: Callable[[bytes], _T] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_T]: ...
+    serializer: Callable[[T], bytes] | None = None,
+    deserializer: Callable[[bytes], T] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisKey[T]: ...
 @overload
-def redis_key(
+def redis_key[T1, T2](
     name: str,
-    type_: tuple[type[_T1], type[_T2]],
+    type_: tuple[type[T1], type[T2]],
     /,
     *,
-    serializer: Callable[[_T1 | _T2], bytes] | None = None,
-    deserializer: Callable[[bytes], _T1 | _T2] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_T1 | _T2]: ...
+    serializer: Callable[[T1 | T2], bytes] | None = None,
+    deserializer: Callable[[bytes], T1 | T2] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisKey[T1 | T2]: ...
 @overload
-def redis_key(
+def redis_key[T1, T2, T3](
     name: str,
-    type_: tuple[type[_T1], type[_T2], type[_T3]],
+    type_: tuple[type[T1], type[T2], type[T3]],
     /,
     *,
-    serializer: Callable[[_T1 | _T2 | _T3], bytes] | None = None,
-    deserializer: Callable[[bytes], _T1 | _T2 | _T3] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_T1 | _T2 | _T3]: ...
+    serializer: Callable[[T1 | T2 | T3], bytes] | None = None,
+    deserializer: Callable[[bytes], T1 | T2 | T3] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisKey[T1 | T2 | T3]: ...
 @overload
-def redis_key(
+def redis_key[T1, T2, T3, T4](
     name: str,
-    type_: tuple[type[_T1], type[_T2], type[_T3], type[_T4]],
+    type_: tuple[type[T1], type[T2], type[T3], type[T4]],
     /,
     *,
-    serializer: Callable[[_T1 | _T2 | _T3 | _T4], bytes] | None = None,
-    deserializer: Callable[[bytes], _T1 | _T2 | _T3 | _T4] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_T1 | _T2 | _T3 | _T4]: ...
+    serializer: Callable[[T1 | T2 | T3 | T4], bytes] | None = None,
+    deserializer: Callable[[bytes], T1 | T2 | T3 | T4] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisKey[T1 | T2 | T3 | T4]: ...
 @overload
-def redis_key(
+def redis_key[T1, T2, T3, T4, T5](
     name: str,
-    type_: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]],
+    type_: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
     /,
     *,
-    serializer: Callable[[_T1 | _T2 | _T3 | _T4 | _T5], bytes] | None = None,
-    deserializer: Callable[[bytes], _T1 | _T2 | _T3 | _T4 | _T5] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_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: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisKey[T1 | T2 | T3 | T4 | T5]: ...
 @overload
-def redis_key(
+def redis_key[T, T1, T2, T3, T4, T5](
     name: str,
-    type_: TypeLike[_T],
+    type_: TypeLike[T],
     /,
     *,
-    serializer: Callable[[_T1 | _T2 | _T3 | _T4 | _T5], bytes] | None = None,
-    deserializer: Callable[[bytes], _T1 | _T2 | _T3 | _T4 | _T5] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_T]: ...
-def redis_key(
+    serializer: Callable[[T1 | T2 | T3 | T4 | T5], bytes] | None = None,
+    deserializer: Callable[[bytes], T1 | T2 | T3 | T4 | T5] | None = None,
+    timeout: Delta | None = None,
+    error: MaybeType[BaseException] = TimeoutError,
+    ttl: Delta | None = None,
+) -> RedisKey[T]: ...
+def redis_key[T](
     name: str,
-    type_: TypeLike[_T],
+    type_: TypeLike[T],
     /,
     *,
     serializer: Callable[[Any], bytes] | None = None,
     deserializer: Callable[[bytes], Any] | None = None,
-    timeout: Duration | None = None,
-    error: type[Exception] = TimeoutError,
-    ttl: Duration | None = None,
-) -> RedisKey[_T]:
+    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
         name=name,
@@ -552,15 +517,15 @@ def redis_key(
 
 
 @overload
-async def publish(
+async def publish[T](
     redis: Redis,
     channel: str,
-    data: _T,
+    data: T,
     /,
     *,
-    serializer: Callable[[_T], EncodableT],
-    timeout: Duration = _PUBLISH_TIMEOUT,
-) -> ResponseT: ...
+    serializer: Callable[[T], EncodableT],
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int: ...
 @overload
 async def publish(
     redis: Redis,
@@ -569,217 +534,192 @@ async def publish(
     /,
     *,
     serializer: None = None,
-    timeout: Duration = _PUBLISH_TIMEOUT,
-) -> ResponseT: ...
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int: ...
 @overload
-async def publish(
+async def publish[T](
     redis: Redis,
     channel: str,
-    data: bytes | str | _T,
+    data: bytes | str | T,
     /,
     *,
-    serializer: Callable[[_T], EncodableT] | None = None,
-    timeout: Duration = _PUBLISH_TIMEOUT,
-) -> ResponseT: ...
-async def publish(
+    serializer: Callable[[T], EncodableT] | None = None,
+    timeout: Delta | None = _PUBLISH_TIMEOUT,
+) -> int: ...
+async def publish[T](
     redis: Redis,
     channel: str,
-    data: bytes | str | _T,
+    data: bytes | str | T,
     /,
     *,
-    serializer: Callable[[_T], EncodableT] | None = None,
-    timeout: Duration = _PUBLISH_TIMEOUT,
-) -> ResponseT:
+    serializer: Callable[[T], EncodableT] | None = None,
+    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_dur(duration=timeout):  # skipif-ci-and-not-linux
-        return await redis.publish(channel, data_use)  # skipif-ci-and-not-linux
+    async with timeout_td(timeout):  # 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(Looper[tuple[str, _T]]):
-    """Service to publish items to Redis."""
-
-    # base
-    freq: Duration = field(default=MILLISECOND, repr=False)
-    backoff: Duration = field(default=SECOND, repr=False)
-    empty_upon_exit: bool = field(default=True, repr=False)
-    # self
-    redis: Redis
-    serializer: Callable[[_T], EncodableT] = serialize
-    publish_timeout: Duration = _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(Generic[_T]):
-    """Mix-in for the publish service."""
-
-    # base - looper
-    publish_service_freq: Duration = field(default=MILLISECOND, repr=False)
-    publish_service_backoff: Duration = 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: Duration | 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: Duration = _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: Duration = SECOND
-_SUBSCRIBE_SLEEP: Duration = 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: Duration | None = _SUBSCRIBE_TIMEOUT,
-    sleep: Duration = _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: Duration | None = _SUBSCRIBE_TIMEOUT,
-    sleep: Duration = _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: Duration | None = _SUBSCRIBE_TIMEOUT,
-    sleep: Duration = _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
-def subscribe(
+@enhanced_async_context_manager
+def subscribe[T](
     redis: Redis,
     channels: MaybeIterable[str],
-    queue: Queue[_T],
+    queue: Queue[T],
     /,
     *,
-    timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
-    sleep: Duration = _SUBSCRIBE_SLEEP,
-    output: Callable[[bytes], _T],
-    filter_: Callable[[_T], bool] | None = None,
+    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
-async def subscribe(
+@enhanced_async_context_manager
+async def subscribe[T](
     redis: Redis,
     channels: MaybeIterable[str],
-    queue: Queue[_RedisMessage] | Queue[bytes] | Queue[_T],
+    queue: Queue[_RedisMessage] | Queue[bytes] | Queue[T],
     /,
     *,
-    timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
-    sleep: Duration = _SUBSCRIBE_SLEEP,
-    output: Literal["raw", "bytes", "text"] | Callable[[bytes], _T] = "text",
-    filter_: Callable[[Any], bool] | None = None,
+    timeout: Delta | None = _SUBSCRIBE_TIMEOUT,
+    output: Literal["raw", "bytes", "text"] | Callable[[bytes], T] = "text",
+    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:
+            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
@@ -789,33 +729,44 @@ async def subscribe(
             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: Duration | None = _SUBSCRIBE_TIMEOUT,
-    sleep: Duration = _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 datetime_duration_to_float(timeout)
+        None if timeout is None else (to_nanoseconds(timeout) / 1e9)
     )
-    sleep_use = datetime_duration_to_float(sleep)  # skipif-ci-and-not-linux
     is_subscribe_message = partial(  # skipif-ci-and-not-linux
         _is_message, channels={c.encode() for c in channels}
     )
@@ -823,30 +774,49 @@ 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 asyncio.sleep(sleep_use)
+                await sleep_td(sleep)
 
 
 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):
@@ -859,125 +829,7 @@ class _RedisMessage(TypedDict):
 ##
 
 
-@dataclass(kw_only=True)
-class SubscribeService(Looper[_T]):
-    """Service to subscribe to Redis."""
-
-    # base
-    freq: Duration = field(default=MILLISECOND, repr=False)
-    backoff: Duration = 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: 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
-    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(Generic[_T]):
-    """Mix-in for the subscribe service."""
-
-    # base - looper
-    subscribe_service_freq: Duration = field(default=MILLISECOND, repr=False)
-    subscribe_service_backoff: Duration = 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: Duration | 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: Duration = _SUBSCRIBE_SLEEP
-    subscribe_service_subscribe_timeout: Duration | 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]:
@@ -999,7 +851,7 @@ _HOST = "localhost"
 _PORT = 6379
 
 
-@asynccontextmanager
+@enhanced_async_context_manager
 async def yield_redis(
     *,
     host: str = _HOST,
@@ -1037,7 +889,9 @@ async def yield_redis(
 ##
 
 
-def _serialize(obj: _T, /, *, serializer: Callable[[_T], bytes] | None = None) -> bytes:
+def _serialize[T](
+    obj: T, /, *, serializer: Callable[[T], bytes] | None = None
+) -> bytes:
     if serializer is None:  # skipif-ci-and-not-linux
         from utilities.orjson import serialize as serializer_use
     else:  # skipif-ci-and-not-linux
@@ -1045,9 +899,9 @@ def _serialize(obj: _T, /, *, serializer: Callable[[_T], bytes] | None = None) -
     return serializer_use(obj)  # skipif-ci-and-not-linux
 
 
-def _deserialize(
-    data: bytes, /, *, deserializer: Callable[[bytes], _T] | None = None
-) -> _T:
+def _deserialize[T](
+    data: bytes, /, *, deserializer: Callable[[bytes], T] | None = None
+) -> T:
     if deserializer is None:  # skipif-ci-and-not-linux
         from utilities.orjson import deserialize as deserializer_use
     else:  # skipif-ci-and-not-linux
@@ -1056,13 +910,10 @@ def _deserialize(
 
 
 __all__ = [
-    "PublishService",
-    "PublishServiceMixin",
     "RedisHashMapKey",
     "RedisKey",
-    "SubscribeService",
-    "SubscribeServiceMixin",
     "publish",
+    "publish_many",
     "redis_hash_map_key",
     "redis_key",
     "subscribe",