• Node ID
• Node Class
• Browse name
• display name
• Description

Node-IDs

• Numeric
  A numeric identifier simply denotes an unsigned number. The designation i is used for the sereralization of this identifier.
• String
  A string is a readable character string. During sereralization, the identifier is marked with s.
• Byte String (opaque)
  An opaque identifier is an identifier that has been created according to a namespace-specific scheme. This is converted into a Base64 string for serealization. This is effective, since characters that cannot be represented can also occur in the byte string. The letter used for the identification is b.
• GUID
  A GUID is a 16-byte hexadecimal number represented in the following format: uint32-uint16-uint16-uint16-uint8[2]-uint8[6] An example of a GUID is 9EAA3455-92B1-C9C6-89C8-2CA23723B2EB.

Node-Classes

• Object
  An object is used to create systems or subsystems. It does not matter if it is a physical or virtual system that is mapped. The following attributes are added to the basic attributes:
  • Event Note
    This signals which events can be monitored.
• Variable
  A variable is used to give content to an object. Since a variable represents a certain value, a variable has many more attributes:
  • DataType
    This is the node ID of the data type.
  • ValueRank
    The ValueRank indicates whether the data is a single value or a list of values. More precisely, the values can be scalar, one-dimensional array, or multidimensional array.
  • ArrayDimensions
    This element indicates how large the individual dimensions are. This attribute is only relevant if the data is not available as a scalar.
  • Value
    This is the value managed by the node. How this element is interpreted depends on the DataType, ValueRank and ArrayDimensions attributes.
  • Historizing
    This element specifies whether a history of the data is stored on the server.
  • AccessLevel
    This element specifies which authorizations are generally granted. Possible permissions are read and write the current value and read/write the history.
  • UserAccessLevel
    This element specifies which authorizations the current user has.
  • MinimumSamplingInterval
    This element specifies how fast the server can capture changes to a value. This is of particular interest if the server must first request the information from a subsystem.
• Methods
  Methods are functions that can be executed on the server.
  • Executable
    This attribute specifies whether the function is currently executable.
  • UserExecutable
    This attribute specifies whether the function can be executed by the current user.
• ReferenceType
  ReferenceTypes describe the relation between elements on the server. A detailed explanation of references can be found in the next section.
  • isAbstract
    This attribute specifies whether the type is an organizational element of the hierarchy or whether it can actually be used. If the type is abstract, it cannot be created, but can be used to address existing elements of a subtype. References are discussed in more detail in the later section.
  • symmetric
    This attribute indicates whether the reference is symmetric. If it is symmetric, then the reference in the opposite direction has the same meaning. An example of a non-symmetric reference is the parent-child relationship; for example: A is the parent of B and B is the child of A. An example of a symmetric reference is the sibling relationship.
  • inverseName
    If the reference is not symmetric, this element specifies the name of the inverted reference. In the previous example, the parent of was the regular name of the reference and is the child of is the name of the reverse reference.
• DataType
  A DataType defines how the data is to be interpreted. The data types specified by the OPC UA Foundation can be found in Namespace 0 and represent basic data types. In addition to the basic data types, it is also possible to define your own data types. However, it makes more sense to define variable types and object types.
  • isAbstract
    This attribute specifies, as with the references, whether it is an organizational element or not.
• VariableType
  A VariableType is used to define the type of a variable in order to give the data elements a meaning. This is especially interesting if you look at an example. Example: A node of the BaseVariableType, a generic variable type, is available on the server. The node represents a temperature. Now it is unknown whether the temperature is Celsius, Kelvin or Fahrenheit. However, when a Celsius type is defined and used, it is immediately clear how to interpret the data. Alternatively, a temperature data type can be defined, where the interpretation is declared in the description. However, this has the disadvantage that it is not immediately clear from the variable type how the data are to be interpreted.
  • DataType
    This is the node ID of the data type.
  • ValueRank
    The ValueRank indicates whether the data is a single value or a list of values. More precisely, the values can be scalar, one-dimensional array, or multidimensional array.
  • ArrayDimensions
    This element indicates how large the individual dimensions are. This attribute is only relevant if the data is not available as a scalar.
  • Value
    This is the value managed by the node. How this element is interpreted depends on the DataType, ValueRank and ArrayDimensions attributes.
  • isAbstract
    This attribute specifies, as with the references, whether it is an organizational element or not.
• ObjectType
  An ObjectType is used to ensure that an object has certain attributes when it is created. In object-oriented programming languages, this construct would also be called class.
  • isAbstract
    This attribute specifies, as with the references, whether it is an organizational element or not.
• View
  A view is a list of nodes that can be interesting for a particular task. For example, you can define a view that is interesting for maintenance and another view that is interesting for regular use. This does not require searching the entire address space of the server.
  • ContainsNoLoop
    This attribute specifies whether the displayed nodes build a circular hierarchy when you follow the references.
  • EventNotifier
    This attribute specifies whether events can be generated via this view (e.g. when data is changed) and whether the event history can be read and changed.

• Source
• Target
• Reference type

• Organisms
  This reference is used when objects or variables are combined in a folder. A folder is an object that is only used to combine information points. For example, folders are used in the standard information model to group all objects, all type definitions and all views.
• HasProperty
  This reference is used to map properties of objects and variables. Properties themselves cannot be sources of further references. An example of a property for a file would be the modification date.
• HasComponent
  This reference is used to define the contents of an object. Elements created using this reference type can still be the source for new references.
• HasOrderedComponent
  This reference is used to give methods to an object.

NodeId

ExpandedNodeId

NodeIDs werden verwendet um Datenelemente eines Servers zu bezeichnen. Darauf wurde im vorhergehenden Abschnitt bereits eingegangen. NodeIDs werden verwendet um lokal Nodes eines Servers zu identifizieren. ExpandedNodeIDs erlauben es, Nodes eines anderen Servers zu referenzieren. So wäre es zum Beispiel möglich alle Variablen und Objektdefinitionen auf einem zentralen Server zu hinterlegen, und diese von anderen Servern referenzieren zu lassen.

DateTime

DateTime wird verwendet, um einen Zeitstempel zu erzeugen.

DataValue

Dies bezeichnet einen Datenwert mit einem Statuscode und einem Zeitstempel.

QualifiedName

Ein QualifiedName bezeichnet einen String, der mit einem Namespace-index versehen ist. Der Browse-Name eines Nodes ist ein Beispiel für einen QualifiedName. Dieser wird in den Angaben dieser Übung wie folgt gekennzeichnet: qn=<namespaceIndex>;<name>

Number

This data type summarizes all numbers. The type of number is irrelevant.

Integer

UInteger

These are signed or unsigned integers. Here, the number indicates how many bits are available.

Float

Double

These are floating point numbers with single and double precision.

DiagnosticInfo

This data type provides detailed information in the event of an error.

Boolean

This data type represents a value that can be True or False.

String

ByteString

Strings and bytestrings are character strings. While strings consist of printable characters, bytestrings consist of all possible characters. Since a byte string very often contains characters that cannot be displayed, they are displayed in Base64 encoded form.

LocalizedText

A LocalizedText is a structure that communicates information in a certain language. A LocalizedText thus has two elements, the language in which the information exists and the information itself.

GUID

A 16 byte value used as a global unique identification number. The value consists of a 32-bit value, two 16-bit values and eight 8-bit values.

XMLElement

An XML element is an element of the Extensible Markup Language.

Discovery

• Browse
  When browsing, you specify a node and get all nodes that have the specified node as source of a reference. You can also filter for references and node classes. At this point, the abstract references mentioned above are helpful, as they cover a large number of concrete references. The following information is always returned for each node:
  • Reference
  • Node ID
  • Browsename
  • Displayname
  • Node Class
  Selected predefined elements of the standard information model of OPC-UA are:
  • qn=0;Root
    • qn=0;Objects
      • qn=0;Server
        • qn=0;NamespaceArray
        • qn=0;ServerArray
    • qn=0;Types
      • qn=0;DataTypes
      • qn=0;ObjectTypes
      • qn=0;ReferenceTypes
      • qn=0;VariableTypes
    • qn=0;Views
• BrowseNext
  This function can be used if not all nodes could be returned. This can be especially the case if more nodes were found than can be sent at once.
• TranslateBrowsePathToNodeID
  This service can be used to convert a browse path to a node ID. This is especially interesting if you know the name of the data point, but the node ID is unknown. Since you need the Node-ID to be able to address nodes, this service is unavoidable. The Browsepath is a list of browser names for each node. This functionality is especially important if the elements on the server can be described semantically or by an ontology.
• Register/Unregister Nodes
  With this functionality you can tell a server that the current connection will access more of the specified nodes. Two things happen. First, it reduces the amount of information that needs to be transferred. This is done by giving the client a numeric node ID, which is the easiest to transfer. Second, the server optimizes access to the data point itself so that writing to or executing from the node is more efficient. Unregister tells the server that the node is no longer needed. This functionality should not be used if the node is only read because there are more efficient mechanisms. These mechanisms are described in the Read/Write section.

Read

Write

Subscriptions and Monitored Items

• Anonymous
• username/password
• X509v3 Certificate
• WS-SecurityToken

• None - The communication is not encrypted.
• Basic128RSA15
• Basic256

Server/Client

Chained Server

Server to Server

Aggregating Server

• Server: engine.ie.technikum-wien.at
• Port: 4840

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
import time
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
import time
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        try:
            # Loop
            while True:
                print("connected with server")
                # Sleep
                time.sleep(1)
        except KeyboardInterrupt:
            pass
    finally:
        # Disconnect
        CLIENT.disconnect()

• Server: engine.ie.technikum-wien.at
• Port: 4840
• Username: student
• Password: student

#!/usr/bin/env python3
"""
This example shows how to connect to the server with credentials
"""
import time
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    USER = "student"
    PASS = "student"
    CREDENTIALS = "{}:{}".format(USER, PASS)
    # This syntax does provide credentials.
    CLIENT = Client("opc.tcp://{}@{}:{}/".format(CREDENTIALS, HOST, PORT))
    try:
        # Connect to the Server
        CLIENT.connect()
        try:
            # Loop
            while True:
                print("connected with server")
                # Sleep
                time.sleep(1)
        except KeyboardInterrupt:
            pass
    finally:
        # Disconnect
        CLIENT.disconnect()

• Namespace of the main server: opc.tcp://engine.ie.technikum-wien.at
• Namespace of the example server: opc.tcp://engine.ie.technikum-wien.at/OPCExamples
• NodeID of the example server: ns=1;s=OPC Examples

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        # There are multiple Namespaces on the Server and we want to query them
        NAMESPACES = CLIENT.get_namespace_array()
        print(">Namespaces")
        for namespace in NAMESPACES:
            print(" {}".format(namespace))

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        # There are multiple Namespaces on the Server and we want to query them
        NAMESPACES = CLIENT.get_namespace_array()
        print(">Namespaces")
        for namespace in NAMESPACES:
            print(" {}".format(namespace))
        # In order to browse, we need some node as a starting point.
        STARTNODE = CLIENT.get_objects_node()
        # The method get_children returns all children of the Node in question
        NODES = STARTNODE.get_children()
        print(">Browsing")
        print(" Children of: {}".format(STARTNODE.nodeid.to_string()))
        for node in NODES:
            print(" {} -- {} -- {}".format(
                node.nodeid.to_string(),                  # Short form of NodeID
                node.get_browse_name().to_string(),       # Short form
                ua.NodeClass(node.get_node_class()).name))# Name of the nodeclass

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        # There are multiple Namespaces on the Server and we want to query them
        NAMESPACES = CLIENT.get_namespace_array()
        print(">Namespaces")
        for namespace in NAMESPACES:
            print(" {}".format(namespace))
        # In order to browse, we need some node as a starting point.
        STARTNODE = CLIENT.get_objects_node()
        # The method get_children returns all children of the Node in question
        NODES = STARTNODE.get_children()
        print(">Browsing")
        print(" Children of: {}".format(STARTNODE.nodeid.to_string()))
        for node in NODES:
            print(" {} -- {} -- {}".format(
                node.nodeid.to_string(),                  # Short form of NodeID
                node.get_browse_name().to_string(),       # Short form
                ua.NodeClass(node.get_node_class()).name))# Name of the nodeclass
        # As we know the Node-ID, we can access the node directly
        STARTNODE = CLIENT.get_node("ns=1;s=OPC Examples")
        NODES = STARTNODE.get_children()
        print(" Children of: {}".format(STARTNODE.nodeid.to_string()))
        for node in NODES:
            print(" {} -- {} -- {}".format(
                node.nodeid.to_string(),                  # Short form of NodeID
                node.get_browse_name().to_string(),       # Short form
                ua.NodeClass(node.get_node_class()).name))# Name of the nodeclass
    finally:
        # Disconnect
        CLIENT.disconnect()

• Namespace of the node: opc.tcp://engine.ie.technikum-wien.at/OPCExamples
• Node ID part of the node to be read: s=ExampleVariable

#!/usr/bin/env python3
"""
This example shows how to read a variable from the server
"""
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExamples")
        # Get Node from the client based on the NodeID
        NODE = CLIENT.get_node("ns={};s=ExampleVariable".format(IDX))
        # Read the current value
        VALUE = NODE.get_value()
        # Print the Information
        print("{}: {}".format(NODE, VALUE))
    finally:
        # Disconnect
        CLIENT.disconnect()

• Namespace of the node: opc.tcp://engine.ie.technikum-wien.at/OPCExamples
• Node ID part of the node to be read: s=ExampleVariable

• __init__(self)
  After creating an instance of the class, a counter is initialized. The counter saves the number of value changes.
• __del__(self)
  If an instance of the class is deleted, a notification with the number of value changes will be exported.
• datachange_notification(self, node, value, _)
  This function is called, when a value change of the assigned node is registered. The parameter value contains the current value of the node. The parameter _ contains the row data of the notification, which does not have to be considered any further. The current value shall be exported in this exercise. Additionally, the counter is incremented at each value change. The function name datachange_notification is a default notation given by the OPC-UA library and is called automatically at value change when required in the main program. The correct implementation of the value change notification is explained in the next part.

#!/usr/bin/env python3
"""
This example shows how to create a subscription to a variable
"""
import time
from opcua import Client

class SubscriptionHandler(object): # pylint: disable=too-few-public-methods
    """
    Subsrciption handler.
    """
    def __init__(self):
        self.counter = 0

    def __del__(self):
        print("Observed {} datachanges".format(self.counter))

    def datachange_notification(self, node, value, _):
        """
        Function that's called when data is changed

        Args:
            node: The node id that had a datachange
            value: The current value
            _: The raw data of the notification

        Returns:
            None
        """
        print("{}: {}".format(node, value))
        self.counter = self.counter + 1

#!/usr/bin/env python3
"""
This example shows how to create a subscription to a variable
"""
import time
from opcua import Client

class SubscriptionHandler(object): # pylint: disable=too-few-public-methods
    """
    Subsrciption handler.
    """
    def __init__(self):
        self.counter = 0

    def __del__(self):
        print("Observed {} datachanges".format(self.counter))

    def datachange_notification(self, node, value, _):
        """
        Function that's called when data is changed

        Args:
            node: The node id that had a datachange
            value: The current value
            _: The raw data of the notification

        Returns:
            None
        """
        print("{}: {}".format(node, value))
        self.counter = self.counter + 1

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExamples")
        NODE = CLIENT.get_node("ns={};s=ExampleVariable".format(IDX))
        # Create a handler to work with the updated data
        HANDLER = SubscriptionHandler()
        # Create a subscription
        SUB = CLIENT.create_subscription(500, HANDLER)
        # Connect NodeIDs to the Subscription
        SUB.subscribe_data_change(NODE)
        try:
            # Loop -- only needed so the program doesn't stop right away
            while True:
                # Sleep
                time.sleep(1)
        except KeyboardInterrupt:
            pass
        SUB.delete()
    finally:
        CLIENT.disconnect()

Find out which data points can be reached via the node ns=1;s=OPC Exercises. Determine the node IDs in the specified namespace, the display name and the class.

#!/usr/bin/env python3
"""
This is an example-solution
"""
from opcua import Client

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        print("Nodes in ns={}:".format(IDX))
        NODE = CLIENT.get_node("ns=1;s=OPC Exercises")
        NODES = NODE.get_children()
        for node in NODES:
            if node.nodeid.NamespaceIndex != IDX: # Required as we get all children of the node
                continue
            print("{} -- {} -- {}".format(
                node.nodeid.to_string(),             # Get a short printable NodeId
                node.get_display_name().to_string(), # Get a short printable Display Name
                node.get_node_class().name))         # Get a short readbale nodeclass
    finally:
        CLIENT.disconnect()

Output the description of the nodes determined in the previous task. For the variables, read the values of the individual nodes over 10 seconds in 1-second intervals and output the values determined.

#!/usr/bin/env python3
"""
This is an example-solution
"""
import time
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        NODE = CLIENT.get_node("ns=1;s=OPC Exercises")
        NODES = NODE.get_children()
        for node in NODES:
            if node.nodeid.NamespaceIndex != IDX:
                continue
            print("{}: {}".format(node.nodeid.to_string(), node.get_description().to_string()))
            if node.get_node_class() == ua.NodeClass.Variable:
                values = []
                for i in range(10):
                    values.append(node.get_value())
                    time.sleep(1)
                print("Values: {}".format(values))
    finally:
        CLIENT.disconnect()

Determine which parameters the methods you found require and which results the methods deliver.

#!/usr/bin/env python3
"""
This is an example solution
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        PARENT = CLIENT.get_node("ns=1;s=OPC Exercises")
        for child in PARENT.get_children():
            if child.nodeid.NamespaceIndex != IDX:
                continue
            if child.get_node_class() != ua.NodeClass.Method:
                continue
            print("{}: {}".format(child.nodeid.to_string(), child.get_display_name().to_string()))
            for arg in child.get_children():
                print(arg.get_display_name().to_string())
                for param in arg.get_value():
                    print("{}: {}".format(param.Name, param.Description.to_string()))
    finally:
        CLIENT.disconnect()

Execute all found methods. If you need to provide input, you may choose any input you like.

#!/usr/bin/env python3
"""
This is an example solution
"""
from opcua import Client

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        METHOD1 = CLIENT.get_node("ns={};i=318".format(IDX))
        METHOD2 = CLIENT.get_node("ns={};i=320".format(IDX))
        PARENT = CLIENT.get_node("ns=1;s=OPC Exercises")
        for idx, res in enumerate(PARENT.call_method(METHOD1)):
            print("{}: {}".format(idx, res))
        RES = PARENT.call_method(METHOD2, "Test String")
        print(RES)
    finally:
        CLIENT.disconnect()

Subscribe to the variables for 10 seconds and display the received values afterwards.

#!/usr/bin/env python3
"""
This is an example-solution
"""
import time
from opcua import Client
from opcua import ua

class SubscriptionHandler(object): # pylint: disable=too-few-public-methods
    """
    Subsrciption handler.
    """
    def __init__(self):
        self.counter = 0
        self.items = {}

    def __del__(self):
        print("Observed {} datachanges".format(self.counter))
        for key, value in self.items.items():
            print("{} ({} values): {}".format(key.nodeid.to_string(), len(value), value))

    def datachange_notification(self, node, value, _):
        """
        Function that's called when data is changed

        Args:
            node: The node id that had a datachange
            value: The current value
            _: The raw data of the notification

        Returns:
            None
        """
        if node not in self.items.keys():
            self.items[node] = []
        self.items[node].append(value)
        self.counter = self.counter + 1

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        NODE = CLIENT.get_node("ns=1;s=OPC Exercises")
        NODES = NODE.get_children()
        HANDLER = SubscriptionHandler()
        SUB = CLIENT.create_subscription(500, HANDLER)
        for child in NODES:
            if child.nodeid.NamespaceIndex != IDX:
                continue
            if child.get_node_class() == ua.NodeClass(2):
                print("{}: {}".format(
                    child.nodeid.to_string(),
                    child.get_description().to_string()))
                SUB.subscribe_data_change(child)
        print("Setup done; sleep 10 Seconds")
        time.sleep(10)
        SUB.delete()
    finally:
        CLIENT.disconnect()