--- a/xmlclass/xsdschema.py Mon Aug 21 20:17:19 2017 +0000
+++ b/xmlclass/xsdschema.py Mon Aug 21 23:22:58 2017 +0300
@@ -22,16 +22,19 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-import os, re
+import os
+import re
import datetime
from xml.dom import minidom
from types import *
from xmlclass import *
+
def GenerateDictFacets(facets):
return dict([(name, (None, False)) for name in facets])
+
def GenerateSimpleTypeXMLText(function):
def generateXMLTextMethod(value, name=None, indent=0):
text = ""
@@ -44,9 +47,11 @@
return text
return generateXMLTextMethod
+
def GenerateFloatXMLText(extra_values=[], decimal=None):
float_format = (lambda x: "{:.{width}f}".format(x, width=decimal).rstrip('0')
if decimal is not None else str)
+
def generateXMLTextMethod(value, name=None, indent=0):
text = ""
if name is not None:
@@ -62,31 +67,32 @@
text += "</%s>\n" % name
return text
return generateXMLTextMethod
-
+
+
DEFAULT_FACETS = GenerateDictFacets(["pattern", "whiteSpace", "enumeration"])
NUMBER_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["maxInclusive", "maxExclusive", "minInclusive", "minExclusive"])
DECIMAL_FACETS = GenerateDictFacets(NUMBER_FACETS.keys() + ["totalDigits", "fractionDigits"])
STRING_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["length", "minLength", "maxLength"])
-ALL_FACETS = ["pattern", "whiteSpace", "enumeration", "maxInclusive",
- "maxExclusive", "minInclusive", "minExclusive", "totalDigits",
- "fractionDigits", "length", "minLength", "maxLength"]
-
-
-#-------------------------------------------------------------------------------
+ALL_FACETS = ["pattern", "whiteSpace", "enumeration", "maxInclusive",
+ "maxExclusive", "minInclusive", "minExclusive", "totalDigits",
+ "fractionDigits", "length", "minLength", "maxLength"]
+
+
+# -------------------------------------------------------------------------------
# Structure reducing functions
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
# Documentation elements
def ReduceAppInfo(factory, attributes, elements):
- return {"type": "appinfo", "source": attributes.get("source", None),
+ return {"type": "appinfo", "source": attributes.get("source", None),
"content": "\n".join(elements)}
def ReduceDocumentation(factory, attributes, elements):
- return {"type": "documentation", "source": attributes.get("source", None),
+ return {"type": "documentation", "source": attributes.get("source", None),
"language": attributes.get("lang", "any"), "content": "\n".join(elements)}
@@ -98,10 +104,10 @@
annotation["appinfo"].append((child["source"], child["content"]))
elif child["type"] == "documentation":
if child["source"] is not None:
- text = "(source: %(source)s):\n%(content)s\n\n"%child
+ text = "(source: %(source)s):\n%(content)s\n\n" % child
else:
text = child["content"] + "\n\n"
- if not annotation["documentation"].has_key(child["language"]):
+ if not child["language"] in annotation["documentation"]:
annotation["documentation"] = text
else:
annotation["documentation"] += text
@@ -109,10 +115,11 @@
# Simple type elements
+
def GenerateFacetReducing(facetname, canbefixed):
def ReduceFacet(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
- if attributes.has_key("value"):
+ if "value" in attributes:
facet = {"type": facetname, "value": attributes["value"], "doc": annotations}
if canbefixed:
facet["fixed"] = attributes.get("fixed", False)
@@ -124,7 +131,7 @@
def ReduceList(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
list = {"type": "list", "itemType": attributes.get("itemType", None), "doc": annotations}
-
+
if len(children) > 0 and children[0]["type"] == SIMPLETYPE:
if list["itemType"] is None:
list["itemType"] = children[0]
@@ -138,7 +145,7 @@
def ReduceUnion(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
union = {"type": "union", "memberTypes": attributes.get("memberTypes", []), "doc": annotations}
-
+
for child in children:
if child["type"] == SIMPLETYPE:
union["memberTypes"].appendchild
@@ -151,35 +158,35 @@
# Initialize type informations
facets = {}
simpleType = {"type": SIMPLETYPE, "final": attributes.get("final", [])}
- if attributes.has_key("name"):
+ 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)):
basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)
if basetypeinfos is None:
- raise "\"%s\" isn't defined!" % typeinfos["base"]
+ raise "\"%s\" isn't defined!" % typeinfos["base"]
else:
basetypeinfos = typeinfos["base"]
-
+
# Check that base type is a simple type
if basetypeinfos["type"] != SIMPLETYPE:
raise ValueError("Base type given isn't a simpleType!")
-
+
simpleType["basename"] = basetypeinfos["basename"]
-
+
# Check that derivation is allowed
- if basetypeinfos.has_key("final"):
+ if "final" in basetypeinfos:
if "#all" in basetypeinfos["final"]:
raise ValueError("Base type can't be derivated!")
if "restriction" in basetypeinfos["final"] and typeinfos["type"] == "restriction":
raise ValueError("Base type can't be derivated by restriction!")
-
+
# Extract simple type facets
for facet in typeinfos.get("facets", []):
facettype = facet["type"]
- if not basetypeinfos["facets"].has_key(facettype):
+ if facettype not in basetypeinfos["facets"]:
raise ValueError("\"%s\" facet can't be defined for \"%s\" type!" % (facettype, type))
elif basetypeinfos["facets"][facettype][1]:
raise ValueError("\"%s\" facet is fixed on base type!" % facettype)
@@ -195,103 +202,103 @@
continue
else:
raise ValueError("\"%s\" facet can't be defined with another facet type!" % facettype)
- elif facets.has_key("enumeration"):
+ elif "enumeration" in facets:
raise ValueError("\"enumeration\" facet can't be defined with another facet type!")
- elif facets.has_key("pattern"):
+ elif "pattern" in facets:
raise ValueError("\"pattern\" facet can't be defined with another facet type!")
- elif facets.has_key(facettype):
+ elif facettype in facets:
raise ValueError("\"%s\" facet can't be defined two times!" % facettype)
elif facettype == "length":
- if facets.has_key("minLength"):
+ if "minLength" in facets:
raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")
- if facets.has_key("maxLength"):
+ if "maxLength" in facets:
raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")
try:
value = int(value)
- except:
+ except Exception:
raise ValueError("\"length\" must be an integer!")
if value < 0:
raise ValueError("\"length\" can't be negative!")
elif basevalue is not None and basevalue != value:
raise ValueError("\"length\" can't be different from \"length\" defined in base type!")
elif facettype == "minLength":
- if facets.has_key("length"):
+ if "length" in facets:
raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")
try:
value = int(value)
- except:
+ except Exception:
raise ValueError("\"minLength\" must be an integer!")
if value < 0:
raise ValueError("\"minLength\" can't be negative!")
- elif facets.has_key("maxLength") and value > facets["maxLength"]:
+ elif "maxLength" in facets and value > facets["maxLength"]:
raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")
elif basevalue is not None and basevalue < value:
raise ValueError("\"minLength\" can't be lesser than \"minLength\" defined in base type!")
elif facettype == "maxLength":
- if facets.has_key("length"):
+ if "length" in facets:
raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")
try:
value = int(value)
- except:
+ except Exception:
raise ValueError("\"maxLength\" must be an integer!")
if value < 0:
raise ValueError("\"maxLength\" can't be negative!")
- elif facets.has_key("minLength") and value < facets["minLength"]:
+ elif "minLength" in facets and value < facets["minLength"]:
raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")
elif basevalue is not None and basevalue > value:
raise ValueError("\"maxLength\" can't be greater than \"maxLength\" defined in base type!")
elif facettype == "minInclusive":
- if facets.has_key("minExclusive"):
+ if "minExclusive" in facets:
raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")
value = basetypeinfos["extract"](facet["value"], False)
- if facets.has_key("maxInclusive") and value > facets["maxInclusive"][0]:
+ if "maxInclusive" in facets and value > facets["maxInclusive"][0]:
raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")
- elif facets.has_key("maxExclusive") and value >= facets["maxExclusive"][0]:
+ elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:
raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")
elif facettype == "minExclusive":
- if facets.has_key("minInclusive"):
+ if "minInclusive" in facets:
raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")
value = basetypeinfos["extract"](facet["value"], False)
- if facets.has_key("maxInclusive") and value >= facets["maxInclusive"][0]:
+ if "maxInclusive" in facets and value >= facets["maxInclusive"][0]:
raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")
- elif facets.has_key("maxExclusive") and value >= facets["maxExclusive"][0]:
+ elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:
raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")
elif facettype == "maxInclusive":
- if facets.has_key("maxExclusive"):
+ if "maxExclusive" in facets:
raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")
value = basetypeinfos["extract"](facet["value"], False)
- if facets.has_key("minInclusive") and value < facets["minInclusive"][0]:
+ if "minInclusive" in facets and value < facets["minInclusive"][0]:
raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")
- elif facets.has_key("minExclusive") and value <= facets["minExclusive"][0]:
+ elif "minExclusive" in facets and value <= facets["minExclusive"][0]:
raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")
elif facettype == "maxExclusive":
- if facets.has_key("maxInclusive"):
+ if "maxInclusive" in facets:
raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")
value = basetypeinfos["extract"](facet["value"], False)
- if facets.has_key("minInclusive") and value <= facets["minInclusive"][0]:
+ if "minInclusive" in facets and value <= facets["minInclusive"][0]:
raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")
- elif facets.has_key("minExclusive") and value <= facets["minExclusive"][0]:
+ elif "minExclusive" in facets and value <= facets["minExclusive"][0]:
raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")
elif facettype == "whiteSpace":
if basevalue == "collapse" and value in ["preserve", "replace"] or basevalue == "replace" and value == "preserve":
- raise ValueError("\"whiteSpace\" is incompatible with \"whiteSpace\" defined in base type!")
+ raise ValueError("\"whiteSpace\" is incompatible with \"whiteSpace\" defined in base type!")
elif facettype == "totalDigits":
- if facets.has_key("fractionDigits") and value <= facets["fractionDigits"][0]:
+ if "fractionDigits" in facets and value <= facets["fractionDigits"][0]:
raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")
elif basevalue is not None and value > basevalue:
raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")
elif facettype == "fractionDigits":
- if facets.has_key("totalDigits") and value <= facets["totalDigits"][0]:
+ if "totalDigits" in facets and value <= facets["totalDigits"][0]:
raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")
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
+
+ # Report not redefined facet from base type to new created type
for facettype, facetvalue in basetypeinfos["facets"].items():
- if not facets.has_key(facettype):
+ 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)
@@ -311,13 +318,13 @@
raise ValueError("value must be greater than %s" % str(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:
+ 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)))
result = model.match(value)
if result is None:
- if len(facetvalue) > 1:
+ 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])
@@ -327,7 +334,7 @@
elif facetvalue == "collapse":
value = GetToken(value, False)
return value
-
+
def CheckSimpleTypeValue(value):
for facetname, (facetvalue, facetfixed) in facets.items():
if facetvalue is not None:
@@ -345,18 +352,18 @@
return False
elif facetname == "maxInclusive" and value > facetvalue:
return False
- elif facetname == "maxExclusive" and value >= facetvalue:
+ elif facetname == "maxExclusive" and value >= facetvalue:
return False
elif facetname == "pattern":
model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))
result = model.match(value)
if result is None:
- if len(facetvalue) > 1:
+ 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():
if facetvalue is not None:
@@ -372,12 +379,12 @@
return facetvalue + 1
elif facetname == "maxInclusive" and facetvalue < 0:
return facetvalue
- elif facetname == "maxExclusive" and facetvalue <= 0:
+ elif facetname == "maxExclusive" and facetvalue <= 0:
return facetvalue - 1
return basetypeinfos["initial"]()
-
+
GenerateSimpleType = basetypeinfos["generate"]
-
+
elif typeinfos["type"] == "list":
# Search for item type definition
if isinstance(typeinfos["itemType"], (StringType, UnicodeType)):
@@ -386,41 +393,42 @@
raise "\"%s\" isn't defined!" % typeinfos["itemType"]
else:
itemtypeinfos = typeinfos["itemType"]
-
+
# Check that item type is a simple type
if itemtypeinfos["type"] != SIMPLETYPE:
- raise ValueError, "Item type given isn't a simpleType!"
-
+ raise ValueError("Item type given isn't a simpleType!")
+
simpleType["basename"] = "list"
-
+
# Check that derivation is allowed
- if itemtypeinfos.has_key("final"):
- if itemtypeinfos["final"].has_key("#all"):
+ if "final" in itemtypeinfos:
+ if "#all" in itemtypeinfos["final"]:
raise ValueError("Item type can't be derivated!")
- if itemtypeinfos["final"].has_key("list"):
+ if "list" in itemtypeinfos["final"]:
raise ValueError("Item type can't be derivated by list!")
-
+
# Generate extract value for new created type
- def ExtractSimpleTypeValue(attr, extract = True):
+ def ExtractSimpleTypeValue(attr, extract=True):
values = []
for value in GetToken(attr, extract).split(" "):
values.append(itemtypeinfos["extract"](value, False))
return values
-
+
def CheckSimpleTypeValue(value):
for item in value:
result = itemtypeinfos["check"](item)
if not result:
return result
return True
-
- SimpleTypeInitialValue = lambda: []
-
+
+ def SimpleTypeInitialValue():
+ return []
+
GenerateSimpleType = GenerateSimpleTypeXMLText(lambda x: " ".join(map(itemtypeinfos["generate"], x)))
-
+
facets = GenerateDictFacets(["length", "maxLength", "minLength", "enumeration", "pattern"])
facets["whiteSpace"] = ("collapse", False)
-
+
elif typeinfos["type"] == "union":
# Search for member types definition
membertypesinfos = []
@@ -431,24 +439,24 @@
raise ValueError("\"%s\" isn't defined!" % membertype)
else:
infos = membertype
-
+
# Check that member type is a simple type
if infos["type"] != SIMPLETYPE:
raise ValueError("Member type given isn't a simpleType!")
-
+
# Check that derivation is allowed
- if infos.has_key("final"):
- if infos["final"].has_key("#all"):
+ if "final" in infos:
+ if "#all" in infos["final"]:
raise ValueError("Item type can't be derivated!")
- if infos["final"].has_key("union"):
+ if "union" in infos["final"]:
raise ValueError("Member type can't be derivated by union!")
-
+
membertypesinfos.append(infos)
-
+
simpleType["basename"] = "union"
-
+
# Generate extract value for new created type
- def ExtractSimpleTypeValue(attr, extract = True):
+ def ExtractSimpleTypeValue(attr, extract=True):
if extract:
value = GetAttributeValue(attr)
else:
@@ -456,28 +464,28 @@
for infos in membertypesinfos:
try:
return infos["extract"](attr, False)
- except:
+ except Exception:
pass
raise ValueError("\"%s\" isn't valid for type defined for union!")
-
+
def CheckSimpleTypeValue(value):
for infos in membertypesinfos:
result = infos["check"](value)
if result:
return result
return False
-
+
SimpleTypeInitialValue = membertypesinfos[0]["initial"]
-
+
def GenerateSimpleTypeFunction(value):
if isinstance(value, BooleanType):
return {True: "true", False: "false"}[value]
else:
return str(value)
GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)
-
+
facets = GenerateDictFacets(["pattern", "enumeration"])
-
+
simpleType["facets"] = facets
simpleType["extract"] = ExtractSimpleTypeValue
simpleType["initial"] = SimpleTypeInitialValue
@@ -485,25 +493,27 @@
simpleType["generate"] = GenerateSimpleType
return simpleType
+
def ReduceSimpleType(factory, attributes, elements):
# Reduce all the simple type children
annotations, children = factory.ReduceElements(elements)
-
+
simpleType = CreateSimpleType(factory, attributes, children[0])
simpleType["doc"] = annotations
-
+
return simpleType
# Complex type
+
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:
- attrnames = dict(map(lambda x:(x["name"], True), basetypeinfos["attributes"]))
-
+ attrnames = dict(map(lambda x: (x["name"], True), basetypeinfos["attributes"]))
+
for element in elements:
if element["type"] == ATTRIBUTE:
if attrnames.get(element["name"], False):
@@ -534,7 +544,7 @@
raise ValueError("Only one base type can be defined for restriction!")
if restriction["base"] is None:
raise ValueError("No base type has been defined for restriction!")
-
+
while len(children) > 0 and children[0]["type"] in ALL_FACETS:
restriction["facets"].append(children.pop(0))
restriction["attributes"] = ExtractAttributes(factory, children, restriction["base"])
@@ -543,7 +553,7 @@
def ReduceExtension(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
- if not attributes.has_key("base"):
+ if "base" not in attributes:
raise ValueError("No base type has been defined for extension!")
extension = {"type": "extension", "attributes": [], "elements": [], "base": attributes["base"], "doc": annotations}
if len(children) > 0:
@@ -558,7 +568,7 @@
extension["elements"].append(content)
elif group["type"] == "group":
elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
- if elmtgroup.has_key("elements"):
+ if "elements" in elmtgroup:
extension["elements"] = elmtgroup["elements"]
extension["order"] = elmtgroup["order"]
else:
@@ -571,24 +581,24 @@
def ReduceSimpleContent(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
simpleContent = children[0].copy()
-
+
basetypeinfos = factory.FindSchemaElement(simpleContent["base"])
if basetypeinfos["type"] == SIMPLETYPE:
contenttypeinfos = simpleContent.copy()
simpleContent.pop("base")
- elif basetypeinfos["type"] == COMPLEXTYPE and \
- len(basetypeinfos["elements"]) == 1 and \
- basetypeinfos["elements"][0]["name"] == "content" and \
- basetypeinfos["elements"][0].has_key("elmt_type") and \
- basetypeinfos["elements"][0]["elmt_type"]["type"] == SIMPLETYPE:
+ elif (basetypeinfos["type"] == COMPLEXTYPE and
+ len(basetypeinfos["elements"]) == 1 and
+ basetypeinfos["elements"][0]["name"] == "content" and
+ "elmt_type" in basetypeinfos["elements"][0] and
+ basetypeinfos["elements"][0]["elmt_type"]["type"] == SIMPLETYPE):
contenttypeinfos = simpleContent.copy()
contenttypeinfos["base"] = basetypeinfos["elements"][0]["elmt_type"]
else:
raise ValueError("No compatible base type defined for simpleContent!")
contenttypeinfos = CreateSimpleType(factory, attributes, contenttypeinfos)
-
+
simpleContent["elements"] = [{"name": "content", "type": ELEMENT,
"elmt_type": contenttypeinfos, "doc": annotations,
"minOccurs": 1, "maxOccurs": 1}]
@@ -605,7 +615,7 @@
def ReduceComplexType(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
if len(children) > 0:
if children[0]["type"] in ["simpleContent", "complexContent"]:
complexType = children[0].copy()
@@ -641,7 +651,7 @@
complexType["elements"].append(content)
elif group["type"] == "group":
elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
- if elmtgroup.has_key("elements"):
+ if "elements" in elmtgroup:
complexType["elements"] = elmtgroup["elements"]
complexType["order"] = elmtgroup["order"]
else:
@@ -661,36 +671,36 @@
# Attribute elements
def ReduceAnyAttribute(factory, attributes, elements):
- return {"type" : "anyAttribute"}
+ return {"type": "anyAttribute"}
def ReduceAttribute(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
- if attributes.has_key("default"):
- if attributes.has_key("fixed"):
+
+ if "default" in attributes:
+ if "fixed" in attributes:
raise ValueError("\"default\" and \"fixed\" can't be defined at the same time!")
elif attributes.get("use", "optional") != "optional":
raise ValueError("if \"default\" present, \"use\" can only have the value \"optional\"!")
-
+
attribute = {"type": ATTRIBUTE, "attr_type": attributes.get("type", None), "doc": annotations}
if len(children) > 0:
if attribute["attr_type"] is None:
attribute["attr_type"] = children[0]
else:
raise ValueError("Only one type can be defined for attribute!")
-
- if attributes.has_key("ref"):
- if attributes.has_key("name"):
+
+ if "ref" in attributes:
+ if "name" in attributes:
raise ValueError("\"ref\" and \"name\" can't be defined at the same time!")
- elif attributes.has_key("form"):
+ elif "form" in attributes:
raise ValueError("\"ref\" and \"form\" can't be defined at the same time!")
elif attribute["attr_type"] is not None:
raise ValueError("if \"ref\" is present, no type can be defined!")
elif attribute["attr_type"] is None:
raise ValueError("No type has been defined for attribute \"%s\"!" % attributes["name"])
-
- if attributes.has_key("type"):
+
+ if "type" in attributes:
tmp_attrs = attributes.copy()
tmp_attrs.pop("type")
attribute.update(tmp_attrs)
@@ -701,7 +711,7 @@
def ReduceAttributeGroup(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
- if attributes.has_key("ref"):
+ if "ref" in attributes:
return {"type": "attributeGroup", "ref": attributes["ref"], "doc": annotations}
else:
return {"type": ATTRIBUTESGROUP, "attributes": ExtractAttributes(factory, children), "doc": annotations}
@@ -711,14 +721,15 @@
def ReduceAny(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
any = {"type": ANY, "doc": annotations}
any.update(attributes)
return any
+
def ReduceElement(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
types = []
constraints = []
for child in children:
@@ -726,19 +737,19 @@
constraints.append(child)
else:
types.append(child)
-
- if attributes.has_key("default") and attributes.has_key("fixed"):
+
+ if "default" in attributes and "fixed" in attributes:
raise ValueError("\"default\" and \"fixed\" can't be defined at the same time!")
-
- if attributes.has_key("ref"):
+
+ if "ref" in attributes:
for attr in ["name", "default", "fixed", "form", "block", "type"]:
- if attributes.has_key(attr):
+ if attr in attributes:
raise ValueError("\"ref\" and \"%s\" can't be defined at the same time!" % attr)
- if attributes.has_key("nillable"):
+ if "nillable" in attributes:
raise ValueError("\"ref\" and \"nillable\" can't be defined at the same time!")
if len(types) > 0:
raise ValueError("No type and no constraints can be defined where \"ref\" is defined!")
-
+
infos = factory.FindSchemaElement(attributes["ref"], ELEMENT)
if infos is not None:
element = infos.copy()
@@ -748,8 +759,8 @@
return element
else:
raise ValueError("\"%s\" base type isn't defined or circular referenced!" % name)
-
- elif attributes.has_key("name"):
+
+ elif "name" in attributes:
element = {"type": ELEMENT, "elmt_type": attributes.get("type", None), "constraints": constraints, "doc": annotations}
if len(types) > 0:
if element["elmt_type"] is None:
@@ -759,8 +770,8 @@
elif element["elmt_type"] is None:
element["elmt_type"] = "tag"
element["type"] = TAG
-
- if attributes.has_key("type"):
+
+ if "type" in attributes:
tmp_attrs = attributes.copy()
tmp_attrs.pop("type")
element.update(tmp_attrs)
@@ -770,20 +781,21 @@
else:
raise ValueError("\"Element\" must have at least a \"ref\" or a \"name\" defined!")
+
def ReduceAll(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
for child in children:
if children["maxOccurs"] == "unbounded" or children["maxOccurs"] > 1:
raise ValueError("\"all\" item can't have \"maxOccurs\" attribute greater than 1!")
-
+
return {"type": "all", "elements": children, "minOccurs": attributes["minOccurs"],
"maxOccurs": attributes["maxOccurs"], "order": False, "doc": annotations}
def ReduceChoice(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
choices = []
for child in children:
if child["type"] in [ELEMENT, ANY, TAG]:
@@ -791,12 +803,12 @@
elif child["type"] == "sequence":
child["minOccurs"] = child["maxOccurs"] = 1
choices.append(child)
- #raise ValueError("\"sequence\" in \"choice\" is not supported. Create instead a new complex type!")
+ # raise ValueError("\"sequence\" in \"choice\" is not supported. Create instead a new complex type!")
elif child["type"] == CHOICE:
choices.extend(child["choices"])
elif child["type"] == "group":
- elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
- if not elmtgroup.has_key("choices"):
+ 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"]:
@@ -810,18 +822,18 @@
else:
choices_tmp.append(choice)
choices.extend(choices_tmp)
-
+
for choice in choices:
attributes["minOccurs"] = min(attributes["minOccurs"], choice["minOccurs"])
choice["minOccurs"] = 1
-
+
return {"type": CHOICE, "choices": choices, "minOccurs": attributes["minOccurs"],
"maxOccurs": attributes["maxOccurs"], "doc": annotations}
def ReduceSequence(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
sequence = []
for child in children:
if child["type"] in [ELEMENT, ANY, TAG, CHOICE]:
@@ -830,12 +842,12 @@
sequence.extend(child["elements"])
elif child["type"] == "group":
elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)
- if not elmtgroup.has_key("elements") or not elmtgroup["order"]:
+ 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:
- elmt_type = "%s_%s"%(elmtgroup["name"], element["name"])
+ 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()
@@ -844,15 +856,15 @@
else:
elements_tmp.append(element)
sequence.extend(elements_tmp)
-
+
return {"type": "sequence", "elements": sequence, "minOccurs": attributes["minOccurs"],
"maxOccurs": attributes["maxOccurs"], "order": True, "doc": annotations}
-
-
+
+
def ReduceGroup(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
- if attributes.has_key("ref"):
+
+ if "ref" in attributes:
return {"type": "group", "ref": attributes["ref"], "doc": annotations}
else:
element = children[0]
@@ -866,41 +878,46 @@
# Constraint elements
+
def ReduceUnique(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
unique = {"type": CONSTRAINT, "const_type": "unique", "selector": children[0], "fields": children[1:]}
unique.update(attributes)
return unique
-
+
+
def ReduceKey(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
key = {"type": CONSTRAINT, "const_type": "key", "selector": children[0], "fields": children[1:]}
key.update(attributes)
return key
+
def ReduceKeyRef(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
keyref = {"type": CONSTRAINT, "const_type": "keyref", "selector": children[0], "fields": children[1:]}
keyref.update(attributes)
return keyref
-
+
+
def ReduceSelector(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
selector = {"type": CONSTRAINT, "const_type": "selector"}
selector.update(attributes)
return selector
+
def ReduceField(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
field = {"type": CONSTRAINT, "const_type": "field"}
field.update(attributes)
return field
-
+
# Inclusion elements
@@ -908,9 +925,10 @@
annotations, children = factory.ReduceElements(elements)
raise ValueError("\"import\" element isn't supported yet!")
+
def ReduceInclude(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
-
+
if factory.FileName is None:
raise ValueError("Include in XSD string not yet supported")
filepath = attributes["schemaLocation"]
@@ -922,7 +940,7 @@
include_factory = XSDClassFactory(minidom.parse(xsdfile), filepath)
xsdfile.close()
include_factory.CreateClasses()
-
+
if factory.TargetNamespace == include_factory.TargetNamespace:
factory.Namespaces[factory.TargetNamespace].update(include_factory.Namespaces[include_factory.TargetNamespace])
else:
@@ -931,7 +949,8 @@
factory.ComputedClassesLookUp.update(include_factory.ComputedClassesLookUp)
factory.EquivalentClassesParent.update(include_factory.EquivalentClassesParent)
return None
-
+
+
def ReduceRedefine(factory, attributes, elements):
annotations, children = factory.ReduceElements(elements)
raise ValueError("\"redefine\" element isn't supported yet!")
@@ -944,23 +963,24 @@
factory.ElementFormDefault = attributes["elementFormDefault"]
factory.BlockDefault = attributes["blockDefault"]
factory.FinalDefault = attributes["finalDefault"]
-
+
targetNamespace = attributes.get("targetNamespace", None)
factory.TargetNamespace = factory.DefinedNamespaces.get(targetNamespace, None)
if factory.TargetNamespace is not None:
factory.etreeNamespaceFormat = "{%s}%%s" % targetNamespace
factory.Namespaces[factory.TargetNamespace] = {}
-
+
annotations, children = factory.ReduceElements(elements, True)
-
+
for child in children:
- if child.has_key("name"):
+ if "name" in child:
infos = factory.GetQualifiedNameInfos(child["name"], factory.TargetNamespace, True)
if infos is None:
factory.Namespaces[factory.TargetNamespace][child["name"]] = child
elif not CompareSchema(infos, child):
raise ValueError("\"%s\" is defined twice in targetNamespace!" % child["name"])
+
def CompareSchema(schema, reference):
if isinstance(schema, ListType):
if not isinstance(reference, ListType) or len(schema) != len(reference):
@@ -975,7 +995,7 @@
return False
for name, value in schema.items():
ref_value = reference.get(name, None)
- if ref_value is None and value != None:
+ if ref_value is None and value is not None:
return False
result = CompareSchema(value, ref_value)
if not result:
@@ -987,10 +1007,11 @@
else:
return True
return schema == reference
-
-#-------------------------------------------------------------------------------
+
+
+# -------------------------------------------------------------------------------
# Base class for XSD schema extraction
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
class XSDClassFactory(ClassFactory):
@@ -999,7 +1020,7 @@
ClassFactory.__init__(self, document, filepath, debug)
self.Namespaces["xml"] = {
"lang": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("lang", LANGUAGE_model)
}
@@ -1007,31 +1028,31 @@
}
self.Namespaces["xsi"] = {
"noNamespaceSchemaLocation": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": NotSupportedYet("noNamespaceSchemaLocation")
}
},
"nil": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": NotSupportedYet("nil")
}
},
"schemaLocation": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": NotSupportedYet("schemaLocation")
}
},
"type": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": NotSupportedYet("type")
}
}
}
-
+
def ParseSchema(self):
for child in self.Document.childNodes:
if child.nodeType == self.Document.ELEMENT_NODE:
@@ -1067,7 +1088,7 @@
if element_type is not None and element["type"] != element_type:
raise ValueError("\"%s\" isn't of the expected type!" % element_name)
return element
-
+
def CreateSchemaElement(self, element_name, element_type):
for type, attributes, elements in self.Schema[2]:
namespace, name = DecomposeQualifiedName(type)
@@ -1090,11 +1111,12 @@
return element_infos
return None
-"""
-This function opens the xsd file and generate a xml parser with class lookup from
-the xml tree
-"""
+
def GenerateParserFromXSD(filepath):
+ """
+ This function opens the xsd file and generate a xml parser with class lookup from
+ the xml tree
+ """
xsdfile = open(filepath, 'r')
xsdstring = xsdfile.read()
xsdfile.close()
@@ -1104,24 +1126,27 @@
os.chdir(cwd)
return parser
-"""
-This function generate a xml from the xsd given as a string
-"""
+
def GenerateParserFromXSDstring(xsdstring):
+ """
+ This function generate a xml from the xsd given as a string
+ """
return GenerateParser(XSDClassFactory(minidom.parseString(xsdstring)), xsdstring)
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
# XSD schema syntax elements
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
+
XSD_NAMESPACE = {
-#-------------------------------------------------------------------------------
-# Syntax elements definition
-#-------------------------------------------------------------------------------
-
- "all": {"struct": """
+ # -------------------------------------------------------------------------------
+ # Syntax elements definition
+ # -------------------------------------------------------------------------------
+
+ "all": {
+ "struct": """
<all
id = ID
maxOccurs = 1 : 1
@@ -1129,29 +1154,33 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, element*)
</all>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("all", ["id", "maxOccurs", "minOccurs"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "all", ["id", "maxOccurs", "minOccurs"],
re.compile("((?:annotation )?(?:element )*)"))
},
"reduce": ReduceAll
},
- "annotation": {"struct": """
+ "annotation": {
+ "struct": """
<annotation
id = ID
{any attributes with non-schema namespace . . .}>
Content: (appinfo | documentation)*
</annotation>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("annotation", ["id"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "annotation", ["id"],
re.compile("((?:app_info |documentation )*)"))
},
"reduce": ReduceAnnotation
},
- "any": {"struct": """
+ "any": {
+ "struct": """
<any
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
@@ -1161,16 +1190,18 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</any>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("any",
- ["id", "maxOccurs", "minOccurs", "namespace", "processContents"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "any",
+ ["id", "maxOccurs", "minOccurs", "namespace", "processContents"],
re.compile("((?:annotation )?(?:simpleType )*)"))
},
"reduce": ReduceAny
},
- "anyAttribute": {"struct": """
+ "anyAttribute": {
+ "struct": """
<anyAttribute
id = ID
namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any
@@ -1178,28 +1209,30 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</anyAttribute>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("anyAttribute",
- ["id", "namespace", "processContents"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "anyAttribute", ["id", "namespace", "processContents"], ONLY_ANNOTATION)
},
"reduce": ReduceAnyAttribute
},
- "appinfo": {"struct": """
+ "appinfo": {
+ "struct": """
<appinfo
source = anyURI
{any attributes with non-schema namespace . . .}>
Content: ({any})*
</appinfo>""",
- "type": SYNTAXELEMENT,
+ "type": SYNTAXELEMENT,
"extract": {
"default": GenerateElement("appinfo", ["source"], re.compile("(.*)"), True)
},
"reduce": ReduceAppInfo
},
- "attribute": {"struct": """
+ "attribute": {
+ "struct": """
<attribute
default = string
fixed = string
@@ -1212,19 +1245,22 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, simpleType?)
</attribute>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("attribute",
- ["default", "fixed", "form", "id", "name", "ref", "type", "use"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "attribute",
+ ["default", "fixed", "form", "id", "name", "ref", "type", "use"],
re.compile("((?:annotation )?(?:simpleType )?)")),
- "schema": GenerateElement("attribute",
- ["default", "fixed", "form", "id", "name", "type"],
+ "schema": GenerateElement(
+ "attribute",
+ ["default", "fixed", "form", "id", "name", "type"],
re.compile("((?:annotation )?(?:simpleType )?)"))
},
"reduce": ReduceAttribute
},
- "attributeGroup": {"struct": """
+ "attributeGroup": {
+ "struct": """
<attributeGroup
id = ID
name = NCName
@@ -1232,18 +1268,21 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
</attributeGroup>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("attributeGroup",
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "attributeGroup",
["id", "ref"], ONLY_ANNOTATION),
- "schema": GenerateElement("attributeGroup",
- ["id", "name"],
+ "schema": GenerateElement(
+ "attributeGroup",
+ ["id", "name"],
re.compile("((?:annotation )?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?))"))
},
"reduce": ReduceAttributeGroup
},
- "choice": {"struct": """
+ "choice": {
+ "struct": """
<choice
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
@@ -1251,30 +1290,36 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (element | group | choice | sequence | any)*)
</choice>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("choice", ["id", "maxOccurs", "minOccurs"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "choice",
+ ["id", "maxOccurs", "minOccurs"],
re.compile("((?:annotation )?(?:element |group |choice |sequence |any )*)"))
},
"reduce": ReduceChoice
},
- "complexContent": {"struct": """
+ "complexContent": {
+ "struct": """
<complexContent
id = ID
mixed = boolean
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (restriction | extension))
</complexContent>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("complexContent", ["id", "mixed"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "complexContent",
+ ["id", "mixed"],
re.compile("((?:annotation )?(?:restriction |extension ))"))
},
"reduce": ReduceComplexContent
},
- "complexType": {"struct": """
+ "complexType": {
+ "struct": """
<complexType
abstract = boolean : false
block = (#all | List of (extension | restriction))
@@ -1285,31 +1330,36 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
</complexType>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("complexType",
- ["abstract", "block", "final", "id", "mixed", "name"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "complexType",
+ ["abstract", "block", "final", "id", "mixed", "name"],
re.compile("((?:annotation )?(?:simpleContent |complexContent |(?:(?:group |all |choice |sequence )?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?))))"))
},
"reduce": ReduceComplexType
},
- "documentation": {"struct" : """
+ "documentation": {
+ "struct": """
<documentation
source = anyURI
xml:lang = language
{any attributes with non-schema namespace . . .}>
Content: ({any})*
</documentation>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("documentation",
- ["source", "lang"], re.compile("(.*)"), True)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "documentation",
+ ["source", "lang"],
+ re.compile("(.*)"), True)
},
"reduce": ReduceDocumentation
},
- "element": {"struct": """
+ "element": {
+ "struct": """
<element
abstract = boolean : false
block = (#all | List of (extension | restriction | substitution))
@@ -1328,64 +1378,74 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
</element>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("element",
- ["abstract", "block", "default", "final", "fixed", "form", "id", "maxOccurs", "minOccurs", "name", "nillable", "ref", "substitutionGroup", "type"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "element",
+ ["abstract", "block", "default", "final", "fixed", "form", "id", "maxOccurs", "minOccurs", "name", "nillable", "ref", "substitutionGroup", "type"],
re.compile("((?:annotation )?(?:simpleType |complexType )?(?:unique |key |keyref )*)")),
- "schema": GenerateElement("element",
- ["abstract", "block", "default", "final", "fixed", "form", "id", "name", "nillable", "substitutionGroup", "type"],
+ "schema": GenerateElement(
+ "element",
+ ["abstract", "block", "default", "final", "fixed", "form", "id", "name", "nillable", "substitutionGroup", "type"],
re.compile("((?:annotation )?(?:simpleType |complexType )?(?:unique |key |keyref )*)"))
},
"reduce": ReduceElement
},
- "enumeration": {"struct": """
+ "enumeration": {
+ "struct": """
<enumeration
id = ID
value = anySimpleType
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</enumeration>""",
- "type": SYNTAXELEMENT,
+ "type": SYNTAXELEMENT,
"extract": {
"default": GenerateElement("enumeration", ["id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("enumeration", False)
},
- "extension": {"struct": """
+ "extension": {
+ "struct": """
<extension
base = QName
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))
</extension>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("extension", ["base", "id"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "extension",
+ ["base", "id"],
re.compile("((?:annotation )?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?))")),
- "complexContent": GenerateElement("extension", ["base", "id"],
+ "complexContent": GenerateElement(
+ "extension",
+ ["base", "id"],
re.compile("((?:annotation )?(?:group |all |choice |sequence )?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?))"))
},
"reduce": ReduceExtension
},
- "field": {"struct": """
+ "field": {
+ "struct": """
<field
id = ID
xpath = a subset of XPath expression, see below
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</field>""",
- "type": SYNTAXELEMENT,
+ "type": SYNTAXELEMENT,
"extract": {
"default": GenerateElement("field", ["id", "xpath"], ONLY_ANNOTATION)
},
"reduce": ReduceField
},
- "fractionDigits": {"struct": """
+ "fractionDigits": {
+ "struct": """
<fractionDigits
fixed = boolean : false
id = ID
@@ -1393,15 +1453,18 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</fractionDigits>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("fractionDigits",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "fractionDigits",
+ ["fixed", "id", "value"],
+ ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("fractionDigits", True)
},
- "group": {"struct": """
+ "group": {
+ "struct": """
<group
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
@@ -1411,19 +1474,22 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (all | choice | sequence)?)
</group>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("group",
- ["id", "maxOccurs", "minOccurs", "ref"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "group",
+ ["id", "maxOccurs", "minOccurs", "ref"],
re.compile("((?:annotation )?(?:all |choice |sequence )?)")),
- "schema": GenerateElement("group",
- ["id", "name"],
+ "schema": GenerateElement(
+ "group",
+ ["id", "name"],
re.compile("((?:annotation )?(?:all |choice |sequence )?)"))
},
"reduce": ReduceGroup
},
- "import": {"struct": """
+ "import": {
+ "struct": """
<import
id = ID
namespace = anyURI
@@ -1431,45 +1497,53 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</import>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("import",
- ["id", "namespace", "schemaLocation"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "import",
+ ["id", "namespace", "schemaLocation"],
+ ONLY_ANNOTATION)
},
"reduce": ReduceImport
},
- "include": {"struct": """
+ "include": {
+ "struct": """
<include
id = ID
schemaLocation = anyURI
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</include>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("include",
- ["id", "schemaLocation"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "include",
+ ["id", "schemaLocation"],
+ ONLY_ANNOTATION)
},
"reduce": ReduceInclude
},
- "key": {"struct": """
+ "key": {
+ "struct": """
<key
id = ID
name = NCName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (selector, field+))
</key>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("key", ["id", "name"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "key", ["id", "name"],
re.compile("((?:annotation )?(?:selector (?:field )+))"))
},
"reduce": ReduceKey
},
- "keyref": {"struct": """
+ "keyref": {
+ "struct": """
<keyref
id = ID
name = NCName
@@ -1477,15 +1551,17 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (selector, field+))
</keyref>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("keyref", ["id", "name", "refer"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "keyref", ["id", "name", "refer"],
re.compile("((?:annotation )?(?:selector (?:field )+))"))
},
"reduce": ReduceKeyRef
},
- "length": {"struct" : """
+ "length": {
+ "struct": """
<length
fixed = boolean : false
id = ID
@@ -1493,30 +1569,33 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</length>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("length",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "length", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("length", True)
},
- "list": {"struct": """
+ "list": {
+ "struct": """
<list
id = ID
itemType = QName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, simpleType?)
</list>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("list", ["id", "itemType"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "list", ["id", "itemType"],
re.compile("((?:annotation )?(?:simpleType )?)$"))
},
"reduce": ReduceList
},
- "maxExclusive": {"struct": """
+ "maxExclusive": {
+ "struct": """
<maxInclusive
fixed = boolean : false
id = ID
@@ -1524,15 +1603,16 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</maxInclusive>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("maxExclusive",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "maxExclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("maxExclusive", True)
},
- "maxInclusive": {"struct": """
+ "maxInclusive": {
+ "struct": """
<maxExclusive
fixed = boolean : false
id = ID
@@ -1540,15 +1620,16 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</maxExclusive>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("maxInclusive",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "maxInclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("maxInclusive", True)
},
- "maxLength": {"struct": """
+ "maxLength": {
+ "struct": """
<maxLength
fixed = boolean : false
id = ID
@@ -1556,15 +1637,16 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</maxLength>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("maxLength",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "maxLength", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("maxLength", True)
},
- "minExclusive": {"struct": """
+ "minExclusive": {
+ "struct": """
<minExclusive
fixed = boolean : false
id = ID
@@ -1572,15 +1654,16 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</minExclusive>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("minExclusive",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "minExclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("minExclusive", True)
},
- "minInclusive": {"struct": """
+ "minInclusive": {
+ "struct": """
<minInclusive
fixed = boolean : false
id = ID
@@ -1588,15 +1671,16 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</minInclusive>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("minInclusive",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "minInclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("minInclusive", True)
},
- "minLength": {"struct": """
+ "minLength": {
+ "struct": """
<minLength
fixed = boolean : false
id = ID
@@ -1604,63 +1688,74 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</minLength>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("minLength",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "minLength", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("minLength", True)
},
- "pattern": {"struct": """
+ "pattern": {
+ "struct": """
<pattern
id = ID
value = string
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</pattern>""",
- "type": SYNTAXELEMENT,
+ "type": SYNTAXELEMENT,
"extract": {
"default": GenerateElement("pattern", ["id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("pattern", False)
},
- "redefine": {"struct": """
+ "redefine": {
+ "struct": """
<redefine
id = ID
schemaLocation = anyURI
{any attributes with non-schema namespace . . .}>
Content: (annotation | (simpleType | complexType | group | attributeGroup))*
</redefine>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("refine", ["id", "schemaLocation"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "refine", ["id", "schemaLocation"],
re.compile("((?:annotation |(?:simpleType |complexType |group |attributeGroup ))*)"))
},
"reduce": ReduceRedefine
},
- "restriction": {"struct": """
+ "restriction": {
+ "struct": """
<restriction
base = QName
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))
</restriction>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("restriction", ["base", "id"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "restriction",
+ ["base", "id"],
re.compile("((?:annotation )?(?:(?:simpleType )?(?:(?:minExclusive |minInclusive |maxExclusive |maxInclusive |totalDigits |fractionDigits |length |minLength |maxLength |enumeration |whiteSpace |pattern )*)))")),
- "simpleContent": GenerateElement("restriction", ["base", "id"],
+ "simpleContent": GenerateElement(
+ "restriction",
+ ["base", "id"],
re.compile("((?:annotation )?(?:(?:simpleType )?(?:(?:minExclusive |minInclusive |maxExclusive |maxInclusive |totalDigits |fractionDigits |length |minLength |maxLength |enumeration |whiteSpace |pattern )*)?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?)))")),
- "complexContent": GenerateElement("restriction", ["base", "id"],
+ "complexContent": GenerateElement(
+ "restriction",
+ ["base", "id"],
re.compile("((?:annotation )?(?:(?:simpleType )?(?:group |all |choice |sequence )?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?)))")),
},
"reduce": ReduceRestriction
},
- "schema": {"struct": """
+ "schema": {
+ "struct": """
<schema
attributeFormDefault = (qualified | unqualified) : unqualified
blockDefault = (#all | List of (extension | restriction | substitution)) : ''
@@ -1673,29 +1768,39 @@
{any attributes with non-schema namespace . . .}>
Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group | attributeGroup) | element | attribute | notation), annotation*)*)
</schema>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("schema",
- ["attributeFormDefault", "blockDefault", "elementFormDefault", "finalDefault", "id", "targetNamespace", "version", "lang"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "schema",
+ ["attributeFormDefault",
+ "blockDefault",
+ "elementFormDefault",
+ "finalDefault",
+ "id",
+ "targetNamespace",
+ "version",
+ "lang"],
re.compile("((?:include |import |redefine |annotation )*(?:(?:(?:simpleType |complexType |group |attributeGroup )|element |attribute |annotation )(?:annotation )*)*)"))
}
},
- "selector": {"struct": """
+ "selector": {
+ "struct": """
<selector
id = ID
xpath = a subset of XPath expression, see below
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</selector>""",
- "type": SYNTAXELEMENT,
+ "type": SYNTAXELEMENT,
"extract": {
"default": GenerateElement("selector", ["id", "xpath"], ONLY_ANNOTATION)
},
"reduce": ReduceSelector
},
- "sequence": {"struct": """
+ "sequence": {
+ "struct": """
<sequence
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
@@ -1703,29 +1808,33 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (element | group | choice | sequence | any)*)
</sequence>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("sequence", ["id", "maxOccurs", "minOccurs"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "sequence", ["id", "maxOccurs", "minOccurs"],
re.compile("((?:annotation )?(?:element |group |choice |sequence |any )*)"))
},
"reduce": ReduceSequence
},
- "simpleContent": {"struct" : """
+ "simpleContent": {
+ "struct": """
<simpleContent
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (restriction | extension))
</simpleContent>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("simpleContent", ["id"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "simpleContent", ["id"],
re.compile("((?:annotation )?(?:restriction |extension ))"))
},
"reduce": ReduceSimpleContent
},
- "simpleType": {"struct" : """
+ "simpleType": {
+ "struct": """
<simpleType
final = (#all | List of (list | union | restriction))
id = ID
@@ -1733,15 +1842,17 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (restriction | list | union))
</simpleType>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("simpleType", ["final", "id", "name"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "simpleType", ["final", "id", "name"],
re.compile("((?:annotation )?(?:restriction |list |union ))"))
},
"reduce": ReduceSimpleType
},
- "totalDigits": {"struct" : """
+ "totalDigits": {
+ "struct": """
<totalDigits
fixed = boolean : false
id = ID
@@ -1749,45 +1860,50 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</totalDigits>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("totalDigits",
- ["fixed", "id", "value"], ONLY_ANNOTATION),
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "totalDigits", ["fixed", "id", "value"], ONLY_ANNOTATION),
},
"reduce": GenerateFacetReducing("totalDigits", True)
},
- "union": {"struct": """
+ "union": {
+ "struct": """
<union
id = ID
memberTypes = List of QName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, simpleType*)
</union>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("union", ["id", "memberTypes"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "union", ["id", "memberTypes"],
re.compile("((?:annotation )?(?:simpleType )*)"))
},
"reduce": ReduceUnion
},
- "unique": {"struct": """
+ "unique": {
+ "struct": """
<unique
id = ID
name = NCName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (selector, field+))
</unique>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("unique", ["id", "name"],
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "unique", ["id", "name"],
re.compile("((?:annotation )?(?:selector |(?:field )+))"))
},
"reduce": ReduceUnique
},
-
- "whiteSpace": {"struct" : """
+
+ "whiteSpace": {
+ "struct": """
<whiteSpace
fixed = boolean : false
id = ID
@@ -1795,20 +1911,20 @@
{any attributes with non-schema namespace . . .}>
Content: (annotation?)
</whiteSpace>""",
- "type": SYNTAXELEMENT,
- "extract": {
- "default": GenerateElement("whiteSpace",
- ["fixed", "id", "value"], ONLY_ANNOTATION)
+ "type": SYNTAXELEMENT,
+ "extract": {
+ "default": GenerateElement(
+ "whiteSpace", ["fixed", "id", "value"], ONLY_ANNOTATION)
},
"reduce": GenerateFacetReducing("whiteSpace", True)
},
-#-------------------------------------------------------------------------------
-# Syntax attributes definition
-#-------------------------------------------------------------------------------
+ # -------------------------------------------------------------------------------
+ # Syntax attributes definition
+ # -------------------------------------------------------------------------------
"abstract": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GetBoolean
},
@@ -1818,31 +1934,32 @@
},
"attributeFormDefault": {
- "type": SYNTAXATTRIBUTE,
- "extract": {
- "default": GenerateEnumeratedExtraction("member attributeFormDefault", ["qualified", "unqualified"])
+ "type": SYNTAXATTRIBUTE,
+ "extract": {
+ "default": GenerateEnumeratedExtraction(
+ "member attributeFormDefault", ["qualified", "unqualified"])
},
"default": {
"default": "unqualified"
}
},
-
+
"base": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member base", QName_model)
}
},
-
+
"block": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateGetList("block", ["restriction", "extension", "substitution"])
}
},
-
+
"blockDefault": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateGetList("block", ["restriction", "extension", "substitution"])
},
@@ -1850,16 +1967,16 @@
"default": ""
}
},
-
+
"default": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GetAttributeValue
}
},
"elementFormDefault": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateEnumeratedExtraction("member elementFormDefault", ["qualified", "unqualified"])
},
@@ -1867,9 +1984,9 @@
"default": "unqualified"
}
},
-
+
"final": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateGetList("final", ["restriction", "extension", "substitution"]),
"simpleType": GenerateGetList("final", ["list", "union", "restriction"])
@@ -1877,7 +1994,7 @@
},
"finalDefault": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateGetList("finalDefault", ["restriction", "extension", "list", "union"])
},
@@ -1885,9 +2002,9 @@
"default": ""
}
},
-
+
"fixed": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GetBoolean,
"attribute": GetAttributeValue,
@@ -1901,35 +2018,35 @@
},
"form": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateEnumeratedExtraction("member form", ["qualified", "unqualified"])
}
},
"id": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member id", NCName_model)
}
},
-
+
"itemType": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member itemType", QName_model)
}
},
"memberTypes": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameListExtraction("member memberTypes", QNames_model)
},
},
-
+
"maxOccurs": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateLimitExtraction(),
"all": GenerateLimitExtraction(1, 1, False)
@@ -1940,9 +2057,9 @@
},
"minOccurs": {
- "type": SYNTAXATTRIBUTE,
- "extract": {
- "default": GenerateLimitExtraction(unbounded = False),
+ "type": SYNTAXATTRIBUTE,
+ "extract": {
+ "default": GenerateLimitExtraction(unbounded=False),
"all": GenerateLimitExtraction(0, 1, False)
},
"default": {
@@ -1951,7 +2068,7 @@
},
"mixed": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GetBoolean
},
@@ -1960,16 +2077,16 @@
"complexType": False
}
},
-
+
"name": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member name", NCName_model)
}
},
-
+
"namespace": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member namespace", URI_model),
"any": GetNamespaces
@@ -1981,14 +2098,14 @@
},
"nillable": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GetBoolean
},
},
-
+
"processContents": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateEnumeratedExtraction("member processContents", ["lax", "skip", "strict"])
},
@@ -1996,9 +2113,9 @@
"default": "strict"
}
},
-
+
"ref": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member ref", QName_model)
}
@@ -2010,44 +2127,44 @@
"default": GenerateModelNameExtraction("member refer", QName_model)
}
},
-
+
"schemaLocation": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member schemaLocation", URI_model)
}
},
-
+
"source": {
"type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member source", URI_model)
}
},
-
+
"substitutionGroup": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member substitutionGroup", QName_model)
}
},
"targetNamespace": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member targetNamespace", URI_model)
}
},
-
+
"type": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateModelNameExtraction("member type", QName_model)
}
},
"use": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GenerateEnumeratedExtraction("member usage", ["required", "optional", "prohibited"])
},
@@ -2057,7 +2174,7 @@
},
"value": {
- "type": SYNTAXATTRIBUTE,
+ "type": SYNTAXATTRIBUTE,
"extract": {
"default": GetAttributeValue,
"fractionDigits": GenerateIntegerExtraction(minInclusive=0),
@@ -2077,23 +2194,23 @@
},
"xpath": {
- "type": SYNTAXATTRIBUTE,
- "extract": {
-# "default": NotSupportedYet("xpath")
+ "type": SYNTAXATTRIBUTE,
+ "extract": {
+ # "default": NotSupportedYet("xpath")
"default": GetAttributeValue
}
},
-
-#-------------------------------------------------------------------------------
-# Simple types definition
-#-------------------------------------------------------------------------------
+
+ # -------------------------------------------------------------------------------
+ # Simple types definition
+ # -------------------------------------------------------------------------------
"string": {
"type": SIMPLETYPE,
"basename": "string",
"extract": GetAttributeValue,
"facets": STRING_FACETS,
- "generate": GenerateSimpleTypeXMLText(lambda x : x),
+ "generate": GenerateSimpleTypeXMLText(lambda x: x),
"initial": lambda: "",
"check": lambda x: isinstance(x, (StringType, UnicodeType))
},
@@ -2103,61 +2220,61 @@
"basename": "normalizedString",
"extract": GetNormalizedString,
"facets": STRING_FACETS,
- "generate": GenerateSimpleTypeXMLText(lambda x : x),
+ "generate": GenerateSimpleTypeXMLText(lambda x: x),
"initial": lambda: "",
"check": lambda x: isinstance(x, (StringType, UnicodeType))
},
"token": {
"type": SIMPLETYPE,
- "basename": "token",
+ "basename": "token",
"extract": GetToken,
"facets": STRING_FACETS,
- "generate": GenerateSimpleTypeXMLText(lambda x : x),
+ "generate": GenerateSimpleTypeXMLText(lambda x: x),
"initial": lambda: "",
"check": lambda x: isinstance(x, (StringType, UnicodeType))
},
-
+
"base64Binary": {
- "type": SIMPLETYPE,
- "basename": "base64Binary",
+ "type": SIMPLETYPE,
+ "basename": "base64Binary",
"extract": NotSupportedYet("base64Binary"),
"facets": STRING_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
"check": lambda x: isinstance(x, (IntType, LongType))
},
-
+
"hexBinary": {
"type": SIMPLETYPE,
- "basename": "hexBinary",
+ "basename": "hexBinary",
"extract": GetHexInteger,
"facets": STRING_FACETS,
- "generate": GenerateSimpleTypeXMLText(lambda x: ("%."+str(int(round(len("%X"%x)/2.)*2))+"X")%x),
+ "generate": GenerateSimpleTypeXMLText(lambda x: ("%."+str(int(round(len("%X" % x)/2.)*2))+"X") % x),
"initial": lambda: 0,
"check": lambda x: isinstance(x, (IntType, LongType))
},
"integer": {
"type": SIMPLETYPE,
- "basename": "integer",
+ "basename": "integer",
"extract": GenerateIntegerExtraction(),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
"check": lambda x: isinstance(x, IntType)
},
-
+
"positiveInteger": {
"type": SIMPLETYPE,
- "basename": "positiveInteger",
+ "basename": "positiveInteger",
"extract": GenerateIntegerExtraction(minExclusive=0),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 1,
"check": lambda x: isinstance(x, IntType)
},
-
+
"negativeInteger": {
"type": SIMPLETYPE,
"basename": "negativeInteger",
@@ -2167,41 +2284,41 @@
"initial": lambda: -1,
"check": lambda x: isinstance(x, IntType)
},
-
+
"nonNegativeInteger": {
- "type": SIMPLETYPE,
- "basename": "nonNegativeInteger",
+ "type": SIMPLETYPE,
+ "basename": "nonNegativeInteger",
"extract": GenerateIntegerExtraction(minInclusive=0),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
"check": lambda x: isinstance(x, IntType)
},
-
+
"nonPositiveInteger": {
"type": SIMPLETYPE,
- "basename": "nonPositiveInteger",
+ "basename": "nonPositiveInteger",
"extract": GenerateIntegerExtraction(maxInclusive=0),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
"check": lambda x: isinstance(x, IntType)
},
-
+
"long": {
"type": SIMPLETYPE,
"basename": "long",
- "extract": GenerateIntegerExtraction(minInclusive=-2**63,maxExclusive=2**63),
+ "extract": GenerateIntegerExtraction(minInclusive=-2**63, maxExclusive=2**63),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
"check": lambda x: isinstance(x, IntType)
},
-
+
"unsignedLong": {
"type": SIMPLETYPE,
"basename": "unsignedLong",
- "extract": GenerateIntegerExtraction(minInclusive=0,maxExclusive=2**64),
+ "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**64),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2211,7 +2328,7 @@
"int": {
"type": SIMPLETYPE,
"basename": "int",
- "extract": GenerateIntegerExtraction(minInclusive=-2**31,maxExclusive=2**31),
+ "extract": GenerateIntegerExtraction(minInclusive=-2**31, maxExclusive=2**31),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2221,7 +2338,7 @@
"unsignedInt": {
"type": SIMPLETYPE,
"basename": "unsignedInt",
- "extract": GenerateIntegerExtraction(minInclusive=0,maxExclusive=2**32),
+ "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**32),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2231,7 +2348,7 @@
"short": {
"type": SIMPLETYPE,
"basename": "short",
- "extract": GenerateIntegerExtraction(minInclusive=-2**15,maxExclusive=2**15),
+ "extract": GenerateIntegerExtraction(minInclusive=-2**15, maxExclusive=2**15),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2240,8 +2357,8 @@
"unsignedShort": {
"type": SIMPLETYPE,
- "basename": "unsignedShort",
- "extract": GenerateIntegerExtraction(minInclusive=0,maxExclusive=2**16),
+ "basename": "unsignedShort",
+ "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**16),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2251,7 +2368,7 @@
"byte": {
"type": SIMPLETYPE,
"basename": "byte",
- "extract": GenerateIntegerExtraction(minInclusive=-2**7,maxExclusive=2**7),
+ "extract": GenerateIntegerExtraction(minInclusive=-2**7, maxExclusive=2**7),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2261,7 +2378,7 @@
"unsignedByte": {
"type": SIMPLETYPE,
"basename": "unsignedByte",
- "extract": GenerateIntegerExtraction(minInclusive=0,maxExclusive=2**8),
+ "extract": GenerateIntegerExtraction(minInclusive=0, maxExclusive=2**8),
"facets": DECIMAL_FACETS,
"generate": GenerateSimpleTypeXMLText(str),
"initial": lambda: 0,
@@ -2285,7 +2402,7 @@
"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, (IntType, FloatType)))
},
"double": {
@@ -2295,7 +2412,7 @@
"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, (IntType, FloatType)))
},
"boolean": {
@@ -2303,10 +2420,10 @@
"basename": "boolean",
"extract": GetBoolean,
"facets": GenerateDictFacets(["pattern", "whiteSpace"]),
- "generate": GenerateSimpleTypeXMLText(lambda x:{True : "true", False : "false"}[x]),
+ "generate": GenerateSimpleTypeXMLText(lambda x: {True: "true", False: "false"}[x]),
"initial": lambda: False,
"check": lambda x: isinstance(x, BooleanType)
- },
+ },
"duration": {
"type": SIMPLETYPE,
@@ -2324,7 +2441,7 @@
"extract": GetDateTime,
"facets": NUMBER_FACETS,
"generate": GenerateSimpleTypeXMLText(datetime.datetime.isoformat),
- "initial": lambda: datetime.datetime(1,1,1,0,0,0,0),
+ "initial": lambda: datetime.datetime(1, 1, 1, 0, 0, 0, 0),
"check": lambda x: isinstance(x, datetime.datetime)
},
@@ -2334,17 +2451,17 @@
"extract": GetDate,
"facets": NUMBER_FACETS,
"generate": GenerateSimpleTypeXMLText(datetime.date.isoformat),
- "initial": lambda: datetime.date(1,1,1),
+ "initial": lambda: datetime.date(1, 1, 1),
"check": lambda x: isinstance(x, datetime.date)
},
-
+
"time": {
"type": SIMPLETYPE,
"basename": "time",
"extract": GetTime,
"facets": NUMBER_FACETS,
"generate": GenerateSimpleTypeXMLText(datetime.time.isoformat),
- "initial": lambda: datetime.time(0,0,0,0),
+ "initial": lambda: datetime.time(0, 0, 0, 0),
"check": lambda x: isinstance(x, datetime.time)
},
@@ -2407,7 +2524,7 @@
"initial": lambda: "",
"check": lambda x: isinstance(x, (StringType, UnicodeType))
},
-
+
"QName": {
"type": SIMPLETYPE,
"basename": "QName",
@@ -2529,6 +2646,5 @@
},
# Complex Types
- "anyType": {"type": COMPLEXTYPE, "extract": lambda x:None},
+ "anyType": {"type": COMPLEXTYPE, "extract": lambda x: None},
}
-