dycw-utilities 0.167.3__tar.gz → 0.168.1__tar.gz

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.167.3
+Version: 0.168.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: atomicwrites<1.5,>=1.4.1
 Requires-Dist: typing-extensions<4.16,>=4.15.0
 Requires-Dist: tzlocal<5.4,>=5.3.1
-Requires-Dist: whenever<0.9,>=0.8.9
+Requires-Dist: whenever<0.10,>=0.9.0
 Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/pyproject.toml

@@ -31,7 +31,7 @@ core = [
   "atomicwrites >=1.4.1, <1.5",
   "typing-extensions >=4.15.0, <4.16",
   "tzlocal >=5.3.1, <5.4",
-  "whenever >=0.8.9, <0.9",
+  "whenever >=0.9.0, <0.10",
 ]
 cryptography = [
   "cryptography >=46.0.1, <46.1",
@@ -90,7 +90,7 @@ jupyter-test = [
   "polars",
 ]
 libcst = [
-  "libcst >=1.8.2, <1.9",
+  "libcst >=1.8.5, <1.9",
 ]
 lightweight-charts = [
   "lightweight-charts >=2.1, <2.2",
@@ -244,12 +244,12 @@ dependencies = [
   "atomicwrites >=1.4.1, <1.5",
   "typing-extensions >=4.15.0, <4.16",
   "tzlocal >=5.3.1, <5.4",
-  "whenever >=0.8.9, <0.9",
+  "whenever >=0.9.0, <0.10",
 ]
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.167.3"
+version = "0.168.1"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -282,7 +282,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.167.3"
+current_version = "0.168.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/tests/conftest.py

@@ -176,7 +176,7 @@ def _is_to_drop(table: str, /) -> bool:
         text = extract_group(r"^(\d{8}T\d{2,})_", table)
     except ExtractGroupError:
         return True
-    date_time = PlainDateTime.parse_common_iso(text)
+    date_time = PlainDateTime.parse_iso(text)
     age = now.difference(date_time, ignore_dst=True)
     return age >= MINUTE
 

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/tests/test_click.py

@@ -124,21 +124,21 @@ class TestParameters:
             param=Date(),
             name="date",
             strategy=dates(),
-            serialize=whenever.Date.format_common_iso,
+            serialize=whenever.Date.format_iso,
             failable=True,
         ),
         _Case(
             param=DateDelta(),
             name="date delta",
             strategy=date_deltas(parsable=True),
-            serialize=whenever.DateDelta.format_common_iso,
+            serialize=whenever.DateDelta.format_iso,
             failable=True,
         ),
         _Case(
             param=DateTimeDelta(),
             name="date-time delta",
             strategy=date_time_deltas(parsable=True),
-            serialize=whenever.DateTimeDelta.format_common_iso,
+            serialize=whenever.DateTimeDelta.format_iso,
             failable=True,
         ),
         _Case(
@@ -222,7 +222,7 @@ class TestParameters:
             param=MonthDay(),
             name="month-day",
             strategy=month_days(),
-            serialize=whenever.MonthDay.format_common_iso,
+            serialize=whenever.MonthDay.format_iso,
             failable=True,
         ),
         _Case(
@@ -232,21 +232,21 @@ class TestParameters:
             param=PlainDateTime(),
             name="plain date-time",
             strategy=plain_date_times(),
-            serialize=whenever.PlainDateTime.format_common_iso,
+            serialize=whenever.PlainDateTime.format_iso,
             failable=True,
         ),
         _Case(
             param=Time(),
             name="time",
             strategy=times(),
-            serialize=whenever.Time.format_common_iso,
+            serialize=whenever.Time.format_iso,
             failable=True,
         ),
         _Case(
             param=TimeDelta(),
             name="time-delta",
             strategy=time_deltas(),
-            serialize=whenever.TimeDelta.format_common_iso,
+            serialize=whenever.TimeDelta.format_iso,
             failable=True,
         ),
         _Case(
@@ -256,14 +256,14 @@ class TestParameters:
             param=YearMonth(),
             name="year-month",
             strategy=year_months(),
-            serialize=whenever.YearMonth.format_common_iso,
+            serialize=whenever.YearMonth.format_iso,
             failable=True,
         ),
         _Case(
             param=ZonedDateTime(),
             name="zoned date-time",
             strategy=zoned_date_times(),
-            serialize=whenever.ZonedDateTime.format_common_iso,
+            serialize=whenever.ZonedDateTime.format_iso,
             failable=True,
         ),
     ]

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/tests/test_hypothesis.py

@@ -209,7 +209,7 @@ class TestDateDeltas:
         if max_value is not None:
             assert days <= to_days(max_value)
         if parsable:
-            assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
+            assert DateDelta.parse_iso(delta.format_iso()) == delta
 
 
 class TestDatePeriods:
@@ -247,7 +247,7 @@ class TestDateTimeDeltas:
         if max_value is not None:
             assert nanos <= to_nanoseconds(max_value)
         if parsable:
-            assert DateTimeDelta.parse_common_iso(delta.format_common_iso()) == delta
+            assert DateTimeDelta.parse_iso(delta.format_iso()) == delta
         if nativable:
             assert isinstance(to_py_time_delta(delta), dt.timedelta)
 
@@ -262,7 +262,7 @@ class TestDates:
                 dates(min_value=min_value, max_value=max_value, two_digit=two_digit)
             )
         assert isinstance(date, Date)
-        assert Date.parse_common_iso(date.format_common_iso()) == date
+        assert Date.parse_iso(date.format_iso()) == date
         if min_value is not None:
             assert date >= min_value
         if max_value is not None:
@@ -722,7 +722,7 @@ class TestMonthDays:
         with assume_does_not_raise(InvalidArgument):
             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
+        assert MonthDay.parse_iso(month_day.format_iso()) == month_day
         if min_value is not None:
             assert month_day >= min_value
         if max_value is not None:
@@ -786,7 +786,7 @@ class TestPlainDateTimes:
                 plain_date_times(min_value=min_value, max_value=max_value)
             )
         assert isinstance(datetime, PlainDateTime)
-        assert PlainDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
+        assert PlainDateTime.parse_iso(datetime.format_iso()) == datetime
         if min_value is not None:
             assert datetime >= min_value
         if max_value is not None:
@@ -1037,7 +1037,7 @@ class TestTimeDeltas:
         with assume_does_not_raise(InvalidArgument):
             delta = data.draw(time_deltas(min_value=min_value, max_value=max_value))
         assert isinstance(delta, TimeDelta)
-        assert TimeDelta.parse_common_iso(delta.format_common_iso()) == delta
+        assert TimeDelta.parse_iso(delta.format_iso()) == delta
         assert isinstance(to_py_time_delta(delta), dt.timedelta)
         if min_value is not None:
             assert delta >= min_value
@@ -1067,7 +1067,7 @@ class TestTimes:
         with assume_does_not_raise(InvalidArgument):
             time = data.draw(times(min_value=min_value, max_value=max_value))
         assert isinstance(time, Time)
-        assert Time.parse_common_iso(time.format_common_iso()) == time
+        assert Time.parse_iso(time.format_iso()) == time
         if min_value is not None:
             assert time >= min_value
         if max_value is not None:
@@ -1204,7 +1204,7 @@ class TestYearMonths:
                 )
             )
         assert isinstance(year_month, YearMonth)
-        assert YearMonth.parse_common_iso(year_month.format_common_iso()) == year_month
+        assert YearMonth.parse_iso(year_month.format_iso()) == year_month
         if min_value is not None:
             assert year_month >= min_value
         if max_value is not None:
@@ -1258,7 +1258,7 @@ class TestZonedDateTimes:
             )
         assert isinstance(datetime, ZonedDateTime)
         _ = datetime.py_datetime()
-        assert ZonedDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
+        assert ZonedDateTime.parse_iso(datetime.format_iso()) == datetime
         assert datetime.tz == time_zone.key
         if min_value is not None:
             assert datetime >= min_value

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/tests/test_pydantic_settings.py

@@ -20,6 +20,13 @@ if TYPE_CHECKING:
 
 
 class TestCustomBaseSettings:
+    def test_hashable(self) -> None:
+        class Settings(CustomBaseSettings):
+            x: int = 1
+
+        settings = load_settings(Settings)
+        _ = hash(settings)
+
     def test_json(self, *, tmp_path: Path) -> None:
         file = tmp_path.joinpath("settings.json")
         _ = file.write_text(json.dumps({"x": 1}))

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/tests/test_whenever.py

@@ -345,14 +345,14 @@ class TestFormatCompact:
     def test_date(self, *, date: Date) -> None:
         result = format_compact(date)
         assert isinstance(result, str)
-        parsed = Date.parse_common_iso(result)
+        parsed = Date.parse_iso(result)
         assert parsed == date
 
     @given(time=times())
     def test_time(self, *, time: Time) -> None:
         result = format_compact(time)
         assert isinstance(result, str)
-        parsed = Time.parse_common_iso(result)
+        parsed = Time.parse_iso(result)
         assert parsed.nanosecond == 0
         expected = time.round()
         assert parsed == expected
@@ -361,7 +361,7 @@ class TestFormatCompact:
     def test_plain_date_time(self, *, date_time: PlainDateTime) -> None:
         result = format_compact(date_time)
         assert isinstance(result, str)
-        parsed = PlainDateTime.parse_common_iso(result)
+        parsed = PlainDateTime.parse_iso(result)
         assert parsed.nanosecond == 0
         expected = date_time.round()
         assert parsed == expected
@@ -736,10 +736,10 @@ class TestMinMax:
             _ = ZONED_DATE_TIME_MAX.add(microseconds=1)
 
     def _format_parse_date_delta(self, delta: DateDelta, /) -> None:
-        _ = DateDelta.parse_common_iso(delta.format_common_iso())
+        _ = DateDelta.parse_iso(delta.format_iso())
 
     def _format_parse_date_time_delta(self, delta: DateTimeDelta, /) -> None:
-        _ = DateTimeDelta.parse_common_iso(delta.format_common_iso())
+        _ = DateTimeDelta.parse_iso(delta.format_iso())
 
 
 class TestMinMaxDate:
@@ -1025,7 +1025,7 @@ class TestToDate:
 
     @given(date=dates())
     def test_str(self, *, date: Date) -> None:
-        assert to_date(date.format_common_iso()) == date
+        assert to_date(date.format_iso()) == date
 
     @given(date=dates())
     def test_py_date(self, *, date: Date) -> None:
@@ -1482,7 +1482,7 @@ class TestToTime:
 
     @given(time=times())
     def test_str(self, *, time: Time) -> None:
-        assert to_time(time.format_common_iso()) == time
+        assert to_time(time.format_iso()) == time
 
     @given(time=times())
     def test_py_time(self, *, time: Time) -> None:
@@ -1628,7 +1628,7 @@ class TestToZonedDateTime:
     def test_str(
         self, *, data: DataObject, date_time: ZonedDateTime, time_zone: ZoneInfo
     ) -> None:
-        text = date_time.format_common_iso()
+        text = date_time.format_iso()
         text_use = data.draw(sampled_from([text, text.replace("/", "_")]))
         result = to_zoned_date_time(text_use, time_zone=time_zone)
         expected = date_time.to_tz(time_zone.key)
@@ -1699,7 +1699,7 @@ class TestToZonedDateTime:
 
 
 class TestTwoDigitYearMonth:
-    def test_parse_common_iso(self) -> None:
+    def test_parse_iso(self) -> None:
         result = two_digit_year_month(0, 1)
         expected = YearMonth(2000, 1)
         assert result == expected

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.167.3"
+__version__ = "0.168.1"

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/aeventkit.py

@@ -169,7 +169,8 @@ class LiftedEvent[F: Callable[..., MaybeCoro[None]]]:
     def __await__(self) -> Any:
         return self.event.__await__()  # pragma: no cover
 
-    __aiter__ = aiter
+    def __aiter__(self) -> Any:
+        return self.event.aiter()  # pragma: no cover
 
     def __contains__(self, c: Any, /) -> bool:
         return self.event.__contains__(c)  # pragma: no cover

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/click.py

@@ -72,7 +72,7 @@ class Date(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.Date.parse_common_iso(value)
+                    return whenever.Date.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -98,7 +98,7 @@ class DateDelta(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.DateDelta.parse_common_iso(value)
+                    return whenever.DateDelta.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -124,7 +124,7 @@ class DateTimeDelta(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.DateTimeDelta.parse_common_iso(value)
+                    return whenever.DateTimeDelta.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -235,7 +235,7 @@ class MonthDay(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.MonthDay.parse_common_iso(value)
+                    return whenever.MonthDay.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -284,7 +284,7 @@ class PlainDateTime(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.PlainDateTime.parse_common_iso(value)
+                    return whenever.PlainDateTime.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -310,7 +310,7 @@ class Time(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.Time.parse_common_iso(value)
+                    return whenever.Time.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -336,7 +336,7 @@ class TimeDelta(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.TimeDelta.parse_common_iso(value)
+                    return whenever.TimeDelta.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -388,7 +388,7 @@ class YearMonth(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.YearMonth.parse_common_iso(value)
+                    return whenever.YearMonth.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:
@@ -414,7 +414,7 @@ class ZonedDateTime(ParamType):
                 return value
             case str():
                 try:
-                    return whenever.ZonedDateTime.parse_common_iso(value)
+                    return whenever.ZonedDateTime.parse_iso(value)
                 except ValueError as error:
                     self.fail(str(error), param, ctx)
             case never:

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/hypothesis.py

@@ -1570,7 +1570,7 @@ def zoned_date_times(
     with (
         assume_does_not_raise(RepeatedTime),
         assume_does_not_raise(SkippedTime),
-        assume_does_not_raise(ValueError, match=r"Resulting datetime is out of range"),
+        assume_does_not_raise(ValueError, match=r"Resulting time is out of range"),
     ):
         zoned = plain.assume_tz(time_zone_.key, disambiguate="raise")
     with assume_does_not_raise(OverflowError, match=r"date value out of range"):

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/orjson.py

@@ -481,49 +481,49 @@ def _object_hook(
             if match := _NONE_PATTERN.search(text):
                 return None
             if match := _DATE_PATTERN.search(text):
-                return Date.parse_common_iso(match.group(1))
+                return Date.parse_iso(match.group(1))
             if match := _DATE_DELTA_PATTERN.search(text):
-                return DateDelta.parse_common_iso(match.group(1))
+                return DateDelta.parse_iso(match.group(1))
             if match := _DATE_PERIOD_PATTERN.search(text):
-                start, end = map(Date.parse_common_iso, match.group(1).split(","))
+                start, end = map(Date.parse_iso, match.group(1).split(","))
                 return DatePeriod(start, end)
             if match := _DATE_TIME_DELTA_PATTERN.search(text):
-                return DateTimeDelta.parse_common_iso(match.group(1))
+                return DateTimeDelta.parse_iso(match.group(1))
             if match := _FLOAT_PATTERN.search(text):
                 return float(match.group(1))
             if match := _MONTH_DAY_PATTERN.search(text):
-                return MonthDay.parse_common_iso(match.group(1))
+                return MonthDay.parse_iso(match.group(1))
             if match := _PATH_PATTERN.search(text):
                 return Path(match.group(1))
             if match := _PLAIN_DATE_TIME_PATTERN.search(text):
-                return PlainDateTime.parse_common_iso(match.group(1))
+                return PlainDateTime.parse_iso(match.group(1))
             if match := _PY_DATE_PATTERN.search(text):
-                return Date.parse_common_iso(match.group(1)).py_date()
+                return Date.parse_iso(match.group(1)).py_date()
             if match := _PY_PLAIN_DATE_TIME_PATTERN.search(text):
-                return PlainDateTime.parse_common_iso(match.group(1)).py_datetime()
+                return PlainDateTime.parse_iso(match.group(1)).py_datetime()
             if match := _PY_TIME_PATTERN.search(text):
-                return Time.parse_common_iso(match.group(1)).py_time()
+                return Time.parse_iso(match.group(1)).py_time()
             if match := _PY_ZONED_DATE_TIME_PATTERN.search(text):
-                return ZonedDateTime.parse_common_iso(match.group(1)).py_datetime()
+                return ZonedDateTime.parse_iso(match.group(1)).py_datetime()
             if match := _TIME_PATTERN.search(text):
-                return Time.parse_common_iso(match.group(1))
+                return Time.parse_iso(match.group(1))
             if match := _TIME_DELTA_PATTERN.search(text):
-                return TimeDelta.parse_common_iso(match.group(1))
+                return TimeDelta.parse_iso(match.group(1))
             if match := _TIME_PERIOD_PATTERN.search(text):
-                start, end = map(Time.parse_common_iso, match.group(1).split(","))
+                start, end = map(Time.parse_iso, match.group(1).split(","))
                 return TimePeriod(start, end)
             if match := _UUID_PATTERN.search(text):
                 return UUID(match.group(1))
             if match := _VERSION_PATTERN.search(text):
                 return parse_version(match.group(1))
             if match := _YEAR_MONTH_PATTERN.search(text):
-                return YearMonth.parse_common_iso(match.group(1))
+                return YearMonth.parse_iso(match.group(1))
             if match := _ZONED_DATE_TIME_PATTERN.search(text):
-                return ZonedDateTime.parse_common_iso(match.group(1))
+                return ZonedDateTime.parse_iso(match.group(1))
             if match := _ZONED_DATE_TIME_PERIOD_PATTERN.search(text):
                 start, end = match.group(1).split(",")
-                end = ZonedDateTime.parse_common_iso(end)
-                start = PlainDateTime.parse_common_iso(start).assume_tz(end.tz)
+                end = ZonedDateTime.parse_iso(end)
+                start = PlainDateTime.parse_iso(start).assume_tz(end.tz)
                 return ZonedDateTimePeriod(start, end)
             if (
                 exc_class := _object_hook_exception_class(

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/parse.py

@@ -204,7 +204,7 @@ def _parse_object_type(
         ),
     ):
         try:
-            return cls.parse_common_iso(text)
+            return cls.parse_iso(text)
         except ValueError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
     if issubclass(cls, Path):
@@ -477,7 +477,7 @@ def serialize_object(
             ZonedDateTime,
         ),
     ):
-        return obj.format_common_iso()
+        return obj.format_iso()
     if isinstance(obj, Enum):
         return obj.name
     if isinstance(obj, dict):

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/pydantic_settings.py

@@ -38,7 +38,7 @@ class CustomBaseSettings(BaseSettings):
 
     # config
     model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(
-        env_nested_delimiter="__"
+        frozen=True, env_nested_delimiter="__"
     )
 
     @classmethod

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/pytest.py

@@ -299,7 +299,7 @@ def _skipif_recent(*, root: PathLike | None = None, delta: Delta = SECOND) -> No
     except FileNotFoundError:
         return
     try:
-        last = ZonedDateTime.parse_common_iso(contents)
+        last = ZonedDateTime.parse_iso(contents)
     except ValueError:
         return
     now = get_now_local()
@@ -328,7 +328,7 @@ def _get_name() -> str:
 def _write(root: PathLike | None = None, /) -> None:
     path = _get_path(root)
     with writer(path, overwrite=True) as temp:
-        _ = temp.write_text(get_now_local().format_common_iso())
+        _ = temp.write_text(get_now_local().format_iso())
 
 
 __all__ = [

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/timer.py

@@ -56,11 +56,11 @@ class Timer:
 
     @override
     def __repr__(self) -> str:
-        return self.timedelta.format_common_iso()
+        return self.timedelta.format_iso()
 
     @override
     def __str__(self) -> str:
-        return self.timedelta.format_common_iso()
+        return self.timedelta.format_iso()
 
     # comparison
 

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/traceback.py

@@ -98,7 +98,7 @@ def _yield_header_lines(
     yield f"Date/time  | {format_compact(now)}"
     start_use = to_zoned_date_time(start).to_tz(LOCAL_TIME_ZONE_NAME)
     yield f"Started    | {format_compact(start_use)}"
-    yield f"Duration   | {(now - start_use).format_common_iso()}"
+    yield f"Duration   | {(now - start_use).format_iso()}"
     yield f"User       | {getuser()}"
     yield f"Host       | {gethostname()}"
     yield f"Process ID | {getpid()}"

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/typed_settings.py

@@ -57,19 +57,19 @@ class ExtendedTSConverter(TSConverter):
     ) -> None:
         super().__init__(resolve_paths=resolve_paths, strlist_sep=strlist_sep)
         cases: list[_ConverterItem] = [
-            (Date, Date.parse_common_iso),
-            (DateDelta, DateDelta.parse_common_iso),
-            (DateTimeDelta, DateTimeDelta.parse_common_iso),
+            (Date, Date.parse_iso),
+            (DateDelta, DateDelta.parse_iso),
+            (DateTimeDelta, DateTimeDelta.parse_iso),
             (IPv4Address, IPv4Address),
             (IPv6Address, IPv6Address),
-            (MonthDay, MonthDay.parse_common_iso),
+            (MonthDay, MonthDay.parse_iso),
             (Path, partial(_parse_path, resolve=resolve_paths, pwd=Path.cwd())),
-            (PlainDateTime, PlainDateTime.parse_common_iso),
-            (Time, Time.parse_common_iso),
-            (TimeDelta, TimeDelta.parse_common_iso),
+            (PlainDateTime, PlainDateTime.parse_iso),
+            (Time, Time.parse_iso),
+            (TimeDelta, TimeDelta.parse_iso),
             (UUID, UUID),
-            (YearMonth, YearMonth.parse_common_iso),
-            (ZonedDateTime, ZonedDateTime.parse_common_iso),
+            (YearMonth, YearMonth.parse_iso),
+            (ZonedDateTime, ZonedDateTime.parse_iso),
             *extra,
         ]
         extras = {cls: _make_converter(cls, func) for cls, func in cases}

{dycw_utilities-0.167.3 → dycw_utilities-0.168.1}/src/utilities/whenever.py

@@ -922,7 +922,7 @@ def to_date(
         case None:
             return get_today(time_zone)
         case str():
-            return Date.parse_common_iso(date)
+            return Date.parse_iso(date)
         case dt.date():
             return Date.from_py_date(date)
         case Callable() as func:
@@ -1505,7 +1505,7 @@ def to_time(
         case None:
             return get_time(time_zone)
         case str():
-            return Time.parse_common_iso(time)
+            return Time.parse_iso(time)
         case dt.time():
             return Time.from_py_time(time)
         case Callable() as func:
@@ -1733,7 +1733,7 @@ def to_zoned_date_time(
         case None:
             return get_now(UTC if time_zone is None else time_zone)
         case str() as text:
-            date_time_use = ZonedDateTime.parse_common_iso(text.replace("~", "/"))
+            date_time_use = ZonedDateTime.parse_iso(text.replace("~", "/"))
         case dt.datetime() as py_date_time:
             if isinstance(date_time.tzinfo, ZoneInfo):
                 py_date_time_use = py_date_time
@@ -1797,7 +1797,7 @@ class WheneverLogRecord(LogRecord):
             name, level, pathname, lineno, msg, args, exc_info, func, sinfo
         )
         length = self._get_length()
-        plain = format(get_now_local().to_plain().format_common_iso(), f"{length}s")
+        plain = format(get_now_local().to_plain().format_iso(), f"{length}s")
         self.zoned_datetime = f"{plain}[{LOCAL_TIME_ZONE_NAME}]"
 
     @classmethod
@@ -1805,7 +1805,7 @@ class WheneverLogRecord(LogRecord):
     def _get_length(cls) -> int:
         """Get maximum length of a formatted string."""
         now = get_now_local().replace(nanosecond=1000).to_plain()
-        return len(now.format_common_iso())
+        return len(now.format_iso())
 
 
 ##