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

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

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

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

@@ -227,7 +227,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.161.0"
+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.161.0"
+current_version = "0.161.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.161.0 → 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.161.0 → 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,
@@ -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,10 +402,9 @@ 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
 
@@ -436,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:
@@ -1395,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(

{dycw_utilities-0.161.0 → dycw_utilities-0.161.1}/src/tests/test_zoneinfo.py

@@ -1,22 +1,14 @@
 from __future__ import annotations
 
 import datetime as dt
-from typing import TYPE_CHECKING, cast
+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,
-    timezones,
-)
-from pytest import raises
+from hypothesis.strategies import DataObject, data, datetimes, just, sampled_from
+from pytest import mark, param, raises
 
-from tests.conftest import SKIPIF_CI_AND_LINUX
-from utilities.hypothesis import zoned_date_times
+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 (
@@ -35,22 +27,23 @@ if TYPE_CHECKING:
 
 
 class TestToZoneInfo:
-    @given(time_zone=timezones())
+    @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=timezones())
+    @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
 
-    def test_local(self) -> None:
-        result = to_zone_info("local")
+    @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=timezones())
+    @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
@@ -59,7 +52,7 @@ class TestToZoneInfo:
         result = to_zone_info(dt.UTC)
         assert result is UTC
 
-    @given(data=data(), time_zone=timezones())
+    @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)
@@ -79,25 +72,25 @@ class TestToZoneInfo:
 
 
 class TestToTimeZoneName:
-    @given(time_zone=timezones())
+    @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=timezones())
+    @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
 
-    def test_local(self) -> None:
-        result = to_time_zone_name("local")
+    @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=timezones())
-    @SKIPIF_CI_AND_LINUX
+    @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
@@ -108,7 +101,7 @@ class TestToTimeZoneName:
         expected = UTC.key
         assert result == expected
 
-    @given(data=data(), time_zone=timezones())
+    @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)

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

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

{dycw_utilities-0.161.0 → 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,6 +98,7 @@ from utilities.whenever import (
     DatePeriod,
     TimePeriod,
     ZonedDateTimePeriod,
+    get_now,
     to_date_time_delta,
     to_days,
     to_nanoseconds,
@@ -105,6 +107,7 @@ 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,
@@ -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.161.0 → dycw_utilities-0.161.1}/src/utilities/types.py

@@ -276,7 +276,12 @@ TIME_ZONES: list[TimeZone] = list(get_args(TimeZone.__value__))
 
 
 type TimeZoneLike = (
-    ZoneInfo | ZonedDateTime | Literal["local"] | TimeZone | dt.tzinfo | dt.datetime
+    ZoneInfo
+    | ZonedDateTime
+    | Literal["local", "localtime"]
+    | TimeZone
+    | dt.tzinfo
+    | dt.datetime
 )
 
 

{dycw_utilities-0.161.0 → dycw_utilities-0.161.1}/src/utilities/whenever.py

@@ -1638,22 +1638,27 @@ def to_zoned_date_time(
 ) -> ZonedDateTime | Sentinel:
     """Convert to a zoned date-time."""
     match date_time:
-        case ZonedDateTime() | Sentinel():
-            return date_time
+        case ZonedDateTime() as date_time_use:
+            ...
+        case Sentinel():
+            return sentinel
         case None:
             return get_now(time_zone)
         case str():
-            return ZonedDateTime.parse_common_iso(date_time)
-        case dt.datetime():
+            date_time_use = ZonedDateTime.parse_common_iso(date_time)
+        case dt.datetime() as py_date_time:
             if isinstance(date_time.tzinfo, ZoneInfo):
-                return ZonedDateTime.from_py_datetime(date_time)
-            if date_time.tzinfo is dt.UTC:
-                return ZonedDateTime.from_py_datetime(date_time.astimezone(UTC))
-            raise ToZonedDateTimeError(date_time=date_time)
+                py_date_time_use = py_date_time
+            elif date_time.tzinfo is dt.UTC:
+                py_date_time_use = py_date_time.astimezone(UTC)
+            else:
+                raise ToZonedDateTimeError(date_time=date_time)
+            date_time_use = ZonedDateTime.from_py_datetime(py_date_time_use)
         case Callable() as func:
             return to_zoned_date_time(func(), time_zone=time_zone)
         case never:
             assert_never(never)
+    return date_time_use.to_tz(to_time_zone_name(time_zone))
 
 
 @dataclass(kw_only=True, slots=True)

{dycw_utilities-0.161.0 → dycw_utilities-0.161.1}/src/utilities/zoneinfo.py

@@ -27,7 +27,7 @@ def to_zone_info(obj: TimeZoneLike, /) -> ZoneInfo:
             return zone_info
         case ZonedDateTime() as date_time:
             return ZoneInfo(date_time.tz)
-        case "local":
+        case "local" | "localtime":
             return LOCAL_TIME_ZONE
         case str() as key:
             return ZoneInfo(key)
@@ -75,7 +75,7 @@ def to_time_zone_name(obj: TimeZoneLike, /) -> TimeZone:
             return cast("TimeZone", zone_info.key)
         case ZonedDateTime() as date_time:
             return cast("TimeZone", date_time.tz)
-        case "local":
+        case "local" | "localtime":
             return LOCAL_TIME_ZONE_NAME
         case str() as time_zone:
             if time_zone in TIME_ZONES: