async def test_xml_xmlelement_array(opc, tmpdir):
o = await opc.opc.nodes.objects.add_variable(
2, "xmllxmlelement_array",
[ua.XmlElement("XMLElem1"),
ua.XmlElement("XMLElem2")], ua.VariantType.XmlElement)
await _test_xml_var_type(opc, tmpdir, o, "xmlelement_array")
await opc.opc.delete_nodes([o])
def test_custom_structs_array(tmpdir):
c = StructGenerator()
c.make_model_from_file(EXAMPLE_BSD_PATH)
ns = {}
output_path = tmpdir.join("test_custom_structs_array.py").strpath
c.save_to_file(output_path)
with open(output_path) as s:
exec(s.read(), ns)
# test with default values
v = ns["ArrayValueDataType"]()
data = struct_to_binary(v)
v2 = struct_from_binary(ns["ArrayValueDataType"], ua.utils.Buffer(data))
# set some values
v = ns["ArrayValueDataType"]()
v.SbyteValue = [1]
v.ByteValue = [2]
v.Int16Value = [3]
v.UInt16Value = [4]
v.Int32Value = [5]
v.UInt32Value = [6]
v.Int64Value = [7]
v.UInt64Value = [8]
v.FloatValue = [9.0]
v.DoubleValue = [10.0]
v.StringValue = ["elleven"]
v.DateTimeValue = [datetime.utcnow()]
# self.GuidValue = uuid.uudib"14"
v.ByteStringValue = [b"fifteen", b"sixteen"]
v.XmlElementValue = [ua.XmlElement("<toto>titi</toto>")]
v.NodeIdValue = [ua.NodeId.from_string("ns=4;i=9999"), ua.NodeId.from_string("i=6")]
data = struct_to_binary(v)
v2 = struct_from_binary(ns["ArrayValueDataType"], ua.utils.Buffer(data))
assert v.NodeIdValue == v2.NodeIdValue
def string_to_val(string, vtype):
"""
Convert back a string to a python or python-asyncua object
Note: no error checking is done here, supplying null strings could raise exceptions (datetime and guid)
"""
string = string.strip()
if string.startswith("["):
string = string[1:-1]
var = []
for s in string.split(","):
s = s.strip()
val = string_to_val(s, vtype)
var.append(val)
return var
if vtype == ua.VariantType.Null:
val = None
elif vtype == ua.VariantType.Boolean:
if string in ("True", "true", "on", "On", "1"):
val = True
else:
val = False
elif vtype in (ua.VariantType.SByte, ua.VariantType.Int16, ua.VariantType.Int32, ua.VariantType.Int64):
if not string:
val = 0
else:
val = int(string)
elif vtype in (ua.VariantType.Byte, ua.VariantType.UInt16, ua.VariantType.UInt32, ua.VariantType.UInt64):
if not string:
val = 0
else:
val = int(string)
elif vtype in (ua.VariantType.Float, ua.VariantType.Double):
if not string:
val = 0.0
else:
val = float(string)
elif vtype == ua.VariantType.XmlElement:
val = ua.XmlElement(string)
elif vtype == ua.VariantType.String:
val = string
elif vtype == ua.VariantType.ByteString:
val = string.encode()
elif vtype in (ua.VariantType.NodeId, ua.VariantType.ExpandedNodeId):
val = ua.NodeId.from_string(string)
elif vtype == ua.VariantType.QualifiedName:
val = ua.QualifiedName.from_string(string)
elif vtype == ua.VariantType.DateTime:
val = parser.parse(string)
elif vtype == ua.VariantType.LocalizedText:
val = ua.LocalizedText.from_string(string)
elif vtype == ua.VariantType.StatusCode:
val = ua.StatusCode(string)
elif vtype == ua.VariantType.Guid:
val = uuid.UUID(string)
else:
# FIXME: Some types are probably missing!
raise NotImplementedError
return val
def test_string_to_val_xml_element():
string = "<p> titi toto </p>"
obj = ua.XmlElement(string)
assert obj == string_to_val(string, ua.VariantType.XmlElement)
assert string == val_to_string(obj)
b = struct_to_binary(obj)
obj2 = struct_from_binary(ua.XmlElement, ua.utils.Buffer(b))
assert obj == obj2
def test_custom_structs(tmpdir):
c = StructGenerator()
c.make_model_from_file(EXAMPLE_BSD_PATH)
output_path = tmpdir.join("test_custom_structs.py").strpath
c.save_to_file(output_path)
ns = {}
with open(output_path) as s:
exec(s.read(), ns)
# test with default values
v = ns["ScalarValueDataType"]()
data = struct_to_binary(v)
v2 = struct_from_binary(ns["ScalarValueDataType"], ua.utils.Buffer(data))
# set some values
v = ns["ScalarValueDataType"]()
v.SbyteValue = 1
v.ByteValue = 2
v.Int16Value = 3
v.UInt16Value = 4
v.Int32Value = 5
v.UInt32Value = 6
v.Int64Value = 7
v.UInt64Value = 8
v.FloatValue = 9.0
v.DoubleValue = 10.0
v.StringValue = "elleven"
v.DateTimeValue = datetime.utcnow()
# self.GuidValue = uuid.uudib"14"
v.ByteStringValue = b"fifteen"
v.XmlElementValue = ua.XmlElement("<toto>titi</toto>")
v.NodeIdValue = ua.NodeId.from_string("ns=4;i=9999")
# self.ExpandedNodeIdValue =
# self.QualifiedNameValue =
# self.LocalizedTextValue =
# self.StatusCodeValue =
# self.VariantValue =
# self.EnumerationValue =
# self.StructureValue =
# self.Number =
# self.Integer =
# self.UInteger =
data = struct_to_binary(v)
v2 = struct_from_binary(ns["ScalarValueDataType"], ua.utils.Buffer(data))
assert v.NodeIdValue == v2.NodeIdValue
async def test_xml_xmlelement(opc, tmpdir):
o = await opc.opc.nodes.objects.add_variable(2, "xmllxmlelement",
ua.XmlElement("XMLElem"))
await _test_xml_var_type(opc, tmpdir, o, "xmlelement")
await opc.opc.delete_nodes([o])
def _parse_value(self, val_el, obj):
"""
Parse the node val_el as a constant.
"""
if val_el is not None and val_el.text is not None:
ntag = self._retag.match(val_el.tag).groups()[1]
else:
ntag = "Null"
obj.valuetype = ntag
if ntag == "Null":
obj.value = None
elif hasattr(ua.ua_binary.Primitives1, ntag):
# Elementary types have their parsing directly relying on ua_type_to_python.
obj.value = ua_type_to_python(val_el.text, ntag)
elif ntag == "DateTime":
obj.value = ua_type_to_python(val_el.text, ntag)
# According to specs, DateTime should be either UTC or with a timezone.
if obj.value.tzinfo is None or obj.value.tzinfo.utcoffset(obj.value) is None:
utc.localize(obj.value) # FIXME Forcing to UTC if unaware, maybe should raise?
elif ntag == "ByteString":
if val_el.text is None:
mytext = b""
else:
mytext = val_el.text.encode()
mytext = base64.b64decode(mytext)
obj.value = mytext
elif ntag == "String" or ntag == "XmlElement":
# String and XMLElement are identical only type is different
mytext = val_el.text
if mytext is None:
# Support importing null strings.
mytext = ""
if ntag == "XmlElement":
obj.value = ua.XmlElement(mytext)
else:
obj.value = mytext
elif ntag == "Guid":
self._parse_contained_value(val_el, obj)
# Override parsed string type to guid.
obj.valuetype = ntag
elif ntag == "NodeId":
id_el = val_el.find("uax:Identifier", self.ns)
if id_el is not None:
obj.value = id_el.text
elif ntag == "ExpandedNodeId":
id_el = val_el.find("uax:Identifier", self.ns)
if id_el is not None:
obj.value = ua.NodeId.from_string(id_el.text)
if not isinstance(obj.value, ua.ExpandedNodeId):
obj.value = ua.ExpandedNodeId(obj.value.Identifier, obj.value.NamespaceIndex)
elif ntag == "ExtensionObject":
obj.value = self._parse_ext_obj(val_el)
elif ntag == "LocalizedText":
obj.value = self._parse_body(val_el)
elif ntag == "ListOfLocalizedText":
obj.value = self._parse_list_of_localized_text(val_el)
elif ntag == "ListOfExtensionObject":
obj.value = self._parse_list_of_extension_object(val_el)
elif ntag == "StatusCode":
code_el = val_el.find("uax:Code", self.ns)
val = code_el.text if code_el is not None else "0"
obj.value = ua.StatusCode(string_to_val(val, ua.VariantType.UInt32))
elif ntag == "QualifiedName":
obj.value = self._parse_qualifed_name(val_el)
elif ntag.startswith("ListOf"):
# Default case for "ListOf" types.
# Should stay after particular cases (e.g.: "ListOfLocalizedText").
obj.value = []
for val_el in val_el:
tmp = NodeData()
self._parse_value(val_el, tmp)
obj.value.append(tmp.value)
else:
# Missing according to ua.VariantType (also missing in string_to_val):
# DataValue, Variant, DiagnosticInfo.
self.logger.warning("Parsing value of type '%s' not implemented", ntag)
