airtai/faststream

Features

• Decorator-Based Routing - Uses function decorators to bind application logic to broker topics for automated event consumption and production.
• Message Broker Consumers - Uses decorator-based interfaces to handle the consumption and production of data across various message brokers.
• Broker Integrations - Provides a consistent API for interacting with multiple message brokers while maintaining access to native provider-specific features.
• Microservices Development - Builds asynchronous, message-based microservices that communicate through brokers using a unified Python interface.
• Messaging Broker Emulators - Redirects publishers and subscribers to an in-memory broker to enable rapid testing without external infrastructure.
• Data Serialization and Parsing - Validates and serializes incoming message payloads into typed objects using schema definitions.
• Kafka Client Integrations - Integrates with multiple Kafka client libraries to provide a unified interface for producing and consuming messages.
• Kafka Message Production - Provides asynchronous Kafka producer interfaces for reliable event-driven communication.
• Kafka Producer and Consumer Utilities - Implements asynchronous Kafka consumer utilities for real-time event processing.
• Structured Message Serialization - Transforms structured Python objects into encoded messages using configurable serialization libraries.
• Event-Driven Application Launchers - Supports hot-reloading and horizontal scaling of event-driven applications across multiple worker processes via the command line.
• Message Schemas - Provides structured data models that enforce type safety and validation for both incoming and outgoing messages across different services.
• Dependency-Injected Configurations - Stores and retrieves runtime objects within message-processing scopes using a dependency injection container.
• Dependency Injection Containers - Provides a built-in dependency injection container to manage and resolve application resources at runtime.
• Dependency Injection Systems - Resolves and provides required resources to message handlers at runtime through a centralized dependency injection container.
• Message Brokers - Supports publishing messages to queues and exchanges using structured data models and native objects.
• Message Processing Pipelines - Links subscriber and publisher decorators to automatically process incoming messages and forward the results to downstream channels.
• Protocol Acknowledgements - Controls the lifecycle of message processing by manually confirming, rejecting, or negatively acknowledging messages.
• Message Brokers - Provides a unified interface for publishing messages to various broker types to facilitate service communication.
• Message Persistence Systems - Persists message streams to ensure data availability for consumers during downtime or after processing.
• Protocol Acknowledgements - Controls message acknowledgment and rejection policies to ensure reliable delivery and error handling.
• Broker Abstractions - Offers a unified interface for interacting with multiple message broker backends while maintaining access to native provider-specific features.
• Event-Driven Frameworks - Provides an asynchronous framework for building event-driven applications with integrated message broker support and dependency injection.
• Application Lifecycle Management - Coordinates message broker startup and shutdown sequences in sync with ASGI web application lifecycles.
• Data Validation Schemas - Provides schema-based validation and type-safe parsing for message payloads using type annotations and data models.
• Dependency Injection Containers - Resolves and injects required resources into message handlers automatically based on function signatures at runtime.
• Dependency Injection Providers - Automatically resolves and injects required services into message handlers based on function signatures.
• Asynchronous Event Stream Subscribers - Consumes messages from topics, queues, or channels across different brokers using a unified asynchronous handler syntax.
• Message Processing Interruptions - Control when and how a message is marked as processed using automatic policies, manual triggers, or exception-based interrupts.
• Event Handler Injection - Provides dependency injection for asynchronous event handlers to simplify access to message data and headers.
• Message Payload Validators - Automatically converts incoming message data into specified types or complex data models using schema validation to ensure data integrity.
• In-Memory Broker Simulators - Redirects subscribers and publishers to an in-memory store to allow application testing without a live broker.
• Shared Message Contracts - Supports defining structured data models shared across publishers and subscribers to maintain consistent message contracts.
• Message Handler Integrations - Embeds message consumers and producers into a web application, enabling the use of shared dependency injection and background tasks.
• Message Body Deserializers - Converts incoming message payloads into typed objects using function annotations and validation, with options to disable casting or validation.
• Message Queue Registrations - Uses function decorators to bind application logic to message broker topics or queues for automated consumption and production.
• Lifespan Integration - Executes startup and shutdown routines to initialize connections or clean up resources in sync with application lifecycles.
• Automated Messaging Responses - Links input and output topics to functions to automatically publish return values to target destinations.
• In-Memory Testing - Simulates broker behavior in a testing mode to validate subscribers and publishers without a live broker.
• Broker Integration Test Suites - Allows executing integration tests against live message broker instances using the same interface as in-memory tests.
• Custom Payload Transformers - Converts raw message data into structured formats using custom decoding logic before passing it to handlers.
• ASGI Compatibility - Coordinates message broker startup and shutdown lifecycles with ASGI web applications.
• Stream Append Operations - Appends timestamped data to persistent logs for subsequent retrieval and replay by consumers.
• Partition Key Assignments - Assigns partition keys during message publication to ensure consistent ordering and load distribution.
• AsyncAPI Documentation Generation - Defines publisher objects that are automatically parsed into documentation to describe the service's output capabilities.
• AsyncAPI Generators - Automatically generates interactive AsyncAPI documentation and schemas from application code and handler definitions.
• Synchronous Request-Response - Sends a message to a broker and waits for a response synchronously using temporary or permanent reply queues.
• Schema-Based Data Models - Groups related message fields into structured objects to ensure consistent data validation and schema documentation.
• Topic Data Extraction - Parses variable segments from a topic name pattern and passes them as arguments to the message handler.
• JSON Message Serializers - Encodes and decodes message payloads using high-performance libraries with integrated schema validation.
• Task Stream Event Publishers - Enables publishing processed function results to broker streams for event-driven data pipelines.
• High-Performance Binary Serialization - Provides high-speed serialization backends to encode and decode message payloads with integrated schema validation.
• MessagePack Serializers - Integrates high-performance serialization using Msgspec for JSON, MessagePack, YAML, and TOML with schema validation.
• Messaging Throughput Scaling - Allows configuring worker counts and acknowledgment policies to scale concurrent message processing throughput.
• Header-Based Routing - Enables complex routing logic by directing messages to queues based on header metadata matching.
• Partitioning by Time or Key - Supports routing messages by partition keys to ensure data grouping and processing order.
• Persistent Storage Management - Provides persistent storage mechanisms to ensure reliable message delivery and processing for event-driven services.
• Cluster Connectivity - Supports connectivity to multi-node Redis clusters to maintain consistent messaging capabilities in distributed environments.
• Message Order Enforcement - Uses first-in, first-out queue structures to ensure messages are handled in the exact order they were produced.
• API Documentation Generators - Generates detailed specifications for messaging systems by defining app metadata, broker details, and handler descriptions.
• AsyncAPI Specification Generators - Generates machine-readable AsyncAPI specifications from application code for event-driven architectures.
• CLI Application Launchers - Enables starting and managing event-driven services directly through a command-line interface for simplified deployment.
• Application Launchers - Provides command-line utilities to launch and manage the lifecycle of event-driven services with configurable scaling and logging.
• Message Context Extractors - Retrieves specific message fields or header values by mapping them to function arguments using declarative annotations.
• Feature Capability Discovery - Enables calling provider-specific messaging features directly while maintaining a unified abstraction layer.
• Message Metadata Extractors - Retrieves broker-specific information such as headers, keys, offsets, and partitions from an incoming event using a unified wrapper.
• Message Handler Routers - Groups subscribers and publishers into modular units with shared middleware and dependencies to separate business logic from registration.
• Distributed Recurring Task Scheduling - Triggers message publishing or function execution on fixed timetables using distributed task queues.
• Consumer Scaling and Distribution - Distributes incoming messages across multiple consumer instances to increase processing throughput for specific topics.
• Queue-Based Message Distribution - Distributes incoming messages to every queue bound to an exchange to ensure all subscribers receive the data.
• Kafka Message Queues - Processes incoming Kafka events using subscriber functions that automatically handle deserialization and execution logic.
• Concurrent Message Processors - Executes multiple message handlers in parallel to increase total throughput while maintaining reliable delivery guarantees and scaling across available data partitions.
• Message Queues - Stores messages in ordered structures to ensure data durability and allow retrieval by consumers that join after the initial broadcast.
• Asynchronous Message Publishing - Provides asynchronous message publishing capabilities to trigger downstream services or update external systems.
• Queue and Exchange Orchestration - Connects queues to exchanges to define custom routing topologies within the messaging system.
• Round-Robin Load Balancers - Distributes incoming messages across multiple service instances using round-robin logic to scale processing capacity.
• Message Broker Infrastructure - Creates and validates message queues and exchanges on a broker to ensure the required topology exists before processing.
• Topology Configurations - Defines custom queue and exchange topologies including binding properties to manage message routing.
• Publish-Subscribe Messaging - Supports publishing messages from handlers while maintaining correlation IDs for distributed tracing.
• Broadcast Messaging - Broadcasts processed results to multiple message destinations simultaneously by attaching multiple publishers to a single handler.
• Real-time Notification Broadcasters - Sends messages instantly to all active subscribers of a channel to support real-time updates and notifications.
• End-to-End Communication Channels - Facilitates asynchronous communication by publishing data structures to specific broker channels.
• Header Name and Value Validations - Enforces schema validation on incoming message headers using type definitions to ensure data integrity.
• Topic-Based Broadcasting - Configures multiple publishers on a single handler to broadcast return values to several different topics simultaneously.
• Kafka Event Publishing - Sends structured data to message brokers by defining publisher interfaces that handle serialization and delivery.
• Browser-Based Test Interfaces - Provides a browser-based interface to publish test messages directly to a broker without leaving the documentation page.
• Message Processing Timeouts - Signals active task status to brokers to prevent premature message redelivery during long-running operations.
• Dynamic Subscriber Managers - Enables programmatic creation and management of message subscribers at runtime for dynamic data sources.
• Dynamic Subscription Controllers - Provides manual control over the subscription lifecycle for retrieving messages individually or as asynchronous streams.
• Pull-Based Consumers - Requests messages from a broker at defined intervals to control throughput and enable batch processing.
• Routing Key Consumers - Processes incoming messages by matching them against specific routing keys to trigger defined handler functions.
• Message Broker Producers - Sends data payloads to designated topics on a message broker to facilitate asynchronous communication.
• Binding Configurations - Provides automated configuration of exchange-to-queue bindings to optimize message routing and support complex messaging topologies.
• Web Framework Broker Lifecycle Embeddings - Integrates broker routers into existing application lifespans or frameworks to unify event-driven and request-response logic.
• Web Framework Lifecycle Integrations - Integrates message brokers with asynchronous web servers by hooking into application startup and shutdown lifecycles.
• Documentation Integrations - Mounts message broker specifications into existing web applications to unify API documentation and service management.
• Message Lifecycle Management - Confirms message processing through positive or negative acknowledgments to ensure reliable delivery and control requeuing.
• Message Stream Handlers - Processes continuous streams of incoming messages using asynchronous loops to handle data as it arrives.
• Message Stream Consumer Groups - Utilizes append-only logs with consumer groups to enable parallel processing and persistent data handling.
• Durable Stream Consumers - Processes messages from durable, append-only logs where data remains available after consumption for independent reading.
• Range-Based Stream Queries - Retrieves specific subsets of logged data by filtering stream entries based on identifiers or timestamps.
• Topic Message Listeners - Registers functions to process incoming messages from specific broker topics or patterns with support for multiple subscriptions.
• Topic Routing Patterns - Captures dynamic segments from message routing keys or topic patterns and maps them to handler function arguments.
• Messaging Channel Management - Listens for incoming messages on specific broker channels or patterns to trigger defined processing functions.
• Pattern-Based Routing - Enables flexible message routing by matching keys against defined patterns.
• Cloud Topic Publishing - Supports publishing messages to topics using reusable publisher objects with integrated documentation support.
• Native Broker Feature Accessors - Provides direct access to native broker-specific capabilities like partition control and exchange types.
• NATS Integrations - Registers handlers to process incoming messages from NATS subjects and queues, supporting request-reply and pub-sub patterns.
• Event Stream Subscription Handlers - Attaches a single processing function to multiple event streams or topics by stacking subscriber decorators to consolidate logic.
• Remote Procedure Calls - Sends messages to a broker and awaits synchronous responses to enable request-response patterns.
• Asynchronous Call Synchronization - Sends messages to specific subjects and waits for responses to enable request-response patterns over asynchronous brokers.
• Subject-Based Routing - Supports subject-based routing to dispatch messages to all active consumers of a specific subject.
• Tracing Context Propagation - Injects active span information into message headers to maintain trace continuity across distributed service boundaries during communication.
• Contextual Metadata Propagation - Carries key-value metadata through message headers across asynchronous boundaries to maintain trace context and shared state between producers and consumers.
• Module Organization - Organizes related message subscribers and publishers into modular units to separate business logic from the main application entry point.
• Runtime Exception Handling - Registers global error processors to manage exceptions across message handlers, decoders, and middleware.
• SASL Implementations - Provides SASL authentication mechanisms including SCRAM and Kerberos for secure message broker connectivity.
• Communication Encryption - Enables SSL/TLS encryption for secure data transmission between services and message brokers.
• SASL Broker Authenticators - Verifies identity using various SASL mechanisms including Plaintext, SCRAM, OAuthBearer, or Kerberos to secure broker connections.
• Initialization and Shutdown Hooks - Provides hooks for executing custom logic during startup and shutdown stages to initialize or clean up resources.
• Event Mocking for Testing - Simulates message publishing and consumption using in-memory mocks or real brokers for workflow testing.
• Global Exception Handlers - Intercepts errors from message handlers and middleware to perform centralized logging and cleanup.
• Handler Middlewares - Applies shared decoders, middleware, and dependency injections to groups of message handlers for consistent processing.
• Return Value Decorators - Links input and output operations via decorators to automatically produce responses to downstream topics.
• Message Batching - Processes multiple incoming messages simultaneously by grouping them into lists to improve throughput and efficiency.
• Message Brokers - Runs message broker applications as asynchronous tasks to integrate event-driven processing into service lifecycles.
• Message Metadata Access - Retrieves message headers, keys, and timestamps through a unified interface that abstracts underlying broker details.
• Message Payload Documentation - Uses data models to specify schemas, examples, and descriptions for message arguments and return types.
• Message Header Attachments - Attaches unique keys, headers, and timestamps to individual messages within a batch for precise tracking.
• Message Header Mappers - Map individual message attributes or specific header values directly into handler arguments for cleaner access to metadata.
• Metadata Propagation - Attaches custom key-value pairs to messages to maintain context and trace information as data moves between distributed microservices.
• Subject Remapping - Extracts dynamic segments from message subject patterns and maps them to handler arguments for routing.
• Post-Connection Startup Hooks - Executes custom operations automatically after a message broker connection is established.
• Publish-Result Channel Bindings - Creates reusable publisher objects that encapsulate destination channels and automatically generate documentation for service interfaces.
• Request-Response Pattern Support - Matches asynchronous message requests with responses using correlation identifiers to emulate synchronous remote procedure calls.
• Retry Strategies - Automatically re-executes failed message processing tasks using configurable strategies like exponential backoff to improve system resilience.
• End-to-End Message Tracing - Supports decorator-based publishing that preserves correlation IDs for end-to-end message tracing.
• Event-Driven Message Tracers - Integrates with OpenTelemetry to export trace data and spans to external collectors via middleware for visibility into event-driven message flows.
• Prometheus-Formatted HTTP Endpoints - Serves collected performance metrics over an HTTP endpoint for external scraping.
• Health Monitoring Endpoints - Provides HTTP endpoints to report application liveness and readiness status for orchestrators.
• HTTP Health Probes - Exposes HTTP endpoints for liveness and readiness probes to monitor service health.
• Trace Exporters - Transmits distributed trace data to OpenTelemetry collectors for external monitoring.
• Message Broker Monitoring - Tracks message throughput and latency metrics for integrated message brokers.
• Request Correlation - Propagates correlation identifiers across the entire message pipeline to enable distributed tracing and tracking of requests between services.
• Request-Scoped Log Context - Automatically attaches message metadata and trace identifiers to log entries for end-to-end traceability.
• Event-Driven Request Loggers - Captures message IDs and broker-specific parameters within the request context to track events as they flow through subscribers.
• Service Observability Integrations - Integrates distributed tracing via OpenTelemetry and metrics collection to monitor service health across asynchronous pipelines.
• Service Metrics Monitoring - Aggregates and exports runtime statistics and system health metrics for event-driven services.
• Event-Driven Test Contexts - Provides in-memory broker simulation via context managers to verify event-driven logic without requiring external infrastructure.
• Event Handler Testing - Validates event-driven logic by simulating broker interactions in memory within standard testing environments.
• Outgoing Message Verifiers - Captures and inspects outgoing message contents to ensure correct data emission during testing.
• Message Broker Mocks - Replaces real message broker connections with in-memory patches during testing to simulate message flows.
• Broker Integration Test Utilities - Verifies that publishers and consumers interact correctly by simulating routing in-memory or connecting to real brokers.
• AsyncAPI Documentation Hosting - Hosts interactive API documentation for message brokers via CLI or ASGI application mounting.
• AsyncAPI Schema Generators - Automatically generates AsyncAPI specification files in JSON or YAML formats based on application code.
• Request & Response Handling - Processes incoming messages within a subscriber and automatically returns a response to the sender to complete a request-reply cycle.
• Microservices Frameworks - Offers a toolkit for building scalable, distributed services with built-in support for tracing and metrics.
• Custom Serialization Logic - Transforms messages into specific formats like Avro, Protobuf, or Msgpack and handles compression steps during transmission.
• Message Content Filtering - Routes messages to specific handlers based on content, headers, or metadata to allow processing multiple message schemas within a single stream.
• Route Parameter Extraction - Parses dynamic segments from topic names directly into function arguments to simplify routing and data handling.
• Message Schema Documentation - Generates automated API documentation for message producers and consumers to ensure service interfaces are discoverable and well-defined.
• ASGI Frameworks - Wraps message broker services in an ASGI-compatible interface for deployment via standard web servers.
• Stream Processing - Simplifies broker-agnostic streaming with a modern framework.
• Streaming Libraries - Python library for writing message queue producers and consumers.

Historial de estrellas