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

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

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

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

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

{dycw_utilities-0.137.0 → 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.137.0 → 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.137.0 → 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.137.0 → 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.137.0 → 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(),

{dycw_utilities-0.137.0 → dycw_utilities-0.138.0}/src/tests/test_whenever.py

@@ -6,15 +6,8 @@ from typing import TYPE_CHECKING, ClassVar, Self
 from zoneinfo import ZoneInfo
 
 from hypothesis import given
-from hypothesis.strategies import (
-    DataObject,
-    data,
-    integers,
-    none,
-    sampled_from,
-    timezones,
-)
-from pytest import mark, param, raises
+from hypothesis.strategies import integers, none, sampled_from, timezones
+from pytest import raises
 from whenever import (
     Date,
     DateDelta,
@@ -32,7 +25,6 @@ from utilities.hypothesis import (
     date_deltas,
     dates,
     freqs,
-    months,
     pairs,
     plain_datetimes,
     sentinels,
@@ -49,8 +41,6 @@ from utilities.whenever import (
     DATE_DELTA_MIN,
     DATE_DELTA_PARSABLE_MAX,
     DATE_DELTA_PARSABLE_MIN,
-    DATE_MAX,
-    DATE_MIN,
     DATE_TIME_DELTA_MAX,
     DATE_TIME_DELTA_MIN,
     DATE_TIME_DELTA_PARSABLE_MAX,
@@ -60,8 +50,6 @@ from utilities.whenever import (
     MINUTE,
     NOW_LOCAL,
     NOW_UTC,
-    PLAIN_DATE_TIME_MAX,
-    PLAIN_DATE_TIME_MIN,
     SECOND,
     TIME_DELTA_MAX,
     TIME_DELTA_MIN,
@@ -73,7 +61,6 @@ from utilities.whenever import (
     Freq,
     MeanDateTimeError,
     MinMaxDateError,
-    Month,
     ToDaysError,
     ToNanosError,
     WheneverLogRecord,
@@ -83,8 +70,6 @@ from utilities.whenever import (
     _MinMaxDateMaxDateError,
     _MinMaxDateMinDateError,
     _MinMaxDatePeriodError,
-    _MonthInvalidError,
-    _MonthParseCommonISOError,
     datetime_utc,
     format_compact,
     from_timestamp,
@@ -107,8 +92,6 @@ from utilities.whenever import (
 from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
-
     from utilities.sentinel import Sentinel
     from utilities.types import MaybeCallableDate, MaybeCallableZonedDateTime
 
@@ -141,7 +124,9 @@ class TestFormatCompact:
         result = format_compact(time)
         assert isinstance(result, str)
         parsed = Time.parse_common_iso(result)
-        assert parsed == time
+        assert parsed.nanosecond == 0
+        expected = time.round()
+        assert parsed == expected
 
     @given(datetime=plain_datetimes())
     def test_plain_datetime(self, *, datetime: PlainDateTime) -> None:
@@ -325,14 +310,6 @@ class TestMeanDateTime:
 
 
 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)
@@ -375,11 +352,11 @@ class TestMinMax:
 
     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)
+            _ = PlainDateTime.MIN.subtract(nanoseconds=1, ignore_dst=True)
 
     def test_plain_date_time_max(self) -> None:
         with raises(ValueError, match=r"Result of add\(\) out of range"):
-            _ = PLAIN_DATE_TIME_MAX.add(microseconds=1, ignore_dst=True)
+            _ = PlainDateTime.MAX.add(microseconds=1, ignore_dst=True)
 
     def test_time_delta_min(self) -> None:
         nanos = TIME_DELTA_MIN.in_nanoseconds()
@@ -466,109 +443,6 @@ class TestMinMaxDate:
             _ = min_max_date(min_date=dates[1], max_date=dates[0])
 
 
-class TestMonth:
-    @mark.parametrize(
-        ("month", "n", "expected"),
-        [
-            param(Month(2000, 1), -2, Month(1999, 11)),
-            param(Month(2000, 1), -1, Month(1999, 12)),
-            param(Month(2000, 1), 0, Month(2000, 1)),
-            param(Month(2000, 1), 1, Month(2000, 2)),
-            param(Month(2000, 1), 2, Month(2000, 3)),
-            param(Month(2000, 1), 11, Month(2000, 12)),
-            param(Month(2000, 1), 12, Month(2001, 1)),
-        ],
-    )
-    def test_add(self, *, month: Month, n: int, expected: Month) -> None:
-        result = month + n
-        assert result == expected
-
-    @given(month=months())
-    def test_common_iso(self, *, month: Month) -> None:
-        result = Month.parse_common_iso(month.format_common_iso())
-        assert result == month
-
-    @given(data=data(), month=months())
-    def test_ensure(self, *, data: DataObject, month: Month) -> None:
-        str_or_value = data.draw(sampled_from([month, month.format_common_iso()]))
-        result = Month.ensure(str_or_value)
-        assert result == month
-
-    @mark.parametrize(
-        ("x", "y", "expected"),
-        [
-            param(Month(2000, 1), Month(1999, 11), 2),
-            param(Month(2000, 1), Month(1999, 12), 1),
-            param(Month(2000, 1), Month(2000, 1), 0),
-            param(Month(2000, 1), Month(2000, 2), -1),
-            param(Month(2000, 1), Month(2000, 3), -2),
-            param(Month(2000, 1), Month(2000, 12), -11),
-            param(Month(2000, 1), Month(2001, 1), -12),
-        ],
-    )
-    def test_diff(self, *, x: Month, y: Month, expected: int) -> None:
-        result = x - y
-        assert result == expected
-
-    @given(month=months())
-    def test_hashable(self, *, month: Month) -> None:
-        _ = hash(month)
-
-    @mark.parametrize(
-        ("text", "expected"),
-        [
-            param("2000-01", Month(2000, 1)),
-            param("2000.01", Month(2000, 1)),
-            param("2000 01", Month(2000, 1)),
-            param("200001", Month(2000, 1)),
-            param("20-01", Month(2020, 1)),
-            param("20.01", Month(2020, 1)),
-        ],
-    )
-    def test_parse_common_iso(self, *, text: str, expected: Month) -> None:
-        result = Month.parse_common_iso(text)
-        assert result == expected
-
-    @mark.parametrize("func", [param(repr), param(str)])
-    def test_repr(self, *, func: Callable[..., str]) -> None:
-        result = func(Month(2000, 12))
-        expected = "2000-12"
-        assert result == expected
-
-    @mark.parametrize(
-        ("month", "n", "expected"),
-        [
-            param(Month(2000, 1), -2, Month(2000, 3)),
-            param(Month(2000, 1), -1, Month(2000, 2)),
-            param(Month(2000, 1), 0, Month(2000, 1)),
-            param(Month(2000, 1), 1, Month(1999, 12)),
-            param(Month(2000, 1), 2, Month(1999, 11)),
-            param(Month(2000, 1), 12, Month(1999, 1)),
-            param(Month(2000, 1), 13, Month(1998, 12)),
-        ],
-    )
-    def test_subtract(self, *, month: Month, n: int, expected: Month) -> None:
-        result = month - n
-        assert result == expected
-
-    @given(date=dates())
-    def test_to_and_from_date(self, *, date: Date) -> None:
-        month = Month.from_date(date)
-        result = month.to_date(day=date.day)
-        assert result == date
-
-    def test_error_invalid(self) -> None:
-        with raises(_MonthInvalidError, match=r"Invalid year and month: \d+, \d+"):
-            _ = Month(2000, 13)
-
-    @mark.parametrize("text", [param("invalid"), param("202-01")])
-    def test_error_parse_common_iso(self, *, text: str) -> None:
-        with raises(
-            _MonthParseCommonISOError, match=r"Unable to parse month; got '.*'"
-        ):
-            _ = Month.parse_common_iso(text)
-
-
 class TestToDate:
     @given(date=dates())
     def test_date(self, *, date: Date) -> None: