dycw-utilities 0.153.14__tar.gz → 0.154.0__tar.gz

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/PKG-INFO

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

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/pyproject.toml

@@ -229,7 +229,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.153.14"
+version = "0.154.0"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -262,7 +262,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.153.14"
+current_version = "0.154.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/conftest.py

@@ -7,13 +7,11 @@ from typing import TYPE_CHECKING
 
 from hypothesis import HealthCheck
 from pytest import fixture, mark, param, skip
-from whenever import PlainDateTime
 
 from utilities.contextlib import enhanced_context_manager
 from utilities.platform import IS_MAC, IS_NOT_LINUX, IS_WINDOWS
 from utilities.re import ExtractGroupError, extract_group
-from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import MINUTE, get_now
+from utilities.whenever import MINUTE, get_now, parse_plain_local
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator, Sequence
@@ -174,11 +172,7 @@ def _is_to_drop(table: str, /) -> bool:
         datetime_str = extract_group(r"^(\d{8}T\d{6})_", table)
     except ExtractGroupError:
         return True
-    datetime = PlainDateTime.parse_common_iso(datetime_str).assume_tz(
-        LOCAL_TIME_ZONE_NAME
-    )
-    now = get_now()
-    return (now - datetime) >= MINUTE
+    return (get_now() - parse_plain_local(datetime_str)) >= MINUTE
 
 
 def _select_tables() -> TextClause:

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/test_iterables.py

@@ -94,7 +94,6 @@ from utilities.iterables import (
     enumerate_with_edge,
     expanding_window,
     filter_include_and_exclude,
-    group_consecutive_integers,
     groupby_lists,
     hashable_to_iterable,
     is_iterable,
@@ -117,7 +116,6 @@ from utilities.iterables import (
     sum_mappings,
     take,
     transpose,
-    ungroup_consecutive_integers,
     unique_everseen,
 )
 from utilities.sentinel import Sentinel, sentinel
@@ -745,18 +743,6 @@ class TestFilterIncludeAndExclude:
         assert result == expected
 
 
-class TestGroupAndUngroupConsecutiveIntegers:
-    @given(xs=lists(integers(), unique=True).map(sorted))
-    def test_main(self, *, xs: list[int]) -> None:
-        result = list(ungroup_consecutive_integers(group_consecutive_integers(xs)))
-        assert result == xs
-
-    def test_example(self) -> None:
-        result = list(group_consecutive_integers([1, 2, 3, 6, 7, 10, 11, 12]))
-        expected = [(1, 3), (6, 7), (10, 12)]
-        assert result == expected
-
-
 class TestGroupbyLists:
     iterable: ClassVar[str] = "AAAABBBCCDAABB"
 

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/test_logging.py

@@ -8,20 +8,13 @@ from re import search
 from typing import TYPE_CHECKING, Any, cast
 
 from hypothesis import given
-from hypothesis.strategies import booleans, integers, none, sampled_from
+from hypothesis.strategies import booleans, integers
 from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
-from utilities.hypothesis import (
-    assume_does_not_raise,
-    pairs,
-    temp_paths,
-    text_ascii,
-    zoned_datetimes,
-)
+from utilities.hypothesis import pairs, temp_paths, text_ascii, zoned_datetimes
 from utilities.iterables import one
 from utilities.logging import (
-    FilterForKeyError,
     GetLoggingLevelNumberError,
     SizeAndTimeRotatingFileHandler,
     _compute_rollover_actions,
@@ -29,7 +22,6 @@ from utilities.logging import (
     _RotatingLogFile,
     add_filters,
     basic_config,
-    filter_for_key,
     get_format_str,
     get_formatter,
     get_logging_level_number,
@@ -39,7 +31,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, to_local_plain
+from utilities.whenever import get_now, to_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -196,7 +188,7 @@ class TestComputeRolloverActions:
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
-        now = format_compact(to_local_plain(get_now()))
+        now = 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
@@ -209,33 +201,6 @@ class TestComputeRolloverActions:
         )
 
 
-class TestFilterForKey:
-    @given(key=text_ascii(), value=booleans() | none(), default=booleans())
-    def test_main(self, *, key: str, value: bool | None, default: bool) -> None:
-        logger = getLogger(unique_str())
-        logger.addHandler(handler := StreamHandler(buffer := StringIO()))
-        with assume_does_not_raise(FilterForKeyError):
-            filter_ = filter_for_key(key, default=default)
-        add_filters(handler, filter_)
-        match value:
-            case bool():
-                logger.warning("message", extra={key: value})
-                expected = value
-            case None:
-                logger.warning("message")
-                expected = default
-        result = buffer.getvalue() != ""
-        assert result is expected
-
-    def test_sunder(self) -> None:
-        _ = filter_for_key("_key")
-
-    @given(key=sampled_from(["msg", "__dunder__"]))
-    def test_error(self, *, key: str) -> None:
-        with raises(FilterForKeyError, match="Invalid key: '.*'"):
-            _ = filter_for_key(key)
-
-
 class TestGetFormatStr:
     @mark.parametrize("prefix", [param(">"), param(None)])
     @mark.parametrize("hostname", [param(True), param(False)])
@@ -313,7 +278,7 @@ class TestRotatingLogFile:
     def test_from_path_with_index_and_end(
         self, *, index: int, end: ZonedDateTime
     ) -> None:
-        path = Path(f"log.{index}__{format_compact(to_local_plain(end))}.txt")
+        path = Path(f"log.{index}__{to_local_plain(end)}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -327,9 +292,7 @@ class TestRotatingLogFile:
         self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
         start, end = datetimes
-        path = Path(
-            f"log.{index}__{format_compact(to_local_plain(start))}__{format_compact(to_local_plain(end))}.txt"
-        )
+        path = Path(f"log.{index}__{to_local_plain(start)}__{to_local_plain(end)}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -359,9 +322,7 @@ class TestRotatingLogFile:
         file = _RotatingLogFile(
             directory=root, stem="log", suffix=".txt", index=index, end=end
         )
-        assert file.path == root.joinpath(
-            f"log.{index}__{format_compact(to_local_plain(end))}.txt"
-        )
+        assert file.path == root.joinpath(f"log.{index}__{to_local_plain(end)}.txt")
 
     @given(
         root=temp_paths(),
@@ -376,7 +337,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(to_local_plain(start))}__{format_compact(to_local_plain(end))}.txt"
+            f"log.{index}__{to_local_plain(start)}__{to_local_plain(end)}.txt"
         )
 
 

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/test_math.py

@@ -1175,6 +1175,9 @@ class TestRoundToFloat:
         param(1.8, 0.5, 2.0),
         param(1.9, 0.5, 2.0),
         param(2.0, 0.5, 2.0),
+        param(1.0745999813079834, 5e-5, 1.0746),
+        param(1.0745500326156616, 5e-5, 1.07455),
+        param(1.0745999813079834, 5e-5, 1.0746),
     ]
 
     @mark.parametrize(("x", "y", "expected"), cases)

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/test_sqlalchemy.py

@@ -99,7 +99,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 MILLISECOND, format_compact, get_now, to_local_plain
+from utilities.whenever import MILLISECOND, get_now, to_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
@@ -111,7 +111,7 @@ if TYPE_CHECKING:
 def _table_names() -> str:
     """Generate at unique string."""
     key = str(uuid4()).replace("-", "")
-    return f"{format_compact(to_local_plain(get_now()))}_{key}"
+    return f"{to_local_plain(get_now())}_{key}"
 
 
 @overload

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/test_traceback.py

@@ -8,20 +8,24 @@ from typing import TYPE_CHECKING
 
 from hypothesis import given
 from hypothesis.strategies import sampled_from
-from pytest import CaptureFixture, raises
+from pytest import CaptureFixture, mark, param, raises
 
 from utilities.iterables import one
 from utilities.traceback import (
     MakeExceptHookError,
+    _make_except_hook_purge,
     _path_to_dots,
     format_exception_stack,
     make_except_hook,
 )
 from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
+from utilities.whenever import SECOND, get_now, to_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
+    from utilities.types import Delta
+
 
 class TestFormatExceptionStack:
     @classmethod
@@ -93,8 +97,9 @@ class TestMakeExceptHook:
             hook(exc_type, exc_val, traceback)
             assert capsys.readouterr() != ""
 
-    def test_file(self, *, tmp_path: Path) -> None:
-        hook = make_except_hook(path=tmp_path)
+    @mark.parametrize("path_max_age", [param(SECOND), param(None)])
+    def test_path(self, *, tmp_path: Path, path_max_age: Delta | None) -> None:
+        hook = make_except_hook(path=tmp_path, path_max_age=path_max_age)
         try:
             _ = 1 / 0
         except ZeroDivisionError:
@@ -109,6 +114,14 @@ class TestMakeExceptHook:
         with raises(MakeExceptHookError, match="No exception to log"):
             hook(exc_type, exc_val, traceback)
 
+    def test_purge(self, *, tmp_path: Path) -> None:
+        now = get_now()
+        path = tmp_path.joinpath(to_local_plain(now - 2 * SECOND)).with_suffix(".txt")
+        path.touch()
+        assert len(list(tmp_path.iterdir())) == 1
+        _make_except_hook_purge(tmp_path, SECOND)
+        assert len(list(tmp_path.iterdir())) == 0
+
 
 class TestPathToDots:
     @given(

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/tests/test_whenever.py

@@ -122,6 +122,7 @@ from utilities.whenever import (
     get_today_local,
     mean_datetime,
     min_max_date,
+    parse_plain_local,
     round_date_or_date_time,
     sub_year_month,
     to_date,
@@ -1016,11 +1017,13 @@ class TestToHours:
             _ = to_hours(delta)
 
 
-class TestToLocalPlain:
+class TestToLocalPlainAndParsePlainLocal:
     @given(date_time=zoned_datetimes())
     def test_main(self, *, date_time: ZonedDateTime) -> None:
-        result = to_local_plain(date_time)
-        assert isinstance(result, PlainDateTime)
+        text = to_local_plain(date_time)
+        assert isinstance(text, str)
+        parsed = parse_plain_local(text)
+        assert abs(parsed - date_time) <= SECOND
 
 
 class TestToMicroseconds:

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.153.14"
+__version__ = "0.154.0"

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/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, to_local_plain
+from utilities.whenever import get_now, to_local_plain
 
 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(to_local_plain(get_now())))
+            page_no, now = (self.page_no(), to_local_plain(get_now()))
             text = f"page {page_no}/{{}}; {now}"
             _ = self.cell(
                 w=0,

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/utilities/iterables.py

@@ -18,7 +18,7 @@ from enum import Enum
 from functools import cmp_to_key, partial, reduce
 from itertools import accumulate, chain, groupby, islice, pairwise, product
 from math import isnan
-from operator import add, itemgetter, or_
+from operator import add, or_
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -821,24 +821,6 @@ def filter_include_and_exclude[T, U](
 ##
 
 
-def group_consecutive_integers(iterable: Iterable[int], /) -> Iterable[tuple[int, int]]:
-    """Group consecutive integers."""
-    integers = sorted(iterable)
-    for _, group in groupby(enumerate(integers), key=lambda x: x[1] - x[0]):
-        as_list = list(map(itemgetter(1), group))
-        yield as_list[0], as_list[-1]
-
-
-def ungroup_consecutive_integers(
-    iterable: Iterable[tuple[int, int]], /
-) -> Iterable[int]:
-    """Ungroup consecutive integers."""
-    return chain.from_iterable(range(start, end + 1) for start, end in iterable)
-
-
-##
-
-
 @overload
 def groupby_lists[T](
     iterable: Iterable[T], /, *, key: None = None
@@ -1504,7 +1486,6 @@ __all__ = [
     "enumerate_with_edge",
     "expanding_window",
     "filter_include_and_exclude",
-    "group_consecutive_integers",
     "groupby_lists",
     "hashable_to_iterable",
     "is_iterable",
@@ -1527,6 +1508,5 @@ __all__ = [
     "sum_mappings",
     "take",
     "transpose",
-    "ungroup_consecutive_integers",
     "unique_everseen",
 ]

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/utilities/logging.py

@@ -31,7 +31,7 @@ from typing import (
     override,
 )
 
-from whenever import PlainDateTime, ZonedDateTime
+from whenever import ZonedDateTime
 
 from utilities.atomicwrites import move_many
 from utilities.dataclasses import replace_non_sentinel
@@ -45,16 +45,15 @@ from utilities.re import (
     extract_groups,
 )
 from utilities.sentinel import Sentinel, sentinel
-from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
 from utilities.whenever import (
     WheneverLogRecord,
-    format_compact,
     get_now_local,
+    parse_plain_local,
     to_local_plain,
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Mapping
+    from collections.abc import Iterable, Mapping
     from datetime import time
     from logging import _FilterType
 
@@ -151,42 +150,6 @@ def basic_config(
 ##
 
 
-def filter_for_key(
-    key: str, /, *, default: bool = False
-) -> Callable[[LogRecord], bool]:
-    """Make a filter for a given attribute."""
-    if (key in _FILTER_FOR_KEY_BLACKLIST) or key.startswith("__"):
-        raise FilterForKeyError(key=key)
-
-    def filter_(record: LogRecord, /) -> bool:
-        try:
-            value = getattr(record, key)
-        except AttributeError:
-            return default
-        return bool(value)
-
-    return filter_
-
-
-# fmt: off
-_FILTER_FOR_KEY_BLACKLIST = {
-    "args", "created", "exc_info", "exc_text", "filename", "funcName", "getMessage", "levelname", "levelno", "lineno", "module", "msecs", "msg", "name", "pathname", "process", "processName", "relativeCreated", "stack_info", "taskName", "thread", "threadName"
-}
-# fmt: on
-
-
-@dataclass(kw_only=True, slots=True)
-class FilterForKeyError(Exception):
-    key: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid key: {self.key!r}"
-
-
-##
-
-
 def get_format_str(*, prefix: str | None = None, hostname: bool = False) -> str:
     """Generate a format string."""
     parts: list[str] = [
@@ -535,10 +498,8 @@ class _RotatingLogFile:
                 stem=stem,
                 suffix=suffix,
                 index=int(index),
-                start=PlainDateTime.parse_common_iso(start).assume_tz(
-                    LOCAL_TIME_ZONE_NAME
-                ),
-                end=PlainDateTime.parse_common_iso(end).assume_tz(LOCAL_TIME_ZONE_NAME),
+                start=parse_plain_local(start),
+                end=parse_plain_local(end),
             )
         try:
             index, end = extract_groups(patterns.pattern2, path.name)
@@ -550,7 +511,7 @@ class _RotatingLogFile:
                 stem=stem,
                 suffix=suffix,
                 index=int(index),
-                end=PlainDateTime.parse_common_iso(end).assume_tz(LOCAL_TIME_ZONE_NAME),
+                end=parse_plain_local(end),
             )
         try:
             index = extract_group(patterns.pattern1, path.name)
@@ -571,9 +532,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(to_local_plain(end))}"
+                tail = f"{index}__{to_local_plain(end)}"
             case int() as index, ZonedDateTime() as start, ZonedDateTime() as end:
-                tail = f"{index}__{format_compact(to_local_plain(start))}__{format_compact(to_local_plain(end))}"
+                tail = f"{index}__{to_local_plain(start)}__{to_local_plain(end)}"
             case _:  # pragma: no cover
                 raise ImpossibleCaseError(
                     case=[f"{self.index=}", f"{self.start=}", f"{self.end=}"]
@@ -626,12 +587,10 @@ def to_logger(logger: LoggerLike | None = None, /) -> Logger:
 
 
 __all__ = [
-    "FilterForKeyError",
     "GetLoggingLevelNumberError",
     "SizeAndTimeRotatingFileHandler",
     "add_filters",
     "basic_config",
-    "filter_for_key",
     "get_format_str",
     "get_logging_level_number",
     "setup_logging",

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/utilities/polars.py

@@ -2383,7 +2383,8 @@ def round_to_float(
 ) -> ExprOrSeries:
     """Round a column to the nearest multiple of another float."""
     x = ensure_expr_or_series(x)
-    return (x / y).round(mode=mode) * y
+    z = (x / y).round(mode=mode) * y
+    return z.round(decimals=number_of_decimals(y) + 1)
 
 
 ##

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/utilities/pyinstrument.py

@@ -8,7 +8,7 @@ from pyinstrument.profiler import Profiler
 
 from utilities.atomicwrites import writer
 from utilities.pathlib import to_path
-from utilities.whenever import format_compact, get_now, to_local_plain
+from utilities.whenever import get_now, to_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -21,9 +21,7 @@ def profile(path: MaybeCallablePathLike = Path.cwd, /) -> Iterator[None]:
     """Profile the contents of a block."""
     with Profiler() as profiler:
         yield
-    filename = to_path(path).joinpath(
-        f"profile__{format_compact(to_local_plain(get_now()))}.html"
-    )
+    filename = to_path(path).joinpath(f"profile__{to_local_plain(get_now())}.html")
     with writer(filename) as temp:
         _ = temp.write_text(profiler.output_html())
 

{dycw_utilities-0.153.14 → dycw_utilities-0.154.0}/src/utilities/traceback.py

@@ -33,6 +33,7 @@ from utilities.whenever import (
     format_compact,
     get_now,
     get_now_local,
+    parse_plain_local,
     to_local_plain,
     to_zoned_date_time,
 )
@@ -43,6 +44,7 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from utilities.types import (
+        Delta,
         MaybeCallableBoolLike,
         MaybeCallablePathLike,
         MaybeCallableZonedDateTimeLike,
@@ -95,16 +97,10 @@ def _yield_header_lines(
 ) -> Iterator[str]:
     """Yield the header lines."""
     now = get_now_local()
-    start_use = to_zoned_date_time(start)
     yield f"Date/time  | {format_compact(now)}"
-    if start_use is None:
-        start_str = ""
-    else:
-        start_str = format_compact(start_use.to_tz(LOCAL_TIME_ZONE_NAME))
-    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()
-    yield f"Duration   | {delta_str}"
+    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"User       | {getuser()}"
     yield f"Host       | {gethostname()}"
     yield f"Process ID | {getpid()}"
@@ -205,6 +201,7 @@ def make_except_hook(
     start: MaybeCallableZonedDateTimeLike = get_now,
     version: MaybeCallableVersionLike | None = None,
     path: MaybeCallablePathLike | None = None,
+    path_max_age: Delta | None = None,
     max_width: int = RICH_MAX_WIDTH,
     indent_size: int = RICH_INDENT_SIZE,
     max_length: int | None = RICH_MAX_LENGTH,
@@ -222,6 +219,7 @@ def make_except_hook(
         start=start,
         version=version,
         path=path,
+        path_max_age=path_max_age,
         max_width=max_width,
         indent_size=indent_size,
         max_length=max_length,
@@ -242,6 +240,7 @@ def _make_except_hook_inner(
     start: MaybeCallableZonedDateTimeLike = get_now,
     version: MaybeCallableVersionLike | None = None,
     path: MaybeCallablePathLike | None = None,
+    path_max_age: Delta | None = None,
     max_width: int = RICH_MAX_WIDTH,
     indent_size: int = RICH_INDENT_SIZE,
     max_length: int | None = RICH_MAX_LENGTH,
@@ -258,11 +257,8 @@ def _make_except_hook_inner(
     slim = format_exception_stack(exc_val, header=True, start=start, version=version)
     _ = sys.stderr.write(f"{slim}\n")  # don't 'from sys import stderr'
     if path is not None:
-        path = (
-            to_path(path)
-            .joinpath(format_compact(to_local_plain(get_now())))
-            .with_suffix(".txt")
-        )
+        path = to_path(path)
+        path_log = path.joinpath(to_local_plain(get_now())).with_suffix(".txt")
         full = format_exception_stack(
             exc_val,
             header=True,
@@ -276,8 +272,10 @@ def _make_except_hook_inner(
             max_depth=max_depth,
             expand_all=expand_all,
         )
-        with writer(path, overwrite=True) as temp:
+        with writer(path_log, overwrite=True) as temp:
             _ = temp.write_text(full)
+        if path_max_age is not None:
+            _make_except_hook_purge(path, path_max_age)
     if slack_url is not None:  # pragma: no cover
         from utilities.slack_sdk import SendToSlackError, send_to_slack
 
@@ -285,13 +283,23 @@ def _make_except_hook_inner(
             send_to_slack(slack_url, f"```{slim}```")
         except SendToSlackError as error:
             _ = stderr.write(f"{error}\n")
-
     if to_bool(pudb):  # pragma: no cover
         from pudb import post_mortem
 
         post_mortem(tb=traceback, e_type=exc_type, e_value=exc_val)
 
 
+def _make_except_hook_purge(path: PathLike, max_age: Delta, /) -> None:
+    threshold = get_now() - max_age
+    paths = {
+        p
+        for p in Path(path).iterdir()
+        if p.is_file() and (parse_plain_local(p.stem) <= threshold)
+    }
+    for p in paths:
+        p.unlink(missing_ok=True)
+
+
 @dataclass(kw_only=True, slots=True)
 class MakeExceptHookError(Exception):
     @override