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

{dycw_utilities-0.134.4.dist-info → dycw_utilities-0.135.0.dist-info}/METADATA

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

{dycw_utilities-0.134.4.dist-info → dycw_utilities-0.135.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=aGENX9jJ-5Lnfpi2UfGD4tuv49MbTmIMv6OGK_-O8lM,60
+utilities/__init__.py,sha256=ZNWx_k_4ER3p4DVbJX8DEVVB_Qth1GiAAheIk1f0wkY,60
 utilities/aiolimiter.py,sha256=mD0wEiqMgwpty4XTbawFpnkkmJS6R4JRsVXFUaoitSU,628
 utilities/altair.py,sha256=HeZBVUocjkrTNwwKrClppsIqgNFF-ykv05HfZSoHYno,9104
 utilities/arq.py,sha256=S-sfBfY-E1ErRKf4sSXt2YyCjKvu-pBlOECDfjBebRA,6399
@@ -37,7 +37,7 @@ utilities/luigi.py,sha256=wK7cB3y8NXeSa8d6r_yTKRmjMguNmIPmy52yg10vPaI,4774
 utilities/math.py,sha256=_6vrDyjtaqE_OFE-F2DNWrDG_J_kMl3nFAJsok9v_bY,26862
 utilities/memory_profiler.py,sha256=XzN56jDCa5aqXS_DxEjb_K4L6aIWh_5zyKi6OhcIxw0,853
 utilities/modules.py,sha256=iuvLluJya-hvl1Q25-Jk3dLgx2Es3ck4SjJiEkAlVTs,3195
-utilities/more_itertools.py,sha256=QCPzZvdsPbbd_ypPP06odqfyK79Vp4oQG9DQbaI205A,8644
+utilities/more_itertools.py,sha256=EX4P5JTc3p9fF3Ia3ZzPy9CEUe6OZcFqrrVplZ4pMaQ,10937
 utilities/numpy.py,sha256=Xn23sA2ZbVNqwUYEgNJD3XBYH6IbCri_WkHSNhg3NkY,26122
 utilities/operator.py,sha256=fZM2DBZdjtU8Lh9Z-eHC4ktNr0vO3JfX8hXgIYwdvBI,3826
 utilities/optuna.py,sha256=C-fhWYiXHVPo1l8QctYkFJ4DyhbSrGorzP1dJb_qvd8,1933
@@ -90,7 +90,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=A-yoOqBqrcVD1yDINDsTFDw7dq9-zgUGn_f8CxVUQJs,23332
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=oEH-nL3t4h9uawyZqWDtNtDAl6M-CLpLYGI_nI6DulM,1971
-dycw_utilities-0.134.4.dist-info/METADATA,sha256=bayiwKsZUr-VMVW1EI2cLFL3rbWrqqftZXA1PrXoe3c,1584
-dycw_utilities-0.134.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.134.4.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.134.4.dist-info/RECORD,,
+dycw_utilities-0.135.0.dist-info/METADATA,sha256=USiapXRoQLG5Wl1CftVIV6nKma65HtH3nIoU7n8OMl8,1584
+dycw_utilities-0.135.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.135.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.135.0.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.134.4"
+__version__ = "0.135.0"

utilities/more_itertools.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-import builtins
-from collections.abc import Hashable
+from collections.abc import Callable, Hashable
 from dataclasses import dataclass
 from itertools import islice
 from textwrap import indent
@@ -25,7 +24,7 @@ from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+    from collections.abc import Iterable, Iterator, Mapping, Sequence
 
 
 @overload
@@ -34,55 +33,107 @@ def bucket_mapping[T, U, UH: Hashable](
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U],
-    list: bool = False,
-    unique: Literal[True],
-) -> Mapping[UH, U]: ...
+    pre: Callable[[T], U],
+    post: Literal["list"],
+) -> Mapping[UH, list[U]]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U] | None = None,
-    list: bool = False,
-    unique: Literal[True],
-) -> Mapping[UH, T]: ...
+    pre: Callable[[T], U],
+    post: Literal["tuple"],
+) -> Mapping[UH, tuple[U, ...]]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U],
-    list: Literal[True],
-) -> Mapping[UH, Sequence[U]]: ...
+    pre: Callable[[T], U],
+    post: Literal["set"],
+) -> Mapping[UH, set[U]]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U],
-    list: bool = False,
-) -> Mapping[UH, Iterator[U]]: ...
+    pre: Callable[[T], U],
+    post: Literal["frozenset"],
+) -> Mapping[UH, frozenset[U]]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U] | None = None,
-    list: Literal[True],
-) -> Mapping[UH, Sequence[T]]: ...
+    pre: Callable[[T], U] | None = None,
+    post: Literal["unique"],
+) -> Mapping[UH, U]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
     iterable: Iterable[T],
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U] | None = None,
-    list: bool = False,
+    pre: Callable[[T], U] | None = None,
+    post: None = None,
+) -> Mapping[UH, Iterator[U]]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
+    post: Literal["list"],
+) -> Mapping[UH, list[T]]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
+    post: Literal["tuple"],
+) -> Mapping[UH, tuple[T, ...]]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
+    post: Literal["set"],
+) -> Mapping[UH, set[T]]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
+    post: Literal["frozenset"],
+) -> Mapping[UH, frozenset[T]]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
+    post: Literal["unique"],
+) -> Mapping[UH, T]: ...
+@overload
+def bucket_mapping[T, UH: Hashable](
+    iterable: Iterable[T],
+    func: Callable[[T], UH],
+    /,
+    *,
+    pre: None = None,
+    post: None = None,
 ) -> Mapping[UH, Iterator[T]]: ...
 @overload
 def bucket_mapping[T, U, UH: Hashable](
@@ -90,15 +141,20 @@ def bucket_mapping[T, U, UH: Hashable](
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U] | None = None,
-    list: bool = False,
-    unique: bool = False,
+    pre: Callable[[T], U] | None = None,
+    post: Literal["list", "tuple", "set", "frozenset", "unique"] | None = None,
 ) -> (
     Mapping[UH, Iterator[T]]
-    | Mapping[UH, Iterator[U]]
-    | Mapping[UH, Sequence[T]]
-    | Mapping[UH, Sequence[U]]
+    | Mapping[UH, list[T]]
+    | Mapping[UH, tuple[T, ...]]
+    | Mapping[UH, set[T]]
+    | Mapping[UH, frozenset[T]]
     | Mapping[UH, T]
+    | Mapping[UH, Iterator[U]]
+    | Mapping[UH, list[U]]
+    | Mapping[UH, tuple[U, ...]]
+    | Mapping[UH, set[U]]
+    | Mapping[UH, frozenset[U]]
     | Mapping[UH, U]
 ): ...
 def bucket_mapping[T, U, UH: Hashable](
@@ -106,42 +162,66 @@ def bucket_mapping[T, U, UH: Hashable](
     func: Callable[[T], UH],
     /,
     *,
-    transform: Callable[[T], U] | None = None,
-    list: bool = False,  # noqa: A002
-    unique: bool = False,
+    pre: Callable[[T], U] | None = None,
+    post: Literal["list", "tuple", "set", "frozenset", "unique"] | None = None,
 ) -> (
     Mapping[UH, Iterator[T]]
-    | Mapping[UH, Iterator[U]]
-    | Mapping[UH, Sequence[T]]
-    | Mapping[UH, Sequence[U]]
+    | Mapping[UH, list[T]]
+    | Mapping[UH, tuple[T, ...]]
+    | Mapping[UH, set[T]]
+    | Mapping[UH, frozenset[T]]
     | Mapping[UH, T]
+    | Mapping[UH, Iterator[U]]
+    | Mapping[UH, list[U]]
+    | Mapping[UH, tuple[U, ...]]
+    | Mapping[UH, set[U]]
+    | Mapping[UH, frozenset[U]]
     | Mapping[UH, U]
 ):
     """Bucket the values of iterable into a mapping."""
-    b = bucket(iterable, func)
-    mapping = {key: b[key] for key in b}
-    match transform, list:
-        case None, False:
-            ...
-        case None, True:
-            mapping = {k: builtins.list(v) for k, v in mapping.items()}
-        case _, False:
-            mapping = {k: map(transform, v) for k, v in mapping.items()}
-        case _, True:
-            mapping = {k: builtins.list(map(transform, v)) for k, v in mapping.items()}
+    bckt = bucket(iterable, func)
+    mapping = {key: bckt[key] for key in bckt}
+    match pre, post:
+        case None, None:
+            return mapping
+        case None, "list":
+            return {k: list(v) for k, v in mapping.items()}
+        case None, "tuple":
+            return {k: tuple(v) for k, v in mapping.items()}
+        case None, "set":
+            return {k: set(v) for k, v in mapping.items()}
+        case None, "frozenset":
+            return {k: frozenset(v) for k, v in mapping.items()}
+        case None, "unique":
+            return _bucket_mapping_unique(mapping)
+        case Callable(), None:
+            return {k: map(pre, v) for k, v in mapping.items()}
+        case Callable(), "list":
+            return {k: list(map(pre, v)) for k, v in mapping.items()}
+        case Callable(), "tuple":
+            return {k: tuple(map(pre, v)) for k, v in mapping.items()}
+        case Callable(), "set":
+            return {k: set(map(pre, v)) for k, v in mapping.items()}
+        case Callable(), "frozenset":
+            return {k: frozenset(map(pre, v)) for k, v in mapping.items()}
+        case Callable(), "unique":
+            return _bucket_mapping_unique({k: map(pre, v) for k, v in mapping.items()})
         case _ as never:
             assert_never(never)
-    if not unique:
-        return mapping
-    results = {}
-    error_no_transform: dict[UH, tuple[T, T]] = {}
+
+
+def _bucket_mapping_unique[K: Hashable, V](
+    mapping: Mapping[K, Iterable[V]], /
+) -> Mapping[K, V]:
+    results: dict[K, V] = {}
+    errors: dict[K, tuple[V, V]] = {}
     for key, value in mapping.items():
         try:
             results[key] = one(value)
         except OneNonUniqueError as error:
-            error_no_transform[key] = (error.first, error.second)
-    if len(error_no_transform) >= 1:
-        raise BucketMappingError(errors=error_no_transform)
+            errors[key] = (error.first, error.second)
+    if len(errors) >= 1:
+        raise BucketMappingError(errors=errors)
     return results