errortools 3.4.0__tar.gz → 3.5.0__tar.gz

{errortools-3.4.0/errortools.egg-info → errortools-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errortools
-Version: 3.4.0
+Version: 3.5.0
 Summary: errortools - a toolset for working with Python exceptions and warnings and logging.
 Author-email: Evan Yang <quantbit@126.com>
 License: Copyright (c) 2026 authors see AUTHORS.txt
@@ -35,13 +35,15 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: OS Independent
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
-Requires-Dist: namebyauthor==1.0.0
+Requires-Dist: namebyauthor==1.2.0
 Requires-Dist: typing_extensions>=4.15.0
 Dynamic: license-file
 

errortools-3.5.0/_errortools/_speedup.c

@@ -0,0 +1,277 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+/* C speedup module for errortools.
+ *
+ * Provides optimized implementations of exception-handling hot paths used by
+ * ``_errortools.future``:
+ *
+ *   - fast_issubclass_check: Quick exception type hierarchy checking
+ *   - fast_append_exception : Efficient exception list append operation
+ *   - fast_suppress_exit    : Combined None-check + issubclass for __exit__
+ *
+ * The functions are tuned for the common case where the exception type raised
+ * is *exactly* one of the suppressed types.  In that case we can avoid the
+ * relatively expensive ``PyObject_IsSubclass`` call (which walks the MRO and
+ * may invoke ``__subclasscheck__``) and answer with a simple pointer
+ * comparison.
+ */
+
+/* --- Python version compatibility ---------------------------------------- */
+
+/* ``Py_IsNone`` and ``Py_NewRef`` were added in Python 3.10; the GIL slot and
+ * multi-interpreter slots were added in 3.12/3.13.  We feature-gate the use
+ * of those so the module still builds on the minimum supported version
+ * (Python 3.8). */
+#if PY_VERSION_HEX >= 0x030A0000
+#define SPEEDUP_IS_NONE(x) Py_IsNone(x)
+#define SPEEDUP_NEW_REF(x) Py_NewRef(x)
+#else
+#define SPEEDUP_IS_NONE(x) ((x) == Py_None)
+#define SPEEDUP_NEW_REF(x) \
+    do {                   \
+        Py_INCREF(x);      \
+    } while (0)
+#endif
+
+/* --- Internal helpers --------------------------------------------------- */
+
+/* Identity-based fast path for ``typ in excs``.
+ *
+ * Returns 1 if ``typ`` is exactly equal to one of the types in ``excs``,
+ * 0 if it is not, and -1 if the fast path could not answer the question
+ * (i.e. ``excs`` is neither a type nor a tuple of types).
+ *
+ * This avoids the relatively expensive ``PyObject_IsSubclass`` call in the
+ * overwhelmingly common case where the exception raised is exactly the type
+ * the caller asked about.  Note that this is *not* a full subclass check:
+ * if the caller needs to also accept subclasses, the result of this
+ * function is only meaningful as a fast-path early-out. */
+static inline int identity_match(PyObject *typ, PyObject *excs) {
+    if (PyType_Check(excs)) {
+        return (typ == excs) ? 1 : 0;
+    }
+    if (PyTuple_Check(excs)) {
+        Py_ssize_t n = PyTuple_GET_SIZE(excs);
+        for (Py_ssize_t i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(excs, i) == typ) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    /* Unknown shape: defer to PyObject_IsSubclass. */
+    return -1;
+}
+
+/* Translate the tri-state return of ``PyObject_IsSubclass`` into a fresh
+ * ``bool`` reference (or ``NULL`` on error). */
+static inline PyObject *bool_from_issubclass(int result) {
+    if (result == -1) {
+        return NULL;
+    }
+    return result ? Py_True : Py_False;
+}
+
+/* Combined fast-path answer for the two subclass-checking entry points.
+ * Returns:
+ *    1 if the identity fast path can answer ``True`` definitively,
+ *    0 if it can answer ``False`` definitively (i.e. ``excs`` is an
+ *      empty tuple, which by definition matches nothing),
+ *   -1 if the fast path is inconclusive and the caller must fall through
+ *      to the full ``PyObject_IsSubclass`` check. */
+static inline int fast_path_result(PyObject *typ, PyObject *excs) {
+    int fast = identity_match(typ, excs);
+    if (fast == 1) {
+        return 1;
+    }
+    if (PyTuple_Check(excs) && PyTuple_GET_SIZE(excs) == 0) {
+        return 0;
+    }
+    return -1;
+}
+
+/* --- Public functions --------------------------------------------------- */
+
+/* fast_issubclass_check(typ, excs) -> bool
+ *
+ * Check whether ``typ`` is a subclass of ``excs``.  Returns ``False`` if
+ * ``typ`` is ``None``.  ``excs`` must be a class or a tuple of classes;
+ * a ``TypeError`` is raised otherwise. */
+static PyObject *fast_issubclass_check(PyObject *self, PyObject *const *args, Py_ssize_t nargs) {
+    (void)self; /* module method - self is unused */
+    if (nargs != 2) {
+        PyErr_Format(PyExc_TypeError,
+                     "fast_issubclass_check() takes exactly 2 arguments (%zd given)",
+                     nargs);
+        return NULL;
+    }
+
+    PyObject *typ = args[0];
+    PyObject *excs = args[1];
+
+    /* None never matches. */
+    if (SPEEDUP_IS_NONE(typ)) {
+        Py_RETURN_FALSE;
+    }
+
+    /* ``excs`` must be a class or tuple of classes. */
+    if (!PyType_Check(excs) && !PyTuple_Check(excs)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "second argument must be a class or tuple of classes");
+        return NULL;
+    }
+
+    /* Fast path: identity match avoids the MRO walk entirely. */
+    int fast = fast_path_result(typ, excs);
+    if (fast == 1) {
+        Py_RETURN_TRUE;
+    }
+    if (fast == 0) {
+        Py_RETURN_FALSE;
+    }
+
+    /* Slow path: defer to CPython's full implementation. */
+    return bool_from_issubclass(PyObject_IsSubclass(typ, excs));
+}
+
+/* fast_append_exception(list, exc) -> None
+ *
+ * Append ``exc`` to ``list``.  ``list`` must be a Python ``list``; a
+ * ``TypeError`` is raised otherwise.  The explicit type check provides a
+ * friendlier error than the ``SystemError`` raised by ``PyList_Append`` for
+ * the same condition. */
+static PyObject *fast_append_exception(PyObject *self, PyObject *const *args, Py_ssize_t nargs) {
+    (void)self; /* module method - self is unused */
+    if (nargs != 2) {
+        PyErr_Format(PyExc_TypeError,
+                     "fast_append_exception() takes exactly 2 arguments (%zd given)",
+                     nargs);
+        return NULL;
+    }
+
+    PyObject *list = args[0];
+    PyObject *exc = args[1];
+
+    if (!PyList_Check(list)) {
+        PyErr_SetString(PyExc_TypeError, "first argument must be a list");
+        return NULL;
+    }
+
+    if (PyList_Append(list, exc) == -1) {
+        return NULL; /* exception already set by PyList_Append */
+    }
+
+    Py_RETURN_NONE;
+}
+
+/* fast_suppress_exit(typ, excs) -> bool
+ *
+ * Return ``True`` if ``typ`` is not ``None`` and is a subclass of one of
+ * the types in ``excs``.  Designed for the ``__exit__`` slot of context
+ * managers: it must never raise on the ``None`` case and should be as cheap
+ * as possible on the hot "no exception" path. */
+static PyObject *fast_suppress_exit(PyObject *self, PyObject *const *args, Py_ssize_t nargs) {
+    (void)self; /* module method - self is unused */
+    if (nargs != 2) {
+        PyErr_Format(PyExc_TypeError,
+                     "fast_suppress_exit() takes exactly 2 arguments (%zd given)",
+                     nargs);
+        return NULL;
+    }
+
+    PyObject *typ = args[0];
+    PyObject *excs = args[1];
+
+    /* Hot path: no exception pending. */
+    if (SPEEDUP_IS_NONE(typ)) {
+        Py_RETURN_FALSE;
+    }
+
+    /* Fast path: typ is exactly one of the suppressed types. */
+    int fast = fast_path_result(typ, excs);
+    if (fast == 1) {
+        Py_RETURN_TRUE;
+    }
+    if (fast == 0) {
+        Py_RETURN_FALSE;
+    }
+
+    /* Slow path: full subclass check.  This is reached for:
+     *   (a) identity miss on a single class,
+     *   (b) identity miss on a non-empty tuple, and
+     *   (c) ``excs`` of an unexpected shape. */
+    return bool_from_issubclass(PyObject_IsSubclass(typ, excs));
+}
+
+/* --- Module definition -------------------------------------------------- */
+
+static PyMethodDef SpeedupMethods[] = {
+    {
+        "fast_issubclass_check",
+        (PyCFunction)(void (*)(void))fast_issubclass_check,
+        METH_FASTCALL,
+        "fast_issubclass_check(typ, excs) -> bool\n\n"
+        "Check whether *typ* is a subclass of *excs*.\n"
+        "Returns ``False`` if *typ* is ``None``; *excs* must be a class or\n"
+        "a tuple of classes.  Uses an identity fast path before falling back\n"
+        "to :c:func:`PyObject_IsSubclass`.",
+    },
+    {
+        "fast_append_exception",
+        (PyCFunction)(void (*)(void))fast_append_exception,
+        METH_FASTCALL,
+        "fast_append_exception(list, exc) -> None\n\n"
+        "Append *exc* to *list* (which must be a :class:`list`).",
+    },
+    {
+        "fast_suppress_exit",
+        (PyCFunction)(void (*)(void))fast_suppress_exit,
+        METH_FASTCALL,
+        "fast_suppress_exit(typ, excs) -> bool\n\n"
+        "Return ``True`` if *typ* is not ``None`` and is a subclass of any\n"
+        "type in *excs*.  Tuned for ``__exit__`` context-manager methods.",
+    },
+    {NULL, NULL, 0, NULL} /* Sentinel */
+};
+
+/* Multi-interpreter / free-threading slots, gated by Python version.
+ *
+ * On Python 3.13+ we opt out of the GIL with ``Py_MOD_GIL_NOT_USED``.  This
+ * is safe because the module owns no global mutable state.  The slot
+ * mechanism requires multi-phase initialization (see ``PyInit__speedup``). */
+#if PY_VERSION_HEX >= 0x030D0000
+static PyModuleDef_Slot speedup_slots[] = {
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+    {0, NULL},
+};
+#endif
+
+static struct PyModuleDef speedupmodule = {
+    PyModuleDef_HEAD_INIT,
+    "_speedup",                 /* m_name */
+    "C speedup module for errortools\n\n"
+    "Provides optimized implementations of exception handling operations:\n"
+    "  - fast_issubclass_check: Quick exception type hierarchy checking\n"
+    "  - fast_append_exception: Efficient exception list append operations\n"
+    "  - fast_suppress_exit: Combined None-check + issubclass for __exit__",
+    0,                          /* m_size (0 = not per-interpreter) */
+    SpeedupMethods,             /* m_methods */
+#if PY_VERSION_HEX >= 0x030D0000
+    speedup_slots,              /* m_slots */
+#else
+    NULL,                       /* m_slots */
+#endif
+    NULL,                       /* m_traverse */
+    NULL,                       /* m_clear */
+    NULL,                       /* m_free */
+};
+
+PyMODINIT_FUNC PyInit__speedup(void) {
+    /* ``PyModuleDef_Init`` must be used (instead of ``PyModule_Create``) when
+     * the module carries ``m_slots`` -- which we do on Python 3.13+ to opt
+     * out of the GIL.  On older versions the two functions are functionally
+     * equivalent, so we use ``PyModuleDef_Init`` unconditionally to keep
+     * the init path single-source. */
+    return PyModuleDef_Init(&speedupmodule);
+}

{errortools-3.4.0 → errortools-3.5.0}/_errortools/classes/group.py

@@ -2,6 +2,7 @@
 
 from abc import abstractmethod, ABC
 import sys
+from typing import Any
 
 __all__ = [
     "BaseGroup",
@@ -21,7 +22,7 @@ class BaseGroup(Exception, ABC):
         group_msg: The message attached to the raised group.
     """
 
-    def __init__(self, group_msg: str = "multiple errors") -> None:
+    def __init__(self, group_msg: str = "multiple errors", *args: Any) -> None:
         """Initialise the group with a message.
 
         Args:
@@ -29,6 +30,7 @@ class BaseGroup(Exception, ABC):
                 Defaults to ``"multiple errors"``.
         """
         self.group_msg = group_msg
+        super().__init__(group_msg, *args)
 
     @property
     @abstractmethod

errortools-3.5.0/_errortools/cli.py

@@ -0,0 +1,259 @@
+"""Public command-line interface for errortools.
+
+This module provides the entry points used by the ``errortools`` and
+``logger`` console scripts declared in :file:`pyproject.toml`.
+
+Two command families share this dispatcher:
+
+* ``errortools``  - metadata, version and developer tooling flags.
+* ``logger``      - log emission and an interactive debug shell.
+
+The correct family is selected once, at module import time, by
+inspecting :data:`sys.argv` rather than the parent process, so the
+detection survives ``python -m _errortools`` invocations and works on
+all supported platforms.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Callable, Sequence
+from typing import Final
+
+from _errortools._cli import _cmd_log, _print_info
+from _errortools.metadata import (
+    __description__,
+    __copyright__,
+    __author__,
+    __author_email__,
+    __license__,
+    __url__,
+)
+from _errortools.version import __version__
+
+# ---------------------------------------------------------------------------
+# Mode detection
+# ---------------------------------------------------------------------------
+
+
+def _detect_mode(argv0: str | None = None) -> str:
+    """Return the CLI family inferred from ``argv0``.
+
+    The detection uses the *basename* of the executable/script rather
+    than a substring test, so paths such as ``/usr/bin/logger`` (a
+    real Unix utility) or ``my_logger_tool`` do not accidentally
+    trigger the logger dispatcher.
+    """
+    raw = argv0 if argv0 is not None else sys.argv[0]
+    basename = os.path.basename(raw).lower()
+    # Strip common suffixes so ``logger-script.py`` / ``logger.exe``
+    # also collapse to the bare command name.
+    for suffix in (".exe", ".py", ".pyw", ".pyz", ".sh"):
+        if basename.endswith(suffix):
+            basename = basename[: -len(suffix)]
+    return "logger" if basename == "logger" else "errortools"
+
+
+# ``sys.argv[0]`` is stable for the lifetime of the process; cache
+# the resolved mode to avoid recomputing the basename on every call.
+_CLI_MODE: Final[str] = _detect_mode()
+
+
+def _make_parser(prog: str, description: str) -> argparse.ArgumentParser:
+    """Build an `ArgumentParser`, enabling colour on 3.14+.
+
+    Colour output is only supported by :mod:`argparse` from Python 3.14,
+    so the ``color`` kwarg is conditionally supplied to stay compatible
+    with the project's ``requires-python = ">=3.8"``.
+    """
+    if sys.version_info >= (3, 14):
+        return argparse.ArgumentParser(prog=prog, description=description, color=True)
+    return argparse.ArgumentParser(prog=prog, description=description)
+
+
+# ---------------------------------------------------------------------------
+# errortools family
+# ---------------------------------------------------------------------------
+
+
+def _build_errortools_parser() -> argparse.ArgumentParser:
+    """Construct the argument parser for the ``errortools`` command."""
+    parser = _make_parser(prog="errortools", description=__description__)
+    parser.add_argument("-v", "--version", action="store_true", help="Show version and exit")
+    parser.add_argument("-c", "--copyrights", action="store_true", help="Show copyright information")
+    parser.add_argument("-a", "--author", action="store_true", help="Show author name")
+    parser.add_argument("-e", "--email", action="store_true", help="Show author email")
+    parser.add_argument("-l", "--license", action="store_true", help="Show license type")
+    parser.add_argument("-u", "--url", action="store_true", help="Show project URL")
+    parser.add_argument("-i", "--info", action="store_true", help="Show all package information")
+    parser.add_argument("--run-tests", action="store_true", help="Run tests using pytest")
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# logger family
+# ---------------------------------------------------------------------------
+
+
+def _build_logger_parser() -> argparse.ArgumentParser:
+    """Construct the argument parser for the ``logger`` command."""
+    parser = _make_parser(
+        prog="logger",
+        description="Logger CLI - emit log records or open an interactive REPL.",
+    )
+    subparsers = parser.add_subparsers(
+        dest="subcmd",
+        required=True,
+        title="available subcommands",
+        metavar="{emit,shell}",
+        help="run `logger {subcommand} -h` to view subcommand details",
+    )
+
+    parser_emit = subparsers.add_parser(
+        "emit",
+        help="Emit a single log message to stdout or stderr",
+        description="Emit a single log message to stdout or stderr.",
+    )
+    parser_emit.add_argument("message", help="Text content of the log record")
+    parser_emit.add_argument(
+        "--level",
+        "-l",
+        default="info",
+        choices=["trace", "debug", "info", "success", "warning", "error", "critical"],
+        help="Log severity level (default: info)",
+    )
+    parser_emit.add_argument(
+        "--output",
+        "-o",
+        choices=["stderr", "stdout"],
+        default="stderr",
+        help="Target output stream (default: stderr)",
+    )
+
+    subparsers.add_parser(
+        "shell",
+        help="Launch an interactive logger REPL debug shell",
+        description="Launch an interactive logger REPL debug shell.",
+    )
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Argument parsing
+# ---------------------------------------------------------------------------
+
+
+def parse_args(args: Sequence[str] | None = None) -> argparse.Namespace:
+    """Parse command-line arguments for the active CLI family."""
+    if _CLI_MODE == "logger":
+        return _build_logger_parser().parse_args(args)
+    return _build_errortools_parser().parse_args(args)
+
+
+# ---------------------------------------------------------------------------
+# Flag dispatch (errortools family)
+# ---------------------------------------------------------------------------
+
+
+def _show_version() -> None:
+    """Print ``errortools <version>`` in the same shape as ``--info``."""
+    print(f"errortools {__version__}")
+
+
+def _show_copyrights() -> None:
+    """Print the project's copyright line."""
+    print(__copyright__)
+
+
+def _show_author() -> None:
+    """Print the author's name."""
+    print(f"Author: {__author__}")
+
+
+def _show_email() -> None:
+    """Print the author's contact email."""
+    print(f"Email: {__author_email__}")
+
+
+def _show_license() -> None:
+    """Print the project's licence."""
+    print(f"License: {__license__}")
+
+
+def _show_url() -> None:
+    """Print the project's homepage URL."""
+    print(f"URL: {__url__}")
+
+
+def _run_tests() -> None:
+    """Delegate to :func:`testing.run_tests.run_tests` with a helpful message on failure."""
+    try:
+        from testing.run_tests import run_tests
+    except ImportError as exc:  # pragma: no cover - environment dependent
+        sys.stderr.write(
+            "errortools: cannot import `testing` package " f"({exc!r}). Install the project with its test extras.\n"
+        )
+        sys.exit(2)
+    run_tests()
+
+
+_FLAG_ACTIONS: Final[dict[str, Callable[[], None]]] = {
+    "version": _show_version,
+    "copyrights": _show_copyrights,
+    "author": _show_author,
+    "email": _show_email,
+    "license": _show_license,
+    "url": _show_url,
+    "run_tests": _run_tests,
+    "info": _print_info,
+}
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def _dispatch_logger(args: argparse.Namespace) -> None:
+    """Route a parsed ``logger`` namespace to its subcommand handler."""
+    if args.subcmd == "shell":
+        from _errortools._logger_shell import start_shell
+
+        start_shell()
+        return
+    # ``subcmd`` is constrained to {"emit", "shell"} by argparse, but
+    # keep a defensive fallback in case ``required=True`` is ever loosened.
+    if args.subcmd == "emit":
+        _cmd_log(args.message, args.level, args.output)
+        return
+    sys.stderr.write(f"errortools: unknown logger subcommand {args.subcmd!r}\n")
+    sys.exit(2)
+
+
+def _dispatch_errortools(args: argparse.Namespace) -> None:
+    """Run the action selected by a flag on the ``errortools`` family."""
+    for flag, action in _FLAG_ACTIONS.items():
+        if getattr(args, flag, False):
+            action()
+            return
+    # No flag supplied → render the help screen.
+    _build_errortools_parser().parse_args(["--help"])
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """Module entry point dispatched to the active CLI family."""
+    if argv is None:
+        argv = sys.argv[1:]
+    args = parse_args(argv)
+
+    if _CLI_MODE == "logger":
+        _dispatch_logger(args)
+        return
+
+    _dispatch_errortools(args)
+
+
+if __name__ == "__main__":
+    main()

{errortools-3.4.0 → errortools-3.5.0}/_errortools/future.py

@@ -17,10 +17,12 @@ try:
     )
 except ImportError:
 
-    def fast_append_exception(lst, exc) -> None:
+    def fast_append_exception(lst: list[BaseException], exc: BaseException) -> None:
         lst.append(exc)
 
-    def fast_suppress_exit(typ, excs) -> bool:
+    def fast_suppress_exit(
+        typ: type[BaseException] | None, excs: type[BaseException] | tuple[type[BaseException], ...]
+    ) -> bool:
         return typ is not None and issubclass(typ, excs)
 
 

{errortools-3.4.0 → errortools-3.5.0}/_errortools/ignore.py

@@ -79,6 +79,9 @@ ignore = ErrorIgnoreWrapper
         -  `ignore_subclass` — suppress exceptions including subclasses
         -  `retry` — automatic retry on exception
     """
+# NOTE: Any exception raised inside the ``with`` block that is an instance of one
+# of *errors* is caught and discarded.  All other exceptions propagate
+# unchanged.  Execution resumes after the ``with`` block.
 
 
 class fast_ignore:
@@ -135,6 +138,10 @@ def ignore_subclass(base: ExceptionType) -> Iterator[None]:
         ...     raise IndexError("out of range")  # IndexError ⊆ LookupError
         ... # suppressed — execution continues here
     """
+    # NOTE: Similar to `ignore`, but accepts a single base class and suppresses
+    # every exception whose type satisfies ``issubclass(type(exc), base)``.
+    # Useful when you want to express intent explicitly — "ignore anything
+    # derived from X" — rather than listing concrete types.
     try:
         yield
     except BaseException as exc:
@@ -155,6 +162,9 @@ def ignore_warns(*categories: type[Warning]) -> Iterator[None]:
         ...     warnings.warn("old api", DeprecationWarning)
         ... # no warning emitted
     """
+    # NOTE: Uses `warnings.catch_warnings` and `warnings.simplefilter`
+    # to silence any warning whose category is one of *categories* for the
+    # duration of the ``with`` block.  All other warnings are unaffected.
     with warnings.catch_warnings():
         for category in categories:
             warnings.filterwarnings("ignore", category=category)

{errortools-3.4.0 → errortools-3.5.0}/_errortools/logging/sink.py

@@ -89,7 +89,7 @@ class BaseSink(ABC):
     def emit(self, record: Record) -> None:
         """Write *record* to this sink."""
 
-    def close(self) -> None:
+    def close(self) -> None:  # noqa: B027
         """Optional cleanup called when sink is removed."""
 
 

{errortools-3.4.0 → errortools-3.5.0}/_errortools/metadata.py

@@ -12,3 +12,20 @@ __fullname__ = na.generate_name(__title__, __author__)
 __slug__ = na.generate_slug(__title__, __author__)
 __signature__ = na.generate_signature(__title__, __author__)
 __uid__ = na.generate_id(__title__, __author__)
+
+if __name__ == "__main__":
+    show_items: list[tuple[str, str]] = [
+        ("author", __author__),
+        ("author email", __author_email__),
+        ("title", __title__),
+        ("description", __description__),
+        ("license", __license__),
+        ("url", __url__),
+        ("fullname", __fullname__),
+        ("slug", __slug__),
+        ("signature", __signature__),
+        ("uid", __uid__),
+    ]
+
+    for label, value in show_items:
+        print(f"{label}: {value}")

{errortools-3.4.0 → errortools-3.5.0}/_errortools/plugins.py

@@ -132,3 +132,7 @@ class Registry:
     @staticmethod
     def clear() -> None:
         clear()
+
+
+if __name__ == "__main__":
+    print(f"All plugins: {list_all()}")