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

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.136.9
+Version: 0.136.10
 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.15,>=4.14.0
 Requires-Dist: tzlocal<5.4,>=5.3.1
-Requires-Dist: whenever<0.9,>=0.8.5
+Requires-Dist: whenever<0.9,>=0.8.6
 Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test

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

@@ -21,7 +21,7 @@ core = [
   "atomicwrites >= 1.4.1, < 1.5",
   "typing-extensions >= 4.14.0, < 4.15",
   "tzlocal >= 5.3.1, < 5.4",
-  "whenever >= 0.8.5, < 0.9",
+  "whenever >= 0.8.6, < 0.9",
 ]
 cryptography = ["cryptography >= 45.0.4, < 45.1"]
 cvxpy = ["cvxpy >= 1.6.5, < 1.7"]
@@ -76,7 +76,7 @@ pytest = [
 pytest-regressions = ["pytest-regressions >= 2.8.0, < 2.9"]
 pytest-regressions-test = ["orjson", "polars-lts-cpu"]
 pytest-test = ["orjson", "pytest-rng", "pytest-rerunfailures"]
-python-dotenv = ["python-dotenv >= 1.1.0, < 1.2"]
+python-dotenv = ["python-dotenv >= 1.1.1, < 1.2"]
 redis = ["redis >= 6.2.0, < 6.3", "orjson"]
 redis-test = ["pytest-rerunfailures"]
 reprlib-test = ["rich"]
@@ -100,12 +100,12 @@ dependencies = [
   "atomicwrites >= 1.4.1, < 1.5",
   "typing-extensions >= 4.14.0, < 4.15",
   "tzlocal >= 5.3.1, < 5.4",
-  "whenever >= 0.8.5, < 0.9",
+  "whenever >= 0.8.6, < 0.9",
 ]
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.136.9"
+version = "0.136.10"
 
 [project.optional-dependencies]
 logging = [
@@ -133,7 +133,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.136.9"
+current_version = "0.136.10"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

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

@@ -192,7 +192,7 @@ class TestComputeRolloverActions:
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
-        now = format_compact(get_now())
+        now = format_compact(get_now().to_plain())
         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)}.txt")
+        path = Path(f"log.{index}__{format_compact(end.to_plain())}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -333,7 +333,9 @@ class TestRotatingLogFile:
         self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
         start, end = datetimes
-        path = Path(f"log.{index}__{format_compact(start)}__{format_compact(end)}.txt")
+        path = Path(
+            f"log.{index}__{format_compact(start.to_plain())}__{format_compact(end.to_plain())}.txt"
+        )
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -363,7 +365,9 @@ class TestRotatingLogFile:
         file = _RotatingLogFile(
             directory=root, stem="log", suffix=".txt", index=index, end=end
         )
-        assert file.path == root.joinpath(f"log.{index}__{format_compact(end)}.txt")
+        assert file.path == root.joinpath(
+            f"log.{index}__{format_compact(end.to_plain())}.txt"
+        )
 
     @given(
         root=temp_paths(),
@@ -378,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)}__{format_compact(end)}.txt"
+            f"log.{index}__{format_compact(start.to_plain())}__{format_compact(end.to_plain())}.txt"
         )
 
 

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/tests/test_period.py

@@ -4,8 +4,9 @@ from re import search
 from typing import TYPE_CHECKING
 
 from hypothesis import HealthCheck, given, settings
-from hypothesis.strategies import DataObject, data, sampled_from
-from pytest import raises
+from hypothesis.strategies import DataObject, data
+from pytest import mark, param, raises
+from whenever import Date, ZonedDateTime
 
 from utilities.hypothesis import (
     assume_does_not_raise,
@@ -30,7 +31,7 @@ from utilities.zoneinfo import UTC, get_time_zone_name
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from whenever import Date, DateDelta, PlainDateTime, TimeDelta, ZonedDateTime
+    from whenever import DateDelta, PlainDateTime, TimeDelta
 
 
 class TestDatePeriod:
@@ -58,13 +59,30 @@ class TestDatePeriod:
         period = DatePeriod(start, end)
         assert period.delta == (end - start)
 
+    @mark.parametrize(
+        ("end", "expected"),
+        [
+            param(Date(2000, 1, 1), "20000101="),
+            param(Date(2000, 1, 2), "20000101-02"),
+            param(Date(2000, 1, 31), "20000101-31"),
+            param(Date(2000, 2, 1), "20000101-0201"),
+            param(Date(2000, 2, 29), "20000101-0229"),
+            param(Date(2000, 12, 31), "20000101-1231"),
+            param(Date(2001, 1, 1), "20000101-20010101"),
+        ],
+    )
+    def test_format_compact(self, *, end: Date, expected: str) -> None:
+        period = DatePeriod(Date(2000, 1, 1), end)
+        assert period.format_compact() == expected
+
     @given(dates=pairs(dates(), sorted=True))
     def test_hashable(self, *, dates: tuple[Date, Date]) -> None:
         start, end = dates
         period = DatePeriod(start, end)
         _ = hash(period)
 
-    @given(dates=pairs(dates(), sorted=True), func=sampled_from([repr, str]))
+    @given(dates=pairs(dates(), sorted=True))
+    @mark.parametrize("func", [param(repr), param(str)])
     def test_repr(self, *, dates: tuple[Date, Date], func: Callable[..., str]) -> None:
         start, end = dates
         period = DatePeriod(start, end)
@@ -145,17 +163,126 @@ class TestZonedDateTimePeriod:
         period = ZonedDateTimePeriod(start, end)
         assert period.delta == (end - start)
 
+    @mark.parametrize(
+        ("end", "expected"),
+        [
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 20, 30, tz=UTC.key),
+                "20000101T102030[UTC]=",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 20, 31, tz=UTC.key),
+                "20000101T102030-102031[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 20, 59, tz=UTC.key),
+                "20000101T102030-102059[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 21, tz=UTC.key),
+                "20000101T102030-1021[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 21, 1, tz=UTC.key),
+                "20000101T102030-102101[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 59, 59, tz=UTC.key),
+                "20000101T102030-105959[UTC]",
+            ),
+            param(ZonedDateTime(2000, 1, 1, 11, tz=UTC.key), "20000101T102030-11[UTC]"),
+            param(
+                ZonedDateTime(2000, 1, 1, 11, 0, 1, tz=UTC.key),
+                "20000101T102030-110001[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 1, 23, 59, 59, tz=UTC.key),
+                "20000101T102030-235959[UTC]",
+            ),
+            param(ZonedDateTime(2000, 1, 2, tz=UTC.key), "20000101T102030-02T00[UTC]"),
+            param(
+                ZonedDateTime(2000, 1, 2, 0, 0, 1, tz=UTC.key),
+                "20000101T102030-02T000001[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 2, 0, 0, 59, tz=UTC.key),
+                "20000101T102030-02T000059[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 2, 0, 1, tz=UTC.key),
+                "20000101T102030-02T0001[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 1, 31, 23, 59, 59, tz=UTC.key),
+                "20000101T102030-31T235959[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 2, 1, tz=UTC.key), "20000101T102030-0201T00[UTC]"
+            ),
+            param(
+                ZonedDateTime(2000, 2, 1, 0, 0, 1, tz=UTC.key),
+                "20000101T102030-0201T000001[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 2, 1, 0, 0, 59, tz=UTC.key),
+                "20000101T102030-0201T000059[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 2, 1, 0, 1, tz=UTC.key),
+                "20000101T102030-0201T0001[UTC]",
+            ),
+            param(
+                ZonedDateTime(2000, 12, 31, 23, 59, 59, tz=UTC.key),
+                "20000101T102030-1231T235959[UTC]",
+            ),
+            param(
+                ZonedDateTime(2001, 1, 1, tz=UTC.key),
+                "20000101T102030-20010101T00[UTC]",
+            ),
+            param(
+                ZonedDateTime(2001, 1, 1, 0, 0, 1, tz=UTC.key),
+                "20000101T102030-20010101T000001[UTC]",
+            ),
+            param(
+                ZonedDateTime(2001, 1, 1, 0, 0, 59, tz=UTC.key),
+                "20000101T102030-20010101T000059[UTC]",
+            ),
+            param(
+                ZonedDateTime(2001, 1, 1, 0, 1, tz=UTC.key),
+                "20000101T102030-20010101T0001[UTC]",
+            ),
+        ],
+    )
+    def test_format_compact(self, *, end: ZonedDateTime, expected: str) -> None:
+        start = ZonedDateTime(2000, 1, 1, 10, 20, 30, tz=UTC.key)
+        period = ZonedDateTimePeriod(start, end)
+        assert period.format_compact() == expected
+
+    @mark.parametrize(
+        ("datetime", "expected"),
+        [
+            param(
+                ZonedDateTime(2000, 1, 1, 10, 20, 30, tz=UTC.key),
+                "20000101T102030[UTC]=",
+            ),
+            param(ZonedDateTime(2000, 1, 1, 10, 20, tz=UTC.key), "20000101T1020[UTC]="),
+            param(ZonedDateTime(2000, 1, 1, 10, tz=UTC.key), "20000101T10[UTC]="),
+        ],
+    )
+    def test_format_compact_extra(
+        self, *, datetime: ZonedDateTime, expected: str
+    ) -> None:
+        period = ZonedDateTimePeriod(datetime, datetime)
+        assert period.format_compact() == expected
+
     @given(datetimes=pairs(zoned_datetimes(), sorted=True))
     def test_hashable(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
         start, end = datetimes
         period = ZonedDateTimePeriod(start, end)
         _ = hash(period)
 
-    @given(
-        data=data(),
-        datetimes=pairs(zoned_datetimes(), sorted=True),
-        func=sampled_from([repr, str]),
-    )
+    @given(data=data(), datetimes=pairs(zoned_datetimes(), sorted=True))
+    @mark.parametrize("func", [param(repr), param(str)])
     def test_repr(
         self,
         *,

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/tests/test_whenever.py

@@ -20,6 +20,7 @@ from whenever import (
     DateDelta,
     DateTimeDelta,
     PlainDateTime,
+    Time,
     TimeDelta,
     TimeZoneNotFoundError,
     ZonedDateTime,
@@ -33,7 +34,9 @@ from utilities.hypothesis import (
     freqs,
     months,
     pairs,
+    plain_datetimes,
     sentinels,
+    times,
     zoned_datetimes,
 )
 from utilities.sentinel import Sentinel, sentinel
@@ -125,13 +128,36 @@ class TestDatetimeUTC:
 
 
 class TestFormatCompact:
-    @given(datetime=zoned_datetimes())
-    def test_main(self, *, datetime: ZonedDateTime) -> None:
+    @given(date=dates())
+    def test_date(self, *, date: Date) -> None:
+        result = format_compact(date)
+        assert isinstance(result, str)
+        parsed = Date.parse_common_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)
+        assert parsed == time
+
+    @given(datetime=plain_datetimes())
+    def test_plain_datetime(self, *, datetime: PlainDateTime) -> None:
         result = format_compact(datetime)
         assert isinstance(result, str)
         parsed = PlainDateTime.parse_common_iso(result)
         assert parsed.nanosecond == 0
-        expected = datetime.round().to_tz(LOCAL_TIME_ZONE_NAME).to_plain()
+        expected = datetime.round()
+        assert parsed == expected
+
+    @given(datetime=zoned_datetimes())
+    def test_zoned_datetime(self, *, datetime: ZonedDateTime) -> None:
+        result = format_compact(datetime)
+        assert isinstance(result, str)
+        parsed = ZonedDateTime.parse_common_iso(result)
+        assert parsed.nanosecond == 0
+        expected = datetime.round()
         assert parsed == expected
 
 

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.136.9"
+__version__ = "0.136.10"

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/fpdf2.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, override
 from fpdf import FPDF
 from fpdf.enums import XPos, YPos
 
-from utilities.whenever import format_compact, get_now
+from utilities.whenever import format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -47,7 +47,7 @@ def yield_pdf(*, header: str | None = None) -> Iterator[_BasePDF]:
         def footer(self) -> None:
             self.set_y(-15)
             self.set_font(family="Helvetica", style="I", size=8)
-            page_no, now = self.page_no(), format_compact(get_now())
+            page_no, now = (self.page_no(), format_compact(get_now_local().to_plain()))
             text = f"page {page_no}/{{}}; {now}"
             _ = self.cell(
                 w=0,

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/logging.py

@@ -45,7 +45,7 @@ from utilities.re import (
 )
 from utilities.sentinel import Sentinel, sentinel
 from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import WheneverLogRecord, format_compact, get_now, get_now_local
+from utilities.whenever import WheneverLogRecord, format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Mapping
@@ -378,7 +378,7 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
         if not self.delay:  # pragma: no cover
             self.stream = self._open()
         self._time_handler.rolloverAt = (  # skipif-ci-and-windows
-            self._time_handler.computeRollover(get_now().timestamp())
+            self._time_handler.computeRollover(get_now_local().timestamp())
         )
 
     def _should_rollover(self, record: LogRecord, /) -> bool:
@@ -533,9 +533,9 @@ class _RotatingLogFile:
             case int() as index, None, None:
                 tail = str(index)
             case int() as index, None, ZonedDateTime() as end:
-                tail = f"{index}__{format_compact(end)}"
+                tail = f"{index}__{format_compact(end.to_plain())}"
             case int() as index, ZonedDateTime() as start, ZonedDateTime() as end:
-                tail = f"{index}__{format_compact(start)}__{format_compact(end)}"
+                tail = f"{index}__{format_compact(start.to_plain())}__{format_compact(end.to_plain())}"
             case _:  # pragma: no cover
                 raise ImpossibleCaseError(
                     case=[f"{self.index=}", f"{self.start=}", f"{self.end=}"]

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/period.py

@@ -9,6 +9,7 @@ from whenever import Date, DateDelta, TimeDelta, ZonedDateTime
 from utilities.dataclasses import replace_non_sentinel
 from utilities.functions import get_class_name
 from utilities.sentinel import Sentinel, sentinel
+from utilities.whenever import format_compact
 from utilities.zoneinfo import get_time_zone_name
 
 if TYPE_CHECKING:
@@ -53,6 +54,17 @@ class DatePeriod:
         """The delta of the period."""
         return self.end - self.start
 
+    def format_compact(self) -> str:
+        """Format the period in a compact fashion."""
+        fc, start, end = format_compact, self.start, self.end
+        if self.start == self.end:
+            return f"{fc(start)}="
+        if self.start.year_month() == self.end.year_month():
+            return f"{fc(start)}-{fc(end, fmt='%d')}"
+        if self.start.year == self.end.year:
+            return f"{fc(start)}-{fc(end, fmt='%m%d')}"
+        return f"{fc(start)}-{fc(end)}"
+
     def replace(
         self, *, start: Date | Sentinel = sentinel, end: Date | Sentinel = sentinel
     ) -> Self:
@@ -101,6 +113,39 @@ class ZonedDateTimePeriod:
         """The duration of the period."""
         return self.end - self.start
 
+    def format_compact(self) -> str:
+        """Format the period in a compact fashion."""
+        fc, start, end = format_compact, self.start, self.end
+        if start == end:
+            if end.second != 0:
+                return f"{fc(start)}="
+            if end.minute != 0:
+                return f"{fc(start, fmt='%Y%m%dT%H%M')}="
+            return f"{fc(start, fmt='%Y%m%dT%H')}="
+        if start.date() == end.date():
+            if end.second != 0:
+                return f"{fc(start.to_plain())}-{fc(end, fmt='%H%M%S')}"
+            if end.minute != 0:
+                return f"{fc(start.to_plain())}-{fc(end, fmt='%H%M')}"
+            return f"{fc(start.to_plain())}-{fc(end, fmt='%H')}"
+        if start.date().year_month() == end.date().year_month():
+            if end.second != 0:
+                return f"{fc(start.to_plain())}-{fc(end, fmt='%dT%H%M%S')}"
+            if end.minute != 0:
+                return f"{fc(start.to_plain())}-{fc(end, fmt='%dT%H%M')}"
+            return f"{fc(start.to_plain())}-{fc(end, fmt='%dT%H')}"
+        if start.year == end.year:
+            if end.second != 0:
+                return f"{fc(start.to_plain())}-{fc(end, fmt='%m%dT%H%M%S')}"
+            if end.minute != 0:
+                return f"{fc(start.to_plain())}-{fc(end, fmt='%m%dT%H%M')}"
+            return f"{fc(start.to_plain())}-{fc(end, fmt='%m%dT%H')}"
+        if end.second != 0:
+            return f"{fc(start.to_plain())}-{fc(end)}"
+        if end.minute != 0:
+            return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H%M')}"
+        return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H')}"
+
     def replace(
         self,
         *,

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/pyinstrument.py

@@ -8,7 +8,7 @@ from pyinstrument.profiler import Profiler
 
 from utilities.atomicwrites import writer
 from utilities.pathlib import get_path
-from utilities.whenever import format_compact, get_now
+from utilities.whenever import format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -22,7 +22,7 @@ def profile(*, path: MaybeCallablePathLike | None = Path.cwd) -> Iterator[None]:
     with Profiler() as profiler:
         yield
     filename = get_path(path=path).joinpath(
-        f"profile__{format_compact(get_now())}.html"
+        f"profile__{format_compact(get_now_local().to_plain())}.html"
     )
     with writer(filename) as temp, temp.open(mode="w") as fh:
         _ = fh.write(profiler.output_html())

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/traceback.py

@@ -27,7 +27,12 @@ from utilities.reprlib import (
     yield_mapping_repr,
 )
 from utilities.version import get_version
-from utilities.whenever import format_compact, get_now, to_zoned_date_time
+from utilities.whenever import (
+    format_compact,
+    get_now,
+    get_now_local,
+    to_zoned_date_time,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Sequence
@@ -89,10 +94,10 @@ def _yield_header_lines(
     version: MaybeCallableVersionLike | None = None,
 ) -> Iterator[str]:
     """Yield the header lines."""
-    now = get_now()
+    now = get_now_local()
     start_use = to_zoned_date_time(date_time=start)
-    yield f"Date/time | {format_compact(now)}"
-    start_str = "" if start_use is None else format_compact(start_use)
+    yield f"Date/time | {format_compact(now.to_plain())}"
+    start_str = "" if start_use is None else format_compact(start_use.to_plain())
     yield f"Started   | {start_str}"
     delta = None if start_use is None else (now - start_use)
     delta_str = "" if delta is None else delta.format_common_iso()
@@ -250,7 +255,9 @@ def _make_except_hook_inner(
     _ = sys.stderr.write(f"{slim}\n")  # don't 'from sys import stderr'
     if path is not None:
         path = (
-            get_path(path=path).joinpath(format_compact(get_now())).with_suffix(".txt")
+            get_path(path=path)
+            .joinpath(format_compact(get_now_local().to_plain()))
+            .with_suffix(".txt")
         )
         full = format_exception_stack(
             exc_val,

{dycw_utilities-0.136.9 → dycw_utilities-0.136.10}/src/utilities/whenever.py

@@ -23,6 +23,7 @@ from whenever import (
     DateDelta,
     DateTimeDelta,
     PlainDateTime,
+    Time,
     TimeDelta,
     ZonedDateTime,
 )
@@ -32,7 +33,7 @@ from utilities.platform import get_strftime
 from utilities.re import ExtractGroupsError, extract_groups
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import DateTimeRoundUnit, MaybeStr
-from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
+from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
@@ -160,10 +161,25 @@ def datetime_utc(
 ##
 
 
-def format_compact(datetime: ZonedDateTime, /) -> str:
-    """Convert a zoned datetime to the local time zone, then format."""
-    py_datetime = datetime.round().to_tz(LOCAL_TIME_ZONE_NAME).to_plain().py_datetime()
-    return py_datetime.strftime(get_strftime("%Y%m%dT%H%M%S"))
+def format_compact(
+    obj: Date | Time | PlainDateTime | ZonedDateTime, /, *, fmt: str | None = None
+) -> str:
+    """Format the date/datetime in a compact fashion."""
+    match obj:
+        case Date() as date:
+            obj_use = date.py_date()
+            fmt_use = "%Y%m%d" if fmt is None else fmt
+        case Time() as time:
+            obj_use = time.py_time()
+            fmt_use = "%H%M%S" if fmt is None else fmt
+        case PlainDateTime() as datetime:
+            obj_use = datetime.round().py_datetime()
+            fmt_use = "%Y%m%dT%H%M%S" if fmt is None else fmt
+        case ZonedDateTime() as datetime:
+            return f"{format_compact(datetime.to_plain(), fmt=fmt)}[{datetime.tz}]"
+        case _ as never:
+            assert_never(never)
+    return obj_use.strftime(get_strftime(fmt_use))
 
 
 ##