beremiz: comparison xmlclass/xsdschema.py

equal deleted inserted replaced

-:2a70d5240300
+:21164625b393
 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 types import *
+from future.builtins import round
+from six import string_types
+from past.builtins import long
 from xmlclass.xmlclass import *
 def GenerateDictFacets(facets):
 def generateXMLTextMethod(value, name=None, indent=0):
 text = ""
 if name is not None:
 ind1, _ind2 = getIndent(indent, name)
 text += ind1 + "<%s>" % name
-if isinstance(value, IntType):
+if isinstance(value, int):
 text += str(value)
 elif value in extra_values or value % 1 != 0:
 text += float_format(value)
 else:
 text += "{:.0f}".format(value)
 if "name" in attributes:
 simpleType["name"] = attributes["name"]
 if typeinfos["type"] in ["restriction", "extension"]:
 # Search for base type definition
-if isinstance(typeinfos["base"], (StringType, UnicodeType)):
+if isinstance(typeinfos["base"], string_types):
 basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)
 if basetypeinfos is None:
 raise "\"%s\" isn't defined!" % typeinfos["base"]
 else:
 basetypeinfos = typeinfos["base"]
 GenerateSimpleType = basetypeinfos["generate"]
 elif typeinfos["type"] == "list":
 # Search for item type definition
-if isinstance(typeinfos["itemType"], (StringType, UnicodeType)):
+if isinstance(typeinfos["itemType"], string_types):
 itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)
 if itemtypeinfos is None:
 raise "\"%s\" isn't defined!" % typeinfos["itemType"]
 else:
 itemtypeinfos = typeinfos["itemType"]
 elif typeinfos["type"] == "union":
 # Search for member types definition
 membertypesinfos = []
 for membertype in typeinfos["memberTypes"]:
-if isinstance(membertype, (StringType, UnicodeType)):
+if isinstance(membertype, string_types):
 infos = factory.FindSchemaElement(membertype, SIMPLETYPE)
 if infos is None:
 raise ValueError("\"%s\" isn't defined!" % membertype)
 else:
 infos = membertype
 return False
 SimpleTypeInitialValue = membertypesinfos[0]["initial"]
 def GenerateSimpleTypeFunction(value):
-if isinstance(value, BooleanType):
+if isinstance(value, bool):
 return {True: "true", False: "false"}[value]
 else:
 return str(value)
 GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)
 def ExtractAttributes(factory, elements, base=None):
 attrs = []
 attrnames = {}
 if base is not None:
 basetypeinfos = factory.FindSchemaElement(base)
-if not isinstance(basetypeinfos, (UnicodeType, StringType)) and basetypeinfos["type"] == COMPLEXTYPE:
+if not isinstance(basetypeinfos, string_types) and basetypeinfos["type"] == COMPLEXTYPE:
 attrnames = dict(map(lambda x: (x["name"], True), basetypeinfos["attributes"]))
 for element in elements:
 if element["type"] == ATTRIBUTE:
 if attrnames.get(element["name"], False):
 elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
 if "choices" not in elmtgroup:
 raise ValueError("Only group composed of \"choice\" can be referenced in \"choice\" element!")
 choices_tmp = []
 for choice in elmtgroup["choices"]:
-if not isinstance(choice["elmt_type"], (UnicodeType, StringType)) and choice["elmt_type"]["type"] == COMPLEXTYPE:
+if not isinstance(choice["elmt_type"], string_types) and choice["elmt_type"]["type"] == COMPLEXTYPE:
 elmt_type = "%s_%s" % (elmtgroup["name"], choice["name"])
 if factory.TargetNamespace is not None:
 elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)
 new_choice = choice.copy()
 new_choice["elmt_type"] = elmt_type
 elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
 if "elements" not in elmtgroup or not elmtgroup["order"]:
 raise ValueError("Only group composed of \"sequence\" can be referenced in \"sequence\" element!")
 elements_tmp = []
 for element in elmtgroup["elements"]:
-if not isinstance(element["elmt_type"], (UnicodeType, StringType)) and element["elmt_type"]["type"] == COMPLEXTYPE:
+if not isinstance(element["elmt_type"], string_types) and element["elmt_type"]["type"] == COMPLEXTYPE:
 elmt_type = "%s_%s" % (elmtgroup["name"], element["name"])
 if factory.TargetNamespace is not None:
 elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)
 new_element = element.copy()
 new_element["elmt_type"] = elmt_type
 elif not CompareSchema(infos, child):
 raise ValueError("\"%s\" is defined twice in targetNamespace!" % child["name"])
 def CompareSchema(schema, reference):
-if isinstance(schema, ListType):
+if isinstance(schema, list):
-if not isinstance(reference, ListType) or len(schema) != len(reference):
+if not isinstance(reference, list) or len(schema) != len(reference):
 return False
 for i, value in enumerate(schema):
 result = CompareSchema(value, reference[i])
 if not result:
 return result
 return True
-elif isinstance(schema, DictType):
+elif isinstance(schema, dict):
-if not isinstance(reference, DictType) or len(schema) != len(reference):
+if not isinstance(reference, dict) or len(schema) != len(reference):
 return False
 for name, value in schema.items():
 ref_value = reference.get(name, None)
 if ref_value is None and value is not None:
 return False
 "basename": "string",
 "extract": GetAttributeValue,
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)},
-},
 "normalizedString": {
 "type": SIMPLETYPE,
 "basename": "normalizedString",
 "extract": GetNormalizedString,
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "token": {
 "type": SIMPLETYPE,
 "basename": "token",
 "extract": GetToken,
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "base64Binary": {
 "type": SIMPLETYPE,
 "basename": "base64Binary",
 "extract": NotSupportedYet("base64Binary"),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, (IntType, LongType))
+"check": lambda x: isinstance(x, (int, long))
 },
 "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, (IntType, LongType))
+"check": lambda x: isinstance(x, (int, long))
 },
 "integer": {
 "type": SIMPLETYPE,
 "basename": "integer",
 "extract": GenerateIntegerExtraction(),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "positiveInteger": {
 "type": SIMPLETYPE,
 "basename": "positiveInteger",
 "extract": GenerateIntegerExtraction(minExclusive=0),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 1,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "negativeInteger": {
 "type": SIMPLETYPE,
 "basename": "negativeInteger",
 "extract": GenerateIntegerExtraction(maxExclusive=0),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: -1,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "nonNegativeInteger": {
 "type": SIMPLETYPE,
 "basename": "nonNegativeInteger",
 "extract": GenerateIntegerExtraction(minInclusive=0),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "nonPositiveInteger": {
 "type": SIMPLETYPE,
 "basename": "nonPositiveInteger",
 "extract": GenerateIntegerExtraction(maxInclusive=0),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "long": {
 "type": SIMPLETYPE,
 "basename": "long",
 "extract": GenerateIntegerExtraction(minInclusive=-2**63, maxExclusive=2**63),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "unsignedLong": {
 "type": SIMPLETYPE,
 "basename": "unsignedLong",
 "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**64),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "int": {
 "type": SIMPLETYPE,
 "basename": "int",
 "extract": GenerateIntegerExtraction(minInclusive=-2**31, maxExclusive=2**31),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "unsignedInt": {
 "type": SIMPLETYPE,
 "basename": "unsignedInt",
 "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**32),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "short": {
 "type": SIMPLETYPE,
 "basename": "short",
 "extract": GenerateIntegerExtraction(minInclusive=-2**15, maxExclusive=2**15),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "unsignedShort": {
 "type": SIMPLETYPE,
 "basename": "unsignedShort",
 "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**16),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "byte": {
 "type": SIMPLETYPE,
 "basename": "byte",
 "extract": GenerateIntegerExtraction(minInclusive=-2**7, maxExclusive=2**7),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "unsignedByte": {
 "type": SIMPLETYPE,
 "basename": "unsignedByte",
 "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**8),
 "facets": DECIMAL_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: 0,
-"check": lambda x: isinstance(x, IntType)
+"check": lambda x: isinstance(x, int)
 },
 "decimal": {
 "type": SIMPLETYPE,
 "basename": "decimal",
 "extract": GenerateFloatExtraction("decimal"),
 "facets": DECIMAL_FACETS,
 "generate": GenerateFloatXMLText(decimal=3),
 "initial": lambda: 0.,
-"check": lambda x: isinstance(x, (IntType, FloatType))
+"check": lambda x: isinstance(x, (int, float))
 },
 "float": {
 "type": SIMPLETYPE,
 "basename": "float",
 "extract": GenerateFloatExtraction("float", ["INF", "-INF", "NaN"]),
 "facets": NUMBER_FACETS,
 "generate": GenerateFloatXMLText(["INF", "-INF", "NaN"]),
 "initial": lambda: 0.,
-"check": lambda x: {"INF": True, "-INF": True, "NaN": True}.get(x, isinstance(x, (IntType, FloatType)))
+"check": lambda x: {"INF": True, "-INF": True, "NaN": True}.get(x, isinstance(x, (int, float)))
 },
 "double": {
 "type": SIMPLETYPE,
 "basename": "double",
 "extract": GenerateFloatExtraction("double", ["INF", "-INF", "NaN"]),
 "facets": NUMBER_FACETS,
 "generate": GenerateFloatXMLText(["INF", "-INF", "NaN"]),
 "initial": lambda: 0.,
-"check": lambda x: {"INF": True, "-INF": True, "NaN": True}.get(x, isinstance(x, (IntType, FloatType)))
+"check": lambda x: {"INF": True, "-INF": True, "NaN": True}.get(x, isinstance(x, (int, float)))
 },
 "boolean": {
 "type": SIMPLETYPE,
 "basename": "boolean",
 "extract": GetBoolean,
 "facets": GenerateDictFacets(["pattern", "whiteSpace"]),
 "generate": GenerateSimpleTypeXMLText(lambda x: {True: "true", False: "false"}[x]),
 "initial": lambda: False,
-"check": lambda x: isinstance(x, BooleanType)
+"check": lambda x: isinstance(x, bool)
 },
 "duration": {
 "type": SIMPLETYPE,
 "basename": "duration",
 "extract": NotSupportedYet("duration"),
 "facets": NUMBER_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "dateTime": {
 "type": SIMPLETYPE,
 "basename": "dateTime",
 "basename": "gYear",
 "extract": NotSupportedYet("gYear"),
 "facets": NUMBER_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "gYearMonth": {
 "type": SIMPLETYPE,
 "basename": "gYearMonth",
 "extract": NotSupportedYet("gYearMonth"),
 "facets": NUMBER_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "gMonth": {
 "type": SIMPLETYPE,
 "basename": "gMonth",
 "extract": NotSupportedYet("gMonth"),
 "facets": NUMBER_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "gMonthDay": {
 "type": SIMPLETYPE,
 "basename": "gMonthDay",
 "extract": NotSupportedYet("gMonthDay"),
 "facets": NUMBER_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "gDay": {
 "type": SIMPLETYPE,
 "basename": "gDay",
 "extract": NotSupportedYet("gDay"),
 "facets": NUMBER_FACETS,
 "generate": GenerateSimpleTypeXMLText(str),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "Name": {
 "type": SIMPLETYPE,
 "basename": "Name",
 "extract": GenerateModelNameExtraction("Name", Name_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "QName": {
 "type": SIMPLETYPE,
 "basename": "QName",
 "extract": GenerateModelNameExtraction("QName", QName_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "NCName": {
 "type": SIMPLETYPE,
 "basename": "NCName",
 "extract": GenerateModelNameExtraction("NCName", NCName_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "anyURI": {
 "type": SIMPLETYPE,
 "basename": "anyURI",
 "extract": GenerateModelNameExtraction("anyURI", URI_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "language": {
 "type": SIMPLETYPE,
 "basename": "language",
 "extract": GenerateModelNameExtraction("language", LANGUAGE_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "en",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "ID": {
 "type": SIMPLETYPE,
 "basename": "ID",
 "extract": GenerateModelNameExtraction("ID", Name_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "IDREF": {
 "type": SIMPLETYPE,
 "basename": "IDREF",
 "extract": GenerateModelNameExtraction("IDREF", Name_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "IDREFS": {
 "type": SIMPLETYPE,
 "basename": "IDREFS",
 "extract": GenerateModelNameExtraction("IDREFS", Names_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "ENTITY": {
 "type": SIMPLETYPE,
 "basename": "ENTITY",
 "extract": GenerateModelNameExtraction("ENTITY", Name_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "ENTITIES": {
 "type": SIMPLETYPE,
 "basename": "ENTITIES",
 "extract": GenerateModelNameExtraction("ENTITIES", Names_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "NOTATION": {
 "type": SIMPLETYPE,
 "basename": "NOTATION",
 "extract": GenerateModelNameExtraction("NOTATION", Name_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "NMTOKEN": {
 "type": SIMPLETYPE,
 "basename": "NMTOKEN",
 "extract": GenerateModelNameExtraction("NMTOKEN", NMToken_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 "NMTOKENS": {
 "type": SIMPLETYPE,
 "basename": "NMTOKENS",
 "extract": GenerateModelNameExtraction("NMTOKENS", NMTokens_model),
 "facets": STRING_FACETS,
 "generate": GenerateSimpleTypeXMLText(lambda x: x),
 "initial": lambda: "",
-"check": lambda x: isinstance(x, (StringType, UnicodeType))
+"check": lambda x: isinstance(x, string_types)
 },
 # Complex Types
 "anyType": {"type": COMPLEXTYPE, "extract": lambda x: None},
 }

changeset 2459	21164625b393
parent 2457	9deec258ab1a
child 3750	f62625418bff