dycw-utilities 0.133.6__tar.gz → 0.133.7__tar.gz

{dycw_utilities-0.133.6 → dycw_utilities-0.133.7}/PKG-INFO

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

{dycw_utilities-0.133.6 → dycw_utilities-0.133.7}/pyproject.toml

@@ -104,7 +104,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.133.6"
+version = "0.133.7"
 
 [project.optional-dependencies]
 logging = [
@@ -131,7 +131,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.133.6"
+current_version = "0.133.7"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.133.6 → dycw_utilities-0.133.7}/src/tests/test_click.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import enum
+from dataclasses import dataclass
 from enum import auto
 from operator import attrgetter
 from re import search
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar
 
 import whenever
 from click import ParamType, argument, command, echo, option
@@ -13,7 +14,6 @@ from hypothesis import given
 from hypothesis.strategies import (
     DataObject,
     SearchStrategy,
-    booleans,
     data,
     frozensets,
     ip_addresses,
@@ -40,6 +40,7 @@ from utilities.click import (
     FrozenSetStrs,
     IPv4Address,
     IPv6Address,
+    ListChoices,
     ListEnums,
     ListStrs,
     Month,
@@ -54,7 +55,6 @@ from utilities.hypothesis import (
     dates,
     freqs,
     months,
-    pairs,
     plain_datetimes,
     text_ascii,
     time_deltas,
@@ -184,124 +184,217 @@ def _lift_serializer(
     return wrapped
 
 
+@dataclass(kw_only=True, slots=True)
+class _Case(Generic[_T]):
+    param: ParamType
+    name: str
+    repr: str | None = None
+    strategy: SearchStrategy[_T]
+    serialize: Callable[[_T], str]
+    failable: bool = False
+
+
 class TestParameters:
-    @given(data=data(), use_value=booleans())
+    cases: ClassVar[list[_Case]] = [
+        _Case(
+            param=Date(),
+            name="date",
+            strategy=dates(),
+            serialize=whenever.Date.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=DateDelta(),
+            name="date delta",
+            strategy=date_deltas(parsable=True),
+            serialize=whenever.DateDelta.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=DateTimeDelta(),
+            name="date-time delta",
+            strategy=date_time_deltas(parsable=True),
+            serialize=whenever.DateTimeDelta.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=Enum(_ExampleEnum),
+            name="enum[_ExampleEnum]",
+            repr="ENUM[_ExampleEnum]",
+            strategy=sampled_from(_ExampleEnum),
+            serialize=attrgetter("name"),
+            failable=True,
+        ),
+        _Case(
+            param=Freq(),
+            name="freq",
+            strategy=freqs(),
+            serialize=utilities.whenever.Freq.serialize,
+            failable=True,
+        ),
+        _Case(
+            param=FrozenSetChoices(["a", "b", "c"]),
+            name="frozenset[choice]",
+            repr="FROZENSET[Choice(['a', 'b', 'c'])]",
+            strategy=frozensets(sampled_from(["a", "b", "c"])),
+            serialize=_lift_serializer(str, sort=True),
+            failable=True,
+        ),
+        _Case(
+            param=FrozenSetEnums(_ExampleEnum),
+            name="frozenset[enum[_ExampleEnum]]",
+            repr="FROZENSET[ENUM[_ExampleEnum]]",
+            strategy=frozensets(sampled_from(_ExampleEnum)),
+            serialize=_lift_serializer(attrgetter("name"), sort=True),
+            failable=True,
+        ),
+        _Case(
+            param=FrozenSetStrs(),
+            name="frozenset[text]",
+            repr="FROZENSET[STRING]",
+            strategy=frozensets(text_ascii()),
+            serialize=_lift_serializer(str, sort=True),
+        ),
+        _Case(
+            param=IPv4Address(),
+            name="ipv4 address",
+            strategy=ip_addresses(v=4),
+            serialize=str,
+            failable=True,
+        ),
+        _Case(
+            param=IPv6Address(),
+            name="ipv6 address",
+            strategy=ip_addresses(v=6),
+            serialize=str,
+            failable=True,
+        ),
+        _Case(
+            param=ListChoices(["a", "b", "c"]),
+            name="list[choice]",
+            repr="LIST[Choice(['a', 'b', 'c'])]",
+            strategy=frozensets(sampled_from(["a", "b", "c"])),
+            serialize=_lift_serializer(str, sort=True),
+            failable=True,
+        ),
+        _Case(
+            param=ListEnums(_ExampleEnum),
+            name="list[enum[_ExampleEnum]]",
+            repr="LIST[ENUM[_ExampleEnum]]",
+            strategy=lists(sampled_from(_ExampleEnum)),
+            serialize=_lift_serializer(attrgetter("name")),
+            failable=True,
+        ),
+        _Case(
+            param=Month(),
+            name="month",
+            strategy=months(),
+            serialize=utilities.whenever.Month.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=PlainDateTime(),
+            name="plain date-time",
+            strategy=plain_datetimes(),
+            serialize=whenever.PlainDateTime.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=Time(),
+            name="time",
+            strategy=times(),
+            serialize=whenever.Time.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=TimeDelta(),
+            name="time-delta",
+            strategy=time_deltas(),
+            serialize=whenever.TimeDelta.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=ZonedDateTime(),
+            name="zoned date-time",
+            strategy=zoned_datetimes(),
+            serialize=whenever.ZonedDateTime.format_common_iso,
+            failable=True,
+        ),
+    ]
+
+    @given(data=data())
     @mark.parametrize(
-        ("param", "exp_repr", "strategy", "serialize", "failable"),
-        [
-            param(Date(), "DATE", dates(), whenever.Date.format_common_iso, True),
-            param(
-                DateDelta(),
-                "DATE DELTA",
-                date_deltas(parsable=True),
-                whenever.DateDelta.format_common_iso,
-                True,
-            ),
-            param(
-                DateTimeDelta(),
-                "DATE-TIME DELTA",
-                date_time_deltas(parsable=True),
-                whenever.DateTimeDelta.format_common_iso,
-                True,
-            ),
-            param(
-                Enum(_ExampleEnum),
-                "ENUM[_ExampleEnum]",
-                sampled_from(_ExampleEnum),
-                attrgetter("name"),
-                True,
-            ),
-            param(Freq(), "FREQ", freqs(), utilities.whenever.Freq.serialize, True),
-            param(
-                FrozenSetChoices(["a", "b", "c"]),
-                "FROZENSET[Choice(['a', 'b', 'c'])]",
-                frozensets(sampled_from(["a", "b", "c"])),
-                _lift_serializer(str, sort=True),
-                True,
-            ),
-            param(
-                FrozenSetEnums(_ExampleEnum),
-                "FROZENSET[ENUM[_ExampleEnum]]",
-                frozensets(sampled_from(_ExampleEnum)),
-                _lift_serializer(attrgetter("name"), sort=True),
-                True,
-            ),
-            param(
-                FrozenSetStrs(),
-                "FROZENSET[STRING]",
-                frozensets(text_ascii()),
-                _lift_serializer(str, sort=True),
-                False,
-            ),
-            param(IPv4Address(), "IPV4 ADDRESS", ip_addresses(v=4), str, True),
-            param(IPv6Address(), "IPV6 ADDRESS", ip_addresses(v=6), str, True),
-            param(
-                ListEnums(_ExampleEnum),
-                "LIST[ENUM[_ExampleEnum]]",
-                lists(sampled_from(_ExampleEnum)),
-                _lift_serializer(attrgetter("name")),
-                True,
-            ),
-            param(
-                Month(),
-                "MONTH",
-                months(),
-                utilities.whenever.Month.format_common_iso,
-                True,
-            ),
-            param(
-                PlainDateTime(),
-                "PLAIN DATE-TIME",
-                plain_datetimes(),
-                whenever.PlainDateTime.format_common_iso,
-                True,
-            ),
-            param(Time(), "TIME", times(), whenever.Time.format_common_iso, True),
-            param(
-                TimeDelta(),
-                "TIME-DELTA",
-                time_deltas(),
-                whenever.TimeDelta.format_common_iso,
-                True,
-            ),
-            param(
-                ZonedDateTime(),
-                "ZONED DATE-TIME",
-                zoned_datetimes(),
-                whenever.ZonedDateTime.format_common_iso,
-                True,
-            ),
-        ],
+        ("param", "strategy", "serialize"),
+        [param(c.param, c.strategy, c.serialize) for c in cases],
     )
-    def test_main(
+    def test_default(
         self,
         *,
         data: DataObject,
         param: ParamType,
-        exp_repr: str,
         strategy: SearchStrategy[Any],
         serialize: Callable[[Any], str],
-        use_value: bool,
-        failable: bool,
     ) -> None:
-        assert repr(param) == exp_repr
-
-        default, value = data.draw(pairs(strategy))
+        default = data.draw(strategy)
 
         @command()
         @option("--value", type=param, default=default)
         def cli(*, value: Any) -> None:
             echo(f"value = {serialize(value)}")
 
-        args = [f"--value={serialize(value)}"] if use_value else None
-        result = CliRunner().invoke(cli, args=args)
+        result = CliRunner().invoke(cli, args=[])
+        assert result.exit_code == 0
+        assert result.stdout == f"value = {serialize(default)}\n"
+
+    @given(data=data())
+    @mark.parametrize(
+        ("param", "strategy", "serialize"),
+        [param(c.param, c.strategy, c.serialize) for c in cases],
+    )
+    def test_cli_value(
+        self,
+        *,
+        data: DataObject,
+        param: ParamType,
+        strategy: SearchStrategy[Any],
+        serialize: Callable[[Any], str],
+    ) -> None:
+        @command()
+        @option("--value", type=param)
+        def cli(*, value: Any) -> None:
+            echo(f"value = {serialize(value)}")
+
+        value = data.draw(strategy)
+        ser = serialize(value)
+        result = CliRunner().invoke(cli, args=[f"--value={ser}"])
         assert result.exit_code == 0
-        expected_str = serialize(value if use_value else default)
-        assert result.stdout == f"value = {expected_str}\n"
+        assert result.stdout == f"value = {ser}\n"
 
-        result = CliRunner().invoke(cli, ["--value=error"])
-        expected = 2 if failable else 0
-        assert result.exit_code == expected
+    @mark.parametrize(
+        ("param", "serialize"),
+        [param(c.param, c.serialize) for c in cases if c.failable],
+    )
+    def test_cli_fail(
+        self, *, param: ParamType, serialize: Callable[[Any], str]
+    ) -> None:
+        @command()
+        @option("--value", type=param)
+        def cli(*, value: Any) -> None:
+            echo(f"value = {serialize(value)}")
+
+        result = CliRunner().invoke(cli, args=["--value=invalid"])
+        assert result.exit_code == 2
+
+    @mark.parametrize(("param", "name"), [param(c.param, c.name) for c in cases])
+    def test_name(self, *, param: ParamType, name: str) -> None:
+        assert param.name == name
+
+    @mark.parametrize(
+        ("param", "repr_", "name"), [param(c.param, c.repr, c.name) for c in cases]
+    )
+    def test_repr(self, *, param: ParamType, repr_: str | None, name: str) -> None:
+        expected = name.upper() if repr_ is None else repr_
+        assert repr(param) == expected
 
     @mark.parametrize(
         "param",

{dycw_utilities-0.133.6 → dycw_utilities-0.133.7}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.133.6"
+__version__ = "0.133.7"

{dycw_utilities-0.133.6 → dycw_utilities-0.133.7}/src/utilities/click.py

@@ -148,9 +148,10 @@ class DateTimeDelta(ParamType):
 class Enum(ParamType, Generic[TEnum]):
     """An enum-valued parameter."""
 
+    @override
     def __init__(self, enum: type[TEnum], /, *, case_sensitive: bool = False) -> None:
         cls = get_class_name(enum)
-        self.name = f"ENUM[{cls}]"
+        self.name = f"enum[{cls}]"
         self._enum = enum
         self._case_sensitive = case_sensitive
         super().__init__()
@@ -180,9 +181,11 @@ class Enum(ParamType, Generic[TEnum]):
 class Freq(ParamType):
     """An frequency-valued parameter."""
 
+    name = "freq"
+
     @override
     def __repr__(self) -> str:
-        return "FREQ"
+        return self.name.upper()
 
     @override
     def convert(
@@ -383,16 +386,16 @@ class ZonedDateTime(ParamType):
 class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
     """A frozenset-valued parameter."""
 
+    @override
     def __init__(self, param: _TParam, /, *, separator: str = ",") -> None:
-        self.name = f"FROZENSET[{param.name}]"
+        self.name = f"frozenset[{param.name}]"
         self._param = param
         self._separator = separator
         super().__init__()
 
     @override
     def __repr__(self) -> str:
-        desc = repr(self._param)
-        return f"FROZENSET[{desc}]"
+        return f"FROZENSET[{self._param!r}]"
 
     @override
     def convert(
@@ -425,6 +428,7 @@ class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
 class FrozenSetChoices(FrozenSetParameter[Choice, str]):
     """A frozenset-of-choices-valued parameter."""
 
+    @override
     def __init__(
         self,
         choices: Sequence[str],
@@ -441,6 +445,7 @@ class FrozenSetChoices(FrozenSetParameter[Choice, str]):
 class FrozenSetEnums(FrozenSetParameter[Enum[TEnum], TEnum]):
     """A frozenset-of-enums-valued parameter."""
 
+    @override
     def __init__(
         self,
         enum: type[TEnum],
@@ -455,6 +460,7 @@ class FrozenSetEnums(FrozenSetParameter[Enum[TEnum], TEnum]):
 class FrozenSetStrs(FrozenSetParameter[StringParamType, str]):
     """A frozenset-of-strs-valued parameter."""
 
+    @override
     def __init__(self, *, separator: str = ",") -> None:
         super().__init__(StringParamType(), separator=separator)
 
@@ -465,16 +471,16 @@ class FrozenSetStrs(FrozenSetParameter[StringParamType, str]):
 class ListParameter(ParamType, Generic[_TParam, _T]):
     """A list-valued parameter."""
 
+    @override
     def __init__(self, param: _TParam, /, *, separator: str = ",") -> None:
-        self.name = f"LIST[{param.name}]"
+        self.name = f"list[{param.name}]"
         self._param = param
         self._separator = separator
         super().__init__()
 
     @override
     def __repr__(self) -> str:
-        desc = repr(self._param)
-        return f"LIST[{desc}]"
+        return f"LIST[{self._param!r}]"
 
     @override
     def convert(
@@ -504,9 +510,27 @@ class ListParameter(ParamType, Generic[_TParam, _T]):
         return _make_metavar(param, desc)
 
 
+class ListChoices(ListParameter[Choice, str]):
+    """A frozenset-of-choices-valued parameter."""
+
+    @override
+    def __init__(
+        self,
+        choices: Sequence[str],
+        /,
+        *,
+        case_sensitive: bool = False,
+        separator: str = ",",
+    ) -> None:
+        super().__init__(
+            Choice(choices, case_sensitive=case_sensitive), separator=separator
+        )
+
+
 class ListEnums(ListParameter[Enum[TEnum], TEnum]):
     """A list-of-enums-valued parameter."""
 
+    @override
     def __init__(
         self,
         enum: type[TEnum],
@@ -521,6 +545,7 @@ class ListEnums(ListParameter[Enum[TEnum], TEnum]):
 class ListStrs(ListParameter[StringParamType, str]):
     """A list-of-strs-valued parameter."""
 
+    @override
     def __init__(self, *, separator: str = ",") -> None:
         super().__init__(StringParamType(), separator=separator)
 
@@ -550,6 +575,7 @@ __all__ = [
     "FrozenSetStrs",
     "IPv4Address",
     "IPv6Address",
+    "ListChoices",
     "ListEnums",
     "ListParameter",
     "ListStrs",