<h1 align="center">Idiomatic asyncio MQTT Client 🙌</h1>
<p align="center">
<a href="https://github.com/sbtinstruments/asyncio-mqtt/blob/main/LICENSE"><img alt="License: BSD-3-Clause" src="https://img.shields.io/github/license/sbtinstruments/asyncio-mqtt"></a>
<a href="https://pypi.org/project/asyncio-mqtt"><img alt="PyPI version" src="https://img.shields.io/pypi/v/asyncio-mqtt"></a>
<a href="https://pypi.org/project/asyncio-mqtt"><img alt="Supported Python versions" src="https://img.shields.io/pypi/pyversions/asyncio-mqtt.svg"></a>
<a href="https://pypi.org/project/asyncio-mqtt"><img alt="PyPI downloads" src="https://img.shields.io/pypi/dm/asyncio-mqtt"></a>
<a href="https://github.com/sbtinstruments/asyncio-mqtt/actions/workflows/test.yml"><img alt="Coverage" src="https://github.com/sbtinstruments/asyncio-mqtt/actions/workflows/test.yml/badge.svg"></a>
<a href="https://codecov.io/gh/sbtinstruments/asyncio-mqtt"><img alt="Coverage" src="https://img.shields.io/codecov/c/github/sbtinstruments/asyncio-mqtt"></a>
<a href="https://results.pre-commit.ci/latest/github/sbtinstruments/asyncio-mqtt/master"><img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/sbtinstruments/asyncio-mqtt/master.svg"></a>
<a href="https://github.com/sbtinstruments/asyncio-mqtt"><img alt="Typing: strict" src="https://img.shields.io/badge/typing-strict-green.svg"></a>
<a href="https://github.com/sbtinstruments/asyncio-mqtt"><img alt="Code Style: Black" src="https://img.shields.io/badge/code%20style-black-black"></a>
</p>
Write code like this:
**Subscriber**
```python
async with Client("test.mosquitto.org") as client:
async with client.messages() as messages:
await client.subscribe("humidity/#")
async for message in messages:
print(message.payload)
```
**Publisher**
```python
async with Client("test.mosquitto.org") as client:
await client.publish("humidity/outside", payload=0.38)
```
_asyncio-mqtt_ combines the stability of the time-proven [paho-mqtt](https://github.com/eclipse/paho.mqtt.python) library with a modern, asyncio-based interface.
- No more callbacks! 👍
- No more return codes (welcome to the `MqttError`)
- Graceful disconnection (forget about `on_unsubscribe`, `on_disconnect`, etc.)
- Compatible with `async` code
- Fully type-hinted
- Did we mention no more callbacks?
The whole thing is less than [700 lines of code](asyncio-mqtt/client.py).
## Contents 🔍
- [Installation](#installation-)
- [Note for Windows users](#note-for-windows-users)
- [Advanced usage](#advanced-usage-)
- [Configuring the client](#configuring-the-client)
- [Filtering messages](#filtering-messages)
- [Sharing the connection](#sharing-the-connection)
- [Side by side with web frameworks](#side-by-side-with-web-frameworks)
- [Why can't I `connect`/`disconnect` manually?](#why-cant-i-connectdisconnect-manually)
- [Listening without blocking](#listening-without-blocking)
- [Reconnecting](#reconnecting)
- [TLS](#tls)
- [Proxying](#proxying)
- [License](#license-)
- [Versioning](#versioning-)
- [Changelog](#changelog-)
- [Related projects](#related-projects-)
## Installation 📚
_asyncio-mqtt_ can be installed via `pip install asyncio-mqtt`. It requires Python 3.7+ to run. The only dependency is [paho-mqtt](https://github.com/eclipse/paho.mqtt.python).
If you can't wait for the latest version and want to install directly from GitHub, use:
`pip install git+https://github.com/sbtinstruments/asyncio-mqtt`
### Note for Windows users
Since Python 3.8, the default asyncio event loop is the `ProactorEventLoop`. Said loop [doesn't support the `add_reader` method](https://docs.python.org/3/library/asyncio-platforms.html#windows) that is required by _asyncio-mqtt_. Please switch to an event loop that supports the `add_reader` method such as the built-in `SelectorEventLoop`:
```python
# Change to the "Selector" event loop
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
# Run your async application as usual
asyncio.run(main())
```
## Advanced usage ⚡
Let's make the example from before more interesting:
### Configuring the client
You can configure quite a few things when initializing the client. These are all the possible parameters together with their default values. See [paho-mqtt's documentation](https://github.com/eclipse/paho.mqtt.python) for more information about the individual parameters.
```python
import asyncio_mqtt as aiomqtt
import paho.mqtt as mqtt
aiomqtt.Client(
hostname="test.mosquitto.org", # The only non-optional parameter
port=1883,
username=None,
password=None,
logger=None,
client_id=None,
tls_context=None,
tls_params=None,
proxy=None,
protocol=None,
will=None,
clean_session=None,
transport="tcp",
keepalive=60,
bind_address="",
bind_port=0,
clean_start=mqtt.client.MQTT_CLEAN_START_FIRST_ONLY,
properties=None,
message_retry_set=20,
socket_options=(),
max_concurrent_outgoing_calls=None,
websocket_path=None,
websocket_headers=None,
)
```
### Filtering messages
Imagine you're measuring temperature and humidity on the outside and inside, and our topics look like this: `temperature/outside`. You want to receive all types of measurements but handle them differently. _asyncio-mqtt_ provides `Topic.matches()` to make this easy:
```python
import asyncio
import asyncio_mqtt as aiomqtt
async def main():
async with aiomqtt.Client("test.mosquitto.org") as client:
async with client.messages() as messages:
await client.subscribe("#")
async for message in messages:
if message.topic.matches("humidity/outside"):
print(f"[humidity/outside] {message.payload}")
if message.topic.matches("+/inside"):
print(f"[+/inside] {message.payload}")
if message.topic.matches("temperature/#"):
print(f"[temperature/#] {message.payload}")
asyncio.run(main())
```
Note that in our example, messages to `temperature/inside` are handled twice!
### Sharing the connection
In many cases, you'll want to send and receive messages in different locations in your code. You could create a new client each time, but
1. this is not very performant, and
2. you'll use a lot more network bandwidth.
You can share the connection by passing the `Client` instance to all functions that need it:
```python
import asyncio
import asyncio_mqtt as aiomqtt
async def publish_humidity(client):
await client.publish("humidity/outside", payload=0.38)
async def publish_temperature(client):
await client.publish("temperature/outside", payload=28.3)
async def main():
async with aiomqtt.Client("test.mosquitto.org") as client:
await publish_humidity(client)
await publish_temperature(client)
asyncio.run(main())
```
#### Side by side with web frameworks
Most web frameworks take control over the "main" function, which makes it difficult to figure out where to create and connect the `Client` and how to share this connection.
Some frameworks like [Starlette](https://github.com/encode/starlette) directly support lifespan context managers, with which you can safely set up a global client instance that you can then pass to functions that need it, just like before:
```python
import asyncio
import asyncio_mqtt as aiomqtt
import starlette.applications
import contextlib
client = None
@contextlib.asynccontextmanager
async def lifespan(app):
global client
async with aiomqtt.Client("test.mosquitto.org") as c:
client = c
yield
app = starlette.applications.Starlette(
routes=[],
lifespan=lifespan,
)
```
FastAPI (which is built upon Starlette) doesn't expose that API yet, but there are [multiple](https://github.com/tiangolo/fastapi/pull/5503) [open PRs](https://github.com/tiangolo/fastapi/pull/2944) to add it. In the meantime, you can work around it via FastAPI's dependency injection.
#### Why can't I `connect`/`disconnect` manually?
Managing a connection by calling `connect` and `disconnect` directly is a bit tricky. For example, when you're disconnecting the client, you'd have to make sure that there's no other task that still relies on the connection. There are many similar situations where something can easily go wrong.
Context managers take care of all connection and disconnection logic for you, in a way that makes it very difficult to shoot yourself in the foot. They are a lot easier and less error-prone to use than `connect`/`disconnect`.
Supporting both context managers and manual `connect`/`disconnect` would add a lot of complexity to _asyncio-mqtt_. To keep maintainer burden manageable, we focus only on the preferred option: context managers.
### Listening without blocking
If you run the basic example for subscribing and listening for messages, you'll notice that the program doesn't finish until you stop it. Waiting for messages blocks the execution of everything that comes afterwards. If you want to run other code after starting your listener (e.g. handling HTTP requests in a web framework) you don't want this.
To solve this, you can use asyncio's `create_task` without `await`ing the created task. The concept is similar to starting a new thread without `join`ing it in a multithreaded application.
```python
import asyncio
import asyncio_mqtt as aiomqtt
async def listen():
async with aiomqtt.Client("test.mosquitto.org") as client:
async with client.messages() as messages:
await client.subscribe("humidity/#")
async for message in messages:
print(message.payload)
async def main():
# Wait for messages in (unawaited) asyncio task
loop = asyncio.get_event_loop()
task = loop.create_task(listen())
# This will still run!
print("Magic!")
# If you don't await the task here the program will simply finish.
# However, if you're using an async web framework you usually don't have to await
# the task, as the framework runs in an endless loop.
await task
asyncio.run(main())
```
### Reconnecting
You can reconnect when the connection to the broker is lost by wrapping your code in a `try/except`-block and listening for `MqttError`s.
```python
import asyncio
import asyncio_mqtt as aiomqtt
async def main():
reconnect_interval = 5 # In seconds
while True:
try:
async with aiomqtt.Client("test.mosquitto.org") as client:
async with client.messages() as messages:
await client.subscribe("humidity/#")
async for message in messages:
print(message.payload.decode())
except aiomqtt.MqttError as error:
print(f'Error "{error}". Reconnecting in {reconnect_interval} seconds.')
await asyncio.sleep(reconnect_interval)
asyncio.run(main())
```
### TLS
You can configure TLS via the `TLSParameters` class. The parameters are directly passed through to paho-mqtt's `tls_set` function. See [paho-mqtt's documentation](https://github.com/eclipse/paho.mqtt.python) for more information about the individual parameters.
```python
import asyncio
import asyncio_mqtt as aiomqtt
import ssl
tls_params = aiomqtt.TLSParameters(
ca_certs=None,
certfile=None,
keyfile=None,
cert_reqs=ssl.CERT_REQUIRED,
tls_version=ssl.PROTOCOL_TLS,
ciphers=None,
)
async def main():
async with aiomqtt.Client("test.mosquitto.org", tls_params=tls_params) as client:
await client.publish("humidity/outside", payload=0.38)
asyncio.run(main())
```
### Proxying
You can configure proxying via the `ProxySettings` class. The parameters are directly passed through to paho-mqtt's `proxy_set` functionality. Both SOCKS and HTTP proxies are supported. Note that proxying is an extra feature (even in paho-mqtt) that requires the `PySocks` dependency. See [paho-mqtt's documentation](https://github.com/eclipse/paho.mqtt.python) for more information about the individual parameters.
```python
import asyncio
import asyncio_mqtt as aiomqtt
import socks
proxy_params = aiomqtt.ProxySettings(
proxy_type=socks.HTTP,
proxy_addr="www.example.com",
proxy_rdns=True,
proxy_username=None,
proxy_password=None,
)
async def main():
async with aiomqtt.Client("test.mosquitto.org", proxy=proxy_params) as client:
await client.publish("humidity/outside", payload=0.38)
asyncio.run(main())
```
## License 📋
<a href="https://github.com/sbtinstruments/asyncio-mqtt/blob/main/LICENSE"><img alt="License: BSD-3-Clause" src="https://img.shields.io/github/license/sbtinstruments/asyncio-mqtt"></a>
Note that the underlying paho-mqtt library is dual-licensed. One of the licenses is the so-called [Eclipse Distribution License v1.0](https://www.eclipse.org/org/documents/edl-v10.php). It is almost word-for-word identical to the [BSD 3-clause License](https://opensource.org/licenses/BSD-3-Clause). The only differences are:
- One use of "COPYRIGHT OWNER" (EDL) instead of "COPYRIGHT HOLDER" (BSD)
- One use of "Eclipse Foundation, Inc." (EDL) instead of "copyright holder" (BSD)
## Versioning 🎯
<a href="https://pypi.org/project/asyncio-mqtt"><img alt="PyPI" src="https://img.shields.io/pypi/v/asyncio-mqtt"></a>
This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
Expect API changes until we reach version `1.0.0`. After `1.0.0`, breaking changes will only occur in major release (e.g., `2.0.0`, `3.0.0`, etc.).
## Changelog 🚧
Please refer to the [CHANGELOG](https://github.com/sbtinstruments/asyncio-mqtt/blob/master/CHANGELOG.md) document. It adheres to the principles of [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## Related projects 🌟
Is _asyncio-mqtt_ not what you are looking for? Try another client:
- [paho-mqtt](https://github.com/eclipse/paho.mqtt.python) — Own protocol implementation. Synchronous.<br> 
- [gmqtt](https://github.com/wialon/gmqtt) — Own protocol implementation. Asynchronous.<br> 
- [fastapi-mqtt](https://github.com/sabuhish/fastapi-mqtt) — Asynchronous wrapper around gmqtt. Simplifies integration in your FastAPI application.<br> 
- [amqtt](https://github.com/Yakifo/amqtt) — Own protocol implementation. Asynchronous. Includes a broker.<br> 
- [mqttools](https://github.com/eerimoq/mqttools) — Own protocol implementation. Asynchronous.<br> 
- [trio-paho-mqtt](https://github.com/bkanuka/trio-paho-mqtt) — Asynchronous wrapper around paho-mqtt (similar to _asyncio-mqtt_). Based on trio instead of asyncio.<br> 
Raw data
{
"_id": null,
"home_page": "",
"name": "asyncio-mqtt",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.7",
"maintainer_email": "Jonathan Plasse <jonathan.plasse@live.fr>, Felix B\u00f6hm <felix@felixboehm.dev>",
"keywords": "mqtt,async,asyncio,paho-mqtt,wrapper",
"author": "",
"author_email": "Frederik Aalund <fpa@sbtinstruments.com>",
"download_url": "",
"platform": null,
"description": "<h1 align=\"center\">Idiomatic asyncio MQTT Client \ud83d\ude4c</h1>\n<p align=\"center\">\n <a href=\"https://github.com/sbtinstruments/asyncio-mqtt/blob/main/LICENSE\"><img alt=\"License: BSD-3-Clause\" src=\"https://img.shields.io/github/license/sbtinstruments/asyncio-mqtt\"></a>\n <a href=\"https://pypi.org/project/asyncio-mqtt\"><img alt=\"PyPI version\" src=\"https://img.shields.io/pypi/v/asyncio-mqtt\"></a>\n <a href=\"https://pypi.org/project/asyncio-mqtt\"><img alt=\"Supported Python versions\" src=\"https://img.shields.io/pypi/pyversions/asyncio-mqtt.svg\"></a>\n <a href=\"https://pypi.org/project/asyncio-mqtt\"><img alt=\"PyPI downloads\" src=\"https://img.shields.io/pypi/dm/asyncio-mqtt\"></a>\n <a href=\"https://github.com/sbtinstruments/asyncio-mqtt/actions/workflows/test.yml\"><img alt=\"Coverage\" src=\"https://github.com/sbtinstruments/asyncio-mqtt/actions/workflows/test.yml/badge.svg\"></a>\n <a href=\"https://codecov.io/gh/sbtinstruments/asyncio-mqtt\"><img alt=\"Coverage\" src=\"https://img.shields.io/codecov/c/github/sbtinstruments/asyncio-mqtt\"></a>\n <a href=\"https://results.pre-commit.ci/latest/github/sbtinstruments/asyncio-mqtt/master\"><img alt=\"pre-commit.ci status\" src=\"https://results.pre-commit.ci/badge/github/sbtinstruments/asyncio-mqtt/master.svg\"></a>\n <a href=\"https://github.com/sbtinstruments/asyncio-mqtt\"><img alt=\"Typing: strict\" src=\"https://img.shields.io/badge/typing-strict-green.svg\"></a>\n <a href=\"https://github.com/sbtinstruments/asyncio-mqtt\"><img alt=\"Code Style: Black\" src=\"https://img.shields.io/badge/code%20style-black-black\"></a>\n</p>\n\nWrite code like this:\n\n**Subscriber**\n\n```python\nasync with Client(\"test.mosquitto.org\") as client:\n async with client.messages() as messages:\n await client.subscribe(\"humidity/#\")\n async for message in messages:\n print(message.payload)\n```\n\n**Publisher**\n\n```python\nasync with Client(\"test.mosquitto.org\") as client:\n await client.publish(\"humidity/outside\", payload=0.38)\n```\n\n_asyncio-mqtt_ combines the stability of the time-proven [paho-mqtt](https://github.com/eclipse/paho.mqtt.python) library with a modern, asyncio-based interface.\n\n- No more callbacks! \ud83d\udc4d\n- No more return codes (welcome to the `MqttError`)\n- Graceful disconnection (forget about `on_unsubscribe`, `on_disconnect`, etc.)\n- Compatible with `async` code\n- Fully type-hinted\n- Did we mention no more callbacks?\n\nThe whole thing is less than [700 lines of code](asyncio-mqtt/client.py).\n\n## Contents \ud83d\udd0d\n\n- [Installation](#installation-)\n - [Note for Windows users](#note-for-windows-users)\n- [Advanced usage](#advanced-usage-)\n - [Configuring the client](#configuring-the-client)\n - [Filtering messages](#filtering-messages)\n - [Sharing the connection](#sharing-the-connection)\n - [Side by side with web frameworks](#side-by-side-with-web-frameworks)\n - [Why can't I `connect`/`disconnect` manually?](#why-cant-i-connectdisconnect-manually)\n - [Listening without blocking](#listening-without-blocking)\n - [Reconnecting](#reconnecting)\n - [TLS](#tls)\n - [Proxying](#proxying)\n- [License](#license-)\n- [Versioning](#versioning-)\n- [Changelog](#changelog-)\n- [Related projects](#related-projects-)\n\n## Installation \ud83d\udcda\n\n_asyncio-mqtt_ can be installed via `pip install asyncio-mqtt`. It requires Python 3.7+ to run. The only dependency is [paho-mqtt](https://github.com/eclipse/paho.mqtt.python).\n\nIf you can't wait for the latest version and want to install directly from GitHub, use:\n\n`pip install git+https://github.com/sbtinstruments/asyncio-mqtt`\n\n### Note for Windows users\n\nSince Python 3.8, the default asyncio event loop is the `ProactorEventLoop`. Said loop [doesn't support the `add_reader` method](https://docs.python.org/3/library/asyncio-platforms.html#windows) that is required by _asyncio-mqtt_. Please switch to an event loop that supports the `add_reader` method such as the built-in `SelectorEventLoop`:\n\n```python\n# Change to the \"Selector\" event loop\nasyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())\n# Run your async application as usual\nasyncio.run(main())\n```\n\n## Advanced usage \u26a1\n\nLet's make the example from before more interesting:\n\n### Configuring the client\n\nYou can configure quite a few things when initializing the client. These are all the possible parameters together with their default values. See [paho-mqtt's documentation](https://github.com/eclipse/paho.mqtt.python) for more information about the individual parameters.\n\n```python\nimport asyncio_mqtt as aiomqtt\nimport paho.mqtt as mqtt\n\n\naiomqtt.Client(\n hostname=\"test.mosquitto.org\", # The only non-optional parameter\n port=1883,\n username=None,\n password=None,\n logger=None,\n client_id=None,\n tls_context=None,\n tls_params=None,\n proxy=None,\n protocol=None,\n will=None,\n clean_session=None,\n transport=\"tcp\",\n keepalive=60,\n bind_address=\"\",\n bind_port=0,\n clean_start=mqtt.client.MQTT_CLEAN_START_FIRST_ONLY,\n properties=None,\n message_retry_set=20,\n socket_options=(),\n max_concurrent_outgoing_calls=None,\n websocket_path=None,\n websocket_headers=None,\n)\n```\n\n### Filtering messages\n\nImagine you're measuring temperature and humidity on the outside and inside, and our topics look like this: `temperature/outside`. You want to receive all types of measurements but handle them differently. _asyncio-mqtt_ provides `Topic.matches()` to make this easy:\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\n\n\nasync def main():\n async with aiomqtt.Client(\"test.mosquitto.org\") as client:\n async with client.messages() as messages:\n await client.subscribe(\"#\")\n async for message in messages:\n if message.topic.matches(\"humidity/outside\"):\n print(f\"[humidity/outside] {message.payload}\")\n if message.topic.matches(\"+/inside\"):\n print(f\"[+/inside] {message.payload}\")\n if message.topic.matches(\"temperature/#\"):\n print(f\"[temperature/#] {message.payload}\")\n\n\nasyncio.run(main())\n```\n\nNote that in our example, messages to `temperature/inside` are handled twice!\n\n### Sharing the connection\n\nIn many cases, you'll want to send and receive messages in different locations in your code. You could create a new client each time, but\n\n1. this is not very performant, and\n2. you'll use a lot more network bandwidth.\n\nYou can share the connection by passing the `Client` instance to all functions that need it:\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\n\n\nasync def publish_humidity(client):\n await client.publish(\"humidity/outside\", payload=0.38)\n\n\nasync def publish_temperature(client):\n await client.publish(\"temperature/outside\", payload=28.3)\n\n\nasync def main():\n async with aiomqtt.Client(\"test.mosquitto.org\") as client:\n await publish_humidity(client)\n await publish_temperature(client)\n\n\nasyncio.run(main())\n```\n\n#### Side by side with web frameworks\n\nMost web frameworks take control over the \"main\" function, which makes it difficult to figure out where to create and connect the `Client` and how to share this connection.\n\nSome frameworks like [Starlette](https://github.com/encode/starlette) directly support lifespan context managers, with which you can safely set up a global client instance that you can then pass to functions that need it, just like before:\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\nimport starlette.applications\nimport contextlib\n\n\nclient = None\n\n\n@contextlib.asynccontextmanager\nasync def lifespan(app):\n global client\n async with aiomqtt.Client(\"test.mosquitto.org\") as c:\n client = c\n yield\n\n\napp = starlette.applications.Starlette(\n routes=[],\n lifespan=lifespan,\n)\n```\n\nFastAPI (which is built upon Starlette) doesn't expose that API yet, but there are [multiple](https://github.com/tiangolo/fastapi/pull/5503) [open PRs](https://github.com/tiangolo/fastapi/pull/2944) to add it. In the meantime, you can work around it via FastAPI's dependency injection.\n\n#### Why can't I `connect`/`disconnect` manually?\n\nManaging a connection by calling `connect` and `disconnect` directly is a bit tricky. For example, when you're disconnecting the client, you'd have to make sure that there's no other task that still relies on the connection. There are many similar situations where something can easily go wrong.\n\nContext managers take care of all connection and disconnection logic for you, in a way that makes it very difficult to shoot yourself in the foot. They are a lot easier and less error-prone to use than `connect`/`disconnect`.\n\nSupporting both context managers and manual `connect`/`disconnect` would add a lot of complexity to _asyncio-mqtt_. To keep maintainer burden manageable, we focus only on the preferred option: context managers.\n\n### Listening without blocking\n\nIf you run the basic example for subscribing and listening for messages, you'll notice that the program doesn't finish until you stop it. Waiting for messages blocks the execution of everything that comes afterwards. If you want to run other code after starting your listener (e.g. handling HTTP requests in a web framework) you don't want this.\n\nTo solve this, you can use asyncio's `create_task` without `await`ing the created task. The concept is similar to starting a new thread without `join`ing it in a multithreaded application.\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\n\n\nasync def listen():\n async with aiomqtt.Client(\"test.mosquitto.org\") as client:\n async with client.messages() as messages:\n await client.subscribe(\"humidity/#\")\n async for message in messages:\n print(message.payload)\n\n\nasync def main():\n # Wait for messages in (unawaited) asyncio task\n loop = asyncio.get_event_loop()\n task = loop.create_task(listen())\n # This will still run!\n print(\"Magic!\")\n # If you don't await the task here the program will simply finish.\n # However, if you're using an async web framework you usually don't have to await\n # the task, as the framework runs in an endless loop.\n await task\n\n\nasyncio.run(main())\n```\n\n### Reconnecting\n\nYou can reconnect when the connection to the broker is lost by wrapping your code in a `try/except`-block and listening for `MqttError`s.\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\n\n\nasync def main():\n reconnect_interval = 5 # In seconds\n while True:\n try:\n async with aiomqtt.Client(\"test.mosquitto.org\") as client:\n async with client.messages() as messages:\n await client.subscribe(\"humidity/#\")\n async for message in messages:\n print(message.payload.decode())\n except aiomqtt.MqttError as error:\n print(f'Error \"{error}\". Reconnecting in {reconnect_interval} seconds.')\n await asyncio.sleep(reconnect_interval)\n\n\n\nasyncio.run(main())\n```\n\n### TLS\n\nYou can configure TLS via the `TLSParameters` class. The parameters are directly passed through to paho-mqtt's `tls_set` function. See [paho-mqtt's documentation](https://github.com/eclipse/paho.mqtt.python) for more information about the individual parameters.\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\nimport ssl\n\n\ntls_params = aiomqtt.TLSParameters(\n ca_certs=None,\n certfile=None,\n keyfile=None,\n cert_reqs=ssl.CERT_REQUIRED,\n tls_version=ssl.PROTOCOL_TLS,\n ciphers=None,\n)\n\n\nasync def main():\n async with aiomqtt.Client(\"test.mosquitto.org\", tls_params=tls_params) as client:\n await client.publish(\"humidity/outside\", payload=0.38)\n\n\nasyncio.run(main())\n```\n\n### Proxying\n\nYou can configure proxying via the `ProxySettings` class. The parameters are directly passed through to paho-mqtt's `proxy_set` functionality. Both SOCKS and HTTP proxies are supported. Note that proxying is an extra feature (even in paho-mqtt) that requires the `PySocks` dependency. See [paho-mqtt's documentation](https://github.com/eclipse/paho.mqtt.python) for more information about the individual parameters.\n\n```python\nimport asyncio\nimport asyncio_mqtt as aiomqtt\nimport socks\n\n\nproxy_params = aiomqtt.ProxySettings(\n proxy_type=socks.HTTP,\n proxy_addr=\"www.example.com\",\n proxy_rdns=True,\n proxy_username=None,\n proxy_password=None,\n)\n\nasync def main():\n async with aiomqtt.Client(\"test.mosquitto.org\", proxy=proxy_params) as client:\n await client.publish(\"humidity/outside\", payload=0.38)\n\n\nasyncio.run(main())\n```\n\n## License \ud83d\udccb\n\n<a href=\"https://github.com/sbtinstruments/asyncio-mqtt/blob/main/LICENSE\"><img alt=\"License: BSD-3-Clause\" src=\"https://img.shields.io/github/license/sbtinstruments/asyncio-mqtt\"></a>\n\nNote that the underlying paho-mqtt library is dual-licensed. One of the licenses is the so-called [Eclipse Distribution License v1.0](https://www.eclipse.org/org/documents/edl-v10.php). It is almost word-for-word identical to the [BSD 3-clause License](https://opensource.org/licenses/BSD-3-Clause). The only differences are:\n\n- One use of \"COPYRIGHT OWNER\" (EDL) instead of \"COPYRIGHT HOLDER\" (BSD)\n- One use of \"Eclipse Foundation, Inc.\" (EDL) instead of \"copyright holder\" (BSD)\n\n## Versioning \ud83c\udfaf\n\n<a href=\"https://pypi.org/project/asyncio-mqtt\"><img alt=\"PyPI\" src=\"https://img.shields.io/pypi/v/asyncio-mqtt\"></a>\n\nThis project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\nExpect API changes until we reach version `1.0.0`. After `1.0.0`, breaking changes will only occur in major release (e.g., `2.0.0`, `3.0.0`, etc.).\n\n## Changelog \ud83d\udea7\n\nPlease refer to the [CHANGELOG](https://github.com/sbtinstruments/asyncio-mqtt/blob/master/CHANGELOG.md) document. It adheres to the principles of [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).\n\n## Related projects \ud83c\udf1f\n\nIs _asyncio-mqtt_ not what you are looking for? Try another client:\n\n- [paho-mqtt](https://github.com/eclipse/paho.mqtt.python) \u2014 Own protocol implementation. Synchronous.<br> \n- [gmqtt](https://github.com/wialon/gmqtt) \u2014 Own protocol implementation. Asynchronous.<br> \n- [fastapi-mqtt](https://github.com/sabuhish/fastapi-mqtt) \u2014 Asynchronous wrapper around gmqtt. Simplifies integration in your FastAPI application.<br> \n- [amqtt](https://github.com/Yakifo/amqtt) \u2014 Own protocol implementation. Asynchronous. Includes a broker.<br> \n- [mqttools](https://github.com/eerimoq/mqttools) \u2014 Own protocol implementation. Asynchronous.<br> \n- [trio-paho-mqtt](https://github.com/bkanuka/trio-paho-mqtt) \u2014 Asynchronous wrapper around paho-mqtt (similar to _asyncio-mqtt_). Based on trio instead of asyncio.<br> \n",
"bugtrack_url": null,
"license": "BSD 3-Clause License",
"summary": "Idiomatic asyncio wrapper around paho-mqtt",
"version": "0.16.2",
"project_urls": {
"Issue tracker": "https://github.com/sbtinstruments/asyncio-mqtt/issues",
"Source code": "https://github.com/sbtinstruments/asyncio-mqtt"
},
"split_keywords": [
"mqtt",
"async",
"asyncio",
"paho-mqtt",
"wrapper"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "2a64c8a8c2ed51f3c1f4b8d2f244424d3bad3fbd4333eb01589c6b00a6dd2c04",
"md5": "323bfb5cc533983d33bf9624ccbb3726",
"sha256": "fe70ea2c648b248779a7ff3d9218262cdd739083743dfaa7c0d52ba458a8ad71"
},
"downloads": -1,
"filename": "asyncio_mqtt-0.16.2-py3-none-any.whl",
"has_sig": false,
"md5_digest": "323bfb5cc533983d33bf9624ccbb3726",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.7",
"size": 17380,
"upload_time": "2023-06-26T19:46:48",
"upload_time_iso_8601": "2023-06-26T19:46:48.342377Z",
"url": "https://files.pythonhosted.org/packages/2a/64/c8a8c2ed51f3c1f4b8d2f244424d3bad3fbd4333eb01589c6b00a6dd2c04/asyncio_mqtt-0.16.2-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-06-26 19:46:48",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "sbtinstruments",
"github_project": "asyncio-mqtt",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "asyncio-mqtt"
}
JSON
