dycw-utilities 0.131.1__tar.gz → 0.131.2__tar.gz

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/PKG-INFO

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

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.1"
+version = "0.131.2"
 
 [project.optional-dependencies]
 logging = [
@@ -341,7 +341,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.1"
+current_version = "0.131.2"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -354,6 +354,7 @@ search = "__version__ = \"{current_version}\""
 [tool.coverage.coverage_conditional_plugin.rules]
 skipif-ci = '"CI" in os_environ'
 skipif-ci-and-not-linux = '("CI" in os_environ) and (sys_platform != "linux")'
+skipif-ci-and-not-windows = '("CI" in os_environ) and (sys_platform != "windows")'
 skipif-ci-and-windows = '("CI" in os_environ) and (sys_platform != "windows")'
 skipif-linux = 'sys_platform == "linux"'
 skipif-mac = 'sys_platform == "darwin"'

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/src/tests/test_hypothesis.py

@@ -28,6 +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 tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -50,8 +51,10 @@ from utilities.hypothesis import (
     _Draw2InputResolvedToSentinelError,
     assume_does_not_raise,
     bool_arrays,
+    date_deltas_whenever,
     date_durations,
     dates_two_digit_year,
+    dates_whenever,
     datetime_durations,
     draw2,
     float32s,
@@ -73,6 +76,7 @@ from utilities.hypothesis import (
     pairs,
     paths,
     plain_datetimes,
+    plain_datetimes_whenever,
     random_states,
     sentinels,
     sets_fixed_length,
@@ -94,6 +98,7 @@ from utilities.hypothesis import (
     uint64s,
     versions,
     zoned_datetimes,
+    zoned_datetimes_whenever,
 )
 from utilities.math import (
     MAX_FLOAT32,
@@ -178,6 +183,31 @@ class TestBoolArrays:
         assert array.shape == shape
 
 
+class TestDateDeltas:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> 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)
+            )
+        assert isinstance(delta, DateDelta)
+        years, months, days = delta.in_years_months_days()
+        assert years == 0
+        assert months == 0
+        if min_value is not None:
+            min_years, min_months, min_days = min_value.in_years_months_days()
+            assert min_years == 0
+            assert min_months == 0
+            assert days >= min_days
+        if max_value is not None:
+            max_years, max_months, max_days = max_value.in_years_months_days()
+            assert max_years == 0
+            assert max_months == 0
+            assert days <= max_days
+
+
 class TestDateDurations:
     @given(
         data=data(),
@@ -257,6 +287,20 @@ class TestDatesTwoDigitYear:
         assert date.year == parsed
 
 
+class TestDatesWhenever:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(dates_whenever() | none())
+        max_value = data.draw(dates_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            date = data.draw(dates_whenever(min_value=min_value, max_value=max_value))
+        assert isinstance(date, Date)
+        if min_value is not None:
+            assert date >= min_value
+        if max_value is not None:
+            assert date <= max_value
+
+
 class TestDateTimeDurations:
     @given(
         data=data(),
@@ -840,6 +884,22 @@ class TestPlainDateTimes:
             _ = data.draw(plain_datetimes(round_="standard"))
 
 
+class TestPlainDateTimesWhenever:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(plain_datetimes_whenever() | none())
+        max_value = data.draw(plain_datetimes_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            datetime = data.draw(
+                plain_datetimes_whenever(min_value=min_value, max_value=max_value)
+            )
+        assert isinstance(datetime, PlainDateTime)
+        if min_value is not None:
+            assert datetime >= min_value
+        if max_value is not None:
+            assert datetime <= max_value
+
+
 class TestRandomStates:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
@@ -1198,3 +1258,23 @@ class TestZonedDateTimes:
             ZonedDateTimesError, match="Rounding requires a timedelta; got None"
         ):
             _ = data.draw(zoned_datetimes(round_="standard"))
+
+
+class TestZonedDateTimesWhenever:
+    @given(data=data(), time_zone=timezones())
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        min_value = data.draw(zoned_datetimes_whenever() | none())
+        max_value = data.draw(zoned_datetimes_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            datetime = data.draw(
+                zoned_datetimes_whenever(
+                    min_value=min_value, max_value=max_value, time_zone=time_zone
+                )
+            )
+        assert isinstance(datetime, ZonedDateTime)
+        assert datetime.tz == time_zone.key
+        if min_value is not None:
+            assert datetime >= min_value
+        if max_value is not None:
+            assert datetime <= max_value

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/src/tests/test_whenever.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import datetime as dt
 from datetime import timezone
-from logging import DEBUG
 from re import escape
 from typing import TYPE_CHECKING
 from zoneinfo import ZoneInfo
@@ -21,7 +20,7 @@ from hypothesis.strategies import (
     timezones,
 )
 from pytest import raises
-from whenever import DateTimeDelta, ZonedDateTime
+from whenever import DateTimeDelta
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -61,7 +60,6 @@ from utilities.whenever import (
     SerializePlainDateTimeError,
     SerializeTimeDeltaError,
     SerializeZonedDateTimeError,
-    WheneverLogRecord,
     _CheckValidZonedDateTimeUnequalError,
     _EnsureTimedeltaNanosecondError,
     _EnsureTimedeltaParseError,
@@ -495,20 +493,3 @@ class TestToDateTimeDelta:
             _ToDateTimeDeltaError, match="Unable to create DateTimeDelta; got .*"
         ):
             _ = _to_datetime_delta(timedelta)
-
-
-class TestWheneverLogRecord:
-    def test_init(self) -> None:
-        _ = WheneverLogRecord("name", DEBUG, "pathname", 0, None, None, None)
-
-    def test_get_length(self) -> None:
-        assert isinstance(WheneverLogRecord._get_length(), int)
-
-    def test_get_now(self) -> None:
-        assert isinstance(WheneverLogRecord._get_now(), ZonedDateTime)
-
-    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.2/src/tests/test_whenever2.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from logging import DEBUG
+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 tests.conftest import IS_CI
+from utilities.hypothesis import zoned_datetimes_whenever
+from utilities.tzdata import HongKong, Tokyo
+from utilities.whenever2 import (
+    DATE_DELTA_MAX,
+    DATE_DELTA_MIN,
+    DATE_MAX,
+    DATE_MIN,
+    DATE_TIME_DELTA_MAX,
+    DATE_TIME_DELTA_MIN,
+    NOW_UTC,
+    PLAIN_DATE_TIME_MAX,
+    PLAIN_DATE_TIME_MIN,
+    TIME_DELTA_MAX,
+    TIME_DELTA_MIN,
+    ZONED_DATE_TIME_MAX,
+    ZONED_DATE_TIME_MIN,
+    WheneverLogRecord,
+    from_timestamp,
+    from_timestamp_millis,
+    from_timestamp_nanos,
+    get_now,
+    get_now_local,
+)
+from utilities.zoneinfo import UTC
+
+
+class TestFromTimeStamp:
+    @given(datetime=zoned_datetimes_whenever(time_zone=UTC if IS_CI else timezones()))
+    def test_main(self, *, datetime: ZonedDateTime) -> None:
+        datetime = datetime.round("second")
+        timestamp = datetime.to_tz(UTC.key).timestamp()
+        result = from_timestamp(timestamp, time_zone=ZoneInfo(datetime.tz))
+        assert result == datetime
+
+    @given(datetime=zoned_datetimes_whenever(time_zone=UTC if IS_CI else timezones()))
+    def test_millis(self, *, datetime: ZonedDateTime) -> None:
+        datetime = datetime.round("millisecond")
+        timestamp = datetime.to_tz(UTC.key).timestamp_millis()
+        result = from_timestamp_millis(timestamp, time_zone=ZoneInfo(datetime.tz))
+        assert result == datetime
+
+    @given(datetime=zoned_datetimes_whenever(time_zone=UTC if IS_CI else timezones()))
+    def test_nanos(self, *, datetime: ZonedDateTime) -> None:
+        timestamp = datetime.to_tz(UTC.key).timestamp_nanos()
+        result = from_timestamp_nanos(timestamp, time_zone=ZoneInfo(datetime.tz))
+        assert result == datetime
+
+
+class TestGetNow:
+    @given(time_zone=just(UTC) if IS_CI else timezones())
+    def test_function(self, *, time_zone: ZoneInfo) -> None:
+        now = get_now(time_zone=time_zone)
+        assert isinstance(now, ZonedDateTime)
+        assert now.tz == time_zone.key
+
+    def test_constant(self) -> None:
+        assert isinstance(NOW_UTC, ZonedDateTime)
+        assert NOW_UTC.tz == "UTC"
+
+
+class TestGetNowLocal:
+    def test_function(self) -> None:
+        now = get_now_local()
+        assert isinstance(now, ZonedDateTime)
+        ETC = ZoneInfo("Etc/UTC")  # noqa: N806
+        time_zones = {ETC, HongKong, Tokyo, UTC}
+        assert any(now.tz == time_zone.key for time_zone in time_zones)
+
+
+class TestMinMax:
+    def test_date_min(self) -> None:
+        with raises(ValueError, match="Resulting date out of range"):
+            _ = DATE_MIN - DateDelta(days=1)
+
+    def test_date_max(self) -> None:
+        with raises(ValueError, match="Resulting date out of range"):
+            _ = DATE_MAX + DateDelta(days=1)
+
+    def test_date_delta_min(self) -> None:
+        with raises(ValueError, match="Addition result out of bounds"):
+            _ = DATE_DELTA_MIN - DateDelta(days=1)
+
+    def test_date_delta_max(self) -> None:
+        with raises(ValueError, match="Addition result out of bounds"):
+            _ = DATE_DELTA_MAX + DateDelta(days=1)
+
+    @mark.parametrize(
+        "delta",
+        [
+            param(DateTimeDelta(days=1)),
+            param(DateTimeDelta(seconds=1)),
+            param(DateTimeDelta(milliseconds=1)),
+            param(DateTimeDelta(microseconds=1)),
+            param(DateTimeDelta(nanoseconds=1)),
+        ],
+    )
+    def test_date_time_delta_min(self, *, delta: DateTimeDelta) -> None:
+        with raises(ValueError, match="Addition result out of bounds"):
+            _ = DATE_TIME_DELTA_MIN - delta
+
+    @mark.parametrize(
+        ("delta", "is_ok"),
+        [
+            param(DateTimeDelta(days=1), False),
+            param(DateTimeDelta(seconds=1), False),
+            param(DateTimeDelta(milliseconds=999), True),
+            param(DateTimeDelta(milliseconds=1000), False),
+            param(DateTimeDelta(microseconds=999_999), True),
+            param(DateTimeDelta(microseconds=1_000_000), False),
+            param(DateTimeDelta(nanoseconds=999_999_999), True),
+            param(DateTimeDelta(nanoseconds=1_000_000_000), False),
+        ],
+    )
+    def test_date_time_delta_max(self, *, delta: DateTimeDelta, is_ok: bool) -> None:
+        if is_ok:
+            _ = DATE_TIME_DELTA_MAX + delta
+        else:
+            with raises(ValueError, match="Addition result out of bounds"):
+                _ = DATE_TIME_DELTA_MAX + delta
+
+    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)
+
+    def test_plain_date_time_max(self) -> None:
+        _ = PLAIN_DATE_TIME_MAX.add(nanoseconds=999, ignore_dst=True)
+        with raises(ValueError, match=r"Result of add\(\) out of range"):
+            _ = PLAIN_DATE_TIME_MAX.add(microseconds=1, ignore_dst=True)
+
+    @mark.parametrize(
+        "delta",
+        [
+            param(TimeDelta(seconds=1)),
+            param(TimeDelta(milliseconds=1)),
+            param(TimeDelta(microseconds=1)),
+            param(TimeDelta(nanoseconds=1)),
+        ],
+    )
+    def test_time_delta_min(self, *, delta: TimeDelta) -> None:
+        with raises(ValueError, match="Addition result out of range"):
+            _ = TIME_DELTA_MIN - delta
+
+    @mark.parametrize(
+        ("delta", "is_ok"),
+        [
+            param(TimeDelta(seconds=1), False),
+            param(TimeDelta(milliseconds=999), True),
+            param(TimeDelta(milliseconds=1000), False),
+            param(TimeDelta(microseconds=999_999), True),
+            param(TimeDelta(microseconds=1_000_000), False),
+            param(TimeDelta(nanoseconds=999_999_999), True),
+            param(TimeDelta(nanoseconds=1_000_000_000), False),
+        ],
+    )
+    def test_time_delta_max(self, *, delta: TimeDelta, is_ok: bool) -> None:
+        if is_ok:
+            _ = TIME_DELTA_MAX + delta
+        else:
+            with raises(ValueError, match="Addition result out of range"):
+                _ = TIME_DELTA_MAX + delta
+
+    def test_zoned_date_time_min(self) -> None:
+        with raises(ValueError, match="Instant is out of range"):
+            _ = ZONED_DATE_TIME_MIN.subtract(nanoseconds=1)
+
+    def test_zoned_date_time_max(self) -> None:
+        _ = ZONED_DATE_TIME_MAX.add(nanoseconds=999)
+        with raises(ValueError, match="Instant is out of range"):
+            _ = ZONED_DATE_TIME_MAX.add(microseconds=1)
+
+
+class TestWheneverLogRecord:
+    def test_init(self) -> None:
+        _ = WheneverLogRecord("name", DEBUG, "pathname", 0, None, None, None)
+
+    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.1 → dycw_utilities-0.131.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.1"
+__version__ = "0.131.2"

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/src/utilities/hypothesis.py

@@ -47,6 +47,7 @@ from hypothesis.strategies import (
     uuids,
 )
 from hypothesis.utils.conventions import not_set
+from whenever import Date, DateDelta
 
 from utilities.datetime import (
     DATETIME_MAX_NAIVE,
@@ -88,7 +89,7 @@ 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.zoneinfo import UTC
+from utilities.zoneinfo import UTC, ensure_time_zone
 
 if TYPE_CHECKING:
     from collections.abc import Collection, Hashable, Iterable, Iterator, Sequence
@@ -96,9 +97,10 @@ if TYPE_CHECKING:
 
     from hypothesis.database import ExampleDatabase
     from numpy.random import RandomState
+    from whenever import PlainDateTime, ZonedDateTime
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
-    from utilities.types import Duration, Number, RoundMode
+    from utilities.types import Duration, Number, RoundMode, TimeZoneLike
 
 
 _T = TypeVar("_T")
@@ -158,6 +160,45 @@ def bool_arrays(
 ##
 
 
+@composite
+def date_deltas_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[DateDelta | None] = None,
+    max_value: MaybeSearchStrategy[DateDelta | None] = None,
+) -> DateDelta:
+    """Strategy for generating date deltas."""
+    from utilities.whenever2 import DATE_DELTA_MAX, DATE_DELTA_MIN
+
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = DATE_DELTA_MIN
+        case DateDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_DELTA_MAX
+        case DateDelta():
+            ...
+        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
+    days = draw(integers(min_value=min_days, max_value=max_days))
+    return DateDelta(days=days)
+
+
+##
+
+
 @composite
 def date_durations(
     draw: DrawFn,
@@ -238,6 +279,41 @@ def dates_two_digit_year(
 ##
 
 
+@composite
+def dates_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Date | None] = None,
+    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:
+            min_value_ = DATE_MIN
+        case Date():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_MAX
+        case Date():
+            ...
+        case _ as never:
+            assert_never(never)
+    py_date = draw(
+        dates(min_value=min_value_.py_date(), max_value=max_value_.py_date())
+    )
+    return Date.from_py_date(py_date)
+
+
+##
+
+
 @composite
 def datetime_durations(
     draw: DrawFn,
@@ -920,7 +996,7 @@ def _pairs_map(elements: list[_T], /) -> tuple[_T, _T]:
 
 def paths() -> SearchStrategy[Path]:
     """Strategy for generating `Path`s."""
-    reserved = {"NUL"}
+    reserved = {"AUX", "NUL"}
     strategy = text_ascii(min_size=1, max_size=10).filter(lambda x: x not in reserved)
     return lists(strategy, max_size=10).map(lambda parts: Path(*parts))
 
@@ -965,6 +1041,45 @@ class PlainDateTimesError(Exception):
 ##
 
 
+@composite
+def plain_datetimes_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | None] = None,
+    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:
+            min_value_ = PLAIN_DATE_TIME_MIN
+        case PlainDateTime():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = PLAIN_DATE_TIME_MAX
+        case PlainDateTime():
+            ...
+        case _ as never:
+            assert_never(never)
+    py_datetime = draw(
+        datetimes(
+            min_value=min_value_.py_datetime(), max_value=max_value_.py_datetime()
+        )
+    )
+    return PlainDateTime.from_py_datetime(py_datetime)
+
+
+##
+
+
 @composite
 def random_states(
     draw: DrawFn, /, *, seed: MaybeSearchStrategy[int | None] = None
@@ -1427,6 +1542,46 @@ class ZonedDateTimesError(Exception):
         return "Rounding requires a timedelta; got None"
 
 
+##
+
+
+@composite
+def zoned_datetimes_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
+) -> ZonedDateTime:
+    """Strategy for generating zoned datetimes."""
+    from whenever import PlainDateTime, ZonedDateTime
+
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    time_zone_ = ensure_time_zone(draw2(draw, time_zone))
+    match min_value_:
+        case None | PlainDateTime():
+            ...
+        case ZonedDateTime():
+            with assume_does_not_raise(ValueError):
+                min_value_ = min_value_.to_tz(time_zone_.key).to_plain()
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None | PlainDateTime():
+            ...
+        case ZonedDateTime():
+            with assume_does_not_raise(ValueError):
+                max_value_ = max_value_.to_tz(time_zone_.key).to_plain()
+        case _ as never:
+            assert_never(never)
+    plain_datetime = draw(
+        plain_datetimes_whenever(min_value=min_value_, max_value=max_value_)
+    )
+    with assume_does_not_raise(ValueError):
+        return plain_datetime.assume_tz(time_zone_.key, disambiguate="raise")
+
+
 __all__ = [
     "Draw2Error",
     "MaybeSearchStrategy",
@@ -1435,8 +1590,10 @@ __all__ = [
     "ZonedDateTimesError",
     "assume_does_not_raise",
     "bool_arrays",
+    "date_deltas_whenever",
     "date_durations",
     "dates_two_digit_year",
+    "dates_whenever",
     "datetime_durations",
     "draw2",
     "float32s",
@@ -1460,6 +1617,7 @@ __all__ = [
     "paths",
     "plain_datetimes",
     "plain_datetimes",
+    "plain_datetimes_whenever",
     "random_states",
     "sentinels",
     "sets_fixed_length",
@@ -1480,4 +1638,5 @@ __all__ = [
     "uint64s",
     "versions",
     "zoned_datetimes",
+    "zoned_datetimes_whenever",
 ]

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/src/utilities/logging.py

@@ -190,7 +190,7 @@ def get_formatter(
 ) -> Formatter:
     """Get the formatter; colored if available."""
     if whenever:
-        from utilities.whenever import WheneverLogRecord
+        from utilities.whenever2 import WheneverLogRecord
 
         setLogRecordFactory(WheneverLogRecord)
         format_ = format_.replace("{asctime}", "{zoned_datetime}")

{dycw_utilities-0.131.1 → dycw_utilities-0.131.2}/src/utilities/typing.py

@@ -234,7 +234,7 @@ def is_instance_gen(obj: Any, type_: Any, /) -> bool:
     """Check if an instance relationship holds, except bool<int."""
     # parent
     if isinstance(type_, tuple):
-        return any(is_instance_gen(obj, t) for t in type_)
+        return any(is_instance_gen(obj, t) for t in type_)  # skipif-ci-and-not-windows
     if is_literal_type(type_):
         return obj in get_args(type_)
     if is_union_type(type_):