XmlExporter._make_idx_dict() - Code Metrics - Inspection of "also export namespace of referenced nodes" - FreeOpcUa/python-opcua - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#327)

by Olivier

created 2016-10-13 07:48 UTC

XmlExporter._make_idx_dict() A

↳ Parent: XmlExporter

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0

"""
from a list of nodes in the address space, build an XML file
format is the one from opc-ua specification
"""
import logging
from collections import OrderedDict
import xml.etree.ElementTree as Et
from copy import copy

from opcua import ua
from opcua.ua import object_ids as o_ids


class XmlExporter(object):

    def __init__(self, server):
        self.logger = logging.getLogger(__name__)
        self.server = server
        self.aliases = {}
        self._addr_idx_to_xml_idx = {}

        node_set_attributes = OrderedDict()
        node_set_attributes['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
        node_set_attributes['xmlns:uax'] = 'http://opcfoundation.org/UA/2008/02/Types.xsd'
        node_set_attributes['xmlns:xsd'] = 'http://www.w3.org/2001/XMLSchema'
        node_set_attributes['xmlns'] = 'http://opcfoundation.org/UA/2011/03/UANodeSet.xsd'

        self.etree = Et.ElementTree(Et.Element('UANodeSet', node_set_attributes))

    def build_etree(self, node_list, uris=None):
        """
        Create an XML etree object from a list of nodes; custom namespace uris are optional
        Namespaces used by nodes are allways exported for consistency.
        Args:
            node_list: list of Node objects for export
            uris: list of namespace uri strings

        Returns:
        """
        self.logger.info('Building XML etree')

        self._add_namespaces(node_list, uris)

        # add all nodes in the list to the XML etree
        for node in node_list:
            self.node_to_etree(node)

        # add aliases to the XML etree
        self._add_alias_els()

    def _add_namespaces(self, nodes, uris):
        idxs = self._get_ns_idxs_of_nodes(nodes)

        ns_array = self.server.get_namespace_array()

        # now add index of provided uris if necessary
        if uris:
            self._add_idxs_from_uris(idxs, uris, ns_array)

        # now create a dict of idx_in_address_space to idx_in_exported_file
        self._addr_idx_to_xml_idx = self._make_idx_dict(idxs, ns_array) 
        print("DICT", self._addr_idx_to_xml_idx)
        ns_to_export = [ns_array[i] for i in self._addr_idx_to_xml_idx.keys() if i != 0]
        print("NS_TO_EXPORT", ns_to_export)

        # write namespaces to xml
        self._add_namespace_uri_els(ns_to_export)

    def _make_idx_dict(self, idxs, ns_array):
        idxs.sort()
        addr_idx_to_xml_idx = {0: 0}
        for xml_idx, addr_idx in enumerate(idxs):
            if addr_idx >= len(ns_array):
                break
            addr_idx_to_xml_idx[addr_idx] = xml_idx + 1
        print(" ADDR_TO_ XML", self._addr_idx_to_xml_idx)
        return addr_idx_to_xml_idx

    def _get_ns_idxs_of_nodes(self, nodes):
        """
        get a list of all indexes used or references by nodes
        """
        idxs = []
        for node in nodes:
            node_idxs = [node.nodeid.NamespaceIndex]
            node_idxs.append(node.get_browse_name().NamespaceIndex)
            node_idxs.extend(ref.NodeId.NamespaceIndex for ref in node.get_references())
            node_idxs = list(set(node_idxs))  # remove duplicates
            for i in node_idxs:
                if i != 0 and i not in idxs:
                    idxs.append(i)
        print("IDXS", idxs)
        return idxs

    def _add_idxs_from_uris(self, idxs, uris, ns_array):
        for uri in uris:
            if uri in ns_array:
                i = ns_array.index(uri)
                if i not in idxs:
                    idxs.append(i)


    def write_xml(self, xmlpath, pretty=True):
        """
        Write the XML etree in the exporter object to a file
        Args:
            xmlpath: string representing the path/file name

        Returns:
        """
        # try to write the XML etree to a file
        self.logger.info('Exporting XML file to %s', xmlpath)
        #from IPython import embed
        # embed()
        if pretty:
            indent(self.etree.getroot())
            self.etree.write(xmlpath,
                             encoding='utf-8',
                             xml_declaration=True
                            )
        else:
            self.etree.write(xmlpath,
                             encoding='utf-8',
                             xml_declaration=True
                            )

    def dump_etree(self):
        """
        Dump etree to console for debugging
        Returns:
        """
        self.logger.info('Dumping XML etree to console')
        Et.dump(self.etree)

    def node_to_etree(self, node):
        """
        Add the necessary XML sub elements to the etree for exporting the node
        Args:
            node: Node object which will be added to XML etree

        Returns:
        """
        node_class = node.get_node_class()
        print("Exporting: ", node)

        if node_class is ua.NodeClass.Object:
            self.add_etree_object(node)
        elif node_class is ua.NodeClass.ObjectType:
            self.add_etree_object_type(node)
        elif node_class is ua.NodeClass.Variable:
            self.add_etree_variable(node)
        elif node_class is ua.NodeClass.VariableType:
            self.add_etree_variable_type(node)
        elif node_class is ua.NodeClass.ReferenceType:
            self.add_etree_reference_type(node)
        elif node_class is ua.NodeClass.DataType:
            self.add_etree_datatype(node)
        elif node_class is ua.NodeClass.Method:
            self.add_etree_method(node)
        else:
            self.logger.info("Exporting node class not implemented: %s ", node_class)

    def _add_sub_el(self, el, name, text):
        child_el = Et.SubElement(el, name)
        child_el.text = text
        return child_el

    def _node_to_string(self, nodeid):
        if not isinstance(nodeid, ua.NodeId):
            nodeid = nodeid.nodeid

        if nodeid.NamespaceIndex in self._addr_idx_to_xml_idx:
            nodeid = copy(nodeid)
            nodeid.NamespaceIndex = self._addr_idx_to_xml_idx[nodeid.NamespaceIndex]
        return nodeid.to_string()

    def _bname_to_string(self, bname):
        if bname.NamespaceIndex in self._addr_idx_to_xml_idx:
            bname = copy(bname)
            bname.NamespaceIndex = self._addr_idx_to_xml_idx[bname.NamespaceIndex]
        return bname.to_string()

    def _add_node_common(self, nodetype, node):
        browsename = node.get_browse_name()
        nodeid = node.nodeid
        parent = node.get_parent()
        displayname = node.get_display_name().Text.decode('utf-8')
        desc = node.get_description().Text
        print("NODE COMMON", node)
        node_el = Et.SubElement(self.etree.getroot(), nodetype)
        node_el.attrib["NodeId"] = self._node_to_string(nodeid)
        node_el.attrib["BrowseName"] = self._bname_to_string(browsename)
        if parent is not None:
            node_class = node.get_node_class()
            if node_class in (ua.NodeClass.Object, ua.NodeClass.Variable, ua.NodeClass.Method):
                node_el.attrib["ParentNodeId"] = self._node_to_string(parent)
        self._add_sub_el(node_el, 'DisplayName', displayname)
        if desc not in (None, ""):
            self._add_sub_el(node_el, 'Description', desc.decode('utf-8'))
        # FIXME: add WriteMask and UserWriteMask
        return node_el

    def add_etree_object(self, node):
        """
        Add a UA object element to the XML etree
        """
        obj_el = self._add_node_common("UAObject", node)
        var = node.get_attribute(ua.AttributeIds.EventNotifier)
        if var.Value.Value != 0:
            obj_el.attrib["EventNotifier"] = str(var.Value.Value)
        self._add_ref_els(obj_el, node)

    def add_etree_object_type(self, node):
        """
        Add a UA object type element to the XML etree
        """
        obj_el = self._add_node_common("UAObjectType", node)
        abstract = node.get_attribute(ua.AttributeIds.IsAbstract).Value.Value
        if abstract:
            obj_el.attrib["IsAbstract"] = 'true'
        self._add_ref_els(obj_el, node)

    def add_variable_common(self, node, el):
        dtype = node.get_data_type()
        if dtype.Identifier in o_ids.ObjectIdNames:
            dtype_name = o_ids.ObjectIdNames[dtype.Identifier]
            self.aliases[dtype_name] = dtype.to_string()
        else:
            dtype_name = dtype.to_string()
        rank = node.get_value_rank()
        if rank != -1:
            el.attrib["ValueRank"] = str(rank)
        #var = node.get_attribute(ua.AttributeIds.ArrayDimensions())
        #self._addobj_el.attrib["ArrayDimensions"] = str(var.Value.Value)
        el.attrib["DataType"] = dtype_name
        value_to_etree(el, dtype_name, dtype, node)

    def add_etree_variable(self, node):
        """
        Add a UA variable element to the XML etree
        """
        var_el = self._add_node_common("UAVariable", node)
        self.add_variable_common(node, var_el)

        accesslevel = node.get_attribute(ua.AttributeIds.AccessLevel).Value.Value
        useraccesslevel = node.get_attribute(ua.AttributeIds.UserAccessLevel).Value.Value

        # We only write these values if they are different from defaults
        # Not sure where default is defined....
        if accesslevel not in (0, ua.AccessLevel.CurrentRead.mask):
            var_el.attrib["AccessLevel"] = str(accesslevel)
        if useraccesslevel not in (0, ua.AccessLevel.CurrentRead.mask):
            var_el.attrib["UserAccessLevel"] = str(useraccesslevel)

        var = node.get_attribute(ua.AttributeIds.MinimumSamplingInterval)
        if var.Value.Value:
            var_el.attrib["MinimumSamplingInterval"] = str(var.Value.Value)
        var = node.get_attribute(ua.AttributeIds.Historizing)
        if var.Value.Value:
            var_el.attrib["Historizing"] = 'true'
        self._add_ref_els(var_el, node)

    def add_etree_variable_type(self, node):
        """
        Add a UA variable type element to the XML etree
        """

        var_el = self._add_node_common("UAVariableType", node)
        self.add_variable_common(node, var_el)

        abstract = node.get_attribute(ua.AttributeIds.IsAbstract)
        if abstract.Value.Value:
            var_el.attrib["IsAbstract"] = "true"

        self._add_ref_els(var_el, node)

    def add_etree_method(self, node):
        obj_el = self._add_node_common("UAMethod", node)

        var = node.get_attribute(ua.AttributeIds.Executable)
        if var.Value.Value is False:
            obj_el.attrib["Executable"] = "false"
        var = node.get_attribute(ua.AttributeIds.UserExecutable)
        if var.Value.Value is False:
            obj_el.attrib["UserExecutable"] = "false"
        self._add_ref_els(obj_el, node)

    def add_etree_reference_type(self, obj):
        obj_el = self._add_node_common("UAReferenceType", obj)
        var = obj.get_attribute(ua.AttributeIds.InverseName)
        if var is not None and var.Value.Value is not None:
            self._add_sub_el(obj_el, 'InverseName', var.Value.Value.Text.decode('utf-8'))
        self._add_ref_els(obj_el, obj)

    def add_etree_datatype(self, obj):
        """
        Add a UA data type element to the XML etree
        """
        obj_el = self._add_node_common("UADataType", obj)
        self._add_ref_els(obj_el, obj)

    def _add_namespace_uri_els(self, uris):
        nuris_el = Et.Element('NamespaceUris')

        for uri in uris:
            self._add_sub_el(nuris_el, 'Uri', uri)

        self.etree.getroot().insert(0, nuris_el)

    def _add_alias_els(self):
        aliases_el = Et.Element('Aliases')

        for k, v in self.aliases.items():
            ref_el = Et.SubElement(aliases_el, 'Alias', Alias=k)
            ref_el.text = v

        self.etree.getroot().insert(0, aliases_el)

    def _add_ref_els(self, parent_el, obj):
        refs = obj.get_references()
        refs_el = Et.SubElement(parent_el, 'References')

        for ref in refs:
            if ref.ReferenceTypeId.Identifier in o_ids.ObjectIdNames:
                ref_name = o_ids.ObjectIdNames[ref.ReferenceTypeId.Identifier]
            else:
                ref_name = ref.ReferenceTypeId.to_string()
            ref_el = Et.SubElement(refs_el, 'Reference')
            ref_el.attrib['ReferenceType'] = ref_name
            if not ref.IsForward:
                ref_el.attrib['IsForward'] = 'false'
            ref_el.text = self._node_to_string(ref.NodeId)

            self.aliases[ref_name] = ref.ReferenceTypeId.to_string()


def member_to_etree(el, name, dtype, val):
    member_el = Et.SubElement(el, "uax:" + name)
    if isinstance(val, (list, tuple)):
        for v in val:
            _value_to_etree(member_el, ua.ObjectIdNames[dtype.Identifier], dtype, v)
    else:
        _val_to_etree(member_el, dtype, val)


def _val_to_etree(el, dtype, val):
    if val is None:
        val = ""
    if dtype == ua.NodeId(ua.ObjectIds.NodeId):
        id_el = Et.SubElement(el, "uax:Identifier")
        id_el.text = val.to_string()
    elif not hasattr(val, "ua_types"):
        if isinstance(val, bytes):
            el.text = val.decode("utf-8")
        else:
            el.text = str(val)
    else:
        for name, vtype in val.ua_types.items():
            member_to_etree(el, name, ua.NodeId(getattr(ua.ObjectIds, vtype)), getattr(val, name))


def value_to_etree(el, dtype_name, dtype, node):
    var = node.get_data_value().Value
    if var.Value is not None:
        val_el = Et.SubElement(el, 'Value')
        _value_to_etree(val_el, dtype_name, dtype, var.Value)


def _value_to_etree(el, type_name, dtype, val):
    if not val:
        return
    if isinstance(val, (list, tuple)):
        if dtype.Identifier > 21:  # this is an extentionObject:
            elname = "uax:ListOfExtensionObject"
        else:
            elname = "uax:ListOf" + type_name
        list_el = Et.SubElement(el, elname)
        for nval in val:
            _value_to_etree(list_el, type_name, dtype, nval)
    else:
        if dtype.Identifier > 21:  # this is an extentionObject:
            _extobj_to_etree(el, type_name, dtype, val)
        else:
            val_el = Et.SubElement(el, "uax:" + type_name)
            _val_to_etree(val_el, dtype, val)
           

def _extobj_to_etree(val_el, name, dtype, val):
    obj_el = Et.SubElement(val_el, "uax:ExtensionObject")
    type_el = Et.SubElement(obj_el, "uax:TypeId")
    id_el = Et.SubElement(type_el, "uax:Identifier")
    id_el.text = dtype.to_string()
    body_el = Et.SubElement(obj_el, "uax:Body")
    struct_el = Et.SubElement(body_el, "uax:" + name)
    for name, vtype in val.ua_types.items():
        member_to_etree(struct_el, name, ua.NodeId(getattr(ua.ObjectIds, vtype)), getattr(val, name))


def indent(elem, level=0):
    '''
    copy and paste from http://effbot.org/zone/element-lib.htm#prettyprint
    it basically walks your tree and adds spaces and newlines so the tree is
    printed in a nice way
    '''
    i = "\n" + level * "  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for elem in elem:
            indent(elem, level + 1)
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i


1			"""
2			from a list of nodes in the address space, build an XML file
3			format is the one from opc-ua specification
4			"""
5			import logging
6			from collections import OrderedDict
7			import xml.etree.ElementTree as Et
8			from copy import copy
9
10			from opcua import ua
11			from opcua.ua import object_ids as o_ids
12
13
14			class XmlExporter(object):
15
16			def __init__(self, server):
17			self.logger = logging.getLogger(__name__)
18			self.server = server
19			self.aliases = {}
20			self._addr_idx_to_xml_idx = {}
21
22			node_set_attributes = OrderedDict()
23			node_set_attributes['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
24			node_set_attributes['xmlns:uax'] = 'http://opcfoundation.org/UA/2008/02/Types.xsd'
25			node_set_attributes['xmlns:xsd'] = 'http://www.w3.org/2001/XMLSchema'
26			node_set_attributes['xmlns'] = 'http://opcfoundation.org/UA/2011/03/UANodeSet.xsd'
27
28			self.etree = Et.ElementTree(Et.Element('UANodeSet', node_set_attributes))
29
30			def build_etree(self, node_list, uris=None):
31			"""
32			Create an XML etree object from a list of nodes; custom namespace uris are optional
33			Namespaces used by nodes are allways exported for consistency.
34			Args:
35			node_list: list of Node objects for export
36			uris: list of namespace uri strings
37
38			Returns:
39			"""
40			self.logger.info('Building XML etree')
41
42			self._add_namespaces(node_list, uris)
43
44			# add all nodes in the list to the XML etree
45			for node in node_list:
46			self.node_to_etree(node)
47
48			# add aliases to the XML etree
49			self._add_alias_els()
50
51			def _add_namespaces(self, nodes, uris):
52			idxs = self._get_ns_idxs_of_nodes(nodes)
53
54			ns_array = self.server.get_namespace_array()
55
56			# now add index of provided uris if necessary
57			if uris:
58			self._add_idxs_from_uris(idxs, uris, ns_array)
59
60			# now create a dict of idx_in_address_space to idx_in_exported_file
61			self._addr_idx_to_xml_idx = self._make_idx_dict(idxs, ns_array)
62			print("DICT", self._addr_idx_to_xml_idx)
63			ns_to_export = [ns_array[i] for i in self._addr_idx_to_xml_idx.keys() if i != 0]
64			print("NS_TO_EXPORT", ns_to_export)
65
66			# write namespaces to xml
67			self._add_namespace_uri_els(ns_to_export)
68
69			def _make_idx_dict(self, idxs, ns_array):
70			idxs.sort()
71			addr_idx_to_xml_idx = {0: 0}
72			for xml_idx, addr_idx in enumerate(idxs):
73			if addr_idx >= len(ns_array):
74			break
75			addr_idx_to_xml_idx[addr_idx] = xml_idx + 1
76			print(" ADDR_TO_ XML", self._addr_idx_to_xml_idx)
77			return addr_idx_to_xml_idx
78
79			def _get_ns_idxs_of_nodes(self, nodes):
80			"""
81			get a list of all indexes used or references by nodes
82			"""
83			idxs = []
84			for node in nodes:
85			node_idxs = [node.nodeid.NamespaceIndex]
86			node_idxs.append(node.get_browse_name().NamespaceIndex)
87			node_idxs.extend(ref.NodeId.NamespaceIndex for ref in node.get_references())
88			node_idxs = list(set(node_idxs)) # remove duplicates
89			for i in node_idxs:
90			if i != 0 and i not in idxs:
91			idxs.append(i)
92			print("IDXS", idxs)
93			return idxs
94
95			def _add_idxs_from_uris(self, idxs, uris, ns_array):
96			for uri in uris:
97			if uri in ns_array:
98			i = ns_array.index(uri)
99			if i not in idxs:
100			idxs.append(i)
101
102
103			def write_xml(self, xmlpath, pretty=True):
104			"""
105			Write the XML etree in the exporter object to a file
106			Args:
107			xmlpath: string representing the path/file name
108
109			Returns:
110			"""
111			# try to write the XML etree to a file
112			self.logger.info('Exporting XML file to %s', xmlpath)
113			#from IPython import embed
114			# embed()
115			if pretty:
116			indent(self.etree.getroot())
117			self.etree.write(xmlpath,
118			encoding='utf-8',
119			xml_declaration=True
120			)
121			else:
122			self.etree.write(xmlpath,
123			encoding='utf-8',
124			xml_declaration=True
125			)
126
127			def dump_etree(self):
128			"""
129			Dump etree to console for debugging
130			Returns:
131			"""
132			self.logger.info('Dumping XML etree to console')
133			Et.dump(self.etree)
134
135			def node_to_etree(self, node):
136			"""
137			Add the necessary XML sub elements to the etree for exporting the node
138			Args:
139			node: Node object which will be added to XML etree
140
141			Returns:
142			"""
143			node_class = node.get_node_class()
144			print("Exporting: ", node)
145
146			if node_class is ua.NodeClass.Object:
147			self.add_etree_object(node)
148			elif node_class is ua.NodeClass.ObjectType:
149			self.add_etree_object_type(node)
150			elif node_class is ua.NodeClass.Variable:
151			self.add_etree_variable(node)
152			elif node_class is ua.NodeClass.VariableType:
153			self.add_etree_variable_type(node)
154			elif node_class is ua.NodeClass.ReferenceType:
155			self.add_etree_reference_type(node)
156			elif node_class is ua.NodeClass.DataType:
157			self.add_etree_datatype(node)
158			elif node_class is ua.NodeClass.Method:
159			self.add_etree_method(node)
160			else:
161			self.logger.info("Exporting node class not implemented: %s ", node_class)
162
163			def _add_sub_el(self, el, name, text):
164			child_el = Et.SubElement(el, name)
165			child_el.text = text
166			return child_el
167
168			def _node_to_string(self, nodeid):
169			if not isinstance(nodeid, ua.NodeId):
170			nodeid = nodeid.nodeid
171
172			if nodeid.NamespaceIndex in self._addr_idx_to_xml_idx:
173			nodeid = copy(nodeid)
174			nodeid.NamespaceIndex = self._addr_idx_to_xml_idx[nodeid.NamespaceIndex]
175			return nodeid.to_string()
176
177			def _bname_to_string(self, bname):
178			if bname.NamespaceIndex in self._addr_idx_to_xml_idx:
179			bname = copy(bname)
180			bname.NamespaceIndex = self._addr_idx_to_xml_idx[bname.NamespaceIndex]
181			return bname.to_string()
182
183			def _add_node_common(self, nodetype, node):
184			browsename = node.get_browse_name()
185			nodeid = node.nodeid
186			parent = node.get_parent()
187			displayname = node.get_display_name().Text.decode('utf-8')
188			desc = node.get_description().Text
189			print("NODE COMMON", node)
190			node_el = Et.SubElement(self.etree.getroot(), nodetype)
191			node_el.attrib["NodeId"] = self._node_to_string(nodeid)
192			node_el.attrib["BrowseName"] = self._bname_to_string(browsename)
193			if parent is not None:
194			node_class = node.get_node_class()
195			if node_class in (ua.NodeClass.Object, ua.NodeClass.Variable, ua.NodeClass.Method):
196			node_el.attrib["ParentNodeId"] = self._node_to_string(parent)
197			self._add_sub_el(node_el, 'DisplayName', displayname)
198			if desc not in (None, ""):
199			self._add_sub_el(node_el, 'Description', desc.decode('utf-8'))
200			# FIXME: add WriteMask and UserWriteMask
201			return node_el
202
203			def add_etree_object(self, node):
204			"""
205			Add a UA object element to the XML etree
206			"""
207			obj_el = self._add_node_common("UAObject", node)
208			var = node.get_attribute(ua.AttributeIds.EventNotifier)
209			if var.Value.Value != 0:
210			obj_el.attrib["EventNotifier"] = str(var.Value.Value)
211			self._add_ref_els(obj_el, node)
212
213			def add_etree_object_type(self, node):
214			"""
215			Add a UA object type element to the XML etree
216			"""
217			obj_el = self._add_node_common("UAObjectType", node)
218			abstract = node.get_attribute(ua.AttributeIds.IsAbstract).Value.Value
219			if abstract:
220			obj_el.attrib["IsAbstract"] = 'true'
221			self._add_ref_els(obj_el, node)
222
223			def add_variable_common(self, node, el):
224			dtype = node.get_data_type()
225			if dtype.Identifier in o_ids.ObjectIdNames:
226			dtype_name = o_ids.ObjectIdNames[dtype.Identifier]
227			self.aliases[dtype_name] = dtype.to_string()
228			else:
229			dtype_name = dtype.to_string()
230			rank = node.get_value_rank()
231			if rank != -1:
232			el.attrib["ValueRank"] = str(rank)
233			#var = node.get_attribute(ua.AttributeIds.ArrayDimensions())
234			#self._addobj_el.attrib["ArrayDimensions"] = str(var.Value.Value)
235			el.attrib["DataType"] = dtype_name
236			value_to_etree(el, dtype_name, dtype, node)
237
238			def add_etree_variable(self, node):
239			"""
240			Add a UA variable element to the XML etree
241			"""
242			var_el = self._add_node_common("UAVariable", node)
243			self.add_variable_common(node, var_el)
244
245			accesslevel = node.get_attribute(ua.AttributeIds.AccessLevel).Value.Value
246			useraccesslevel = node.get_attribute(ua.AttributeIds.UserAccessLevel).Value.Value
247
248			# We only write these values if they are different from defaults
249			# Not sure where default is defined....
250			if accesslevel not in (0, ua.AccessLevel.CurrentRead.mask):
251			var_el.attrib["AccessLevel"] = str(accesslevel)
252			if useraccesslevel not in (0, ua.AccessLevel.CurrentRead.mask):
253			var_el.attrib["UserAccessLevel"] = str(useraccesslevel)
254
255			var = node.get_attribute(ua.AttributeIds.MinimumSamplingInterval)
256			if var.Value.Value:
257			var_el.attrib["MinimumSamplingInterval"] = str(var.Value.Value)
258			var = node.get_attribute(ua.AttributeIds.Historizing)
259			if var.Value.Value:
260			var_el.attrib["Historizing"] = 'true'
261			self._add_ref_els(var_el, node)
262
263			def add_etree_variable_type(self, node):
264			"""
265			Add a UA variable type element to the XML etree
266			"""
267
268			var_el = self._add_node_common("UAVariableType", node)
269			self.add_variable_common(node, var_el)
270
271			abstract = node.get_attribute(ua.AttributeIds.IsAbstract)
272			if abstract.Value.Value:
273			var_el.attrib["IsAbstract"] = "true"
274
275			self._add_ref_els(var_el, node)
276
277			def add_etree_method(self, node):
278			obj_el = self._add_node_common("UAMethod", node)
279
280			var = node.get_attribute(ua.AttributeIds.Executable)
281			if var.Value.Value is False:
282			obj_el.attrib["Executable"] = "false"
283			var = node.get_attribute(ua.AttributeIds.UserExecutable)
284			if var.Value.Value is False:
285			obj_el.attrib["UserExecutable"] = "false"
286			self._add_ref_els(obj_el, node)
287
288			def add_etree_reference_type(self, obj):
289			obj_el = self._add_node_common("UAReferenceType", obj)
290			var = obj.get_attribute(ua.AttributeIds.InverseName)
291			if var is not None and var.Value.Value is not None:
292			self._add_sub_el(obj_el, 'InverseName', var.Value.Value.Text.decode('utf-8'))
293			self._add_ref_els(obj_el, obj)
294
295			def add_etree_datatype(self, obj):
296			"""
297			Add a UA data type element to the XML etree
298			"""
299			obj_el = self._add_node_common("UADataType", obj)
300			self._add_ref_els(obj_el, obj)
301
302			def _add_namespace_uri_els(self, uris):
303			nuris_el = Et.Element('NamespaceUris')
304
305			for uri in uris:
306			self._add_sub_el(nuris_el, 'Uri', uri)
307
308			self.etree.getroot().insert(0, nuris_el)
309
310			def _add_alias_els(self):
311			aliases_el = Et.Element('Aliases')
312
313			for k, v in self.aliases.items():
314			ref_el = Et.SubElement(aliases_el, 'Alias', Alias=k)
315			ref_el.text = v
316
317			self.etree.getroot().insert(0, aliases_el)
318
319			def _add_ref_els(self, parent_el, obj):
320			refs = obj.get_references()
321			refs_el = Et.SubElement(parent_el, 'References')
322
323			for ref in refs:
324			if ref.ReferenceTypeId.Identifier in o_ids.ObjectIdNames:
325			ref_name = o_ids.ObjectIdNames[ref.ReferenceTypeId.Identifier]
326			else:
327			ref_name = ref.ReferenceTypeId.to_string()
328			ref_el = Et.SubElement(refs_el, 'Reference')
329			ref_el.attrib['ReferenceType'] = ref_name
330			if not ref.IsForward:
331			ref_el.attrib['IsForward'] = 'false'
332			ref_el.text = self._node_to_string(ref.NodeId)
333
334			self.aliases[ref_name] = ref.ReferenceTypeId.to_string()
335
336
337			def member_to_etree(el, name, dtype, val):
338			member_el = Et.SubElement(el, "uax:" + name)
339			if isinstance(val, (list, tuple)):
340			for v in val:
341			_value_to_etree(member_el, ua.ObjectIdNames[dtype.Identifier], dtype, v)
342			else:
343			_val_to_etree(member_el, dtype, val)
344
345
346			def _val_to_etree(el, dtype, val):
347			if val is None:
348			val = ""
349			if dtype == ua.NodeId(ua.ObjectIds.NodeId):
350			id_el = Et.SubElement(el, "uax:Identifier")
351			id_el.text = val.to_string()
352			elif not hasattr(val, "ua_types"):
353			if isinstance(val, bytes):
354			el.text = val.decode("utf-8")
355			else:
356			el.text = str(val)
357			else:
358			for name, vtype in val.ua_types.items():
359			member_to_etree(el, name, ua.NodeId(getattr(ua.ObjectIds, vtype)), getattr(val, name))
360
361
362			def value_to_etree(el, dtype_name, dtype, node):
363			var = node.get_data_value().Value
364			if var.Value is not None:
365			val_el = Et.SubElement(el, 'Value')
366			_value_to_etree(val_el, dtype_name, dtype, var.Value)
367
368
369			def _value_to_etree(el, type_name, dtype, val):
370			if not val:
371			return
372			if isinstance(val, (list, tuple)):
373			if dtype.Identifier > 21: # this is an extentionObject:
374			elname = "uax:ListOfExtensionObject"
375			else:
376			elname = "uax:ListOf" + type_name
377			list_el = Et.SubElement(el, elname)
378			for nval in val:
379			_value_to_etree(list_el, type_name, dtype, nval)
380			else:
381			if dtype.Identifier > 21: # this is an extentionObject:
382			_extobj_to_etree(el, type_name, dtype, val)
383			else:
384			val_el = Et.SubElement(el, "uax:" + type_name)
385			_val_to_etree(val_el, dtype, val)
386
387
388			def _extobj_to_etree(val_el, name, dtype, val):
389			obj_el = Et.SubElement(val_el, "uax:ExtensionObject")
390			type_el = Et.SubElement(obj_el, "uax:TypeId")
391			id_el = Et.SubElement(type_el, "uax:Identifier")
392			id_el.text = dtype.to_string()
393			body_el = Et.SubElement(obj_el, "uax:Body")
394			struct_el = Et.SubElement(body_el, "uax:" + name)
395			for name, vtype in val.ua_types.items():
396			member_to_etree(struct_el, name, ua.NodeId(getattr(ua.ObjectIds, vtype)), getattr(val, name))
397
398
399			def indent(elem, level=0):
400			'''
401			copy and paste from http://effbot.org/zone/element-lib.htm#prettyprint
402			it basically walks your tree and adds spaces and newlines so the tree is
403			printed in a nice way
404			'''
405			i = "\n" + level * " "
406			if len(elem):
407			if not elem.text or not elem.text.strip():
408			elem.text = i + " "
409			if not elem.tail or not elem.tail.strip():
410			elem.tail = i
411			for elem in elem:
412			indent(elem, level + 1)
413			if not elem.tail or not elem.tail.strip():
414			elem.tail = i
415			else:
416			if level and (not elem.tail or not elem.tail.strip()):
417			elem.tail = i
418

FreeOpcUa / python-opcua

Pull Request — master (#327)

XmlExporter._make_idx_dict() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like