dycw-utilities 0.160.2__tar.gz → 0.161.1__tar.gz

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/PKG-INFO

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

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/pyproject.toml

@@ -227,7 +227,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.160.2"
+version = "0.161.1"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -259,7 +259,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.160.2"
+current_version = "0.161.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/tests/conftest.py

@@ -9,7 +9,7 @@ from hypothesis import HealthCheck
 from pytest import fixture, mark, param, skip
 
 from utilities.contextlib import enhanced_context_manager
-from utilities.platform import IS_MAC, IS_NOT_LINUX, IS_WINDOWS
+from utilities.platform import IS_LINUX, IS_MAC, IS_NOT_LINUX, IS_WINDOWS
 from utilities.re import ExtractGroupError, extract_group
 from utilities.whenever import MINUTE, get_now, parse_plain_local
 
@@ -29,11 +29,13 @@ SKIPIF_CI = mark.skipif(IS_CI, reason="Skipped for CI")
 IS_CI_AND_NOT_LINUX = IS_CI and IS_NOT_LINUX
 IS_CI_AND_WINDOWS = IS_CI and IS_WINDOWS
 IS_CI_AND_MAC = IS_CI and IS_MAC
+IS_CI_AND_LINUX = IS_CI and IS_LINUX
 SKIPIF_CI_AND_NOT_LINUX = mark.skipif(
     IS_CI_AND_NOT_LINUX, reason="Skipped for CI/non-Linux"
 )
 SKIPIF_CI_AND_WINDOWS = mark.skipif(IS_CI_AND_WINDOWS, reason="Skipped for CI/Windows")
 SKIPIF_CI_AND_MAC = mark.skipif(IS_CI_AND_MAC, reason="Skipped for CI/Mac")
+SKIPIF_CI_AND_LINUX = mark.skipif(IS_CI_AND_LINUX, reason="Skipped for CI/Linux")
 
 
 # hypothesis

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/tests/test_hypothesis.py

@@ -5,6 +5,7 @@ from itertools import pairwise
 from pathlib import Path
 from re import search
 from typing import TYPE_CHECKING, Any, cast
+from zoneinfo import ZoneInfo
 
 from hypothesis import assume, given, settings
 from hypothesis.errors import InvalidArgument
@@ -20,7 +21,6 @@ from hypothesis.strategies import (
     just,
     none,
     sets,
-    timezones,
 )
 from libcst import Import, ImportFrom
 from numpy import inf, int64, isfinite, isinf, isnan, ravel, rint
@@ -34,7 +34,6 @@ from whenever import (
     PlainDateTime,
     Time,
     TimeDelta,
-    TimeZoneNotFoundError,
     YearMonth,
     ZonedDateTime,
 )
@@ -97,6 +96,7 @@ from utilities.hypothesis import (
     urls,
     versions,
     year_months,
+    zone_infos,
     zoned_date_time_periods,
     zoned_date_times,
 )
@@ -134,6 +134,7 @@ from utilities.whenever import (
     DatePeriod,
     TimePeriod,
     ZonedDateTimePeriod,
+    get_now,
     to_days,
     to_nanoseconds,
     to_py_time_delta,
@@ -141,7 +142,6 @@ from utilities.whenever import (
 
 if TYPE_CHECKING:
     from collections.abc import Set as AbstractSet
-    from zoneinfo import ZoneInfo
 
     from utilities.sentinel import Sentinel
     from utilities.tempfile import TemporaryDirectory
@@ -1186,11 +1186,21 @@ class TestYearMonths:
             assert year_month.on_day(28) <= DATE_TWO_DIGIT_YEAR_MAX
 
 
+class TestZoneInfos:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        time_zone = data.draw(zone_infos())
+        assert isinstance(time_zone, ZoneInfo)
+        assert time_zone.key not in {"Etc/UTC", "localtime"}
+        _ = get_now(time_zone)
+
+
 class TestZonedDateTimePeriods:
-    @given(data=data(), time_zone=timezones())
-    def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
         min_value = data.draw(zoned_date_times() | none())
         max_value = data.draw(zoned_date_times() | none())
+        time_zone = data.draw(zone_infos())
         with assume_does_not_raise(InvalidArgument):
             period = data.draw(
                 zoned_date_time_periods(
@@ -1206,10 +1216,11 @@ class TestZonedDateTimePeriods:
 
 
 class TestZonedDateTimes:
-    @given(data=data(), time_zone=timezones())
-    def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
         min_value = data.draw(zoned_date_times() | none())
         max_value = data.draw(zoned_date_times() | none())
+        time_zone = data.draw(zone_infos())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
                 zoned_date_times(
@@ -1225,9 +1236,9 @@ class TestZonedDateTimes:
         if max_value is not None:
             assert datetime <= max_value
 
-    @given(data=data(), time_zone=timezones())
-    def test_examples(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
-        with assume_does_not_raise(TimeZoneNotFoundError):
-            max_value = ZonedDateTime(1, 1, 2, tz=time_zone.key)
+    @given(data=data())
+    def test_examples(self, *, data: DataObject) -> None:
+        time_zone = data.draw(zone_infos())
+        max_value = ZonedDateTime(1, 1, 2, tz=time_zone.key)
         datetime = data.draw(zoned_date_times(max_value=max_value, time_zone=time_zone))
         _ = datetime.py_datetime()

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/tests/test_polars.py

@@ -222,7 +222,7 @@ from utilities.whenever import (
     get_now_plain,
     get_today,
 )
-from utilities.zoneinfo import UTC, get_time_zone_name
+from utilities.zoneinfo import UTC, to_time_zone_name
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Mapping, Sequence
@@ -1426,18 +1426,18 @@ class TestDataClassToSchema:
 
 
 class TestDatetimeDTypes:
-    @given(
-        case=sampled_from([
-            (HongKong, DatetimeHongKong),
-            (Tokyo, DatetimeTokyo),
-            (USCentral, DatetimeUSCentral),
-            (USEastern, DatetimeUSEastern),
-            (UTC, DatetimeUTC),
-        ])
+    @mark.parametrize(
+        ("time_zone", "dtype"),
+        [
+            param(HongKong, DatetimeHongKong),
+            param(Tokyo, DatetimeTokyo),
+            param(USCentral, DatetimeUSCentral),
+            param(USEastern, DatetimeUSEastern),
+            param(UTC, DatetimeUTC),
+        ],
     )
-    def test_main(self, *, case: tuple[ZoneInfo, Datetime]) -> None:
-        time_zone, dtype = case
-        name = get_time_zone_name(time_zone)
+    def test_main(self, *, time_zone: ZoneInfo, dtype: Datetime) -> None:
+        name = to_time_zone_name(time_zone)
         expected = dtype.time_zone
         assert name == expected
 

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/tests/test_types.py

@@ -9,8 +9,7 @@ from hypothesis.strategies import sampled_from
 from pytest import mark, param
 
 from utilities.platform import SYSTEM
-from utilities.types import Dataclass, Number, PathLike, TimeZone
-from utilities.typing import get_literal_elements
+from utilities.types import TIME_ZONES, Dataclass, Number, PathLike
 
 
 class TestDataClassProtocol:
@@ -45,7 +44,7 @@ class TestPathLike:
 
 class TestTimeZone:
     def test_main(self) -> None:
-        result = set(get_literal_elements(TimeZone))
+        result = set(TIME_ZONES)
         expected = available_timezones()
         match SYSTEM:
             case "windows" | "mac":

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/tests/test_whenever.py

@@ -8,14 +8,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Self, cast
 from zoneinfo import ZoneInfo
 
 from hypothesis import HealthCheck, given, settings
-from hypothesis.strategies import (
-    DataObject,
-    data,
-    integers,
-    none,
-    sampled_from,
-    timezones,
-)
+from hypothesis.strategies import DataObject, data, integers, none, sampled_from
 from pytest import mark, param, raises
 from whenever import (
     Date,
@@ -24,7 +17,6 @@ from whenever import (
     PlainDateTime,
     Time,
     TimeDelta,
-    TimeZoneNotFoundError,
     Weekday,
     YearMonth,
     ZonedDateTime,
@@ -41,6 +33,7 @@ from utilities.hypothesis import (
     time_deltas,
     time_periods,
     times,
+    zone_infos,
     zoned_date_time_periods,
     zoned_date_times,
     zoned_date_times_2000,
@@ -150,7 +143,7 @@ from utilities.whenever import (
     to_zoned_date_time,
     two_digit_year_month,
 )
-from utilities.zoneinfo import UTC, get_time_zone_name
+from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -382,7 +375,7 @@ class TestFormatCompact:
 
 class TestFromTimeStamp:
     @given(
-        datetime=zoned_date_times(time_zone=timezones()).map(
+        datetime=zoned_date_times(time_zone=zone_infos()).map(
             lambda d: d.round("second")
         )
     )
@@ -392,7 +385,7 @@ class TestFromTimeStamp:
         assert result == datetime
 
     @given(
-        datetime=zoned_date_times(time_zone=timezones()).map(
+        datetime=zoned_date_times(time_zone=zone_infos()).map(
             lambda d: d.round("millisecond")
         )
     )
@@ -401,7 +394,7 @@ class TestFromTimeStamp:
         result = from_timestamp_millis(timestamp, time_zone=ZoneInfo(datetime.tz))
         assert result == datetime
 
-    @given(datetime=zoned_date_times(time_zone=timezones()))
+    @given(datetime=zoned_date_times(time_zone=zone_infos()))
     def test_nanos(self, *, datetime: ZonedDateTime) -> None:
         timestamp = datetime.timestamp_nanos()
         result = from_timestamp_nanos(timestamp, time_zone=ZoneInfo(datetime.tz))
@@ -409,16 +402,16 @@ class TestFromTimeStamp:
 
 
 class TestGetNow:
-    @given(time_zone=timezones())
+    @given(time_zone=zone_infos())
     def test_function(self, *, time_zone: ZoneInfo) -> None:
-        with assume_does_not_raise(TimeZoneNotFoundError):
-            now = get_now(time_zone)
+        now = get_now(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"
+        expected = UTC.key
+        assert NOW_UTC.tz == expected
 
 
 class TestGetNowLocal:
@@ -435,10 +428,9 @@ class TestGetNowLocal:
 
 
 class TestGetNowPlain:
-    @given(time_zone=timezones())
+    @given(time_zone=zone_infos())
     def test_function(self, *, time_zone: ZoneInfo) -> None:
-        with assume_does_not_raise(TimeZoneNotFoundError):
-            now = get_now_plain(time_zone)
+        now = get_now_plain(time_zone)
         assert isinstance(now, PlainDateTime)
 
     def test_constant(self) -> None:
@@ -1394,32 +1386,50 @@ class TestToZonedDateTime:
     def test_default(self) -> None:
         assert abs(to_zoned_date_time() - get_now()) <= SECOND
 
-    @given(date_time=zoned_date_times())
-    def test_date_time(self, *, date_time: ZonedDateTime) -> None:
-        assert to_zoned_date_time(date_time) == date_time
+    @given(date_time=zoned_date_times(), time_zone=zone_infos())
+    def test_date_time(self, *, date_time: ZonedDateTime, time_zone: ZoneInfo) -> None:
+        result = to_zoned_date_time(date_time, time_zone=time_zone)
+        expected = date_time.to_tz(time_zone.key)
+        assert result.exact_eq(expected)
 
-    @given(date_time=zoned_date_times())
-    def test_str(self, *, date_time: ZonedDateTime) -> None:
-        assert to_zoned_date_time(date_time.format_common_iso()) == date_time
+    @given(date_time=zoned_date_times(), time_zone=zone_infos())
+    def test_str(self, *, date_time: ZonedDateTime, time_zone: ZoneInfo) -> None:
+        result = to_zoned_date_time(date_time.format_common_iso(), time_zone=time_zone)
+        expected = date_time.to_tz(time_zone.key)
+        assert result.exact_eq(expected)
 
-    @given(date_time=zoned_date_times_2000)
-    def test_py_date_time_zone_info(self, *, date_time: ZonedDateTime) -> None:
-        assert to_zoned_date_time(date_time.py_datetime()) == date_time
+    @given(date_time=zoned_date_times_2000, time_zone=zone_infos())
+    def test_py_date_time_zone_info(
+        self, *, date_time: ZonedDateTime, time_zone: ZoneInfo
+    ) -> None:
+        result = to_zoned_date_time(date_time.py_datetime(), time_zone=time_zone)
+        expected = date_time.to_tz(time_zone.key)
+        assert result.exact_eq(expected)
 
-    @given(date_time=zoned_date_times_2000)
-    def test_py_date_time_dt_utc(self, *, date_time: ZonedDateTime) -> None:
-        result = to_zoned_date_time(date_time.py_datetime().astimezone(dt.UTC))
-        assert result == date_time
+    @given(date_time=zoned_date_times_2000, time_zone=zone_infos())
+    def test_py_date_time_dt_utc(
+        self, *, date_time: ZonedDateTime, time_zone: ZoneInfo
+    ) -> None:
+        result = to_zoned_date_time(
+            date_time.py_datetime().astimezone(dt.UTC), time_zone=time_zone
+        )
+        expected = date_time.to_tz(time_zone.key)
+        assert result.exact_eq(expected)
 
-    @given(date_time=zoned_date_times())
-    def test_callable(self, *, date_time: ZonedDateTime) -> None:
-        assert to_zoned_date_time(lambda: date_time) == date_time
+    @given(date_time=zoned_date_times(), time_zone=zone_infos())
+    def test_callable(self, *, date_time: ZonedDateTime, time_zone: ZoneInfo) -> None:
+        result = to_zoned_date_time(lambda: date_time, time_zone=time_zone)
+        expected = date_time.to_tz(time_zone.key)
+        assert result.exact_eq(expected)
 
-    def test_none(self) -> None:
-        assert abs(to_zoned_date_time(None) - get_now()) <= SECOND
+    @given(time_zone=zone_infos())
+    def test_none(self, *, time_zone: ZoneInfo) -> None:
+        result = to_zoned_date_time(None, time_zone=time_zone)
+        assert abs(result - get_now(time_zone)) <= SECOND
 
-    def test_sentinel(self) -> None:
-        assert to_zoned_date_time(sentinel) is sentinel
+    @given(time_zone=zone_infos())
+    def test_sentinel(self, *, time_zone: ZoneInfo) -> None:
+        assert to_zoned_date_time(sentinel, time_zone=time_zone) is sentinel
 
     @given(date_times=pairs(zoned_date_times()))
     def test_replace_non_sentinel(
@@ -1466,12 +1476,6 @@ 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)
-
 
 class TestZonedDateTimePeriod:
     @given(period=zoned_date_time_periods(), delta=time_deltas())
@@ -1669,7 +1673,7 @@ class TestZonedDateTimePeriod:
         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)
+        name = UTC.key
         expected = ZonedDateTimePeriod(period.start.to_tz(name), period.end.to_tz(name))
         assert result == expected
 

dycw_utilities-0.161.1/src/tests/test_zoneinfo.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING, Literal, cast
+from zoneinfo import ZoneInfo
+
+from hypothesis import given
+from hypothesis.strategies import DataObject, data, datetimes, just, sampled_from
+from pytest import mark, param, raises
+
+from utilities.hypothesis import zone_infos, zoned_date_times
+from utilities.tzdata import HongKong, Tokyo
+from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
+from utilities.zoneinfo import (
+    UTC,
+    _ToTimeZoneNameInvalidKeyError,
+    _ToTimeZoneNameInvalidTZInfoError,
+    _ToTimeZoneNamePlainDateTimeError,
+    _ToZoneInfoInvalidTZInfoError,
+    _ToZoneInfoPlainDateTimeError,
+    to_time_zone_name,
+    to_zone_info,
+)
+
+if TYPE_CHECKING:
+    from utilities.types import TimeZoneLike
+
+
+class TestToZoneInfo:
+    @given(time_zone=zone_infos())
+    def test_zone_info(self, *, time_zone: ZoneInfo) -> None:
+        result = to_zone_info(time_zone)
+        assert result is time_zone
+
+    @given(data=data(), time_zone=zone_infos())
+    def test_zoned_date_time(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        date_time = data.draw(zoned_date_times(time_zone=time_zone))
+        result = to_zone_info(date_time)
+        assert result is time_zone
+
+    @mark.parametrize("time_zone", [param("local"), param("localtime")])
+    def test_local(self, *, time_zone: Literal["local", "localtime"]) -> None:
+        result = to_zone_info(time_zone)
+        assert result is LOCAL_TIME_ZONE
+
+    @given(time_zone=zone_infos())
+    def test_str(self, *, time_zone: ZoneInfo) -> None:
+        result = to_zone_info(cast("TimeZoneLike", time_zone.key))
+        assert result is time_zone
+
+    def test_tz_info(self) -> None:
+        result = to_zone_info(dt.UTC)
+        assert result is UTC
+
+    @given(data=data(), time_zone=zone_infos())
+    def test_py_zoned_date_time(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        date_time = data.draw(datetimes(timezones=just(time_zone)))
+        result = to_zone_info(date_time)
+        assert result is time_zone
+
+    def test_error_invalid_tz_info(self) -> None:
+        time_zone = dt.timezone(dt.timedelta(hours=12))
+        with raises(
+            _ToZoneInfoInvalidTZInfoError, match=r"Invalid time-zone: UTC\+12:00"
+        ):
+            _ = to_zone_info(time_zone)
+
+    @given(date_time=datetimes())
+    def test_error_plain_date_time(self, *, date_time: dt.datetime) -> None:
+        with raises(_ToZoneInfoPlainDateTimeError, match="Plain date-time: .*"):
+            _ = to_zone_info(date_time)
+
+
+class TestToTimeZoneName:
+    @given(time_zone=zone_infos())
+    def test_zone_info(self, *, time_zone: ZoneInfo) -> None:
+        result = to_time_zone_name(time_zone)
+        expected = time_zone.key
+        assert result == expected
+
+    @given(data=data(), time_zone=zone_infos())
+    def test_zoned_date_time(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        date_time = data.draw(zoned_date_times(time_zone=time_zone))
+        result = to_time_zone_name(date_time)
+        expected = time_zone.key
+        assert result == expected
+
+    @mark.parametrize("time_zone", [param("local"), param("localtime")])
+    def test_local(self, *, time_zone: Literal["local", "localtime"]) -> None:
+        result = to_time_zone_name(time_zone)
+        assert result == LOCAL_TIME_ZONE_NAME
+
+    @given(time_zone=zone_infos())
+    def test_str(self, *, time_zone: ZoneInfo) -> None:
+        result = to_time_zone_name(cast("TimeZoneLike", time_zone.key))
+        expected = time_zone.key
+        assert result == expected
+
+    def test_tz_info(self) -> None:
+        result = to_time_zone_name(dt.UTC)
+        expected = UTC.key
+        assert result == expected
+
+    @given(data=data(), time_zone=zone_infos())
+    def test_py_zoned_date_time(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        date_time = data.draw(datetimes(timezones=just(time_zone)))
+        result = to_time_zone_name(date_time)
+        expected = time_zone.key
+        assert result == expected
+
+    def test_error_invalid_key(self) -> None:
+        with raises(
+            _ToTimeZoneNameInvalidKeyError, match="Invalid time-zone: 'invalid'"
+        ):
+            _ = to_time_zone_name(cast("TimeZoneLike", "invalid"))
+
+    def test_error_invalid_tz_info(self) -> None:
+        time_zone = dt.timezone(dt.timedelta(hours=12))
+        with raises(_ToTimeZoneNameInvalidTZInfoError, match="Invalid time-zone: .*"):
+            _ = to_time_zone_name(time_zone)
+
+    @given(date_time=datetimes())
+    def test_error_plain_date_time(self, *, date_time: dt.datetime) -> None:
+        with raises(_ToTimeZoneNamePlainDateTimeError, match="Plain date-time: .*"):
+            _ = to_time_zone_name(date_time)
+
+
+class TestTimeZones:
+    @given(time_zone=sampled_from([HongKong, Tokyo, UTC]))
+    def test_main(self, *, time_zone: ZoneInfo) -> None:
+        assert isinstance(time_zone, ZoneInfo)

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.160.2"
+__version__ = "0.161.1"

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/utilities/hypothesis.py

@@ -32,6 +32,7 @@ from hypothesis.strategies import (
     sampled_from,
     sets,
     text,
+    timezones,
     uuids,
 )
 from hypothesis.utils.conventions import not_set
@@ -97,14 +98,16 @@ from utilities.whenever import (
     DatePeriod,
     TimePeriod,
     ZonedDateTimePeriod,
+    get_now,
     to_date_time_delta,
     to_days,
     to_nanoseconds,
 )
-from utilities.zoneinfo import UTC, ensure_time_zone
+from utilities.zoneinfo import UTC, to_zone_info
 
 if TYPE_CHECKING:
     from collections.abc import Collection, Hashable, Iterable, Iterator
+    from zoneinfo import ZoneInfo
 
     from hypothesis.database import ExampleDatabase
     from libcst import Import, ImportFrom
@@ -835,7 +838,7 @@ def paths(
 @composite
 def _path_parts(draw: DrawFn, /) -> str:
     part = draw(text_ascii(min_size=1, max_size=10))
-    reserved = {"AUX", "NUL", "nuL"}
+    reserved = {"AUX", "NUL", "nuL", "pRn"}
     _ = assume(part not in reserved)
     return part
 
@@ -1476,6 +1479,19 @@ def year_months(
 ##
 
 
+@composite
+def zone_infos(draw: DrawFn, /) -> ZoneInfo:
+    """Strategy for generating time-zones."""
+    time_zone = draw(timezones())
+    _ = assume(time_zone.key not in {"Etc/UTC", "localtime"})
+    with assume_does_not_raise(TimeZoneNotFoundError):
+        _ = get_now(time_zone)
+    return time_zone
+
+
+##
+
+
 @composite
 def zoned_date_time_periods(
     draw: DrawFn,
@@ -1509,7 +1525,7 @@ def zoned_date_times(
 ) -> ZonedDateTime:
     """Strategy for generating zoned date-times."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    time_zone_ = ensure_time_zone(draw2(draw, time_zone))
+    time_zone_ = to_zone_info(draw2(draw, time_zone))
     match min_value_:
         case None | PlainDateTime():
             ...
@@ -1530,7 +1546,6 @@ def zoned_date_times(
     with (
         assume_does_not_raise(RepeatedTime),
         assume_does_not_raise(SkippedTime),
-        assume_does_not_raise(TimeZoneNotFoundError),
         assume_does_not_raise(ValueError, match="Resulting datetime is out of range"),
     ):
         zoned = plain.assume_tz(time_zone_.key, disambiguate="raise")
@@ -1602,6 +1617,7 @@ __all__ = [
     "urls",
     "versions",
     "year_months",
+    "zone_infos",
     "zoned_date_time_periods",
     "zoned_date_times",
     "zoned_date_times_2000",

{dycw_utilities-0.160.2 → dycw_utilities-0.161.1}/src/utilities/polars.py

@@ -104,7 +104,7 @@ from utilities.whenever import (
     ZonedDateTimePeriod,
     to_py_time_delta,
 )
-from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
+from utilities.zoneinfo import UTC, to_time_zone_name
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
@@ -834,7 +834,7 @@ def convert_time_zone(
 
 def _convert_time_zone_one(sr: Series, /, *, time_zone: TimeZoneLike = UTC) -> Series:
     if isinstance(sr.dtype, Datetime):
-        return sr.dt.convert_time_zone(get_time_zone_name(time_zone))
+        return sr.dt.convert_time_zone(to_time_zone_name(time_zone))
     return sr
 
 
@@ -2110,7 +2110,7 @@ def period_range(
     eager: bool = False,
 ) -> Series | Expr:
     """Construct a period range."""
-    time_zone_use = None if time_zone is None else ensure_time_zone(time_zone).key
+    time_zone_use = None if time_zone is None else to_time_zone_name(time_zone)
     match end_or_length:
         case ZonedDateTime() as end:
             ...
@@ -2127,7 +2127,7 @@ def period_range(
         time_zone=time_zone_use,
         eager=eager,
     ).alias("start")
-    ends = (starts.dt.offset_by(interval)).alias("end")
+    ends = starts.dt.offset_by(interval).alias("end")
     period = struct(starts, ends)
     return try_reify_expr(period, starts, ends)
 
@@ -2220,7 +2220,7 @@ def _replace_time_zone_one(
     sr: Series, /, *, time_zone: TimeZoneLike | None = UTC
 ) -> Series:
     if isinstance(sr.dtype, Datetime):
-        time_zone_use = None if time_zone is None else get_time_zone_name(time_zone)
+        time_zone_use = None if time_zone is None else to_time_zone_name(time_zone)
         return sr.dt.replace_time_zone(time_zone_use)
     return sr
 
@@ -2611,7 +2611,7 @@ def zoned_date_time_dtype(
     *, time_unit: TimeUnit = "us", time_zone: TimeZoneLike = UTC
 ) -> Datetime:
     """Create a zoned date-time data type."""
-    return Datetime(time_unit=time_unit, time_zone=get_time_zone_name(time_zone))
+    return Datetime(time_unit=time_unit, time_zone=to_time_zone_name(time_zone))
 
 
 def zoned_date_time_period_dtype(