dycw-utilities 0.125.3__tar.gz → 0.125.5__tar.gz

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.125.3
+Version: 0.125.5
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: typing-extensions<4.14,>=4.13.1
 Provides-Extra: test
-Requires-Dist: hypothesis<6.132,>=6.131.27; extra == 'test'
+Requires-Dist: hypothesis<6.132,>=6.131.28; extra == 'test'
 Requires-Dist: pytest-asyncio<0.27,>=0.26.0; extra == 'test'
 Requires-Dist: pytest-cov<6.2,>=6.1.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
-Requires-Dist: pytest-lazy-fixtures<1.2,>=1.1.2; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures<1.2,>=1.1.3; extra == 'test'
 Requires-Dist: pytest-only<2.2,>=2.1.2; extra == 'test'
 Requires-Dist: pytest-randomly<3.17,>=3.16.0; extra == 'test'
 Requires-Dist: pytest-regressions<2.8,>=2.7.0; extra == 'test'
@@ -41,7 +41,7 @@ Requires-Dist: whenever<0.9,>=0.8.2; extra == 'zzz-test-click'
 Provides-Extra: zzz-test-contextlib
 Provides-Extra: zzz-test-contextvars
 Provides-Extra: zzz-test-cryptography
-Requires-Dist: cryptography<45.1,>=45.0.2; extra == 'zzz-test-cryptography'
+Requires-Dist: cryptography<45.1,>=45.0.3; extra == 'zzz-test-cryptography'
 Provides-Extra: zzz-test-cvxpy
 Requires-Dist: cvxpy<1.7,>=1.6.5; extra == 'zzz-test-cvxpy'
 Provides-Extra: zzz-test-dataclasses
@@ -78,7 +78,7 @@ Provides-Extra: zzz-test-hypothesis
 Requires-Dist: aiosqlite<0.22,>=0.21.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: asyncpg<0.31,>=0.30.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: greenlet<3.3,>=3.2.0; extra == 'zzz-test-hypothesis'
-Requires-Dist: hypothesis<6.132,>=6.131.27; extra == 'zzz-test-hypothesis'
+Requires-Dist: hypothesis<6.132,>=6.131.28; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: numpy<2.3,>=2.2.6; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'
@@ -174,7 +174,7 @@ Requires-Dist: scipy<1.16,>=1.15.3; extra == 'zzz-test-scipy'
 Provides-Extra: zzz-test-sentinel
 Provides-Extra: zzz-test-shelve
 Provides-Extra: zzz-test-slack-sdk
-Requires-Dist: aiohttp<3.12,>=3.11.16; extra == 'zzz-test-slack-sdk'
+Requires-Dist: aiohttp<3.13,>=3.12.0; extra == 'zzz-test-slack-sdk'
 Requires-Dist: slack-sdk<3.36,>=3.35.0; extra == 'zzz-test-slack-sdk'
 Provides-Extra: zzz-test-socket
 Provides-Extra: zzz-test-sqlalchemy

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/pyproject.toml

@@ -8,7 +8,7 @@ requires = ["hatchling"]
 # dependency groups
 [dependency-groups]
 dev = [
-  "aiohttp >= 3.11.16, < 3.12",  # for slack
+  "aiohttp >= 3.12.0, < 3.13",  # for slack
   "aiosqlite >= 0.21.0, < 0.22",
   "altair >= 5.5.0, < 5.6",
   "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
@@ -18,14 +18,14 @@ dev = [
   "click >= 8.2.1, < 8.3",
   "coloredlogs >= 15.0.1, < 15.1",
   "concurrent-log-handler >= 0.9.26, < 0.10",
-  "cryptography >= 45.0.2, < 45.1",
+  "cryptography >= 45.0.3, < 45.1",
   "cvxpy >= 1.6.5, < 1.7",
   "eventkit >= 1.0.3, < 1.1",
   "fastapi >= 0.115.11, < 0.116",
   "fpdf2 >= 2.8.3, < 2.9",
   "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
   "httpx >= 0.28.1, < 0.29",  # for fastapi
-  "hypothesis >= 6.131.27, < 6.132",
+  "hypothesis >= 6.131.28, < 6.132",
   "img2pdf >= 0.6.0, < 0.7",
   "lightweight-charts >= 2.1, < 2.2",
   "loguru >= 0.7.3, < 0.8",
@@ -35,6 +35,7 @@ dev = [
   "nest-asyncio >= 1.6.0, < 1.7",  # for sqlalchemy async
   "nox >= 2025.2.9, < 2025.3",
   "numpy >= 2.2.6, < 2.3",
+  "libcst >= 1.7.0, < 1.8",
   "optuna >= 4.3.0, < 4.4",
   "orjson >= 3.10.18, < 3.11",
   "pathvalidate >= 3.2.3, < 3.3",
@@ -44,6 +45,7 @@ dev = [
   "psycopg2-binary >= 2.9.10, < 2.10",  # for sqlalchemy
   "pydantic >= 2.11.4, < 2.12",
   "pyinstrument >= 5.0.2, < 5.1",
+  "pyright[nodejs] >= 1.1.401, < 1.2",
   "pyrsistent >= 0.20.0, < 0.21",
   "pytest >= 8.3.5, < 8.4",
   "pytest-regressions >= 2.7.0, < 2.8",
@@ -70,7 +72,7 @@ dev = [
   "pytest-asyncio >= 0.26.0, < 0.27",
   "pytest-cov >= 6.1.1, < 6.2",
   "pytest-instafail >= 0.5.0, < 0.6",
-  "pytest-lazy-fixtures >= 1.1.2, < 1.2",
+  "pytest-lazy-fixtures >= 1.1.3, < 1.2",
   "pytest-only >= 2.1.2, < 2.2",
   "pytest-randomly >= 3.16.0, < 3.17",
   "pytest-rerunfailures >= 15.1, < 16",
@@ -91,16 +93,16 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.125.3"
+version = "0.125.5"
 
 [project.optional-dependencies]
 test = [
-  "hypothesis >= 6.131.27, < 6.132",
+  "hypothesis >= 6.131.28, < 6.132",
   "pytest >= 8.3.5, < 8.4",
   "pytest-asyncio >= 0.26.0, < 0.27",
   "pytest-cov >= 6.1.1, < 6.2",
   "pytest-instafail >= 0.5.0, < 0.6",
-  "pytest-lazy-fixtures >= 1.1.2, < 1.2",
+  "pytest-lazy-fixtures >= 1.1.3, < 1.2",
   "pytest-only >= 2.1.2, < 2.2",
   "pytest-randomly >= 3.16.0, < 3.17",
   "pytest-regressions >= 2.7.0, < 2.8",
@@ -131,7 +133,7 @@ zzz-test-click = [
 ]
 zzz-test-contextlib = []
 zzz-test-contextvars = []
-zzz-test-cryptography = ["cryptography >= 45.0.2, < 45.1"]
+zzz-test-cryptography = ["cryptography >= 45.0.3, < 45.1"]
 zzz-test-cvxpy = ["cvxpy >= 1.6.5, < 1.7"]
 zzz-test-dataclasses = [
   "orjson >= 3.10.15, < 3.11",
@@ -172,7 +174,7 @@ zzz-test-hypothesis = [
   "aiosqlite >= 0.21.0, < 0.22",
   "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
   "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
-  "hypothesis >= 6.131.27, < 6.132",
+  "hypothesis >= 6.131.28, < 6.132",
   "luigi >= 3.6.0, < 3.7",
   "numpy >= 2.2.6, < 2.3",
   "pathvalidate >= 3.2.3, < 3.3",
@@ -268,7 +270,7 @@ zzz-test-scipy = ["scipy >= 1.15.3, < 1.16"]
 zzz-test-sentinel = []
 zzz-test-shelve = []
 zzz-test-slack-sdk = [
-  "aiohttp >= 3.11.16, < 3.12",  # for slack
+  "aiohttp >= 3.12.0, < 3.13",  # for slack
   "slack-sdk >= 3.35.0, < 3.36",
 ]
 zzz-test-socket = []
@@ -332,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.125.3"
+current_version = "0.125.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -394,6 +396,7 @@ style = [
 [tool.pyright]
 deprecateTypingAliases = true
 enableReachabilityAnalysis = false
+ignore = ["**/_typeshed/**"]
 pythonVersion = "3.12"
 reportAny = false
 reportCallInDefaultInitializer = true

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/tests/test_iterables.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import re
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 from enum import Enum, auto
 from functools import cmp_to_key
 from itertools import chain, repeat
 from math import isfinite, isinf, isnan, nan
 from operator import add, neg, sub
 from re import DOTALL
-from typing import TYPE_CHECKING, Any, ClassVar, override
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from hypothesis import given
 from hypothesis.strategies import (
@@ -52,7 +52,6 @@ from utilities.iterables import (
     CheckSubSetError,
     CheckSuperMappingError,
     CheckSuperSetError,
-    Collection,
     EnsureIterableError,
     EnsureIterableNotStrError,
     MergeStrMappingsError,
@@ -637,168 +636,6 @@ class TestCmpNullable:
         assert result == expected
 
 
-@dataclass(unsafe_hash=True, slots=True)
-class _Item:
-    n: int
-
-
-class TestCollection:
-    def test_and_singleton(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection & _Item(1)
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(1))
-        assert result == expected
-
-    def test_and_collection(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection & Collection(_Item(1))
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(1))
-        assert result == expected
-
-    def test_and_iterable(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection & [_Item(1)]
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(1))
-        assert result == expected
-
-    def test_filter(self) -> None:
-        collection = Collection(map(_Item, range(4)))
-        result = collection.filter(lambda item: item.n % 2 == 0)
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(0), _Item(2))
-        assert result == expected
-
-    def test_hash(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        _ = hash(collection)
-
-    def test_init(self) -> None:
-        class SubCollection(Collection[_Item]):
-            @override
-            def __init__(self, *item_or_items: MaybeIterable[_Item]) -> None:
-                super().__init__(*item_or_items)
-                if any(item.n >= 1 for item in self):
-                    msg = "n >= 1 is not permitted"
-                    raise ValueError(msg)
-
-        with raises(ValueError, match="n >= 1 is not permitted"):
-            _ = SubCollection(map(_Item, range(3)))
-
-    def test_map_return_same_type(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection.map(lambda item: replace(item, n=item.n + 1))
-        assert isinstance(result, Collection)
-        expected = Collection(map(_Item, range(1, 4)))
-        assert result == expected
-
-    def test_map_return_different_type(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection.map(lambda item: item.n)
-        assert isinstance(result, Collection)
-        expected = Collection(range(3))
-        assert result == expected
-
-    def test_new_one_singleton(self) -> None:
-        collection = Collection(_Item(1))
-        assert isinstance(collection, Collection)
-        assert len(collection) == 1
-        assert one(collection) == _Item(1)
-
-    def test_new_one_iterable(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        assert isinstance(collection, Collection)
-        assert len(collection) == 3
-
-    def test_new_many_singletons(self) -> None:
-        collection = Collection(_Item(1), _Item(2), _Item(3))
-        assert isinstance(collection, Collection)
-        assert len(collection) == 3
-
-    def test_new_many_iterables(self) -> None:
-        collection = Collection(map(_Item, range(3)), map(_Item, range(3)))
-        assert isinstance(collection, Collection)
-        assert len(collection) == 3
-
-    def test_new_check_items(self) -> None:
-        class SubCollection(Collection[_Item]):
-            @classmethod
-            @override
-            def check_items(cls, items: Iterable[_Item]) -> None:
-                if any(item.n >= 1 for item in items):
-                    msg = "n >= 1 is not permitted"
-                    raise ValueError(msg)
-
-        with raises(ValueError, match="n >= 1 is not permitted"):
-            _ = SubCollection(map(_Item, range(3)))
-
-    def test_or_singleton(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection | _Item(3)
-        assert isinstance(result, Collection)
-        expected = Collection(map(_Item, range(4)))
-        assert result == expected
-
-    def test_or_collection(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection | Collection(map(_Item, range(1, 4)))
-        assert isinstance(result, Collection)
-        expected = Collection(map(_Item, range(4)))
-        assert result == expected
-
-    def test_or_iterable(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection | map(_Item, range(1, 4))
-        assert isinstance(result, Collection)
-        expected = Collection(map(_Item, range(4)))
-        assert result == expected
-
-    def test_partition(self) -> None:
-        collection = Collection(map(_Item, range(4)))
-        result_false, result_true = collection.partition(lambda item: item.n % 2 == 0)
-        assert isinstance(result_false, Collection)
-        expected_false = Collection(_Item(1), _Item(3))
-        assert result_false == expected_false
-        assert isinstance(result_true, Collection)
-        expected_true = Collection(_Item(0), _Item(2))
-        assert result_true == expected_true
-
-    def test_repr(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = repr(collection)
-        expected = "Collection({_Item(n=0), _Item(n=1), _Item(n=2)})"
-        assert result == expected
-
-    def test_str(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = str(collection)
-        expected = "Collection({_Item(n=0), _Item(n=1), _Item(n=2)})"
-        assert result == expected
-
-    def test_sub_single_item(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection - _Item(1)
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(0), _Item(2))
-        assert result == expected
-
-    def test_sub_collection(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection - Collection(_Item(1))
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(0), _Item(2))
-        assert result == expected
-
-    def test_sub_iterable(self) -> None:
-        collection = Collection(map(_Item, range(3)))
-        result = collection - [_Item(1)]
-        assert isinstance(result, Collection)
-        expected = Collection(_Item(0), _Item(2))
-        assert result == expected
-
-
 class TestEnsureHashables:
     def test_main(self) -> None:
         assert ensure_hashables(1, 2, a=3, b=4) == ([1, 2], {"a": 3, "b": 4})

dycw_utilities-0.125.5/src/tests/test_libcst.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import re
+from re import DOTALL
+
+from hypothesis import given
+from hypothesis.strategies import sampled_from
+from libcst import (
+    Attribute,
+    Dot,
+    Expr,
+    Import,
+    ImportAlias,
+    ImportFrom,
+    ImportStar,
+    Module,
+    Name,
+    SimpleStatementLine,
+)
+from pytest import raises
+
+from tests.conftest import SKIPIF_CI
+from utilities.iterables import one
+from utilities.libcst import (
+    _ParseImportAliasError,
+    _ParseImportEmptyModuleError,
+    generate_f_string,
+    generate_from_import,
+    generate_import,
+    join_dotted_str,
+    parse_import,
+    render_module,
+    split_dotted_str,
+)
+
+
+class TestGenerateFString:
+    def test_main(self) -> None:
+        string = generate_f_string("foo", "bar")
+        result = Module([SimpleStatementLine([Expr(string)])]).code.strip("\n")
+        expected = 'f"{foo}bar"'
+        assert result == expected
+
+
+class TestGenerateFromImport:
+    @given(
+        case=sampled_from([
+            ("foo", "bar", None, "from foo import bar"),
+            ("foo", "bar", "bar2", "from foo import bar as bar2"),
+            ("foo.bar", "baz", None, "from foo.bar import baz"),
+            ("foo.bar", "baz", "baz2", "from foo.bar import baz as baz2"),
+        ])
+    )
+    def test_main(self, *, case: tuple[str, str, str | None, str]) -> None:
+        module, name, asname, expected = case
+        imp = generate_from_import(module, name, asname=asname)
+        result = Module([SimpleStatementLine([imp])]).code.strip("\n")
+        assert result == expected
+
+
+class TestGenerateImport:
+    @given(
+        case=sampled_from([
+            ("foo", None, "import foo"),
+            ("foo", "foo2", "import foo as foo2"),
+            ("foo.bar", None, "import foo.bar"),
+            ("foo.bar", "bar2", "import foo.bar as bar2"),
+        ])
+    )
+    def test_main(self, *, case: tuple[str, str | None, str]) -> None:
+        module, asname, expected = case
+        imp = generate_import(module, asname=asname)
+        result = Module([SimpleStatementLine([imp])]).code.strip("\n")
+        assert result == expected
+
+
+class TestParseImport:
+    def test_import_one_name(self) -> None:
+        imp = Import(names=[ImportAlias(Name("foo"))])
+        parsed = one(parse_import(imp))
+        assert parsed.module == "foo"
+        assert parsed.name is None
+
+    def test_import_one_attr(self) -> None:
+        imp = Import(names=[ImportAlias(Attribute(Name("foo"), Name("bar")))])
+        parsed = one(parse_import(imp))
+        assert parsed.module == "foo.bar"
+        assert parsed.name is None
+
+    def test_import_many(self) -> None:
+        imp = Import(names=[ImportAlias(Name("foo")), ImportAlias(Name("bar"))])
+        result = parse_import(imp)
+        assert len(result) == 2
+        first, second = result
+        assert first.module == "foo"
+        assert first.name is None
+        assert second.module == "bar"
+        assert second.name is None
+
+    def test_from_import_one(self) -> None:
+        imp = ImportFrom(module=Name("foo"), names=[ImportAlias(Name("bar"))])
+        result = one(parse_import(imp))
+        assert result.module == "foo"
+        assert result.name == "bar"
+
+    def test_from_import_many(self) -> None:
+        imp = ImportFrom(
+            module=Name("foo"),
+            names=[ImportAlias(Name("bar")), ImportAlias(Name("baz"))],
+        )
+        result = parse_import(imp)
+        first, second = result
+        assert first.module == "foo"
+        assert first.name == "bar"
+        assert second.module == "foo"
+        assert second.name == "baz"
+
+    def test_from_import_star(self) -> None:
+        imp = ImportFrom(module=Name("foo"), names=ImportStar())
+        result = one(parse_import(imp))
+        assert result.module == "foo"
+        assert result.name == "*"
+
+    def test_error_empty_module(self) -> None:
+        alias = ImportAlias(name=Name("foo"))
+        imp = ImportFrom(module=None, names=[alias], relative=[Dot()])
+        with raises(
+            _ParseImportEmptyModuleError, match="Module must not be None; got .*"
+        ):
+            _ = parse_import(imp)
+
+    def test_error_alias(self) -> None:
+        alias = ImportAlias(name=Attribute(Name("foo"), Name("bar")))
+        imp = ImportFrom(module=Name("baz"), names=[alias])
+        with raises(
+            _ParseImportAliasError,
+            match=re.compile(
+                r"Invalid alias name; got module 'baz' and attribute 'Name\(.*\)'",
+                flags=DOTALL,
+            ),
+        ):
+            _ = parse_import(imp)
+
+
+class TestRenderModule:
+    @SKIPIF_CI
+    def test_main(self) -> None:
+        module = Module([SimpleStatementLine([generate_import("foo")])])
+        result = render_module(module)
+        expected = "import foo\n"
+        assert result == expected
+
+
+class TestSplitAndJoinDottedStr:
+    @given(text=sampled_from(["foo", "foo.bar", "foo.bar.baz"]))
+    def test_main(self, *, text: str) -> None:
+        result = join_dotted_str(split_dotted_str(text))
+        assert result == text

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/tests/test_loguru.py

@@ -6,12 +6,7 @@ from re import search
 from typing import TYPE_CHECKING, Any, cast
 
 from loguru import logger
-from loguru._recattrs import (
-    RecordFile,  # pyright: ignore[reportPrivateImportUsage]
-    RecordLevel,  # pyright: ignore[reportPrivateImportUsage]
-    RecordProcess,  # pyright: ignore[reportPrivateImportUsage]
-    RecordThread,  # pyright: ignore[reportPrivateImportUsage]
-)
+from loguru._recattrs import RecordFile, RecordLevel, RecordProcess, RecordThread
 from pytest import CaptureFixture, fixture, mark, param, raises
 
 from utilities.loguru import (

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/tests/test_polars.py

@@ -51,10 +51,7 @@ from polars import (
     lit,
     struct,
 )
-from polars._typing import (
-    IntoExprColumn,  # pyright: ignore[reportPrivateImportUsage]
-    SchemaDict,  # pyright: ignore[reportPrivateImportUsage]
-)
+from polars._typing import IntoExprColumn, SchemaDict
 from polars.exceptions import ComputeError
 from polars.testing import assert_frame_equal, assert_series_equal
 from pytest import raises
@@ -177,11 +174,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Mapping, Sequence
     from zoneinfo import ZoneInfo
 
-    from polars._typing import (
-        IntoExprColumn,  # pyright: ignore[reportPrivateImportUsage]
-        PolarsDataType,  # pyright: ignore[reportPrivateImportUsage]
-        SchemaDict,  # pyright: ignore[reportPrivateImportUsage]
-    )
+    from polars._typing import IntoExprColumn, PolarsDataType, SchemaDict
     from polars.datatypes import DataTypeClass
 
     from utilities.types import MaybeType, StrMapping, WeekDay

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/tests/test_pytest.py

@@ -19,7 +19,7 @@ from utilities.pytest import (
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-    from _pytest.legacypath import Testdir  # pyright: ignore[reportPrivateImportUsage]
+    from _pytest.legacypath import Testdir
 
 
 _ = random_state

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/tests/test_sqlalchemy_polars.py

@@ -111,9 +111,7 @@ from utilities.sqlalchemy_polars import (
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Sequence
 
-    from polars._typing import (
-        PolarsDataType,  # pyright: ignore[reportPrivateImportUsage]
-    )
+    from polars._typing import PolarsDataType
     from polars.datatypes import DataTypeClass
     from sqlalchemy.ext.asyncio import AsyncEngine
 

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.125.3"
+__version__ = "0.125.5"

{dycw_utilities-0.125.3 → dycw_utilities-0.125.5}/src/utilities/iterables.py

@@ -25,7 +25,6 @@ from typing import (
     Any,
     Generic,
     Literal,
-    Self,
     TypeGuard,
     TypeVar,
     assert_never,
@@ -45,7 +44,7 @@ from utilities.math import (
 )
 from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import Sign, THashable, THashable2, TSupportsAdd, TSupportsLT
+from utilities.types import Sign, THashable, TSupportsAdd, TSupportsLT
 from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
@@ -722,57 +721,6 @@ def chunked(iterable: Iterable[_T], n: int, /) -> Iterator[Sequence[_T]]:
 ##
 
 
-class Collection(frozenset[THashable]):
-    """A collection of hashable, sortable items."""
-
-    def __new__(cls, *item_or_items: MaybeIterable[THashable]) -> Self:
-        items = list(chain(*map(always_iterable, item_or_items)))
-        cls.check_items(items)
-        return super().__new__(cls, items)
-
-    def __init__(self, *item_or_items: MaybeIterable[THashable]) -> None:
-        super().__init__()
-        _ = item_or_items
-
-    @override
-    def __and__(self, other: MaybeIterable[THashable], /) -> Self:
-        if isinstance(other, type(self)):
-            return type(self)(super().__and__(other))
-        return self.__and__(type(self)(other))
-
-    @override
-    def __or__(self, other: MaybeIterable[THashable], /) -> Self:
-        if isinstance(other, type(self)):
-            return type(self)(super().__or__(other))
-        return self.__or__(type(self)(other))
-
-    @override
-    def __sub__(self, other: MaybeIterable[THashable], /) -> Self:
-        if isinstance(other, type(self)):
-            return type(self)(super().__sub__(other))
-        return self.__sub__(type(self)(other))
-
-    @classmethod
-    def check_items(cls, items: Iterable[THashable], /) -> None:
-        _ = items
-
-    def filter(self, func: Callable[[THashable], bool], /) -> Self:
-        return type(self)(filter(func, self))
-
-    def map(self, func: Callable[[THashable], THashable2], /) -> Collection[THashable2]:
-        values = cast("Any", map(func, self))
-        return cast("Any", type(self)(values))
-
-    def partition(self, func: Callable[[THashable], bool], /) -> tuple[Self, Self]:
-        from more_itertools import partition
-
-        is_false, is_true = partition(func, self)
-        return type(self)(is_false), type(self)(is_true)
-
-
-##
-
-
 def ensure_hashables(
     *args: Any, **kwargs: Any
 ) -> tuple[list[Hashable], dict[str, Hashable]]: