dycw-utilities 0.129.8__tar.gz → 0.129.10__tar.gz

{dycw_utilities-0.129.8 → dycw_utilities-0.129.10}/PKG-INFO

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

{dycw_utilities-0.129.8 → dycw_utilities-0.129.10}/pyproject.toml

@@ -93,7 +93,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.129.8"
+version = "0.129.10"
 
 [project.optional-dependencies]
 test = [
@@ -332,7 +332,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.129.8"
+current_version = "0.129.10"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

dycw_utilities-0.129.10/src/tests/test_git.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hypothesis import given, settings
+from pytest import raises
+
+from utilities.git import GetRepoRootError, get_repo_root
+from utilities.hypothesis import git_repos
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class TestGetRepoRoot:
+    @given(repo=git_repos())
+    @settings(max_examples=1)
+    def test_main(self, *, repo: Path) -> None:
+        root = get_repo_root(path=repo)
+        expected = repo.resolve()
+        assert root == expected
+
+    def test_error(self, *, tmp_path: Path) -> None:
+        with raises(
+            GetRepoRootError, match="Path is not part of a `git` repository: .*"
+        ):
+            _ = get_repo_root(path=tmp_path)

{dycw_utilities-0.129.8 → dycw_utilities-0.129.10}/src/tests/test_traceback.py

@@ -2,9 +2,14 @@ from __future__ import annotations
 
 from io import StringIO
 from logging import StreamHandler, getLogger
+from pathlib import Path
+from re import search
+from sys import exc_info
 from typing import TYPE_CHECKING, ClassVar, Literal
 
-from pytest import raises
+from hypothesis import given
+from hypothesis.strategies import sampled_from
+from pytest import CaptureFixture, raises
 
 from tests.conftest import SKIPIF_CI
 from tests.test_traceback_funcs.chain import func_chain_first
@@ -29,11 +34,15 @@ from utilities.traceback import (
     ExcChainTB,
     ExcGroupTB,
     ExcTB,
+    MakeExceptHookError,
     RichTracebackFormatter,
     _CallArgsError,
     _format_exception,
     _Frame,
+    _path_to_dots,
+    format_exception_stack,
     get_rich_traceback,
+    make_except_hook,
     trace,
     yield_exceptions,
     yield_extended_frame_summaries,
@@ -41,7 +50,7 @@ from utilities.traceback import (
 )
 
 if TYPE_CHECKING:
-    from pathlib import Path
+    from collections.abc import Iterable
     from re import Pattern
     from traceback import FrameSummary
     from types import FrameType
@@ -62,6 +71,54 @@ class TestFormatException:
         assert result == expected
 
 
+class TestFormatExceptionStack:
+    def test_main(self) -> None:
+        try:
+            _ = func_one(1, 2, 3, 4, c=5, d=6, e=7)
+        except AssertionError as error:
+            result = format_exception_stack(error).splitlines()
+            self._assert_lines(result)
+
+    def test_header(self) -> None:
+        try:
+            _ = func_one(1, 2, 3, 4, c=5, d=6, e=7)
+        except AssertionError as error:
+            result = format_exception_stack(error, header=True).splitlines()
+            patterns = [
+                r"^Date/time \| .+$",
+                r"^Started   \| .+$",
+                r"^Duration  \| .+$",
+                r"^User      \| .+$",
+                r"^Host      \| .+$",
+                r"^Version   \|\s$",
+                r"^$",
+            ]
+            for line, pattern in zip(result[:7], patterns[:7], strict=False):
+                assert search(pattern, line), line
+            self._assert_lines(result[7:])
+
+    def test_capture_locals(self) -> None:
+        try:
+            _ = func_one(1, 2, 3, 4, c=5, d=6, e=7)
+        except AssertionError as error:
+            result = format_exception_stack(error, capture_locals=True).splitlines()
+            assert len(result) == 17
+            indices = [0, 3, 9, 16]
+            self._assert_lines([result[i] for i in indices])
+            for i in set(range(17)) - set(indices):
+                assert search(r"^    \| \w+ = .+$", result[i])
+
+    def _assert_lines(self, lines: Iterable[str], /) -> None:
+        expected = [
+            r"^1/3 \| tests\.test_traceback:\d+ \| test_\w+ \| _ = func_one\(1, 2, 3, 4, c=5, d=6, e=7\)$",
+            r"^2/3 \| utilities\.traceback:\d+ \| trace_sync \| return func_typed\(\*args, \*\*kwargs\)$",
+            r'^3/3 \| tests\.test_traceback_funcs\.one:16 \| func_one \| assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"$',
+            r"^AssertionError\(Result \(56\) must be divisible by 10\)$",
+        ]
+        for line, pattern in zip(lines, expected, strict=True):
+            assert search(pattern, line), line
+
+
 class TestFrame:
     frame: ClassVar[_Frame] = _Frame(
         module="module",
@@ -463,6 +520,33 @@ class TestGetRichTraceback:
         assert isinstance(exc_path.error, AssertionError)
 
 
+class TestMakeExceptHook:
+    def test_main(self, *, capsys: CaptureFixture) -> None:
+        hook = make_except_hook()
+        try:
+            _ = 1 / 0
+        except ZeroDivisionError:
+            exc_type, exc_val, traceback = exc_info()
+            hook(exc_type, exc_val, traceback)
+            assert capsys.readouterr() != ""
+
+    def test_file(self, *, tmp_path: Path) -> None:
+        hook = make_except_hook(path=tmp_path)
+        try:
+            _ = 1 / 0
+        except ZeroDivisionError:
+            exc_type, exc_val, traceback = exc_info()
+            hook(exc_type, exc_val, traceback)
+        path = one(tmp_path.iterdir())
+        assert search(r"^\d{8}T\d{6}\.txt$", path.name)
+
+    def test_non_error(self) -> None:
+        hook = make_except_hook()
+        exc_type, exc_val, traceback = exc_info()
+        with raises(MakeExceptHookError, match="No exception to log"):
+            hook(exc_type, exc_val, traceback)
+
+
 class TestRichTracebackFormatter:
     def test_decorated(
         self, *, tmp_path: Path, traceback_func_one: Pattern[str]
@@ -519,6 +603,42 @@ class TestRichTracebackFormatter:
         assert result.startswith("> ")
 
 
+class TestPathToDots:
+    @given(
+        case=sampled_from([
+            (
+                Path("repo", ".venv", "lib", "site-packages", "click", "core.py"),
+                "click.core",
+            ),
+            (
+                Path(
+                    "repo", ".venv", "lib", "site-packages", "utilities", "traceback.py"
+                ),
+                "utilities.traceback",
+            ),
+            (Path("repo", ".venv", "bin", "cli.py"), "bin.cli"),
+            (Path("src", "utilities", "foo", "bar.py"), "utilities.foo.bar"),
+            (
+                Path(
+                    "uv",
+                    "python",
+                    "cpython-3.13.0-macos-aarch64-none",
+                    "lib",
+                    "python3.13",
+                    "asyncio",
+                    "runners.py",
+                ),
+                "asyncio.runners",
+            ),
+            (Path("unknown", "file.py"), "unknown.file"),
+        ])
+    )
+    def test_main(self, *, case: tuple[Path, str]) -> None:
+        path, expected = case
+        result = _path_to_dots(path)
+        assert result == expected
+
+
 class TestYieldExceptions:
     def test_main(self) -> None:
         class FirstError(Exception): ...

{dycw_utilities-0.129.8 → dycw_utilities-0.129.10}/src/tests/test_whenever.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import datetime as dt
 from datetime import timezone
-from logging import getLogger, setLogRecordFactory
+from logging import DEBUG
 from re import escape
 from typing import TYPE_CHECKING
 from zoneinfo import ZoneInfo
@@ -21,7 +21,7 @@ from hypothesis.strategies import (
     timezones,
 )
 from pytest import raises
-from whenever import DateTimeDelta
+from whenever import DateTimeDelta, ZonedDateTime
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -41,7 +41,6 @@ from utilities.hypothesis import (
     timedeltas_2w,
     zoned_datetimes,
 )
-from utilities.text import unique_str
 from utilities.tzdata import HongKong
 from utilities.whenever import (
     MAX_SERIALIZABLE_TIMEDELTA,
@@ -498,7 +497,17 @@ class TestToDateTimeDelta:
 
 
 class TestWheneverLogRecord:
-    def test_main(self) -> None:
-        logger = getLogger(unique_str())
-        setLogRecordFactory(WheneverLogRecord)
-        logger.warning("message")
+    def test_init(self) -> None:
+        _ = WheneverLogRecord("name", DEBUG, "pathname", 0, None, None, None)
+
+    def test_get_length(self) -> None:
+        assert isinstance(WheneverLogRecord._get_length(), int)
+
+    def test_get_now(self) -> None:
+        assert isinstance(WheneverLogRecord._get_now(), ZonedDateTime)
+
+    def test_get_time_zone(self) -> None:
+        assert isinstance(WheneverLogRecord._get_time_zone(), ZoneInfo)
+
+    def test_get_time_zone_key(self) -> None:
+        assert isinstance(WheneverLogRecord._get_time_zone_key(), str)

{dycw_utilities-0.129.8 → dycw_utilities-0.129.10}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.129.8"
+__version__ = "0.129.10"

dycw_utilities-0.129.10/src/utilities/git.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from re import IGNORECASE, search
+from subprocess import PIPE, CalledProcessError, check_output
+from typing import TYPE_CHECKING, override
+
+from utilities.pathlib import PWD
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike
+
+
+def get_repo_root(*, path: PathLike = PWD) -> Path:
+    """Get the repo root."""
+    try:
+        output = check_output(
+            ["git", "rev-parse", "--show-toplevel"], stderr=PIPE, cwd=path, text=True
+        )
+    except CalledProcessError as error:
+        # newer versions of git report "Not a git repository", whilst older
+        # versions report "not a git repository"
+        if search("fatal: not a git repository", error.stderr, flags=IGNORECASE):
+            raise GetRepoRootError(cwd=path) from error
+        raise  # pragma: no cover
+    else:
+        return Path(output.strip("\n"))
+
+
+@dataclass(kw_only=True, slots=True)
+class GetRepoRootError(Exception):
+    cwd: PathLike
+
+    @override
+    def __str__(self) -> str:
+        return f"Path is not part of a `git` repository: {self.cwd}"
+
+
+__all__ = ["GetRepoRootError", "get_repo_root"]

{dycw_utilities-0.129.8 → dycw_utilities-0.129.10}/src/utilities/traceback.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+import re
+import sys
+from asyncio import run
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass, field, replace
-from functools import wraps
+from functools import partial, wraps
 from getpass import getuser
 from inspect import iscoroutinefunction, signature
+from itertools import repeat
 from logging import Formatter, Handler, LogRecord
 from pathlib import Path
 from socket import gethostname
@@ -26,8 +30,8 @@ from typing import (
     runtime_checkable,
 )
 
-from utilities.datetime import get_datetime, get_now
-from utilities.errors import ImpossibleCaseError
+from utilities.datetime import get_datetime, get_now, serialize_compact
+from utilities.errors import ImpossibleCaseError, repr_error
 from utilities.functions import (
     ensure_not_none,
     ensure_str,
@@ -35,7 +39,8 @@ from utilities.functions import (
     get_func_name,
     get_func_qualname,
 )
-from utilities.iterables import always_iterable, one
+from utilities.iterables import OneEmptyError, always_iterable, one
+from utilities.pathlib import get_path
 from utilities.reprlib import (
     RICH_EXPAND_ALL,
     RICH_INDENT_SIZE,
@@ -46,12 +51,18 @@ from utilities.reprlib import (
     yield_call_args_repr,
     yield_mapping_repr,
 )
-from utilities.types import MaybeCallableDateTime, TBaseException, TCallable
+from utilities.types import (
+    MaybeCallableDateTime,
+    MaybeCallablePathLike,
+    PathLike,
+    TBaseException,
+    TCallable,
+)
 from utilities.version import get_version
 from utilities.whenever import serialize_duration
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Iterator
+    from collections.abc import Callable, Iterable, Iterator, Sequence
     from logging import _FormatStyle
     from types import FrameType, TracebackType
 
@@ -68,6 +79,131 @@ _START = get_now()
 ##
 
 
+def format_exception_stack(
+    error: BaseException,
+    /,
+    *,
+    header: bool = False,
+    start: MaybeCallableDateTime | None = _START,
+    version: MaybeCallableVersionLike | None = None,
+    capture_locals: bool = False,
+    max_width: int = RICH_MAX_WIDTH,
+    indent_size: int = RICH_INDENT_SIZE,
+    max_length: int | None = RICH_MAX_LENGTH,
+    max_string: int | None = RICH_MAX_STRING,
+    max_depth: int | None = RICH_MAX_DEPTH,
+    expand_all: bool = RICH_EXPAND_ALL,
+) -> str:
+    """Format an exception stack."""
+    lines: Sequence[str] = []
+    if header:
+        lines.extend(_yield_header_lines(start=start, version=version))
+    lines.extend(
+        _yield_formatted_frame_summary(
+            error,
+            capture_locals=capture_locals,
+            max_width=max_width,
+            indent_size=indent_size,
+            max_length=max_length,
+            max_string=max_string,
+            max_depth=max_depth,
+            expand_all=expand_all,
+        )
+    )
+    return "\n".join(lines)
+
+
+##
+
+
+def make_except_hook(
+    *,
+    start: MaybeCallableDateTime | None = _START,
+    version: MaybeCallableVersionLike | None = None,
+    path: MaybeCallablePathLike | None = None,
+    max_width: int = RICH_MAX_WIDTH,
+    indent_size: int = RICH_INDENT_SIZE,
+    max_length: int | None = RICH_MAX_LENGTH,
+    max_string: int | None = RICH_MAX_STRING,
+    max_depth: int | None = RICH_MAX_DEPTH,
+    expand_all: bool = RICH_EXPAND_ALL,
+    slack_url: str | None = None,
+) -> Callable[
+    [type[BaseException] | None, BaseException | None, TracebackType | None], None
+]:
+    """Exception hook to log the traceback."""
+    return partial(
+        _make_except_hook_inner,
+        start=start,
+        version=version,
+        path=path,
+        max_width=max_width,
+        indent_size=indent_size,
+        max_length=max_length,
+        max_string=max_string,
+        max_depth=max_depth,
+        expand_all=expand_all,
+        slack_url=slack_url,
+    )
+
+
+def _make_except_hook_inner(
+    exc_type: type[BaseException] | None,
+    exc_val: BaseException | None,
+    traceback: TracebackType | None,
+    /,
+    *,
+    start: MaybeCallableDateTime | None = _START,
+    version: MaybeCallableVersionLike | None = None,
+    path: MaybeCallablePathLike | None = None,
+    max_width: int = RICH_MAX_WIDTH,
+    indent_size: int = RICH_INDENT_SIZE,
+    max_length: int | None = RICH_MAX_LENGTH,
+    max_string: int | None = RICH_MAX_STRING,
+    max_depth: int | None = RICH_MAX_DEPTH,
+    expand_all: bool = RICH_EXPAND_ALL,
+    slack_url: str | None = None,
+) -> None:
+    """Exception hook to log the traceback."""
+    _ = (exc_type, traceback)
+    if exc_val is None:
+        raise MakeExceptHookError
+    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:
+        from utilities.atomicwrites import writer
+        from utilities.tzlocal import get_now_local
+
+        path = (
+            get_path(path=path)
+            .joinpath(serialize_compact(get_now_local()))
+            .with_suffix(".txt")
+        )
+        full = format_exception_stack(
+            exc_val,
+            header=True,
+            start=start,
+            version=version,
+            capture_locals=True,
+            max_width=max_width,
+            indent_size=indent_size,
+            max_length=max_length,
+            max_string=max_string,
+            max_depth=max_depth,
+            expand_all=expand_all,
+        )
+        with writer(path, overwrite=True) as temp:
+            _ = temp.write_text(full)
+    if slack_url is not None:  # pragma: no cover
+        from utilities.slack_sdk import send_to_slack
+
+        send = f"```{slim}```"
+        run(send_to_slack(slack_url, send))
+
+
+##
+
+
 class RichTracebackFormatter(Formatter):
     """Formatter for rich tracebacks."""
 
@@ -811,6 +947,9 @@ def _merge_frames(
     return values[::-1]
 
 
+##
+
+
 def _yield_header_lines(
     *,
     start: MaybeCallableDateTime | None = _START,
@@ -838,12 +977,108 @@ def _yield_header_lines(
     yield ""
 
 
+##
+
+
+def _yield_formatted_frame_summary(
+    error: BaseException,
+    /,
+    *,
+    capture_locals: bool = False,
+    max_width: int = RICH_MAX_WIDTH,
+    indent_size: int = RICH_INDENT_SIZE,
+    max_length: int | None = RICH_MAX_LENGTH,
+    max_string: int | None = RICH_MAX_STRING,
+    max_depth: int | None = RICH_MAX_DEPTH,
+    expand_all: bool = RICH_EXPAND_ALL,
+) -> Iterator[str]:
+    """Yield the formatted frame summary lines."""
+    stack = TracebackException.from_exception(
+        error, capture_locals=capture_locals
+    ).stack
+    n = len(stack)
+    for i, frame in enumerate(stack, start=1):
+        num = f"{i}/{n}"
+        first, *rest = _yield_frame_summary_lines(
+            frame,
+            max_width=max_width,
+            indent_size=indent_size,
+            max_length=max_length,
+            max_string=max_string,
+            max_depth=max_depth,
+            expand_all=expand_all,
+        )
+        yield f"{num} | {first}"
+        blank = "".join(repeat(" ", len(num)))
+        for rest_i in rest:
+            yield f"{blank} | {rest_i}"
+    yield repr_error(error)
+
+
+def _yield_frame_summary_lines(
+    frame: FrameSummary,
+    /,
+    *,
+    max_width: int = RICH_MAX_WIDTH,
+    indent_size: int = RICH_INDENT_SIZE,
+    max_length: int | None = RICH_MAX_LENGTH,
+    max_string: int | None = RICH_MAX_STRING,
+    max_depth: int | None = RICH_MAX_DEPTH,
+    expand_all: bool = RICH_EXPAND_ALL,
+) -> Iterator[str]:
+    module = _path_to_dots(frame.filename)
+    yield f"{module}:{frame.lineno} | {frame.name} | {frame.line}"
+    if frame.locals is not None:
+        yield from yield_mapping_repr(
+            frame.locals,
+            _max_width=max_width,
+            _indent_size=indent_size,
+            _max_length=max_length,
+            _max_string=max_string,
+            _max_depth=max_depth,
+            _expand_all=expand_all,
+        )
+
+
+def _path_to_dots(path: PathLike, /) -> str:
+    new_path: Path | None = None
+    for pattern in [
+        "site-packages",
+        ".venv",  # after site-packages
+        "src",
+        r"python\d+\.\d+",
+    ]:
+        if (new_path := _trim_path(path, pattern)) is not None:
+            break
+    path_use = Path(path) if new_path is None else new_path
+    return ".".join(path_use.with_suffix("").parts)
+
+
+def _trim_path(path: PathLike, pattern: str, /) -> Path | None:
+    parts = Path(path).parts
+    compiled = re.compile(f"^{pattern}$")
+    try:
+        i = one(i for i, p in enumerate(parts) if compiled.search(p))
+    except OneEmptyError:
+        return None
+    return Path(*parts[i + 1 :])
+
+
+@dataclass(kw_only=True, slots=True)
+class MakeExceptHookError(Exception):
+    @override
+    def __str__(self) -> str:
+        return "No exception to log"
+
+
 __all__ = [
     "ExcChainTB",
     "ExcGroupTB",
     "ExcTB",
     "RichTracebackFormatter",
+    "format_exception_stack",
     "get_rich_traceback",
+    "make_except_hook",
     "trace",
     "yield_exceptions",
     "yield_extended_frame_summaries",