dycw-utilities 0.112.12__tar.gz → 0.112.14__tar.gz

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/PKG-INFO

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

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/pyproject.toml

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

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/src/tests/test_more_itertools.py

@@ -7,6 +7,7 @@ from pytest import mark, param, raises
 from utilities.more_itertools import (
     Split,
     bucket_mapping,
+    partition_list,
     partition_typeguard,
     peekable,
     yield_splits,
@@ -35,6 +36,19 @@ class TestBucketMapping:
         assert mapping["c"] == ["c1", "c2"]
 
 
+class TestPartitionList:
+    def test_main(self) -> None:
+        def is_even(x: int, /) -> bool:
+            return x % 2 == 0
+
+        iterable = [1, 2, 3, 4]
+        false, true = partition_list(is_even, iterable)
+        assert isinstance(false, list)
+        assert false == [1, 3]
+        assert isinstance(true, list)
+        assert true == [2, 4]
+
+
 class TestPartitionTypeguard:
     def test_main(self) -> None:
         def is_int(x: Any, /) -> TypeGuard[int]:

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/src/tests/test_redis.py

@@ -20,6 +20,7 @@ from tests.test_operator import make_objects
 from utilities.functions import get_class_name
 from utilities.hypothesis import (
     int64s,
+    pairs,
     settings_with_reduced_examples,
     text_ascii,
     yield_test_redis,
@@ -323,6 +324,20 @@ class TestRedisHashMapKey:
             with raises(KeyError):
                 _ = await hm_key.get(test.redis, key)
 
+    @given(data=data(), key=pairs(int64s()), value=booleans())
+    @settings_with_reduced_examples(phases={Phase.generate})
+    @SKIPIF_CI_AND_NOT_LINUX
+    async def test_delete_compound(
+        self, *, data: DataObject, key: tuple[int, int], value: bool
+    ) -> None:
+        async with yield_test_redis(data) as test:
+            hm_key = redis_hash_map_key(test.key, tuple[int, int], bool)
+            _ = await hm_key.set(test.redis, key, value)
+            assert await hm_key.get(test.redis, key) is value
+            _ = await hm_key.delete(test.redis, key)
+            with raises(KeyError):
+                _ = await hm_key.get(test.redis, key)
+
     @given(data=data(), key=int64s(), value=booleans())
     @settings_with_reduced_examples(phases={Phase.generate})
     @SKIPIF_CI_AND_NOT_LINUX
@@ -333,6 +348,18 @@ class TestRedisHashMapKey:
             _ = await hm_key.set(test.redis, key, value)
             assert await hm_key.exists(test.redis, key)
 
+    @given(data=data(), key=pairs(int64s()), value=booleans())
+    @settings_with_reduced_examples(phases={Phase.generate})
+    @SKIPIF_CI_AND_NOT_LINUX
+    async def test_exists_compound(
+        self, *, data: DataObject, key: tuple[int, int], value: bool
+    ) -> None:
+        async with yield_test_redis(data) as test:
+            hm_key = redis_hash_map_key(test.key, tuple[int, int], bool)
+            assert not (await hm_key.exists(test.redis, key))
+            _ = await hm_key.set(test.redis, key, value)
+            assert await hm_key.exists(test.redis, key)
+
     @given(data=data(), mapping=dictionaries(int64s(), booleans()))
     @settings_with_reduced_examples(phases={Phase.generate})
     @SKIPIF_CI_AND_NOT_LINUX

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.12"
+__version__ = "0.112.14"

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/src/utilities/more_itertools.py

@@ -32,6 +32,9 @@ _T = TypeVar("_T")
 _U = TypeVar("_U")
 
 
+##
+
+
 @overload
 def bucket_mapping(
     iterable: Iterable[_T], func: Callable[[_T], THashable], /, *, list: Literal[True]
@@ -55,6 +58,20 @@ def bucket_mapping(
     return mapping
 
 
+##
+
+
+def partition_list(
+    pred: Callable[[_T], bool], iterable: Iterable[_T], /
+) -> tuple[list[_T], list[_T]]:
+    """Partition with lists."""
+    false, true = partition(pred, iterable)
+    return list(false), list(true)
+
+
+##
+
+
 def partition_typeguard(
     pred: Callable[[_T], TypeGuard[_U]], iterable: Iterable[_T], /
 ) -> tuple[Iterator[_T], Iterator[_U]]:
@@ -64,6 +81,9 @@ def partition_typeguard(
     return false, true
 
 
+##
+
+
 class peekable(_peekable, Generic[_T]):  # noqa: N801
     """Peekable which supports dropwhile/takewhile methods."""
 
@@ -98,6 +118,9 @@ class peekable(_peekable, Generic[_T]):  # noqa: N801
             yield next(self)
 
 
+##
+
+
 @dataclass(kw_only=True, slots=True)
 class Split(Generic[_T]):
     """An iterable split into head/tail."""
@@ -184,4 +207,11 @@ def _yield_splits3(
         )
 
 
-__all__ = ["Split", "bucket_mapping", "partition_typeguard", "peekable", "yield_splits"]
+__all__ = [
+    "Split",
+    "bucket_mapping",
+    "partition_list",
+    "partition_typeguard",
+    "peekable",
+    "yield_splits",
+]

{dycw_utilities-0.112.12 → dycw_utilities-0.112.14}/src/utilities/redis.py

@@ -88,20 +88,24 @@ class RedisHashMapKey(Generic[_K, _V]):
 
     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
         ):
-            return await cast("Awaitable[int]", redis.hdel(self.name, cast("str", key)))
+            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:
         """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
         ):
-            return await cast(
-                "Awaitable[bool]", redis.hexists(self.name, cast("str", key))
-            )
+            return await cast("Awaitable[bool]", redis.hexists(self.name, ser))
 
     async def get(self, redis: Redis, key: _K, /) -> _V:
         """Get a value from a hashmap in `redis`."""