beremiz: comparison xmlclass/xsdschema.py

equal deleted inserted replaced

-:c74815729afd
+:691083b5682a
 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"]
 #-------------------------------------------------------------------------------
 #                           Structure reducing functions
 #-------------------------------------------------------------------------------
 #-------------------------------------------------------------------------------
 #                           Syntax elements definition
 #-------------------------------------------------------------------------------
-"all": {"struct": """
+"all": {
+"struct": """
 <all
 id = ID
 maxOccurs = 1 : 1
 minOccurs = (0 | 1) : 1
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, element*)
 </all>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("all", ["id", "maxOccurs", "minOccurs"],
+"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"],
+"default": GenerateElement(
+"annotation", ["id"],
 re.compile("((?:app_info |documentation )*)"))
 },
 "reduce": ReduceAnnotation
 },
-"any": {"struct": """
+"any": {
+"struct": """
 <any
 id = ID
 maxOccurs = (nonNegativeInteger | unbounded)  : 1
 minOccurs = nonNegativeInteger : 1
 namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) )  : ##any
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </any>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("any",
+"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
 processContents = (lax | skip | strict) : strict
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </anyAttribute>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("anyAttribute",
+"default": GenerateElement(
-["id", "namespace", "processContents"], ONLY_ANNOTATION)
+"anyAttribute", ["id", "namespace", "processContents"], ONLY_ANNOTATION)
 },
 "reduce": ReduceAnyAttribute
 },
-"appinfo": {"struct": """
+"appinfo": {
+"struct": """
 <appinfo
 source = anyURI
 {any attributes with non-schema namespace . . .}>
 Content: ({any})*
 </appinfo>""",
 "default": GenerateElement("appinfo", ["source"], re.compile("(.*)"), True)
 },
 "reduce": ReduceAppInfo
 },
-"attribute": {"struct": """
+"attribute": {
+"struct": """
 <attribute
 default = string
 fixed = string
 form = (qualified | unqualified)
 id = ID
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, simpleType?)
 </attribute>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("attribute",
+"default": GenerateElement(
+"attribute",
 ["default", "fixed", "form", "id", "name", "ref", "type", "use"],
 re.compile("((?:annotation )?(?:simpleType )?)")),
-"schema": GenerateElement("attribute",
+"schema": GenerateElement(
+"attribute",
 ["default", "fixed", "form", "id", "name", "type"],
 re.compile("((?:annotation )?(?:simpleType )?)"))
 },
 "reduce": ReduceAttribute
 },
-"attributeGroup": {"struct": """
+"attributeGroup": {
+"struct": """
 <attributeGroup
 id = ID
 name = NCName
 ref = QName
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
 </attributeGroup>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("attributeGroup",
+"default": GenerateElement(
+"attributeGroup",
 ["id", "ref"], ONLY_ANNOTATION),
-"schema": GenerateElement("attributeGroup",
+"schema": GenerateElement(
+"attributeGroup",
 ["id", "name"],
 re.compile("((?:annotation )?(?:(?:attribute |attributeGroup )*(?:anyAttribute )?))"))
 },
 "reduce": ReduceAttributeGroup
 },
-"choice": {"struct": """
+"choice": {
+"struct": """
 <choice
 id = ID
 maxOccurs = (nonNegativeInteger | unbounded)  : 1
 minOccurs = nonNegativeInteger : 1
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, (element | group | choice | sequence | any)*)
 </choice>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("choice", ["id", "maxOccurs", "minOccurs"],
+"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"],
+"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))
 final = (#all | List of (extension | restriction))
 id = ID
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
 </complexType>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("complexType",
+"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",
+"default": GenerateElement(
-["source", "lang"], re.compile("(.*)"), True)
+"documentation",
+["source", "lang"],
+re.compile("(.*)"), True)
 },
 "reduce": ReduceDocumentation
 },
-"element": {"struct": """
+"element": {
+"struct": """
 <element
 abstract = boolean : false
 block = (#all | List of (extension | restriction | substitution))
 default = string
 final = (#all | List of (extension | restriction))
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
 </element>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("element",
+"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",
+"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?)
 "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"],
+"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?)
 "default": GenerateElement("field", ["id", "xpath"], ONLY_ANNOTATION)
 },
 "reduce": ReduceField
 },
-"fractionDigits": {"struct": """
+"fractionDigits": {
+"struct": """
 <fractionDigits
 fixed = boolean : false
 id = ID
 value = nonNegativeInteger
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </fractionDigits>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("fractionDigits",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"fractionDigits",
+["fixed", "id", "value"],
+ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("fractionDigits", True)
 },
-"group": {"struct": """
+"group": {
+"struct": """
 <group
 id = ID
 maxOccurs = (nonNegativeInteger | unbounded)  : 1
 minOccurs = nonNegativeInteger : 1
 name = NCName
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, (all | choice | sequence)?)
 </group>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("group",
+"default": GenerateElement(
+"group",
 ["id", "maxOccurs", "minOccurs", "ref"],
 re.compile("((?:annotation )?(?:all |choice |sequence )?)")),
-"schema": GenerateElement("group",
+"schema": GenerateElement(
+"group",
 ["id", "name"],
 re.compile("((?:annotation )?(?:all |choice |sequence )?)"))
 },
 "reduce": ReduceGroup
 },
-"import": {"struct": """
+"import": {
+"struct": """
 <import
 id = ID
 namespace = anyURI
 schemaLocation = anyURI
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </import>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("import",
+"default": GenerateElement(
-["id", "namespace", "schemaLocation"], ONLY_ANNOTATION)
+"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",
+"default": GenerateElement(
-["id", "schemaLocation"], ONLY_ANNOTATION)
+"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"],
+"default": GenerateElement(
+"key", ["id", "name"],
 re.compile("((?:annotation )?(?:selector (?:field )+))"))
 },
 "reduce": ReduceKey
 },
-"keyref": {"struct": """
+"keyref": {
+"struct": """
 <keyref
 id = ID
 name = NCName
 refer = QName
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, (selector, field+))
 </keyref>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("keyref", ["id", "name", "refer"],
+"default": GenerateElement(
+"keyref", ["id", "name", "refer"],
 re.compile("((?:annotation )?(?:selector (?:field )+))"))
 },
 "reduce": ReduceKeyRef
 },
-"length": {"struct": """
+"length": {
+"struct": """
 <length
 fixed = boolean : false
 id = ID
 value = nonNegativeInteger
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </length>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("length",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"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"],
+"default": GenerateElement(
+"list", ["id", "itemType"],
 re.compile("((?:annotation )?(?:simpleType )?)$"))
 },
 "reduce": ReduceList
 },
-"maxExclusive": {"struct": """
+"maxExclusive": {
+"struct": """
 <maxInclusive
 fixed = boolean : false
 id = ID
 value = anySimpleType
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </maxInclusive>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("maxExclusive",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"maxExclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("maxExclusive", True)
 },
-"maxInclusive": {"struct": """
+"maxInclusive": {
+"struct": """
 <maxExclusive
 fixed = boolean : false
 id = ID
 value = anySimpleType
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </maxExclusive>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("maxInclusive",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"maxInclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("maxInclusive", True)
 },
-"maxLength": {"struct": """
+"maxLength": {
+"struct": """
 <maxLength
 fixed = boolean : false
 id = ID
 value = nonNegativeInteger
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </maxLength>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("maxLength",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"maxLength", ["fixed", "id", "value"], ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("maxLength", True)
 },
-"minExclusive": {"struct": """
+"minExclusive": {
+"struct": """
 <minExclusive
 fixed = boolean : false
 id = ID
 value = anySimpleType
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </minExclusive>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("minExclusive",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"minExclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("minExclusive", True)
 },
-"minInclusive": {"struct": """
+"minInclusive": {
+"struct": """
 <minInclusive
 fixed = boolean : false
 id = ID
 value = anySimpleType
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </minInclusive>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("minInclusive",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"minInclusive", ["fixed", "id", "value"], ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("minInclusive", True)
 },
-"minLength": {"struct": """
+"minLength": {
+"struct": """
 <minLength
 fixed = boolean : false
 id = ID
 value = nonNegativeInteger
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </minLength>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("minLength",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"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?)
 "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"],
+"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"],
+"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))  : ''
 elementFormDefault = (qualified | unqualified) : unqualified
 finalDefault = (#all | List of (extension | restriction | list | union))  : ''
 {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",
+"default": GenerateElement(
-["attributeFormDefault", "blockDefault", "elementFormDefault", "finalDefault", "id", "targetNamespace", "version", "lang"],
+"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?)
 "default": GenerateElement("selector", ["id", "xpath"], ONLY_ANNOTATION)
 },
 "reduce": ReduceSelector
 },
-"sequence": {"struct": """
+"sequence": {
+"struct": """
 <sequence
 id = ID
 maxOccurs = (nonNegativeInteger | unbounded)  : 1
 minOccurs = nonNegativeInteger : 1
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, (element | group | choice | sequence | any)*)
 </sequence>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("sequence", ["id", "maxOccurs", "minOccurs"],
+"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"],
+"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
 name = NCName
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?, (restriction | list | union))
 </simpleType>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("simpleType", ["final", "id", "name"],
+"default": GenerateElement(
+"simpleType", ["final", "id", "name"],
 re.compile("((?:annotation )?(?:restriction |list |union ))"))
 },
 "reduce": ReduceSimpleType
 },
-"totalDigits": {"struct": """
+"totalDigits": {
+"struct": """
 <totalDigits
 fixed = boolean : false
 id = ID
 value = positiveInteger
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </totalDigits>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("totalDigits",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION),
+"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"],
+"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"],
+"default": GenerateElement(
+"unique", ["id", "name"],
 re.compile("((?:annotation )?(?:selector |(?:field )+))"))
 },
 "reduce": ReduceUnique
 },
-"whiteSpace": {"struct": """
+"whiteSpace": {
+"struct": """
 <whiteSpace
 fixed = boolean : false
 id = ID
 value = (collapse | preserve | replace)
 {any attributes with non-schema namespace . . .}>
 Content: (annotation?)
 </whiteSpace>""",
 "type": SYNTAXELEMENT,
 "extract": {
-"default": GenerateElement("whiteSpace",
+"default": GenerateElement(
-["fixed", "id", "value"], ONLY_ANNOTATION)
+"whiteSpace", ["fixed", "id", "value"], ONLY_ANNOTATION)
 },
 "reduce": GenerateFacetReducing("whiteSpace", True)
 },
 #-------------------------------------------------------------------------------
 },
 "attributeFormDefault": {
 "type": SYNTAXATTRIBUTE,
 "extract": {
-"default": GenerateEnumeratedExtraction("member attributeFormDefault", ["qualified", "unqualified"])
+"default": GenerateEnumeratedExtraction(
+"member attributeFormDefault", ["qualified", "unqualified"])
 },
 "default": {
 "default": "unqualified"
 }
 },

changeset 1768	691083b5682a
parent 1767	c74815729afd
child 1774	ac0fe8aabb5e