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

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

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

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

@@ -1,8 +1,8 @@
-utilities/__init__.py,sha256=Ayw_2oayPW-WIP3bGtbUE6g3SFitrjRG5_og7H0SmV8,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
-utilities/asyncio.py,sha256=F12PF2z0letHzFhESXLlAYLTSV7MpTAGfW8FF3EWFmM,37403
+utilities/asyncio.py,sha256=qqoV2xXrZoOw1ck9yHOh8mxlnoh96Huwd5xGmJcu3fQ,38165
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=9im2g8OCf-Iynqa8bAv8N0Ycj9QvrJmGO7yLCZEdgII,986
 utilities/cachetools.py,sha256=v1-9sXHLdOLiwmkq6NB0OUbxeKBuVVN6wmAWefWoaHI,2744
@@ -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.3.dist-info/METADATA,sha256=asf6ss3pPJEYGfENxbgJ4xgaihG7bK8FFO3Nbc3mMaQ,1584
-dycw_utilities-0.134.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.134.3.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.134.3.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.3"
+__version__ = "0.135.0"

utilities/asyncio.py

@@ -223,6 +223,7 @@ class EnhancedTaskGroup(TaskGroup):
     _semaphore: Semaphore | None
     _timeout: TimeDelta | None
     _error: MaybeType[BaseException]
+    _debug: bool
     _stack: AsyncExitStack
     _timeout_cm: _AsyncGeneratorContextManager[None] | None
 
@@ -233,11 +234,13 @@ class EnhancedTaskGroup(TaskGroup):
         max_tasks: int | None = None,
         timeout: TimeDelta | None = None,
         error: MaybeType[BaseException] = TimeoutError,
+        debug: bool = False,
     ) -> None:
         super().__init__()
         self._semaphore = None if max_tasks is None else Semaphore(max_tasks)
         self._timeout = timeout
         self._error = error
+        self._debug = debug
         self._stack = AsyncExitStack()
         self._timeout_cm = None
 
@@ -254,7 +257,14 @@ class EnhancedTaskGroup(TaskGroup):
         tb: TracebackType | None,
     ) -> None:
         _ = await self._stack.__aexit__(et, exc, tb)
-        _ = await super().__aexit__(et, exc, tb)
+        match self._debug:
+            case True:
+                with suppress(Exception):
+                    _ = await super().__aexit__(et, exc, tb)
+            case False:
+                _ = await super().__aexit__(et, exc, tb)
+            case _ as never:
+                assert_never(never)
 
     @override
     def create_task[T](
@@ -276,6 +286,21 @@ class EnhancedTaskGroup(TaskGroup):
         _ = self._stack.push_async_callback(cm.__aexit__, None, None, None)
         return self.create_task(cm.__aenter__())
 
+    async def run_or_create_task[T](
+        self,
+        coro: _CoroutineLike[T],
+        *,
+        name: str | None = None,
+        context: Context | None = None,
+    ) -> T | Task[T]:
+        match self._debug:
+            case True:
+                return await coro
+            case False:
+                return self.create_task(coro, name=name, context=context)
+            case _ as never:
+                assert_never(never)
+
     async def _wrap_with_semaphore[T](
         self, semaphore: Semaphore, coroutine: _CoroutineLike[T], /
     ) -> T:

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