beremiz: comparison xmlclass/xmlclass.py

equal deleted inserted replaced

-:fda6c1a37662
+:f62625418bff
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-from __future__ import absolute_import
-from __future__ import print_function
 import os
 import re
 import datetime
 from functools import reduce
 from xml.dom import minidom
 [
 SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,
 ATTRIBUTESGROUP, ELEMENTSGROUP, ATTRIBUTE, ELEMENT, CHOICE, ANY, TAG, CONSTRAINT,
-] = range(13)
+] = list(range(13))
 def NotSupportedYet(type):
 """
 Function that generates a function that point out to user that datatype
 """
 This function calculates the number of whitespace for indentation
 """
 first = indent * 2
 second = first + len(balise) + 1
-return u'\t'.expandtabs(first), u'\t'.expandtabs(second)
+return '\t'.expandtabs(first), '\t'.expandtabs(second)
 def GetAttributeValue(attr, extract=True):
 """
 Function that extracts data from a tree node
 return attr
 if len(attr.childNodes) == 1:
 return text(unescape(attr.childNodes[0].data))
 else:
 # content is a CDATA
-txt = u''
+txt = ''
 for node in attr.childNodes:
-if not (node.nodeName == "#text" and node.data.strip() == u''):
+if not (node.nodeName == "#text" and node.data.strip() == ''):
 txt += text(unescape(node.data))
 return text
 def GetNormalizedString(attr, extract=True):
 def initial_value():
 value = infos["elmt_type"]["initial"]()
 if infos["type"] != ANY:
 DefaultElementClass.__setattr__(value, "tag", element_name)
 return value
-return [initial_value() for dummy in xrange(infos["minOccurs"])]
+return [initial_value() for dummy in range(infos["minOccurs"])]
 else:
 return []
 def GetContentInfos(name, choices):
 if choice_name in choices_dict:
 raise ValueError("'%s' element defined two times in choice" % choice_name)
 choices_dict[choice_name] = infos
 prefix = ("%s:" % factory.TargetNamespace
 if factory.TargetNamespace is not None else "")
-choices_xpath = "|".join(map(lambda x: prefix + x, choices_dict.keys()))
+choices_xpath = "|".join([prefix + x for x in list(choices_dict.keys())])
 def GetContentInitial():
 content_name, infos = choices[0]
 if content_name == "sequence":
 content_value = []
-for dummy in xrange(infos["minOccurs"]):
+for dummy in range(infos["minOccurs"]):
 for element_infos in infos["elements"]:
 content_value.extend(GetElementInitialValue(factory, element_infos))
 else:
 content_value = GetElementInitialValue(factory, infos)
 return content_value
 def GetQualifiedNameInfos(self, name, namespace=None, canbenone=False):
 if namespace is None:
 if name in self.Namespaces[self.SchemaNamespace]:
 return self.Namespaces[self.SchemaNamespace][name]
-for space, elements in self.Namespaces.iteritems():
+for space, elements in self.Namespaces.items():
 if space != self.SchemaNamespace and name in elements:
 return elements[name]
 parts = name.split("_", 1)
 if len(parts) > 1:
 group = self.GetQualifiedNameInfos(parts[0], namespace)
 def SplitQualifiedName(self, name, namespace=None, canbenone=False):
 if namespace is None:
 if name in self.Namespaces[self.SchemaNamespace]:
 return name, None
-for space, elements in self.Namespaces.items():
+for space, elements in list(self.Namespaces.items()):
 if space != self.SchemaNamespace and name in elements:
 return name, None
 parts = name.split("_", 1)
 if len(parts) > 1:
 group = self.GetQualifiedNameInfos(parts[0], namespace)
 raise ValueError("Unknown namespace \"%s\"!" % namespace)
 return None, None
 def ExtractNodeAttrs(self, element_name, node, valid_attrs):
 attrs = {}
-for qualified_name, attr in node._attrs.items():
+for qualified_name, attr in list(node._attrs.items()):
 namespace, name = DecomposeQualifiedName(qualified_name)
 if name in valid_attrs:
 infos = self.GetQualifiedNameInfos(name, namespace)
 if infos["type"] != SYNTAXATTRIBUTE:
 raise ValueError("\"%s\" can't be a member attribute!" % name)
 return typeinfos
 def GetEquivalentParents(self, parent):
 return reduce(lambda x, y: x + y,
 [[p] + self.GetEquivalentParents(p)
-for p in self.EquivalentClassesParent.get(parent, {}).keys()], [])
+for p in list(self.EquivalentClassesParent.get(parent, {}).keys())], [])
 def CreateClasses(self):
 """
 Method that generates the classes
 """
 self.ParseSchema()
-for name, infos in self.Namespaces[self.TargetNamespace].items():
+for name, infos in list(self.Namespaces[self.TargetNamespace].items()):
 if infos["type"] == ELEMENT:
 if not isinstance(infos["elmt_type"], string_types) and \
 infos["elmt_type"]["type"] == COMPLEXTYPE:
 self.ComputeAfter.append((name, None, infos["elmt_type"], True))
 while len(self.ComputeAfter) > 0:
 result = self.CreateClass(*self.ComputeAfter.pop(0))
 if result is not None and \
 not isinstance(result, string_types):
 self.Namespaces[self.TargetNamespace][result["name"]] = result
-for name, parents in self.ComputedClassesLookUp.iteritems():
+for name, parents in self.ComputedClassesLookUp.items():
 if isinstance(parents, dict):
-computed_classes = parents.items()
+computed_classes = list(parents.items())
 elif parents[1] is not None:
 computed_classes = [(self.etreeNamespaceFormat % parents[1], parents[0])]
 else:
 computed_classes = []
 for parent, computed_class in computed_classes:
 return classname
 elif result is not None:
 if self.FileName is not None:
 classinfos["base"] = self.ComputedClasses[self.FileName].get(result["name"], None)
 if classinfos["base"] is None:
-for filename, classes in self.ComputedClasses.iteritems():
+for filename, classes in self.ComputedClasses.items():
 if filename != self.FileName:
 classinfos["base"] = classes.get(result["name"], None)
 if classinfos["base"] is not None:
 break
 else:
 def PrintClasses(self):
 """
 Method that print the classes generated
 """
-items = self.ComputedClasses.items()
+items = list(self.ComputedClasses.items())
 items.sort()
 if self.FileName is not None:
 for filename, classes in items:
 print("File '%s':" % filename)
-class_items = classes.items()
+class_items = list(classes.items())
 class_items.sort()
 for classname, xmlclass in class_items:
 print("%s: %s" % (classname, str(xmlclass)))
 else:
 for classname, xmlclass in items:
 print("%s: %s" % (classname, str(xmlclass)))
 def PrintClassNames(self):
-classnames = self.XMLClassDefinitions.keys()
+classnames = list(self.XMLClassDefinitions.keys())
 classnames.sort()
 for classname in classnames:
 print(classname)
 else:
 element_name = factory.etreeNamespaceFormat % name
 if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
 values = self.findall(element_name)
 if element_infos["elmt_type"]["type"] == SIMPLETYPE:
-return map(lambda value:
+return [element_infos["elmt_type"]["extract"](value.text, extract=False) for value in values]
-element_infos["elmt_type"]["extract"](value.text, extract=False),
-values)
 return values
 else:
 value = self.find(element_name)
 if element_infos["elmt_type"]["type"] == SIMPLETYPE:
 return element_infos["elmt_type"]["extract"](value.text, extract=False)
 for element in self.xpath(element_xpath, namespaces=factory.NSMAP):
 self.remove(element)
 if value is not None:
-element_idx = elements.keys().index(name)
+element_idx = list(elements.keys()).index(name)
 if element_idx > 0:
-previous_elements_xpath = "|".join(map(
+previous_elements_xpath = "|".join([prefix + x
-lambda x: prefix + x
 if x != "content"
-else elements["content"]["elmt_type"]["choices_xpath"].path,
+else elements["content"]["elmt_type"]["choices_xpath"].path for x in list(elements.keys())[:element_idx]])
-elements.keys()[:element_idx]))
 insertion_point = len(self.xpath(previous_elements_xpath, namespaces=factory.NSMAP))
 else:
 insertion_point = 0
 else:
 if not derived:
 children.extend(self.getElementAttributes())
 if "base" in classinfos:
 children.extend(classinfos["base"].getElementInfos(self, name, derived=True)["children"])
-for element_name, element in elements.items():
+for element_name, element in list(elements.items()):
 if element["minOccurs"] == 0:
 use = "optional"
 if element_name == "content" and element["type"] == CHOICE:
 attr_type = [(choice["name"], None) for choice in element["choices"]]
 if self.content is None:
 self.set(attribute["name"], attribute["attr_type"]["generate"](attribute["attr_type"]["initial"]()))
 for element in classinfos["elements"]:
 if element["type"] != CHOICE:
 initial = GetElementInitialValue(factory, element)
 if initial is not None:
-map(self.append, initial)
+list(map(self.append, initial))
 return initMethod
 def generateSetMethod(attr):
 def setMethod(self, value):
 self.NSMAP = namespaces
 targetNamespace = etree.QName(default_namespace_format % "d").namespace
 if targetNamespace is not None:
 self.RootNSMAP = {
 name if targetNamespace != uri else None: uri
-for name, uri in namespaces.iteritems()}
+for name, uri in namespaces.items()}
 else:
 self.RootNSMAP = namespaces
 self.BaseClass = base_class
 self.XSDSchema = xsd_schema
 factory.Parser = parser
 ComputedClasses = factory.CreateClasses()
 if factory.FileName is not None:
 ComputedClasses = ComputedClasses[factory.FileName]
-BaseClass = [(name, XSDclass) for name, XSDclass in ComputedClasses.items() if XSDclass.IsBaseClass]
+BaseClass = [(name, XSDclass) for name, XSDclass in list(ComputedClasses.items()) if XSDclass.IsBaseClass]
 parser.initMembers(
 factory.NSMAP,
 factory.etreeNamespaceFormat,
 BaseClass[0] if len(BaseClass) == 1 else None,

branch	python3
changeset 3750	f62625418bff
parent 3589	a0b645a934c9
child 3752	9f6f46dbe3ae