dycw-utilities 0.136.10__tar.gz → 0.138.0__tar.gz

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/PKG-INFO

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

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/pyproject.toml

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

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_click.py

@@ -43,10 +43,11 @@ from utilities.click import (
     ListChoices,
     ListEnums,
     ListStrs,
-    Month,
+    MonthDay,
     PlainDateTime,
     Time,
     TimeDelta,
+    YearMonth,
     ZonedDateTime,
 )
 from utilities.hypothesis import (
@@ -54,11 +55,12 @@ from utilities.hypothesis import (
     date_time_deltas,
     dates,
     freqs,
-    months,
+    month_days,
     plain_datetimes,
     text_ascii,
     time_deltas,
     times,
+    year_months,
     zoned_datetimes,
 )
 from utilities.text import join_strs, strip_and_dedent
@@ -283,10 +285,10 @@ class TestParameters:
             failable=True,
         ),
         _Case(
-            param=Month(),
-            name="month",
-            strategy=months(),
-            serialize=utilities.whenever.Month.format_common_iso,
+            param=MonthDay(),
+            name="month-day",
+            strategy=month_days(),
+            serialize=whenever.MonthDay.format_common_iso,
             failable=True,
         ),
         _Case(
@@ -310,6 +312,13 @@ class TestParameters:
             serialize=whenever.TimeDelta.format_common_iso,
             failable=True,
         ),
+        _Case(
+            param=YearMonth(),
+            name="year-month",
+            strategy=year_months(),
+            serialize=whenever.YearMonth.format_common_iso,
+            failable=True,
+        ),
         _Case(
             param=ZonedDateTime(),
             name="zoned date-time",

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_hypothesis.py

@@ -30,10 +30,12 @@ from whenever import (
     Date,
     DateDelta,
     DateTimeDelta,
+    MonthDay,
     PlainDateTime,
     Time,
     TimeDelta,
     TimeZoneNotFoundError,
+    YearMonth,
     ZonedDateTime,
 )
 
@@ -62,7 +64,7 @@ from utilities.hypothesis import (
     int64s,
     int_arrays,
     lists_fixed_length,
-    months,
+    month_days,
     namespace_mixins,
     numbers,
     pairs,
@@ -89,6 +91,7 @@ from utilities.hypothesis import (
     uint32s,
     uint64s,
     versions,
+    year_months,
     zoned_datetimes,
 )
 from utilities.iterables import one
@@ -115,7 +118,6 @@ from utilities.whenever import (
     DATE_TWO_DIGIT_YEAR_MAX,
     DATE_TWO_DIGIT_YEAR_MIN,
     Freq,
-    Month,
     to_days,
     to_nanos,
 )
@@ -611,24 +613,19 @@ class TestListsFixedLength:
             assert sorted(result) == result
 
 
-class TestMonths:
-    @given(data=data(), two_digit=booleans())
-    def test_main(self, *, data: DataObject, two_digit: bool) -> None:
-        min_value = data.draw(months() | none())
-        max_value = data.draw(months() | none())
+class TestMonthDays:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(month_days() | none())
+        max_value = data.draw(month_days() | none())
         with assume_does_not_raise(InvalidArgument):
-            month = data.draw(
-                months(min_value=min_value, max_value=max_value, two_digit=two_digit)
-            )
-        assert isinstance(month, Month)
-        assert Month.parse_common_iso(month.format_common_iso()) == month
+            month_day = data.draw(month_days(min_value=min_value, max_value=max_value))
+        assert isinstance(month_day, MonthDay)
+        assert MonthDay.parse_common_iso(month_day.format_common_iso()) == month_day
         if min_value is not None:
-            assert month >= min_value
+            assert month_day >= min_value
         if max_value is not None:
-            assert month <= max_value
-        if two_digit:
-            assert month.to_date() >= DATE_TWO_DIGIT_YEAR_MIN
-            assert month.to_date() <= DATE_TWO_DIGIT_YEAR_MAX
+            assert month_day <= max_value
 
 
 class TestNamespaceMixins:
@@ -683,8 +680,8 @@ class TestPairs:
 class TestPaths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_depth = data.draw(integers(0, 10) | none())
-        max_depth = data.draw(integers(0, 10) | none())
+        min_depth = data.draw(integers(0, 5) | none())
+        max_depth = data.draw(integers(0, 5) | none())
         with assume_does_not_raise(InvalidArgument):
             path = data.draw(paths(min_depth=min_depth, max_depth=max_depth))
         assert isinstance(path, Path)
@@ -1010,6 +1007,28 @@ class TestVersions:
             assert version.suffix is None
 
 
+class TestYearMonths:
+    @given(data=data(), two_digit=booleans())
+    def test_main(self, *, data: DataObject, two_digit: bool) -> None:
+        min_value = data.draw(year_months() | none())
+        max_value = data.draw(year_months() | none())
+        with assume_does_not_raise(InvalidArgument):
+            year_month = data.draw(
+                year_months(
+                    min_value=min_value, max_value=max_value, two_digit=two_digit
+                )
+            )
+        assert isinstance(year_month, YearMonth)
+        assert YearMonth.parse_common_iso(year_month.format_common_iso()) == year_month
+        if min_value is not None:
+            assert year_month >= min_value
+        if max_value is not None:
+            assert year_month <= max_value
+        if two_digit:
+            assert year_month.on_day(1) >= DATE_TWO_DIGIT_YEAR_MIN
+            assert year_month.on_day(28) <= DATE_TWO_DIGIT_YEAR_MAX
+
+
 class TestZonedDateTimes:
     @given(data=data(), time_zone=timezones())
     def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_logging.py

@@ -38,7 +38,7 @@ from utilities.logging import (
 from utilities.text import unique_str
 from utilities.types import LogLevel
 from utilities.typing import get_args
-from utilities.whenever import format_compact, get_now
+from utilities.whenever import format_compact, get_now, to_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -192,7 +192,7 @@ class TestComputeRolloverActions:
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
-        now = format_compact(get_now().to_plain())
+        now = format_compact(to_local_plain(get_now()))
         tmp_path.joinpath(f"log.99__{now}__{now}.txt").touch()
         actions = _compute_rollover_actions(tmp_path, "log", ".txt")
         assert len(actions.deletions) == 2
@@ -319,7 +319,7 @@ class TestRotatingLogFile:
     def test_from_path_with_index_and_end(
         self, *, index: int, end: ZonedDateTime
     ) -> None:
-        path = Path(f"log.{index}__{format_compact(end.to_plain())}.txt")
+        path = Path(f"log.{index}__{format_compact(to_local_plain(end))}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -334,7 +334,7 @@ class TestRotatingLogFile:
     ) -> None:
         start, end = datetimes
         path = Path(
-            f"log.{index}__{format_compact(start.to_plain())}__{format_compact(end.to_plain())}.txt"
+            f"log.{index}__{format_compact(to_local_plain(start))}__{format_compact(to_local_plain(end))}.txt"
         )
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
@@ -366,7 +366,7 @@ class TestRotatingLogFile:
             directory=root, stem="log", suffix=".txt", index=index, end=end
         )
         assert file.path == root.joinpath(
-            f"log.{index}__{format_compact(end.to_plain())}.txt"
+            f"log.{index}__{format_compact(to_local_plain(end))}.txt"
         )
 
     @given(
@@ -382,7 +382,7 @@ class TestRotatingLogFile:
             directory=root, stem="log", suffix=".txt", index=index, start=start, end=end
         )
         assert file.path == root.joinpath(
-            f"log.{index}__{format_compact(start.to_plain())}__{format_compact(end.to_plain())}.txt"
+            f"log.{index}__{format_compact(to_local_plain(start))}__{format_compact(to_local_plain(end))}.txt"
         )
 
 

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_objects/objects.py

@@ -39,6 +39,7 @@ from utilities.hypothesis import (
     date_time_deltas,
     dates,
     int64s,
+    month_days,
     paths,
     plain_datetimes,
     text_ascii,
@@ -46,6 +47,7 @@ from utilities.hypothesis import (
     time_deltas,
     times,
     versions,
+    year_months,
     zoned_datetimes,
 )
 from utilities.math import MAX_INT64, MIN_INT64
@@ -81,6 +83,7 @@ def objects(
         | dates()
         | floats(allow_nan=floats_allow_nan)
         | (int64s() if parsable else integers())
+        | month_days()
         | none()
         | paths()
         | plain_datetimes()
@@ -89,6 +92,7 @@ def objects(
         | times()
         | uuids()
         | versions()
+        | year_months()
         | zoned_datetimes()
     )
     if dataclass_custom_equality:

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_parse.py

@@ -24,9 +24,11 @@ from whenever import (
     Date,
     DateDelta,
     DateTimeDelta,
+    MonthDay,
     PlainDateTime,
     Time,
     TimeDelta,
+    YearMonth,
     ZonedDateTime,
 )
 
@@ -45,7 +47,7 @@ from utilities.functions import ensure_path
 from utilities.hypothesis import (
     dates,
     int64s,
-    months,
+    month_days,
     numbers,
     paths,
     plain_datetimes,
@@ -53,6 +55,7 @@ from utilities.hypothesis import (
     time_deltas,
     times,
     versions,
+    year_months,
     zoned_datetimes,
 )
 from utilities.math import is_equal
@@ -68,7 +71,6 @@ from utilities.sentinel import Sentinel, sentinel
 from utilities.text import parse_bool
 from utilities.types import Number
 from utilities.version import Version
-from utilities.whenever import Month
 
 
 class TestSerializeAndParseObject:
@@ -143,11 +145,11 @@ class TestSerializeAndParseObject:
         result = parse_object(TrueOrFalseFutureLit, truth)
         assert result == truth
 
-    @given(month=months())
-    def test_month(self, *, month: Month) -> None:
-        serialized = serialize_object(month)
-        result = parse_object(Month, serialized)
-        assert result == month
+    @given(month_day=month_days())
+    def test_month_day(self, *, month_day: MonthDay) -> None:
+        serialized = serialize_object(month_day)
+        result = parse_object(MonthDay, serialized)
+        assert result == month_day
 
     def test_none(self) -> None:
         serialized = serialize_object(None)
@@ -316,6 +318,12 @@ class TestSerializeAndParseObject:
         result = parse_object(Version, serialized)
         assert result == version
 
+    @given(year_month=year_months())
+    def test_year_month(self, *, year_month: YearMonth) -> None:
+        serialized = serialize_object(year_month)
+        result = parse_object(YearMonth, serialized)
+        assert result == year_month
+
     @given(datetime=zoned_datetimes())
     def test_zoned_datetime(self, *, datetime: ZonedDateTime) -> None:
         serialized = serialize_object(datetime)
@@ -507,6 +515,13 @@ class TestParseObject:
         ):
             _ = parse_object(list[int], "[invalid]")
 
+    def test_error_month_day(self) -> None:
+        with raises(
+            _ParseObjectParseError,
+            match=r"Unable to parse <class 'whenever\.MonthDay'>; got 'invalid'",
+        ):
+            _ = parse_object(MonthDay, "invalid")
+
     def test_error_none(self) -> None:
         with raises(
             _ParseObjectParseError, match="Unable to parse None; got 'invalid'"
@@ -622,6 +637,13 @@ class TestParseObject:
         ):
             _ = parse_object(Version, "invalid")
 
+    def test_error_year_month(self) -> None:
+        with raises(
+            _ParseObjectParseError,
+            match=r"Unable to parse <class 'whenever\.YearMonth'>; got 'invalid'",
+        ):
+            _ = parse_object(YearMonth, "invalid")
+
     def test_error_zoned_datetime(self) -> None:
         with raises(
             _ParseObjectParseError,

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_sqlalchemy.py

@@ -89,7 +89,7 @@ from utilities.sqlalchemy import (
 )
 from utilities.text import strip_and_dedent
 from utilities.typing import get_args, get_literal_elements
-from utilities.whenever import SECOND, format_compact, get_now
+from utilities.whenever import SECOND, format_compact, get_now, to_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
@@ -102,9 +102,8 @@ if TYPE_CHECKING:
 
 def _table_names() -> str:
     """Generate at unique string."""
-    now = get_now()
     key = str(uuid4()).replace("-", "")
-    return f"{format_compact(now)}_{key}"
+    return f"{format_compact(to_local_plain(get_now()))}_{key}"
 
 
 @overload

{dycw_utilities-0.136.10 → dycw_utilities-0.138.0}/src/tests/test_typed_settings.py

@@ -2,7 +2,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from ipaddress import IPv4Address, IPv6Address
 from pathlib import Path
-from typing import assert_never
+from typing import Any, ClassVar, assert_never
 
 import typed_settings
 from hypothesis import given
@@ -20,9 +20,11 @@ from whenever import (
     Date,
     DateDelta,
     DateTimeDelta,
+    MonthDay,
     PlainDateTime,
     Time,
     TimeDelta,
+    YearMonth,
     ZonedDateTime,
 )
 
@@ -31,12 +33,14 @@ from utilities.hypothesis import (
     date_time_deltas,
     dates,
     freqs,
+    month_days,
     paths,
     plain_datetimes,
     temp_paths,
     text_ascii,
     time_deltas,
     times,
+    year_months,
     zoned_datetimes,
 )
 from utilities.os import temp_environ
@@ -51,47 +55,88 @@ from utilities.whenever import Freq
 app_names = text_ascii(min_size=1).map(str.lower)
 
 
+@dataclass(kw_only=True, slots=True)
+class _Case[T]:
+    cls: type[T]
+    strategy: SearchStrategy[T]
+    serialize: Callable[[T], str]
+
+
 class TestExtendedTSConverter:
+    cases: ClassVar[list[_Case]] = [
+        _Case(cls=Date, strategy=dates(), serialize=Date.format_common_iso),
+        _Case(
+            cls=DateDelta,
+            strategy=date_deltas(parsable=True),
+            serialize=DateDelta.format_common_iso,
+        ),
+        _Case(
+            cls=DateTimeDelta,
+            strategy=date_time_deltas(parsable=True),
+            serialize=DateTimeDelta.format_common_iso,
+        ),
+        _Case(cls=Freq, strategy=freqs(), serialize=Freq.serialize),
+        _Case(cls=IPv4Address, strategy=ip_addresses(v=4), serialize=str),
+        _Case(cls=IPv6Address, strategy=ip_addresses(v=6), serialize=str),
+        _Case(
+            cls=MonthDay, strategy=month_days(), serialize=MonthDay.format_common_iso
+        ),
+        _Case(
+            cls=PlainDateTime,
+            strategy=plain_datetimes(),
+            serialize=PlainDateTime.format_common_iso,
+        ),
+        _Case(cls=Time, strategy=times(), serialize=Time.format_common_iso),
+        _Case(
+            cls=TimeDelta, strategy=time_deltas(), serialize=TimeDelta.format_common_iso
+        ),
+        _Case(
+            cls=YearMonth, strategy=year_months(), serialize=YearMonth.format_common_iso
+        ),
+        _Case(
+            cls=ZonedDateTime,
+            strategy=zoned_datetimes(),
+            serialize=ZonedDateTime.format_common_iso,
+        ),
+    ]
+
+    @given(data=data())
+    @mark.parametrize(("cls", "strategy"), [param(c.cls, c.strategy) for c in cases])
+    def test_default(
+        self, *, data: DataObject, cls: type[Any], strategy: SearchStrategy[Any]
+    ) -> None:
+        default = data.draw(strategy)
+
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            value: cls = default  # pyright: ignore[reportInvalidTypeForm]
+
+        loaded = typed_settings.load_settings(
+            Settings, loaders=[], converter=ExtendedTSConverter()
+        )
+        assert loaded.value == default
+
     @given(data=data(), root=temp_paths(), app_name=app_names)
     @mark.parametrize(
-        ("test_cls", "strategy", "serialize"),
-        [
-            param(Date, dates(), Date.format_common_iso),
-            param(DateDelta, date_deltas(parsable=True), DateDelta.format_common_iso),
-            param(
-                DateTimeDelta,
-                date_time_deltas(parsable=True),
-                DateTimeDelta.format_common_iso,
-            ),
-            param(Freq, freqs(), Freq.serialize),
-            param(IPv4Address, ip_addresses(v=4), IPv4Address),
-            param(IPv6Address, ip_addresses(v=6), IPv6Address),
-            param(PlainDateTime, plain_datetimes(), PlainDateTime.format_common_iso),
-            param(Time, times(), Time.format_common_iso),
-            param(TimeDelta, time_deltas(), TimeDelta.format_common_iso),
-            param(ZonedDateTime, zoned_datetimes(), ZonedDateTime.format_common_iso),
-        ],
+        ("cls", "strategy", "serialize"),
+        [param(c.cls, c.strategy, c.serialize) for c in cases],
     )
-    def test_main[T](
+    def test_loaded(
         self,
         *,
         data: DataObject,
         root: Path,
         app_name: str,
-        test_cls: type[T],
-        strategy: SearchStrategy[T],
-        serialize: Callable[[T], str],
+        cls: type[Any],
+        strategy: SearchStrategy[Any],
+        serialize: Callable[[Any], str],
     ) -> None:
         default, value = data.draw(tuples(strategy, strategy))
 
         @dataclass(frozen=True, kw_only=True, slots=True)
         class Settings:
-            value: test_cls = default  # pyright: ignore[reportInvalidTypeForm]
+            value: cls = default  # pyright: ignore[reportInvalidTypeForm]
 
-        settings_default = typed_settings.load_settings(
-            Settings, loaders=[], converter=ExtendedTSConverter()
-        )
-        assert settings_default.value == default
         file = Path(root, "file.toml")
         _ = file.write_text(
             strip_and_dedent(f"""
@@ -99,14 +144,14 @@ class TestExtendedTSConverter:
                 value = '{serialize(value)}'
             """)
         )
-        settings_loaded = typed_settings.load_settings(
+        loaded = typed_settings.load_settings(
             Settings,
             loaders=[
                 FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
             ],
             converter=ExtendedTSConverter(),
         )
-        assert settings_loaded.value == value
+        assert loaded.value == value
 
     @given(
         root=temp_paths(),