--- a/xmlclass/xmlclass.py Fri Nov 23 11:01:20 2018 +0100
+++ b/xmlclass/xmlclass.py Fri Nov 23 12:13:24 2018 +0100
@@ -28,12 +28,14 @@
import os
import re
import datetime
-from types import *
from xml.dom import minidom
from xml.sax.saxutils import unescape
-from new import classobj
from collections import OrderedDict
-
+from builtins import str as text
+from functools import reduce
+
+from six import string_types
+from six.moves import xrange
from lxml import etree
@@ -51,33 +53,33 @@
def NodeSetAttr(node, name, value):
attr = minidom.Attr(name)
- text = minidom.Text()
- text.data = value
- attr.childNodes[0] = text
+ txt = minidom.Text()
+ txt.data = value
+ attr.childNodes[0] = txt
node._attrs[name] = attr
# Regular expression models for checking all kind of
# string values defined in XML standard
-Name_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*)$')
-Names_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*(?: [a-zA-Z_\:][\w\.\-\:]*)*)$')
-NMToken_model = re.compile('([\w\.\-\:]*)$')
-NMTokens_model = re.compile('([\w\.\-\:]*(?: [\w\.\-\:]*)*)$')
-QName_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)$')
-QNames_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*(?: (?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)*)$')
-NCName_model = re.compile('([a-zA-Z_][\w]*)$')
-URI_model = re.compile('((?:htt(p|ps)://|/)?(?:[\w.-]*/?)*)$')
-LANGUAGE_model = re.compile('([a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*)$')
-
-ONLY_ANNOTATION = re.compile("((?:annotation )?)")
+Name_model = re.compile(r'([a-zA-Z_\:][\w\.\-\:]*)$')
+Names_model = re.compile(r'([a-zA-Z_\:][\w\.\-\:]*(?: [a-zA-Z_\:][\w\.\-\:]*)*)$')
+NMToken_model = re.compile(r'([\w\.\-\:]*)$')
+NMTokens_model = re.compile(r'([\w\.\-\:]*(?: [\w\.\-\:]*)*)$')
+QName_model = re.compile(r'((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)$')
+QNames_model = re.compile(r'((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*(?: (?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)*)$')
+NCName_model = re.compile(r'([a-zA-Z_][\w]*)$')
+URI_model = re.compile(r'((?:htt(p|ps)://|/)?(?:[\w.-]*/?)*)$')
+LANGUAGE_model = re.compile(r'([a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*)$')
+
+ONLY_ANNOTATION = re.compile(r"((?:annotation )?)")
"""
Regular expression models for extracting dates and times from a string
"""
-time_model = re.compile('([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)(?:Z)?$')
-date_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')
-datetime_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')
+time_model = re.compile(r'([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)(?:Z)?$')
+date_model = re.compile(r'([0-9]{4})-([0-9]{2})-([0-9]{2})((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')
+datetime_model = re.compile(r'([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')
class xml_timezone(datetime.tzinfo):
@@ -139,13 +141,13 @@
if not extract:
return attr
if len(attr.childNodes) == 1:
- return unicode(unescape(attr.childNodes[0].data))
+ return text(unescape(attr.childNodes[0].data))
else:
# content is a CDATA
- text = u''
+ txt = u''
for node in attr.childNodes:
if not (node.nodeName == "#text" and node.data.strip() == u''):
- text += unicode(unescape(node.data))
+ txt += text(unescape(node.data))
return text
@@ -574,7 +576,7 @@
"extract": ExtractAny,
"generate": GenerateAny,
"initial": InitialAny,
- "check": lambda x: isinstance(x, (StringType, UnicodeType, etree.ElementBase))
+ "check": lambda x: isinstance(x, (string_types, etree.ElementBase))
}
@@ -606,7 +608,7 @@
def FindTypeInfos(factory, infos):
- if isinstance(infos, (UnicodeType, StringType)):
+ if isinstance(infos, string_types):
namespace, name = DecomposeQualifiedName(infos)
return factory.GetQualifiedNameInfos(name, namespace)
return infos
@@ -952,7 +954,7 @@
if parent is not None else None)
parent_class = lookup_classes.get(parent)
if parent_class is not None:
- if isinstance(parent_class, ListType):
+ if isinstance(parent_class, list):
if typeinfos not in parent_class:
lookup_classes[parent].append(typeinfos)
elif parent_class != typeinfos:
@@ -962,13 +964,13 @@
def AddToLookupClass(self, name, parent, typeinfos):
lookup_name = self.etreeNamespaceFormat % name
- if isinstance(typeinfos, (StringType, UnicodeType)):
+ if isinstance(typeinfos, string_types):
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):
+ elif isinstance(lookup_classes, dict):
self.AddDistinctionBetweenParentsInLookupClass(
lookup_classes, parent, typeinfos)
else:
@@ -980,7 +982,7 @@
self.ComputedClassesLookUp[lookup_name] = lookup_classes
def ExtractTypeInfos(self, name, parent, typeinfos):
- if isinstance(typeinfos, (StringType, UnicodeType)):
+ if isinstance(typeinfos, string_types):
namespace, type_name = DecomposeQualifiedName(typeinfos)
infos = self.GetQualifiedNameInfos(type_name, namespace)
if name != "base":
@@ -991,13 +993,13 @@
if infos["type"] == COMPLEXTYPE:
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)):
+ if result is not None and not isinstance(result, string_types):
self.Namespaces[self.TargetNamespace][result["name"]] = result
return result
elif infos["type"] == ELEMENT and infos["elmt_type"]["type"] == COMPLEXTYPE:
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)):
+ if result is not None and not isinstance(result, string_types):
self.Namespaces[self.TargetNamespace][result["name"]] = result
return result
else:
@@ -1019,19 +1021,19 @@
self.ParseSchema()
for name, infos in self.Namespaces[self.TargetNamespace].items():
if infos["type"] == ELEMENT:
- if not isinstance(infos["elmt_type"], (UnicodeType, StringType)) and \
+ 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, (UnicodeType, StringType)):
+ if result is not None and not isinstance(result, string_types):
self.Namespaces[self.TargetNamespace][result["name"]] = result
elif infos["type"] == COMPLEXTYPE:
self.ComputeAfter.append((name, None, infos))
while len(self.ComputeAfter) > 0:
result = self.CreateClass(*self.ComputeAfter.pop(0))
if result is not None and \
- not isinstance(result, (UnicodeType, StringType)):
+ not isinstance(result, string_types):
self.Namespaces[self.TargetNamespace][result["name"]] = result
elif infos["type"] == ELEMENTSGROUP:
elements = []
@@ -1040,17 +1042,17 @@
elif "choices" in infos:
elements = infos["choices"]
for element in elements:
- if not isinstance(element["elmt_type"], (UnicodeType, StringType)) and \
+ if not isinstance(element["elmt_type"], string_types) and \
element["elmt_type"]["type"] == COMPLEXTYPE:
self.ComputeAfter.append((element["name"], infos["name"], element["elmt_type"]))
while len(self.ComputeAfter) > 0:
result = self.CreateClass(*self.ComputeAfter.pop(0))
if result is not None and \
- not isinstance(result, (UnicodeType, StringType)):
+ not isinstance(result, string_types):
self.Namespaces[self.TargetNamespace][result["name"]] = result
for name, parents in self.ComputedClassesLookUp.iteritems():
- if isinstance(parents, DictType):
+ if isinstance(parents, dict):
computed_classes = parents.items()
elif parents[1] is not None:
computed_classes = [(self.etreeNamespaceFormat % parents[1], parents[0])]
@@ -1058,7 +1060,7 @@
computed_classes = []
for parent, computed_class in computed_classes:
for equivalent_parent in self.GetEquivalentParents(parent):
- if not isinstance(parents, DictType):
+ if not isinstance(parents, dict):
parents = dict(computed_classes)
self.ComputedClassesLookUp[name] = parents
parents[equivalent_parent] = computed_class
@@ -1168,7 +1170,7 @@
classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)
classmembers["setElementValue"] = generateSetElementValue(self, classinfos)
- class_definition = classobj(str(name), bases, classmembers)
+ class_definition = type(str(name), bases, classmembers)
setattr(class_definition, "__getattr__", generateGetattrMethod(self, class_definition, classinfos))
setattr(class_definition, "__setattr__", generateSetattrMethod(self, class_definition, classinfos))
class_infos = {
@@ -1248,7 +1250,7 @@
if element["type"] == ANY:
infos = element.copy()
infos["minOccurs"] = 0
- elements.append(ComputeMultiplicity("#text |#cdata-section |\w* ", infos))
+ elements.append(ComputeMultiplicity(r"#text |#cdata-section |\w* ", infos))
elif element["type"] == CHOICE:
choices = []
for infos in element["choices"]:
@@ -1381,7 +1383,7 @@
else:
insertion_point = 0
- if not isinstance(value, ListType):
+ if not isinstance(value, list):
value = [value]
for element in reversed(value):
@@ -1720,7 +1722,7 @@
return countMethod
-NAMESPACE_PATTERN = re.compile("xmlns(?:\:[^\=]*)?=\"[^\"]*\" ")
+NAMESPACE_PATTERN = re.compile(r"xmlns(?:\:[^\=]*)?=\"[^\"]*\" ")
class DefaultElementClass(etree.ElementBase):
@@ -1747,13 +1749,13 @@
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)):
+ if not isinstance(element_class, dict):
+ if isinstance(element_class[0], string_types):
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)):
+ if isinstance(element_with_parent_class, string_types):
return self.GetElementClass(element_with_parent_class, default=default)
return element_with_parent_class
@@ -1810,12 +1812,12 @@
parent = element.getparent()
element_class = self.GetElementClass(
element.tag, parent.tag if parent is not None else None)
- if isinstance(element_class, ListType):
+ if isinstance(element_class, list):
children = "".join([
"%s " % etree.QName(child.tag).localname
for child in element])
for possible_class in element_class:
- if isinstance(possible_class, (StringType, UnicodeType)):
+ if isinstance(possible_class, string_types):
possible_class = self.GetElementClass(possible_class)
if possible_class.StructurePattern.match(children) is not None:
return possible_class
@@ -1889,7 +1891,7 @@
(subclass of lxml.etree._Element created by class factory)
"""
element_class = self.GetElementClass(element_tag, parent_tag)
- if isinstance(element_class, ListType):
+ if isinstance(element_class, list):
if class_idx is not None and class_idx < len(element_class):
element_class = element_class[class_idx]
else: