1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 

     4 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5 #based on the plcopen standard. 

     6 #

     7 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8 #

     9 #See COPYING file for copyrights details.

    10 #

    11 #This library is free software; you can redistribute it and/or

    12 #modify it under the terms of the GNU General Public

    13 #License as published by the Free Software Foundation; either

    14 #version 2.1 of the License, or (at your option) any later version.

    15 #

    16 #This library is distributed in the hope that it will be useful,

    17 #but WITHOUT ANY WARRANTY; without even the implied warranty of

    18 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19 #General Public License for more details.

    20 #

    21 #You should have received a copy of the GNU General Public

    22 #License along with this library; if not, write to the Free Software

    23 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24 

    25 from xml.dom import minidom

    26 from types import *

    27 import re, datetime

    28 from xmlclass import *

    29 

    30 def GenerateDictFacets(facets):

    31     return dict([(name, (None, False)) for name in facets])

    32 

    33 def GenerateSimpleTypeXMLText(function):

    34     def generateXMLTextMethod(value, name = None, indent = 0):

    35         text = ""

    36         if name is not None:

    37             ind1, ind2 = getIndent(indent, name)

    38             text += ind1 + "<%s>"%name

    39         text += function(value)

    40         if name is not None:

    41             text += "</%s>\n"%name

    42         return text

    43     return generateXMLTextMethod

    44 

    45 def GenerateFloatXMLText(extra_values = []):

    46     def generateXMLTextMethod(value, name = None, indent = 0):

    47         text = ""

    48         if name is not None:

    49             ind1, ind2 = getIndent(indent, name)

    50             text += ind1 + "<%s>"%name

    51         if value in extra_values or value % 1 != 0 or isinstance(value, IntType):

    52             text += str(value)

    53         else:

    54             text += "%.0f"%value

    55         if name is not None:

    56             text += "</%s>\n"%name

    57         return text

    58     return generateXMLTextMethod

    59         

    60 DEFAULT_FACETS = GenerateDictFacets(["pattern", "whiteSpace", "enumeration"])

    61 NUMBER_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["maxInclusive", "maxExclusive", "minInclusive", "minExclusive"])

    62 DECIMAL_FACETS = GenerateDictFacets(NUMBER_FACETS.keys() + ["totalDigits", "fractionDigits"])

    63 STRING_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["length", "minLength", "maxLength"])

    64 

    65 ALL_FACETS = ["pattern", "whiteSpace", "enumeration", "maxInclusive", 

    66     "maxExclusive", "minInclusive", "minExclusive", "totalDigits", 

    67     "fractionDigits", "length", "minLength", "maxLength"]

    68 

    69 

    70 #-------------------------------------------------------------------------------

    71 #                           Structure reducing functions

    72 #-------------------------------------------------------------------------------

    73 

    74 

    75 # Documentation elements

    76 

    77 def ReduceAppInfo(factory, attributes, elements):

    78     return {"type" : "appinfo", "source" : attributes.get("source", None), 

    79         "content" : "\n".join(elements)}

    80 

    81 

    82 def ReduceDocumentation(factory, attributes, elements):

    83     return {"type" : "documentation", "source" : attributes.get("source", None), 

    84         "language" : attributes.get("lang", "any"), "content" : "\n".join(elements)}

    85 

    86 

    87 def ReduceAnnotation(factory, attributes, elements):

    88     annotations, children = factory.ReduceElements(elements)

    89     annotation = {"type" : "annotation", "appinfo" : [], "documentation" : {}}

    90     for child in children:

    91         if child["type"] == "appinfo":

    92             annotation["appinfo"].append((child["source"], child["content"]))

    93         elif child["type"] == "documentation":

    94             if child["source"] is not None:

    95                 text = "(source : %(source)s):\n%(content)s\n\n"%child

    96             else:

    97                 text = child["content"] + "\n\n"

    98             if child["language"] not in annotation["documentation"]:

    99                 annotation["documentation"] = text

   100             else:

   101                 annotation["documentation"] += text

   102     return annotation

   103 

   104 # Simple type elements

   105 

   106 def GenerateFacetReducing(facetname, canbefixed):

   107     def ReduceFacet(factory, attributes, elements):

   108         annotations, children = factory.ReduceElements(elements)

   109         if "value" in attributes:

   110             facet = {"type" : facetname, "value" : attributes["value"], "doc" : annotations}

   111             if canbefixed:

   112                 facet["fixed"] = attributes.get("fixed", False)

   113             return facet

   114         raise ValueError, "A value must be defined for the \"%s\" facet!"%facetname

   115     return ReduceFacet

   116 

   117 

   118 def ReduceList(factory, attributes, elements):

   119     annotations, children = factory.ReduceElements(elements)

   120     list = {"type" : "list", "itemType" : attributes.get("itemType", None), "doc" : annotations}

   121     

   122     if len(children) > 0 and children[0]["type"] == SIMPLETYPE:

   123         if list["itemType"] is None:

   124             list["itemType"] = children[0]

   125         else:

   126             raise ValueError, "Only one base type can be defined for restriction!"

   127     if list["itemType"] is None:

   128         raise ValueError, "No base type has been defined for list!"

   129     return list

   130 

   131 

   132 def ReduceUnion(factory, attributes, elements):

   133     annotations, children = factory.ReduceElements(elements)

   134     union = {"type" : "union", "memberTypes" : attributes.get("memberTypes", []), "doc" : annotations}

   135     

   136     if child in children:

   137         if child["type"] == SIMPLETYPE:

   138             union["memberTypes"] = child

   139     if len(union["memberTypes"]) == 0:

   140         raise ValueError, "No base type has been defined for union!"

   141     return list

   142 

   143 

   144 def ReduceSimpleType(factory, attributes, elements):

   145     # Reduce all the simple type children

   146     annotations, children = factory.ReduceElements(elements)

   147     

   148     typeinfos = children[0]

   149     

   150     # Initialize type informations

   151     facets = {}

   152     simpleType = {"type" : SIMPLETYPE, "final" : attributes.get("final", []), "doc" : annotations}

   153     if "name" in attributes:

   154         simpleType["name"] = attributes["name"]

   155     

   156     if typeinfos["type"] == "restriction":

   157         # Search for base type definition

   158         if isinstance(typeinfos["base"], (StringType, UnicodeType)):

   159             basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)

   160             if basetypeinfos is None:

   161                 raise "\"%s\" isn't defined!"%typeinfos["base"] 

   162         else:

   163             basetypeinfos = typeinfos["base"]

   164         

   165         # Check that base type is a simple type

   166         if basetypeinfos["type"] != SIMPLETYPE:

   167             raise ValueError, "Base type given isn't a simpleType!"

   168         

   169         typeinfos["basename"] = basetypeinfos["basename"]

   170         

   171         # Check that derivation is allowed

   172         if "final" in basetypeinfos:

   173             if "#all" in basetypeinfos["final"]:

   174                 raise ValueError, "Base type can't be derivated!"

   175             if "restriction" in basetypeinfos["final"]:

   176                 raise ValueError, "Base type can't be derivated by restriction!"

   177         

   178         # Extract simple type facets

   179         for facet in typeinfos["facets"]:

   180             facettype = facet["type"]

   181             if facettype not in basetypeinfos["facets"]:

   182                 raise ValueError, "\"%s\" facet can't be defined for \"%s\" type!"%(facettype, type)

   183             elif basetypeinfos["facets"][facettype][1]:

   184                 raise ValueError, "\"%s\" facet is fixed on base type!"%facettype

   185             value = facet["value"]

   186             basevalue = basetypeinfos["facets"][facettype][0]

   187             if facettype == "enumeration":

   188                 value = basetypeinfos["extract"](value, False)

   189                 if len(facets) == 0:

   190                     facets["enumeration"] = ([value], False)

   191                     continue

   192                 elif facets.keys() == ["enumeration"]:

   193                     facets["enumeration"][0].append(value)

   194                     continue

   195                 else:

   196                     raise ValueError, "\"enumeration\" facet can't be defined with another facet type!"

   197             elif "enumeration" in facets:

   198                 raise ValueError, "\"enumeration\" facet can't be defined with another facet type!"

   199             elif facettype in facets:

   200                 raise ValueError, "\"%s\" facet can't be defined two times!"%facettype

   201             elif facettype == "length":

   202                 if "minLength" in facets:

   203                     raise ValueError, "\"length\" and \"minLength\" facets can't be defined at the same time!"

   204                 if "maxLength" in facets:

   205                     raise ValueError, "\"length\" and \"maxLength\" facets can't be defined at the same time!"

   206                 try:

   207                     value = int(value)

   208                 except:

   209                     raise ValueError, "\"length\" must be an integer!"

   210                 if value < 0:

   211                     raise ValueError, "\"length\" can't be negative!"

   212                 elif basevalue is not None and basevalue != value:

   213                     raise ValueError, "\"length\" can't be different from \"length\" defined in base type!"

   214             elif facettype == "minLength":

   215                 if "length" in facets:

   216                     raise ValueError, "\"length\" and \"minLength\" facets can't be defined at the same time!"

   217                 try:

   218                     value = int(value)

   219                 except:

   220                     raise ValueError, "\"minLength\" must be an integer!"

   221                 if value < 0:

   222                     raise ValueError, "\"minLength\" can't be negative!"

   223                 elif "maxLength" in facets and value > facets["maxLength"]:

   224                     raise ValueError, "\"minLength\" must be lesser than or equal to \"maxLength\"!"

   225                 elif basevalue is not None and basevalue < value:

   226                     raise ValueError, "\"minLength\" can't be lesser than \"minLength\" defined in base type!"

   227             elif facettype == "maxLength":

   228                 if "length" in facets:

   229                     raise ValueError, "\"length\" and \"maxLength\" facets can't be defined at the same time!"

   230                 try:

   231                     value = int(value)

   232                 except:

   233                     raise ValueError, "\"maxLength\" must be an integer!"

   234                 if value < 0:

   235                     raise ValueError, "\"maxLength\" can't be negative!"

   236                 elif "minLength" in facets and value < facets["minLength"]:

   237                     raise ValueError, "\"minLength\" must be lesser than or equal to \"maxLength\"!"

   238                 elif basevalue is not None and basevalue > value:

   239                     raise ValueError, "\"maxLength\" can't be greater than \"maxLength\" defined in base type!"

   240             elif facettype == "minInclusive":

   241                 if "minExclusive" in facets:

   242                     raise ValueError, "\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!"

   243                 value = basetypeinfos["extract"](facet["value"], False)

   244                 if "maxInclusive" in facets and value > facets["maxInclusive"][0]:

   245                     raise ValueError, "\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!"

   246                 elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:

   247                     raise ValueError, "\"minInclusive\" must be lesser than \"maxExclusive\"!"

   248             elif facettype == "minExclusive":

   249                 if "minInclusive" in facets:

   250                     raise ValueError, "\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!"

   251                 value = basetypeinfos["extract"](facet["value"], False)

   252                 if "maxInclusive" in facets and value >= facets["maxInclusive"][0]:

   253                     raise ValueError, "\"minExclusive\" must be lesser than \"maxInclusive\"!"

   254                 elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:

   255                     raise ValueError, "\"minExclusive\" must be lesser than \"maxExclusive\"!"

   256             elif facettype == "maxInclusive":

   257                 if "maxExclusive" in facets:

   258                     raise ValueError, "\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!"

   259                 value = basetypeinfos["extract"](facet["value"], False)

   260                 if "minInclusive" in facets and value < facets["minInclusive"][0]:

   261                     raise ValueError, "\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!"

   262                 elif "minExclusive" in facets and value <= facets["minExclusive"][0]:

   263                     raise ValueError, "\"minExclusive\" must be lesser than \"maxInclusive\"!"

   264             elif facettype == "maxExclusive":

   265                 if "maxInclusive" in facets:

   266                     raise ValueError, "\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!"

   267                 value = basetypeinfos["extract"](facet["value"], False)

   268                 if "minInclusive" in facets and value <= facets["minInclusive"][0]:

   269                     raise ValueError, "\"minInclusive\" must be lesser than \"maxExclusive\"!"

   270                 elif "minExclusive" in facets and value <= facets["minExclusive"][0]:

   271                     raise ValueError, "\"minExclusive\" must be lesser than \"maxExclusive\"!"

   272             elif facettype == "whiteSpace":

   273                 if basevalue == "collapse" and value in ["preserve", "replace"] or basevalue == "replace" and value == "preserve":

   274                    raise ValueError, "\"whiteSpace\" is incompatible with \"whiteSpace\" defined in base type!"

   275             elif facettype == "totalDigits":

   276                 if "fractionDigits" in facets and value <= facets["fractionDigits"][0]:

   277                     raise ValueError, "\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!"

   278                 elif basevalue is not None and value > basevalue:

   279                     raise ValueError, "\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!"

   280             elif facettype == "fractionDigits":

   281                 if "totalDigits" in facets and value <= facets["totalDigits"][0]:

   282                     raise ValueError, "\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!"

   283                 elif basevalue is not None and value > basevalue:

   284                     raise ValueError, "\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!"

   285             facets[facettype] = (value, facet.get("fixed", False))

   286         

   287         # Report not redefined facet from base type to new created type 

   288         for facettype, facetvalue in basetypeinfos["facets"].items():

   289             if facettype not in facets:

   290                 facets[facettype] = facetvalue

   291         

   292         # Generate extract value for new created type

   293         def ExtractSimpleTypeValue(attr, extract = True):

   294             value = basetypeinfos["extract"](attr, extract)

   295             for facetname, (facetvalue, facetfixed) in facets.items():

   296                 if facetvalue is not None:

   297                     if facetname == "enumeration" and value not in facetvalue:

   298                         raise ValueError, "\"%s\" not in enumerated values"%value

   299                     elif facetname == "length" and len(value) != facetvalue:

   300                         raise ValueError, "value must have a length of %d"%facetvalue

   301                     elif facetname == "minLength" and len(value) < facetvalue:

   302                         raise ValueError, "value must have a length of %d at least"%facetvalue

   303                     elif facetname == "maxLength" and len(value) > facetvalue:

   304                         raise ValueError, "value must have a length of %d at most"%facetvalue

   305                     elif facetname == "minInclusive" and value < facetvalue:

   306                         raise ValueError, "value must be greater than or equal to %s"%str(facetvalue)

   307                     elif facetname == "minExclusive" and value <= facetvalue:

   308                         raise ValueError, "value must be greater than %s"%str(facetvalue)

   309                     elif facetname == "maxInclusive" and value > facetvalue:

   310                         raise ValueError, "value must be lesser than or equal to %s"%str(facetvalue)

   311                     elif facetname == "maxExclusive"  and value >= facetvalue:

   312                         raise ValueError, "value must be lesser than %s"%str(facetvalue)

   313                     elif facetname == "pattern":

   314                         model = re.compile("(?:%s)?$"%facetvalue)

   315                         result = model.match(value)

   316                         if result is None:

   317                             raise ValueError, "value doesn't follow the pattern %s"%facetvalue

   318                     elif facetname == "whiteSpace":

   319                         if facetvalue == "replace":

   320                             value = GetNormalizedString(value, False)

   321                         elif facetvalue == "collapse":

   322                             value = GetToken(value, False)

   323             return value

   324         

   325         def CheckSimpleTypeValue(value):

   326             for facetname, (facetvalue, facetfixed) in facets.items():

   327                 if facetvalue is not None:

   328                     if facetname == "enumeration" and value not in facetvalue:

   329                         return False

   330                     elif facetname == "length" and len(value) != facetvalue:

   331                         return False

   332                     elif facetname == "minLength" and len(value) < facetvalue:

   333                         return False

   334                     elif facetname == "maxLength" and len(value) > facetvalue:

   335                         return False

   336                     elif facetname == "minInclusive" and value < facetvalue:

   337                         return False

   338                     elif facetname == "minExclusive" and value <= facetvalue:

   339                         return False

   340                     elif facetname == "maxInclusive" and value > facetvalue:

   341                         return False

   342                     elif facetname == "maxExclusive"  and value >= facetvalue:

   343                         return False

   344                     elif facetname == "pattern":

   345                         model = re.compile("(?:%s)?$"%facetvalue)

   346                         result = model.match(value)

   347                         if result is None:

   348                             raise ValueError, "value doesn't follow the pattern %s"%facetvalue

   349             return True

   350         

   351         def SimpleTypeInitialValue():

   352             for facetname, (facetvalue, facetfixed) in facets.items():

   353                 if facetvalue is not None:

   354                     if facetname == "enumeration":

   355                         return facetvalue[0]

   356                     elif facetname == "length":

   357                         return " "*facetvalue

   358                     elif facetname == "minLength":

   359                         return " "*minLength

   360                     elif facetname == "minInclusive" and facetvalue > 0:

   361                         return facetvalue

   362                     elif facetname == "minExclusive" and facetvalue >= 0:

   363                         return facetvalue + 1

   364                     elif facetname == "maxInclusive" and facetvalue < 0:

   365                         return facetvalue

   366                     elif facetname == "maxExclusive"  and facetvalue <= 0:

   367                         return facetvalue - 1

   368             return basetypeinfos["initial"]()

   369         

   370         GenerateSimpleType = basetypeinfos["generate"]

   371         

   372     elif typeinfos["type"] == "list":

   373         # Search for item type definition

   374         if isinstance(typeinfos["itemType"], (StringType, UnicodeType)):

   375             itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)

   376             if itemtypeinfos is None:

   377                 raise "\"%s\" isn't defined!"%typeinfos["itemType"]

   378         else:

   379             itemtypeinfos = typeinfos["itemType"]

   380         

   381         # Check that item type is a simple type

   382         if itemtypeinfos["type"] != SIMPLETYPE:

   383             raise ValueError, "Item type given isn't a simpleType!"

   384         

   385         # Check that derivation is allowed

   386         if "#all" in itemtypeinfos["final"]:

   387             raise ValueError, "Item type can't be derivated!"

   388         if "list" in itemtypeinfos["final"]:

   389             raise ValueError, "Item type can't be derivated by list!"

   390         

   391         # Generate extract value for new created type

   392         def ExtractSimpleTypeValue(attr, extract = True):

   393             values = []

   394             for value in GetToken(attr, extract).split(" "):

   395                 values.append(itemtypeinfos["extract"](value, False))

   396             return values

   397         

   398         def CheckSimpleTypeValue(value):

   399             for value in GetToken(attr, extract).split(" "):

   400                 result = itemtypeinfos["check"](value)

   401                 if not result:

   402                     return result

   403             return True

   404         

   405         SimpleTypeInitialValue = lambda: ""

   406         

   407         GenerateSimpleType = GenerateSimpleTypeXMLText(lambda x : " ".join(map(itemtypeinfos, values)))

   408         

   409         facets = GenerateDictFacets(["length", "maxLength", "minLength", "enumeration", "pattern"])

   410         facet["whiteSpace"] = ("collapse", False)

   411     

   412     elif typeinfos["type"] == "union":

   413         # Search for member types definition

   414         membertypesinfos = []

   415         for membertype in typeinfos["memberTypes"]:

   416             if isinstance(membertype, (StringType, UnicodeType)):

   417                 infos = factory.FindSchemaElement(typeinfos["memberTypes"], SIMPLETYPE)

   418                 if infos is None:

   419                     raise "\"%s\" isn't defined!"%typeinfos["itemType"]

   420             else:

   421                 infos = membertype

   422             

   423             # Check that member type is a simple type

   424             if infos["type"] != SIMPLETYPE:

   425                 raise ValueError, "Member type given isn't a simpleType!"

   426             

   427             # Check that derivation is allowed

   428             if "#all" in infos["final"]:

   429                 raise ValueError, "Item type can't be derivated!"

   430             if "union" in infos["final"]:

   431                 raise ValueError, "Member type can't be derivated by union!"

   432             

   433             membertypesinfos.append(infos)

   434         

   435         # Generate extract value for new created type

   436         def ExtractSimpleTypeValue(attr, extract = True):

   437             if extract:

   438                 value = GetAttributeValue(attr)

   439             else:

   440                 value = attr

   441             for infos in membertypesinfos:

   442                 try:

   443                     return infos["extract"](attr, False)

   444                 except:

   445                     pass

   446             raise ValueError, "\"%s\" isn't valid for type defined for union!"

   447         

   448         def CheckSimpleTypeValue(value):

   449             for infos in membertypesinfos:

   450                 result = infos["check"](value)

   451                 if result:

   452                     return result

   453             return False

   454         

   455         SimpleTypeInitialValue = membertypesinfos[0]["initial"]

   456         

   457         def GenerateSimpleTypeFunction(value):

   458             if isinstance(value, BooleanType):

   459                 return {True : "true", False : "false"}[value]

   460             else:

   461                 return str(value)

   462         GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)

   463         

   464         facets = GenerateDictFacets(["pattern", "enumeration"])

   465     

   466     simpleType["facets"] = facets

   467     simpleType["extract"] = ExtractSimpleTypeValue

   468     simpleType["initial"] = SimpleTypeInitialValue

   469     simpleType["check"] = CheckSimpleTypeValue

   470     simpleType["generate"] = GenerateSimpleType

   471     return simpleType

   472 

   473 

   474 # Complex type

   475 

   476 def ExtractAttributes(factory, elements, base = None):

   477     if base is not None:

   478         basetypeinfos = factory.FindSchemaElement(base, COMPLEXTYPE)

   479         if isinstance(basetypeinfos, (UnicodeType, StringType)):

   480             attrnames = {}

   481         else:

   482             attrnames = dict(map(lambda x:(x["name"], True), basetypeinfos["attributes"]))

   483     else:

   484         attrnames = {}

   485     attrs = []

   486     for element in elements:

   487         if element["type"] == ATTRIBUTE:

   488             if attrnames.get(element["name"], False):

   489                 raise ValueError, "\"%s\" attribute has been defined two times!"%element["name"]

   490             else:

   491                 attrnames[element["name"]] = True

   492                 attrs.append(element)

   493         elif element["type"] == "attributeGroup":

   494             attrgroup = factory.FindSchemaElement(element["ref"], ATTRIBUTESGROUP)

   495             for attr in attrgroup["attributes"]:

   496                 if attrnames.get(attr["name"], False):

   497                     raise ValueError, "\"%s\" attribute has been defined two times!"%attr["name"]

   498                 else:

   499                     attrnames[attr["name"]] = True

   500                     attrs.append(attr)

   501         elif element["type"] == "anyAttribute":

   502             raise ValueError, "\"anyAttribute\" element isn't supported yet!"

   503     return attrs

   504 

   505 

   506 def ReduceRestriction(factory, attributes, elements):

   507     annotations, children = factory.ReduceElements(elements)

   508     restriction = {"type" : "restriction", "base" : attributes.get("base", None), "facets" : [], "doc" : annotations}

   509     if len(children) > 0 and children[0]["type"] == SIMPLETYPE:

   510         if restriction["base"] is None:

   511             restriction["base"] = children.pop(0)

   512         else:

   513             raise ValueError, "Only one base type can be defined for restriction!"

   514     if restriction["base"] is None:

   515         raise ValueError, "No base type has been defined for restriction!"

   516     

   517     while len(children) > 0 and children[0]["type"] in ALL_FACETS:

   518         restriction["facets"].append(children.pop(0))

   519     restriction["attributes"] = ExtractAttributes(factory, children)

   520     return restriction

   521 

   522 

   523 def ReduceExtension(factory, attributes, elements):

   524     annotations, children = factory.ReduceElements(elements)

   525     extension = {"type" : "extension", "attributes" : [], "elements" : [], "base" : attributes.get("base", None), "doc" : annotations}

   526     if len(children) > 0:

   527         if children[0]["type"] in ["group", "all", CHOICE, "sequence"]:

   528             group = children.pop(0)

   529             if group["type"] in ["all", "sequence"]:

   530                 extension["elements"] = group["elements"]

   531                 extension["order"] = group["order"]

   532             elif group["type"] == CHOICE:

   533                 content = group.copy()

   534                 content["name"] = "content"

   535                 extension["elements"].append(content)

   536             elif group["type"] == "group":

   537                 elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

   538                 if "elements" in elmtgroup:

   539                     extension["elements"] = elmtgroup["elements"]

   540                     extension["order"] = elmtgroup["order"]

   541                 else:

   542                     content = elmtgroup.copy()

   543                     content["name"] = "content"

   544                     extension["elements"].append(content)

   545         extension["attributes"] = ExtractAttributes(factory, children, extension["base"])

   546     return extension

   547 

   548 

   549 def ReduceSimpleContent(factory, attributes, elements):

   550     annotations, children = factory.ReduceElements(elements)

   551     simpleContent = children[0].copy()

   552     simpleContent["type"] = "simpleContent"

   553     return simpleContent

   554 

   555 

   556 def ReduceComplexContent(factory, attributes, elements):

   557     annotations, children = factory.ReduceElements(elements)

   558     complexContent = children[0].copy()

   559     complexContent["type"] = "complexContent"

   560     return complexContent

   561 

   562 

   563 def ReduceComplexType(factory, attributes, elements):

   564     annotations, children = factory.ReduceElements(elements)

   565         

   566     if len(children) > 0:

   567         if children[0]["type"] in ["simpleContent", "complexContent"]:

   568             complexType = children[0].copy()

   569             complexType.update(attributes)

   570             complexType["type"] = COMPLEXTYPE

   571             return complexType

   572         elif children[0]["type"] in ["group", "all", CHOICE, "sequence"]:

   573             complexType = {"type" : COMPLEXTYPE, "elements" : [], "order" : True, "doc" : annotations}

   574             complexType.update(attributes)

   575             group = children.pop(0)

   576             if group["type"] in ["all", "sequence"]:

   577                 if group["minOccurs"] == 0 or group["maxOccurs"] != 1:

   578                     if len(group["elements"]) > 1:

   579                         raise ValueError, "Not supported yet!"

   580                     if group["minOccurs"] == 0:

   581                         group["elements"][0]["minOccurs"] = group["minOccurs"]

   582                     if group["maxOccurs"] != 1:

   583                         group["elements"][0]["maxOccurs"] = group["maxOccurs"]

   584                 complexType["elements"] = group["elements"]

   585                 complexType["order"] = group["order"]

   586             elif group["type"] == CHOICE:

   587                 content = group.copy()

   588                 content["name"] = "content"

   589                 complexType["elements"].append(content)

   590             elif group["type"] == "group":

   591                 elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

   592                 if "elements" in elmtgroup:

   593                     complexType["elements"] = elmtgroup["elements"]

   594                     complexType["order"] = elmtgroup["order"]

   595                 else:

   596                     content = elmtgroup.copy()

   597                     content["name"] = "content"

   598                     complexType["elements"].append(content)

   599         else:

   600             complexType = {"elements" : [], "order" : True, "doc" : annotations}

   601             complexType.update(attributes)

   602             complexType["type"] = COMPLEXTYPE

   603         complexType["attributes"] = ExtractAttributes(factory, children)

   604         return complexType

   605     else:

   606         raise ValueError, "\"ComplexType\" can't be empty!"

   607 

   608 

   609 # Attribute elements

   610 

   611 def ReduceAnyAttribute(factory, attributes, elements):

   612     return {"type" : "anyAttribute"}

   613 

   614 

   615 def ReduceAttribute(factory, attributes, elements):

   616     annotations, children = factory.ReduceElements(elements)

   617     

   618     if "default" in attributes:

   619         if "fixed" in attributes:

   620             raise ValueError, "\"default\" and \"fixed\" can't be defined at the same time!"

   621         elif attributes.get("use", "optional") != "optional":

   622             raise ValueError, "if \"default\" present, \"use\" can only have the value \"optional\"!"

   623     

   624     attribute = {"type" : ATTRIBUTE, "attr_type" : attributes.get("type", None), "doc" : annotations}

   625     if len(children) > 0:

   626         if attribute["attr_type"] is None:

   627             attribute["attr_type"] = children[0]

   628         else:

   629             raise ValueError, "Only one type can be defined for attribute!"

   630     

   631     if "ref" in attributes:

   632         if "name" in attributes:

   633             raise ValueError, "\"ref\" and \"name\" can't be defined at the same time!"

   634         elif "form" in attributes:

   635             raise ValueError, "\"ref\" and \"form\" can't be defined at the same time!"

   636         elif attribute["attr_type"] is not None:

   637             raise ValueError, "if \"ref\" is present, no type can be defined!"

   638     elif attribute["attr_type"] is None:

   639         raise ValueError, "No type has been defined for attribute!"

   640     

   641     if "type" in attributes:

   642         tmp_attrs = attributes.copy()

   643         tmp_attrs.pop("type")

   644         attribute.update(tmp_attrs)

   645     else:

   646         attribute.update(attributes)

   647     return attribute

   648 

   649 

   650 def ReduceAttributeGroup(factory, attributes, elements):

   651     annotations, children = factory.ReduceElements(elements)

   652     if "ref" in attributes:

   653         return {"type" : "attributeGroup", "ref" : attributes["ref"], "doc" : annotations}

   654     else:

   655         return {"type" : ATTRIBUTESGROUP, "attributes" : ExtractAttributes(factory, children), "doc" : annotations}

   656 

   657 

   658 # Elements groups

   659 

   660 def ReduceAny(factory, attributes, elements):

   661     annotations, children = factory.ReduceElements(elements)

   662     

   663     any = {"type" : ANY, "doc" : annotations}

   664     any.update(attributes)

   665     return any

   666 

   667 def ReduceElement(factory, attributes, elements):

   668     if "default" in attributes and "fixed" in attributes:

   669         raise ValueError, "\"default\" and \"fixed\" can't be defined at the same time!"

   670     

   671     if "ref" in attributes:

   672         annotations, children = factory.ReduceElements(elements)

   673         

   674         for attr in ["name", "default", "fixed", "form", "block", "type"]:

   675             if attr in attributes:

   676                 raise ValueError, "\"ref\" and \"%s\" can't be defined at the same time!"%attr

   677         if attributes.get("nillable", False):

   678             raise ValueError, "\"ref\" and \"nillable\" can't be defined at the same time!"

   679         if len(children) > 0:

   680             raise ValueError, "No type and no constraints can be defined where \"ref\" is defined!"

   681     

   682         infos = factory.FindSchemaElement(attributes["ref"], ELEMENT)

   683         if infos is not None:

   684             element = infos.copy()

   685             element["minOccurs"] = attributes["minOccurs"]

   686             element["maxOccurs"] = attributes["maxOccurs"]

   687             return element

   688         else:

   689             raise ValueError, "\"%s\" base type isn't defined or circular referenced!"%name

   690     

   691     elif "name" in attributes:

   692         annotations, children = factory.ReduceElements(elements)

   693         

   694         element = {"type" : ELEMENT, "elmt_type" : attributes.get("type", None), "doc" : annotations}

   695         if len(children) > 0:

   696             if element["elmt_type"] is None:

   697                 element["elmt_type"] = children[0]

   698             else:

   699                 raise ValueError, "Only one type can be defined for attribute!"

   700         elif element["elmt_type"] is None:

   701             element["elmt_type"] = "tag"

   702             element["type"] = TAG

   703         

   704         if "type" in attributes:

   705             tmp_attrs = attributes.copy()

   706             tmp_attrs.pop("type")

   707             element.update(tmp_attrs)

   708         else:

   709             element.update(attributes)

   710         return element

   711     else:

   712         raise ValueError, "\"Element\" must have at least a \"ref\" or a \"name\" defined!"

   713 

   714 def ReduceAll(factory, attributes, elements):

   715     annotations, children = factory.ReduceElements(elements)

   716     

   717     for child in children:

   718         if children["maxOccurs"] == "unbounded" or children["maxOccurs"] > 1:

   719             raise ValueError, "\"all\" item can't have \"maxOccurs\" attribute greater than 1!"

   720     

   721     return {"type" : "all", "elements" : children, "minOccurs" : attributes["minOccurs"],

   722         "maxOccurs" : attributes["maxOccurs"], "order" : False, "doc" : annotations}

   723 

   724 

   725 def ReduceChoice(factory, attributes, elements):

   726     annotations, children = factory.ReduceElements(elements)

   727     

   728     choices = []

   729     for child in children:

   730         if child["type"] in [ELEMENT, ANY, TAG]:

   731             choices.append(child)

   732         elif child["type"] == "sequence":

   733             raise ValueError, "\"sequence\" in \"choice\" is not supported. Create instead a new complex type!"

   734         elif child["type"] == CHOICE:

   735             choices.extend(child["choices"])

   736         elif child["type"] == "group":

   737             elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP) 

   738             if "choices" not in elmtgroup:

   739                 raise ValueError, "Only group composed of \"choice\" can be referenced in \"choice\" element!"

   740             choices_tmp = []

   741             for choice in elmtgroup["choices"]:

   742                 if not isinstance(choice["elmt_type"], (UnicodeType, StringType)) and choice["elmt_type"]["type"] == COMPLEXTYPE:

   743                     elmt_type = "%s_%s"%(elmtgroup["name"], choice["name"])

   744                     if factory.TargetNamespace is not None:

   745                         elmt_type = "%s:%s"%(factory.TargetNamespace, elmt_type)

   746                     new_choice = choice.copy()

   747                     new_choice["elmt_type"] = elmt_type

   748                     choices_tmp.append(new_choice)

   749                 else:

   750                     choices_tmp.append(choice)

   751             choices.extend(choices_tmp)

   752     

   753     return {"type" : CHOICE, "choices" : choices, "minOccurs" : attributes["minOccurs"],

   754         "maxOccurs" : attributes["maxOccurs"], "doc" : annotations}

   755 

   756 

   757 def ReduceSequence(factory, attributes, elements):

   758     annotations, children = factory.ReduceElements(elements)

   759     

   760     sequence = []

   761     for child in children:

   762         if child["type"] in [ELEMENT, ANY, TAG]:

   763             sequence.append(child)

   764         elif child["type"] == CHOICE:

   765             content = child.copy()

   766             content["name"] = "content"

   767             sequence.append(content)

   768         elif child["type"] == "sequence":

   769             sequence.extend(child["elements"])

   770         elif child["type"] == "group":

   771             elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

   772             if "elements" not in elmtgroup or not elmtgroup["order"]:

   773                 raise ValueError, "Only group composed of \"sequence\" can be referenced in \"sequence\" element!"

   774             elements_tmp = []

   775             for element in elmtgroup["elements"]:

   776                 if not isinstance(element["elmt_type"], (UnicodeType, StringType)) and element["elmt_type"]["type"] == COMPLEXTYPE:

   777                     elmt_type = "%s_%s"%(elmtgroup["name"], element["name"])

   778                     if factory.TargetNamespace is not None:

   779                         elmt_type = "%s:%s"%(factory.TargetNamespace, elmt_type)

   780                     new_element = element.copy()

   781                     new_element["elmt_type"] = elmt_type

   782                     elements_tmp.append(new_element)

   783                 else:

   784                     elements_tmp.append(element)

   785             sequence.extend(elements_tmp)

   786             

   787     return {"type" : "sequence", "elements" : sequence, "minOccurs" : attributes["minOccurs"],

   788         "maxOccurs" : attributes["maxOccurs"], "order" : True, "doc" : annotations}

   789     

   790     

   791 def ReduceGroup(factory, attributes, elements):

   792     annotations, children = factory.ReduceElements(elements)

   793     

   794     if "ref" in attributes:

   795         return {"type" : "group", "ref" : attributes["ref"], "doc" : annotations}

   796     else:

   797         element = children[0]

   798         group = {"type" : ELEMENTSGROUP, "doc" : annotations}

   799         if element["type"] == CHOICE:

   800             group["choices"] = element["choices"]

   801         else:

   802             group.update({"elements" : element["elements"], "order" : group["order"]})

   803         group.update(attributes)

   804         return group

   805 

   806 # Constraint elements

   807 

   808 def ReduceUnique(factory, attributes, elements):

   809     annotations, children = factory.ReduceElements(elements)

   810     raise ValueError, "\"unique\" element isn't supported yet!"

   811 

   812 def ReduceKey(factory, attributes, elements):

   813     annotations, children = factory.ReduceElements(elements)

   814     raise ValueError, "\"key\" element isn't supported yet!"

   815     

   816 def ReduceKeyRef(factory, attributes, elements):

   817     annotations, children = factory.ReduceElements(elements)

   818     raise ValueError, "\"keyref\" element isn't supported yet!"

   819     

   820 def ReduceSelector(factory, attributes, elements):

   821     annotations, children = factory.ReduceElements(elements)

   822     raise ValueError, "\"selector\" element isn't supported yet!"

   823 

   824 def ReduceField(factory, attributes, elements):

   825     annotations, children = factory.ReduceElements(elements)

   826     raise ValueError, "\"field\" element isn't supported yet!"

   827     

   828 

   829 # Inclusion elements

   830 

   831 def ReduceImport(factory, attributes, elements):

   832     annotations, children = factory.ReduceElements(elements)

   833     raise ValueError, "\"import\" element isn't supported yet!"

   834 

   835 def ReduceInclude(factory, attributes, elements):

   836     annotations, children = factory.ReduceElements(elements)

   837     raise ValueError, "\"include\" element isn't supported yet!"

   838     

   839 def ReduceRedefine(factory, attributes, elements):

   840     annotations, children = factory.ReduceElements(elements)

   841     raise ValueError, "\"redefine\" element isn't supported yet!"

   842 

   843 

   844 # Schema element

   845 

   846 def ReduceSchema(factory, attributes, elements):

   847     factory.AttributeFormDefault = attributes["attributeFormDefault"]

   848     factory.ElementFormDefault = attributes["elementFormDefault"]

   849     factory.BlockDefault = attributes["blockDefault"]

   850     factory.FinalDefault = attributes["finalDefault"]

   851     

   852     if "targetNamespace" in attributes:

   853         factory.TargetNamespace = factory.DefinedNamespaces.get(attributes["targetNamespace"], None)

   854     factory.Namespaces[factory.TargetNamespace] = {}

   855     

   856     annotations, children = factory.ReduceElements(elements, True)

   857     

   858     for child in children:

   859         if "name" in child:

   860             infos = factory.GetQualifiedNameInfos(child["name"], factory.TargetNamespace, True)

   861             if infos is None:

   862                 factory.Namespaces[factory.TargetNamespace][child["name"]] = child

   863             elif not CompareSchema(infos, child):

   864                 raise ValueError, "\"%s\" is defined twice in targetNamespace!"%child["name"]

   865 

   866 def CompareSchema(schema, reference):

   867     if isinstance(schema, ListType):

   868         if not isinstance(reference, ListType) or len(schema) != len(reference):

   869             return False

   870         for i, value in enumerate(schema):

   871             result = CompareSchema(value, reference[i])

   872             if not result:

   873                 return result

   874         return True

   875     elif isinstance(schema, DictType):

   876         if not isinstance(reference, DictType) or len(schema) != len(reference):

   877             return False

   878         for name, value in schema.items():

   879             ref_value = reference.get(name, None)

   880             if ref_value is None:

   881                 return False

   882             result = CompareSchema(value, ref_value)

   883             if not result:

   884                 return result

   885         return True

   886     elif isinstance(schema, FunctionType):

   887         if not isinstance(reference, FunctionType) or schema.__name__ != reference.__name__:

   888             return False

   889         else:

   890             return True

   891     return schema == reference

   892     

   893 #-------------------------------------------------------------------------------

   894 #                       Base class for XSD schema extraction

   895 #-------------------------------------------------------------------------------

   896 

   897 

   898 class XSDClassFactory(ClassFactory):

   899 

   900     def __init__(self, document, debug = False):

   901         ClassFactory.__init__(self, document, debug)

   902         self.Namespaces["xml"] = {

   903             "lang" : {

   904                 "type" : SYNTAXATTRIBUTE, 

   905                 "extract" : {

   906                     "default" : GenerateEnumeratedExtraction("lang", LANGUAGES)

   907                 }

   908             }

   909         }

   910         self.Namespaces["xsi"] = {

   911             "noNamespaceSchemaLocation" : {

   912                 "type" : SYNTAXATTRIBUTE, 

   913                 "extract" : {

   914                     "default" : NotSupportedYet("noNamespaceSchemaLocation")

   915                 }

   916             },

   917             "nil" : {

   918                 "type" : SYNTAXATTRIBUTE, 

   919                 "extract" : {

   920                     "default" : NotSupportedYet("nil")

   921                 }

   922             },

   923             "schemaLocation" : {

   924                 "type" : SYNTAXATTRIBUTE, 

   925                 "extract" : {

   926                     "default" : NotSupportedYet("schemaLocation")

   927                 }

   928             },

   929             "type" : {

   930                 "type" : SYNTAXATTRIBUTE, 

   931                 "extract" : {

   932                     "default" : NotSupportedYet("type")

   933                 }

   934             }

   935         }

   936         

   937     def ParseSchema(self):

   938         schema = self.Document.childNodes[0]

   939         for qualified_name, attr in schema._attrs.items():

   940             value = GetAttributeValue(attr)

   941             if value == "http://www.w3.org/2001/XMLSchema":

   942                 namespace, name = DecomposeQualifiedName(qualified_name)

   943                 if namespace == "xmlns":

   944                     self.DefinedNamespaces["http://www.w3.org/2001/XMLSchema"] = name

   945                     self.SchemaNamespace = name

   946                 else:

   947                     self.DefinedNamespaces["http://www.w3.org/2001/XMLSchema"] = self.SchemaNamespace

   948                 self.Namespaces[self.SchemaNamespace] = XSD_NAMESPACE

   949         self.Schema = XSD_NAMESPACE["schema"]["extract"]["default"](self, schema)

   950         ReduceSchema(self, self.Schema[1], self.Schema[2])

   951 

   952     def FindSchemaElement(self, element_name, element_type):

   953         namespace, name = DecomposeQualifiedName(element_name)

   954         element = self.GetQualifiedNameInfos(name, namespace, True)

   955         if element is None and namespace == self.TargetNamespace and name not in self.CurrentCompilations:

   956             self.CurrentCompilations.append(name)

   957             element = self.CreateSchemaElement(name, element_type)

   958             self.CurrentCompilations.pop(-1)

   959             if element is not None:

   960                 self.Namespaces[self.TargetNamespace][name] = element

   961         if element is None:

   962             if name in self.CurrentCompilations:

   963                 if self.Debug:

   964                     print "Warning : \"%s\" is circular referenced!"%element_name

   965                 return element_name

   966             else:

   967                 raise ValueError, "\"%s\" isn't defined!"%element_name

   968         if element["type"] != element_type:

   969             raise ValueError, "\"%s\" isn't a group!"%element_name

   970         return element

   971     

   972     def CreateSchemaElement(self, element_name, element_type):

   973         for type, attributes, elements in self.Schema[2]:

   974             namespace, name = DecomposeQualifiedName(type)

   975             if "name" in attributes and attributes["name"] == element_name:

   976                 element_infos = None

   977                 if element_type == ATTRIBUTE and name == "attribute":

   978                     element_infos = ReduceAttribute(self, attributes, elements)

   979                 elif element_type == ELEMENT and name == "element":

   980                     element_infos = ReduceElement(self, attributes, elements)

   981                 elif element_type == ATTRIBUTESGROUP and name == "attributeGroup":

   982                     element_infos = ReduceAttributeGroup(self, attributes, elements)

   983                 elif element_type == ELEMENTSGROUP and name == "group":

   984                     element_infos = ReduceGroup(self, attributes, elements)

   985                 elif element_type == SIMPLETYPE and name == "simpleType":

   986                     element_infos = ReduceSimpleType(self, attributes, elements)

   987                 elif element_type == COMPLEXTYPE and name == "complexType":

   988                     element_infos = ReduceComplexType(self, attributes, elements)

   989                 if element_infos is not None:

   990                     self.Namespaces[self.TargetNamespace][element_name] = element_infos

   991                     return element_infos

   992         return None

   993 

   994 """

   995 This function opens the xsd file and generate the classes from the xml tree

   996 """

   997 def GenerateClassesFromXSD(filename, declare = False):

   998     xsdfile = open(filename, 'r')

   999     factory = XSDClassFactory(minidom.parse(xsdfile))

  1000     xsdfile.close()

  1001     factory.ParseSchema()

  1002     return GenerateClasses(factory, declare)

  1003 

  1004 """

  1005 This function generate the classes from the xsd given as a string

  1006 """

  1007 def GenerateClassesFromXSDstring(xsdstring, declare = False):

  1008     factory = XSDClassFactory(minidom.parseString(xsdstring))

  1009     factory.ParseSchema()

  1010     return GenerateClasses(factory, declare)

  1011 

  1012 

  1013 #-------------------------------------------------------------------------------

  1014 #                           XSD schema syntax elements

  1015 #-------------------------------------------------------------------------------

  1016 

  1017 XSD_NAMESPACE = {

  1018 

  1019 #-------------------------------------------------------------------------------

  1020 #                           Syntax elements definition

  1021 #-------------------------------------------------------------------------------

  1022 

  1023     "all" : {"struct" : """

  1024         <all

  1025           id = ID

  1026           maxOccurs = 1 : 1

  1027           minOccurs = (0 | 1) : 1

  1028           {any attributes with non-schema namespace . . .}>

  1029           Content: (annotation?, element*)

  1030         </all>""",

  1031         "type" : SYNTAXELEMENT, 

  1032         "extract" : {

  1033             "default" : GenerateElement("all", ["id", "maxOccurs", "minOccurs"], 

  1034                 re.compile("((?:annotation )?(?:element )*)"))

  1035         },

  1036         "reduce" : ReduceAll

  1037     },

  1038 

  1039     "annotation" : {"struct" : """

  1040         <annotation

  1041           id = ID

  1042           {any attributes with non-schema namespace . . .}>

  1043           Content: (appinfo | documentation)*

  1044         </annotation>""",

  1045         "type" : SYNTAXELEMENT, 

  1046         "extract" : {

  1047             "default" : GenerateElement("annotation", ["id"], 

  1048                 re.compile("((?:app_info |documentation )*)"))

  1049         },

  1050         "reduce" : ReduceAnnotation

  1051     },

  1052 

  1053     "any" : {"struct": """

  1054         <any

  1055           id = ID

  1056           maxOccurs = (nonNegativeInteger | unbounded)  : 1

  1057           minOccurs = nonNegativeInteger : 1

  1058           namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) )  : ##any

  1059           processContents = (lax | skip | strict) : strict

  1060           {any attributes with non-schema namespace . . .}>

  1061           Content: (annotation?)

  1062         </any>""",

  1063         "type" : SYNTAXELEMENT, 

  1064         "extract" : {

  1065             "default" : GenerateElement("any", 

  1066                 ["id", "maxOccurs", "minOccurs", "namespace", "processContents"], 

  1067                 re.compile("((?:annotation )?(?:simpleType )*)"))

  1068         },

  1069         "reduce" : ReduceAny

  1070     },

  1071 

  1072     "anyAttribute" : {"struct" : """

  1073         <anyAttribute

  1074           id = ID

  1075           namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) )  : ##any

  1076           processContents = (lax | skip | strict) : strict

  1077           {any attributes with non-schema namespace . . .}>

  1078           Content: (annotation?)

  1079         </anyAttribute>""",

  1080         "type" : SYNTAXELEMENT, 

  1081         "extract" : {

  1082             "default" : GenerateElement("anyAttribute",

  1083                 ["id", "namespace", "processContents"], ONLY_ANNOTATION)

  1084         },

  1085         "reduce" : ReduceAnyAttribute

  1086     },

  1087 

  1088     "appinfo" : {"struct" : """

  1089         <appinfo

  1090           source = anyURI

  1091           {any attributes with non-schema namespace . . .}>

  1092           Content: ({any})*

  1093         </appinfo>""",

  1094         "type" : SYNTAXELEMENT, 

  1095         "extract" : {

  1096             "default" : GenerateElement("appinfo", ["source"], re.compile("(.*)"), True)

  1097         },

  1098         "reduce" : ReduceAppInfo

  1099     },

  1100 

  1101     "attribute" : {"struct" : """

  1102         <attribute

  1103           default = string

  1104           fixed = string

  1105           form = (qualified | unqualified)

  1106           id = ID

  1107           name = NCName

  1108           ref = QName

  1109           type = QName

  1110           use = (optional | prohibited | required) : optional

  1111           {any attributes with non-schema namespace . . .}>

  1112           Content: (annotation?, simpleType?)

  1113         </attribute>""",

  1114         "type" : SYNTAXELEMENT, 

  1115         "extract" : {

  1116             "default" : GenerateElement("attribute", 

  1117                 ["default", "fixed", "form", "id", "name", "ref", "type", "use"], 

  1118                 re.compile("((?:annotation )?(?:simpleType )?)")),

  1119             "schema" : GenerateElement("attribute", 

  1120                 ["default", "fixed", "form", "id", "name", "type"], 

  1121                 re.compile("((?:annotation )?(?:simpleType )?)"))

  1122         },

  1123         "reduce" : ReduceAttribute

  1124     },

  1125 

  1126     "attributeGroup" : {"struct" : """

  1127         <attributeGroup

  1128           id = ID

  1129           name = NCName

  1130           ref = QName

  1131           {any attributes with non-schema namespace . . .}>

  1132           Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))

  1133         </attributeGroup>""",

  1134         "type" : SYNTAXELEMENT, 

  1135         "extract" : {

  1136             "default" : GenerateElement("attributeGroup",