dycw-utilities 0.131.5__tar.gz → 0.131.7__tar.gz

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/PKG-INFO

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

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/pyproject.toml

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

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/src/tests/test_hypothesis.py

@@ -28,7 +28,7 @@ from luigi import Task
 from numpy import inf, int64, isfinite, isinf, isnan, ravel, rint
 from pathvalidate import validate_filepath
 from pytest import mark, raises
-from whenever import Date, DateDelta, PlainDateTime, ZonedDateTime
+from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -92,7 +92,9 @@ from utilities.hypothesis import (
     text_clean,
     text_digits,
     text_printable,
+    time_deltas_whenever,
     timedeltas_2w,
+    times_whenever,
     triples,
     uint32s,
     uint64s,
@@ -1153,6 +1155,38 @@ class TestTimeDeltas2W:
         assert min_value <= timedelta <= max_value
 
 
+class TestTimeDeltas:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(time_deltas_whenever() | none())
+        max_value = data.draw(time_deltas_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            delta = data.draw(
+                time_deltas_whenever(min_value=min_value, max_value=max_value)
+            )
+        assert isinstance(delta, TimeDelta)
+        assert TimeDelta.parse_common_iso(delta.format_common_iso()) == delta
+        if min_value is not None:
+            assert delta >= min_value
+        if max_value is not None:
+            assert delta <= max_value
+
+
+class TestTimes:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(times_whenever() | none())
+        max_value = data.draw(times_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            time = data.draw(times_whenever(min_value=min_value, max_value=max_value))
+        assert isinstance(time, Time)
+        assert Time.parse_common_iso(time.format_common_iso()) == time
+        if min_value is not None:
+            assert time >= min_value
+        if max_value is not None:
+            assert time <= max_value
+
+
 class TestTriples:
     @given(data=data(), unique=booleans(), sorted_=booleans())
     def test_main(self, *, data: DataObject, unique: bool, sorted_: bool) -> None:

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/src/tests/test_whenever2.py

@@ -6,11 +6,12 @@ from zoneinfo import ZoneInfo
 from hypothesis import given
 from hypothesis.strategies import just, timezones
 from pytest import mark, param, raises
-from whenever import DateDelta, DateTimeDelta, TimeDelta, ZonedDateTime
+from whenever import Date, DateDelta, DateTimeDelta, TimeDelta, ZonedDateTime
 
 from tests.conftest import IS_CI
 from utilities.hypothesis import zoned_datetimes_whenever
 from utilities.tzdata import HongKong, Tokyo
+from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.whenever2 import (
     DATE_DELTA_MAX,
     DATE_DELTA_MIN,
@@ -22,11 +23,14 @@ from utilities.whenever2 import (
     DATE_TIME_DELTA_MIN,
     DATE_TIME_DELTA_PARSABLE_MAX,
     DATE_TIME_DELTA_PARSABLE_MIN,
+    NOW_LOCAL,
     NOW_UTC,
     PLAIN_DATE_TIME_MAX,
     PLAIN_DATE_TIME_MIN,
     TIME_DELTA_MAX,
     TIME_DELTA_MIN,
+    TODAY_LOCAL,
+    TODAY_UTC,
     ZONED_DATE_TIME_MAX,
     ZONED_DATE_TIME_MIN,
     WheneverLogRecord,
@@ -35,6 +39,8 @@ from utilities.whenever2 import (
     from_timestamp_nanos,
     get_now,
     get_now_local,
+    get_today,
+    get_today_local,
 )
 from utilities.zoneinfo import UTC
 
@@ -81,6 +87,28 @@ class TestGetNowLocal:
         time_zones = {ETC, HongKong, Tokyo, UTC}
         assert any(now.tz == time_zone.key for time_zone in time_zones)
 
+    def test_constant(self) -> None:
+        assert isinstance(NOW_LOCAL, ZonedDateTime)
+        assert NOW_LOCAL.tz == LOCAL_TIME_ZONE.key
+
+
+class TestGetToday:
+    def test_function(self) -> None:
+        today = get_today()
+        assert isinstance(today, Date)
+
+    def test_constant(self) -> None:
+        assert isinstance(TODAY_UTC, Date)
+
+
+class TestGetTodayLocal:
+    def test_function(self) -> None:
+        today = get_today_local()
+        assert isinstance(today, Date)
+
+    def test_constant(self) -> None:
+        assert isinstance(TODAY_LOCAL, Date)
+
 
 class TestMinMax:
     def test_date_min(self) -> None:
@@ -151,19 +179,19 @@ class TestMinMax:
 
     def test_date_time_delta_parsable_min(self) -> None:
         def func(delta: DateTimeDelta, /) -> None:
-            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+            _ = DateTimeDelta.parse_common_iso(delta.format_common_iso())
 
         _ = func(DATE_TIME_DELTA_PARSABLE_MIN)
-        with raises(ValueError, match="Invalid format: '.*'"):
+        with raises(ValueError, match="Addition result out of bounds"):
             _ = func(DATE_TIME_DELTA_PARSABLE_MIN - DateTimeDelta(nanoseconds=1))
 
     def test_date_time_delta_parsable_max(self) -> None:
         def func(delta: DateTimeDelta, /) -> None:
-            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+            _ = DateTimeDelta.parse_common_iso(delta.format_common_iso())
 
         _ = func(DATE_TIME_DELTA_PARSABLE_MAX)
-        with raises(ValueError, match="Invalid format: '.*'"):
-            _ = func(DATE_TIME_DELTA_PARSABLE_MAX + DateTimeDelta(nanoseconds=1))
+        with raises(ValueError, match="Invalid format or out of range: '.*'"):
+            _ = func(DATE_TIME_DELTA_PARSABLE_MAX + TimeDelta(nanoseconds=1))
 
     def test_plain_date_time_min(self) -> None:
         with raises(ValueError, match=r"Result of subtract\(\) out of range"):
@@ -184,6 +212,7 @@ class TestMinMax:
         ],
     )
     def test_time_delta_min(self, *, delta: TimeDelta) -> None:
+        _ = TimeDelta.parse_common_iso(TIME_DELTA_MIN.format_common_iso())
         with raises(ValueError, match="Addition result out of range"):
             _ = TIME_DELTA_MIN - delta
 
@@ -202,6 +231,7 @@ class TestMinMax:
     def test_time_delta_max(self, *, delta: TimeDelta, is_ok: bool) -> None:
         if is_ok:
             _ = TIME_DELTA_MAX + delta
+            _ = TimeDelta.parse_common_iso(delta.format_common_iso())
         else:
             with raises(ValueError, match="Addition result out of range"):
                 _ = TIME_DELTA_MAX + delta

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.5"
+__version__ = "0.131.7"

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/src/utilities/hypothesis.py

@@ -24,6 +24,7 @@ from typing import (
     override,
 )
 
+import hypothesis.strategies
 from hypothesis import HealthCheck, Phase, Verbosity, assume, settings
 from hypothesis.errors import InvalidArgument
 from hypothesis.strategies import (
@@ -47,7 +48,7 @@ from hypothesis.strategies import (
     uuids,
 )
 from hypothesis.utils.conventions import not_set
-from whenever import Date, DateDelta
+from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta
 
 from utilities.datetime import (
     DATETIME_MAX_NAIVE,
@@ -89,6 +90,20 @@ from utilities.platform import IS_WINDOWS
 from utilities.sentinel import Sentinel, sentinel
 from utilities.tempfile import TEMP_DIR, TemporaryDirectory
 from utilities.version import Version
+from utilities.whenever2 import (
+    DATE_DELTA_MAX,
+    DATE_DELTA_MIN,
+    DATE_DELTA_PARSABLE_MAX,
+    DATE_DELTA_PARSABLE_MIN,
+    DATE_MAX,
+    DATE_MIN,
+    PLAIN_DATE_TIME_MAX,
+    PLAIN_DATE_TIME_MIN,
+    TIME_DELTA_MAX,
+    TIME_DELTA_MIN,
+    TIME_MAX,
+    TIME_MIN,
+)
 from utilities.zoneinfo import UTC, ensure_time_zone
 
 if TYPE_CHECKING:
@@ -97,7 +112,7 @@ if TYPE_CHECKING:
 
     from hypothesis.database import ExampleDatabase
     from numpy.random import RandomState
-    from whenever import PlainDateTime, ZonedDateTime
+    from whenever import ZonedDateTime
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
     from utilities.types import Duration, Number, RoundMode, TimeZoneLike
@@ -170,13 +185,6 @@ def date_deltas_whenever(
     parsable: MaybeSearchStrategy[bool] = False,
 ) -> DateDelta:
     """Strategy for generating date deltas."""
-    from utilities.whenever2 import (
-        DATE_DELTA_MAX,
-        DATE_DELTA_MIN,
-        DATE_DELTA_PARSABLE_MAX,
-        DATE_DELTA_PARSABLE_MIN,
-    )
-
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
@@ -307,8 +315,6 @@ def dates_whenever(
     max_value: MaybeSearchStrategy[Date | None] = None,
 ) -> Date:
     """Strategy for generating dates."""
-    from utilities.whenever2 import DATE_MAX, DATE_MIN
-
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
@@ -1069,10 +1075,6 @@ def plain_datetimes_whenever(
     max_value: MaybeSearchStrategy[PlainDateTime | None] = None,
 ) -> PlainDateTime:
     """Strategy for generating plain datetimes."""
-    from whenever import PlainDateTime
-
-    from utilities.whenever2 import PLAIN_DATE_TIME_MAX, PLAIN_DATE_TIME_MIN
-
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
@@ -1405,6 +1407,41 @@ def text_printable(
 ##
 
 
+@composite
+def time_deltas_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[TimeDelta | None] = None,
+    max_value: MaybeSearchStrategy[TimeDelta | None] = None,
+) -> TimeDelta:
+    """Strategy for generating time deltas."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = TIME_DELTA_MIN
+        case TimeDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = TIME_DELTA_MAX
+        case TimeDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    py_time = draw(
+        hypothesis.strategies.timedeltas(
+            min_value=min_value_.py_timedelta(), max_value=max_value_.py_timedelta()
+        )
+    )
+    return TimeDelta.from_py_timedelta(py_time)
+
+
+##
+
+
 @composite
 def timedeltas_2w(
     draw: DrawFn,
@@ -1431,6 +1468,41 @@ def timedeltas_2w(
 ##
 
 
+@composite
+def times_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Time | None] = None,
+    max_value: MaybeSearchStrategy[Time | None] = None,
+) -> Time:
+    """Strategy for generating times."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = TIME_MIN
+        case Time():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = TIME_MAX
+        case Time():
+            ...
+        case _ as never:
+            assert_never(never)
+    py_time = draw(
+        hypothesis.strategies.times(
+            min_value=min_value_.py_time(), max_value=max_value_.py_time()
+        )
+    )
+    return Time.from_py_time(py_time)
+
+
+##
+
+
 def triples(
     strategy: SearchStrategy[_T],
     /,
@@ -1651,7 +1723,9 @@ __all__ = [
     "text_clean",
     "text_digits",
     "text_printable",
+    "time_deltas_whenever",
     "timedeltas_2w",
+    "times_whenever",
     "triples",
     "uint32s",
     "uint64s",

{dycw_utilities-0.131.5 → dycw_utilities-0.131.7}/src/utilities/whenever2.py

@@ -5,7 +5,15 @@ from functools import cache
 from logging import LogRecord
 from typing import TYPE_CHECKING, Any, override
 
-from whenever import Date, DateTimeDelta, PlainDateTime, ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from utilities.zoneinfo import UTC, get_time_zone_name
 
@@ -15,8 +23,15 @@ if TYPE_CHECKING:
     from utilities.types import TimeZoneLike
 
 
+## bounds
+
+
 DATE_MIN = Date.from_py_date(dt.date.min)
 DATE_MAX = Date.from_py_date(dt.date.max)
+TIME_MIN = Time.from_py_time(dt.time.min)
+TIME_MAX = Time.from_py_time(dt.time.max)
+
+
 PLAIN_DATE_TIME_MIN = PlainDateTime.from_py_datetime(dt.datetime.min)  # noqa: DTZ901
 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)
@@ -28,10 +43,24 @@ 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)
-DATE_TIME_DELTA_PARSABLE_MAX = DateTimeDelta(days=999999)
-DATE_DELTA_PARSABLE_MIN = DATE_TIME_DELTA_PARSABLE_MIN.date_part()
-DATE_DELTA_PARSABLE_MAX = DATE_TIME_DELTA_PARSABLE_MAX.date_part()
+
+DATE_TIME_DELTA_PARSABLE_MIN = DateTimeDelta(days=-999999, seconds=-316192377600)
+DATE_TIME_DELTA_PARSABLE_MAX = DateTimeDelta(days=999999, seconds=316192377600)
+DATE_DELTA_PARSABLE_MIN = DateDelta(days=-999999)
+DATE_DELTA_PARSABLE_MAX = DateDelta(days=999999)
+
+
+## common constants
+
+
+ZERO_TIME = Time()
+MICROSECOND = TimeDelta(microseconds=1)
+MILLISECOND = TimeDelta(milliseconds=1)
+SECOND = TimeDelta(seconds=1)
+MINUTE = TimeDelta(minutes=1)
+HOUR = TimeDelta(hours=1)
+DAY = DateDelta(days=1)
+WEEK = DateDelta(weeks=1)
 
 
 ##
@@ -68,6 +97,28 @@ def get_now_local() -> ZonedDateTime:
     return get_now(time_zone="local")
 
 
+NOW_LOCAL = get_now_local()
+
+
+##
+
+
+def get_today(*, time_zone: TimeZoneLike = UTC) -> Date:
+    """Get the current, timezone-aware local date."""
+    return get_now(time_zone=time_zone).date()
+
+
+TODAY_UTC = get_today(time_zone=UTC)
+
+
+def get_today_local() -> Date:
+    """Get the current, timezone-aware local date."""
+    return get_today(time_zone="local")
+
+
+TODAY_LOCAL = get_today_local()
+
+
 ##
 
 
@@ -132,10 +183,23 @@ __all__ = [
     "DATE_TIME_DELTA_MIN",
     "DATE_TIME_DELTA_PARSABLE_MAX",
     "DATE_TIME_DELTA_PARSABLE_MIN",
+    "DAY",
+    "HOUR",
+    "MICROSECOND",
+    "MILLISECOND",
+    "MINUTE",
+    "NOW_LOCAL",
     "PLAIN_DATE_TIME_MAX",
     "PLAIN_DATE_TIME_MIN",
+    "SECOND",
     "TIME_DELTA_MAX",
     "TIME_DELTA_MIN",
+    "TIME_MAX",
+    "TIME_MIN",
+    "TODAY_LOCAL",
+    "TODAY_UTC",
+    "WEEK",
+    "ZERO_TIME",
     "ZONED_DATE_TIME_MAX",
     "ZONED_DATE_TIME_MIN",
     "WheneverLogRecord",
@@ -143,6 +207,7 @@ __all__ = [
     "from_timestamp_millis",
     "from_timestamp_nanos",
     "get_now",
-    "get_now",
     "get_now_local",
+    "get_today",
+    "get_today_local",
 ]