aiosignal

aiosignal is a straightforward implementation of async signal/event handling, primarily used as a dependency for aiohttp rather than a standalone library. The API is simple: create a Signal, register async callbacks with `connect()`, and trigger them with `send()`. It works reliably for basic pub-sub patterns in async code, but that's where the positives end from a developer experience perspective.

The documentation is extremely sparse - essentially just API reference with minimal examples. There's no tutorial explaining common patterns, error handling strategies, or how to debug issues when callbacks don't fire as expected. When you make mistakes like forgetting to await `send()`, the error messages don't provide helpful context. Stack Overflow has almost no aiosignal-specific questions, and GitHub issues are mostly related to aiohttp integration.

For day-to-day usage, you'll likely spend time figuring out patterns that should be documented. The library is stable and does what it says, but if you need a signal/event system with better onboarding, consider blinker or PyPubSub which have more comprehensive documentation and examples.

aiosignal provides a straightforward implementation of async signal/callback management, primarily used as a dependency for aiohttp. The core API is simple: create a Signal, register async callbacks with `connect()`, and trigger them with `send()`. It works reliably for basic pub-sub patterns in asyncio applications.

The developer experience leaves much to be desired. Type hints exist but are incomplete - the Signal class uses generic TypeVar bounds that don't provide meaningful IDE completion for your actual callback signatures. Documentation is extremely sparse, essentially just docstrings with minimal examples. You'll spend time reading the source code (thankfully it's small) to understand nuances like frozen signals or how kwargs are passed through.

Error handling is basic but adequate. If a callback raises an exception, it propagates clearly. The package does what it advertises but feels more like an internal utility that was extracted rather than a thoughtfully designed public API. For simple use cases it's fine, but consider alternatives like blinker or PyPubSub if you need richer features or better ergonomics.

In production, aiosignal is refreshingly simple - it's essentially a callback registry with async support. The API surface is tiny: Signal objects that you can send() to notify all registered callbacks. Memory footprint is negligible, and there's zero overhead when signals aren't registered. I've used it extensively in middleware chains and lifecycle hooks where components need to react to events without tight coupling.

Performance characteristics are excellent - callbacks execute sequentially in registration order, which is predictable for logging and metrics hooks. Error handling is straightforward: exceptions in one callback don't prevent others from firing, though you need to handle propagation yourself. No connection pools or resource management to worry about since it's purely in-memory callback coordination.

The main gotcha is understanding frozen vs non-frozen signals. Frozen signals prevent new registrations after first send(), which caught me once in hot-reload scenarios. Documentation is sparse but the codebase is small enough to read directly. No retry logic or timeout handling - that's your responsibility in callbacks.