asyncua: Pure Python OPC-UA Client and Server Library

Warnings

• breaking Starting with version 1.2.0 (currently in beta), asyncua removes support for Python versions older than 3.10. Users on Python 3.9 or earlier must upgrade their Python environment before migrating to asyncua 1.2.x or later.
  Fix: Upgrade your Python environment to 3.10 or newer. For projects requiring older Python versions, stick to asyncua version 1.1.x or earlier.
• gotcha asyncua is an asyncio-based library. All network operations (connect, read, write, subscribe, disconnect, etc.) are coroutines and must be properly `await`ed within an `async` function. Forgetting `await` will result in coroutine objects not being run, leading to unexpected behavior or resource leaks.
  Fix: Ensure all asyncua methods are called with `await`. For example, use `await client.connect()` instead of `client.connect()`.
• gotcha Always ensure to call `await client.disconnect()` or use `async with Client(...)` for client connections to gracefully close the connection and release resources. Failing to do so can leave dangling connections and consume system resources unnecessarily.
  Fix: Wrap client connection logic in `try...finally` to ensure `await client.disconnect()` is called, or preferably, use `async with Client(...) as client:` which handles connection and disconnection automatically.
• gotcha When interacting with OPC-UA values, ensure correct handling of `asyncua.ua.Variant` and `asyncua.ua.VariantType`. Directly assigning Python types might work for simple cases, but explicit `ua.Variant` usage is often required for specific OPC-UA data types, especially when writing values.
  Fix: When writing values, explicitly construct `ua.Variant` objects with the correct `VariantType` if the default conversion is not sufficient, e.g., `await node.write_value(ua.Variant(123, ua.VariantType.Int32))`.

Install

• pip install asyncua Install stable version
• pip install --pre asyncua Install pre-release version (e.g., 1.2b)

Imports

• Client

  from asyncua import Client

• Server

  from asyncua import Server

• ua

  from asyncua import ua

  Import `ua` directly for convenient access to OPC-UA data types like Variant, NodeId, etc.
• Node

  from asyncua.common.node import Node

  While Node objects are common, they are usually obtained from Client/Server methods rather than instantiated directly. Direct import is for type hinting or advanced scenarios.

Quickstart

This quickstart demonstrates how to establish a basic OPC-UA client connection, retrieve the root node, and gracefully disconnect. It uses an environment variable for the server URL, which is a common practice for flexible deployment. Remember that `asyncua` is built on `asyncio`, so all client/server operations must be `await`ed within an `async` function.

import asyncio
from asyncua import Client, ua
import os

async def main():
    # Replace with your OPC-UA server endpoint
    server_url = os.environ.get('OPCUA_SERVER_URL', 'opc.tcp://localhost:4840/freeopcua/server/')
    
    # Client connection example
    client = Client(url=server_url)
    
    try:
        await client.connect()
        print(f"Connected to OPC-UA server at {server_url}")
        
        # Get the root node
        root = client.get_root_node()
        print(f"Root node: {root}")
        
        # Example: Read a variable (replace with actual node ID)
        # For example, to read a variable under Objects/MyObject/MyVariable
        # node_id_str = "ns=2;i=1001" # Example NodeId
        # my_variable = await client.get_node(node_id_str)
        # value = await my_variable.read_value()
        # print(f"Value of {node_id_str}: {value}")
        
        # You can browse nodes, subscribe to data changes, write values, etc.
        
    except Exception as e:
        print(f"Error connecting or interacting with server: {e}")
    finally:
        print("Disconnecting from OPC-UA server...")
        await client.disconnect()

if __name__ == '__main__':
    asyncio.run(main())