Package: azure-eventhub
Azure Event Hubs client library for PythonAzure Event Hubs is a highly scalable publish-subscribe service that can ingest millions of events per second and stream
them to multiple consumers. This lets you process and analyze the massive amounts of data produced by your connected
devices and applications. Once Event Hubs has collected the data, you can retrieve, transform, and store it by using
any real-time analytics provider or with batching/storage adapters. If you would like to know more about Azure Event Hubs,
you may wish to review:What is Event Hubs?The Azure Event Hubs client library allows for publishing and consuming of Azure Event Hubs events and may be used to:Emit telemetry about your application for business intelligence and diagnostic purposes.Publish facts about the state of your application which interested parties may observe and use as a trigger for taking action.Observe interesting operations and interactions happening within your business or other ecosystem, allowing loosely coupled systems to interact without the need to bind them together.Receive events from one or more publishers, transform them to better meet the needs of your ecosystem, then publish the transformed events to a new stream for consumers to observe.Source code|Package (PyPi)|Package (Conda)|API reference documentation|Product documentation|SamplesGetting startedPrerequisitesPython 3.8 or later.Microsoft Azure Subscription:To use Azure services, including Azure Event Hubs, you'll need a subscription.
If you do not have an existing Azure account, you may sign up for a free trial or use your MSDN subscriber benefits when youcreate an account.Event Hubs namespace with an Event Hub:To interact with Azure Event Hubs, you'll also need to have a namespace and Event Hub  available.
If you are not familiar with creating Azure resources, you may wish to follow the step-by-step guide
forcreating an Event Hub using the Azure portal.
There, you can also find detailed instructions for using the Azure CLI, Azure PowerShell, or Azure Resource Manager (ARM) templates to create an Event Hub.Install the packageInstall the Azure Event Hubs client library for Python with pip:$ pip install azure-eventhubAuthenticate the clientInteraction with Event Hubs starts with an instance of EventHubConsumerClient or EventHubProducerClient class. You need either the host name, SAS/AAD credential and event hub name or a connection string to instantiate the client object.Create client from connection string:For the Event Hubs client library to interact with an Event Hub, the easiest means is to use a connection string, which is created automatically when creating an Event Hubs namespace.
If you aren't familiar with shared access policies in Azure, you may wish to follow the step-by-step guide toget an Event Hubs connection string.Thefrom_connection_stringmethod takes the connection string of the formEndpoint=sb://<yournamespace>.servicebus.windows.net/;SharedAccessKeyName=<yoursharedaccesskeyname>;SharedAccessKey=<yoursharedaccesskey>and
entity name to your Event Hub instance. You can get the connection string from theAzure portal.Create client using the azure-identity library:Alternately, one can use a Credential object to authenticate via AAD with the azure-identity package.This constructor demonstrated in the sample linked above takes the host name and entity name of your Event Hub instance and credential that implements theTokenCredentialprotocol. There are implementations of theTokenCredentialprotocol available in theazure-identity package. The host name is of the format<yournamespace.servicebus.windows.net>.To use the credential types provided byazure-identity, please install the package:pip install azure-identityAdditionally, to use the async API,  you must first install an async transport, such asaiohttp:pip install aiohttpWhen using Azure Active Directory, your principal must be assigned a role which allows access to Event Hubs, such as the
Azure Event Hubs Data Owner role. For more information about using Azure Active Directory authorization with Event Hubs,
please refer tothe associated documentation.Key conceptsAnEventHubProducerClientis a source of telemetry data, diagnostics information, usage logs, or other log data,
as part of an embedded device solution, a mobile device application, a game title running on a console or other device,
some client or server based business solution, or a web site.AnEventHubConsumerClientpicks up such information from the Event Hub and processes it. Processing may involve aggregation,
complex computation, and filtering. Processing may also involve distribution or storage of the information in a raw or transformed fashion.
Event Hub consumers are often robust and high-scale platform infrastructure parts with built-in analytics capabilities,
like Azure Stream Analytics, Apache Spark, or Apache Storm.Apartitionis an ordered sequence of events that is held in an Event Hub. Azure Event Hubs provides message streaming
through a partitioned consumer pattern in which each consumer only reads a specific subset, or partition, of the message stream.
As newer events arrive, they are added to the end of this sequence. The number of partitions is specified at the time an Event Hub is created and cannot be changed.Aconsumer groupis a view of an entire Event Hub. Consumer groups enable multiple consuming applications to each
have a separate view of the event stream, and to read the stream independently at their own pace and from their own position.
There can be at most 5 concurrent readers on a partition per consumer group; however it is recommended that there is only
one active consumer for a given partition and consumer group pairing. Each active reader receives all of the events from
its partition; if there are multiple readers on the same partition, then they will receive duplicate events.For more concepts and deeper discussion, see:Event Hubs Features.
Also, the concepts for AMQP are well documented inOASIS Advanced Messaging Queuing Protocol (AMQP) Version 1.0.Thread safetyWe do not guarantee that the EventHubProducerClient or EventHubConsumerClient are thread-safe. We do not recommend reusing these instances across threads. It is up to the running application to use these classes in a thread-safe manner.The data model type,EventDataBatchis not thread-safe. It should not be shared across threads nor used concurrently with client methods.ExamplesThe following sections provide several code snippets covering some of the most common Event Hubs tasks, including:Inspect an Event HubPublish events to an Event HubConsume events from an Event HubConsume events from an Event Hub in batchesPublish events to an Event Hub asynchronouslyConsume events from an Event Hub asynchronouslyConsume events from an Event Hub in batches asynchronouslyConsume events and save checkpoints using a checkpoint storeUse EventHubConsumerClient to work with IoT HubInspect an Event HubGet the partition ids of an Event Hub.importosfromazure.eventhubimportEventHubConsumerClientCONNECTION_STR=os.environ["EVENT_HUB_CONN_STR"]EVENTHUB_NAME=os.environ['EVENT_HUB_NAME']consumer_client=EventHubConsumerClient.from_connection_string(conn_str=CONNECTION_STR,consumer_group='$Default',eventhub_name=EVENTHUB_NAME,)withconsumer_client:pass# consumer_client is now ready to be used.Publish events to an Event HubUse thecreate_batchmethod onEventHubProducerClientto create anEventDataBatchobject which can then be sent using thesend_batchmethod.
Events may be added to theEventDataBatchusing theaddmethod until the maximum batch size limit in bytes has been reached.defsend_event_data_batch(producer):# Without specifying partition_id or partition_key# the events will be distributed to available partitions via round-robin.event_data_batch=producer.create_batch()event_data_batch.add(EventData('Single message'))producer.send_batch(event_data_batch)Consume events from an Event HubThere are multiple ways to consume events from an EventHub.  To simply trigger a callback when an event is received,
theEventHubConsumerClient.receivemethod will be of use as follows:importloggingfromazure.eventhubimportEventHubConsumerClientconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group,eventhub_name=eventhub_name)logger=logging.getLogger("azure.eventhub")logging.basicConfig(level=logging.INFO)defon_event(partition_context,event):logger.info("Received event from partition{}".format(partition_context.partition_id))partition_context.update_checkpoint(event)withclient:client.receive(on_event=on_event,starting_position="-1",# "-1" is from the beginning of the partition.)# receive events from specified partition:# client.receive(on_event=on_event, partition_id='0')Consume events from an Event Hub in batchesWhereas the above sample triggers the callback for each message as it is received, the following sample
triggers the callback on a batch of events, attempting to receive a number at a time.importloggingfromazure.eventhubimportEventHubConsumerClientconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group,eventhub_name=eventhub_name)logger=logging.getLogger("azure.eventhub")logging.basicConfig(level=logging.INFO)defon_event_batch(partition_context,events):logger.info("Received event from partition{}".format(partition_context.partition_id))partition_context.update_checkpoint()withclient:client.receive_batch(on_event_batch=on_event_batch,starting_position="-1",# "-1" is from the beginning of the partition.)# receive events from specified partition:# client.receive_batch(on_event_batch=on_event_batch, partition_id='0')Publish events to an Event Hub asynchronouslyUse thecreate_batchmethod onEventHubProducerto create anEventDataBatchobject which can then be sent using thesend_batchmethod.
Events may be added to theEventDataBatchusing theaddmethod until the maximum batch size limit in bytes has been reached.importasynciofromazure.eventhub.aioimportEventHubProducerClient# The package name suffixed with ".aio" for asyncfromazure.eventhubimportEventDataconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'asyncdefcreate_batch(client):event_data_batch=awaitclient.create_batch()can_add=Truewhilecan_add:try:event_data_batch.add(EventData('Message inside EventBatchData'))exceptValueError:can_add=False# EventDataBatch object reaches max_size.returnevent_data_batchasyncdefsend():client=EventHubProducerClient.from_connection_string(connection_str,eventhub_name=eventhub_name)batch_data=awaitcreate_batch(client)asyncwithclient:awaitclient.send_batch(batch_data)if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(send())Consume events from an Event Hub asynchronouslyThis SDK supports both synchronous and asyncio based code.  To receive as demonstrated in the samples above, but within
aio, one would need the following:importloggingimportasynciofromazure.eventhub.aioimportEventHubConsumerClientconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'logger=logging.getLogger("azure.eventhub")logging.basicConfig(level=logging.INFO)asyncdefon_event(partition_context,event):logger.info("Received event from partition{}".format(partition_context.partition_id))awaitpartition_context.update_checkpoint(event)asyncdefreceive():client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group,eventhub_name=eventhub_name)asyncwithclient:awaitclient.receive(on_event=on_event,starting_position="-1",# "-1" is from the beginning of the partition.)# receive events from specified partition:# await client.receive(on_event=on_event, partition_id='0')if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(receive())Consume events from an Event Hub in batches asynchronouslyAll synchronous functions are supported in aio as well.  As demonstrated above for synchronous batch receipt, one can accomplish
the same within asyncio as follows:importloggingimportasynciofromazure.eventhub.aioimportEventHubConsumerClientconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'logger=logging.getLogger("azure.eventhub")logging.basicConfig(level=logging.INFO)asyncdefon_event_batch(partition_context,events):logger.info("Received event from partition{}".format(partition_context.partition_id))awaitpartition_context.update_checkpoint()asyncdefreceive_batch():client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group,eventhub_name=eventhub_name)asyncwithclient:awaitclient.receive_batch(on_event_batch=on_event_batch,starting_position="-1",# "-1" is from the beginning of the partition.)# receive events from specified partition:# await client.receive_batch(on_event_batch=on_event_batch, partition_id='0')if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(receive_batch())Consume events and save checkpoints using a checkpoint storeEventHubConsumerClientis a high level construct which allows you to receive events from multiple partitions at once
and load balance with other consumers using the same Event Hub and consumer group.This also allows the user to track progress when events are processed using checkpoints.A checkpoint is meant to represent the last successfully processed event by the user from a particular partition of
a consumer group in an Event Hub instance. TheEventHubConsumerClientuses an instance ofCheckpointStoreto update checkpoints
and to store the relevant information required by the load balancing algorithm.Search pypi with the prefixazure-eventhub-checkpointstoreto
find packages that support this and use theCheckpointStoreimplementation from one such package. Please note that both sync and async libraries are provided.In the below example, we create an instance ofEventHubConsumerClientand use aBlobCheckpointStore. You need
tocreate an Azure Storage accountand aBlob Containerto run the code.Azure Blob Storage Checkpoint Store AsyncandAzure Blob Storage Checkpoint Store Syncare one of theCheckpointStoreimplementations we provide that applies Azure Blob Storage as the persistent store.importasynciofromazure.eventhub.aioimportEventHubConsumerClientfromazure.eventhub.extensions.checkpointstoreblobaioimportBlobCheckpointStoreconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'storage_connection_str='<< CONNECTION STRING FOR THE STORAGE >>'container_name='<<NAME OF THE BLOB CONTAINER>>'asyncdefon_event(partition_context,event):# do somethingawaitpartition_context.update_checkpoint(event)# Or update_checkpoint every N events for better performance.asyncdefreceive(client):awaitclient.receive(on_event=on_event,starting_position="-1",# "-1" is from the beginning of the partition.)asyncdefmain():checkpoint_store=BlobCheckpointStore.from_connection_string(storage_connection_str,container_name)client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group,eventhub_name=eventhub_name,checkpoint_store=checkpoint_store,# For load balancing and checkpoint. Leave None for no load balancing)asyncwithclient:awaitreceive(client)if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(main())Use EventHubConsumerClient to work with IoT HubYou can useEventHubConsumerClientto work with IoT Hub as well. This is useful for receiving telemetry data of IoT Hub from the
linked EventHub. The associated connection string will not have send claims, hence sending events is not possible.Please notice that the connection string needs to be for anEvent Hub-compatible endpoint,
e.g. "Endpoint=sb://my-iothub-namespace-[uid].servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-iot-hub-name"There are two ways to get the Event Hubs compatible endpoint:Manually get the "Built-in endpoints" of the IoT Hub in Azure Portal and receive from it.fromazure.eventhubimportEventHubConsumerClientconnection_str='Endpoint=sb://my-iothub-namespace-[uid].servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-iot-hub-name'consumer_group='<< CONSUMER GROUP >>'client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group)partition_ids=client.get_partition_ids()Programmatically retrieve the built-in Event Hubs compatible endpoint.
Refer toIoT Hub Connection String Sample.TroubleshootingSee theazure-eventhubstroubleshooting guidefor details on how to diagnose various failure scenarios.Next stepsMore sample codePlease take a look at thesamplesdirectory for detailed examples of how to use this library to send and receive events to/from Event Hubs.DocumentationReference documentation is availablehere.Schema Registry and Avro EncoderThe EventHubs SDK integrates nicely with theSchema Registryservice andAvro.
For more information, please refer toSchema Registry SDKandSchema Registry Avro Encoder SDK.Pure Python AMQP Transport and Backward Compatibility SupportThe Azure Event Hubs client library is now based on a pure Python AMQP implementation.uAMQPhas been removed as required dependency.To useuAMQPas the underlying transport:Installuamqpwith pip.$ pip install uamqpPassuamqp_transport=Trueduring client construction.fromazure.eventhubimportEventHubProducerClient,EventHubConsumerClientconnection_str='<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>'consumer_group='<< CONSUMER GROUP >>'eventhub_name='<< NAME OF THE EVENT HUB >>'client=EventHubProducerClient.from_connection_string(connection_str,eventhub_name=eventhub_name,uamqp_transport=True)client=EventHubConsumerClient.from_connection_string(connection_str,consumer_group,eventhub_name=eventhub_name,uamqp_transport=True)Note: Themessageattribute onEventData/EventDataBatch, which previously exposed theuamqp.Message, has been deprecated.
The "Legacy" objects returned byEventData.message/EventDataBatch.messagehave been introduced to help facilitate the transition.Building uAMQP wheel from sourceIfuAMQPis intended to be used as the underlying AMQP protocol implementation forazure-eventhub,
uAMQP wheels can be found for most major operating systems.If you intend to useuAMQPand you're running on a platform for which uAMQP wheels are not provided, please follow
theuAMQP Installationguidance to install from source.Provide FeedbackIf you encounter any bugs or have suggestions, please file an issue in theIssuessection of the project.ContributingThis project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visithttps://cla.microsoft.com.When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the
PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.This project has adopted theMicrosoft Open Source Code of Conduct.
For more information see theCode of Conduct FAQor contactopencode@microsoft.comwith any additional questions or comments.Release History5.11.6 (2024-02-12)This version and all future versions will require Python 3.8+. Python 3.7 is no longer supported.Features AddedAddedkeep_alivefunctionality on EventHubProducerClient to allow for long-living producers.#33726Other ChangesAdded support for Python 3.12.5.11.5 (2023-11-13)Bugs FixedFixed a pyAMQP error where events split across multiple TransferFrames were depleting the link credit by more than 1 credit per message. (#32767)5.11.4 (2023-08-08)Features AddedA new float keyword argumentsocket_timeouthas been added to the sync and asyncEventHubConsumerClientandEventHubProducerClient.Bugs FixedFixed bug#31258where asyncBlobCheckpointStorewas reprocessing old events after an error.5.11.3 (2023-07-12)Bugs FixedFixed the errorend frame received on invalid channelwhich was raised when a disconnect was sent by the service (#30860)Fixed the errorlink already closedwhich was raised when the client was closing and disconnecting from the service (#30836)Other ChangesUpdated tracing (#29934):Span names renamed:Azure.EventHubs.sendtoEventHubs.sendAzure.EventHubs.messagetoEventHubs.messageAzure.EventHubs.processtoEventHubs.processAnEventHubs.receivespan will be created upon receiving events.Additional attributes added to spans:messaging.system- messaging system (i.e.,eventhubs)messaging.operation- type of operation (i.e.,publish,receive, orprocess)messaging.batch.message_count- number of messages sent, received, or processed (if more than one)Thecomponentattribute was removed from all spans.Allsendspans now contain links tomessagespans. Now,messagespans will no longer contain a link to thesendspan.Message application properties will now contain values fortraceparent(andtracestateif applicable)Process spans will now be a direct children of message span contexts in when event handling on a per-message basis. (#30537)5.11.2 (2023-03-20)Bugs FixedFixed a bug that would prevent reconnect after a long idle period, network drop (issue #28996)5.11.1 (2023-01-25)Bugs FixedFixed a bug where, whenwebsocket-clientwas not installed, the error was not caught/raised properly (issue #28453).5.11.0 (2023-01-19)Version 5.11.0 is our first stable release of the Azure Event Hubs client library based on a pure Python implemented AMQP stack.Features AddedA new boolean keyword argumentuamqp_transporthas been added to sync and asyncEventHubProducerClient/EventHubConsumerClientconstructors which indicates whether to use theuamqplibrary or the default pure Python AMQP library as the underlying transport.Bugs FixedFixed a bug that caused an error when sending batches with tracing enabled (issue #27986).Fixed a bug whereEventHubSharedKeyCredentialreturned anAccessToken.tokenof typebytesand notstr, now matching the documentation.Other ChangesThemessageattribute onEventData/EventDataBatch, which previously exposed theuamqp.Message, has been deprecated.LegacyMessage/LegacyBatchMessageobjects returned by themessageattribute onEventData/EventDataBatchhave been introduced to help facilitate the transition.Removed uAMQP from required dependencies.Addinguamqp >= 1.6.3as an optional dependency for use with theuamqp_transportkeyword.Added support for Python 3.11.5.8.0b2 (2022-10-11)Features AddedUpdated the optional dependency for async transport using AMQP over WebSocket fromwebsocket-clienttoaiohttp(Issue #24315, thanks @hansmbakker for the suggestion).5.8.0b1 (2022-09-22)This version and all future versions will require Python 3.7+. Python 3.6 is no longer supported.Other ChangesAdded theuamqp_transportoptional parameter to the clients, to allow switching to theuamqplibrary as the transport.5.10.1 (2022-08-22)This version and all future versions will require Python 3.7+, Python 3.6 is no longer supported.Bugs FixedFixed a bug in asyncBufferedProducerthat would block when flushing the queue causing the client to freeze up (issue #23510).Fixed a bug in the asyncEventHubProducerClientandEventHubConsumerClientthat set the default value of thetransport_typeparameter in thefrom_connection_stringmethods toNonerather thanTransportType.Amqp.Other ChangesInternal refactoring to support upcoming Pure Python AMQP-based release.Updated uAMQP dependency to 1.6.0.5.8.0a5 (2022-07-19)Bugs FixedFixed bug that prevented token refresh at regular intervals.Fixed bug that was improperly passing the debug keyword argument, so that network trace debug logs are output when requested.Other ChangesAdded logging added in to track proper token refreshes & fetches, output exception reason for producer init failure.5.10.0 (2022-06-08)Features AddedIncludes the following features related to buffered sending of events:A new methodsend_eventtoEventHubProducerClientwhich allows sending singleEventDataorAmqpAnnotatedMessage.Buffered mode sending toEventHubProducerClientwhich is intended to allow for efficient publishing of events
without having to explicitly manage batches in the application.The constructor ofEventHubProducerClientandfrom_connection_stringmethod takes the following new keyword arguments
for configuration:buffered_mode: The flag to enable/disable buffered mode sending.on_success: The callback to be called once events have been successfully published.on_error: The callback to be called once events have failed to be published.max_buffer_length: The total number of events per partition that can be buffered before a flush will be triggered.max_wait_time: The amount of time to wait for a batch to be built with events in the buffer before publishing.A new methodEventHubProducerClient.flushwhich flushes events in the buffer to be sent immediately.A new methodEventHubProducerClient.get_buffered_event_countwhich returns the number of events that are buffered and waiting to be published for a given partition.A new propertyEventHubProducerClient.total_buffered_event_countwhich returns the total number of events that are currently buffered and waiting to be published, across all partitions.A new boolean keyword argumentflushtoEventHubProducerClient.closewhich indicates whether to flush the buffer or not while closing.5.8.0a4 (2022-06-07)Features AddedAdded support for connection using websocket and http proxy.Added support for custom endpoint connection over websocket.5.9.0 (2022-05-10)Features AddedThe classmethodfrom_message_contenthas been added toEventDatafor interoperability with the Schema Registry Avro Encoder library, and takescontentandcontent_typeas positional parameters.Other ChangesFeatures related to buffered sending of events are still in beta and will not be included in this release.5.9.0b3 (2022-04-20)Features AddedIntroduced new methodsend_eventtoEventHubProducerClientwhich allows sending singleEventDataorAmqpAnnotatedMessage.Introduced buffered mode sending toEventHubProducerClientwhich is intended to allow for efficient publishing of events
without having to explicitly manage batches in the application.The constructor ofEventHubProducerClientandfrom_connection_stringmethod now takes the following new keyword arguments
for configuration:buffered_mode: The flag to enable/disable buffered mode sending.on_success: The callback to be called once events have been successfully published.on_error: The callback to be called once events have failed to be published.max_buffer_length: The total number of events per partition that can be buffered before a flush will be triggered.max_wait_time: The amount of time to wait for a batch to be built with events in the buffer before publishing.Introduced new methodEventHubProducerClient.flushwhich flushes events in the buffer to be sent immediately.Introduced new methodEventHubProducerClient.get_buffered_event_countwhich returns the number of events that are buffered and waiting to be published for a given partition.Introduced new propertyEventHubProducerClient.total_buffered_event_countwhich returns the total number of events that are currently buffered and waiting to be published, across all partitions.Introduced new boolean keyword argumentflushtoEventHubProducerClient.closewhich indicates whether to flush the buffer or not while closing.Other ChangesUpdatedEventDatainternals for interoperability with the Schema Registry Avro Encoder library.5.9.0b2 (2022-03-09)Breaking Changesfrom_message_dataonEventDatahas been renamedfrom_message_contentfor interoperability with the Schema Registry Avro Encoder library. Thedataparameter has been renamed tocontent.5.8.0a3 (2022-03-08)Other ChangesImproved the performance of async sending and receiving.5.9.0b1 (2022-02-09)The following features have been temporarily pulled out of asyncEventHubProducerClientandEventHubConsumerClientwhich will be added back in future previews as we work towards a stable release:Passing the following keyword arguments to the constructors andfrom_connection_stringmethods of theEventHubProducerClientandEventHubConsumerClientis not supported:transport_type,http_proxy,custom_endpoint_address, andconnection_verify.5.8.0a2 (2022-02-09)Features AddedAdded support for asyncEventHubProducerClientandEventHubConsumerClient.5.8.0a1 (2022-01-13)Version 5.8.0a1 is our first efforts to build an Azure Event Hubs client library based on pure python implemented AMQP stack.Breaking changesThe following features have been temporarily pulled out which will be added back in future previews as we work towards a stable release:Async is not supported.Passing the following keyword arguments to the constructors andfrom_connection_stringmethods of theEventHubProducerClientandEventHubConsumerClientis not supported:transport_type,http_proxy,custom_endpoint_address, andconnection_verify.Other ChangesuAMQP dependency is removed.5.7.0 (2022-01-12)This version and all future versions will require Python 3.6+. Python 2.7 is no longer supported.Features AddedAdded support for fixed (linear) retry backoff:Sync/asyncEventHubProducerClientandEventHubConsumerClientconstructors andfrom_connection_stringtakeretry_modeas a keyword argument.Bugs FixedFixed a bug thatEventHubProducerClientcould be reopened for sending events instead of encountering withKeyErrorwhen the client is previously closed (issue #21849).Other ChangesImproved token refresh timing to prevent potentially blocking main flow when the token is about to get expired soon.Updated uAMQP dependency to 1.5.1.5.6.1 (2021-10-06)Bugs FixedFixed a bug for checking thatazure.eventhub.amqp.AmqpMessageHeaderandazure.eventhub.amqp.AmqpMessagePropertiescontain specific properties using theinkeyword.Other ChangesUpdated uAMQP dependency to 1.4.3.Added support for Python 3.10.Fixed memory leak in win32 socketio and tlsio (issue #19777).Fixed memory leak in the process of converting AMQPValue into string (issue #19777).5.6.0 (2021-07-07)Features AddedAdded support for sending AMQP annotated message which allows full access to the AMQP message fields.Introduced new namespaceazure.eventhub.amqp.Added new enum classazure.eventhub.amqp.AmqpMessageBodyTypeto represent the body type of the message which includes:DATA: The body of message consists of one or more data sections and each section contains opaque binary data.SEQUENCE: The body of message consists of one or more sequence sections and each section contains an arbitrary number of structured data elements.VALUE: The body of message consists of one amqp-value section and the section contains a single AMQP value.Introduced new classazure.eventhub.amqp.AmqpAnnotatedMessagefor accessing low-level amqp message sections which can be instantiated for sending.Introduced new classesazure.eventhub.amqp.AmqpMessageHeaderandazure.eventhub.amqp.AmqpMessagePropertiesfor accessing amqp header and properties.Added new propertybody_typeonazure.eventhub.EventDatawhich returnsazure.eventhub.amqp.AmqpMessageBodyType.Added new read-only propertyraw_amqp_messageonazure.eventhub.EventDatawhich returnsazure.eventhub.amqp.AmqpAnnotatedMessage.FixedUpdated uAMQP dependency to 1.4.1.Fixed a bug that attributes creation_time, absolute_expiry_time and group_sequence on MessageProperties should be compatible with integer types on Python 2.7.5.5.0 (2021-05-13)New FeaturesAdded support for usingazure.core.credentials.AzureNamedKeyCredentialas credential for authenticating producer and consumer clients.Bug FixesFixed bug that custom user agent string should be put in front of the built-in user agent string instead of being appended.Updated uAMQP dependency to 1.4.0.Fixed memory leaks in the process of link attach where source and target cython objects are not properly deallocated (#15747).Improved management operation callback not to parse description value of non AMQP_TYPE_STRING type as string (#18361).NotesUpdated azure-core dependency to 1.14.0.5.4.0 (2021-04-07)This version follows from version 5.3.1, rather than 5.4.0b1 so that the preview idempotent producer feature is not included.New FeaturesAdded support for usingazure.core.credentials.AzureSasCredentialas credential for authenticating producer and consumer clients.Updatedlist_ownership,claim_ownership,update_checkpoint,list_checkpointson sync and asyncCheckpointStoreto support taking**kwargs.WARNING: Implementing a custom checkpointstore that does not support taking**kwargsin the methods listed previously will result in the following pylint error:W0221: Parameters differ from overridden ________ method (arguments-differ).Updatedupdate_checkpointon sync and asyncPartitionContextto support taking**kwargs.Bug FixesUpdated uAMQP dependency to 1.3.0.Fixed bug that sending message of large size triggering segmentation fault when the underlying socket connection is lost (#13739, #14543).Fixed bug in link flow control where link credit and delivery count should be calculated based on per message instead of per transfer frame (#16934).NotesUpdated azure-core dependency to 1.13.0.5.4.0b1 (2021-03-09)This version and all future versions will require Python 2.7 or Python 3.6+, Python 3.5 is no longer supported.New FeaturesAdded support for idempotent publishing which is supported by the service to endeavor to reduce the number of duplicate
events that are published.EventHubProducerClientconstructor accepts two new parameters for idempotent publishing:enable_idempotent_partitions: A boolean value to tell theEventHubProducerClientwhether to enable idempotency.partition_config: The set of configurations that can be specified to influence publishing behavior
specific to the configured Event Hub partition.Introduced a new methodget_partition_publishing_propertiesonEventHubProducerClientto inspect the information
about the state of publishing for a partition.Introduced a new propertypublished_sequence_numberonEventDatato get the publishing sequence number assigned
to the event at the time it was successfully published.Introduced a new propertystarting_published_sequence_numberonEventDataBatchto get the publishing sequence
number assigned to the first event in the batch at the time the batch was successfully published.Introduced a new classazure.eventhub.PartitionPublishingConfigurationwhich is a set of configurations that can be
specified to influence the behavior when publishing directly to an Event Hub partition.NotesUpdated uAMQP dependency to 1.2.15.5.3.1 (2021-03-09)This version will be the last version to officially support Python 3.5, future versions will require Python 2.7 or Python 3.6+.Bug fixesSending emptyevent_data_batchwill be a no-op now instead of raising error.5.3.0 (2021-02-08)New FeaturesAdded aparse_connection_stringmethod which parses a connection string into a properties bag,EventHubConnectionStringProperties, containing its component parts.The constructor andfrom_connection_stringmethod ofEventHubConsumerClientandEventHubProducerClientnow accept two new optional arguments:custom_endpoint_addresswhich allows for specifying a custom endpoint to use when communicating with the Event Hubs service,
and is useful when your network does not allow communicating to the standard Event Hubs endpoint.connection_verifywhich allows for specifying the path to the custom CA_BUNDLE file of the SSL certificate which is used to authenticate
the identity of the connection endpoint.NotesUpdated uAMQP dependency to 1.2.14.5.2.1 (2021-01-11)Bug fixesUpdatedazure.eventhub.extension.__init__.pyto be compatible with pkgutil-style namespace (PR #13210, thanks @pjachowi).Updated uAMQP dependency to 1.2.13Added support for Python 3.9.Fixed bug that macOS was unable to detect network error (#15473).Fixed bug thatuamqp.ReceiveClientanduamqp.ReceiveClientAsyncreceive messages during connection establishment (#15555).Fixed bug where connection establishment on macOS with Clang 12 triggering unrecognized selector exception (#15567).Fixed bug in accessing message properties triggering segmentation fault when the underlying C bytes are NULL (#15568).5.2.0 (2020-09-08)New FeaturesConnection strings used withfrom_connection_stringmethods now supports using theSharedAccessSignaturekey in leiu ofsharedaccesskeyandsharedaccesskeyname, taking the string of the properly constructed token as value.5.2.0b1 (2020-07-06)New FeaturesEventHubConsumerClientconstructor accepts two new parameters for the load balancer.load_balancing_strategy, which can be "greedy" or "balanced".
With greedy strategy, one execution of load balancing will claim as many partitions as required to balance the load
whereas with balanced strategy one execution of load balancing will claim at most 1 partition.partition_ownership_expiration_interval, which allows you to customize the partition ownership expiration for load balancing.
A consumer client may lose its owned partitions more often with a smaller expiration interval. But a larger interval
may result in idle partitions not being claimed for longer time.Added enum classazure.eventhub.LoadBalancingStrategyforload_balancing_strategy.5.1.0 (2020-05-04)New FeaturesEventHubProducerClient.send_batchaccepts either anEventDataBatchor a finite list ofEventData. #9181Added enqueueTime to span links of distributed tracing. #9599Bug fixesFixed a bug that turnedazure.eventhub.EventhubConsumerClientinto an exclusive receiver when it has no checkpoint store. #11181Updated uAMQP dependency to 1.2.7.Fixed bug in setting certificate of tlsio on MacOS. #7201Fixed bug that caused segmentation fault in network tracing on MacOS when settinglogging_enabletoTrueinEventHubConsumerClientandEventHubProducerClient.5.1.0b1 (2020-04-06)New FeaturesAddedEventHubConsumerClient.receive_batch()to receive and process events in batches instead of one by one. #9184EventHubConsumerCliuent.receive()has a new parammax_wait_time.on_eventis called everymax_wait_timewhen no events are received andmax_wait_timeis notNoneor 0.Param event ofPartitionContext.update_checkpointis now optional. The last received event is used when param event is not passed in.EventData.system_propertieshas added missing properties when consuming messages from IotHub. #104085.0.1 (2020-03-09)Bug fixesFixed a bug that swallowed errors when receiving events withazure.eventhub.EventHubConsumerClient#9660Fixed a bug that causedget_eventhub_properties,get_partition_ids, andget_partition_propertiesto raise
an error on Azure Stack #99205.0.0 (2020-01-13)Breaking changesEventDataRemoved deprecated propertyapplication_propertiesand deprecated methodencode_message().EventHubConsumerClienton_errorwould be called whenEventHubConsumerClientfailed to claim ownership of partitions.on_partition_closeandon_partition_initializewould be called in the case of exceptions raised byon_eventcallback.EventHubConsumerClientwould close and re-open the internal partition receiver in this case.Default starting position from whereEventHubConsumerClientshould resume receiving after recovering from an error has been re-prioritized.If there is checkpoint, it will resume from the checkpoint.If there is no checkpoint butstarting_positionis provided, it will resume fromstarting_posititon.If there is no checkpoint orstarting_position, it will resume from the latest position.PartitionContextupdate_checkpointwould do in-memory checkpoint instead of doing nothing when checkpoint store is not explicitly provided.The in-memory checkpoints would be used forEventHubConsumerClientreceiving recovering.get_partition_ids,get_partition_properties,get_eventhub_propertieswould raise error in the case of service returning an error status code.AuthenticationErrorwould be raised when service returning error code 401.ConnectErrorwould be raised when service returning error code 404.EventHubErrorwould be raised when service returning other error codes.5.0.0b6 (2019-12-03)Breaking changesAll exceptions should now be imported fromazure.eventhub.exceptions.Introduced separateEventHubSharedKeyCredentialobjects for synchronous and asynchronous operations.
For async, import the credentials object from theazure.eventhub.aionamespace.EventDataRenamed propertyapplication_propertiestoproperties.EventDatano longer has attributelast_enqueued_event_properties- use this onPartitionContextinstead.EvenDataBatchEventDataBatch.try_addhas been renamed toEventDataBatch.add.Renamed propertysizetosize_in_bytes.Renamed attributemax_sizetomax_size_in_bytes.EventHubConsumerClientandEventHubProducerClientRenamed methodget_propertiestoget_eventhub_properties.Renamed parameters in constructor:hosttofully_qualified_namespace,event_hub_pathtoeventhub_name.Renamed parameters inget_partition_properties:partitiontopartition_id.Renamed parameterconsumer_group_nametoconsumer_groupand moved that parameter fromreceivemethod to the constructor ofEventHubConsumerClient.Renamed parameterinitial_event_positiontostarting_positionon thereceivemethod ofEventHubConsumerClient.Renamed parameterevent_hub_pathtoeventhub_namein constructor andfrom_connection_stringmethod of the client object.EventHubProducerClient.sendhas been renamed tosend_batchwhich will only acceptEventDataBatchobject as input.EventHubProducerClient.create_batchnow also takes thepartition_idandpartition_keyas optional parameters (which are no longer specified at send).Renamed modulePartitionManagertoCheckpointStore.Receive event callback parameter has been renamed toon_eventand now operates on a single event rather than a list of events.Removed classEventPostition.Thestarting_positionparameter of thereceivemethod accepts offset(str), sequence number(int), datetime (datetime.datetime) ordictof these types.Thestarting_position_inclusiveparameter of thereceivemethod acceptsboolordictindicating whether the given event position is inclusive or not.PartitionContextno longer has attributeowner_id.PartitionContextnow has attributelast_enqueued_event_propertieswhich is populated iftrack_last_enqueued_event_propertiesis set toTruein thereceivemethod.New featuresAdded new parameteridle_timeoutin construct andfrom_connection_stringtoEventHubConsumerClientandEventHubProducerClientafter which the underlying connection will close if there is no further activity.5.0.0b5 (2019-11-04)Breaking changesEventHubClient,EventHubConsumerandEventHubProducerhas been removed. UseEventHubProducerClientandEventHubConsumerClientinstead.Construction of both objects is the same as it was for the previous client.IntroducedEventHubProducerClientas substitution forEventHubProducer.EventHubProducerClientsupports sending events to different partitions.IntroducedEventHubConsumerClientas substitution forEventHubConsumer.EventHubConsumerClientsupports receiving events from single/all partitions.There are no longer methods which directly returnEventData, all receiving is done via callback method:on_events.EventHubConsumerClienthas taken on the responsibility ofEventProcessor.EventHubConsumerClientnow acceptsPartitionManagerto do load-balancing and checkpoint.ReplacedPartitionProcessorby four independent callback methods accepted by thereceivemethod onEventHubConsumerClient.on_events(partition_context, events)called when events are received.on_error(partition_context, exceptioncalled when errors occur.on_partition_initialize(partition_context)called when a partition consumer is opened.on_partition_close(partition_context, reason)called when a partition consumer is closed.Some modules and classes that were importable from several different places have been removed:azure.eventhub.commonhas been removed. Import fromazure.eventhubinstead.azure.eventhub.client_abstracthas been removed. Useazure.eventhub.EventHubProducerClientorazure.eventhub.EventHubConsumerClientinstead.azure.eventhub.clienthas been removed. Useazure.eventhub.EventHubProducerClientorazure.eventhub.EventHubConsumerClientinstead.azure.eventhub.producerhas been removed. Useazure.eventhub.EventHubProducerClientinstead.azure.eventhub.consumerhas been removed. Useazure.eventhub.EventHubConsumerClientinstead.azure.eventhub.aio.client_asynchas been removed. Useazure.eventhub.aio.EventHubProducerClientorazure.eventhub.aio.EventHubConsumerClientinstead.azure.eventhub.aio.producer_asynchas been removed. Useazure.eventhub.aio.EventHubProducerClientinstead.azure.eventhub.aio.consumer_asynchas been removed. Useazure.eventhub.aio.EventHubConsumerClientinstead.azure.eventhub.aio.event_processor.event_processorhas been removed. Useazure.eventhub.aio.EventHubConsumerClientinstead.azure.eventhub.aio.event_processor.partition_processorhas been removed. Use callback methods instead.azure.eventhub.aio.event_processor.partition_managerhas been removed. Import fromazure.eventhub.aioinstead.azure.eventhub.aio.event_processor.partition_contexthas been removed. Import fromazure.eventhub.aioinstead.azure.eventhub.aio.event_processor.sample_partition_managerhas been removed.Bug fixesFixed bug in user-agent string not being parsed.5.0.0b4 (2019-10-08)New featuresAdded support for tracing (issue #7153).Added the capability of tracking last enqueued event properties of the partition toEventHubConsumer.Added new boolean type parametertrack_last_enqueued_event_propertiesin methodEventHubClient.create_consumer().Added new propertylast_enqueued_event_propertiesofEventHubConsumerwhich contains sequence_number, offset, enqueued_time and retrieval_time information.By default the capability is disabled as it will cost extra bandwidth for transferring more information if turned on.Breaking changesRemoved support for IoT Hub direct connection.EventHubs compatible connection stringof an IotHub can be used to createEventHubClientand read properties or events from an IoT Hub.Removed support for sending EventData to IoT Hub.Removed parameterexceptionin methodclose()ofEventHubConsumerandEventHubProcuer.Updated uAMQP dependency to 1.2.3.5.0.0b3 (2019-09-10)New featuresAdded support for automatic load balancing among multipleEventProcessor.AddedBlobPartitionManagerwhich implementsPartitionManager.Azure Blob Storage is applied for storing data used byEventProcessor.Packaged separately as a plug-in toEventProcessor.For details, please refer toAzure Blob Storage Partition Manager.Added propertysystem_propertiesonEventData.Breaking changesRemoved constructor method ofPartitionProcessor. For initialization please implement the methodinitialize.ReplacedCheckpointManagerbyPartitionContext.PartitionContexthas partition context information and methodupdate_checkpoint.Updated all methods ofPartitionProcessorto includePartitionContextas part of the arguments.Updated accessibility of class members inEventHub/EventHubConsumer/EventHubProducerto be private.Movedazure.eventhub.eventprocessorunderaiopackage, which now becomesazure.eventhub.aio.eventprocessor.5.0.0b2 (2019-08-06)New featuresAdded methodcreate_batchon theEventHubProducerto create anEventDataBatchthat can then be used to add events until the maximum size is reached.This batch object can then be used in thesend()method to send all the added events to Event Hubs.This allows publishers to build batches without the possibility of encountering the error around the message size exceeding the supported limit when sending events.It also allows publishers with bandwidth concerns to control the size of each batch published.Added new configuration parameters for exponential delay between retry operations.retry_total: The total number of attempts to redo the failed operation.backoff_factor: The delay time factor.backoff_max: The maximum delay time in total.Added support for context manager onEventHubClient.Added new error typeOperationTimeoutErrorfor send operation.Introduced a new classEventProcessorwhich replaces the older concept ofEvent Processor Host. This early preview is intended to allow users to test the new design using a single instance ofEventProcessor. The ability to checkpoints to a durable store will be added in future updates.EventProcessor: EventProcessor creates and runs consumers for all partitions of the eventhub.PartitionManager: PartitionManager defines the interface for getting/claiming ownerships of partitions and updating checkpoints.PartitionProcessor: PartitionProcessor defines the interface for processing events.CheckpointManager: CheckpointManager takes responsibility for updating checkpoints during events processing.Breaking changesEventProcessorHostwas replaced byEventProcessor, please read the new features for details.Replacedmax_retriesconfiguration parameter of the EventHubClient withretry_total.5.0.0b1 (2019-06-25)Version 5.0.0b1 is a preview of our efforts to create a client library that is user friendly and idiomatic to the Python ecosystem. The reasons for most of the changes in this update can be found in theAzure SDK Design Guidelines for Python. For more information, please visithttps://aka.ms/azure-sdk-preview1-python.New featuresAdded new configuration parameters for creating EventHubClient.credential: The credential object used for authentication which implementsTokenCredentialinterface of getting tokens.transport_type: The type of transport protocol that will be used for communicating with the Event Hubs service.max_retries: The max number of attempts to redo the failed operation when an error happened.for detailed information about the configuration parameters, please read the reference documentation.Added new methodsget_partition_propertiesandget_partition_idsto EventHubClient.Added support for http proxy.Added support for authentication using azure-identity credential.Added support for transport using AMQP over WebSocket.Breaking changesNew error hierarchyazure.error.EventHubErrorazure.error.ConnectionLostErrorazure.error.ConnectErrorazure.error.AuthenticationErrorazure.error.EventDataErrorazure.error.EventDataSendErrorRenamed Sender/Receiver to EventHubProducer/EventHubConsumer.Renamedadd_sendertocreate_producerandadd_receivertocreate_consumerin EventHubClient.EventHubConsumer is now iterable.Rename class azure.eventhub.Offset to azure.eventhub.EventPosition.Rename methodget_eventhub_infotoget_propertiesof EventHubClient.Reorganized connection management, EventHubClient is no longer responsible for opening/closing EventHubProducer/EventHubConsumer.Each EventHubProducer/EventHubConsumer is responsible for its own connection management.Added support for context manager on EventHubProducer and EventHubConsumer.Reorganized async APIs into "azure.eventhub.aio" namespace and rename to drop the "_async" suffix.Updated uAMQP dependency to 1.2.1.3.1 (2019-02-28)BugFixesFixed bug where datetime offset filter was using a local timestamp rather than UTC.Fixed stackoverflow error in continuous connection reconnect attempts.1.3.0 (2019-01-29)BugFixesAdded support for auto reconnect on token expiration and other auth errors (issue #89).FeaturesAdded ability to create ServiceBusClient from an existing SAS auth token, including
providing a function to auto-renew that token on expiry.Added support for storing a custom EPH context value in checkpoint (PR #84, thanks @konstantinmiller)1.2.0 (2018-11-29)Support for Python 2.7 in azure.eventhub module (azure.eventprocessorhost will not support Python 2.7).Parse EventData.enqueued_time as a UTC timestamp (issue #72, thanks @vjrantal)1.1.1 (2018-10-03)Fixed bug in Azure namespace package.1.1.0 (2018-09-21)Changes toAzureStorageCheckpointLeaseManagerparameters to support other connection options (issue #61):Thestorage_account_name,storage_account_keyandlease_container_namearguments are now optional keyword arguments.Added asas_tokenargument that must be specified withstorage_account_namein place ofstorage_account_key.Added anendpoint_suffixargument to support storage endpoints in National Clouds.Added aconnection_stringargument that, if specified, overrides all other endpoint arguments.Thelease_container_nameargument now defaults to"eph-leases"if not specified.Fix for clients failing to start if run called multipled times (issue #64).Added convenience methodsbody_as_strandbody_as_jsonto EventData object for easier processing of message data.1.0.0 (2018-08-22)API stable.Renamed internal_asyncmodule toasync_opsfor docs generation.Added optionalauth_timeoutparameter toEventHubClientandEventHubClientAsyncto configure how long to allow for token
negotiation to complete. Default is 60 seconds.Added optionalsend_timeoutparameter toEventHubClient.add_senderandEventHubClientAsync.add_async_senderto determine the
timeout for Events to be successfully sent. Default value is 60 seconds.Reformatted logging for performance.0.2.0 (2018-08-06)Stability improvements for EPH.Updated uAMQP version.Added new configuration options for Sender and Receiver;keep_aliveandauto_reconnect.
These flags have been added to the following:EventHubClient.add_receiverEventHubClient.add_senderEventHubClientAsync.add_async_receiverEventHubClientAsync.add_async_senderEPHOptions.keey_alive_intervalEPHOptions.auto_reconnect_on_error0.2.0rc2 (2018-07-29)Breaking changeEventData.offsetwill now return an object of type~uamqp.common.Offsetrather than str.
The original string value can be retrieved from~uamqp.common.Offset.value.Each sender/receiver will now run in its own independent connection.Updated uAMQP dependency to 0.2.0Fixed issue with IoTHub clients not being able to retrieve partition information.Added support for HTTP proxy settings to both EventHubClient and EPH.Added error handling policy to automatically reconnect on retryable error.Added keep-alive thread for maintaining an unused connection.0.2.0rc1 (2018-07-06)Breaking changeRestructured library to support Python 3.7. Submoduleasynchas been renamed and all classes from
this module can now be imported from azure.eventhub directly.Breaking changeRemoved optionalcallbackargument fromReceiver.receiveandAsyncReceiver.receive.Breaking changeEventData.propertieshas been renamed toEventData.application_properties.
This removes the potential for messages to be processed via callback for not yet returned
in the batch.Updated uAMQP dependency to v0.1.0Added support for constructing IoTHub connections.Fixed memory leak in receive operations.Dropped Python 2.7 wheel support.0.2.0b2 (2018-05-29)Addednamespace_suffixto EventHubConfig() to support national clouds.Addeddevice_idattribute to EventData to support IoT Hub use cases.Added message header to workaround service bug for PartitionKey support.Updated uAMQP dependency to vRC1.0.2.0b1 (2018-04-20)Updated uAMQP to latest version.Further testing and minor bug fixes.0.2.0a2 (2018-04-02)Updated uAQMP dependency.