beremiz: comparison xmlclass/xsdschema.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 types import FunctionType
 from xml.dom import minidom
 from future.builtins import round
 from six import string_types
-from past.builtins import long
+from past.builtins import int
 from xmlclass.xmlclass import *
 def GenerateDictFacets(facets):
 return text
 return generateXMLTextMethod
 DEFAULT_FACETS = GenerateDictFacets(["pattern", "whiteSpace", "enumeration"])
-NUMBER_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["maxInclusive", "maxExclusive", "minInclusive", "minExclusive"])
+NUMBER_FACETS = GenerateDictFacets(list(DEFAULT_FACETS.keys()) + ["maxInclusive", "maxExclusive", "minInclusive", "minExclusive"])
-DECIMAL_FACETS = GenerateDictFacets(NUMBER_FACETS.keys() + ["totalDigits", "fractionDigits"])
+DECIMAL_FACETS = GenerateDictFacets(list(NUMBER_FACETS.keys()) + ["totalDigits", "fractionDigits"])
-STRING_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["length", "minLength", "maxLength"])
+STRING_FACETS = GenerateDictFacets(list(DEFAULT_FACETS.keys()) + ["length", "minLength", "maxLength"])
 ALL_FACETS = ["pattern", "whiteSpace", "enumeration", "maxInclusive",
 "maxExclusive", "minInclusive", "minExclusive", "totalDigits",
 "fractionDigits", "length", "minLength", "maxLength"]
 if facettype in ["enumeration", "pattern"]:
 value = basetypeinfos["extract"](value, False)
 if len(facets) == 0:
 facets[facettype] = ([value], False)
 continue
-elif facets.keys() == [facettype]:
+elif list(facets.keys()) == [facettype]:
 facets[facettype][0].append(value)
 continue
 else:
 raise ValueError("\"%s\" facet can't be defined with another facet type!" % facettype)
 elif "enumeration" in facets:
 elif basevalue is not None and value > basevalue:
 raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")
 facets[facettype] = (value, facet.get("fixed", False))
 # Report not redefined facet from base type to new created type
-for facettype, facetvalue in basetypeinfos["facets"].items():
+for facettype, facetvalue in list(basetypeinfos["facets"].items()):
 if facettype not in facets:
 facets[facettype] = facetvalue
 # Generate extract value for new created type
 def ExtractSimpleTypeValue(attr, extract=True):
 value = basetypeinfos["extract"](attr, extract)
-for facetname, (facetvalue, _facetfixed) in facets.items():
+for facetname, (facetvalue, _facetfixed) in list(facets.items()):
 if facetvalue is not None:
 if facetname == "enumeration" and value not in facetvalue:
 raise ValueError("\"%s\" not in enumerated values" % value)
 elif facetname == "length" and len(value) != facetvalue:
 raise ValueError("value must have a length of %d" % facetvalue)
 elif facetname == "maxInclusive" and value > facetvalue:
 raise ValueError("value must be lesser than or equal to %s" % str(facetvalue))
 elif facetname == "maxExclusive" and value >= facetvalue:
 raise ValueError("value must be lesser than %s" % str(facetvalue))
 elif facetname == "pattern":
-model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))
+model = re.compile("(?:%s)?$" % "|".join(["(?:%s)" % x for x in facetvalue]))
 result = model.match(value)
 if result is None:
 if len(facetvalue) > 1:
 raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))
 else:
 elif facetvalue == "collapse":
 value = GetToken(value, False)
 return value
 def CheckSimpleTypeValue(value):
-for facetname, (facetvalue, _facetfixed) in facets.items():
+for facetname, (facetvalue, _facetfixed) in list(facets.items()):
 if facetvalue is not None:
 if facetname == "enumeration" and value not in facetvalue:
 return False
 elif facetname == "length" and len(value) != facetvalue:
 return False
 elif facetname == "maxInclusive" and value > facetvalue:
 return False
 elif facetname == "maxExclusive" and value >= facetvalue:
 return False
 elif facetname == "pattern":
-model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))
+model = re.compile("(?:%s)?$" % "|".join(["(?:%s)" % x for x in facetvalue]))
 result = model.match(value)
 if result is None:
 if len(facetvalue) > 1:
 raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))
 else:
 raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])
 return True
 def SimpleTypeInitialValue():
-for facetname, (facetvalue, _facetfixed) in facets.items():
+for facetname, (facetvalue, _facetfixed) in list(facets.items()):
 if facetvalue is not None:
 if facetname == "enumeration":
 return facetvalue[0]
 elif facetname == "length":
 return " "*facetvalue
 attrs = []
 attrnames = {}
 if base is not None:
 basetypeinfos = factory.FindSchemaElement(base)
 if not isinstance(basetypeinfos, string_types) and basetypeinfos["type"] == COMPLEXTYPE:
-attrnames = dict(map(lambda x: (x["name"], True), basetypeinfos["attributes"]))
+attrnames = dict([(x["name"], True) for x in basetypeinfos["attributes"]])
 for element in elements:
 if element["type"] == ATTRIBUTE:
 if attrnames.get(element["name"], False):
 raise ValueError("\"%s\" attribute has been defined two times!" % element["name"])
 return result
 return True
 elif isinstance(schema, dict):
 if not isinstance(reference, dict) or len(schema) != len(reference):
 return False
-for name, value in schema.items():
+for name, value in list(schema.items()):
 ref_value = reference.get(name, None)
 if ref_value is None and value is not None:
 return False
 result = CompareSchema(value, ref_value)
 if not result:
 def ParseSchema(self):
 for child in self.Document.childNodes:
 if child.nodeType == self.Document.ELEMENT_NODE:
 schema = child
 break
-for qualified_name, attr in schema._attrs.items():
+for qualified_name, attr in list(schema._attrs.items()):
 namespace, name = DecomposeQualifiedName(qualified_name)
 if namespace == "xmlns":
 value = GetAttributeValue(attr)
 self.DefinedNamespaces[value] = name
 self.NSMAP[name] = value
 "basename": "base64Binary",
 "extract": NotSupportedYet("base64Binary"),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, (int, long))
+"check": lambda x: isinstance(x, int)
 },
 "hexBinary": {
 "type": SIMPLETYPE,
 "basename": "hexBinary",
 "extract": GetHexInteger,
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: ("%."+str(int(round(len("%X" % x)/2.)*2))+"X") % x),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, (int, long))
+"check": lambda x: isinstance(x, int)
 },
 "integer": {
 "type": SIMPLETYPE,
 "basename": "integer",

branch	python3
changeset 3750	f62625418bff
parent 2457	9deec258ab1a
child 3752	9f6f46dbe3ae