dycw-utilities 0.112.8__py3-none-any.whl → 0.112.9__py3-none-any.whl

{dycw_utilities-0.112.8.dist-info → dycw_utilities-0.112.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.112.8
+Version: 0.112.9
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -74,7 +74,7 @@ Requires-Dist: polars-lts-cpu<1.29,>=1.28.1; extra == 'zzz-test-hashlib'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-hashlib'
 Provides-Extra: zzz-test-http
 Requires-Dist: atomicwrites<1.5,>=1.4.1; extra == 'zzz-test-http'
-Requires-Dist: orjson<3.11,>=3.10.16; extra == 'zzz-test-http'
+Requires-Dist: orjson<3.11,>=3.10.18; extra == 'zzz-test-http'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-http'
 Provides-Extra: zzz-test-hypothesis
 Requires-Dist: aiosqlite<0.22,>=0.21.0; extra == 'zzz-test-hypothesis'
@@ -144,7 +144,7 @@ Provides-Extra: zzz-test-pqdm
 Requires-Dist: pqdm<0.3,>=0.2.0; extra == 'zzz-test-pqdm'
 Provides-Extra: zzz-test-pydantic
 Requires-Dist: atomicwrites<1.5,>=1.4.1; extra == 'zzz-test-pydantic'
-Requires-Dist: pydantic<2.12,>=2.11.2; extra == 'zzz-test-pydantic'
+Requires-Dist: pydantic<2.12,>=2.11.4; extra == 'zzz-test-pydantic'
 Provides-Extra: zzz-test-pyinstrument
 Requires-Dist: atomicwrites<1.5,>=1.4.1; extra == 'zzz-test-pyinstrument'
 Requires-Dist: pyinstrument<5.1,>=5.0.0; extra == 'zzz-test-pyinstrument'
@@ -153,7 +153,7 @@ Provides-Extra: zzz-test-pyrsistent
 Requires-Dist: pyrsistent<0.21,>=0.20.0; extra == 'zzz-test-pyrsistent'
 Provides-Extra: zzz-test-pytest
 Requires-Dist: atomicwrites<1.5,>=1.4.1; extra == 'zzz-test-pytest'
-Requires-Dist: orjson<3.11,>=3.10.16; extra == 'zzz-test-pytest'
+Requires-Dist: orjson<3.11,>=3.10.18; extra == 'zzz-test-pytest'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-pytest'
 Provides-Extra: zzz-test-pytest-regressions
 Requires-Dist: pytest-regressions<2.8,>=2.7.0; extra == 'zzz-test-pytest-regressions'
@@ -197,7 +197,7 @@ Requires-Dist: sqlalchemy<2.1,>=2.0.40; extra == 'zzz-test-sqlalchemy-polars'
 Requires-Dist: tenacity<9.0,>=8.5.0; extra == 'zzz-test-sqlalchemy-polars'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-sqlalchemy-polars'
 Provides-Extra: zzz-test-streamlit
-Requires-Dist: streamlit<1.45,>=1.44.1; extra == 'zzz-test-streamlit'
+Requires-Dist: streamlit<1.46,>=1.45.0; extra == 'zzz-test-streamlit'
 Provides-Extra: zzz-test-sys
 Requires-Dist: atomicwrites<1.5,>=1.4.1; extra == 'zzz-test-sys'
 Requires-Dist: rich<14.1,>=14.0.0; extra == 'zzz-test-sys'

{dycw_utilities-0.112.8.dist-info → dycw_utilities-0.112.9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=XeC2tMugkErM_YQbJ1Iwis-CVp-V14bjMaBeziiWF1s,60
+utilities/__init__.py,sha256=4oIYPUfPGTr8vXSSPtcMMTgcanNRfFAjAkM3ufwN-Mg,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
 utilities/astor.py,sha256=xuDUkjq0-b6fhtwjhbnebzbqQZAjMSHR1IIS5uOodVg,777
 utilities/asyncio.py,sha256=41oQUurWMvadFK5gFnaG21hMM0Vmfn2WS6OpC0R9mas,14757
@@ -58,7 +58,7 @@ utilities/pytest_regressions.py,sha256=-SVT9647Dg6-JcdsiaDKXe3NdOmmrvGevLKWwGjxq
 utilities/python_dotenv.py,sha256=iWcnpXbH7S6RoXHiLlGgyuH6udCupAcPd_gQ0eAenQ0,3190
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=5J4d8VwIPFVrX2Eb8zfoxImDv7IwiN_U7mJ07wR2Wvs,3958
-utilities/redis.py,sha256=fAUbfOlCmxcxhh47PXQX63w0CU5iOFKfdUJ7jDn9ntM,22096
+utilities/redis.py,sha256=XYHo1Qne4j5_BSIUorF8n5EWCRwByTdbAL3NLC6e2_4,25261
 utilities/reprlib.py,sha256=Re9bk3n-kC__9DxQmRlevqFA86pE6TtVfWjUgpbVOv0,1849
 utilities/rich.py,sha256=t50MwwVBsoOLxzmeVFSVpjno4OW6Ufum32skXbV8-Bs,1911
 utilities/scipy.py,sha256=X6ROnHwiUhAmPhM0jkfEh0-Fd9iRvwiqtCQMOLmOQF8,945
@@ -87,7 +87,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=iLRP_-8CZtBpHKbGZGu-kjSMg1ZubJ-VSmgSy7Eudxw,17787
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-Xm57PMMwDTYpxJdkiJG13wnbwK--I7XItBh5WVhD-o,1874
-dycw_utilities-0.112.8.dist-info/METADATA,sha256=i2cGlKTXS9uPmvL_dC8xIdqS9wlxq5NbsOgmOn6J23o,13004
-dycw_utilities-0.112.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.112.8.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.112.8.dist-info/RECORD,,
+dycw_utilities-0.112.9.dist-info/METADATA,sha256=w5dmojTlh4MG3_sA2rTFFQLP-BclPCLPCQ98Rf4RF-o,13004
+dycw_utilities-0.112.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.112.9.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.112.9.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.8"
+__version__ = "0.112.9"

utilities/redis.py

@@ -31,11 +31,18 @@ from utilities.datetime import (
 )
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int
-from utilities.iterables import always_iterable
+from utilities.iterables import always_iterable, one
 
 if TYPE_CHECKING:
     import datetime as dt
-    from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
+    from collections.abc import (
+        AsyncIterator,
+        Awaitable,
+        Callable,
+        Iterable,
+        Mapping,
+        Sequence,
+    )
 
     from redis.asyncio import ConnectionPool
     from redis.asyncio.client import PubSub
@@ -71,6 +78,7 @@ class RedisHashMapKey(Generic[_K, _V]):
     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
@@ -95,46 +103,102 @@ class RedisHashMapKey(Generic[_K, _V]):
                 "Awaitable[bool]", redis.hexists(self.name, cast("str", key))
             )
 
-    async def get(self, redis: Redis, key: _K, /) -> _V | None:
+    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]:
         """Get a value from a hashmap in `redis`."""
-        ser_key = _serialize(  # skipif-ci-and-not-linux
-            key, serializer=self.key_serializer
-        )
         async with timeout_dur(  # skipif-ci-and-not-linux
             duration=self.timeout, error=self.error
         ):
             result = await cast(  # skipif-ci-and-not-linux
-                "Awaitable[bytes | None]", redis.hget(self.name, cast("Any", ser_key))
+                "Awaitable[Mapping[bytes, bytes]]", redis.hgetall(self.name)
             )
-        match result:  # skipif-ci-and-not-linux
-            case None:
-                return None
-            case bytes() as data:
-                return _deserialize(data, deserializer=self.value_deserializer)
-            case _ as never:
-                assert_never(never)
+        return {  # skipif-ci-and-not-linux
+            _deserialize(key, deserializer=self.key_deserializer): _deserialize(
+                value, deserializer=self.value_deserializer
+            )
+            for key, value in result.items()
+        }
+
+    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
+            return []
+        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
+        ):
+            result = await cast(  # skipif-ci-and-not-linux
+                "Awaitable[Sequence[bytes | None]]", redis.hmget(self.name, ser)
+            )
+        return [  # skipif-ci-and-not-linux
+            None
+            if data is None
+            else _deserialize(data, deserializer=self.value_deserializer)
+            for data in result
+        ]
+
+    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
+        ):
+            result = await cast("Awaitable[Sequence[bytes]]", redis.hkeys(self.name))
+        return [  # skipif-ci-and-not-linux
+            _deserialize(data, deserializer=self.key_deserializer) for data in result
+        ]
+
+    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
+        ):
+            return await cast("Awaitable[int]", redis.hlen(self.name))
 
     async def set(self, redis: Redis, key: _K, value: _V, /) -> int:
         """Set a value in a hashmap in `redis`."""
-        ser_key = _serialize(  # skipif-ci-and-not-linux
-            key, serializer=self.key_serializer
-        )
-        ser_value = _serialize(  # skipif-ci-and-not-linux
-            value, serializer=self.value_serializer
-        )
+        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:
+        """Set multiple value(s) in a hashmap in `redis`."""
+        if len(mapping) == 0:  # skipif-ci-and-not-linux
+            return 0
+        ser = {  # skipif-ci-and-not-linux
+            _serialize(key, serializer=self.key_serializer): _serialize(
+                value, serializer=self.value_serializer
+            )
+            for key, value in mapping.items()
+        }
         async with timeout_dur(  # skipif-ci-and-not-linux
             duration=self.timeout, error=self.error
         ):
             result = await cast(
-                "Awaitable[int]",
-                redis.hset(
-                    self.name, key=cast("Any", ser_key), value=cast("Any", ser_value)
-                ),
+                "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))
         return result  # skipif-ci-and-not-linux
 
+    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
+        ):
+            result = await cast("Awaitable[Sequence[bytes]]", redis.hvals(self.name))
+        return [  # skipif-ci-and-not-linux
+            _deserialize(data, deserializer=self.value_deserializer) for data in result
+        ]
+
 
 @overload
 def redis_hash_map_key(
@@ -144,6 +208,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -158,6 +223,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -172,6 +238,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -186,6 +253,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -200,6 +268,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -214,6 +283,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -228,6 +298,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -242,6 +313,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -256,6 +328,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -270,6 +343,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -283,6 +357,7 @@ def redis_hash_map_key(
     /,
     *,
     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,
@@ -294,6 +369,7 @@ def redis_hash_map_key(
         name=name,
         key=key,
         key_serializer=key_serializer,
+        key_deserializer=key_deserializer,
         value=value,
         value_serializer=value_serializer,
         value_deserializer=value_deserializer,
@@ -343,23 +419,15 @@ class RedisKey(Generic[_T]):
             duration=self.timeout, error=self.error
         ):
             result = cast("bytes | None", await redis.get(self.name))
-        match result:  # skipif-ci-and-not-linux
-            case None:
-                return None
-            case bytes() as data:
-                if self.deserializer is None:
-                    from utilities.orjson import deserialize
-
-                    return deserialize(data)
-                return self.deserializer(data)
-            case _ as never:
-                assert_never(never)
+        if result is None:  # skipif-ci-and-not-linux
+            raise KeyError(self.name)
+        return _deserialize(  # skipif-ci-and-not-linux
+            result, deserializer=self.deserializer
+        )
 
     async def set(self, redis: Redis, value: _T, /) -> int:
         """Set a value in `redis`."""
-        ser_value = _serialize(  # skipif-ci-and-not-linux
-            value, serializer=self.serializer
-        )
+        ser = _serialize(value, serializer=self.serializer)  # skipif-ci-and-not-linux
         ttl = (  # skipif-ci-and-not-linux
             None
             if self.ttl is None
@@ -369,7 +437,7 @@ class RedisKey(Generic[_T]):
             duration=self.timeout, error=self.error
         ):
             result = await redis.set(  # skipif-ci-and-not-linux
-                self.name, ser_value, px=ttl
+                self.name, ser, px=ttl
             )
         return ensure_int(result)  # skipif-ci-and-not-linux