dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/click.py

@@ -1,65 +1,60 @@
 from __future__ import annotations
 
-import datetime as dt
+import enum
+import ipaddress
 import pathlib
-from typing import TYPE_CHECKING, Generic, TypedDict, TypeVar, override
-from uuid import UUID
+import uuid
+from enum import StrEnum
+from typing import TYPE_CHECKING, TypedDict, assert_never, override
 
-import click
+import whenever
 from click import Choice, Context, Parameter, ParamType
-from click.types import (
-    BoolParamType,
-    FloatParamType,
-    IntParamType,
-    StringParamType,
-    UUIDParameterType,
-)
+from click.types import IntParamType, StringParamType
 
-import utilities.datetime
-import utilities.types
-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.functions import EnsureStrError, ensure_str, get_class, get_class_name
+from utilities.iterables import is_iterable_not_str, one_unique
+from utilities.parse import ParseObjectError, parse_object
 from utilities.text import split_str
-from utilities.types import (
-    DateLike,
-    DateTimeLike,
-    EnumLike,
-    MaybeStr,
-    TEnum,
-    TimeDeltaLike,
-    TimeLike,
-)
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Sequence
-
-_T = TypeVar("_T")
-_TParam = TypeVar("_TParam", bound=ParamType)
+    from collections.abc import Iterable
+
+    from utilities.types import (
+        DateDeltaLike,
+        DateLike,
+        DateTimeDeltaLike,
+        EnumLike,
+        IPv4AddressLike,
+        IPv6AddressLike,
+        MaybeStr,
+        MonthDayLike,
+        PathLike,
+        PlainDateTimeLike,
+        TimeDeltaLike,
+        TimeLike,
+        YearMonthLike,
+        ZonedDateTimeLike,
+    )
 
 
-FilePath = click.Path(file_okay=True, dir_okay=False, path_type=pathlib.Path)
-DirPath = click.Path(file_okay=False, dir_okay=True, path_type=pathlib.Path)
-ExistingFilePath = click.Path(
-    exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path
-)
-ExistingDirPath = click.Path(
-    exists=True, file_okay=False, dir_okay=True, path_type=pathlib.Path
-)
-
-
-class _HelpOptionNames(TypedDict):
-    help_option_names: Sequence[str]
+class _ContextSettings(TypedDict):
+    context_settings: _ContextSettingsInner
 
 
-class _ContextSettings(TypedDict):
-    context_settings: _HelpOptionNames
+class _ContextSettingsInner(TypedDict):
+    max_content_width: int
+    help_option_names: list[str]
+    show_default: bool
 
 
-CONTEXT_SETTINGS_HELP_OPTION_NAMES = _ContextSettings(
-    context_settings=_HelpOptionNames(help_option_names=["-h", "--help"])
+_MAX_CONTENT_WIDTH = 120
+_CONTEXT_SETTINGS_INNER = _ContextSettingsInner(
+    max_content_width=_MAX_CONTENT_WIDTH,
+    help_option_names=["-h", "--help"],
+    show_default=True,
 )
+CONTEXT_SETTINGS = _ContextSettings(context_settings=_CONTEXT_SETTINGS_INNER)
 
 
 # parameters
@@ -77,20 +72,24 @@ class Date(ParamType):
     @override
     def convert(
         self, value: DateLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.date:
+    ) -> whenever.Date:
         """Convert a value into the `Date` type."""
-        from utilities.whenever import EnsureDateError, ensure_date
+        match value:
+            case whenever.Date():
+                return value
+            case str():
+                try:
+                    return whenever.Date.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
 
-        try:
-            return ensure_date(value)
-        except EnsureDateError as error:
-            self.fail(str(error), param, ctx)
 
+class DateDelta(ParamType):
+    """A date-delta-valued parameter."""
 
-class Duration(ParamType):
-    """A duration-valued parameter."""
-
-    name = "duration"
+    name = "date delta"
 
     @override
     def __repr__(self) -> str:
@@ -98,27 +97,58 @@ class Duration(ParamType):
 
     @override
     def convert(
-        self,
-        value: MaybeStr[utilities.types.Duration],
-        param: Parameter | None,
-        ctx: Context | None,
-    ) -> utilities.types.Duration:
-        """Convert a value into the `Duration` type."""
-        from utilities.whenever import EnsureDurationError, ensure_duration
-
-        try:
-            return ensure_duration(value)
-        except EnsureDurationError as error:
-            self.fail(str(error), param, ctx)
+        self, value: DateDeltaLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.DateDelta:
+        """Convert a value into the `DateDelta` type."""
+        match value:
+            case whenever.DateDelta():
+                return value
+            case str():
+                try:
+                    return whenever.DateDelta.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class DateTimeDelta(ParamType):
+    """A date-delta-valued parameter."""
+
+    name = "date-time delta"
 
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
 
-class Enum(ParamType, Generic[TEnum]):
+    @override
+    def convert(
+        self, value: DateTimeDeltaLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.DateTimeDelta:
+        """Convert a value into the `DateTimeDelta` type."""
+        match value:
+            case whenever.DateTimeDelta():
+                return value
+            case str():
+                try:
+                    return whenever.DateTimeDelta.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class Enum[E: enum.Enum](ParamType):
     """An enum-valued parameter."""
 
-    def __init__(self, enum: type[TEnum], /, *, case_sensitive: bool = False) -> None:
+    @override
+    def __init__(
+        self, enum: type[E], /, *, value: bool = False, case_sensitive: bool = False
+    ) -> None:
         cls = get_class_name(enum)
-        self.name = f"ENUM[{cls}]"
+        self.name = f"enum[{cls}]"
         self._enum = enum
+        self._value = issubclass(self._enum, StrEnum) or value
         self._case_sensitive = case_sensitive
         super().__init__()
 
@@ -129,8 +159,8 @@ class Enum(ParamType, Generic[TEnum]):
 
     @override
     def convert(
-        self, value: EnumLike[TEnum], param: Parameter | None, ctx: Context | None
-    ) -> TEnum:
+        self, value: EnumLike[E], param: Parameter | None, ctx: Context | None
+    ) -> E:
         """Convert a value into the `Enum` type."""
         try:
             return ensure_enum(value, self._enum, case_sensitive=self._case_sensitive)
@@ -140,34 +170,160 @@ class Enum(ParamType, Generic[TEnum]):
     @override
     def get_metavar(self, param: Parameter, ctx: Context) -> str | None:
         _ = ctx
-        desc = ",".join(e.name for e in self._enum)
+        desc = ",".join(str(e.value) if self._value else e.name for e in self._enum)
         return _make_metavar(param, desc)
 
 
-class Month(ParamType):
-    """A month-valued parameter."""
+class EnumPartial[E: enum.Enum](ParamType):
+    """An enum-valued parameter."""
 
-    name = "month"
+    @override
+    def __init__(
+        self,
+        members: Iterable[E],
+        /,
+        *,
+        value: bool = False,
+        case_sensitive: bool = False,
+    ) -> None:
+        self._members = list(members)
+        self._enum = one_unique(get_class(e) for e in self._members)
+        cls = get_class_name(self._enum)
+        self.name = f"enum-partial[{cls}]"
+        self._value = issubclass(self._enum, StrEnum) or value
+        self._case_sensitive = case_sensitive
+        super().__init__()
 
     @override
     def __repr__(self) -> str:
-        return self.name.upper()
+        cls = get_class_name(self._enum)
+        return f"ENUMPARTIAL[{cls}]"
 
     @override
     def convert(
-        self, value: MonthLike, param: Parameter | None, ctx: Context | None
-    ) -> utilities.datetime.Month:
-        """Convert a value into the `Month` type."""
+        self, value: EnumLike[E], param: Parameter | None, ctx: Context | None
+    ) -> E:
+        """Convert a value into the `Enum` type."""
         try:
-            return ensure_month(value)
-        except EnsureMonthError as error:
+            enum = ensure_enum(value, self._enum, case_sensitive=self._case_sensitive)
+        except EnsureEnumError as error:
             self.fail(str(error), param, ctx)
+        if enum in self._members:
+            return enum
+        return self.fail(f"{enum.value!r} is not a selected member")
+
+    @override
+    def get_metavar(self, param: Parameter, ctx: Context) -> str | None:
+        _ = ctx
+        desc = ",".join(str(e.value) if self._value else e.name for e in self._members)
+        return _make_metavar(param, desc)
+
+
+class IPv4Address(ParamType):
+    """An IPv4 address-valued parameter."""
+
+    name = "ipv4 address"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: IPv4AddressLike, param: Parameter | None, ctx: Context | None
+    ) -> ipaddress.IPv4Address:
+        """Convert a value into the `IPv4Address` type."""
+        match value:
+            case ipaddress.IPv4Address():
+                return value
+            case str():
+                try:
+                    return parse_object(ipaddress.IPv4Address, value)
+                except ParseObjectError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class IPv6Address(ParamType):
+    """An IPv6 address-valued parameter."""
+
+    name = "ipv6 address"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: IPv6AddressLike, param: Parameter | None, ctx: Context | None
+    ) -> ipaddress.IPv6Address:
+        """Convert a value into the `IPv6Address` type."""
+        match value:
+            case ipaddress.IPv6Address():
+                return value
+            case str():
+                try:
+                    return parse_object(ipaddress.IPv6Address, value)
+                except ParseObjectError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class MonthDay(ParamType):
+    """A month-day parameter."""
+
+    name = "month-day"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: MonthDayLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.MonthDay:
+        """Convert a value into the `MonthDay` type."""
+        match value:
+            case whenever.MonthDay():
+                return value
+            case str():
+                try:
+                    return whenever.MonthDay.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class Path(ParamType):
+    """A path-valued parameter."""
+
+    name = "path"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: PathLike, param: Parameter | None, ctx: Context | None
+    ) -> pathlib.Path:
+        """Convert a value into the `Path` type."""
+        match value:
+            case pathlib.Path():
+                return value.expanduser()
+            case str():
+                return pathlib.Path(value).expanduser()
+            case never:
+                assert_never(never)
 
 
 class PlainDateTime(ParamType):
     """A local-datetime-valued parameter."""
 
-    name = "plain datetime"
+    name = "plain date-time"
 
     @override
     def __repr__(self) -> str:
@@ -175,15 +331,19 @@ class PlainDateTime(ParamType):
 
     @override
     def convert(
-        self, value: DateTimeLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.date:
-        """Convert a value into the `LocalDateTime` type."""
-        from utilities.whenever import EnsurePlainDateTimeError, ensure_plain_datetime
-
-        try:
-            return ensure_plain_datetime(value)
-        except EnsurePlainDateTimeError as error:
-            self.fail(str(error), param, ctx)
+        self, value: PlainDateTimeLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.PlainDateTime:
+        """Convert a value into the `PlainDateTime` type."""
+        match value:
+            case whenever.PlainDateTime():
+                return value
+            case str():
+                try:
+                    return whenever.PlainDateTime.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
 
 
 class Time(ParamType):
@@ -198,20 +358,50 @@ class Time(ParamType):
     @override
     def convert(
         self, value: TimeLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.time:
+    ) -> whenever.Time:
         """Convert a value into the `Time` type."""
-        from utilities.whenever import EnsureTimeError, ensure_time
+        match value:
+            case whenever.Time():
+                return value
+            case str():
+                try:
+                    return whenever.Time.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class TimeDelta(ParamType):
+    """A timedelta-valued parameter."""
 
-        try:
-            return ensure_time(value)
-        except EnsureTimeError as error:
-            return self.fail(str(error), param=param, ctx=ctx)
+    name = "time-delta"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
 
+    @override
+    def convert(
+        self, value: TimeDeltaLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.TimeDelta:
+        """Convert a value into the `TimeDelta` type."""
+        match value:
+            case whenever.TimeDelta():
+                return value
+            case str():
+                try:
+                    return whenever.TimeDelta.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
 
-class Timedelta(ParamType):
-    """A timedelta-valued parameter."""
 
-    name = "timedelta"
+class UUID(ParamType):
+    """A UUID-valued parameter."""
+
+    name = "uuid"
 
     @override
     def __repr__(self) -> str:
@@ -219,21 +409,51 @@ class Timedelta(ParamType):
 
     @override
     def convert(
-        self, value: TimeDeltaLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.timedelta:
-        """Convert a value into the `Timedelta` type."""
-        from utilities.whenever import EnsureTimedeltaError, ensure_timedelta
+        self, value: uuid.UUID | str, param: Parameter | None, ctx: Context | None
+    ) -> uuid.UUID:
+        """Convert a value into the `UUID` type."""
+        match value:
+            case uuid.UUID():
+                return value
+            case str():
+                try:
+                    return uuid.UUID(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
+
+
+class YearMonth(ParamType):
+    """A year-month parameter."""
+
+    name = "year-month"
 
-        try:
-            return ensure_timedelta(value)
-        except EnsureTimedeltaError as error:
-            self.fail(str(error), param, ctx)
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: YearMonthLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.YearMonth:
+        """Convert a value into the `YearMonth` type."""
+        match value:
+            case whenever.YearMonth():
+                return value
+            case str():
+                try:
+                    return whenever.YearMonth.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
 
 
 class ZonedDateTime(ParamType):
     """A zoned-datetime-valued parameter."""
 
-    name = "zoned datetime"
+    name = "zoned date-time"
 
     @override
     def __repr__(self) -> str:
@@ -241,41 +461,42 @@ class ZonedDateTime(ParamType):
 
     @override
     def convert(
-        self, value: DateTimeLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.date:
-        """Convert a value into the `DateTime` type."""
-        from utilities.whenever import EnsureZonedDateTimeError, ensure_zoned_datetime
-
-        try:
-            return ensure_zoned_datetime(value)
-        except EnsureZonedDateTimeError as error:
-            self.fail(str(error), param, ctx)
+        self, value: ZonedDateTimeLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.ZonedDateTime:
+        """Convert a value into the `ZonedDateTime` type."""
+        match value:
+            case whenever.ZonedDateTime():
+                return value
+            case str():
+                try:
+                    return whenever.ZonedDateTime.parse_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case never:
+                assert_never(never)
 
 
 # parameters - frozenset
 
 
-class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
+class FrozenSetParameter[P: ParamType, T](ParamType):
     """A frozenset-valued parameter."""
 
-    def __init__(self, param: _TParam, /, *, separator: str = ",") -> None:
-        self.name = f"FROZENSET[{param.name}]"
+    @override
+    def __init__(self, param: P, /, *, separator: str = ",") -> None:
+        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(
-        self,
-        value: MaybeStr[Iterable[_T]],
-        param: Parameter | None,
-        ctx: Context | None,
-    ) -> frozenset[_T]:
+        self, value: MaybeStr[Iterable[T]], param: Parameter | None, ctx: Context | None
+    ) -> frozenset[T]:
         """Convert a value into the `ListDates` type."""
         if is_iterable_not_str(value):
             return frozenset(value)
@@ -297,26 +518,13 @@ class FrozenSetParameter(ParamType, Generic[_TParam, _T]):
         return _make_metavar(param, desc)
 
 
-class FrozenSetBools(FrozenSetParameter[BoolParamType, str]):
-    """A frozenset-of-bools-valued parameter."""
-
-    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 = ",") -> None:
-        super().__init__(Date(), separator=separator)
-
-
 class FrozenSetChoices(FrozenSetParameter[Choice, str]):
     """A frozenset-of-choices-valued parameter."""
 
+    @override
     def __init__(
         self,
-        choices: Sequence[str],
+        choices: list[str],
         /,
         *,
         case_sensitive: bool = False,
@@ -327,79 +535,53 @@ class FrozenSetChoices(FrozenSetParameter[Choice, str]):
         )
 
 
-class FrozenSetEnums(FrozenSetParameter[Enum[TEnum], TEnum]):
+class FrozenSetEnums[E: enum.Enum](FrozenSetParameter[Enum[E], E]):
     """A frozenset-of-enums-valued parameter."""
 
+    @override
     def __init__(
-        self,
-        enum: type[TEnum],
-        /,
-        *,
-        case_sensitive: bool = False,
-        separator: str = ",",
+        self, enum: type[E], /, *, case_sensitive: bool = False, separator: str = ","
     ) -> None:
         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 = ",") -> None:
-        super().__init__(FloatParamType(), separator=separator)
-
-
 class FrozenSetInts(FrozenSetParameter[IntParamType, int]):
     """A frozenset-of-ints-valued parameter."""
 
+    @override
     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 = ",") -> None:
-        super().__init__(Month(), separator=separator)
-
-
 class FrozenSetStrs(FrozenSetParameter[StringParamType, str]):
     """A frozenset-of-strs-valued parameter."""
 
+    @override
     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 = ",") -> None:
-        super().__init__(UUIDParameterType(), separator=separator)
-
-
 # parameters - list
 
 
-class ListParameter(ParamType, Generic[_TParam, _T]):
+class ListParameter[P: ParamType, T](ParamType):
     """A list-valued parameter."""
 
-    def __init__(self, param: _TParam, /, *, separator: str = ",") -> None:
-        self.name = f"LIST[{param.name}]"
+    @override
+    def __init__(self, param: P, /, *, separator: str = ",") -> None:
+        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(
-        self,
-        value: MaybeStr[Iterable[_T]],
-        param: Parameter | None,
-        ctx: Context | None,
-    ) -> list[_T]:
+        self, value: MaybeStr[Iterable[T]], param: Parameter | None, ctx: Context | None
+    ) -> list[T]:
         """Convert a value into the `List` type."""
         if is_iterable_not_str(value):
             return list(value)
@@ -421,69 +603,49 @@ class ListParameter(ParamType, Generic[_TParam, _T]):
         return _make_metavar(param, desc)
 
 
-class ListBools(ListParameter[BoolParamType, str]):
-    """A list-of-bools-valued parameter."""
-
-    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 = ",") -> None:
-        super().__init__(Date(), separator=separator)
-
-
-class ListEnums(ListParameter[Enum[TEnum], TEnum]):
-    """A list-of-enums-valued parameter."""
+class ListChoices(ListParameter[Choice, str]):
+    """A frozenset-of-choices-valued parameter."""
 
+    @override
     def __init__(
         self,
-        enum: type[TEnum],
+        choices: list[str],
         /,
         *,
         case_sensitive: bool = False,
         separator: str = ",",
     ) -> None:
-        super().__init__(Enum(enum, case_sensitive=case_sensitive), separator=separator)
+        super().__init__(
+            Choice(choices, case_sensitive=case_sensitive), separator=separator
+        )
 
 
-class ListFloats(ListParameter[FloatParamType, float]):
-    """A list-of-floats-valued parameter."""
+class ListEnums[E: enum.Enum](ListParameter[Enum[E], E]):
+    """A list-of-enums-valued parameter."""
 
-    def __init__(self, *, separator: str = ",") -> None:
-        super().__init__(FloatParamType(), separator=separator)
+    @override
+    def __init__(
+        self, enum: type[E], /, *, case_sensitive: bool = False, separator: str = ","
+    ) -> None:
+        super().__init__(Enum(enum, case_sensitive=case_sensitive), separator=separator)
 
 
 class ListInts(ListParameter[IntParamType, int]):
     """A list-of-ints-valued parameter."""
 
+    @override
     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 = ",") -> None:
-        super().__init__(Month(), separator=separator)
-
-
 class ListStrs(ListParameter[StringParamType, str]):
     """A list-of-strs-valued parameter."""
 
+    @override
     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 = ",") -> None:
-        super().__init__(UUIDParameterType(), separator=separator)
-
-
 # private
 
 
@@ -493,36 +655,30 @@ def _make_metavar(param: Parameter, desc: str, /) -> str:
 
 
 __all__ = [
-    "CONTEXT_SETTINGS_HELP_OPTION_NAMES",
+    "CONTEXT_SETTINGS",
+    "UUID",
     "Date",
-    "DirPath",
-    "Duration",
+    "DateDelta",
+    "DateTimeDelta",
     "Enum",
-    "ExistingDirPath",
-    "ExistingFilePath",
-    "FilePath",
-    "FrozenSetBools",
+    "EnumPartial",
     "FrozenSetChoices",
-    "FrozenSetDates",
     "FrozenSetEnums",
-    "FrozenSetFloats",
-    "FrozenSetInts",
-    "FrozenSetMonths",
     "FrozenSetParameter",
     "FrozenSetStrs",
-    "FrozenSetUUIDs",
-    "ListBools",
-    "ListDates",
+    "IPv4Address",
+    "IPv6Address",
+    "ListChoices",
     "ListEnums",
-    "ListFloats",
     "ListInts",
-    "ListMonths",
     "ListParameter",
     "ListStrs",
-    "ListUUIDs",
-    "Month",
+    "MonthDay",
+    "Path",
+    "Path",
     "PlainDateTime",
     "Time",
-    "Timedelta",
+    "TimeDelta",
+    "YearMonth",
     "ZonedDateTime",
 ]