pip3 install vl-mqtt-client

from vl_device_mqtt import VLDeviceMqttClient, VLPublishInfo

telemetry = {"temperature": 41.9, "enabled": False, "currentFirmwareVersion": "v1.2.2"}
client = VLDeviceMqttClient("console.viralink.io", "A1_TEST_TOKEN")

# Connect to ViraLink
client.connect()

# Sending telemetry without checking the delivery status
client.send_telemetry(telemetry) 

# Sending telemetry and checking the delivery status (QoS = 1 by default)
result = client.send_telemetry(telemetry)

# get is a blocking call that awaits delivery status  
success = result.get() == VLPublishInfo.VL_ERR_SUCCESS

# Disconnect from ViraLink
client.disconnect()

from time import sleep
from vl_device_mqtt import VLDeviceMqttClient

def callback(result):
    print(result)

client = VLDeviceMqttClient("console.viralink.io", "A1_TEST_TOKEN")
client.connect()
client.subscribe_to_attribute("uploadFrequency", callback)
client.subscribe_to_all_attributes(callback)
while True:
    sleep(1)

from time import time
from vl_device_mqtt import VLDeviceMqttClient, VLPublishInfo


telemetry_with_ts = {"ts": int(round(time() * 1000)), "values": {"temperature": 42.1, "humidity": 70}}
client = VLDeviceMqttClient("console.viralink.io", "A1_TEST_TOKEN")
# we set maximum amount of messages sent to send them at the same time. it may stress memory but increases performance
client.max_inflight_messages_set(100)
client.connect()
results = []
result = True
for i in range(0, 100):
    results.append(client.send_telemetry(telemetry_with_ts))
for tmp_result in results:
    result &= tmp_result.get() == VLPublishInfo.VL_ERR_SUCCESS
print("Result", str(result))
client.disconnect()

from time import sleep
from vl_device_mqtt import VLDeviceMqttClient


def <strong>on_attributes_change</strong>(result, exception):
    if exception <strong>is</strong> <strong>not</strong> None:
        print("Exception:", str(exception))
    else:
        print(result)

client = VLDeviceMqttClient("console.viralink.io", "A1_TEST_TOKEN")
client.connect()
client.request_attributes(["configuration","targetFirmwareVersion"], callback=on_attributes_change)


while True:
    sleep(1)

from psutil import cpu_percent, virtual_memory
from time import sleep
from vl_device_mqtt import VLDeviceMqttClient


# dependently of request method we send different data back
def on_server_side_rpc_request(client, request_id, request_body):
    print(request_id, request_body)
    if request_body["method"] == "getCPULoad":
        client.send_rpc_reply(request_id, {"CPU percent": cpu_percent()})
    elif request_body["method"] == "getMemoryUsage":
        client.send_rpc_reply(request_id, {"Memory": virtual_memory().percent})

client = VLDeviceMqttClient("console.viralink.io", "A1_TEST_TOKEN")
client.set_server_side_rpc_request_handler(on_server_side_rpc_request)
client.connect()

from time import time
from vl_gateway_mqtt import VLGatewayMqttClient


gateway = VLGatewayMqttClient("console.viralink.io", "GATEWAY_TEST_TOKEN")
gateway.connect()
gateway.gw_connect_device("Test Device A1")

gateway.gw_send_telemetry("Test Device A1", {"ts": int(round(time() * 1000)), "values": {"temperature": 42.2}})
gateway.gw_send_attributes("Test Device A1", {"firmwareVersion": "2.3.1"})

gateway.gw_disconnect_device("Test Device A1")
gateway.disconnect()

from time import sleep
from vl_gateway_mqtt import VLGatewayMqttClient


def callback(result, exception):
    if exception is not None:
        print("Exception: " + str(exception))
    else:
        print(result)

gateway = VLGatewayMqttClient("console.viralink.io", "TEST_GATEWAY_TOKEN")
gateway.connect()
gateway.gw_request_shared_attributes("Test Device A1", ["temperature"], callback)

while True:
    sleep(1)

from time import sleep
from psutil import cpu_percent, virtual_memory
from vl_gateway_mqtt import VLGatewayMqttClient


def rpc_request_response(client, request_id, request_body):
    # request body contains id, method and other parameters
    print(request_body)
    method = request_body["data"]["method"]
    device = request_body["device"]
    req_id = request_body["data"]["id"]
    # dependently of request method we send different data back
    if method == 'getCPULoad':
        gateway.gw_send_rpc_reply(device, req_id, {"CPU load": cpu_percent()})
    elif method == 'getMemoryLoad':
        gateway.gw_send_rpc_reply(device, req_id, {"Memory": virtual_memory().percent})
    else:
        print('Unknown method: ' + method)

gateway = VLGatewayMqttClient("console.viralink.io", "TEST_GATEWAY_TOKEN")
gateway.connect()
# now rpc_request_response will process rpc requests from servers
gateway.gw_set_server_side_rpc_request_handler(rpc_request_response)
# without device connection it is impossible to get any messages
gateway.gw_connect_device("Test Device A1")

while True:
    sleep(1)