dycw-utilities 0.131.15__py3-none-any.whl → 0.131.17__py3-none-any.whl

utilities/click.py

@@ -1,40 +1,38 @@
 from __future__ import annotations
 
-import datetime as dt
 import pathlib
-from typing import TYPE_CHECKING, Generic, TypedDict, TypeVar, override
-from uuid import UUID
+from typing import TYPE_CHECKING, Generic, TypedDict, TypeVar, 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 StringParamType
 
-import utilities.datetime
-import utilities.types
-from utilities.datetime import EnsureMonthError, MonthLike, ensure_month
+from utilities.datetime import EnsureMonthError, 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.text import split_str
 from utilities.types import (
-    DateTimeLike,
+    DateDeltaLike,
+    DateLike,
+    DateTimeDeltaLike,
     EnumLike,
     MaybeStr,
-    PyDateLike,
-    PyTimeDeltaLike,
-    PyTimeLike,
+    PlainDateTimeLike,
     TEnum,
+    TimeDeltaLike,
+    TimeLike,
+    ZonedDateTimeLike,
 )
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
 
+    import utilities.datetime
+    from utilities.datetime import MonthLike
+
+
 _T = TypeVar("_T")
 _TParam = TypeVar("_TParam", bound=ParamType)
 
@@ -76,21 +74,25 @@ class Date(ParamType):
 
     @override
     def convert(
-        self, value: PyDateLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.date:
+        self, value: DateLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.Date:
         """Convert a value into the `Date` type."""
-        from utilities.whenever import EnsureDateError, ensure_date
-
-        try:
-            return ensure_date(value)
-        except EnsureDateError as error:
-            self.fail(str(error), param, ctx)
+        match value:
+            case whenever.Date():
+                return value
+            case str():
+                try:
+                    return whenever.Date.parse_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as never:
+                assert_never(never)
 
 
-class Duration(ParamType):
-    """A duration-valued parameter."""
+class DateDelta(ParamType):
+    """A date-delta-valued parameter."""
 
-    name = "duration"
+    name = "date delta"
 
     @override
     def __repr__(self) -> str:
@@ -98,18 +100,45 @@ 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
+        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_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as never:
+                assert_never(never)
+
+
+class DateTimeDelta(ParamType):
+    """A date-delta-valued parameter."""
+
+    name = "date-time delta"
 
-        try:
-            return ensure_duration(value)
-        except EnsureDurationError as error:
-            self.fail(str(error), param, ctx)
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @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_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as never:
+                assert_never(never)
 
 
 class Enum(ParamType, Generic[TEnum]):
@@ -167,7 +196,7 @@ class Month(ParamType):
 class PlainDateTime(ParamType):
     """A local-datetime-valued parameter."""
 
-    name = "plain datetime"
+    name = "plain date-time"
 
     @override
     def __repr__(self) -> str:
@@ -175,15 +204,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_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as never:
+                assert_never(never)
 
 
 class Time(ParamType):
@@ -197,21 +230,25 @@ class Time(ParamType):
 
     @override
     def convert(
-        self, value: PyTimeLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.time:
+        self, value: TimeLike, param: Parameter | None, ctx: Context | None
+    ) -> whenever.Time:
         """Convert a value into the `Time` type."""
-        from utilities.whenever import EnsureTimeError, ensure_time
-
-        try:
-            return ensure_time(value)
-        except EnsureTimeError as error:
-            return self.fail(str(error), param=param, ctx=ctx)
-
-
-class Timedelta(ParamType):
+        match value:
+            case whenever.Time():
+                return value
+            case str():
+                try:
+                    return whenever.Time.parse_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as never:
+                assert_never(never)
+
+
+class TimeDelta(ParamType):
     """A timedelta-valued parameter."""
 
-    name = "timedelta"
+    name = "time-delta"
 
     @override
     def __repr__(self) -> str:
@@ -219,21 +256,25 @@ class Timedelta(ParamType):
 
     @override
     def convert(
-        self, value: PyTimeDeltaLike, param: Parameter | None, ctx: Context | None
-    ) -> dt.timedelta:
-        """Convert a value into the `Timedelta` type."""
-        from utilities.whenever import EnsureTimedeltaError, ensure_timedelta
-
-        try:
-            return ensure_timedelta(value)
-        except EnsureTimedeltaError as error:
-            self.fail(str(error), param, ctx)
+        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_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as 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,15 +282,19 @@ 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_common_iso(value)
+                except ValueError as error:
+                    self.fail(str(error), param, ctx)
+            case _ as never:
+                assert_never(never)
 
 
 # parameters - frozenset
@@ -297,20 +342,6 @@ 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."""
 
@@ -341,27 +372,6 @@ class FrozenSetEnums(FrozenSetParameter[Enum[TEnum], TEnum]):
         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."""
-
-    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."""
 
@@ -369,13 +379,6 @@ class FrozenSetStrs(FrozenSetParameter[StringParamType, str]):
         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
 
 
@@ -421,20 +424,6 @@ 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."""
 
@@ -449,27 +438,6 @@ class ListEnums(ListParameter[Enum[TEnum], TEnum]):
         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 = ",") -> None:
-        super().__init__(FloatParamType(), separator=separator)
-
-
-class ListInts(ListParameter[IntParamType, int]):
-    """A list-of-ints-valued parameter."""
-
-    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."""
 
@@ -477,13 +445,6 @@ class ListStrs(ListParameter[StringParamType, str]):
         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
 
 
@@ -495,34 +456,22 @@ def _make_metavar(param: Parameter, desc: str, /) -> str:
 __all__ = [
     "CONTEXT_SETTINGS_HELP_OPTION_NAMES",
     "Date",
+    "DateDelta",
+    "DateTimeDelta",
     "DirPath",
-    "Duration",
     "Enum",
     "ExistingDirPath",
     "ExistingFilePath",
     "FilePath",
-    "FrozenSetBools",
     "FrozenSetChoices",
-    "FrozenSetDates",
     "FrozenSetEnums",
-    "FrozenSetFloats",
-    "FrozenSetInts",
-    "FrozenSetMonths",
     "FrozenSetParameter",
     "FrozenSetStrs",
-    "FrozenSetUUIDs",
-    "ListBools",
-    "ListDates",
     "ListEnums",
-    "ListFloats",
-    "ListInts",
-    "ListMonths",
     "ListParameter",
     "ListStrs",
-    "ListUUIDs",
-    "Month",
     "PlainDateTime",
     "Time",
-    "Timedelta",
+    "TimeDelta",
     "ZonedDateTime",
 ]

utilities/hypothesis.py

@@ -48,7 +48,15 @@ from hypothesis.strategies import (
     uuids,
 )
 from hypothesis.utils.conventions import not_set
-from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from utilities.datetime import (
     DATETIME_MAX_NAIVE,
@@ -97,12 +105,19 @@ from utilities.whenever2 import (
     DATE_DELTA_PARSABLE_MIN,
     DATE_MAX,
     DATE_MIN,
+    DATE_TIME_DELTA_MAX,
+    DATE_TIME_DELTA_MIN,
+    DATE_TIME_DELTA_PARSABLE_MAX,
+    DATE_TIME_DELTA_PARSABLE_MIN,
     PLAIN_DATE_TIME_MAX,
     PLAIN_DATE_TIME_MIN,
     TIME_DELTA_MAX,
     TIME_DELTA_MIN,
     TIME_MAX,
     TIME_MIN,
+    to_date_time_delta,
+    to_days,
+    to_nanos,
 )
 from utilities.zoneinfo import UTC, ensure_time_zone
 
@@ -199,25 +214,11 @@ def date_deltas_whenever(
             ...
         case _ as never:
             assert_never(never)
-    min_years, min_months, min_days = min_value_.in_years_months_days()
-    assert min_years == 0
-    assert min_months == 0
-    max_years, max_months, max_days = max_value_.in_years_months_days()
-    assert max_years == 0
-    assert max_months == 0
+    min_days = to_days(min_value_)
+    max_days = to_days(max_value_)
     if draw2(draw, parsable):
-        parsable_min_years, parsable_min_months, parsable_min_days = (
-            DATE_DELTA_PARSABLE_MIN.in_years_months_days()
-        )
-        assert parsable_min_years == 0
-        assert parsable_min_months == 0
-        min_days = max(min_days, parsable_min_days)
-        parsable_max_years, parsable_max_months, parsable_max_days = (
-            DATE_DELTA_PARSABLE_MAX.in_years_months_days()
-        )
-        assert parsable_max_years == 0
-        assert parsable_max_months == 0
-        max_days = min(max_days, parsable_max_days)
+        min_days = max(min_days, to_days(DATE_DELTA_PARSABLE_MIN))
+        max_days = min(max_days, to_days(DATE_DELTA_PARSABLE_MAX))
     days = draw(integers(min_value=min_days, max_value=max_days))
     return DateDelta(days=days)
 
@@ -287,6 +288,42 @@ def _is_between_timedelta(
 ##
 
 
+@composite
+def date_time_deltas_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[DateTimeDelta | None] = None,
+    max_value: MaybeSearchStrategy[DateTimeDelta | None] = None,
+    parsable: MaybeSearchStrategy[bool] = False,
+) -> DateTimeDelta:
+    """Strategy for generating date deltas."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = DATE_TIME_DELTA_MIN
+        case DateTimeDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_TIME_DELTA_MAX
+        case DateTimeDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    min_nanos, max_nanos = map(to_nanos, [min_value_, max_value_])
+    if draw2(draw, parsable):
+        min_nanos = max(min_nanos, to_nanos(DATE_TIME_DELTA_PARSABLE_MIN))
+        max_nanos = min(max_nanos, to_nanos(DATE_TIME_DELTA_PARSABLE_MAX))
+    nanos = draw(integers(min_value=min_nanos, max_value=max_nanos))
+    return to_date_time_delta(nanos)
+
+
+##
+
+
 @composite
 def dates_two_digit_year(
     draw: DrawFn,
@@ -1468,6 +1505,7 @@ __all__ = [
     "bool_arrays",
     "date_deltas_whenever",
     "date_durations",
+    "date_time_deltas_whenever",
     "dates_two_digit_year",
     "dates_whenever",
     "datetime_durations",

utilities/pottery.py

@@ -8,14 +8,16 @@ from pottery import AIORedlock
 from pottery.exceptions import ReleaseUnlockedLock
 from redis.asyncio import Redis
 
-from utilities.asyncio import sleep_dur, timeout_dur
-from utilities.datetime import MILLISECOND, SECOND, datetime_duration_to_float
+from utilities.asyncio import sleep_td, timeout_td
 from utilities.iterables import always_iterable
+from utilities.whenever2 import MILLISECOND, SECOND
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterable
 
-    from utilities.types import Duration, MaybeIterable
+    from whenever import TimeDelta
+
+    from utilities.types import MaybeIterable
 
 
 @asynccontextmanager
@@ -25,10 +27,10 @@ async def yield_access(
     /,
     *,
     num: int = 1,
-    timeout_acquire: Duration | None = None,
-    timeout_release: Duration = 10 * SECOND,
-    sleep: Duration = MILLISECOND,
-    throttle: Duration | None = None,
+    timeout_acquire: TimeDelta | None = None,
+    timeout_release: TimeDelta = 10 * SECOND,
+    sleep: TimeDelta = MILLISECOND,
+    throttle: TimeDelta | None = None,
 ) -> AsyncIterator[None]:
     """Acquire access to a locked resource, amongst 1 of multiple connections."""
     if num <= 0:
@@ -36,14 +38,11 @@ async def yield_access(
     masters = (  # skipif-ci-and-not-linux
         {redis} if isinstance(redis, Redis) else set(always_iterable(redis))
     )
-    auto_release_time = datetime_duration_to_float(  # skipif-ci-and-not-linux
-        timeout_release
-    )
     locks = [  # skipif-ci-and-not-linux
         AIORedlock(
             key=f"{key}_{i}_of_{num}",
             masters=masters,
-            auto_release_time=auto_release_time,
+            auto_release_time=timeout_release.in_seconds(),
         )
         for i in range(1, num + 1)
     ]
@@ -54,7 +53,7 @@ async def yield_access(
         )
         yield
     finally:  # skipif-ci-and-not-linux
-        await sleep_dur(duration=throttle)
+        await sleep_td(throttle)
         if lock is not None:
             with suppress(ReleaseUnlockedLock):
                 await lock.release()
@@ -66,20 +65,18 @@ async def _get_first_available_lock(
     /,
     *,
     num: int = 1,
-    timeout: Duration | None = None,
-    sleep: Duration | None = None,
+    timeout: TimeDelta | None = None,
+    sleep: TimeDelta | None = None,
 ) -> AIORedlock:
     locks = list(locks)  # skipif-ci-and-not-linux
     error = _YieldAccessUnableToAcquireLockError(  # skipif-ci-and-not-linux
         key=key, num=num, timeout=timeout
     )
-    async with timeout_dur(  # skipif-ci-and-not-linux
-        duration=timeout, error=error
-    ):
+    async with timeout_td(timeout, error=error):  # skipif-ci-and-not-linux
         while True:
             if (result := await _get_first_available_lock_if_any(locks)) is not None:
                 return result
-            await sleep_dur(duration=sleep)
+            await sleep_td(sleep)
 
 
 async def _get_first_available_lock_if_any(
@@ -106,7 +103,7 @@ class _YieldAccessNumLocksError(YieldAccessError):
 
 @dataclass(kw_only=True, slots=True)
 class _YieldAccessUnableToAcquireLockError(YieldAccessError):
-    timeout: Duration | None
+    timeout: TimeDelta | None
 
     @override
     def __str__(self) -> str: