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 import os, re

    26 import datetime

    27 from xml.dom import minidom

    28 from types import *

    29 

    30 from xmlclass import *

    31 

    32 def GenerateDictFacets(facets):

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

    34 

    35 def GenerateSimpleTypeXMLText(function):

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

    37         text = ""

    38         if name is not None:

    39             ind1, ind2 = getIndent(indent, name)

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

    41         text += function(value)

    42         if name is not None:

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

    44         return text

    45     return generateXMLTextMethod

    46 

    47 def GenerateFloatXMLText(extra_values=[]):

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

    49         text = ""

    50         if name is not None:

    51             ind1, ind2 = getIndent(indent, name)

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

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

    54             text += str(value)

    55         else:

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

    57         if name is not None:

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

    59         return text

    60     return generateXMLTextMethod

    61         

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

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

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

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

    66 

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

    68     "maxExclusive", "minInclusive", "minExclusive", "totalDigits", 

    69     "fractionDigits", "length", "minLength", "maxLength"]

    70 

    71 

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

    73 #                           Structure reducing functions

    74 #-------------------------------------------------------------------------------

    75 

    76 

    77 # Documentation elements

    78 

    79 def ReduceAppInfo(factory, attributes, elements):

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

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

    82 

    83 

    84 def ReduceDocumentation(factory, attributes, elements):

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

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

    87 

    88 

    89 def ReduceAnnotation(factory, attributes, elements):

    90     annotations, children = factory.ReduceElements(elements)

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

    92     for child in children:

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

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

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

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

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

    98             else:

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

   100             if not annotation["documentation"].has_key(child["language"]):

   101                 annotation["documentation"] = text

   102             else:

   103                 annotation["documentation"] += text

   104     return annotation

   105 

   106 # Simple type elements

   107 

   108 def GenerateFacetReducing(facetname, canbefixed):

   109     def ReduceFacet(factory, attributes, elements):

   110         annotations, children = factory.ReduceElements(elements)

   111         if attributes.has_key("value"):

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

   113             if canbefixed:

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

   115             return facet

   116         raise ValueError("A value must be defined for the \"%s\" facet!" % facetname)

   117     return ReduceFacet

   118 

   119 

   120 def ReduceList(factory, attributes, elements):

   121     annotations, children = factory.ReduceElements(elements)

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

   123     

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

   125         if list["itemType"] is None:

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

   127         else:

   128             raise ValueError("Only one base type can be defined for restriction!")

   129     if list["itemType"] is None:

   130         raise ValueError("No base type has been defined for list!")

   131     return list

   132 

   133 

   134 def ReduceUnion(factory, attributes, elements):

   135     annotations, children = factory.ReduceElements(elements)

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

   137     

   138     for child in children:

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

   140             union["memberTypes"].appendchild

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

   142         raise ValueError("No base type has been defined for union!")

   143     return union

   144 

   145 

   146 def CreateSimpleType(factory, attributes, typeinfos):

   147     # Initialize type informations

   148     facets = {}

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

   150     if attributes.has_key("name"):

   151         simpleType["name"] = attributes["name"]

   152     

   153     if typeinfos["type"] in ["restriction", "extension"]:

   154         # Search for base type definition

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

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

   157             if basetypeinfos is None:

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

   159         else:

   160             basetypeinfos = typeinfos["base"]

   161         

   162         # Check that base type is a simple type

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

   164             raise ValueError("Base type given isn't a simpleType!")

   165         

   166         simpleType["basename"] = basetypeinfos["basename"]

   167         

   168         # Check that derivation is allowed

   169         if basetypeinfos.has_key("final"):

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

   171                 raise ValueError("Base type can't be derivated!")

   172             if "restriction" in basetypeinfos["final"] and typeinfos["type"] == "restriction":

   173                 raise ValueError("Base type can't be derivated by restriction!")

   174         

   175         # Extract simple type facets

   176         for facet in typeinfos.get("facets", []):

   177             facettype = facet["type"]

   178             if not basetypeinfos["facets"].has_key(facettype):

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

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

   181                 raise ValueError("\"%s\" facet is fixed on base type!" % facettype)

   182             value = facet["value"]

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

   184             if facettype in ["enumeration", "pattern"]:

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

   186                 if len(facets) == 0:

   187                     facets[facettype] = ([value], False)

   188                     continue

   189                 elif facets.keys() == [facettype]:

   190                     facets[facettype][0].append(value)

   191                     continue

   192                 else:

   193                     raise ValueError("\"%s\" facet can't be defined with another facet type!" % facettype)

   194             elif facets.has_key("enumeration"):

   195                 raise ValueError("\"enumeration\" facet can't be defined with another facet type!")

   196             elif facets.has_key("pattern"):

   197                 raise ValueError("\"pattern\" facet can't be defined with another facet type!")

   198             elif facets.has_key(facettype):

   199                 raise ValueError("\"%s\" facet can't be defined two times!" % facettype)

   200             elif facettype == "length":

   201                 if facets.has_key("minLength"):

   202                     raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")

   203                 if facets.has_key("maxLength"):

   204                     raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")

   205                 try:

   206                     value = int(value)

   207                 except:

   208                     raise ValueError("\"length\" must be an integer!")

   209                 if value < 0:

   210                     raise ValueError("\"length\" can't be negative!")

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

   212                     raise ValueError("\"length\" can't be different from \"length\" defined in base type!")

   213             elif facettype == "minLength":

   214                 if facets.has_key("length"):

   215                     raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")

   216                 try:

   217                     value = int(value)

   218                 except:

   219                     raise ValueError("\"minLength\" must be an integer!")

   220                 if value < 0:

   221                     raise ValueError("\"minLength\" can't be negative!")

   222                 elif facets.has_key("maxLength") and value > facets["maxLength"]:

   223                     raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")

   224                 elif basevalue is not None and basevalue < value:

   225                     raise ValueError("\"minLength\" can't be lesser than \"minLength\" defined in base type!")

   226             elif facettype == "maxLength":

   227                 if facets.has_key("length"):

   228                     raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")

   229                 try:

   230                     value = int(value)

   231                 except:

   232                     raise ValueError("\"maxLength\" must be an integer!")

   233                 if value < 0:

   234                     raise ValueError("\"maxLength\" can't be negative!")

   235                 elif facets.has_key("minLength") and value < facets["minLength"]:

   236                     raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")

   237                 elif basevalue is not None and basevalue > value:

   238                     raise ValueError("\"maxLength\" can't be greater than \"maxLength\" defined in base type!")

   239             elif facettype == "minInclusive":

   240                 if facets.has_key("minExclusive"):

   241                     raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")

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

   243                 if facets.has_key("maxInclusive") and value > facets["maxInclusive"][0]:

   244                     raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")

   245                 elif facets.has_key("maxExclusive") and value >= facets["maxExclusive"][0]:

   246                     raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")

   247             elif facettype == "minExclusive":

   248                 if facets.has_key("minInclusive"):

   249                     raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")

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

   251                 if facets.has_key("maxInclusive") and value >= facets["maxInclusive"][0]:

   252                     raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")

   253                 elif facets.has_key("maxExclusive") and value >= facets["maxExclusive"][0]:

   254                     raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

   255             elif facettype == "maxInclusive":

   256                 if facets.has_key("maxExclusive"):

   257                     raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")

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

   259                 if facets.has_key("minInclusive") and value < facets["minInclusive"][0]:

   260                     raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")

   261                 elif facets.has_key("minExclusive") and value <= facets["minExclusive"][0]:

   262                     raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")

   263             elif facettype == "maxExclusive":

   264                 if facets.has_key("maxInclusive"):

   265                     raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")

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

   267                 if facets.has_key("minInclusive") and value <= facets["minInclusive"][0]:

   268                     raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")

   269                 elif facets.has_key("minExclusive") and value <= facets["minExclusive"][0]:

   270                     raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

   271             elif facettype == "whiteSpace":

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

   273                    raise ValueError("\"whiteSpace\" is incompatible with \"whiteSpace\" defined in base type!")

   274             elif facettype == "totalDigits":

   275                 if facets.has_key("fractionDigits") and value <= facets["fractionDigits"][0]:

   276                     raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")

   277                 elif basevalue is not None and value > basevalue:

   278                     raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")

   279             elif facettype == "fractionDigits":

   280                 if facets.has_key("totalDigits") and value <= facets["totalDigits"][0]:

   281                     raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")

   282                 elif basevalue is not None and value > basevalue:

   283                     raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")

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

   285         

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

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

   288             if not facets.has_key(facettype):

   289                 facets[facettype] = facetvalue

   290         

   291         # Generate extract value for new created type

   292         def ExtractSimpleTypeValue(attr, extract=True):

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

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

   295                 if facetvalue is not None:

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

   297                         raise ValueError("\"%s\" not in enumerated values" % value)

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

   299                         raise ValueError("value must have a length of %d" % facetvalue)

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

   301                         raise ValueError("value must have a length of %d at least" % facetvalue)

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

   303                         raise ValueError("value must have a length of %d at most" % facetvalue)

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

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

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

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

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

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

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

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

   312                     elif facetname == "pattern":

   313                         model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))

   314                         result = model.match(value)

   315                         if result is None:

   316                             if len(facetvalue) > 1:   

   317                                 raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))

   318                             else:

   319                                 raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])

   320                     elif facetname == "whiteSpace":

   321                         if facetvalue == "replace":

   322                             value = GetNormalizedString(value, False)

   323                         elif facetvalue == "collapse":

   324                             value = GetToken(value, False)

   325             return value

   326         

   327         def CheckSimpleTypeValue(value):

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

   329                 if facetvalue is not None:

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

   331                         return False

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

   333                         return False

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

   335                         return False

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

   337                         return False

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

   339                         return False

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

   341                         return False

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

   343                         return False

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

   345                         return False

   346                     elif facetname == "pattern":

   347                         model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))

   348                         result = model.match(value)

   349                         if result is None:

   350                             if len(facetvalue) > 1:   

   351                                 raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))

   352                             else:

   353                                 raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])

   354             return True

   355         

   356         def SimpleTypeInitialValue():

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

   358                 if facetvalue is not None:

   359                     if facetname == "enumeration":

   360                         return facetvalue[0]

   361                     elif facetname == "length":

   362                         return " "*facetvalue

   363                     elif facetname == "minLength":

   364                         return " "*minLength

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

   366                         return facetvalue

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

   368                         return facetvalue + 1

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

   370                         return facetvalue

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

   372                         return facetvalue - 1

   373             return basetypeinfos["initial"]()

   374         

   375         GenerateSimpleType = basetypeinfos["generate"]

   376         

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

   378         # Search for item type definition

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

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

   381             if itemtypeinfos is None:

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

   383         else:

   384             itemtypeinfos = typeinfos["itemType"]

   385         

   386         # Check that item type is a simple type

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

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

   389         

   390         simpleType["basename"] = "list"

   391         

   392         # Check that derivation is allowed

   393         if itemtypeinfos.has_key("final"):

   394             if itemtypeinfos["final"].has_key("#all"):

   395                 raise ValueError("Item type can't be derivated!")

   396             if itemtypeinfos["final"].has_key("list"):

   397                 raise ValueError("Item type can't be derivated by list!")

   398         

   399         # Generate extract value for new created type

   400         def ExtractSimpleTypeValue(attr, extract = True):

   401             values = []

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

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

   404             return values

   405         

   406         def CheckSimpleTypeValue(value):

   407             for item in value:

   408                 result = itemtypeinfos["check"](item)

   409                 if not result:

   410                     return result

   411             return True

   412         

   413         SimpleTypeInitialValue = lambda: []

   414         

   415         GenerateSimpleType = GenerateSimpleTypeXMLText(lambda x: " ".join(map(itemtypeinfos["generate"], x)))

   416         

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

   418         facets["whiteSpace"] = ("collapse", False)

   419     

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

   421         # Search for member types definition

   422         membertypesinfos = []

   423         for membertype in typeinfos["memberTypes"]:

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

   425                 infos = factory.FindSchemaElement(membertype, SIMPLETYPE)

   426                 if infos is None:

   427                     raise ValueError("\"%s\" isn't defined!" % membertype)

   428             else:

   429                 infos = membertype

   430             

   431             # Check that member type is a simple type

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

   433                 raise ValueError("Member type given isn't a simpleType!")

   434             

   435             # Check that derivation is allowed

   436             if infos.has_key("final"):

   437                 if infos["final"].has_key("#all"):

   438                     raise ValueError("Item type can't be derivated!")

   439                 if infos["final"].has_key("union"):

   440                     raise ValueError("Member type can't be derivated by union!")

   441             

   442             membertypesinfos.append(infos)

   443         

   444         simpleType["basename"] = "union"

   445         

   446         # Generate extract value for new created type

   447         def ExtractSimpleTypeValue(attr, extract = True):

   448             if extract:

   449                 value = GetAttributeValue(attr)

   450             else:

   451                 value = attr

   452             for infos in membertypesinfos:

   453                 try:

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

   455                 except:

   456                     pass

   457             raise ValueError("\"%s\" isn't valid for type defined for union!")

   458         

   459         def CheckSimpleTypeValue(value):

   460             for infos in membertypesinfos:

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

   462                 if result:

   463                     return result

   464             return False

   465         

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

   467         

   468         def GenerateSimpleTypeFunction(value):

   469             if isinstance(value, BooleanType):

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

   471             else:

   472                 return str(value)

   473         GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)

   474         

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

   476     

   477     simpleType["facets"] = facets

   478     simpleType["extract"] = ExtractSimpleTypeValue

   479     simpleType["initial"] = SimpleTypeInitialValue

   480     simpleType["check"] = CheckSimpleTypeValue

   481     simpleType["generate"] = GenerateSimpleType

   482     return simpleType

   483 

   484 def ReduceSimpleType(factory, attributes, elements):

   485     # Reduce all the simple type children

   486     annotations, children = factory.ReduceElements(elements)

   487     

   488     simpleType = CreateSimpleType(factory, attributes, children[0])

   489     simpleType["doc"] = annotations

   490     

   491     return simpleType

   492 

   493 # Complex type

   494 

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

   496     attrs = []

   497     attrnames = {}

   498     if base is not None:

   499         basetypeinfos = factory.FindSchemaElement(base)

   500         if not isinstance(basetypeinfos, (UnicodeType, StringType)) and basetypeinfos["type"] == COMPLEXTYPE:

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

   502         

   503     for element in elements:

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

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

   506                 raise ValueError("\"%s\" attribute has been defined two times!" % element["name"])

   507             else:

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

   509                 attrs.append(element)

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

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

   512             for attr in attrgroup["attributes"]:

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

   514                     raise ValueError("\"%s\" attribute has been defined two times!" % attr["name"])

   515                 else:

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

   517                     attrs.append(attr)

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

   519             raise ValueError("\"anyAttribute\" element isn't supported yet!")

   520     return attrs

   521 

   522 

   523 def ReduceRestriction(factory, attributes, elements):

   524     annotations, children = factory.ReduceElements(elements)

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

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

   527         if restriction["base"] is None:

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

   529         else:

   530             raise ValueError("Only one base type can be defined for restriction!")

   531     if restriction["base"] is None:

   532         raise ValueError("No base type has been defined for restriction!")

   533     

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

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

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

   537     return restriction

   538 

   539 

   540 def ReduceExtension(factory, attributes, elements):

   541     annotations, children = factory.ReduceElements(elements)

   542     if not attributes.has_key("base"):

   543         raise ValueError("No base type has been defined for extension!")

   544     extension = {"type": "extension", "attributes": [], "elements": [], "base": attributes["base"], "doc": annotations}

   545     if len(children) > 0:

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

   547             group = children.pop(0)

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

   549                 extension["elements"] = group["elements"]

   550                 extension["order"] = group["order"]

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

   552                 content = group.copy()

   553                 content["name"] = "content"

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

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

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

   557                 if elmtgroup.has_key("elements"):

   558                     extension["elements"] = elmtgroup["elements"]

   559                     extension["order"] = elmtgroup["order"]

   560                 else:

   561                     content = elmtgroup.copy()

   562                     content["name"] = "content"

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

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

   565     return extension

   566 

   567 

   568 def ReduceSimpleContent(factory, attributes, elements):

   569     annotations, children = factory.ReduceElements(elements)

   570     

   571     simpleContent = children[0].copy()

   572     

   573     basetypeinfos = factory.FindSchemaElement(simpleContent["base"])

   574     if basetypeinfos["type"] == SIMPLETYPE:

   575         contenttypeinfos = simpleContent.copy()

   576         simpleContent.pop("base")

   577     elif basetypeinfos["type"] == COMPLEXTYPE and \

   578          len(basetypeinfos["elements"]) == 1 and \

   579          basetypeinfos["elements"][0]["name"] == "content" and \

   580          basetypeinfos["elements"][0].has_key("elmt_type") and \

   581          basetypeinfos["elements"][0]["elmt_type"]["type"] == SIMPLETYPE:

   582         contenttypeinfos = simpleContent.copy()

   583         contenttypeinfos["base"] = basetypeinfos["elements"][0]["elmt_type"]

   584     else:

   585         raise ValueError("No compatible base type defined for simpleContent!")

   586     contenttypeinfos = CreateSimpleType(factory, attributes, contenttypeinfos)

   587     

   588     simpleContent["elements"] = [{"name": "content", "type": ELEMENT,

   589                                   "elmt_type": contenttypeinfos, "doc": annotations,

   590                                   "minOccurs": 1, "maxOccurs": 1}]

   591     simpleContent["type"] = "simpleContent"

   592     return simpleContent

   593 

   594 

   595 def ReduceComplexContent(factory, attributes, elements):

   596     annotations, children = factory.ReduceElements(elements)

   597     complexContent = children[0].copy()

   598     complexContent["type"] = "complexContent"

   599     return complexContent

   600 

   601 

   602 def ReduceComplexType(factory, attributes, elements):

   603     annotations, children = factory.ReduceElements(elements)

   604     

   605     if len(children) > 0:

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

   607             complexType = children[0].copy()

   608             complexType.update(attributes)

   609             complexType["type"] = COMPLEXTYPE

   610             return complexType

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

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

   613             complexType.update(attributes)

   614             group = children.pop(0)

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

   616                 choice_number = 0

   617                 for element in group["elements"]:

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

   619                         choice_number += 1

   620                 if (group["minOccurs"] == 0 or group["maxOccurs"] != 1) and len(group["elements"]) > 1 or choice_number > 1:

   621                     content = {"type": CHOICE, "name": "content", "choices": [group], "minOccurs": 1, "maxOccurs": 1}

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

   623                 else:

   624                     if len(group["elements"]) == 1:

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

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

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

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

   629                     for element in group["elements"]:

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

   631                             element["name"] = "content"

   632                     complexType["elements"] = group["elements"]

   633                     complexType["order"] = group["order"]

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

   635                 content = group.copy()

   636                 content["name"] = "content"

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

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

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

   640                 if elmtgroup.has_key("elements"):

   641                     complexType["elements"] = elmtgroup["elements"]

   642                     complexType["order"] = elmtgroup["order"]

   643                 else:

   644                     content = elmtgroup.copy()

   645                     content["name"] = "content"

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

   647         else:

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

   649             complexType.update(attributes)

   650             complexType["type"] = COMPLEXTYPE

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

   652         return complexType

   653     else:

   654         raise ValueError("\"ComplexType\" can't be empty!")

   655 

   656 

   657 # Attribute elements

   658 

   659 def ReduceAnyAttribute(factory, attributes, elements):

   660     return {"type" : "anyAttribute"}

   661 

   662 

   663 def ReduceAttribute(factory, attributes, elements):

   664     annotations, children = factory.ReduceElements(elements)

   665     

   666     if attributes.has_key("default"):

   667         if attributes.has_key("fixed"):

   668             raise ValueError("\"default\" and \"fixed\" can't be defined at the same time!")

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

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

   671     

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

   673     if len(children) > 0:

   674         if attribute["attr_type"] is None:

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

   676         else:

   677             raise ValueError("Only one type can be defined for attribute!")

   678     

   679     if attributes.has_key("ref"):

   680         if attributes.has_key("name"):

   681             raise ValueError("\"ref\" and \"name\" can't be defined at the same time!")

   682         elif attributes.has_key("form"):

   683             raise ValueError("\"ref\" and \"form\" can't be defined at the same time!")

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

   685             raise ValueError("if \"ref\" is present, no type can be defined!")

   686     elif attribute["attr_type"] is None:

   687         raise ValueError("No type has been defined for attribute \"%s\"!" % attributes["name"])

   688     

   689     if attributes.has_key("type"):

   690         tmp_attrs = attributes.copy()

   691         tmp_attrs.pop("type")

   692         attribute.update(tmp_attrs)

   693     else:

   694         attribute.update(attributes)

   695     return attribute

   696 

   697 

   698 def ReduceAttributeGroup(factory, attributes, elements):

   699     annotations, children = factory.ReduceElements(elements)

   700     if attributes.has_key("ref"):

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

   702     else:

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

   704 

   705 

   706 # Elements groups

   707 

   708 def ReduceAny(factory, attributes, elements):

   709     annotations, children = factory.ReduceElements(elements)

   710     

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

   712     any.update(attributes)

   713     return any

   714 

   715 def ReduceElement(factory, attributes, elements):

   716     annotations, children = factory.ReduceElements(elements)

   717     

   718     types = []

   719     constraints = []

   720     for child in children:

   721         if child["type"] == CONSTRAINT:

   722             constraints.append(child)

   723         else:

   724             types.append(child)

   725     

   726     if attributes.has_key("default") and attributes.has_key("fixed"):

   727         raise ValueError("\"default\" and \"fixed\" can't be defined at the same time!")

   728     

   729     if attributes.has_key("ref"):

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

   731             if attributes.has_key(attr):

   732                 raise ValueError("\"ref\" and \"%s\" can't be defined at the same time!" % attr)

   733         if attributes.has_key("nillable"):

   734             raise ValueError("\"ref\" and \"nillable\" can't be defined at the same time!")

   735         if len(types) > 0:

   736             raise ValueError("No type and no constraints can be defined where \"ref\" is defined!")

   737     

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

   739         if infos is not None:

   740             element = infos.copy()

   741             element["constraints"] = constraints

   742             element["minOccurs"] = attributes["minOccurs"]

   743             element["maxOccurs"] = attributes["maxOccurs"]

   744             return element

   745         else:

   746             raise ValueError("\"%s\" base type isn't defined or circular referenced!" % name)

   747     

   748     elif attributes.has_key("name"):

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

   750         if len(types) > 0:

   751             if element["elmt_type"] is None:

   752                 element["elmt_type"] = types[0]

   753             else:

   754                 raise ValueError("Only one type can be defined for attribute!")

   755         elif element["elmt_type"] is None:

   756             element["elmt_type"] = "tag"

   757             element["type"] = TAG

   758         

   759         if attributes.has_key("type"):

   760             tmp_attrs = attributes.copy()

   761             tmp_attrs.pop("type")

   762             element.update(tmp_attrs)

   763         else:

   764             element.update(attributes)

   765         return element

   766     else:

   767         raise ValueError("\"Element\" must have at least a \"ref\" or a \"name\" defined!")

   768 

   769 def ReduceAll(factory, attributes, elements):

   770     annotations, children = factory.ReduceElements(elements)

   771     

   772     for child in children:

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

   774             raise ValueError("\"all\" item can't have \"maxOccurs\" attribute greater than 1!")

   775     

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

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

   778 

   779 

   780 def ReduceChoice(factory, attributes, elements):

   781     annotations, children = factory.ReduceElements(elements)

   782     

   783     choices = []

   784     for child in children:

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

   786             choices.append(child)

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

   788             child["minOccurs"] = child["maxOccurs"] = 1

   789             choices.append(child)

   790             #raise ValueError("\"sequence\" in \"choice\" is not supported. Create instead a new complex type!")

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

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

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

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

   795             if not elmtgroup.has_key("choices"):

   796                 raise ValueError("Only group composed of \"choice\" can be referenced in \"choice\" element!")

   797             choices_tmp = []

   798             for choice in elmtgroup["choices"]:

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

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

   801                     if factory.TargetNamespace is not None:

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

   803                     new_choice = choice.copy()

   804                     new_choice["elmt_type"] = elmt_type

   805                     choices_tmp.append(new_choice)

   806                 else:

   807                     choices_tmp.append(choice)

   808             choices.extend(choices_tmp)

   809     

   810     for choice in choices:

   811         attributes["minOccurs"] = min(attributes["minOccurs"], choice["minOccurs"])

   812         choice["minOccurs"] = 1

   813     

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

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

   816 

   817 

   818 def ReduceSequence(factory, attributes, elements):

   819     annotations, children = factory.ReduceElements(elements)

   820     

   821     sequence = []

   822     for child in children:

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

   824             sequence.append(child)

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

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

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

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

   829             if not elmtgroup.has_key("elements") or not elmtgroup["order"]:

   830                 raise ValueError("Only group composed of \"sequence\" can be referenced in \"sequence\" element!")

   831             elements_tmp = []

   832             for element in elmtgroup["elements"]:

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

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

   835                     if factory.TargetNamespace is not None:

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

   837                     new_element = element.copy()

   838                     new_element["elmt_type"] = elmt_type

   839                     elements_tmp.append(new_element)

   840                 else:

   841                     elements_tmp.append(element)

   842             sequence.extend(elements_tmp)

   843             

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

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

   846     

   847     

   848 def ReduceGroup(factory, attributes, elements):

   849     annotations, children = factory.ReduceElements(elements)

   850     

   851     if attributes.has_key("ref"):

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

   853     else:

   854         element = children[0]

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

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

   857             group["choices"] = element["choices"]

   858         else:

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

   860         group.update(attributes)

   861         return group

   862 

   863 # Constraint elements

   864 

   865 def ReduceUnique(factory, attributes, elements):

   866     annotations, children = factory.ReduceElements(elements)

   867     

   868     unique = {"type": CONSTRAINT, "const_type": "unique", "selector": children[0], "fields": children[1:]}

   869     unique.update(attributes)

   870     return unique

   871     

   872 def ReduceKey(factory, attributes, elements):

   873     annotations, children = factory.ReduceElements(elements)

   874     

   875     key = {"type": CONSTRAINT, "const_type": "key", "selector": children[0], "fields": children[1:]}

   876     key.update(attributes)

   877     return key

   878 

   879 def ReduceKeyRef(factory, attributes, elements):

   880     annotations, children = factory.ReduceElements(elements)

   881     

   882     keyref = {"type": CONSTRAINT, "const_type": "keyref", "selector": children[0], "fields": children[1:]}

   883     keyref.update(attributes)

   884     return keyref

   885     

   886 def ReduceSelector(factory, attributes, elements):

   887     annotations, children = factory.ReduceElements(elements)

   888     

   889     selector = {"type": CONSTRAINT, "const_type": "selector"}

   890     selector.update(attributes)

   891     return selector

   892 

   893 def ReduceField(factory, attributes, elements):

   894     annotations, children = factory.ReduceElements(elements)

   895     

   896     field = {"type": CONSTRAINT, "const_type": "field"}

   897     field.update(attributes)

   898     return field

   899     

   900 

   901 # Inclusion elements

   902 

   903 def ReduceImport(factory, attributes, elements):

   904     annotations, children = factory.ReduceElements(elements)

   905     raise ValueError("\"import\" element isn't supported yet!")

   906 

   907 def ReduceInclude(factory, attributes, elements):

   908     annotations, children = factory.ReduceElements(elements)

   909     

   910     if factory.FileName is None:

   911         raise ValueError("Include in XSD string not yet supported")

   912     filepath = attributes["schemaLocation"]

   913     if filepath is not None and not os.path.exists(filepath):

   914         filepath = os.path.join(factory.BaseFolder, filepath)

   915         if not os.path.exists(filepath):

   916             raise ValueError("No file '%s' found for include" % attributes["schemaLocation"])

   917     xsdfile = open(filepath, 'r')

   918     include_factory = XSDClassFactory(minidom.parse(xsdfile), filepath)

   919     xsdfile.close()

   920     include_factory.CreateClasses()

   921     

   922     if factory.TargetNamespace == include_factory.TargetNamespace:

   923         factory.Namespaces[factory.TargetNamespace].update(include_factory.Namespaces[include_factory.TargetNamespace])

   924     else:

   925         factory.Namespaces[include_factory.TargetNamespace] = include_factory.Namespaces[include_factory.TargetNamespace]

   926     factory.ComputedClasses.update(include_factory.ComputedClasses)

   927     return None

   928     

   929 def ReduceRedefine(factory, attributes, elements):

   930     annotations, children = factory.ReduceElements(elements)

   931     raise ValueError("\"redefine\" element isn't supported yet!")

   932 

   933 

   934 # Schema element

   935 

   936 def ReduceSchema(factory, attributes, elements):

   937     factory.AttributeFormDefault = attributes["attributeFormDefault"]

   938     factory.ElementFormDefault = attributes["elementFormDefault"]

   939     factory.BlockDefault = attributes["blockDefault"]

   940     factory.FinalDefault = attributes["finalDefault"]

   941     

   942     if attributes.has_key("targetNamespace"):

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

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

   945     

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

   947     

   948     for child in children:

   949         if child.has_key("name"):

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

   951             if infos is None:

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

   953             elif not CompareSchema(infos, child):

   954                 raise ValueError("\"%s\" is defined twice in targetNamespace!" % child["name"])

   955 

   956 def CompareSchema(schema, reference):

   957     if isinstance(schema, ListType):

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

   959             return False

   960         for i, value in enumerate(schema):

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

   962             if not result:

   963                 return result

   964         return True

   965     elif isinstance(schema, DictType):

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

   967             return False

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

   969             ref_value = reference.get(name, None)

   970             if ref_value is None and value != None:

   971                 return False

   972             result = CompareSchema(value, ref_value)

   973             if not result:

   974                 return result

   975         return True

   976     elif isinstance(schema, FunctionType):

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

   978             return False

   979         else:

   980             return True

   981     return schema == reference

   982     

   983 #-------------------------------------------------------------------------------

   984 #                       Base class for XSD schema extraction

   985 #-------------------------------------------------------------------------------

   986 

   987 

   988 class XSDClassFactory(ClassFactory):

   989 

   990     def __init__(self, document, filepath=None, debug=False):

   991         ClassFactory.__init__(self, document, filepath, debug)

   992         self.Namespaces["xml"] = {

   993             "lang": {

   994                 "type": SYNTAXATTRIBUTE, 

   995                 "extract": {

   996                     "default": GenerateModelNameExtraction("lang", LANGUAGE_model)

   997                 }

   998             }

   999         }

  1000         self.Namespaces["xsi"] = {

  1001             "noNamespaceSchemaLocation": {

  1002                 "type": SYNTAXATTRIBUTE, 

  1003                 "extract": {

  1004                     "default": NotSupportedYet("noNamespaceSchemaLocation")

  1005                 }

  1006             },

  1007             "nil": {

  1008                 "type": SYNTAXATTRIBUTE, 

  1009                 "extract": {

  1010                     "default": NotSupportedYet("nil")

  1011                 }

  1012             },

  1013             "schemaLocation": {

  1014                 "type": SYNTAXATTRIBUTE, 

  1015                 "extract": {

  1016                     "default": NotSupportedYet("schemaLocation")

  1017                 }

  1018             },

  1019             "type": {

  1020                 "type": SYNTAXATTRIBUTE, 

  1021                 "extract": {

  1022                     "default": NotSupportedYet("type")

  1023                 }

  1024             }

  1025         }

  1026         

  1027     def ParseSchema(self):

  1028         for child in self.Document.childNodes:

  1029             if child.nodeType == self.Document.ELEMENT_NODE:

  1030                 schema = child

  1031                 break

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

  1033             value = GetAttributeValue(attr)

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

  1035                 namespace, name = DecomposeQualifiedName(qualified_name)

  1036                 if namespace == "xmlns":

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

  1038                     self.SchemaNamespace = name

  1039                 else:

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

  1041                 self.Namespaces[self.SchemaNamespace] = XSD_NAMESPACE

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

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

  1044 

  1045     def FindSchemaElement(self, element_name, element_type=None):

  1046         namespace, name = DecomposeQualifiedName(element_name)

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

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

  1049             self.CurrentCompilations.append(name)

  1050             element = self.CreateSchemaElement(name, element_type)

  1051             self.CurrentCompilations.pop(-1)

  1052             if element is not None:

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

  1054         if element is None:

  1055             if name in self.CurrentCompilations:

  1056                 if self.Debug:

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

  1058             else:

  1059                 raise ValueError("\"%s\" isn't defined!" % element_name)

  1060         if element_type is not None and element["type"] != element_type:

  1061             raise ValueError("\"%s\" isn't of the expected type!" % element_name)

  1062         return element

  1063     

  1064     def CreateSchemaElement(self, element_name, element_type):

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

  1066             namespace, name = DecomposeQualifiedName(type)

  1067             if attributes.get("name", None) == element_name:

  1068                 element_infos = None

  1069                 if element_type in (ATTRIBUTE, None) and name == "attribute":

  1070                     element_infos = ReduceAttribute(self, attributes, elements)

  1071                 elif element_type in (ELEMENT, None) and name == "element":

  1072                     element_infos = ReduceElement(self, attributes, elements)

  1073                 elif element_type in (ATTRIBUTESGROUP, None) and name == "attributeGroup":

  1074                     element_infos = ReduceAttributeGroup(self, attributes, elements)

  1075                 elif element_type in (ELEMENTSGROUP, None) and name == "group":

  1076                     element_infos = ReduceGroup(self, attributes, elements)

  1077                 elif element_type in (SIMPLETYPE, None) and name == "simpleType":

  1078                     element_infos = ReduceSimpleType(self, attributes, elements)

  1079                 elif element_type in (COMPLEXTYPE, None) and name == "complexType":

  1080                     element_infos = ReduceComplexType(self, attributes, elements)

  1081                 if element_infos is not None:

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

  1083                     return element_infos

  1084         return None

  1085 

  1086 """

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

  1088 """

  1089 def GenerateClassesFromXSD(filepath):

  1090     xsdfile = open(filepath, 'r')

  1091     factory = XSDClassFactory(minidom.parse(xsdfile), filepath)

  1092     xsdfile.close()

  1093     return GenerateClasses(factory)

  1094 

  1095 """

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

  1097 """

  1098 def GenerateClassesFromXSDstring(xsdstring):

  1099     return GenerateClasses(XSDClassFactory(minidom.parseString(xsdstring)))

  1100 

  1101 

  1102 #-------------------------------------------------------------------------------

  1103 #                           XSD schema syntax elements

  1104 #-------------------------------------------------------------------------------

  1105 

  1106 XSD_NAMESPACE = {

  1107 

  1108 #-------------------------------------------------------------------------------

  1109 #                           Syntax elements definition

  1110 #-------------------------------------------------------------------------------

  1111 

  1112     "all": {"struct": """

  1113         <all

  1114           id = ID

  1115           maxOccurs = 1 : 1

  1116           minOccurs = (0 | 1) : 1

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

  1118           Content: (annotation?, element*)

  1119         </all>""",

  1120         "type": SYNTAXELEMENT, 

  1121         "extract": {

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

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

  1124         },

  1125         "reduce": ReduceAll

  1126     },

  1127 

  1128     "annotation": {"struct": """

  1129         <annotation

  1130           id = ID

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

  1132           Content: (appinfo | documentation)*

  1133         </annotation>""",

  1134         "type": SYNTAXELEMENT, 

  1135         "extract": {