dycw-utilities 0.131.4__tar.gz → 0.131.6__tar.gz

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/PKG-INFO

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

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/pyproject.toml

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

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/tests/test_hypothesis.py

@@ -183,14 +183,16 @@ class TestBoolArrays:
         assert array.shape == shape
 
 
-class TestDateDeltas:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
+class TestDateDeltasWhenever:
+    @given(data=data(), parsable=booleans())
+    def test_main(self, *, data: DataObject, parsable: bool) -> None:
         min_value = data.draw(date_deltas_whenever() | none())
         max_value = data.draw(date_deltas_whenever() | none())
         with assume_does_not_raise(InvalidArgument):
             delta = data.draw(
-                date_deltas_whenever(min_value=min_value, max_value=max_value)
+                date_deltas_whenever(
+                    min_value=min_value, max_value=max_value, parsable=parsable
+                )
             )
         assert isinstance(delta, DateDelta)
         years, months, days = delta.in_years_months_days()
@@ -206,6 +208,8 @@ class TestDateDeltas:
             assert max_years == 0
             assert max_months == 0
             assert days <= max_days
+        if parsable:
+            assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
 
 
 class TestDateDurations:
@@ -295,6 +299,7 @@ class TestDatesWhenever:
         with assume_does_not_raise(InvalidArgument):
             date = data.draw(dates_whenever(min_value=min_value, max_value=max_value))
         assert isinstance(date, Date)
+        assert Date.parse_common_iso(date.format_common_iso()) == date
         if min_value is not None:
             assert date >= min_value
         if max_value is not None:
@@ -894,6 +899,7 @@ class TestPlainDateTimesWhenever:
                 plain_datetimes_whenever(min_value=min_value, max_value=max_value)
             )
         assert isinstance(datetime, PlainDateTime)
+        assert PlainDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
         if min_value is not None:
             assert datetime >= min_value
         if max_value is not None:
@@ -1273,6 +1279,7 @@ class TestZonedDateTimesWhenever:
                 )
             )
         assert isinstance(datetime, ZonedDateTime)
+        assert ZonedDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
         assert datetime.tz == time_zone.key
         if min_value is not None:
             assert datetime >= min_value

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/tests/test_operator.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from dataclasses import dataclass
 from enum import Enum, auto
 from functools import partial
@@ -23,16 +22,15 @@ from hypothesis.strategies import (
     recursive,
     sampled_from,
     times,
-    timezones,
     tuples,
     uuids,
 )
 from polars import DataFrame, Int64
 from pytest import raises
+from whenever import DateTimeDelta
 
 import utilities.math
 import utilities.operator
-from tests.conftest import IS_CI_AND_WINDOWS
 from tests.test_typing_funcs.with_future import (
     DataClassFutureCustomEquality,
     DataClassFutureDefaultInInitChild,
@@ -60,6 +58,7 @@ from utilities.hypothesis import (
 from utilities.math import MAX_INT64, MIN_INT64
 from utilities.operator import IsEqualError
 from utilities.polars import are_frames_equal
+from utilities.whenever2 import get_now
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -106,11 +105,12 @@ def base_objects(
         | timedeltas_2w()
         | uuids()
         | versions()
+        | zoned_datetimes(
+            min_value=get_now().py_datetime(),
+            max_value=(get_now() + DateTimeDelta(years=1)).py_datetime(),
+            valid=True,
+        )
     )
-    if IS_CI_AND_WINDOWS:
-        base |= zoned_datetimes()
-    else:
-        base |= zoned_datetimes(time_zone=timezones() | just(dt.UTC), valid=True)
     if dataclass_custom_equality:
         base |= builds(DataClassFutureCustomEquality)
     if dataclass_default_in_init_child:
@@ -348,8 +348,8 @@ class TestIsEqual:
         assert utilities.operator.is_equal(first, second, abs_tol=1e-8)
 
     @given(
-        x=dates() | datetimes() | zoned_datetimes(time_zone=timezones()),
-        y=dates() | datetimes() | zoned_datetimes(time_zone=timezones()),
+        x=dates() | datetimes() | zoned_datetimes(),
+        y=dates() | datetimes() | zoned_datetimes(),
     )
     def test_dates_or_datetimes(self, *, x: DateOrDateTime, y: DateOrDateTime) -> None:
         result = utilities.operator.is_equal(x, y)

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/tests/test_parse.py

@@ -36,6 +36,7 @@ from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_path
 from utilities.hypothesis import (
     datetime_durations,
+    int64s,
     numbers,
     paths,
     plain_datetimes,
@@ -78,10 +79,10 @@ class TestSerializeAndParseObject:
         result = parse_object(dt.datetime, serialized)
         assert result == datetime
 
-    @given(mapping=dictionaries(dates(), zoned_datetimes()))
-    def test_dict(self, *, mapping: dict[dt.date, dt.datetime]) -> None:
+    @given(mapping=dictionaries(dates(), int64s()))
+    def test_dict(self, *, mapping: dict[dt.date, int]) -> None:
         serialized = serialize_object(mapping)
-        result = parse_object(dict[dt.date, dt.datetime], serialized)
+        result = parse_object(dict[dt.date, int], serialized)
         assert result == mapping
 
     @given(duration=datetime_durations(two_way=True))

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/tests/test_whenever2.py

@@ -6,23 +6,31 @@ 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,
+    DATE_DELTA_PARSABLE_MAX,
+    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,
+    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,
@@ -31,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
 
@@ -77,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:
@@ -95,6 +127,22 @@ class TestMinMax:
         with raises(ValueError, match="Addition result out of bounds"):
             _ = DATE_DELTA_MAX + DateDelta(days=1)
 
+    def test_date_delta_parsable_min(self) -> None:
+        def func(delta: DateDelta, /) -> None:
+            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_DELTA_PARSABLE_MIN)
+        with raises(ValueError, match="Invalid format: '.*'"):
+            _ = func(DATE_DELTA_PARSABLE_MIN - DateDelta(days=1))
+
+    def test_date_delta_parsable_max(self) -> None:
+        def func(delta: DateDelta, /) -> None:
+            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_DELTA_PARSABLE_MAX)
+        with raises(ValueError, match="Invalid format: '.*'"):
+            _ = func(DATE_DELTA_PARSABLE_MAX + DateDelta(days=1))
+
     @mark.parametrize(
         "delta",
         [
@@ -129,6 +177,22 @@ class TestMinMax:
             with raises(ValueError, match="Addition result out of bounds"):
                 _ = DATE_TIME_DELTA_MAX + delta
 
+    def test_date_time_delta_parsable_min(self) -> None:
+        def func(delta: DateTimeDelta, /) -> None:
+            _ = DateTimeDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_TIME_DELTA_PARSABLE_MIN)
+        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:
+            _ = DateTimeDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_TIME_DELTA_PARSABLE_MAX)
+        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"):
             _ = PLAIN_DATE_TIME_MIN.subtract(nanoseconds=1, ignore_dst=True)
@@ -148,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
 
@@ -166,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
@@ -186,3 +252,9 @@ class TestWheneverLogRecord:
 
     def test_get_length(self) -> None:
         assert isinstance(WheneverLogRecord._get_length(), int)
+
+    def test_get_time_zone(self) -> None:
+        assert isinstance(WheneverLogRecord._get_time_zone(), ZoneInfo)
+
+    def test_get_time_zone_key(self) -> None:
+        assert isinstance(WheneverLogRecord._get_time_zone_key(), str)

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.4"
+__version__ = "0.131.6"

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/utilities/hypothesis.py

@@ -47,7 +47,7 @@ from hypothesis.strategies import (
     uuids,
 )
 from hypothesis.utils.conventions import not_set
-from whenever import Date, DateDelta, PlainDateTime
+from whenever import Date, DateDelta
 
 from utilities.datetime import (
     DATETIME_MAX_NAIVE,
@@ -97,7 +97,7 @@ if TYPE_CHECKING:
 
     from hypothesis.database import ExampleDatabase
     from numpy.random import RandomState
-    from whenever import ZonedDateTime
+    from whenever import PlainDateTime, ZonedDateTime
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
     from utilities.types import Duration, Number, RoundMode, TimeZoneLike
@@ -167,9 +167,15 @@ def date_deltas_whenever(
     *,
     min_value: MaybeSearchStrategy[DateDelta | None] = None,
     max_value: MaybeSearchStrategy[DateDelta | None] = None,
+    parsable: MaybeSearchStrategy[bool] = False,
 ) -> DateDelta:
     """Strategy for generating date deltas."""
-    from utilities.whenever2 import DATE_DELTA_MAX, DATE_DELTA_MIN
+    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_:
@@ -192,6 +198,19 @@ def date_deltas_whenever(
     max_years, max_months, max_days = max_value_.in_years_months_days()
     assert max_years == 0
     assert max_months == 0
+    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)
     days = draw(integers(min_value=min_days, max_value=max_days))
     return DateDelta(days=days)
 
@@ -1050,6 +1069,8 @@ 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]]

{dycw_utilities-0.131.4 → dycw_utilities-0.131.6}/src/utilities/whenever2.py

@@ -5,17 +5,33 @@ 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.tzlocal import LOCAL_TIME_ZONE
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
+    from zoneinfo import ZoneInfo
+
     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,6 +44,25 @@ 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_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)
+
+
 ##
 
 
@@ -62,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()
+
+
 ##
 
 
@@ -88,7 +145,24 @@ class WheneverLogRecord(LogRecord):
         )
         length = self._get_length()
         plain = format(get_now_local().to_plain().format_common_iso(), f"{length}s")
-        self.zoned_datetime = f"{plain}[{LOCAL_TIME_ZONE.key}]"
+        time_zone = self._get_time_zone_key()
+        self.zoned_datetime = f"{plain}[{time_zone}]"
+
+    @classmethod
+    @cache
+    def _get_time_zone(cls) -> ZoneInfo:
+        """Get the local timezone."""
+        try:
+            from utilities.tzlocal import get_local_time_zone
+        except ModuleNotFoundError:  # pragma: no cover
+            return UTC
+        return get_local_time_zone()
+
+    @classmethod
+    @cache
+    def _get_time_zone_key(cls) -> str:
+        """Get the local timezone as a string."""
+        return cls._get_time_zone().key
 
     @classmethod
     @cache
@@ -101,14 +175,31 @@ class WheneverLogRecord(LogRecord):
 __all__ = [
     "DATE_DELTA_MAX",
     "DATE_DELTA_MIN",
+    "DATE_DELTA_PARSABLE_MAX",
+    "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",
+    "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",
@@ -116,6 +207,7 @@ __all__ = [
     "from_timestamp_millis",
     "from_timestamp_nanos",
     "get_now",
-    "get_now",
     "get_now_local",
+    "get_today",
+    "get_today_local",
 ]