exceptiongroup

This is a clean backport of PEP 654's ExceptionGroup functionality to Python <3.11. In practice, it's straightforward to use - you can aggregate multiple exceptions and handle them with `except*` syntax (or `catch()` for older Python). The library has virtually no attack surface since it's pure exception handling logic with no external dependencies, network calls, or file I/O.

From a security perspective, this package is refreshingly minimal. Exception messages and tracebacks behave as you'd expect - no surprises with information leakage beyond what standard Python exceptions already expose. The library doesn't add magic or hidden state. Input validation is inherent to the design: you pass exception objects, and the type system handles the rest.

One gotcha: when migrating code to use exception groups, you need to audit your error handling carefully. Bare `except Exception` clauses won't catch ExceptionGroup by design, which can lead to unhandled exceptions bubbling up if you're not thorough. This is architecturally correct but requires discipline during adoption.

This is a straightforward backport of PEP 654's exception groups for Python <3.11. From a security perspective, it's low-risk - it's purely structural code that wraps exceptions without introducing new I/O, network calls, or dependencies. The library has zero external dependencies, which is excellent for supply chain risk mitigation.

In practice, it handles exception aggregation cleanly, especially useful when dealing with concurrent operations or validation failures where you want to collect multiple errors before raising. The API mirrors Python 3.11+'s native implementation exactly, making migration smooth. Exception messages are well-formed and don't leak sensitive data by default - you control what goes into each exception.

One practical concern: exception groups can make debugging harder if you're not careful about how you structure error handling. Stack traces become nested, and if you're logging exceptions automatically, ensure your logging framework handles ExceptionGroup properly or you'll get incomplete error reports. The library itself is sound, but teams need to update their error handling patterns accordingly.

This is a straightforward backport of PEP 654's ExceptionGroup and except* syntax support for Python versions before 3.11. In production, it's been rock-solid with zero runtime overhead beyond the exception handling itself. Memory footprint is negligible - it's essentially just the exception tree structure you'd naturally have anyway.

The API is identical to Python 3.11+'s built-in implementation, which means your code seamlessly transitions when you eventually upgrade. The library handles nested exception groups cleanly, preserving tracebacks properly for debugging. I've used it extensively in async codebases where TaskGroups raise multiple exceptions concurrently, and the error propagation is predictable and observable.

One gotcha: the except* syntax requires special handling pre-3.11, so you'll need to use the .split() and .subgroup() methods directly rather than the syntactic sugar. Documentation could be better on performance characteristics when dealing with deeply nested exception trees, but in practice I haven't hit issues even with hundreds of grouped exceptions.