--- a/plcopen/plcopen.py Wed Aug 07 11:47:14 2013 +0200
+++ b/plcopen/plcopen.py Mon Aug 26 10:55:03 2013 +0200
@@ -26,6 +26,7 @@
from collections import OrderedDict
Dictionary that makes the relation between var names in plcopen and displayed values
@@ -122,11 +123,29 @@
result = criteria["pattern"].search(text, result.end())
-PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))+PLCOpenParser = GenerateParserFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))
+def LoadProject(filepath): + project_file = open(filepath) + project_xml = project_file.read()\ + .replace("http://www.plcopen.org/xml/tc6.xsd", + "http://www.plcopen.org/xml/tc6_0201")\ + .replace("<![CDATA[", "<xhtml:p><![CDATA[")\ + .replace("]]>", "]]></xhtml:p>") + return etree.fromstring(project_xml, PLCOpenParser) -cls = PLCOpenClasses.get("formattedText", None)+def SaveProject(project, filepath): + project_file = open(filepath, 'w') + project_file.write(etree.tostring( +cls = PLCOpenParser.GetElementClass("formattedText") def updateElementName(self, old_name, new_name):
@@ -170,9 +189,8 @@
return [(tuple(parent_infos),) + result for result in TestTextElement(self.gettext(), criteria)]
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project", None)+cls = PLCOpenParser.GetElementClass("project") - cls.singleLineAttributes = False cls.EnumeratedDataTypeValues = {}
cls.CustomDataTypeRange = {}
cls.CustomTypeHierarchy = {}
@@ -324,7 +342,7 @@
for configuration in self.instances.configurations.getconfiguration():
if configuration.getname() == name:
raise ValueError, _("\"%s\" configuration already exists !!!")%name
- new_configuration = PLCOpenClasses["configurations_configuration"]()+ new_configuration = PLCOpenParser.CreateElement("configuration", "configurations") new_configuration.setname(name)
self.instances.configurations.appendconfiguration(new_configuration)
setattr(cls, "addconfiguration", addconfiguration)
@@ -355,7 +373,7 @@
for resource in configuration.getresource():
if resource.getname() == name:
raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)
- new_resource = PLCOpenClasses["configuration_resource"]()+ new_resource = PLCOpenParser.CreateElement("resource", "configuration") new_resource.setname(name)
configuration.appendresource(new_resource)
setattr(cls, "addconfigurationResource", addconfigurationResource)
@@ -416,25 +434,26 @@
def AddCustomDataType(self, datatype):
name = datatype.getname()
basetype_content = datatype.getbaseType().getcontent()
- if basetype_content["value"] is None:- self.CustomTypeHierarchy[name] = basetype_content["name"]- elif basetype_content["name"] in ["string", "wstring"]:- self.CustomTypeHierarchy[name] = basetype_content["name"].upper()- elif basetype_content["name"] == "derived":- self.CustomTypeHierarchy[name] = basetype_content["value"].getname()- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:- range = (basetype_content["value"].range.getlower(), - basetype_content["value"].range.getupper())+ basetype_content_name = basetype_content.getLocalTag() + if basetype_content.__class__ == DefaultElementClass: + self.CustomTypeHierarchy[name] = basetype_content_name + elif basetype_content_name in ["string", "wstring"]: + self.CustomTypeHierarchy[name] = basetype_content_name.upper() + elif basetype_content_name == "derived": + self.CustomTypeHierarchy[name] = basetype_content.getname() + elif basetype_content_name in ["subrangeSigned", "subrangeUnsigned"]: + range = (basetype_content.range.getlower(), + basetype_content.range.getupper()) self.CustomDataTypeRange[name] = range
- base_type = basetype_content["value"].baseType.getcontent()- if base_type["value"] is None:- self.CustomTypeHierarchy[name] = base_type["name"]+ base_type = basetype_content.baseType.getcontent() + if base_type.__class__ == DefaultElementClass: + self.CustomTypeHierarchy[name] = basetype.getLocalTag() - self.CustomTypeHierarchy[name] = base_type["value"].getname()+ self.CustomTypeHierarchy[name] = base_type.getname() - if basetype_content["name"] == "enum":+ if basetype_content_name == "enum": - for value in basetype_content["value"].values.getvalue():+ for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP): values.append(value.getname())
self.EnumeratedDataTypeValues[name] = values
self.CustomTypeHierarchy[name] = "ANY_DERIVED"
@@ -458,43 +477,47 @@
return_type = pou.interface.getreturnType()
var_type = return_type.getcontent()
- if var_type["name"] == "derived":- block_infos["outputs"].append(("OUT", var_type["value"].getname(), "none"))- elif var_type["name"] in ["string", "wstring"]:- block_infos["outputs"].append(("OUT", var_type["name"].upper(), "none"))+ var_type_name = var_type.getLocalTag() + if var_type_name == "derived": + block_infos["outputs"].append(("OUT", var_type.getname(), "none")) + elif var_type_name in ["string", "wstring"]: + block_infos["outputs"].append(("OUT", var_type_name.upper(), "none")) - block_infos["outputs"].append(("OUT", var_type["name"], "none"))+ block_infos["outputs"].append(("OUT", var_type_name, "none")) for type, varlist in pou.getvars():
for var in varlist.getvariable():
var_type = var.type.getcontent()
- if var_type["name"] == "derived":- block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))- block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))- elif var_type["name"] in ["string", "wstring"]:- block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))- block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))+ var_type_name = var_type.getLocalTag() + if var_type_name == "derived": + block_infos["inputs"].append((var.getname(), var_type.getname(), "none")) + block_infos["outputs"].append((var.getname(), var_type.getname(), "none")) + elif var_type_name in ["string", "wstring"]: + block_infos["inputs"].append((var.getname(), var_type_name.upper(), "none")) + block_infos["outputs"].append((var.getname(), var_type_name.upper(), "none")) - block_infos["inputs"].append((var.getname(), var_type["name"], "none"))- block_infos["outputs"].append((var.getname(), var_type["name"], "none"))+ block_infos["inputs"].append((var.getname(), var_type_name, "none")) + block_infos["outputs"].append((var.getname(), var_type_name, "none")) for var in varlist.getvariable():
var_type = var.type.getcontent()
- if var_type["name"] == "derived":- block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))- elif var_type["name"] in ["string", "wstring"]:- block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))+ var_type_name = var_type.getLocalTag() + if var_type_name == "derived": + block_infos["inputs"].append((var.getname(), var_type.getname(), "none")) + elif var_type_name in ["string", "wstring"]: + block_infos["inputs"].append((var.getname(), var_type_name.upper(), "none")) - block_infos["inputs"].append((var.getname(), var_type["name"], "none"))+ block_infos["inputs"].append((var.getname(), var_type_name, "none")) for var in varlist.getvariable():
var_type = var.type.getcontent()
- if var_type["name"] == "derived":- block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))- elif var_type["name"] in ["string", "wstring"]:- block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))+ var_type_name = var_type.getLocalTag() + if var_type_name == "derived": + block_infos["outputs"].append((var.getname(), var_type.getname(), "none")) + elif var_type_name in ["string", "wstring"]: + block_infos["outputs"].append((var.getname(), var_type_name.upper(), "none")) - block_infos["outputs"].append((var.getname(), var_type["name"], "none")) + block_infos["outputs"].append((var.getname(), var_type_name, "none")) block_infos["usage"] = "\n (%s) => (%s)" % (", ".join(["%s:%s" % (input[1], input[0]) for input in block_infos["inputs"]]),
", ".join(["%s:%s" % (output[1], output[0]) for output in block_infos["outputs"]]))
self.CustomBlockTypes[pou_name]=block_infos
@@ -509,34 +532,34 @@
def RefreshElementUsingTree(self):
# Reset the tree of user-defined element cross-use
self.ElementUsingTree = {}
- datatypes = self.getdataTypes()- for datatype in datatypes:+ for datatype in self.getdataTypes(): name = datatype.getname()
basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] == "derived":- self.AddElementUsingTreeInstance(name,- basetype_content["value"])- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:- base_type = basetype_content["value"].baseType.getcontent()- if base_type["name"] == "derived":- self.AddElementUsingTreeInstance(name, base_type["value"])- elif basetype_content["name"] == "struct":- for element in basetype_content["value"].getvariable():+ basetype_content_name = basetype_content.getLocalTag() + if basetype_content_name == "derived": + self.AddElementUsingTreeInstance(name, basetype_content) + elif basetype_content_name in ["subrangeSigned", "subrangeUnsigned", "array"]: + base_type = basetype_content.baseType.getcontent() + if base_type.getLocalTag() == "derived": + self.AddElementUsingTreeInstance(name, base_type) + elif basetype_content_name == "struct": + for element in basetype_content.getvariable(): type_content = element.type.getcontent()
- if type_content["name"] == "derived":- self.AddElementUsingTreeInstance(name, type_content["value"])+ if type_content.getLocalTag() == "derived": + self.AddElementUsingTreeInstance(name, type_content)
+ for pou in self.getpous(): # Extract variables from every varLists
- for type, varlist in pou.getvars():+ for varlist_type, varlist in pou.getvars(): for var in varlist.getvariable():
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":- self.AddElementUsingTreeInstance(name, vartype_content["value"])+ if vartype_content.getLocalTag() == "derived": + self.AddElementUsingTreeInstance(name, vartype_content) setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree)
@@ -689,16 +712,17 @@
# Return if Data Type can be used for located variables
def IsLocatableType(self, datatype):
basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] in ["enum", "struct"]:+ basetype_content_name = basetype_content.getLocalTag() + if basetype_content_name in ["enum", "struct"]: - elif basetype_content["name"] == "derived":- base_type = self.getdataType(basetype_content["value"].getname())+ elif basetype_content_name == "derived": + base_type = self.getdataType(basetype_content.getname()) if base_type is not None:
return self.IsLocatableType(base_type)
- elif basetype_content["name"] == "array":- array_base_type = basetype_content["value"].baseType.getcontent()- if array_base_type["value"] is not None and array_base_type["name"] not in ["string", "wstring"]:- base_type = self.getdataType(array_base_type["value"].getname())+ elif basetype_content_name == "array": + array_base_type = basetype_content.baseType.getcontent() + if array_base_type == DefaultElementClass and array_base_type.getLocalTag() not in ["string", "wstring"]: + base_type = self.getdataType(array_base_type.getname()) if base_type is not None:
return self.IsLocatableType(base_type)
@@ -711,13 +735,8 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project_fileHeader", None)+cls = PLCOpenParser.GetElementClass("contentHeader", "project") - cls.singleLineAttributes = False-cls = PLCOpenClasses.get("project_contentHeader", None)- cls.singleLineAttributes = False def setpageSize(self, width, height):
self.coordinateInfo.setpageSize(width, height)
@@ -740,7 +759,7 @@
setattr(cls, "getscaling", getscaling)
-cls = PLCOpenClasses.get("contentHeader_coordinateInfo", None)+cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader") def setpageSize(self, width, height):
if width == 0 and height == 0:
@@ -809,7 +828,7 @@
variables = varlist.getvariable()
for i in xrange(len(variables)-1, -1, -1):
if variables[i].getaddress() == address:
+ variables.remove(variables[i]) def _removeConfigurationResourceVariableByFilter(self, address_model):
for varlist in self.getglobalVars():
@@ -819,7 +838,7 @@
if var_address is not None:
result = address_model.match(var_address)
+ variables.remove(variables[i]) def _SearchInConfigurationResource(self, criteria, parent_infos=[]):
search_result = _Search([("name", self.getname())], criteria, parent_infos)
@@ -839,32 +858,32 @@
-cls = PLCOpenClasses.get("configurations_configuration", None)+cls = PLCOpenParser.GetElementClass("configuration", "configurations") - def addglobalVar(self, type, name, location="", description=""):+ def addglobalVar(self, var_type, name, location="", description=""): globalvars = self.getglobalVars()
- globalvars.append(PLCOpenClasses["varList"]())- var = PLCOpenClasses["varListPlain_variable"]()+ globalvars.append(PLCOpenParser.CreateElement("varList")) + var = PLCOpenParser.CreateElement("variable", "varListPlain") - var_type = PLCOpenClasses["dataType"]()- if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:- var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()})- elif type == "WSTRING":- var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()})+ var_type_obj = PLCOpenParser.CreateElement("dataType") + if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]: + if var_type == "STRING": + var_type_obj.setcontent(PLCOpenParser.CreateElement("string", "elementaryTypes")) + elif var_type == "WSTRING": + var_type_obj.setcontent(PLCOpenParser.CreateElement("wstring", "elementaryTypes")) - var_type.setcontent({"name" : type, "value" : None})+ var_type_obj.setcontent(PLCOpenParser.CreateElement(var_type)) - derived_type = PLCOpenClasses["derivedTypes_derived"]()- derived_type.setname(type)- var_type.setcontent({"name" : "derived", "value" : derived_type})+ derived_type = PLCOpenParser.CreateElement("derived", "derivedTypes") + derived_type.setname(var_type) + var_type_obj.setcontent(derived_type) + var.settype(var_type_obj) - ft = PLCOpenClasses["formattedText"]()+ ft = PLCOpenParser.CreateElementClass("formattedText") globalvars[-1].appendvariable(var)
@@ -896,7 +915,7 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("configuration_resource", None)+cls = PLCOpenParser.GetElementClass("resource", "configuration") def updateElementName(self, old_name, new_name):
_updateConfigurationResourceElementName(self, old_name, new_name)
@@ -937,7 +956,7 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("resource_task", None)+cls = PLCOpenParser.GetElementClass("task", "resource") def compatibility(self, tree):
if tree.hasAttribute("interval"):
@@ -986,7 +1005,7 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("pouInstance", None)+cls = PLCOpenParser.GetElementClass("pouInstance") def compatibility(self, tree):
if tree.hasAttribute("type"):
@@ -1004,31 +1023,33 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("varListPlain_variable", None)+cls = PLCOpenParser.GetElementClass("variable", "varListPlain") vartype_content = self.gettype().getcontent()
+ vartype_content_name = vartype_content.getLocalTag() # Variable type is a user data type
- if vartype_content["name"] == "derived":- return vartype_content["value"].getname()+ if vartype_content_name == "derived": + return vartype_content.getname() # Variable type is a string type
- elif vartype_content["name"] in ["string", "wstring"]:- return vartype_content["name"].upper()+ elif vartype_content_name in ["string", "wstring"]: + return vartype_content_name.upper() # Variable type is an array
- elif vartype_content["name"] == "array":- base_type = vartype_content["value"].baseType.getcontent()+ elif vartype_content_name == "array": + base_type = vartype_content.baseType.getcontent() + base_type_name = base_type.getLocalTag() # Array derived directly from a user defined type
- if base_type["name"] == "derived":- basetype_name = base_type["value"].getname()+ if base_type_name == "derived": + basetype_name = base_type.getname() # Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:- basetype_name = base_type["name"].upper()+ elif base_type_name in ["string", "wstring"]: + basetype_name = base_type_name.upper() # Array derived directly from an elementary type
- basetype_name = base_type["name"]- return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name)+ basetype_name = base_type_name + return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content.getdimension())), basetype_name) # Variable type is an elementary type
- return vartype_content["name"]+ return vartype_content_name setattr(cls, "gettypeAsText", gettypeAsText)
def Search(self, criteria, parent_infos=[]):
@@ -1045,7 +1066,7 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project_types", None)+cls = PLCOpenParser.GetElementClass("types", "project") def getdataTypeElements(self):
return self.dataTypes.getdataType()
@@ -1060,9 +1081,9 @@
setattr(cls, "getdataTypeElement", getdataTypeElement)
def appenddataTypeElement(self, name):
- new_datatype = PLCOpenClasses["dataTypes_dataType"]()+ new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes") new_datatype.setname(name)
- new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})+ new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL")) self.dataTypes.appenddataType(new_datatype)
setattr(cls, "appenddataTypeElement", appenddataTypeElement)
@@ -1072,9 +1093,9 @@
def removedataTypeElement(self, name):
- for idx, element in enumerate(self.dataTypes.getdataType()):+ for element in self.dataTypes.getdataType(): if element.getname() == name:
- self.dataTypes.removedataType(idx)+ self.dataTypes.remove(element) @@ -1097,10 +1118,10 @@
for element in self.pous.getpou():
if element.getname() == name:
raise ValueError, _("\"%s\" POU already exists !!!")%name
- new_pou = PLCOpenClasses["pous_pou"]()+ new_pou = PLCOpenParser.CreateElement("pou", "pous") new_pou.setpouType(pou_type)
- new_pou.appendbody(PLCOpenClasses["body"]())+ new_pou.appendbody(PLCOpenParser.CreateElement("body")) new_pou.setbodyType(body_type)
self.pous.appendpou(new_pou)
setattr(cls, "appendpouElement", appendpouElement)
@@ -1111,9 +1132,9 @@
def removepouElement(self, name):
- for idx, element in enumerate(self.pous.getpou()):+ for element in self.pous.getpou(): if element.getname() == name:
- self.pous.removepou(idx)+ self.pous.remove(element) @@ -1133,7 +1154,7 @@
def _updateBaseTypeElementName(self, old_name, new_name):
self.baseType.updateElementName(old_name, new_name)
-cls = PLCOpenClasses.get("dataTypes_dataType", None)+cls = PLCOpenParser.GetElementClass("dataType", "dataTypes") setattr(cls, "updateElementName", _updateBaseTypeElementName)
@@ -1149,33 +1170,34 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("dataType", None)+cls = PLCOpenParser.GetElementClass("dataType") def updateElementName(self, old_name, new_name):
- if self.content["name"] in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]:- self.content["value"].updateElementName(old_name, new_name)- elif self.content["name"] == "struct":- for element in self.content["value"].getvariable():+ content_name = self.content.getLocalTag() + if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]: + self.content.updateElementName(old_name, new_name) + elif content_name == "struct": + for element in self.content.getvariable(): element_type = element.type.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def Search(self, criteria, parent_infos=[]):
- if self.content["name"] in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]:+ content_name = self.content.getLocalTag() + if content_name in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]: search_result.extend(self.content["value"].Search(criteria, parent_infos))
- elif self.content["name"] == "struct":+ elif content_name == "struct": for i, element in enumerate(self.content["value"].getvariable()):
search_result.extend(element.Search(criteria, parent_infos + ["struct", i]))
- basetype = self.content["name"]- if basetype in ["string", "wstring"]:- basetype = basetype.upper()- search_result.extend(_Search([("base", basetype)], criteria, parent_infos))+ if content_name in ["string", "wstring"]: + content_name = content_name.upper() + search_result.extend(_Search([("base", content_name)], criteria, parent_infos)) setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("derivedTypes_array", None)+cls = PLCOpenParser.GetElementClass("array", "derivedTypes") setattr(cls, "updateElementName", _updateBaseTypeElementName)
@@ -1195,17 +1217,17 @@
-cls = PLCOpenClasses.get("derivedTypes_subrangeSigned", None)+cls = PLCOpenParser.GetElementClass("subrangeSigned", "derivedTypes") setattr(cls, "updateElementName", _updateBaseTypeElementName)
setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenClasses.get("derivedTypes_subrangeUnsigned", None)+cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "derivedTypes") setattr(cls, "updateElementName", _updateBaseTypeElementName)
setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenClasses.get("derivedTypes_enum", None)+cls = PLCOpenParser.GetElementClass("enum", "derivedTypes") def updateElementName(self, old_name, new_name):
@@ -1220,13 +1242,13 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("pous_pou", None)+cls = PLCOpenParser.GetElementClass("pou", "pous") def setdescription(self, description):
doc = self.getdocumentation()
- doc = PLCOpenClasses["formattedText"]()+ doc = PLCOpenParser.CreateElement("formattedText") self.setdocumentation(doc)
setattr(cls, "setdescription", setdescription)
@@ -1238,25 +1260,17 @@
setattr(cls, "getdescription", getdescription)
- def setbodyType(self, type):+ def setbodyType(self, body_type):
- self.body[0].setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})- self.body[0].setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})- self.body[0].setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})- self.body[0].setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})- self.body[0].setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})+ if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: + self.body[0].setcontent(PLCOpenParser.CreateElementClass(body_type, "body")) raise ValueError, "%s isn't a valid body type!"%type
setattr(cls, "setbodyType", setbodyType)
- return self.body[0].getcontent()["name"]+ return self.body[0].getcontent().getLocalTag() setattr(cls, "getbodyType", getbodyType)
def resetexecutionOrder(self):
@@ -1326,56 +1340,54 @@
for name, value in VarTypes.items():
reverse_types[value] = name
for varlist in self.interface.getcontent():
- vars.append((reverse_types[varlist["name"]], varlist["value"]))+ vars.append((reverse_types[varlist.getLocalTag()], varlist)) setattr(cls, "getvars", getvars)
if self.interface is None:
- self.interface = PLCOpenClasses["pou_interface"]()- self.interface.setcontent([])- for vartype, varlist in vars:- self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist})+ self.interface = PLCOpenParser.CreateElement("interface", "pou") + self.interface.setcontent(vars) setattr(cls, "setvars", setvars)
- def addpouLocalVar(self, type, name, location="", description=""):- self.addpouVar(type, name, location=location, description=description)+ def addpouLocalVar(self, var_type, name, location="", description=""): + self.addpouVar(var_type, name, location=location, description=description) setattr(cls, "addpouLocalVar", addpouLocalVar)
- def addpouExternalVar(self, type, name):+ def addpouExternalVar(self, var_type, name): self.addpouVar(type, name, "externalVars")
setattr(cls, "addpouExternalVar", addpouExternalVar)
- def addpouVar(self, type, name, var_class="localVars", location="", description=""):+ def addpouVar(self, var_type, name, var_class="localVars", location="", description=""): if self.interface is None:
- self.interface = PLCOpenClasses["pou_interface"]()+ self.interface = PLCOpenParser.CreateElement("interface", "pou") content = self.interface.getcontent()
if len(content) == 0 or content[-1]["name"] != var_class:
- content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()})+ self.appendcontent(PLCOpenParser.CreateElement(var_class, "interface")) varlist = content[-1]["value"]
variables = varlist.getvariable()
if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():
- content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()})- var = PLCOpenClasses["varListPlain_variable"]()+ self.appendcontent(PLCOpenParser.CreateElementClass(var_class, "interface")) + var = PLCOpenParser.CreateElementClass("variable", "varListPlain") - var_type = PLCOpenClasses["dataType"]()- if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:- var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()})- elif type == "WSTRING":- var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()})+ var_type_obj = PLCOpenParser.CreateElement("dataType") + if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]: + if var_type == "STRING": + var_type_obj.setcontent(PLCOpenParser.CreateElement("string", "elementaryTypes")) + elif var_type == "WSTRING": + var_type_obj.setcontent(PLCOpenParser.CreateElement("wstring", "elementaryTypes")) - var_type.setcontent({"name" : type, "value" : None})+ var_type_obj.setcontent(PLCOpenParser.CreateElement(var_type)) - derived_type = PLCOpenClasses["derivedTypes_derived"]()- derived_type.setname(type)- var_type.setcontent({"name" : "derived", "value" : derived_type})+ derived_type = PLCOpenParser.CreateElement("derived", "derivedTypes") + derived_type.setname(var_type) + var_type_obj.setcontent(derived_type) + var.settype(var_type_obj) - ft = PLCOpenClasses["formattedText"]()+ ft = PLCOpenParser.GetElementClass("formattedText")() @@ -1390,24 +1402,23 @@
if var.getname() == old_name:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type:+ if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == old_type: - vartype_content["value"].setname(new_type)+ vartype_content.setname(new_type) setattr(cls, "changepouVar", changepouVar)
- def removepouVar(self, type, name):+ def removepouVar(self, var_type, name): if self.interface is not None:
content = self.interface.getcontent()
- variables = varlist["value"].getvariable()+ for var in varlist.getvariable(): if var.getname() == name:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getname() == type:+ if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == var_type: - if len(varlist["value"].getvariable()) == 0:+ if len(varlist.getvariable()) == 0: setattr(cls, "removepouVar", removepouVar)
@@ -1415,7 +1426,7 @@
def hasblock(self, name=None, block_type=None):
if self.getbodyType() in ["FBD", "LD", "SFC"]:
for instance in self.getinstances():
- if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and + if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and (name and instance.getinstanceName() == name or
block_type and instance.gettypeName() == block_type)):
@@ -1434,16 +1445,16 @@
setattr(cls, "hasblock", hasblock)
- def addtransition(self, name, type):+ def addtransition(self, name, body_type): self.transitions.settransition([])
- transition = PLCOpenClasses["transitions_transition"]()+ transition = PLCOpenParser.CreateElement("transition", "transitions") - transition.setbodyType(type)+ transition.setbodyType(body_type) transition.settext(":= ;")
+ elif body_type == "IL": transition.settext("\tST\t%s"%name)
self.transitions.appendtransition(transition)
setattr(cls, "addtransition", addtransition)
@@ -1464,30 +1475,28 @@
def removetransition(self, name):
- transitions = self.transitions.gettransition()- while i < len(transitions) and not removed:- if transitions[i].getname() == name:- if transitions[i].getbodyType() in ["FBD", "LD", "SFC"]:- for instance in transitions[i].getinstances():- if isinstance(instance, PLCOpenClasses["fbdObjects_block"]):+ for transition in self.transitions.gettransition(): + if transition.getname() == name: + if transition.getbodyType() in ["FBD", "LD", "SFC"]: + for instance in transition.getinstances(): + if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): self.removepouVar(instance.gettypeName(),
instance.getinstanceName())
+ self.transitions.remove(transition)
raise ValueError, _("Transition with name %s doesn't exist!")%name
setattr(cls, "removetransition", removetransition)
- def addaction(self, name, type):+ def addaction(self, name, body_type): self.actions.setaction([])
- action = PLCOpenClasses["actions_action"]()+ action = PLCOpenParser.CreateElement("action", "actions") - action.setbodyType(type)+ action.setbodyType(body_type) self.actions.appendaction(action)
setattr(cls, "addaction", addaction)
@@ -1507,19 +1516,17 @@
def removeaction(self, name):
- actions = self.actions.getaction()- while i < len(actions) and not removed:- if actions[i].getname() == name:- if actions[i].getbodyType() in ["FBD", "LD", "SFC"]:- for instance in actions[i].getinstances():- if isinstance(instance, PLCOpenClasses["fbdObjects_block"]):+ for action in self.actions.getaction(): + if action.getname() == name: + if action.getbodyType() in ["FBD", "LD", "SFC"]: + for instance in action.getinstances(): + if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): self.removepouVar(instance.gettypeName(),
instance.getinstanceName())
+ self.actions.remove(action)
raise ValueError, _("Action with name %s doesn't exist!")%name
setattr(cls, "removeaction", removeaction)
@@ -1527,7 +1534,7 @@
def updateElementName(self, old_name, new_name):
for content in self.interface.getcontent():
- for var in content["value"].getvariable():+ for var in content.getvariable(): var_address = var.getaddress()
if var_address is not None:
if var_address == old_name:
@@ -1535,9 +1542,9 @@
if var.getname() == old_name:
var_type_content = var.gettype().getcontent()
- if var_type_content["name"] == "derived":- if var_type_content["value"].getname() == old_name:- var_type_content["value"].setname(new_name)+ if var_type_content.getLocalTag() == "derived": + if var_type_content.getname() == old_name: + var_type_content.setname(new_name) self.body[0].updateElementName(old_name, new_name)
for action in self.getactionList():
action.updateElementName(old_name, new_name)
@@ -1548,7 +1555,7 @@
def updateElementAddress(self, address_model, new_leading):
for content in self.interface.getcontent():
- for var in content["value"].getvariable():+ for var in content.getvariable(): var_address = var.getaddress()
if var_address is not None:
var.setaddress(update_address(var_address, address_model, new_leading))
@@ -1562,22 +1569,20 @@
def removeVariableByAddress(self, address):
for content in self.interface.getcontent():
- variables = content["value"].getvariable()- for i in xrange(len(variables)-1, -1, -1):- if variables[i].getaddress() == address:+ for variable in content.getvariable(): + if variable.getaddress() == address: + content.remove(variable) setattr(cls, "removeVariableByAddress", removeVariableByAddress)
def removeVariableByFilter(self, address_model):
for content in self.interface.getcontent():
- variables = content["value"].getvariable()- for i in xrange(len(variables)-1, -1, -1):- var_address = variables[i].getaddress()+ for variable in content.getvariable(): + var_address = variable.getaddress() if var_address is not None:
result = address_model.match(var_address)
+ content.remove(variable) setattr(cls, "removeVariableByFilter", removeVariableByFilter)
def Search(self, criteria, parent_infos=[]):
@@ -1589,11 +1594,11 @@
if self.interface is not None:
for content in self.interface.getcontent():
- variable_type = searchResultVarTypes.get(content["value"], "var_local")- variables = content["value"].getvariable()- for modifier, has_modifier in [("constant", content["value"].getconstant()),- ("retain", content["value"].getretain()),- ("non_retain", content["value"].getnonretain())]:+ variable_type = searchResultVarTypes.get(content, "var_local") + variables = content.getvariable() + for modifier, has_modifier in [("constant", content.getconstant()), + ("retain", content.getretain()), + ("non_retain", content.getnonretain())]: for result in TestTextElement(modifier, criteria):
search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result)
@@ -1610,22 +1615,14 @@
setattr(cls, "Search", Search)
-def setbodyType(self, type):- self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})- self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})- self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})- self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})- self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})+def setbodyType(self, body_type): + if body_type in ["IL", "ST", "LD", "FBD", "SFC"]: + self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body")) raise ValueError, "%s isn't a valid body type!"%type
- return self.body.getcontent()["name"]+ return self.body.getcontent().getLocalTag() def resetexecutionOrder(self):
self.body.resetexecutionOrder()
@@ -1663,7 +1660,7 @@
def hasblock(self, name=None, block_type=None):
if self.getbodyType() in ["FBD", "LD", "SFC"]:
for instance in self.getinstances():
- if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and + if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and (name and instance.getinstanceName() == name or
block_type and instance.gettypeName() == block_type)):
@@ -1678,7 +1675,7 @@
self.body.updateElementAddress(address_model, new_leading)
-cls = PLCOpenClasses.get("transitions_transition", None)+cls = PLCOpenParser.GetElementClass("transition", "transitions") setattr(cls, "setbodyType", setbodyType)
setattr(cls, "getbodyType", getbodyType)
@@ -1706,7 +1703,7 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("actions_action", None)+cls = PLCOpenParser.GetElementClass("action", "actions") setattr(cls, "setbodyType", setbodyType)
setattr(cls, "getbodyType", getbodyType)
@@ -1734,27 +1731,9 @@
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("body", None)+cls = PLCOpenParser.GetElementClass("body") cls.currentExecutionOrderId = 0
- cls.instances_dict = {}- setattr(cls, "_init_", getattr(cls, "__init__"))- def __init__(self, *args, **kwargs):- self._init_(*args, **kwargs)- self.instances_dict = {}- setattr(cls, "__init__", __init__)- setattr(cls, "_loadXMLTree", getattr(cls, "loadXMLTree"))- def loadXMLTree(self, *args, **kwargs):- self._loadXMLTree(*args, **kwargs)- if self.content["name"] in ["LD","FBD","SFC"]:- self.instances_dict = dict(- [(element["value"].getlocalId(), element)- for element in self.content["value"].getcontent()])- setattr(cls, "loadXMLTree", loadXMLTree) def resetcurrentExecutionOrderId(self):
object.__setattr__(self, "currentExecutionOrderId", 0)
@@ -1766,44 +1745,44 @@
setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId)
def resetexecutionOrder(self):
- if self.content["name"] == "FBD":- for element in self.content["value"].getcontent():- if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None), - PLCOpenClasses.get("commonObjects_connector", None), - PLCOpenClasses.get("commonObjects_continuation", None))):- element["value"].setexecutionOrderId(0)+ if self.content.getLocalTag() == "FBD": + for element in self.content.getcontent(): + if not isinstance(element, (PLCOpenParser.GetElementClass("comment", "commonObjects"), + PLCOpenParser.GetElementClass("connector", "commonObjects"), + PLCOpenParser.GetElementClass("continuation", "commonObjects"))): + element.setexecutionOrderId(0) raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "resetexecutionOrder", resetexecutionOrder)
def compileexecutionOrder(self):
- if self.content["name"] == "FBD":+ if self.content.getLocalTag() == "FBD": self.resetexecutionOrder()
self.resetcurrentExecutionOrderId()
- for element in self.content["value"].getcontent():- if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getexecutionOrderId() == 0:- connections = element["value"].connectionPointIn.getconnections()+ for element in self.content.getcontent(): + if isinstance(element, PLCOpenParser.GetElementClass("outVariable", "fbdObjects")) and element.getexecutionOrderId() == 0: + connections = element.connectionPointIn.getconnections() if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
- element["value"].setexecutionOrderId(self.getnewExecutionOrderId())+ element.setexecutionOrderId(self.getnewExecutionOrderId()) raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "compileexecutionOrder", compileexecutionOrder)
def compileelementExecutionOrder(self, link):
- if self.content["name"] == "FBD":+ if self.content.getLocalTag() == "FBD": localid = link.getrefLocalId()
instance = self.getcontentInstance(localid)
- if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0:+ if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and instance.getexecutionOrderId() == 0: for variable in instance.inputVariables.getvariable():
connections = variable.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
instance.setexecutionOrderId(self.getnewExecutionOrderId())
- elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0:+ elif isinstance(instance, PLCOpenParser.GetElementClass("continuation", "commonObjects")) and instance.getexecutionOrderId() == 0: name = instance.getname()
for tmp_instance in self.getcontentInstances():
- if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:+ if isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0: connections = tmp_instance.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
@@ -1812,74 +1791,70 @@
setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)
def setelementExecutionOrder(self, instance, new_executionOrder):
- if self.content["name"] == "FBD":+ if self.contentLgetLocalTag() == "FBD": old_executionOrder = instance.getexecutionOrderId()
if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0:
- for element in self.content["value"].getcontent():- if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)):- element_executionOrder = element["value"].getexecutionOrderId()+ for element in self.content.getcontent(): + if element != instance and not isinstance(element, PLCOpenParser.GetElementClass("comment", "commonObjects")): + element_executionOrder = element.getexecutionOrderId() if old_executionOrder <= element_executionOrder <= new_executionOrder:
- element["value"].setexecutionOrderId(element_executionOrder - 1)+ element.setexecutionOrderId(element_executionOrder - 1) if new_executionOrder <= element_executionOrder <= old_executionOrder:
- element["value"].setexecutionOrderId(element_executionOrder + 1)+ element.setexecutionOrderId(element_executionOrder + 1) instance.setexecutionOrderId(new_executionOrder)
raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
def appendcontentInstance(self, name, instance):
- if self.content["name"] in ["LD","FBD","SFC"]:- element = {"name" : name, "value" : instance}- self.content["value"].appendcontent(element)- self.instances_dict[instance.getlocalId()] = element+ if self.content.getLocalTag() in ["LD","FBD","SFC"]: + self.content.appendcontent(instance) raise TypeError, _("%s body don't have instances!")%self.content["name"]
setattr(cls, "appendcontentInstance", appendcontentInstance)
def getcontentInstances(self):
- if self.content["name"] in ["LD","FBD","SFC"]:- for element in self.content["value"].getcontent():- instances.append(element["value"])+ if self.content.getLocalTag() in ["LD","FBD","SFC"]: + return self.content.getcontent() raise TypeError, _("%s body don't have instances!")%self.content["name"]
setattr(cls, "getcontentInstances", getcontentInstances)
- def getcontentInstance(self, id):- if self.content["name"] in ["LD","FBD","SFC"]:- instance = self.instances_dict.get(id, None)- if instance is not None:- return instance["value"]+ def getcontentInstance(self, local_id): + if self.content.getLocalTag() in ["LD","FBD","SFC"]: + instance = self.content.xpath("*[@localId=%d]" % local_id) raise TypeError, _("%s body don't have instances!")%self.content["name"]
setattr(cls, "getcontentInstance", getcontentInstance)
def getcontentRandomInstance(self, exclude):
- if self.content["name"] in ["LD","FBD","SFC"]:- ids = self.instances_dict.viewkeys() - exclude- return self.instances_dict[ids.pop()]["value"]+ if self.content.getLocalTag() in ["LD","FBD","SFC"]: + instance = self.content.xpath("*[regexp:test(@localId,'(%s)')]" % "|".join(map(str, exclude))) raise TypeError, _("%s body don't have instances!")%self.content["name"]
setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
def getcontentInstanceByName(self, name):
- if self.content["name"] in ["LD","FBD","SFC"]:- for element in self.content["value"].getcontent():- if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_block", None)) and element["value"].getinstanceName() == name:- return element["value"]+ if self.content.getLocalTag() in ["LD","FBD","SFC"]: + instance = self.content.xpath("ppx:block[@instanceName=%s]" % name, namespaces=PLCOpenParser.NSMAP) raise TypeError, _("%s body don't have instances!")%self.content["name"]
setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
- def removecontentInstance(self, id):- if self.content["name"] in ["LD","FBD","SFC"]:- element = self.instances_dict.pop(id, None)- if element is not None:- self.content["value"].getcontent().remove(element)+ def removecontentInstance(self, local_id): + if self.content.getLocalTag() in ["LD","FBD","SFC"]: + instance = self.content.xpath("*[@localId=%d]" % local_id) + self.content.remove(instance[0]) raise ValueError, _("Instance with id %d doesn't exist!")%id
@@ -1887,49 +1862,49 @@
setattr(cls, "removecontentInstance", removecontentInstance)
- if self.content["name"] in ["IL","ST"]:- self.content["value"].settext(text)+ if self.content.getLocalTag() in ["IL","ST"]: + self.content.settext(text) raise TypeError, _("%s body don't have text!")%self.content["name"]
setattr(cls, "settext", settext)
- if self.content["name"] in ["IL","ST"]:- return self.content["value"].gettext()+ if self.content.getLocalTag() in ["IL","ST"]: + return self.content.gettext() raise TypeError, _("%s body don't have text!")%self.content["name"]
setattr(cls, "gettext", gettext)
def hasblock(self, block_type):
- if self.content["name"] in ["IL","ST"]:- return self.content["value"].hasblock(block_type)+ if self.content.getLocalTag() in ["IL","ST"]: + return self.content.hasblock(block_type) raise TypeError, _("%s body don't have text!")%self.content["name"]
setattr(cls, "hasblock", hasblock)
def updateElementName(self, old_name, new_name):
- if self.content["name"] in ["IL", "ST"]:- self.content["value"].updateElementName(old_name, new_name)+ if self.content.getLocalTag() in ["IL", "ST"]: + self.content.updateElementName(old_name, new_name) - for element in self.content["value"].getcontent():- element["value"].updateElementName(old_name, new_name)+ for element in self.content.getcontent(): + element.updateElementName(old_name, new_name) setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.content["name"] in ["IL", "ST"]:- self.content["value"].updateElementAddress(address_model, new_leading)+ if self.content.getLocalTag() in ["IL", "ST"]: + self.content.updateElementAddress(address_model, new_leading) - for element in self.content["value"].getcontent():- element["value"].updateElementAddress(address_model, new_leading)+ for element in self.content.getcontent(): + element.updateElementAddress(address_model, new_leading) setattr(cls, "updateElementAddress", updateElementAddress)
def Search(self, criteria, parent_infos=[]):
- if self.content["name"] in ["IL", "ST"]:- search_result = self.content["value"].Search(criteria, parent_infos + ["body", 0])+ if self.content.getLocalTag() in ["IL", "ST"]: + search_result = self.content.Search(criteria, parent_infos + ["body", 0]) - for element in self.content["value"].getcontent():- search_result.extend(element["value"].Search(criteria, parent_infos))+ for element in self.content.getcontent(): + search_result.extend(element.Search(criteria, parent_infos)) setattr(cls, "Search", Search)
@@ -1972,15 +1947,11 @@
def _filterConnections(connectionPointIn, localId, connections):
in_connections = connectionPointIn.getconnections()
if in_connections is not None:
- for i, connection in enumerate(in_connections):+ for connection in in_connections: connected = connection.getrefLocalId()
if not connections.has_key((localId, connected)) and \
not connections.has_key((connected, localId)):
- connectionPointIn.removeconnection(i)+ connectionPointIn.remove(connection) def _filterConnectionsSingle(self, connections):
if self.connectionPointIn is not None:
@@ -1991,8 +1962,8 @@
_filterConnections(connectionPointIn, self.localId, connections)
def _getconnectionsdefinition(instance, connections_end):
- id = instance.getlocalId()- return dict([((id, end), True) for end in connections_end])+ local_id = instance.getlocalId() + return dict([((local_id, end), True) for end in connections_end]) def _updateConnectionsId(connectionPointIn, translation):
@@ -2063,9 +2034,8 @@
"multiple": _updateConnectionsIdMultiple},
-def _initElementClass(name, classname, connectionPointInType="none"):- ElementNameToClass[name] = classname- cls = PLCOpenClasses.get(classname, None)+def _initElementClass(name, parent, connectionPointInType="none"): + cls = PLCOpenParser.GetElementClass(name, parent) setattr(cls, "getx", getx)
setattr(cls, "gety", gety)
@@ -2210,7 +2180,7 @@
return getdivergenceinfos
-cls = _initElementClass("comment", "commonObjects_comment")+cls = _initElementClass("comment", "commonObjects") infos = _getelementinfos(self)
@@ -2239,7 +2209,7 @@
return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"])
setattr(cls, "Search", Search)
-cls = _initElementClass("block", "fbdObjects_block")+cls = _initElementClass("block", "fbdObjects") def getBoundingBox(self):
bbox = _getBoundingBox(self)
@@ -2298,15 +2268,15 @@
setattr(cls, "Search", Search)
-cls = _initElementClass("leftPowerRail", "ldObjects_leftPowerRail")+cls = _initElementClass("leftPowerRail", "ldObjects") setattr(cls, "getinfos", _getpowerrailinfosFunction("leftPowerRail"))
-cls = _initElementClass("rightPowerRail", "ldObjects_rightPowerRail", "multiple")+cls = _initElementClass("rightPowerRail", "ldObjects", "multiple") setattr(cls, "getinfos", _getpowerrailinfosFunction("rightPowerRail"))
-cls = _initElementClass("contact", "ldObjects_contact", "single")+cls = _initElementClass("contact", "ldObjects", "single") setattr(cls, "getinfos", _getldelementinfosFunction("contact"))
@@ -2323,7 +2293,7 @@
return _Search([("reference", self.getvariable())], criteria, parent_infos + ["contact", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = _initElementClass("coil", "ldObjects_coil", "single")+cls = _initElementClass("coil", "ldObjects", "single") setattr(cls, "getinfos", _getldelementinfosFunction("coil"))
@@ -2340,7 +2310,7 @@
return _Search([("reference", self.getvariable())], criteria, parent_infos + ["coil", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = _initElementClass("step", "sfcObjects_step", "single")+cls = _initElementClass("step", "sfcObjects", "single") infos = _getelementinfos(self)
@@ -2361,7 +2331,7 @@
return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("transition_condition", None)+cls = PLCOpenParser.GetElementClass("condition", "transition") def compatibility(self, tree):
@@ -2378,7 +2348,7 @@
setattr(cls, "compatibility", compatibility)
-cls = _initElementClass("transition", "sfcObjects_transition")+cls = _initElementClass("transition", "sfcObjects") infos = _getelementinfos(self)
@@ -2399,33 +2369,32 @@
setattr(cls, "getinfos", getinfos)
- def setconditionContent(self, type, value):+ def setconditionContent(self, condition_type, value): - if type == "reference":- condition = PLCOpenClasses["condition_reference"]()+ if condition_type == "reference": + condition = PLCOpenParser.CreateElement("reference", "condition")
- condition = PLCOpenClasses["condition_inline"]()- condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})+ elif condition_type == "inline": + condition = PLCOpenParser.CreateElement("inline", "condition") + condition.setcontent(PLCOpenParser.GetElementClass("ST", "inline")) - elif type == "connection":- type = "connectionPointIn"- condition = PLCOpenClasses["connectionPointIn"]()- self.condition.setcontent({"name" : type, "value" : condition})+ elif condition_type == "connection": + condition = PLCOpenParser.CreateElementClass("connectionPointIn") + self.condition.setcontent(condition) setattr(cls, "setconditionContent", setconditionContent)
def getconditionContent(self):
content = self.condition.getcontent()
- values = {"type" : content["name"]}+ values = {"type" : content.getLocalTag()} if values["type"] == "reference":
- values["value"] = content["value"].getname()+ values["value"] = content.getname() elif values["type"] == "inline":
- values["value"] = content["value"].gettext()+ values["value"] = content.gettext() elif values["type"] == "connectionPointIn":
values["type"] = "connection"
- values["value"] = content["value"]+ values["value"] = content setattr(cls, "getconditionContent", getconditionContent)
@@ -2433,8 +2402,8 @@
def getconditionConnection(self):
content = self.condition.getcontent()
- if content["name"] == "connectionPointIn":- return content["value"]+ if content.getLocalTag() == "connectionPointIn": setattr(cls, "getconditionConnection", getconditionConnection)
@@ -2473,20 +2442,22 @@
def updateElementName(self, old_name, new_name):
content = self.condition.getcontent()
- if content["name"] == "reference":- if content["value"].getname() == old_name:- content["value"].setname(new_name)- elif content["name"] == "inline":- content["value"].updateElementName(old_name, new_name)+ content_name = content.getLocalTag() + if content_name == "reference": + if content.getname() == old_name: + content.setname(new_name) + elif content_name == "inline": + content.updateElementName(old_name, new_name) setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
content = self.condition.getcontent()
- if content["name"] == "reference":- content["value"].setname(update_address(content["value"].getname(), address_model, new_leading))- elif content["name"] == "inline":- content["value"].updateElementAddress(address_model, new_leading)+ content_name = content.getLocalTag() + if content_name == "reference": + content.setname(update_address(content.getname(), address_model, new_leading)) + elif content_name == "inline": + content.updateElementAddress(address_model, new_leading) setattr(cls, "updateElementAddress", updateElementAddress)
def getconnections(self):
@@ -2500,10 +2471,11 @@
parent_infos = parent_infos + ["transition", self.getlocalId()]
content = self.condition.getcontent()
- if content["name"] == "reference":- search_result.extend(_Search([("reference", content["value"].getname())], criteria, parent_infos))- elif content["name"] == "inline":- search_result.extend(content["value"].Search(criteria, parent_infos + ["inline"]))+ content_name = content.getLocalTag() + if content_name == "reference": + search_result.extend(_Search([("reference", content.getname())], criteria, parent_infos)) + elif content_name == "inline": + search_result.extend(content.Search(criteria, parent_infos + ["inline"])) setattr(cls, "Search", Search)
@@ -2537,7 +2509,7 @@
return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("actionBlock_action", None)+cls = PLCOpenParser.GetElementClass("action", "actionBlock") def compatibility(self, tree):
relPosition = reduce(lambda x, y: x | (y.nodeName == "relPosition"), tree.childNodes, False)
@@ -2563,7 +2535,7 @@
def setinlineContent(self, content):
- self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})+ self.inline.setcontent(PLCOpenParser.CreateElementClass("ST", "action")) self.inline.settext(content)
setattr(cls, "setinlineContent", setinlineContent)
@@ -2618,7 +2590,7 @@
def setactions(self, actions):
- action = PLCOpenClasses["actionBlock_action"]()+ action = PLCOpenParser.GetElementClass("action", "actionBlock")() action.setqualifier(params["qualifier"])
if params["type"] == "reference":
@@ -2746,15 +2718,16 @@
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("connection", None)+cls = PLCOpenParser.GetElementClass("connection") def setpoints(self, points):
- position = PLCOpenClasses["position"]()+ position = PLCOpenParser.CreateElement("position") - self.position.append(position)+ positions.append(position) + self.positions = positions setattr(cls, "setpoints", setpoints)
@@ -2764,10 +2737,10 @@
setattr(cls, "getpoints", getpoints)
-cls = PLCOpenClasses.get("connectionPointIn", None)+cls = PLCOpenParser.GetElementClass("connectionPointIn") def setrelPositionXY(self, x, y):
- self.relPosition = PLCOpenClasses["position"]()+ self.relPosition = PLCOpenParser.CreateElement("position") setattr(cls, "setrelPositionXY", setrelPositionXY)
@@ -2780,67 +2753,59 @@
setattr(cls, "getrelPositionXY", getrelPositionXY)
- self.content = {"name" : "connection", "value" : [PLCOpenClasses["connection"]()]}- self.content["value"].append(PLCOpenClasses["connection"]())+ self.appendcontent(PLCOpenParser.CreateElement("connection")) setattr(cls, "addconnection", addconnection)
def removeconnection(self, idx):
- self.content["value"].pop(idx)- if len(self.content["value"]) == 0:+ if len(self.content) > idx: + self.remove(self.content[idx]) setattr(cls, "removeconnection", removeconnection)
def removeconnections(self):
setattr(cls, "removeconnections", removeconnections)
def getconnections(self):
- return self.content["value"] setattr(cls, "getconnections", getconnections)
- def setconnectionId(self, idx, id):- self.content["value"][idx].setrefLocalId(id)+ def setconnectionId(self, idx, local_id): + if len(self.content) > idx: + self.content[idx].setrefLocalId(local_id) setattr(cls, "setconnectionId", setconnectionId)
def getconnectionId(self, idx):
- return self.content["value"][idx].getrefLocalId()+ if len(self.content) > idx: + return self.content[idx].getrefLocalId() setattr(cls, "getconnectionId", getconnectionId)
def setconnectionPoints(self, idx, points):
- self.content["value"][idx].setpoints(points)+ if len(self.content) > idx: + self.content[idx].setpoints(points) setattr(cls, "setconnectionPoints", setconnectionPoints)
def getconnectionPoints(self, idx):
- return self.content["value"][idx].getpoints()+ if len(self.content) > idx: + return self.content[idx].getpoints() setattr(cls, "getconnectionPoints", getconnectionPoints)
def setconnectionParameter(self, idx, parameter):
- self.content["value"][idx].setformalParameter(parameter)+ if len(self.content) > idx: + self.content[idx].setformalParameter(parameter) setattr(cls, "setconnectionParameter", setconnectionParameter)
def getconnectionParameter(self, idx):
- return self.content["value"][idx].getformalParameter()+ if len(self.content) > idx: + return self.content[idx].getformalParameter() setattr(cls, "getconnectionParameter", getconnectionParameter)
-cls = PLCOpenClasses.get("connectionPointOut", None)+cls = PLCOpenParser.GetElementClass("connectionPointOut") def setrelPositionXY(self, x, y):
- self.relPosition = PLCOpenClasses["position"]()+ self.relPosition = PLCOpenParser.CreateElement("position") setattr(cls, "setrelPositionXY", setrelPositionXY)
@@ -2851,24 +2816,21 @@
setattr(cls, "getrelPositionXY", getrelPositionXY)
-cls = PLCOpenClasses.get("value", None)+cls = PLCOpenParser.GetElementClass("value") def setvalue(self, value):
if value.startswith("[") and value.endswith("]"):
- arrayValue = PLCOpenClasses["value_arrayValue"]()- self.content = {"name" : "arrayValue", "value" : arrayValue}+ self.content = PLCOpenParser.CreateElement("arrayValue", "value") elif value.startswith("(") and value.endswith(")"):
- structValue = PLCOpenClasses["value_structValue"]()- self.content = {"name" : "structValue", "value" : structValue}+ self.content = PLCOpenParser.CreateElement("structValue", "value") - simpleValue = PLCOpenClasses["value_simpleValue"]()- self.content = {"name" : "simpleValue", "value": simpleValue}- self.content["value"].setvalue(value)+ self.content = PLCOpenParser.CreateElement("simpleValue", "value") + self.content.setvalue(value) setattr(cls, "setvalue", setvalue)
- return self.content["value"].getvalue()+ return self.content.getvalue() setattr(cls, "getvalue", getvalue)
def extractValues(values):
@@ -2885,15 +2847,15 @@
raise ValueError, _("\"%s\" is an invalid value!")%value
-cls = PLCOpenClasses.get("value_arrayValue", None)+cls = PLCOpenParser.GetElementClass("arrayValue", "value") arrayValue_model = re.compile("([0-9]*)\((.*)\)$")
def setvalue(self, value):
for item in extractValues(value[1:-1]):
- element = PLCOpenClasses["arrayValue_value"]()+ element = PLCOpenParser.CreateElement("value", "arrayValue") result = arrayValue_model.match(item)
@@ -2901,7 +2863,8 @@
element.setvalue(groups[1].strip())
- self.value.append(element)+ elements.append(element) setattr(cls, "setvalue", setvalue)
@@ -2918,20 +2881,21 @@
return "[%s]"%", ".join(values)
setattr(cls, "getvalue", getvalue)
-cls = PLCOpenClasses.get("value_structValue", None)+cls = PLCOpenParser.GetElementClass("structValue", "value") structValue_model = re.compile("(.*):=(.*)")
def setvalue(self, value):
for item in extractValues(value[1:-1]):
result = structValue_model.match(item)
- element = PLCOpenClasses["structValue_value"]()+ element = PLCOpenParser.CreateElement("value", "structValue") element.setmember(groups[0].strip())
element.setvalue(groups[1].strip())
- self.value.append(element)+ elements.append(element) setattr(cls, "setvalue", setvalue)
@@ -2940,3 +2904,4 @@
values.append("%s := %s"%(element.getmember(), element.getvalue()))
return "(%s)"%", ".join(values)
setattr(cls, "getvalue", getvalue)
--- a/xmlclass/xmlclass.py Wed Aug 07 11:47:14 2013 +0200
+++ b/xmlclass/xmlclass.py Mon Aug 26 10:55:03 2013 +0200
@@ -28,7 +28,9 @@
from xml.dom import minidom
from xml.sax.saxutils import escape, unescape, quoteattr
+from collections import OrderedDict @@ -591,15 +593,21 @@
def GetElementInitialValue(factory, infos):
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["minOccurs"] == 0 and infos["maxOccurs"] == 1:- if infos.has_key("default"):- return infos["elmt_type"]["extract"](infos["default"], False)+ if infos["minOccurs"] == 1: + element_name = factory.etreeNamespaceFormat % infos["name"] + if infos["type"] == SIMPLETYPE: + value = etree.Element(element_name) + value.text = (infos["elmt_type"]["generate"](infos["elmt_type"]["initial"]()))
- elif infos["minOccurs"] == 1 and infos["maxOccurs"] == 1:- return infos["elmt_type"]["initial"]()+ value = infos["elmt_type"]["initial"]() + DefaultElementClass.__setattr__(value, "tag", element_name) + return [initial_value() for i in xrange(infos["minOccurs"])] - return [infos["elmt_type"]["initial"]() for i in xrange(infos["minOccurs"])] def HandleError(message, raise_exception):
@@ -691,6 +699,10 @@
if choices_dict.has_key(choice_name):
raise ValueError("'%s' element defined two times in choice" % choice_name)
choices_dict[choice_name] = infos
+ choices_xpath = "|".join(map(lambda x: "%s:%s" % (factory.TargetNamespace, x), choices_dict.keys())) + def GetContentChoicesXPath(): content_name, infos = choices[0]
@@ -828,6 +840,7 @@
+ "choices_xpath": GetContentChoicesXPath, "initial": GetContentInitial,
"extract": ExtractContent,
@@ -901,9 +914,11 @@
self.XMLClassDefinitions = {}
self.DefinedNamespaces = {}
self.SchemaNamespace = None
self.TargetNamespace = None
+ self.etreeNamespaceFormat = "%s" self.CurrentCompilations = []
@@ -914,6 +929,8 @@
self.ComputedClasses = {}
self.ComputedClassesInfos = {}
+ self.ComputedClassesLookUp = {} + self.EquivalentClassesParent = {} self.AlreadyComputed = {}
def GetQualifiedNameInfos(self, name, namespace=None, canbenone=False):
@@ -1016,7 +1033,9 @@
attrs[name] = infos["extract"]["default"](attr)
elif namespace == "xmlns":
infos = self.GetQualifiedNameInfos("anyURI", self.SchemaNamespace)
- self.DefinedNamespaces[infos["extract"](attr)] = name+ value = infos["extract"](attr) + self.DefinedNamespaces[value] = name + self.NSMAP[name] = value raise ValueError("Invalid attribute \"%s\" for member \"%s\"!" % (qualified_name, node.nodeName))
@@ -1063,20 +1082,44 @@
+ def AddEquivalentClass(self, name, base): + equivalences = self.EquivalentClassesParent.setdefault(self.etreeNamespaceFormat % name, {}) + equivalences[self.etreeNamespaceFormat % base] = True + def AddToLookupClass(self, name, parent, typeinfos): + lookup_name = self.etreeNamespaceFormat % name + if isinstance(typeinfos, (StringType, UnicodeType)): + self.AddEquivalentClass(name, typeinfos) + typeinfos = self.etreeNamespaceFormat % typeinfos + lookup_classes = self.ComputedClassesLookUp.get(lookup_name) + if lookup_classes is None: + self.ComputedClassesLookUp[lookup_name] = (typeinfos, parent) + elif isinstance(lookup_classes, DictType): + lookup_classes[self.etreeNamespaceFormat % parent + if parent is not None else None] = typeinfos + lookup_classes = {self.etreeNamespaceFormat % lookup_classes[1] + if lookup_classes[1] is not None else None: lookup_classes[0]} + lookup_classes[self.etreeNamespaceFormat % parent + if parent is not None else None] = typeinfos + self.ComputedClassesLookUp[lookup_name] = lookup_classes def ExtractTypeInfos(self, name, parent, typeinfos):
if isinstance(typeinfos, (StringType, UnicodeType)):
- namespace, name = DecomposeQualifiedName(typeinfos)- infos = self.GetQualifiedNameInfos(name, namespace)+ namespace, type_name = DecomposeQualifiedName(typeinfos) + if namespace == self.TargetNamespace and name != "base": + self.AddToLookupClass(name, parent, type_name) + infos = self.GetQualifiedNameInfos(type_name, namespace) if infos["type"] == COMPLEXTYPE:
- name, parent = self.SplitQualifiedName(name, namespace)- result = self.CreateClass(name, parent, infos)+ type_name, parent = self.SplitQualifiedName(type_name, namespace) + result = self.CreateClass(type_name, parent, infos) if result is not None and not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
elif infos["type"] == ELEMENT and infos["elmt_type"]["type"] == COMPLEXTYPE:
- name, parent = self.SplitQualifiedName(name, namespace)- result = self.CreateClass(name, parent, infos["elmt_type"])+ type_name, parent = self.SplitQualifiedName(type_name, namespace) + result = self.CreateClass(type_name, parent, infos["elmt_type"]) if result is not None and not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
@@ -1141,9 +1184,12 @@
base_infos = classinfos.get("base", None)
if base_infos is not None:
+ namespace, base_name = DecomposeQualifiedName(base_infos) + if namespace == self.TargetNamespace: + self.AddEquivalentClass(name, base_name) result = self.ExtractTypeInfos("base", name, base_infos)
- namespace, base_name = DecomposeQualifiedName(base_infos) + namespace, base_name = DecomposeQualifiedName(base_infos) if self.AlreadyComputed.get(base_name, False):
self.ComputeAfter.append((name, parent, classinfos))
if self.TargetNamespace is not None:
@@ -1164,7 +1210,7 @@
if classinfos["base"] is None:
raise ValueError("No class found for base type")
bases.append(classinfos["base"])
+ bases.append(DefaultElementClass) classmembers = {"__doc__": classinfos.get("doc", ""), "IsBaseClass": baseclass}
@@ -1177,11 +1223,8 @@
raise ValueError("\"%s\" type is not a simple type!" % attribute["attr_type"])
attrname = attribute["name"]
if attribute["use"] == "optional":
- classmembers[attrname] = None classmembers["add%s"%attrname] = generateAddMethod(attrname, self, attribute)
classmembers["delete%s"%attrname] = generateDeleteMethod(attrname)
- classmembers[attrname] = infos["initial"]() classmembers["set%s"%attrname] = generateSetMethod(attrname)
classmembers["get%s"%attrname] = generateGetMethod(attrname)
@@ -1212,24 +1255,18 @@
element["elmt_type"] = infos
if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:
- classmembers[elmtname] = [] classmembers["append%s" % elmtname] = generateAppendMethod(elmtname, element["maxOccurs"], self, element)
classmembers["insert%s" % elmtname] = generateInsertMethod(elmtname, element["maxOccurs"], self, element)
classmembers["remove%s" % elmtname] = generateRemoveMethod(elmtname, element["minOccurs"])
classmembers["count%s" % elmtname] = generateCountMethod(elmtname)
if element["minOccurs"] == 0:
- classmembers[elmtname] = None classmembers["add%s" % elmtname] = generateAddMethod(elmtname, self, element)
classmembers["delete%s" % elmtname] = generateDeleteMethod(elmtname)
- elif not isinstance(element["elmt_type"], (UnicodeType, StringType)):- classmembers[elmtname] = element["elmt_type"]["initial"]()- classmembers[elmtname] = None classmembers["set%s" % elmtname] = generateSetMethod(elmtname)
classmembers["get%s" % elmtname] = generateGetMethod(elmtname)
- classmembers["__init__"] = generateInitMethod(self, classinfos)+ classmembers["_init"] = generateInitMethod(self, classinfos) classmembers["getStructure"] = generateStructureMethod(classinfos)
classmembers["loadXMLTree"] = generateLoadXMLTree(self, classinfos)
classmembers["generateXMLText"] = generateGenerateXMLText(self, classinfos)
@@ -1241,6 +1278,7 @@
classmembers["extraAttrs"] = {}
class_definition = classobj(str(classname), bases, classmembers)
+ setattr(class_definition, "__getattr__", generateGetattrMethod(self, class_definition, classinfos)) setattr(class_definition, "__setattr__", generateSetattrMethod(self, class_definition, classinfos))
class_infos = {"type": COMPILEDCOMPLEXTYPE,
@@ -1255,6 +1293,9 @@
self.ComputedClasses[classname] = class_definition
self.ComputedClassesInfos[classname] = class_infos
+ self.AddToLookupClass(name, parent, class_definition) + self.AddToLookupClass(classname, None, class_definition) @@ -1306,6 +1347,46 @@
return classExtractfunction
+def generateGetattrMethod(factory, class_definition, classinfos): + attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"]) + optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"]) + elements = dict([(element["name"], element) for element in classinfos["elements"]]) + def getattrMethod(self, name): + if attributes.has_key(name): + attribute_infos = attributes[name] + attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"]) + return attribute_infos["attr_type"]["extract"](value, extract=False) + elif attribute_infos.has_key("fixed"): + return attribute_infos["attr_type"]["extract"](attribute_infos["fixed"], extract=False) + return attribute_infos["attr_type"]["initial"]() + elif elements.has_key(name): + element_infos = elements[name] + element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"]) + content = self.xpath(element_infos["elmt_type"]["choices_xpath"](), namespaces=factory.NSMAP) + if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1: + element_name = factory.etreeNamespaceFormat % name + if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1: + return self.findall(element_name) + return self.find(element_name) + elif classinfos.has_key("base"): + return classinfos["base"].__getattr__(self, name) + return DefaultElementClass.__getattribute__(self, name) Method that generate the method for loading an xml tree by following the
@@ -1313,31 +1394,52 @@
def generateSetattrMethod(factory, class_definition, classinfos):
attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])
- elements = dict([(element["name"], element) for element in classinfos["elements"]])+ elements = OrderedDict([(element["name"], element) for element in classinfos["elements"]]) def setattrMethod(self, name, value):
if attributes.has_key(name):
- attributes[name]["attr_type"] = FindTypeInfos(factory, attributes[name]["attr_type"])- if optional_attributes.get(name, False):- return object.__setattr__(self, name, None)- raise ValueError("Attribute '%s' isn't optional." % name)- elif attributes[name].has_key("fixed") and value != attributes[name]["fixed"]:- raise ValueError, "Value of attribute '%s' can only be '%s'."%(name, str(attributes[name]["fixed"]))- elif attributes[name]["attr_type"]["check"](value):- return object.__setattr__(self, name, value)- raise ValueError("Invalid value for attribute '%s'." % (name))+ attribute_infos = attributes[name] + attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"]) + if optional_attributes.get(name, False): + default = attribute_infos.get("default", None) + if value is None or value == default: + elif attribute_infos.has_key("fixed"): + return self.set(name, attribute_infos["attr_type"]["generate"](value)) elif elements.has_key(name):
- if CheckElementValue(factory, name, elements[name], value):- return object.__setattr__(self, name, value)- raise ValueError("Invalid value for attribute '%s'." % (name))+ element_infos = elements[name] + element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"]) + element_xpath = ("%s:%s" % (factory.TargetNamespace, name) + else elements["content"]["elmt_type"]["choices_xpath"]()) + for element in self.xpath(element_xpath, namespaces=factory.NSMAP): + previous_elements_xpath = "|".join(map( + lambda x: "%s:%s" % (factory.TargetNamespace, x) + else elements["content"]["elmt_type"]["choices_xpath"](), + elements.keys()[elements.keys().index(name)])) + insertion_point = len(self.xpath(previous_elements_xpath, namespaces=factory.NSMAP)) + if not isinstance(value, ListType): + for element in reversed(value): + self.insert(insertion_point, element) elif classinfos.has_key("base"):
return classinfos["base"].__setattr__(self, name, value)
elif class_definition.__dict__.has_key(name):
- return object.__setattr__(self, name, value)+ return DefaultElementClass.__setattr__(self, name, value) raise AttributeError("'%s' can't have an attribute '%s'." % (self.__class__.__name__, name))
@@ -1725,18 +1827,21 @@
if classinfos.has_key("base"):
- classinfos["base"].__init__(self)+ classinfos["base"]._init(self) for attribute in classinfos["attributes"]:
attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])
- if attribute["use"] == "required":- setattr(self, attribute["name"], attribute["attr_type"]["initial"]())- elif attribute["use"] == "optional":- if attribute.has_key("default"):- setattr(self, attribute["name"], attribute["attr_type"]["extract"](attribute["default"], False))- setattr(self, attribute["name"], None)+ if attribute["use"] == "required" and self.get(attribute["name"]) is None: + self.set(attribute["name"], attribute["attr_type"]["generate"](attribute["attr_type"]["initial"]())) for element in classinfos["elements"]:
- setattr(self, element["name"], GetElementInitialValue(factory, element))+ if element["name"] != "content": + etree.QName(factory.NSMAP["xhtml"], "p") + if element["type"] == ANY + else factory.etreeNamespaceFormat % element["name"]) + if self.find(element_name) is None: + initial = GetElementInitialValue(factory, element) + if initial is not None: + map(self.append, initial) def generateSetMethod(attr):
@@ -1761,9 +1866,7 @@
extract = infos["elmt_type"]["extract"]
raise ValueError("Invalid class attribute!")
- if infos.has_key("default"):- setattr(self, attr, extract(infos["default"], False))+ if not infos.has_key("default"): setattr(self, attr, initial())
@@ -1777,10 +1880,10 @@
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
attr_list = getattr(self, attr)
if maxOccurs == "unbounded" or len(attr_list) < maxOccurs:
- if infos["elmt_type"]["check"](value):- attr_list.append(value)+ if len(attr_list) == 0: + setattr(self, attr, [value]) - raise ValueError("\"%s\" value isn't valid!" % attr)+ attr_list[-1].addnext(value) raise ValueError("There can't be more than %d values in \"%s\"!" % (maxOccurs, attr))
@@ -1790,10 +1893,12 @@
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
attr_list = getattr(self, attr)
if maxOccurs == "unbounded" or len(attr_list) < maxOccurs:
- if infos["elmt_type"]["check"](value):- attr_list.insert(index, value)+ if len(attr_list) == 0: + setattr(self, attr, [value]) + attr_list[0].addprevious(value) - raise ValueError("\"%s\" value isn't valid!" % attr)+ attr_list[min(index - 1, len(attr_list) - 1)].addnext(value) raise ValueError("There can't be more than %d values in \"%s\"!" % (maxOccurs, attr))
@@ -1805,24 +1910,24 @@
def generateSetChoiceByTypeMethod(factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def setChoiceMethod(self, type):- if not choices.has_key(type):- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])- new_element = choices[type]["elmt_type"]["initial"]()- self.content = {"name": type, "value": new_element}+ def setChoiceMethod(self, content_type): + if not choices.has_key(content_type): + raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type) + choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"]) + new_content = choices[content_type]["elmt_type"]["initial"]() + self.content = new_content def generateAppendChoiceByTypeMethod(maxOccurs, factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def appendChoiceMethod(self, type):- if not choices.has_key(type):- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])+ def appendChoiceMethod(self, content_type): + if not choices.has_key(content_type): + raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type) + choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"]) if maxOccurs == "unbounded" or len(self.content) < maxOccurs:
- new_element = choices[type]["elmt_type"]["initial"]()- self.content.append({"name": type, "value": new_element})+ new_element = choices[content_type]["elmt_type"]["initial"]() + self.appendcontent(new_element) raise ValueError("There can't be more than %d values in \"content\"!" % maxOccurs)
@@ -1830,13 +1935,13 @@
def generateInsertChoiceByTypeMethod(maxOccurs, factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def insertChoiceMethod(self, index, type):- if not choices.has_key(type):- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])+ def insertChoiceMethod(self, index, content_type): + if not choices.has_key(content_type): + raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type) + choices[type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"]) if maxOccurs == "unbounded" or len(self.content) < maxOccurs:
- new_element = choices[type]["elmt_type"]["initial"]()- self.content.insert(index, {"name" : type, "value" : new_element})+ new_element = choices[content_type]["elmt_type"]["initial"]() + self.insertcontent(index, new_element) raise ValueError("There can't be more than %d values in \"content\"!" % maxOccurs)
@@ -1846,7 +1951,7 @@
def removeMethod(self, index):
attr_list = getattr(self, attr)
if len(attr_list) > minOccurs:
- getattr(self, attr).pop(index)+ self.remove(attr_list[index]) raise ValueError("There can't be less than %d values in \"%s\"!" % (minOccurs, attr))
@@ -1857,16 +1962,102 @@
-This function generate the classes from a class factory+This function generate a xml parser from a class factory -def GenerateClasses(factory):+class DefaultElementClass(etree.ElementBase): + return etree.QName(self.tag).localname + return etree.tostring(self, pretty_print=True) +class XMLElementClassLookUp(etree.PythonElementClassLookup): + def __init__(self, classes, class_equivalence, *args, **kwargs): + etree.PythonElementClassLookup.__init__(self, *args, **kwargs) + self.LookUpClasses = classes + self.ClassEquivalence = class_equivalence + def GetElementClass(self, element_tag, parent_tag=None, default=DefaultElementClass): + element_class = self.LookUpClasses.get(element_tag, (default, None)) + if not isinstance(element_class, DictType): + if isinstance(element_class[0], (StringType, UnicodeType)): + return self.GetElementClass(element_class[0], default=default) + return element_class[0] + element_with_parent_class = element_class.get(parent_tag, default) + if isinstance(element_with_parent_class, (StringType, UnicodeType)): + return self.GetElementClass(element_with_parent_class, default=default) + elif element_with_parent_class == DefaultElementClass: + for equivalent_parent in self.ClassEquivalence.get(parent_tag, {}).keys(): + return self.GetElementClass(element_tag, equivalent_parent, default) + return element_with_parent_class + def lookup(self, document, element): + parent = element.getparent() + return self.GetElementClass(element.tag, + parent.tag if parent is not None else None) +class XMLClassParser(etree.XMLParser): + def __init__(self, namespaces, default_namespace_format, base_class, *args, **kwargs): + etree.XMLParser.__init__(self, *args, **kwargs) + self.DefaultNamespaceFormat = default_namespace_format + self.NSMAP = namespaces + targetNamespace = etree.QName(default_namespace_format % "d").namespace + if targetNamespace is not None: + name if targetNamespace != uri else None: uri + for name, uri in namespaces.iteritems()} + self.RootNSMAP = namespaces + self.BaseClass = base_class + def set_element_class_lookup(self, class_lookup): + etree.XMLParser.set_element_class_lookup(self, class_lookup) + self.ClassLookup = class_lookup + if self.BaseClass is not None: + return self.makeelement( + self.DefaultNamespaceFormat % self.BaseClass[0], + def GetElementClass(self, element_tag, parent_tag=None): + return self.ClassLookup.GetElementClass( + self.DefaultNamespaceFormat % element_tag, + self.DefaultNamespaceFormat % parent_tag + if parent_tag is not None else parent_tag, + def CreateElement(self, element_tag, parent_tag=None): + new_element = self.GetElementClass(element_tag, parent_tag)() + DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag) +def GenerateParser(factory, xsdstring): ComputedClasses = factory.CreateClasses()
if factory.FileName is not None and len(ComputedClasses) == 1:
- UpdateXMLClassGlobals(ComputedClasses[factory.FileName])- return ComputedClasses[factory.FileName]+ ComputedClasses = ComputedClasses[factory.FileName] + BaseClass = [(name, XSDclass) for name, XSDclass in ComputedClasses.items() if XSDclass.IsBaseClass] - UpdateXMLClassGlobals(ComputedClasses)+ UpdateXMLClassGlobals(ComputedClasses) + parser = XMLClassParser( + factory.etreeNamespaceFormat, + BaseClass[0] if len(BaseClass) == 1 else None, + schema = etree.XMLSchema(etree.fromstring(xsdstring)), + strip_cdata = False, remove_blank_text=True) + class_lookup = XMLElementClassLookUp(factory.ComputedClassesLookUp, factory.EquivalentClassesParent) + parser.set_element_class_lookup(class_lookup) def UpdateXMLClassGlobals(classes):
globals().update(classes)
