dycw-utilities 0.109.23__tar.gz → 0.109.25__tar.gz

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/PKG-INFO

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

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/pyproject.toml

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

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/src/tests/test_iterables.py

@@ -4,7 +4,7 @@ import re
 from dataclasses import dataclass, replace
 from enum import Enum, auto
 from itertools import chain, repeat
-from math import isfinite, isinf, isnan
+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
@@ -1359,6 +1359,10 @@ class TestSortIterablesCmpFloats:
         if isnan(x) is not isnan(y):
             assert result1 != result2
 
+    def test_nan_vs_nan(self) -> None:
+        result = _sort_iterable_cmp_floats(nan, nan)
+        assert result == 0
+
 
 class TestSumMappings:
     @given(mappings=lists(dictionaries(text_ascii(), integers())))

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/src/tests/test_pqdm.py

@@ -14,11 +14,11 @@ from utilities.hypothesis import int32s, pairs, settings_with_reduced_examples
 from utilities.iterables import transpose
 from utilities.pqdm import _get_desc, pqdm_map, pqdm_starmap
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import Parallelism
+from utilities.types import Parallelism, StrStrMapping
 from utilities.typing import get_args
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Mapping
+    from collections.abc import Callable
 
 
 class TestGetDesc:
@@ -36,7 +36,7 @@ class TestGetDesc:
         *,
         desc: str | None | Sentinel,
         func: Callable[..., Any],
-        expected: Mapping[str, str],
+        expected: StrStrMapping,
     ) -> None:
         assert _get_desc(desc, func) == expected
 

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/src/tests/test_text.py

@@ -1,32 +1,41 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from hypothesis import given
 from hypothesis.strategies import (
     DataObject,
     booleans,
     data,
     integers,
+    just,
     lists,
+    none,
     sampled_from,
     sets,
 )
 from pytest import mark, param, raises
 
 from utilities.hypothesis import text_ascii
-from utilities.sentinel import sentinel
 from utilities.text import (
     ParseBoolError,
     ParseNoneError,
+    SplitKeyValuePairsError,
+    SplitStrError,
     join_strs,
     parse_bool,
     parse_none,
     repr_encode,
     snake_case,
+    split_key_value_pairs,
     split_str,
     str_encode,
     strip_and_dedent,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class TestParseBool:
     @given(data=data(), value=booleans())
@@ -66,20 +75,60 @@ class TestReprEncode:
         assert result == expected
 
 
+class TestSplitKeyValuePairs:
+    @given(
+        case=sampled_from([
+            ("", []),
+            ("a=1", [("a", "1")]),
+            ("a=1,b=22", [("a", "1"), ("b", "22")]),
+            ("a=1,b=22,c=333", [("a", "1"), ("b", "22"), ("c", "333")]),
+            ("=1", [("", "1")]),
+            ("a=", [("a", "")]),
+            ("a=1,=22,c=333", [("a", "1"), ("", "22"), ("c", "333")]),
+            ("a=1,b=,c=333", [("a", "1"), ("b", ""), ("c", "333")]),
+        ])
+    )
+    def test_main(self, *, case: tuple[str, Sequence[tuple[str, str]]]) -> None:
+        text, expected = case
+        result = split_key_value_pairs(text)
+        assert result == expected
+
+    def test_mapping(self) -> None:
+        result = split_key_value_pairs("a=1,b=22,c=333", mapping=True)
+        expected = {"a": "1", "b": "22", "c": "333"}
+        assert result == expected
+
+    def test_error(self) -> None:
+        with raises(
+            SplitKeyValuePairsError,
+            match=r"Unable to split 'a=1,a=22,a=333' into a mapping since there are duplicate keys; got \{'a': 3\}",
+        ):
+            _ = split_key_value_pairs("a=1,a=22,a=333", mapping=True)
+
+
 class TestSplitStrAndJoinStr:
-    @mark.parametrize(
-        ("text", "texts"),
-        [
-            param("", [""]),
-            param("1", ["1"]),
-            param("1,2", ["1", "2"]),
-            param(",", ["", ""]),
-            param(str(sentinel), []),
-        ],
+    @given(
+        data=data(),
+        case=sampled_from([
+            ("", 0, []),
+            (r"\,", 1, [""]),
+            (",", 2, ["", ""]),
+            (",,", 3, ["", "", ""]),
+            ("1", 1, ["1"]),
+            ("1,22", 2, ["1", "22"]),
+            ("1,22,333", 3, ["1", "22", "333"]),
+            ("1,,333", 3, ["1", "", "333"]),
+        ]),
     )
-    def test_main(self, *, text: str, texts: list[str]) -> None:
-        assert split_str(text) == texts
-        assert join_strs(texts) == text
+    def test_main(self, *, case: tuple[str, int, list[str]], data: DataObject) -> None:
+        text, n, expected = case
+        n_use = data.draw(just(n) | none())
+        result = split_str(text, n=n_use)
+        if n_use is None:
+            assert result == expected
+        else:
+            assert result == tuple(expected)
+        assert join_strs(result) == text
 
     @given(texts=lists(text_ascii()))
     def test_generic(self, *, texts: list[str]) -> None:
@@ -89,6 +138,12 @@ class TestSplitStrAndJoinStr:
     def test_sort(self, *, texts: set[str]) -> None:
         assert split_str(join_strs(texts, sort=True)) == sorted(texts)
 
+    def test_error(self) -> None:
+        with raises(
+            SplitStrError, match=r"Unable to split '1,22,333' into 4 part\(s\); got 3"
+        ):
+            _ = split_str("1,22,333", n=4)
+
 
 class TestSnakeCase:
     @given(

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.109.23"
+__version__ = "0.109.25"

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/src/utilities/click.py

@@ -21,7 +21,6 @@ from utilities.datetime import EnsureMonthError, MonthLike, ensure_month
 from utilities.enum import EnsureEnumError, ensure_enum
 from utilities.functions import EnsureStrError, ensure_str, get_class_name
 from utilities.iterables import is_iterable_not_str
-from utilities.sentinel import SENTINEL_REPR
 from utilities.text import split_str
 from utilities.types import (
     DateLike,
@@ -245,13 +244,10 @@ class ZonedDateTime(ParamType):
 class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
     """A frozenset-valued parameter."""
 
-    def __init__(
-        self, param: _TParam, /, *, separator: str = ",", empty: str = SENTINEL_REPR
-    ) -> None:
+    def __init__(self, param: _TParam, /, *, separator: str = ",") -> None:
         self.name = f"FROZENSET[{param.name}]"
         self._param = param
         self._separator = separator
-        self._empty = empty
         super().__init__()
 
     @override
@@ -273,7 +269,7 @@ class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
             text = ensure_str(value)
         except EnsureStrError as error:
             return self.fail(str(error), param=param, ctx=ctx)
-        values = split_str(text, separator=self._separator, empty=self._empty)
+        values = split_str(text, separator=self._separator)
         return frozenset(self._param.convert(v, param, ctx) for v in values)
 
     @override
@@ -290,15 +286,15 @@ class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
 class FrozenSetBools(FrozenSetParameter[BoolParamType, str]):
     """A frozenset-of-bools-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(BoolParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(BoolParamType(), separator=separator)
 
 
 class FrozenSetDates(FrozenSetParameter[Date, dt.date]):
     """A frozenset-of-dates-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(Date(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(Date(), separator=separator)
 
 
 class FrozenSetChoices(FrozenSetParameter[Choice, str]):
@@ -311,12 +307,9 @@ class FrozenSetChoices(FrozenSetParameter[Choice, str]):
         *,
         case_sensitive: bool = False,
         separator: str = ",",
-        empty: str = SENTINEL_REPR,
     ) -> None:
         super().__init__(
-            Choice(choices, case_sensitive=case_sensitive),
-            separator=separator,
-            empty=empty,
+            Choice(choices, case_sensitive=case_sensitive), separator=separator
         )
 
 
@@ -330,46 +323,43 @@ class FrozenSetEnums(FrozenSetParameter[Enum[TEnum], TEnum]):
         *,
         case_sensitive: bool = False,
         separator: str = ",",
-        empty: str = SENTINEL_REPR,
     ) -> None:
-        super().__init__(
-            Enum(enum, case_sensitive=case_sensitive), separator=separator, empty=empty
-        )
+        super().__init__(Enum(enum, case_sensitive=case_sensitive), separator=separator)
 
 
 class FrozenSetFloats(FrozenSetParameter[FloatParamType, float]):
     """A frozenset-of-floats-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(FloatParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(FloatParamType(), separator=separator)
 
 
 class FrozenSetInts(FrozenSetParameter[IntParamType, int]):
     """A frozenset-of-ints-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(IntParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(IntParamType(), separator=separator)
 
 
 class FrozenSetMonths(FrozenSetParameter[Month, utilities.datetime.Month]):
     """A frozenset-of-months-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(Month(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(Month(), separator=separator)
 
 
 class FrozenSetStrs(FrozenSetParameter[StringParamType, str]):
     """A frozenset-of-strs-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(StringParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(StringParamType(), separator=separator)
 
 
 class FrozenSetUUIDs(FrozenSetParameter[UUIDParameterType, UUID]):
     """A frozenset-of-UUIDs-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(UUIDParameterType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(UUIDParameterType(), separator=separator)
 
 
 # parameters - list
@@ -378,13 +368,10 @@ class FrozenSetUUIDs(FrozenSetParameter[UUIDParameterType, UUID]):
 class ListParameter(ParamType, Generic[_TParam, _T]):
     """A list-valued parameter."""
 
-    def __init__(
-        self, param: _TParam, /, *, separator: str = ",", empty: str = SENTINEL_REPR
-    ) -> None:
+    def __init__(self, param: _TParam, /, *, separator: str = ",") -> None:
         self.name = f"LIST[{param.name}]"
         self._param = param
         self._separator = separator
-        self._empty = empty
         super().__init__()
 
     @override
@@ -406,7 +393,7 @@ class ListParameter(ParamType, Generic[_TParam, _T]):
             text = ensure_str(value)
         except EnsureStrError as error:
             return self.fail(str(error), param=param, ctx=ctx)
-        values = split_str(text, separator=self._separator, empty=self._empty)
+        values = split_str(text, separator=self._separator)
         return [self._param.convert(v, param, ctx) for v in values]
 
     @override
@@ -423,15 +410,15 @@ class ListParameter(ParamType, Generic[_TParam, _T]):
 class ListBools(ListParameter[BoolParamType, str]):
     """A list-of-bools-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(BoolParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(BoolParamType(), separator=separator)
 
 
 class ListDates(ListParameter[Date, dt.date]):
     """A list-of-dates-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(Date(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(Date(), separator=separator)
 
 
 class ListEnums(ListParameter[Enum[TEnum], TEnum]):
@@ -444,46 +431,43 @@ class ListEnums(ListParameter[Enum[TEnum], TEnum]):
         *,
         case_sensitive: bool = False,
         separator: str = ",",
-        empty: str = SENTINEL_REPR,
     ) -> None:
-        super().__init__(
-            Enum(enum, case_sensitive=case_sensitive), separator=separator, empty=empty
-        )
+        super().__init__(Enum(enum, case_sensitive=case_sensitive), separator=separator)
 
 
 class ListFloats(ListParameter[FloatParamType, float]):
     """A list-of-floats-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(FloatParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(FloatParamType(), separator=separator)
 
 
 class ListInts(ListParameter[IntParamType, int]):
     """A list-of-ints-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(IntParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(IntParamType(), separator=separator)
 
 
 class ListMonths(ListParameter[Month, utilities.datetime.Month]):
     """A list-of-months-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(Month(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(Month(), separator=separator)
 
 
 class ListStrs(ListParameter[StringParamType, str]):
     """A list-of-strs-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(StringParamType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(StringParamType(), separator=separator)
 
 
 class ListUUIDs(ListParameter[UUIDParameterType, UUID]):
     """A list-of-UUIDs-valued parameter."""
 
-    def __init__(self, *, separator: str = ",", empty: str = SENTINEL_REPR) -> None:
-        super().__init__(UUIDParameterType(), separator=separator, empty=empty)
+    def __init__(self, *, separator: str = ",") -> None:
+        super().__init__(UUIDParameterType(), separator=separator)
 
 
 # private

{dycw_utilities-0.109.23 → dycw_utilities-0.109.25}/src/utilities/dataclasses.py

@@ -24,7 +24,7 @@ from utilities.iterables import OneStrEmptyError, OneStrNonUniqueError, one_str
 from utilities.operator import is_equal
 from utilities.parse import ParseTextError, parse_text
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import ParseTextExtra, TDataclass
+from utilities.types import ParseTextExtra, StrStrMapping, TDataclass
 from utilities.typing import get_type_hints
 
 if TYPE_CHECKING:
@@ -444,7 +444,7 @@ class StrMappingToFieldMappingError(Exception):
 
 
 def text_to_dataclass(
-    text_or_mapping: str | Mapping[str, str],
+    text_or_mapping: str | StrStrMapping,
     cls: type[TDataclass],
     /,
     *,
@@ -499,9 +499,7 @@ def text_to_dataclass(
     )
 
 
-def _text_to_dataclass_split_text(
-    text: str, cls: type[TDataclass], /
-) -> Mapping[str, str]:
+def _text_to_dataclass_split_text(text: str, cls: type[TDataclass], /) -> StrStrMapping:
     pairs = (t for t in text.split(",") if t != "")
     return dict(_text_to_dataclass_split_key_value_pair(pair, cls) for pair in pairs)