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

utilities/whenever2.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import datetime as dt
 from collections.abc import Callable
+from dataclasses import dataclass
 from functools import cache
 from logging import LogRecord
 from typing import TYPE_CHECKING, Any, assert_never, overload, override
@@ -17,6 +18,7 @@ from whenever import (
 )
 
 from utilities.datetime import maybe_sub_pct_y
+from utilities.math import sign
 from utilities.sentinel import Sentinel, sentinel
 from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
 from utilities.zoneinfo import UTC, get_time_zone_name
@@ -44,16 +46,52 @@ PLAIN_DATE_TIME_MIN = PlainDateTime.from_py_datetime(dt.datetime.min)  # noqa: D
 PLAIN_DATE_TIME_MAX = PlainDateTime.from_py_datetime(dt.datetime.max)  # noqa: DTZ901
 ZONED_DATE_TIME_MIN = PLAIN_DATE_TIME_MIN.assume_tz(UTC.key)
 ZONED_DATE_TIME_MAX = PLAIN_DATE_TIME_MAX.assume_tz(UTC.key)
-DATE_TIME_DELTA_MIN = DateTimeDelta(days=-3652059, seconds=-316192377600)
-DATE_TIME_DELTA_MAX = DateTimeDelta(days=3652059, seconds=316192377600)
-DATE_DELTA_MIN = DATE_TIME_DELTA_MIN.date_part()
-DATE_DELTA_MAX = DATE_TIME_DELTA_MAX.date_part()
-TIME_DELTA_MIN = DATE_TIME_DELTA_MIN.time_part()
-TIME_DELTA_MAX = DATE_TIME_DELTA_MAX.time_part()
 
 
-DATE_TIME_DELTA_PARSABLE_MIN = DateTimeDelta(days=-999999, seconds=-316192377600)
-DATE_TIME_DELTA_PARSABLE_MAX = DateTimeDelta(days=999999, seconds=316192377600)
+DATE_TIME_DELTA_MIN = DateTimeDelta(
+    weeks=-521722,
+    days=-5,
+    hours=-23,
+    minutes=-59,
+    seconds=-59,
+    milliseconds=-999,
+    microseconds=-999,
+    nanoseconds=-999,
+)
+DATE_TIME_DELTA_MAX = DateTimeDelta(
+    weeks=521722,
+    days=5,
+    hours=23,
+    minutes=59,
+    seconds=59,
+    milliseconds=999,
+    microseconds=999,
+    nanoseconds=999,
+)
+DATE_DELTA_MIN = DATE_TIME_DELTA_MIN.date_part()
+DATE_DELTA_MAX = DATE_TIME_DELTA_MAX.date_part()
+TIME_DELTA_MIN = TimeDelta(hours=-87831216)
+TIME_DELTA_MAX = TimeDelta(hours=87831216)
+
+
+DATE_TIME_DELTA_PARSABLE_MIN = DateTimeDelta(
+    weeks=-142857,
+    hours=-23,
+    minutes=-59,
+    seconds=-59,
+    milliseconds=-999,
+    microseconds=-999,
+    nanoseconds=-999,
+)
+DATE_TIME_DELTA_PARSABLE_MAX = DateTimeDelta(
+    weeks=142857,
+    hours=23,
+    minutes=59,
+    seconds=59,
+    milliseconds=999,
+    microseconds=999,
+    nanoseconds=999,
+)
 DATE_DELTA_PARSABLE_MIN = DateDelta(days=-999999)
 DATE_DELTA_PARSABLE_MAX = DateDelta(days=999999)
 
@@ -163,6 +201,164 @@ def to_date(
             assert_never(never)
 
 
+##
+
+
+def to_days(delta: DateDelta, /) -> int:
+    """Compute the number of days in a date delta."""
+    months, days = delta.in_months_days()
+    if months != 0:
+        raise ToDaysError(months=months)
+    return days
+
+
+@dataclass(kw_only=True, slots=True)
+class ToDaysError(Exception):
+    months: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Date delta must not contain months; got {self.months}"
+
+
+##
+
+
+def to_date_time_delta(nanos: int, /) -> DateTimeDelta:
+    """Construct a date-time delta."""
+    components = _to_time_delta_components(nanos)
+    days, hours = divmod(components.hours, 24)
+    weeks, days = divmod(days, 7)
+    match sign(nanos):  # pragma: no cover
+        case 1:
+            if hours < 0:
+                hours += 24
+                days -= 1
+            if days < 0:
+                days += 7
+                weeks -= 1
+        case -1:
+            if hours > 0:
+                hours -= 24
+                days += 1
+            if days > 0:
+                days -= 7
+                weeks += 1
+        case 0:
+            ...
+    return DateTimeDelta(
+        weeks=weeks,
+        days=days,
+        hours=hours,
+        minutes=components.minutes,
+        seconds=components.seconds,
+        microseconds=components.microseconds,
+        milliseconds=components.milliseconds,
+        nanoseconds=components.nanoseconds,
+    )
+
+
+##
+
+
+def to_nanos(delta: DateTimeDelta, /) -> int:
+    """Compute the number of nanoseconds in a date-time delta."""
+    months, days, _, _ = delta.in_months_days_secs_nanos()
+    if months != 0:
+        raise ToNanosError(months=months)
+    return 24 * 60 * 60 * int(1e9) * days + delta.time_part().in_nanoseconds()
+
+
+@dataclass(kw_only=True, slots=True)
+class ToNanosError(Exception):
+    months: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Date-time delta must not contain months; got {self.months}"
+
+
+##
+
+
+def to_time_delta(nanos: int, /) -> TimeDelta:
+    """Construct a time delta."""
+    components = _to_time_delta_components(nanos)
+    return TimeDelta(
+        hours=components.hours,
+        minutes=components.minutes,
+        seconds=components.seconds,
+        microseconds=components.microseconds,
+        milliseconds=components.milliseconds,
+        nanoseconds=components.nanoseconds,
+    )
+
+
+@dataclass(kw_only=True, slots=True)
+class _TimeDeltaComponents:
+    hours: int
+    minutes: int
+    seconds: int
+    microseconds: int
+    milliseconds: int
+    nanoseconds: int
+
+
+def _to_time_delta_components(nanos: int, /) -> _TimeDeltaComponents:
+    sign_use = sign(nanos)
+    micros, nanos = divmod(nanos, int(1e3))
+    millis, micros = divmod(micros, int(1e3))
+    secs, millis = divmod(millis, int(1e3))
+    mins, secs = divmod(secs, 60)
+    hours, mins = divmod(mins, 60)
+    match sign_use:  # pragma: no cover
+        case 1:
+            if nanos < 0:
+                nanos += int(1e3)
+                micros -= 1
+            if micros < 0:
+                micros += int(1e3)
+                millis -= 1
+            if millis < 0:
+                millis += int(1e3)
+                secs -= 1
+            if secs < 0:
+                secs += 60
+                mins -= 1
+            if mins < 0:
+                mins += 60
+                hours -= 1
+        case -1:
+            if nanos > 0:
+                nanos -= int(1e3)
+                micros += 1
+            if micros > 0:
+                micros -= int(1e3)
+                millis += 1
+            if millis > 0:
+                millis -= int(1e3)
+                secs += 1
+            if secs > 0:
+                secs -= 60
+                mins += 1
+            if mins > 0:
+                mins -= 60
+                hours += 1
+        case 0:
+            ...
+    return _TimeDeltaComponents(
+        hours=hours,
+        minutes=mins,
+        seconds=secs,
+        microseconds=micros,
+        milliseconds=millis,
+        nanoseconds=nanos,
+    )
+
+
+##
+
+
 @overload
 def to_zoned_date_time(*, date_time: MaybeCallableZonedDateTime) -> ZonedDateTime: ...
 @overload
@@ -265,6 +461,8 @@ __all__ = [
     "ZERO_TIME",
     "ZONED_DATE_TIME_MAX",
     "ZONED_DATE_TIME_MIN",
+    "ToDaysError",
+    "ToNanosError",
     "WheneverLogRecord",
     "format_compact",
     "format_compact",
@@ -276,5 +474,8 @@ __all__ = [
     "get_today",
     "get_today_local",
     "to_date",
+    "to_date_time_delta",
+    "to_days",
+    "to_nanos",
     "to_zoned_date_time",
 ]

utilities/tenacity.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from contextlib import AbstractAsyncContextManager, asynccontextmanager
-from typing import TYPE_CHECKING, Any, override
-
-from tenacity import (
-    AsyncRetrying,
-    AttemptManager,
-    RetryCallState,
-    RetryError,
-    after_nothing,
-    before_nothing,
-    retry_if_exception_type,
-    stop_never,
-    wait_none,
-)
-from tenacity import wait_exponential_jitter as _wait_exponential_jitter
-from tenacity._utils import MAX_WAIT
-from tenacity.asyncio import _portable_async_sleep
-
-from utilities.asyncio import timeout_dur
-from utilities.contextlib import NoOpContextManager
-from utilities.datetime import datetime_duration_to_float
-
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Callable
-
-    from tenacity.retry import RetryBaseT
-    from tenacity.stop import StopBaseT
-    from tenacity.wait import WaitBaseT
-
-    from utilities.types import Duration, MaybeAwaitable
-
-
-type MaybeAttemptManager = NoOpContextManager | AttemptManager
-type MaybeAttemptContextManager = AbstractAsyncContextManager[MaybeAttemptManager]
-
-
-class wait_exponential_jitter(_wait_exponential_jitter):  # noqa: N801
-    """Subclass of `wait_exponential_jitter` accepting durations."""
-
-    @override
-    def __init__(
-        self,
-        initial: Duration = 1,
-        max: Duration = MAX_WAIT,
-        exp_base: float = 2,
-        jitter: Duration = 1,
-    ) -> None:
-        super().__init__(
-            initial=datetime_duration_to_float(initial),
-            max=datetime_duration_to_float(max),
-            exp_base=exp_base,
-            jitter=datetime_duration_to_float(jitter),
-        )
-
-
-async def yield_attempts(
-    *,
-    sleep: Callable[[int | float], MaybeAwaitable[None]] | None = None,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    before: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    after: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    before_sleep: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    reraise: bool | None = None,
-    retry_error_cls: type[RetryError] | None = None,
-    retry_error_callback: Callable[[RetryCallState], MaybeAwaitable[Any]] | None = None,
-) -> AsyncIterator[MaybeAttemptManager]:
-    """Yield the attempts."""
-    if (
-        (sleep is None)
-        and (stop is None)
-        and (wait is None)
-        and (retry is None)
-        and (before is None)
-        and (after is None)
-        and (before_sleep is None)
-        and (reraise is None)
-        and (retry_error_cls is None)
-    ):
-        yield NoOpContextManager()
-    else:
-        retrying = AsyncRetrying(
-            sleep=_portable_async_sleep if sleep is None else sleep,
-            stop=stop_never if stop is None else stop,
-            wait=wait_none() if wait is None else wait,
-            retry=retry_if_exception_type() if retry is None else retry,
-            before=before_nothing if before is None else before,
-            after=after_nothing if after is None else after,
-            before_sleep=None if before_sleep is None else before_sleep,
-            reraise=False if reraise is None else reraise,
-            retry_error_cls=RetryError if retry_error_cls is None else retry_error_cls,
-            retry_error_callback=retry_error_callback,
-        )
-        async for attempt in retrying:
-            yield attempt
-
-
-async def yield_timeout_attempts(
-    *,
-    sleep: Callable[[int | float], MaybeAwaitable[None]] | None = None,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    before: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    after: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    before_sleep: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    reraise: bool | None = None,
-    retry_error_cls: type[RetryError] | None = None,
-    retry_error_callback: Callable[[RetryCallState], MaybeAwaitable[Any]] | None = None,
-    timeout: Duration | None = None,
-) -> AsyncIterator[MaybeAttemptContextManager]:
-    """Yield the attempts, with timeout."""
-    async for attempt in yield_attempts(
-        sleep=sleep,
-        stop=stop,
-        wait=wait,
-        retry=retry,
-        before=before,
-        after=after,
-        before_sleep=before_sleep,
-        reraise=reraise,
-        retry_error_cls=retry_error_cls,
-        retry_error_callback=retry_error_callback,
-    ):
-
-        @asynccontextmanager
-        async def new(
-            attempt: MaybeAttemptManager, /
-        ) -> AsyncIterator[MaybeAttemptManager]:
-            with attempt:
-                async with timeout_dur(duration=timeout):
-                    yield attempt
-
-        yield new(attempt)
-
-
-__all__ = [
-    "MaybeAttemptManager",
-    "wait_exponential_jitter",
-    "yield_attempts",
-    "yield_timeout_attempts",
-]