DataExcept 0.4.0__tar.gz → 0.4.2__tar.gz

{dataexcept-0.4.0 → dataexcept-0.4.2}/CHANGELOG.md

@@ -7,6 +7,168 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.2] - 2026-08-25
+
+### Changed
+
+- `SECURITY.md` states two further boundaries rather than leaving them to be
+  discovered: state attached to an exception *after* it is constructed is not
+  swept, and a URL nested inside a value you pass is rendered redacted but the
+  object itself is not rewritten. Walking and rewriting arbitrary caller data
+  structures would be a surprising thing for an exception library to do, and
+  could not be complete anyway.
+
+### Fixed
+
+- **Sensitive query parameters are matched by token, not substring.** The
+  substring rule was wrong in both directions: it redacted `monkey`, `design`,
+  `assign`, `keyword` and `authors`, mangling ordinary debugging information,
+  while still missing `passphrase`. Parameter names are now split on
+  separators and camelCase and matched word by word, so `X-Amz-Signature`,
+  `accessToken` and `client_secret` are caught and `?monkey=bobo` is left
+  alone.
+
+### Security
+
+- **`jwt`, `bearer`, `hmac` and `sas` are recognised as secret parameter
+  names.** Checked the token set against the parameters actually used by AWS
+  SigV4, Azure SAS, Google Cloud and OAuth 2: the signature and credential
+  parameters were already covered, but those four were not. `code`, `state`,
+  `nonce` and `client_id` are deliberately still ignored — an OAuth code is a
+  secret, but the name is far more often a country code, an HTTP status or a
+  discount code, and redacting those would destroy more than it protects.
+- **Three ways a URL could still reach a message, all closed.** The redaction
+  boundary scrubbed the message and a handful of named fields, but 18 classes
+  interpolate some *other* attribute into `__str__` — a field, a column, a
+  resource — and a caller can put a URL in any of them. Every stored string is
+  now swept, so no class leaks a credential-bearing URL through its message,
+  its attributes or its `args`. A test fills every string argument of every
+  class with one and checks all three surfaces.
+- Two classes assigned their attributes *after* calling `super().__init__`, so
+  the sweep never saw them. Both now assign first, and a test fails if any
+  constructor does it again.
+- The URL pattern carried a `` anchor, so a URL directly following a word
+  character was never matched — including `feature_https://...`, the step name
+  `FeaturePreprocessingError` builds from its own argument.
+
+## [0.4.1] - 2026-08-25
+
+### Added
+
+- Tests that derive the facts stated in more than one file, instead of trusting
+  them to be copied correctly: the citation, security policy, changelog and
+  checklist must all name the current version, checklist sections must be
+  numbered uniquely, no document may quote a test count, and the supported
+  Python range must agree across `requires-python`, the classifiers, the CI
+  matrix and the release gate.
+- A contract-coverage test. The whole-hierarchy suites called `pytest.skip()`
+  when they could not build a class, so a class could sit outside the pickling,
+  message and inheritance guarantees with CI still green — and two were doing
+  exactly that. Skipping now requires an explicit, reasoned entry in an
+  exclusion table, which is empty.
+
+- **Python 3.14 support.** `requires-python` capped at `<3.14`, so the package
+  refused to install on the current stable interpreter — 3.14 was released in
+  October 2025 and is no longer upcoming. The range is now `>=3.10,<3.15`, 3.14
+  is in the classifiers and the CI matrix, and `test (3.14)` joins the checks
+  the release workflow requires before it will build.
+
+### Changed
+
+- `SECURITY.md` states the boundary precisely, including what is **not**
+  covered: a bare non-URL secret written into free-form text cannot be
+  recognised. The previous wording claimed credentials "never appear ...
+  whatever you pass in", which was broader than the implementation.
+
+- The serialization and hierarchy guarantees are stated more precisely.
+  "Survives a process boundary intact" now says what happens to state that
+  cannot be serialized, and "catches anything this package raises" is now
+  "every operational exception" — constructors deliberately raise plain
+  `TypeError` for invalid arguments, which sits outside the hierarchy.
+
+### Fixed
+
+- **An exception pickled by 0.4.0 could not be loaded by 0.4.1.** Restoring the
+  chain added three parameters to the private `_rebuild`, and an older payload
+  passes only three arguments — so a queued exception that outlived an upgrade,
+  or one sent by a worker on the previous release, raised `TypeError` on
+  unpickling. The new parameters carry defaults.
+
+- The test probe fed a bare string to `Sequence[str]` parameters, so
+  `DataFormatError` and `DtypeMismatchError` correctly rejected it and were
+  silently skipped. The probe builds them properly now; nothing is skipped.
+- `is_number` accepted booleans, because `bool` subclasses `int` and so
+  satisfies `numbers.Real`. A boolean is never a meaningful metric, threshold
+  or ratio, and accepting one hid a caller passing the wrong variable.
+- `MergeKeyError("id", "cust_id")` silently became `['i', 'd']` — a bare string
+  is a sequence of strings. It now raises `TypeError`, matching
+  `DtypeMismatchError`, which already rejected this.
+- `SECURITY.md` named 0.3.x as supported at 0.4.0, `CHECKLIST.md` was dated to
+  the previous release and numbered two sections 12, and the README quoted a
+  test count that no longer matched. `scripts/bump_version.py` now writes every
+  file that states the version, so they cannot drift apart by hand again.
+- `black`'s target version is pinned rather than inferred from
+  `requires-python`. Adding 3.14 made inference pick `py314`, and black then
+  refused to verify its own output when run on an older interpreter — which is
+  what CI does.
+
+- **Exception chaining was lost on a pickle round trip.** `__reduce__` saved
+  `args` and `__dict__`, but `__cause__`, `__context__` and
+  `__suppress_context__` are special exception state rather than `__dict__`
+  entries — so a wrapped exception rebuilt in another process no longer showed
+  what actually failed. All three are now restored explicitly. The 0.4.0 tests
+  did not catch this because they compared `args`, rendered text and `__dict__`
+  and never the chain; they now check it.
+- **An exception carrying unpickleable state could not cross a process
+  boundary at all.** Several classes accept arbitrary caller state, so a
+  lambda, generator, open file or locally defined class made the whole
+  exception unserializable — replacing the real failure with a serialization
+  error about it. Such values are now replaced by an `UnpicklableValue`
+  describing what was there, and an unpickleable cause by an
+  `UnpicklableCause`, so the exception still arrives.
+
+### Security
+
+- **Redaction is no longer defeated by the traceback.** `log_exception` passed
+  `exc_info`, so logging rendered the whole exception chain — including a
+  wrapped third-party exception whose own message still quoted the
+  credential-bearing URL. Redacting what DataExcept renders did nothing about
+  that. When the chain contains a URL, `log_exception` now formats the
+  traceback and scrubs it; every other exception keeps the structured
+  `exc_info` path, so nothing changes for them.
+- `SECURITY.md` documents what remains outside that boundary: the wrapped
+  exception object is still reachable, so `traceback.print_exc()`,
+  `repr(exc.__dict__)` or `logger.error(..., exc_info=True)` will render its
+  text. A third-party exception's message is not ours to rewrite.
+
+- **Every GitHub Action is pinned to a full-length commit SHA.** All 34
+  references used mutable tags, including `pypa/gh-action-pypi-publish` in the
+  OIDC publishing job — the step that holds the credential which uploads to
+  PyPI. Whoever controls an action repository can move a tag to different code
+  at any time; a commit SHA is the only immutable reference. Each pin carries
+  the version in a trailing comment so it stays reviewable and Dependabot can
+  still update it, and a test fails if any mutable reference reappears.
+
+- **Credentials in a URL path are now redacted.** `redact_url` kept the whole
+  path, so `WebhookError` logged a Slack webhook URL — which Slack documents as
+  a secret in its entirety — unchanged. Where the path *is* the credential the
+  path is now dropped, keeping the host, which is what makes the error
+  actionable.
+- **Sensitive parameters are matched by substring, not an exact allowlist.**
+  `X-Amz-Signature`, `X-Amz-Credential`, `auth_token` and `refresh_token` all
+  passed through before. Fragments are covered too, so an OAuth
+  `#access_token=` no longer survives.
+- **A secret can no longer be reintroduced after redaction.** Redacting only
+  the structured argument left two open routes: a caller-supplied `message`,
+  and the text of a wrapped exception quoting the original URL. Every message
+  in the hierarchy now passes through one scrubbing boundary, so a URL is
+  redacted wherever it appears. Where the library was handed the secret
+  explicitly, that exact value is removed from the message as well.
+- **URL-bearing fields beyond the four patched classes are redacted.**
+  `DataLoadingError.source` documents itself as "file path, URL" and rendered
+  a presigned S3 URL verbatim. Nine such fields now use `redact_if_url`, which
+  leaves ordinary file paths untouched.
+
 ## [0.4.0] - 2026-08-24
 
 ### Added
@@ -236,7 +398,6 @@ project description, and its quick-start example did not run.
 - `examples/example_usage.py` raised `TimeoutError` with keyword arguments the
   builtin does not accept — a live instance of the shadowing hazard.
 
-
 ## [0.1.0] - 2026-08-24
 
 First public release.
@@ -268,7 +429,9 @@ First public release.
 - Published to PyPI via OIDC trusted publishing; no long-lived API token is
   involved in a release.
 
-[Unreleased]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.4.2...HEAD
+[0.4.2]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/DiogoRibeiro7/DataExcept/compare/v0.2.0...v0.2.1

{dataexcept-0.4.0 → dataexcept-0.4.2}/CITATION.cff

@@ -1,7 +1,7 @@
 cff-version: 1.2.0
 message: "If you use this software, please cite it using the following metadata."
 title: "DataExcept"
-version: "0.4.0"
+version: "0.4.2"
 authors:
   - family-names: "Ribeiro"
     given-names: "Diogo"
@@ -11,4 +11,4 @@ authors:
 type: software
 url: "https://github.com/DiogoRibeiro7/DataExcept"
 repository-code: "https://github.com/DiogoRibeiro7/DataExcept"
-date-released: "2026-08-24"
+date-released: "2026-08-25"

{dataexcept-0.4.0 → dataexcept-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DataExcept
-Version: 0.4.0
+Version: 0.4.2
 Summary: A Python package providing structured, easily-extendable custom exception types.
 License-Expression: MIT
 License-File: LICENSE
@@ -9,13 +9,14 @@ Author: Diogo Ribeiro
 Author-email: dfr@esmad.ipp.pt
 Maintainer: Diogo Ribeiro
 Maintainer-email: diogo.debastos.ribeiro@gmail.com
-Requires-Python: >=3.10,<3.14
+Requires-Python: >=3.10,<3.15
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: tomli ; python_version < "3.11"
 Project-URL: Changelog, https://github.com/DiogoRibeiro7/DataExcept/releases
 Project-URL: Documentation, https://diogoribeiro7.github.io/DataExcept/
@@ -41,13 +42,13 @@ Description-Content-Type: text/markdown
 
 ## 🎯 Key Features
 
-- **🏗️ Hierarchical Structure**: Catch one specific error, a whole domain, or everything via `DataExceptError`
+- **🏗️ Hierarchical Structure**: Catch one specific error, a whole domain, or every operational error via `DataExceptError`
 - **📦 One Import**: Every exception is available from `dataexcept` directly, or from its domain module — same objects either way
-- **📊 Data Science Focused**: 99 exception classes covering ML pipelines, feature engineering, model training
-- **🔧 Production Ready**: Logging helpers, error context, and exceptions that survive a process boundary intact
+- **📊 Data Science Focused**: 100 exception classes covering ML pipelines, feature engineering, model training
+- **🔧 Production Ready**: Logging helpers, error context, and exceptions that pickle — so they cross a process boundary with their message, attributes and cause intact
 - **📚 Academic Quality**: Proper documentation, type hints, and citation support
-- **🐍 Python 3.10+**: Modern Python with full type safety
-- **🧪 Well Tested**: 690+ tests at 92% branch coverage of the package, gated in CI
+- **🐍 Python 3.10 – 3.14**: Every supported version tested in CI, with full type safety
+- **🧪 Well Tested**: Full branch coverage of the package gated in CI, with contract tests over every exception class
 
 ## 📦 Quick Installation
 
@@ -213,7 +214,7 @@ except Exception as exc:
 ### Command Line Interface
 
 ```bash
-# List every exception class the package exports (99 of them, alphabetically)
+# List every exception class the package exports (100 of them, alphabetically)
 $ dataexcept list
 ApiError
 AuthenticationError
@@ -224,7 +225,7 @@ BiasDetectionError
 
 # Check version
 $ dataexcept --version
-dataexcept 0.4.0
+dataexcept 0.4.2
 ```
 
 ## 🎯 Use Cases
@@ -374,7 +375,7 @@ If you use DataExcept in your research, please cite it:
   author = {Ribeiro, Diogo},
   title = {DataExcept: Structured Exception Handling for Data Science},
   url = {https://github.com/DiogoRibeiro7/DataExcept},
-  version = {0.4.0},
+  version = {0.4.2},
   year = {2026},
   publisher = {GitHub}
 }

{dataexcept-0.4.0 → dataexcept-0.4.2}/README.md

@@ -15,13 +15,13 @@
 
 ## 🎯 Key Features
 
-- **🏗️ Hierarchical Structure**: Catch one specific error, a whole domain, or everything via `DataExceptError`
+- **🏗️ Hierarchical Structure**: Catch one specific error, a whole domain, or every operational error via `DataExceptError`
 - **📦 One Import**: Every exception is available from `dataexcept` directly, or from its domain module — same objects either way
-- **📊 Data Science Focused**: 99 exception classes covering ML pipelines, feature engineering, model training
-- **🔧 Production Ready**: Logging helpers, error context, and exceptions that survive a process boundary intact
+- **📊 Data Science Focused**: 100 exception classes covering ML pipelines, feature engineering, model training
+- **🔧 Production Ready**: Logging helpers, error context, and exceptions that pickle — so they cross a process boundary with their message, attributes and cause intact
 - **📚 Academic Quality**: Proper documentation, type hints, and citation support
-- **🐍 Python 3.10+**: Modern Python with full type safety
-- **🧪 Well Tested**: 690+ tests at 92% branch coverage of the package, gated in CI
+- **🐍 Python 3.10 – 3.14**: Every supported version tested in CI, with full type safety
+- **🧪 Well Tested**: Full branch coverage of the package gated in CI, with contract tests over every exception class
 
 ## 📦 Quick Installation
 
@@ -187,7 +187,7 @@ except Exception as exc:
 ### Command Line Interface
 
 ```bash
-# List every exception class the package exports (99 of them, alphabetically)
+# List every exception class the package exports (100 of them, alphabetically)
 $ dataexcept list
 ApiError
 AuthenticationError
@@ -198,7 +198,7 @@ BiasDetectionError
 
 # Check version
 $ dataexcept --version
-dataexcept 0.4.0
+dataexcept 0.4.2
 ```
 
 ## 🎯 Use Cases
@@ -348,7 +348,7 @@ If you use DataExcept in your research, please cite it:
   author = {Ribeiro, Diogo},
   title = {DataExcept: Structured Exception Handling for Data Science},
   url = {https://github.com/DiogoRibeiro7/DataExcept},
-  version = {0.4.0},
+  version = {0.4.2},
   year = {2026},
   publisher = {GitHub}
 }

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/__init__.py

@@ -38,7 +38,7 @@ from . import (  # noqa: F401
     security_exceptions,
 )
 from ._deprecation import resolve_deprecated
-from .base import DataExceptError
+from .base import DataExceptError, UnpicklableCause, UnpicklableValue
 from .database_exceptions import (
     DatabaseConnectionError,
     DatabaseError,
@@ -163,8 +163,12 @@ from .security_exceptions import (
 )
 
 __all__ = [
-    # The root of the hierarchy: catches anything this package raises.
+    # The root of the hierarchy: catches every operational exception the
+    # package raises.
     "DataExceptError",
+    # Placeholders for state that could not survive serialization.
+    "UnpicklableCause",
+    "UnpicklableValue",
     # Every exception class the package defines.
     "ApiError",
     "AuthenticationError",

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/_validation.py

@@ -15,8 +15,14 @@ def is_number(value: object) -> bool:
     science. ``numbers.Real`` accepts them because NumPy registers its scalar
     types with the ABC, and it needs no dependency on NumPy to do so.
 
+    Booleans are excluded: ``bool`` subclasses ``int``, so ``numbers.Real``
+    would accept ``True`` as a metric.
+
     This is a function rather than an inline ``isinstance`` because narrowing a
     value to ``numbers.Real`` defeats mypy's inference for the rest of the
     enclosing class.
     """
-    return isinstance(value, numbers.Real)
+    # bool subclasses int, so numbers.Real accepts True and False. A boolean
+    # is never a meaningful metric, threshold or ratio, and accepting one hides
+    # a caller passing the wrong variable.
+    return not isinstance(value, bool) and isinstance(value, numbers.Real)

dataexcept-0.4.2/dataexcept/base.py

@@ -0,0 +1,195 @@
+"""The root of the DataExcept exception hierarchy.
+
+Every operational exception this package defines derives from
+:class:`DataExceptError`, so a caller can catch the whole library with one
+clause while still catching narrowly where it matters::
+
+    try:
+        run_pipeline()
+    except ValidationError:
+        ...              # exactly this failure
+    except DataExceptError:
+        ...              # anything else DataExcept raised
+
+(Constructors also raise plain ``TypeError`` when given invalid arguments.
+Those are programming errors, not operational ones, and are deliberately not
+part of this hierarchy.)
+
+The base also carries the serialization contract for the hierarchy. Two
+problems make that necessary:
+
+* Most constructors take several arguments while ``Exception.args`` holds only
+  the rendered message, so the default protocol -- which replays ``args``
+  through ``__init__`` -- cannot rebuild them.
+* Several exceptions accept arbitrary caller state (``DataValidationError``
+  takes any ``value``), and that state may not be pickleable at all.
+
+An exception that cannot cross a process boundary is useless exactly where a
+data pipeline needs it most, so rather than fail, unpickleable state is
+replaced by a description of what was there.
+"""
+
+from __future__ import annotations
+
+import pickle
+from typing import Any, Dict, Optional, Tuple, Type
+
+from .redaction import redact_urls_in_text
+
+__all__ = ["DataExceptError", "UnpicklableCause", "UnpicklableValue"]
+
+#: Attribute names used across the package to hold the exception that caused
+#: this one. Checked in order; the first that holds an exception wins.
+_CAUSE_ATTRIBUTES = ("original", "original_exception", "cause")
+
+
+class UnpicklableValue:
+    """Stands in for state that could not survive serialization.
+
+    An exception carrying a lambda, an open file or a lock would otherwise be
+    unraisable across a process boundary. Keeping a description preserves what
+    the value was for debugging, which is the reason it was attached.
+    """
+
+    __slots__ = ("description",)
+
+    def __init__(self, description: str) -> None:
+        self.description = description
+
+    def __repr__(self) -> str:
+        return f"<unpicklable: {self.description}>"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, UnpicklableValue)
+            and other.description == self.description
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.description)
+
+
+def _safe(value: Any) -> Any:
+    """Return *value*, or a placeholder if it cannot be pickled."""
+    try:
+        pickle.dumps(value)
+    except Exception:
+        try:
+            description = f"{type(value).__name__}: {value!r}"
+        except Exception:  # pragma: no cover - a repr that itself raises
+            description = type(value).__name__
+        return UnpicklableValue(description[:200])
+    return value
+
+
+def _safe_exception(exc: Optional[BaseException]) -> Optional[BaseException]:
+    """Return *exc*, or an exception describing it if it cannot be pickled."""
+    if exc is None:
+        return None
+    try:
+        pickle.dumps(exc)
+    except Exception:
+        return UnpicklableCause(f"{type(exc).__name__}: {exc}")
+    return exc
+
+
+def _rebuild(
+    cls: Type["DataExceptError"],
+    args: Tuple[Any, ...],
+    state: Dict[str, Any],
+    cause: Optional[BaseException] = None,
+    context: Optional[BaseException] = None,
+    suppress_context: bool = False,
+) -> "DataExceptError":
+    """Recreate *cls* without replaying its ``__init__``.
+
+    Constructors validate and render a message from their arguments; replaying
+    them would need those arguments, which ``args`` does not carry. Restoring
+    ``args`` and ``__dict__`` directly reproduces the exception exactly.
+
+    The three chain arguments carry defaults so that a payload pickled by an
+    earlier version -- which passed only ``cls``, ``args`` and ``state`` --
+    still loads. An exception can outlive an upgrade: it may sit in a task
+    queue, or be sent by a worker running the previous release.
+
+    ``__cause__``, ``__context__`` and ``__suppress_context__`` live outside
+    ``__dict__`` -- they are special exception state -- so they are restored
+    explicitly. Without this the chain is silently lost, and a traceback
+    rebuilt in another process no longer shows what actually failed.
+    """
+    exc = cls.__new__(cls)
+    Exception.__init__(exc, *args)
+    exc.__dict__.update(state)
+    exc.__cause__ = cause
+    exc.__context__ = context
+    exc.__suppress_context__ = suppress_context
+    return exc
+
+
+class DataExceptError(Exception):
+    """Base class for every operational exception DataExcept raises."""
+
+    #: Passed to redact_urls_in_text when scrubbing this class's message.
+    #: WebhookError sets it False, because a webhook URL's path *is* the
+    #: credential.
+    _keep_url_path = True
+
+    def __init__(self, *args: Any) -> None:
+        # One boundary for the whole hierarchy. Whatever built the message -- a
+        # constructor, a caller-supplied `message`, or the text of a wrapped
+        # exception quoting the original URL -- it is scrubbed here, because
+        # redacting only the structured argument leaves all three routes open.
+        keep_path = type(self)._keep_url_path
+        if args and isinstance(args[0], str):
+            args = (redact_urls_in_text(args[0], keep_path=keep_path),) + args[1:]
+
+        # Many classes store the message on self.message and render *that* in
+        # __str__, and 18 interpolate some other attribute -- a field, a
+        # column, a resource -- any of which a caller can fill with a URL. So
+        # every stored string is swept, not just the message.
+        #
+        # redact_urls_in_text rather than redact_if_url: a message has the URL
+        # embedded in prose, and redact_if_url only handles a value that is
+        # wholly a URL. It is a no-op on anything without "://" in it, so
+        # ordinary names and file paths are untouched.
+        for name, value in list(self.__dict__.items()):
+            if isinstance(value, str) and "://" in value:
+                self.__dict__[name] = redact_urls_in_text(value, keep_path=keep_path)
+
+        super().__init__(*args)
+        # Constructors that wrap another exception record it on an attribute.
+        # Mirroring it into __cause__ is what makes a traceback print the
+        # underlying failure, exactly as `raise ... from exc` would; assigning
+        # __cause__ also sets __suppress_context__, as `raise from` does.
+        for attribute in _CAUSE_ATTRIBUTES:
+            candidate = getattr(self, attribute, None)
+            if isinstance(candidate, BaseException):
+                self.__cause__ = candidate
+                break
+
+    def __reduce__(self) -> Tuple[Any, Tuple[Any, ...]]:
+        args = tuple(_safe(arg) for arg in self.args)
+        state = {key: _safe(value) for key, value in self.__dict__.items()}
+        return (
+            _rebuild,
+            (
+                type(self),
+                args,
+                state,
+                _safe_exception(self.__cause__),
+                _safe_exception(self.__context__),
+                self.__suppress_context__,
+            ),
+        )
+
+
+class UnpicklableCause(DataExceptError):
+    """Stands in for a cause that could not be serialized.
+
+    ``__cause__`` and ``__context__`` must be exceptions, so the placeholder
+    used for ordinary attributes will not do here. Dropping the chain instead
+    would silently lose the reason for the failure.
+    """

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/dataengineering_exceptions.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Optional
 
 from .base import DataExceptError
+from .redaction import redact_if_url
 
 
 class DataEngineeringError(DataExceptError):
@@ -111,7 +112,7 @@ class MissingPartitionError(DataEngineeringError):
             message: Optional custom error message.
         """
         self.partition = partition
-        self.location = location
+        self.location = redact_if_url(location)
         default = f"Partition '{partition}' not found at {location}"
         super().__init__(message or default)
 

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/datascience_exceptions/ingestion.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Optional, Sequence
 
 from .._validation import is_number
+from ..redaction import redact_if_url
 from .base import DataScienceError
 
 
@@ -26,7 +27,7 @@ class DataLoadingError(DataScienceError):
             )
 
         message = f"Failed to load data from {source!r}: {original}"
-        self.source = source
+        self.source = redact_if_url(source)
         self.original = original
         super().__init__(message)
 

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/datascience_exceptions/operations.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Optional
 
 from .._validation import is_number
+from ..redaction import redact_if_url
 from .base import DataScienceError
 
 
@@ -26,7 +27,7 @@ class ModelSerializationError(DataScienceError):
             )
 
         message = f"Failed to serialize to {path!r}: {original}"
-        self.path = path
+        self.path = redact_if_url(path)
         self.original = original
         super().__init__(message)
 

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/datascience_exceptions/training.py

@@ -69,8 +69,10 @@ class ConvergenceError(ModelTrainingError):
                 f"Model '{model_type}' failed to converge after "
                 f"{iterations} iterations"
             )
-        super().__init__(model_type=model_type, epoch=None, message=message)
+        # Assigned before super(): DataExceptError.__init__ sweeps the stored
+        # strings for URLs, and anything set afterwards escapes that.
         self.iterations = iterations
+        super().__init__(model_type=model_type, epoch=None, message=message)
 
     def __str__(self) -> str:
         return f"[ConvergenceError] {self.message}"

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/exceptions/notification.py

@@ -41,9 +41,14 @@ class EmailError(NotificationError):
 class WebhookError(NotificationError):
     """Raised when a webhook POST fails."""
 
+    # Slack, Discord and others put the secret in the webhook path, so keeping
+    # the path would defeat the redaction. This also applies to the scrubbing
+    # of the whole message, which is how a wrapped HTTP exception quoting the
+    # original URL gets its path dropped too.
+    _keep_url_path = False
+
     def __init__(self, url: str, original_exception: Exception | None = None):
-        # Webhook URLs commonly authenticate through a query parameter.
-        self.url = redact_url(url)
+        self.url = redact_url(url, keep_path=False)
         # original_exception is set by NotificationError.__init__ below.
         msg = f"Webhook to URL '{self.url}' failed"
         if original_exception:

{dataexcept-0.4.0 → dataexcept-0.4.2}/dataexcept/io_exceptions.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from .base import DataExceptError
+from .redaction import redact_if_url
 
 
 class CustomIOError(DataExceptError):
@@ -21,7 +22,7 @@ class FileReadError(CustomIOError):
             path: File path that could not be read.
             original: Optional underlying exception.
         """
-        self.path = path
+        self.path = redact_if_url(path)
         self.original = original
         msg = f"Failed to read file '{path}'"
         if original:
@@ -39,7 +40,7 @@ class FileWriteError(CustomIOError):
             path: File path that could not be written to.
             original: Optional underlying exception.
         """
-        self.path = path
+        self.path = redact_if_url(path)
         self.original = original
         msg = f"Failed to write file '{path}'"
         if original:
@@ -56,7 +57,7 @@ class FileLockError(CustomIOError):
         Args:
             path: Path of the lock file.
         """
-        self.path = path
+        self.path = redact_if_url(path)
         super().__init__(f"Unable to obtain lock for '{path}'")