dycw-utilities 0.131.12__tar.gz → 0.131.14__tar.gz

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/PKG-INFO

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

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/pyproject.toml

@@ -61,6 +61,7 @@ dev = [
   "streamlit >= 1.45.0, < 1.46",
   "tenacity >= 8.5.0, < 9.0",  # limited by luigi
   "tomlkit >= 0.13.2, < 0.14",
+  "typed-settings >= 24.6.0, < 24.7",
   "tzdata >= 2025.2, < 2025.3",
   "uvicorn >= 0.34.1, < 0.35",
   "vegafusion >= 2.0.2, < 2.1",
@@ -94,7 +95,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.12"
+version = "0.131.14"
 
 [project.optional-dependencies]
 logging = [
@@ -121,7 +122,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.12"
+current_version = "0.131.14"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -319,6 +320,7 @@ select = [
   "S101",  # assert
   "SLF001",  # private-member-access
 ]
+"src/tests/test_typed_settings.py" = ["I002"]  # missing-required-import
 "src/tests/test_typing_funcs/no_future.py" = ["I002"]  # missing-required-import
 
 [tool.ruff.lint.flake8-tidy-imports]

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/src/tests/test_atools.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from asyncio import sleep
-
+from utilities.asyncio import sleep_dur
 from utilities.atools import call_memoized
+from utilities.whenever2 import SECOND
 
 
 class TestCallMemoized:
@@ -20,6 +20,7 @@ class TestCallMemoized:
 
     async def test_refresh(self) -> None:
         counter = 0
+        delta = 0.05 * SECOND
 
         async def increment() -> int:
             nonlocal counter
@@ -27,9 +28,9 @@ class TestCallMemoized:
             return counter
 
         for _ in range(2):
-            assert (await call_memoized(increment, 0.05)) == 1
+            assert (await call_memoized(increment, delta)) == 1
             assert counter == 1
-        await sleep(0.1)
+        await sleep_dur(duration=2 * delta)
         for _ in range(2):
-            assert (await call_memoized(increment, 0.05)) == 2
+            assert (await call_memoized(increment, delta)) == 2
             assert counter == 2

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/src/tests/test_cachetools.py

@@ -1,20 +1,32 @@
 from __future__ import annotations
 
-from time import sleep
+from typing import TYPE_CHECKING
 
 from hypothesis import example, given
-from hypothesis.strategies import floats, integers, none
+from hypothesis.strategies import integers, none
 
+from utilities.asyncio import sleep_dur
 from utilities.cachetools import TTLSet, cache
+from utilities.hypothesis import time_deltas_whenever
+from utilities.whenever2 import SECOND
+
+if TYPE_CHECKING:
+    from whenever import TimeDelta
 
 
 class TestCache:
     @example(max_size=None, max_duration=None)
-    @example(max_size=None, max_duration=1.0)
+    @example(max_size=None, max_duration=SECOND)
     @example(max_size=1, max_duration=None)
-    @example(max_size=1, max_duration=1.0)
-    @given(max_size=integers(1, 10) | none(), max_duration=floats(0.1, 10.0) | none())
-    def test_main(self, *, max_size: int, max_duration: float) -> None:
+    @example(max_size=1, max_duration=SECOND)
+    @given(
+        max_size=integers(1, 10) | none(),
+        max_duration=time_deltas_whenever(
+            min_value=0.1 * SECOND, max_value=10.0 * SECOND
+        )
+        | none(),
+    )
+    def test_main(self, *, max_size: int, max_duration: TimeDelta) -> None:
         counter = 0
 
         @cache(max_size=max_size, max_duration=max_duration)
@@ -48,10 +60,11 @@ class TestTTLSet:
         set_ = TTLSet(range(3))
         assert len(set_) == 3
 
-    def test_max_duration(self) -> None:
-        set_ = TTLSet(range(3), max_duration=0.1)
+    async def test_max_duration(self) -> None:
+        delta = 0.1 * SECOND
+        set_ = TTLSet(range(3), max_duration=delta)
         assert set_ == {0, 1, 2}
-        sleep(0.2)
+        await sleep_dur(duration=2 * delta)
         assert set_ == set()
 
     def test_max_size(self) -> None:

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/src/tests/test_hypothesis.py

@@ -43,7 +43,6 @@ from utilities.datetime import (
 )
 from utilities.functions import ensure_int
 from utilities.hypothesis import (
-    MaybeSearchStrategy,
     PlainDateTimesError,
     Shape,
     ZonedDateTimesError,
@@ -67,9 +66,6 @@ from utilities.hypothesis import (
     int64s,
     int_arrays,
     lists_fixed_length,
-    min_and_max_datetimes,
-    min_and_maybe_max_datetimes,
-    min_and_maybe_max_sizes,
     months,
     namespace_mixins,
     numbers,
@@ -706,82 +702,6 @@ class TestListsFixedLength:
             assert sorted(result) == result
 
 
-class TestMinAndMaxDateTimes:
-    @given(
-        data=data(),
-        min_value=zoned_datetimes() | none() | just(zoned_datetimes() | none()),
-        max_value=zoned_datetimes() | none() | just(zoned_datetimes() | none()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[dt.datetime | None],
-        max_value: MaybeSearchStrategy[dt.datetime | None],
-    ) -> None:
-        min_datetime, max_datetime = data.draw(
-            min_and_max_datetimes(min_value=min_value, max_value=max_value)
-        )
-        assert min_datetime <= max_datetime
-        if isinstance(min_value, dt.datetime):
-            assert min_datetime == min_value
-        if isinstance(max_value, dt.datetime):
-            assert max_datetime == max_value
-
-
-class TestMinAndMaybeMaxDateTimes:
-    @given(
-        data=data(),
-        min_value=zoned_datetimes() | none() | just(zoned_datetimes() | none()),
-        max_value=zoned_datetimes()
-        | none()
-        | sentinels()
-        | just(zoned_datetimes() | none() | sentinels()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[dt.datetime | None],
-        max_value: MaybeSearchStrategy[dt.datetime | None | Sentinel],
-    ) -> None:
-        min_datetime, max_datetime = data.draw(
-            min_and_maybe_max_datetimes(min_value=min_value, max_value=max_value)
-        )
-        assert (max_datetime is None) or (min_datetime <= max_datetime)
-        if isinstance(min_value, dt.datetime):
-            assert min_datetime == min_value
-        if isinstance(max_value, dt.datetime) or (max_value is None):
-            assert max_datetime == max_value
-
-
-class TestMinAndMaybeMaxSizes:
-    @given(
-        data=data(),
-        min_value=integers(min_value=0) | none() | just(integers(min_value=0) | none()),
-        max_value=integers(min_value=0)
-        | none()
-        | sentinels()
-        | just(integers(min_value=0) | none() | sentinels()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[int | None],
-        max_value: MaybeSearchStrategy[int | None | Sentinel],
-    ) -> None:
-        min_size, max_size = data.draw(
-            min_and_maybe_max_sizes(min_value=min_value, max_value=max_value)
-        )
-        assert min_size >= 0
-        assert (max_size is None) or (min_size <= max_size)
-        if isinstance(min_value, int):
-            assert min_size == min_value
-        if isinstance(max_value, int) or (max_value is None):
-            assert max_size == max_value
-
-
 class TestMonths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/src/tests/test_orjson.py

@@ -81,6 +81,7 @@ from utilities.polars import check_polars_dataframe, zoned_datetime
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import LogLevel, MaybeIterable, PathLike
 from utilities.typing import get_args
+from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.whenever2 import MINUTE, SECOND, get_now
 
 if TYPE_CHECKING:
@@ -169,7 +170,7 @@ class TestGetLogRecords:
                 "level": UInt64,
                 "path_name": String,
                 "line_num": UInt64,
-                "datetime": zoned_datetime(time_zone="local"),
+                "datetime": zoned_datetime(time_zone=LOCAL_TIME_ZONE),
                 "func_name": String,
                 "stack_info": String,
                 "extra": Object,

dycw_utilities-0.131.14/src/tests/test_period.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+from re import search
+from typing import TYPE_CHECKING
+
+from hypothesis import HealthCheck, given, settings
+from hypothesis.strategies import DataObject, data, sampled_from
+from pytest import raises
+
+from utilities.hypothesis import (
+    assume_does_not_raise,
+    date_deltas_whenever,
+    dates_whenever,
+    pairs,
+    plain_datetimes_whenever,
+    time_deltas_whenever,
+    zoned_datetimes_whenever,
+)
+from utilities.period import (
+    DatePeriod,
+    ZonedDateTimePeriod,
+    _PeriodAsDict,
+    _PeriodInvalidError,
+    _PeriodTimeZoneError,
+)
+from utilities.tzdata import USCentral, USEastern
+from utilities.whenever2 import DAY
+from utilities.zoneinfo import UTC, get_time_zone_name
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from whenever import Date, DateDelta, PlainDateTime, TimeDelta, ZonedDateTime
+
+
+class TestDatePeriod:
+    @given(dates=pairs(dates_whenever(), sorted=True), delta=date_deltas_whenever())
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_add(self, *, dates: tuple[Date, Date], delta: DateDelta) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Resulting date out of range"):
+            result = period + delta
+        expected = DatePeriod(start + delta, end + delta)
+        assert result == expected
+
+    @given(date=dates_whenever(), dates=pairs(dates_whenever(), sorted=True))
+    def test_contains(self, *, date: Date, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = date in period
+        expected = start <= date <= end
+        assert result is expected
+
+    @given(dates=pairs(dates_whenever(), sorted=True))
+    def test_delta(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        assert period.delta == (end - start)
+
+    @given(dates=pairs(dates_whenever(), sorted=True))
+    def test_hashable(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        _ = hash(period)
+
+    @given(dates=pairs(dates_whenever(), sorted=True), func=sampled_from([repr, str]))
+    def test_repr(self, *, dates: tuple[Date, Date], func: Callable[..., str]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = func(period)
+        assert search(r"^DatePeriod\(\d{4}-\d{2}-\d{2}, \d{4}-\d{2}-\d{2}\)$", result)
+
+    @given(
+        dates1=pairs(dates_whenever(), sorted=True),
+        dates2=pairs(dates_whenever(), sorted=True),
+    )
+    def test_sortable(
+        self, *, dates1: tuple[Date, Date], dates2: tuple[Date, Date]
+    ) -> None:
+        start1, end1 = dates1
+        start2, end2 = dates2
+        period1 = DatePeriod(start1, end1)
+        period2 = DatePeriod(start2, end2)
+        _ = sorted([period1, period2])
+
+    @given(dates=pairs(dates_whenever(), sorted=True), delta=date_deltas_whenever())
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_sub(self, *, dates: tuple[Date, Date], delta: DateDelta) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Resulting date out of range"):
+            result = period - delta
+        expected = DatePeriod(start - delta, end - delta)
+        assert result == expected
+
+    @given(dates=pairs(dates_whenever(), sorted=True))
+    def test_to_dict(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = period.to_dict()
+        expected = _PeriodAsDict(start=start, end=end)
+        assert result == expected
+
+    @given(dates=pairs(dates_whenever(), unique=True, sorted=True))
+    def test_error_period_invalid(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        with raises(_PeriodInvalidError, match="Invalid period; got .* > .*"):
+            _ = DatePeriod(end, start)
+
+
+class TestZonedDateTimePeriod:
+    @given(
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        delta=time_deltas_whenever(),
+    )
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_add(
+        self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime], delta: TimeDelta
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Instant is out of range"):
+            result = period + delta
+        expected = ZonedDateTimePeriod(start + delta, end + delta)
+        assert result == expected
+
+    @given(
+        datetime=zoned_datetimes_whenever(),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+    )
+    def test_contains(
+        self, *, datetime: ZonedDateTime, datetimes: tuple[ZonedDateTime, ZonedDateTime]
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = datetime in period
+        expected = start <= datetime <= end
+        assert result is expected
+
+    @given(
+        datetime=zoned_datetimes_whenever(),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+    )
+    def test_contain_datetime(
+        self, *, datetime: ZonedDateTime, datetimes: tuple[ZonedDateTime, ZonedDateTime]
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = datetime in period
+        expected = start <= datetime <= end
+        assert result is expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_delta(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        assert period.delta == (end - start)
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_hashable(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        _ = hash(period)
+
+    @given(
+        data=data(),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        func=sampled_from([repr, str]),
+    )
+    def test_repr(
+        self,
+        *,
+        data: DataObject,
+        datetimes: tuple[ZonedDateTime, ZonedDateTime],
+        func: Callable[..., str],
+    ) -> None:
+        start, end = datetimes
+        datetimes = data.draw(pairs(zoned_datetimes_whenever(), sorted=True))
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = func(period)
+        assert search(
+            r"^ZonedDateTimePeriod\(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?, \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?\[.+\]\)$",
+            result,
+        )
+
+    @given(
+        dates1=pairs(zoned_datetimes_whenever(), sorted=True),
+        dates2=pairs(zoned_datetimes_whenever(), sorted=True),
+    )
+    def test_sortable(
+        self,
+        *,
+        dates1: tuple[ZonedDateTime, ZonedDateTime],
+        dates2: tuple[ZonedDateTime, ZonedDateTime],
+    ) -> None:
+        start1, end1 = dates1
+        start2, end2 = dates2
+        period1 = ZonedDateTimePeriod(start1, end1)
+        period2 = ZonedDateTimePeriod(start2, end2)
+        _ = sorted([period1, period2])
+
+    @given(
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        delta=time_deltas_whenever(),
+    )
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_sub(
+        self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime], delta: TimeDelta
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Instant is out of range"):
+            result = period - delta
+        expected = ZonedDateTimePeriod(start - delta, end - delta)
+        assert result == expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_to_dict(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = period.to_dict()
+        expected = _PeriodAsDict(start=start, end=end)
+        assert result == expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_to_tz(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        with assume_does_not_raise(OverflowError, match="date value out of range"):
+            result = period.to_tz(UTC)
+        assert result.time_zone == UTC
+        name = get_time_zone_name(UTC)
+        expected = ZonedDateTimePeriod(start.to_tz(name), end.to_tz(name))
+        assert result == expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), unique=True, sorted=True))
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_error_period_invalid(
+        self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]
+    ) -> None:
+        start, end = datetimes
+        with raises(_PeriodInvalidError, match="Invalid period; got .* > .*"):
+            _ = ZonedDateTimePeriod(end, start)
+
+    @given(datetimes=pairs(plain_datetimes_whenever(), sorted=True))
+    def test_error_period_time_zone(
+        self, *, datetimes: tuple[PlainDateTime, PlainDateTime]
+    ) -> None:
+        plain_start, plain_end = datetimes
+        with assume_does_not_raise(OverflowError, match="date value out of range"):
+            start = (plain_start - DAY).assume_tz(USCentral.key)
+            end = (plain_end + DAY).assume_tz(USEastern.key)
+        with raises(
+            _PeriodTimeZoneError,
+            match="Period must contain exactly one time zone; got .* and .*",
+        ):
+            _ = ZonedDateTimePeriod(start, end)

dycw_utilities-0.131.14/src/tests/test_typed_settings.py

@@ -0,0 +1,97 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from operator import eq
+from pathlib import Path
+from typing import TypeVar
+
+from hypothesis import given
+from hypothesis.strategies import DataObject, SearchStrategy, data, tuples
+from pytest import mark, param
+from typed_settings import FileLoader, TomlFormat, load_settings
+from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
+
+from utilities.hypothesis import (
+    date_deltas_whenever,
+    dates_whenever,
+    plain_datetimes_whenever,
+    temp_paths,
+    text_ascii,
+    time_deltas_whenever,
+    times_whenever,
+    zoned_datetimes_whenever,
+)
+from utilities.typed_settings import ExtendedTSConverter
+
+app_names = text_ascii(min_size=1).map(str.lower)
+
+
+_T = TypeVar("_T")
+
+
+class TestExtendedTSConverter:
+    @given(data=data(), root=temp_paths(), appname=text_ascii(min_size=1))
+    @mark.parametrize(
+        ("test_cls", "strategy", "serialize"),
+        [
+            param(Date, dates_whenever(), Date.format_common_iso),
+            param(
+                DateDelta,
+                date_deltas_whenever(parsable=True),
+                DateDelta.format_common_iso,
+            ),
+            param(
+                PlainDateTime,
+                plain_datetimes_whenever(),
+                PlainDateTime.format_common_iso,
+            ),
+            param(Time, times_whenever(), Time.format_common_iso),
+            param(TimeDelta, time_deltas_whenever(), TimeDelta.format_common_iso),
+            param(
+                ZonedDateTime,
+                zoned_datetimes_whenever(),
+                ZonedDateTime.format_common_iso,
+            ),
+        ],
+    )
+    def test_main(
+        self,
+        *,
+        data: DataObject,
+        root: Path,
+        appname: str,
+        test_cls: type[_T],
+        strategy: SearchStrategy[_T],
+        serialize: Callable[[_T], str],
+    ) -> None:
+        default, value = data.draw(tuples(strategy, strategy))
+        self._run_test(test_cls, default, root, appname, serialize, value, eq)
+
+    def _run_test(
+        self,
+        test_cls: type[_T],
+        default: _T,
+        root: Path,
+        appname: str,
+        serialize: Callable[[_T], str],
+        value: _T,
+        equal: Callable[[_T, _T], bool],
+        /,
+    ) -> None:
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            value: test_cls = default  # pyright: ignore[reportInvalidTypeForm]
+
+        settings_default = load_settings(
+            Settings, loaders=[], converter=ExtendedTSConverter()
+        )
+        assert settings_default.value == default
+        _ = hash(settings_default)
+        file = Path(root, "file.toml")
+        with file.open(mode="w") as fh:
+            _ = fh.write(f'[{appname}]\nvalue = "{serialize(value)}"')
+        settings_loaded = load_settings(
+            Settings,
+            loaders=[FileLoader(formats={"*.toml": TomlFormat(appname)}, files=[file])],
+            converter=ExtendedTSConverter(),
+        )
+        assert equal(settings_loaded.value, value)

dycw_utilities-0.131.14/src/tests/test_tzdata.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from zoneinfo import ZoneInfo
+
+from hypothesis import given
+from hypothesis.strategies import sampled_from
+
+from utilities.tzdata import HongKong, Tokyo, USCentral, USEastern
+
+
+class TestTimeZones:
+    @given(time_zone=sampled_from([HongKong, Tokyo, USCentral, USEastern]))
+    def test_main(self, *, time_zone: ZoneInfo) -> None:
+        assert isinstance(time_zone, ZoneInfo)

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/src/tests/test_zoneinfo.py

@@ -10,7 +10,7 @@ from pytest import raises
 
 from utilities.hypothesis import zoned_datetimes
 from utilities.tzdata import HongKong, Tokyo
-from utilities.tzlocal import get_local_time_zone
+from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
 from utilities.zoneinfo import (
     UTC,
     _EnsureTimeZoneInvalidTZInfoError,
@@ -45,8 +45,7 @@ class TestEnsureTimeZone:
 
     def test_local(self) -> None:
         result = ensure_time_zone("local")
-        expected = get_local_time_zone()
-        assert result is expected
+        assert result is LOCAL_TIME_ZONE
 
     @given(data=data(), time_zone=timezones())
     def test_zoned_datetime(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
@@ -78,8 +77,7 @@ class TestGetTimeZoneName:
 
     def test_local(self) -> None:
         result = get_time_zone_name("local")
-        expected = get_local_time_zone().key
-        assert result is expected
+        assert result == LOCAL_TIME_ZONE_NAME
 
 
 class TestTimeZones:

{dycw_utilities-0.131.12 → dycw_utilities-0.131.14}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.12"
+__version__ = "0.131.14"