ThingsBoard Python Client SDK 2.0 – Complete Architectural Rewrite Based on gmqtt

__init__.py

@@ -12,6 +12,3 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-
-__name__ = "tb_mqtt_client"

examples/device/claim_device.py

@@ -0,0 +1,68 @@
+#  Copyright 2025 ThingsBoard
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+# Example script to claim a device using ThingsBoard DeviceClient
+
+import asyncio
+import logging
+
+from tb_mqtt_client.common.config_loader import DeviceConfig
+from tb_mqtt_client.common.logging_utils import configure_logging, get_logger
+from tb_mqtt_client.common.publish_result import PublishResult
+from tb_mqtt_client.entities.data.claim_request import ClaimRequest
+from tb_mqtt_client.service.device.client import DeviceClient
+
+configure_logging()
+logger = get_logger(__name__)
+logger.setLevel(logging.INFO)
+logging.getLogger("tb_mqtt_client").setLevel(logging.INFO)
+
+# Constants for connection
+PLATFORM_HOST = "localhost"  # Replace with your ThingsBoard host
+DEVICE_ACCESS_TOKEN = "YOUR_ACCESS_TOKEN"  # Replace with your device's access token
+
+# Constants for claiming
+CLAIMING_DURATION = 120  # Default claiming duration in seconds
+CLAIMING_SECRET_KEY = "YOUR_SECRET_KEY"  # Replace with your actual secret key
+
+
+async def main():
+    # Create device config
+    config = DeviceConfig()
+    config.host = PLATFORM_HOST
+    config.access_token = DEVICE_ACCESS_TOKEN
+
+    # Create device client
+    client = DeviceClient(config)
+    await client.connect()
+
+    # Build claim request with secret key and optional duration (in seconds)
+    claim_request = ClaimRequest.build(secret_key=CLAIMING_SECRET_KEY, duration=CLAIMING_DURATION)
+
+    # Send claim request
+    result: PublishResult = await client.claim_device(claim_request,
+                                                      wait_for_publish=True,
+                                                      timeout=CLAIMING_DURATION + 10)
+    if result.is_successful():
+        logger.info(
+            f"Claiming request was sent successfully. "
+            f"Please use the secret key '{CLAIMING_SECRET_KEY}' to claim the device from the dashboard.")
+    else:
+        logger.error(f"Failed to send claiming request. Result: {result}")
+
+    await client.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/device/client_provisioning.py

@@ -1,70 +1,57 @@
-# Copyright 2025. ThingsBoard
+#  Copyright 2025 ThingsBoard
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
 #
-#  http://www.apache.org/licenses/LICENSE-2.0
+#       http://www.apache.org/licenses/LICENSE-2.0
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
 
+# Example script to device provisioning using the DeviceClient
 
+import asyncio
 import logging
-from tb_device_mqtt import TBDeviceMqttClient, TBPublishInfo
-logging.basicConfig(level=logging.DEBUG)
+from random import randint
 
+from tb_mqtt_client.common.logging_utils import configure_logging, get_logger
+from tb_mqtt_client.entities.data.provisioning_request import AccessTokenProvisioningCredentials, ProvisioningRequest
+from tb_mqtt_client.entities.data.timeseries_entry import TimeseriesEntry
+from tb_mqtt_client.service.device.client import DeviceClient
 
-def main():
-    """
-    We can provide the following parameters to provisioning function:
-      host - required - Host of ThingsBoard
-      provision_device_key - required - device provision key from device profile
-      provision_device_secret - required - device provision secret from device profile
-      port=1883 - not required - MQTT port of ThingsBoard instance
-      device_name=None - may be generated on ThingsBoard - You may pass here name for device, if this parameter is not assigned, the name will be generated
+configure_logging()
+logger = get_logger(__name__)
+logger.setLevel(logging.INFO)
+logging.getLogger("tb_mqtt_client").setLevel(logging.INFO)
 
-      ### Credentials type = ACCESS_TOKEN
 
-      access_token=None - may be generated on ThingsBoard - You may pass here some access token and it will be saved as accessToken for device on ThingsBoard.
+async def main():
+    provisioning_credentials = AccessTokenProvisioningCredentials(
+        provision_device_key='YOUR_PROVISION_DEVICE_KEY',
+        provision_device_secret='YOUR_PROVISION_DEVICE_SECRET',
+    )
+    provisioning_request = ProvisioningRequest('localhost', credentials=provisioning_credentials)
+    provisioning_response = await DeviceClient.provision(provisioning_request)
 
-      ### Credentials type = MQTT_BASIC
+    if provisioning_response.error is not None:
+        logger.error(f"Provisioning failed: {provisioning_response.error}")
+        return
 
-      client_id=None - not required (if username is not None) - You may pass here client Id for your device and use it later for connecting
-      username=None - not required (if client id is not None) - You may pass here username for your client and use it later for connecting
-      password=None - not required - You may pass here password and use it later for connecting
+    logger.info('Provisioned device configuration: ', provisioning_response)
 
-      ### Credentials type = X509_CERTIFICATE
-      hash=None - required (If you want to use this credentials type) - You should pass here public key of the device, generated from mqttserver.jks
+    # Create a DeviceClient instance with the provisioned device configuration
+    client = DeviceClient(provisioning_response.result)
+    await client.connect()
 
-    """
+    # Send single telemetry entry to the provisioned device
+    await client.send_timeseries(TimeseriesEntry("batteryLevel", randint(0, 100)))
 
-    # Call device provisioning, to do this we don't need an instance of the TBDeviceMqttClient to provision device
+    await client.stop()
 
-    THINGSBOARD_HOST = "mqtt.thingsboard.cloud"
 
-    credentials = TBDeviceMqttClient.provision(THINGSBOARD_HOST, "PROVISION_DEVICE_KEY", "PROVISION_DEVICE_SECRET")
-
-    if credentials is not None and credentials.get("status") == "SUCCESS":
-        username = None
-        password = None
-        client_id = None
-        if credentials["credentialsType"] == "ACCESS_TOKEN":
-            username = credentials["credentialsValue"]
-        elif credentials["credentialsType"] == "MQTT_BASIC":
-            username = credentials["credentialsValue"]["userName"]
-            password = credentials["credentialsValue"]["password"]
-            client_id = credentials["credentialsValue"]["clientId"]
-
-        client = TBDeviceMqttClient(THINGSBOARD_HOST, username=username, password=password, client_id=client_id)
-        client.connect()
-        # Other code
-
-        client.stop()
-
-
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    asyncio.run(main())

examples/device/firmware_update.py

@@ -1,37 +1,57 @@
-# Copyright 2025. ThingsBoard
+#  Copyright 2025 ThingsBoard
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
 #
-#  http://www.apache.org/licenses/LICENSE-2.0
+#       http://www.apache.org/licenses/LICENSE-2.0
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
 
-import time
+# Example script to update firmware using the DeviceClient
+
+import asyncio
 import logging
-from tb_device_mqtt import TBDeviceMqttClient, FW_STATE_ATTR
+from time import monotonic
+
+from tb_mqtt_client.common.config_loader import DeviceConfig
+from tb_mqtt_client.common.logging_utils import configure_logging, get_logger
+from tb_mqtt_client.service.device.client import DeviceClient
+
+configure_logging()
+logger = get_logger(__name__)
+logger.setLevel(logging.INFO)
+logging.getLogger("tb_mqtt_client").setLevel(logging.INFO)
+
+firmware_received = asyncio.Event()
+firmware_update_timeout = 30
+
+
+async def firmware_update_callback(_, payload):
+    logger.info(f"Firmware update payload received: {payload}")
+    firmware_received.set()
 
-logging.basicConfig(level=logging.INFO)
 
+async def main():
+    config = DeviceConfig()
+    config.host = "localhost"
+    config.access_token = "YOUR_ACCESS_TOKEN"
 
-def main():
-    client = TBDeviceMqttClient("127.0.0.1", username="A2_TEST_TOKEN")
-    client.connect()
+    client = DeviceClient(config)
+    await client.connect()
 
-    client.get_firmware_update()
+    await client.update_firmware(on_received_callback=firmware_update_callback)
 
-    # Waiting for firmware to be delivered
-    while not client.current_firmware_info[FW_STATE_ATTR] == 'UPDATED':
-        time.sleep(1)
+    update_started = monotonic()
+    while not firmware_received.is_set() and monotonic() - update_started < firmware_update_timeout:
+        await asyncio.sleep(1)
 
-    client.disconnect()
-    client.stop()
+    await client.stop()
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    asyncio.run(main())