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 sys

    26 import re

    27 import datetime

    28 from types import *

    29 from xml.dom import minidom

    30 from xml.sax.saxutils import escape, unescape, quoteattr

    31 from new import classobj

    32 

    33 def CreateNode(name):

    34     node = minidom.Node()

    35     node.nodeName = name

    36     node._attrs = {}

    37     node.childNodes = []

    38     return node

    39 

    40 def NodeRenameAttr(node, old_name, new_name):

    41     node._attrs[new_name] = node._attrs.pop(old_name)

    42 

    43 def NodeSetAttr(node, name, value):

    44     attr = minidom.Attr(name)

    45     text = minidom.Text()

    46     text.data = value

    47     attr.childNodes[0] = text

    48     node._attrs[name] = attr

    49 

    50 """

    51 Regular expression models for checking all kind of string values defined in XML

    52 standard

    53 """

    54 Name_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*)$')

    55 Names_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*(?: [a-zA-Z_\:][\w\.\-\:]*)*)$')

    56 NMToken_model = re.compile('([\w\.\-\:]*)$')

    57 NMTokens_model = re.compile('([\w\.\-\:]*(?: [\w\.\-\:]*)*)$')

    58 QName_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)$')

    59 QNames_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*(?: (?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)*)$')

    60 NCName_model = re.compile('([a-zA-Z_][\w]*)$')

    61 URI_model = re.compile('((?:http://|/)?(?:[\w.-]*/?)*)$')

    62 LANGUAGE_model = re.compile('([a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*)$')

    63 

    64 ONLY_ANNOTATION = re.compile("((?:annotation )?)")

    65 

    66 """

    67 Regular expression models for extracting dates and times from a string

    68 """

    69 time_model = re.compile('([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)(?:Z)?$')

    70 date_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')

    71 datetime_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?$')

    72 

    73 class xml_timezone(datetime.tzinfo):

    74 

    75     def SetOffset(self, offset):

    76         if offset == "Z":

    77             self.__offset = timedelta(minutes = 0)

    78             self.__name = "UTC"

    79         else:

    80             sign = {"-" : -1, "+" : 1}[offset[0]]

    81             hours, minutes = [int(val) for val in offset[1:].split(":")]

    82             self.__offset = timedelta(minutes=sign * (hours * 60 + minutes))

    83             self.__name = ""

    84 

    85     def utcoffset(self, dt):

    86         return self.__offset

    87 

    88     def tzname(self, dt):

    89         return self.__name

    90 

    91     def dst(self, dt):

    92         return ZERO

    93 

    94 [SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE, 

    95  ATTRIBUTESGROUP, ELEMENTSGROUP, ATTRIBUTE, ELEMENT, CHOICE, ANY, TAG

    96 ] = range(12)

    97 

    98 def NotSupportedYet(type):

    99     """

   100     Function that generates a function that point out to user that datatype

   101     used is not supported by xmlclass yet

   102     @param type: data type

   103     @return: function generated

   104     """

   105     def GetUnknownValue(attr):

   106         raise ValueError("\"%s\" type isn't supported by \"xmlclass\" yet!" % \

   107                          type)

   108     return GetUnknownValue

   109 

   110 """

   111 This function calculates the number of whitespace for indentation

   112 """

   113 def getIndent(indent, balise):

   114     first = indent * 2

   115     second = first + len(balise) + 1

   116     return u'\t'.expandtabs(first), u'\t'.expandtabs(second)

   117 

   118 

   119 def GetAttributeValue(attr, extract=True):

   120     """

   121     Function that extracts data from a tree node

   122     @param attr: tree node containing data to extract

   123     @param extract: attr is a tree node or not

   124     @return: data extracted as string

   125     """

   126     if not extract:

   127         return attr

   128     if len(attr.childNodes) == 1:

   129         return unescape(attr.childNodes[0].data.encode())

   130     else:

   131         # content is a CDATA

   132         text = ""

   133         for node in attr.childNodes:

   134             if node.nodeName != "#text":

   135                 text += node.data.encode()

   136         return text

   137 

   138 

   139 def GetNormalizedString(attr, extract=True):

   140     """

   141     Function that normalizes a string according to XML 1.0. Replace  

   142     tabulations, line feed and carriage return by white space

   143     @param attr: tree node containing data to extract or data to normalize

   144     @param extract: attr is a tree node or not

   145     @return: data normalized as string

   146     """

   147     if extract:

   148         value = GetAttributeValue(attr)

   149     else:

   150         value = attr

   151     return value.replace("\t", " ").replace("\r", " ").replace("\n", " ")

   152 

   153 

   154 def GetToken(attr, extract=True):

   155     """

   156     Function that tokenizes a string according to XML 1.0. Remove any leading  

   157     and trailing white space and replace internal sequence of two or more 

   158     spaces by only one white space

   159     @param attr: tree node containing data to extract or data to tokenize

   160     @param extract: attr is a tree node or not

   161     @return: data tokenized as string

   162     """

   163     return " ".join([part for part in 

   164                      GetNormalizedString(attr, extract).split(" ")

   165                      if part])

   166 

   167 

   168 def GetHexInteger(attr, extract=True):

   169     """

   170     Function that extracts an hexadecimal integer from a tree node or a string

   171     @param attr: tree node containing data to extract or data as a string

   172     @param extract: attr is a tree node or not

   173     @return: data as an integer

   174     """

   175     if extract:

   176         value = GetAttributeValue(attr)

   177     else:

   178         value = attr

   179     if len(value) % 2 != 0:

   180         raise ValueError("\"%s\" isn't a valid hexadecimal integer!" % value)

   181     try:

   182         return int(value, 16)

   183     except:

   184         raise ValueError("\"%s\" isn't a valid hexadecimal integer!" % value)

   185 

   186 

   187 def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None, 

   188                               minExclusive=None, maxExclusive=None):

   189     """

   190     Function that generates an extraction function for integer defining min and

   191     max of integer value

   192     @param minInclusive: inclusive minimum

   193     @param maxInclusive: inclusive maximum

   194     @param minExclusive: exclusive minimum

   195     @param maxExclusive: exclusive maximum

   196     @return: function generated

   197     """

   198     def GetInteger(attr, extract=True):

   199         """

   200         Function that extracts an integer from a tree node or a string

   201         @param attr: tree node containing data to extract or data as a string

   202         @param extract: attr is a tree node or not

   203         @return: data as an integer

   204         """

   205 

   206         if extract:

   207             value = GetAttributeValue(attr)

   208         else:

   209             value = attr

   210         try:

   211             # TODO: permit to write value like 1E2

   212             value = int(value)

   213         except:

   214             raise ValueError("\"%s\" isn't a valid integer!" % value)

   215         if minInclusive is not None and value < minInclusive:

   216             raise ValueError("\"%d\" isn't greater or equal to %d!" % \

   217                              (value, minInclusive))

   218         if maxInclusive is not None and value > maxInclusive:

   219             raise ValueError("\"%d\" isn't lesser or equal to %d!" % \

   220                              (value, maxInclusive))

   221         if minExclusive is not None and value <= minExclusive:

   222             raise ValueError("\"%d\" isn't greater than %d!" % \

   223                              (value, minExclusive))

   224         if maxExclusive is not None and value >= maxExclusive:

   225             raise ValueError("\"%d\" isn't lesser than %d!" % \

   226                              (value, maxExclusive))

   227         return value

   228     return GetInteger

   229 

   230 

   231 def GenerateFloatExtraction(type, extra_values=[]):

   232     """

   233     Function that generates an extraction function for float

   234     @param type: name of the type of float

   235     @return: function generated

   236     """

   237     def GetFloat(attr, extract = True):

   238         """

   239         Function that extracts a float from a tree node or a string

   240         @param attr: tree node containing data to extract or data as a string

   241         @param extract: attr is a tree node or not

   242         @return: data as a float

   243         """

   244         if extract:

   245             value = GetAttributeValue(attr)

   246         else:

   247             value = attr

   248         if value in extra_values:

   249             return value

   250         try:

   251             return float(value)

   252         except:

   253             raise ValueError("\"%s\" isn't a valid %s!" % (value, type))

   254     return GetFloat

   255 

   256 

   257 def GetBoolean(attr, extract=True):

   258     """

   259     Function that extracts a boolean from a tree node or a string

   260     @param attr: tree node containing data to extract or data as a string

   261     @param extract: attr is a tree node or not

   262     @return: data as a boolean

   263     """

   264     if extract:

   265         value = GetAttributeValue(attr)

   266     else:

   267         value = attr

   268     if value == "true" or value == "1":

   269         return True

   270     elif value == "false" or value == "0":

   271         return False

   272     else:

   273         raise ValueError("\"%s\" isn't a valid boolean!" % value)

   274 

   275 

   276 def GetTime(attr, extract=True):

   277     """

   278     Function that extracts a time from a tree node or a string

   279     @param attr: tree node containing data to extract or data as a string

   280     @param extract: attr is a tree node or not

   281     @return: data as a time

   282     """

   283     if extract:

   284         value = GetAttributeValue(attr)

   285     else:

   286         value = attr

   287     result = time_model.match(value)

   288     if result:

   289         values = result.groups()

   290         time_values = [int(v) for v in values[:2]]

   291         seconds = float(values[2])

   292         time_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   293         return datetime.time(*time_values)

   294     else:

   295         raise ValueError("\"%s\" isn't a valid time!" % value)

   296 

   297 

   298 def GetDate(attr, extract=True):

   299     """

   300     Function that extracts a date from a tree node or a string

   301     @param attr: tree node containing data to extract or data as a string

   302     @param extract: attr is a tree node or not

   303     @return: data as a date

   304     """

   305     if extract:

   306         value = GetAttributeValue(attr)

   307     else:

   308         value = attr

   309     result = date_model.match(value)

   310     if result:

   311         values = result.groups()

   312         date_values = [int(v) for v in values[:3]]

   313         if values[3] is not None:

   314             tz = xml_timezone()

   315             tz.SetOffset(values[3])

   316             date_values.append(tz)

   317         return datetime.date(*date_values)

   318     else:

   319         raise ValueError("\"%s\" isn't a valid date!" % value)

   320 

   321 

   322 def GetDateTime(attr, extract=True):

   323     """

   324     Function that extracts date and time from a tree node or a string

   325     @param attr: tree node containing data to extract or data as a string

   326     @param extract: attr is a tree node or not

   327     @return: data as date and time

   328     """

   329     if extract:

   330         value = GetAttributeValue(attr)

   331     else:

   332         value = attr

   333     result = datetime_model.match(value)

   334     if result:

   335         values = result.groups()

   336         datetime_values = [int(v) for v in values[:5]]

   337         seconds = float(values[5])

   338         datetime_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   339         if values[6] is not None:

   340             tz = xml_timezone()

   341             tz.SetOffset(values[6])

   342             datetime_values.append(tz)

   343         return datetime.datetime(*datetime_values)

   344     else:

   345         raise ValueError("\"%s\" isn't a valid datetime!" % value)

   346 

   347 

   348 def GenerateModelNameExtraction(type, model):

   349     """

   350     Function that generates an extraction function for string matching a model

   351     @param type: name of the data type

   352     @param model: model that data must match

   353     @return: function generated

   354     """

   355     def GetModelName(attr, extract=True):

   356         """

   357         Function that extracts a string from a tree node or not and check that

   358         string extracted or given match the model

   359         @param attr: tree node containing data to extract or data as a string

   360         @param extract: attr is a tree node or not

   361         @return: data as a string if matching

   362         """

   363         if extract:

   364             value = GetAttributeValue(attr)

   365         else:

   366             value = attr

   367         result = model.match(value)

   368         if not result:

   369             raise ValueError("\"%s\" isn't a valid %s!" % (value, type))

   370         return value

   371     return GetModelName

   372 

   373 

   374 def GenerateLimitExtraction(min=None, max=None, unbounded=True):

   375     """

   376     Function that generates an extraction function for integer defining min and

   377     max of integer value

   378     @param min: minimum limit value

   379     @param max: maximum limit value

   380     @param unbounded: value can be "unbounded" or not

   381     @return: function generated

   382     """

   383     def GetLimit(attr, extract=True):

   384         """

   385         Function that extracts a string from a tree node or not and check that

   386         string extracted or given is in a list of values

   387         @param attr: tree node containing data to extract or data as a string

   388         @param extract: attr is a tree node or not

   389         @return: data as a string

   390         """

   391         if extract:

   392             value = GetAttributeValue(attr)

   393         else:

   394             value = attr

   395         if value == "unbounded":

   396             if unbounded:

   397                 return value

   398             else:

   399                 raise ValueError("Member limit can't be defined to \"unbounded\"!")

   400         try:

   401             limit = int(value)

   402         except:

   403             raise ValueError("\"%s\" isn't a valid value for this member limit!" % value)

   404         if limit < 0:

   405             raise ValueError("Member limit can't be negative!")

   406         elif min is not None and limit < min:

   407             raise ValueError("Member limit can't be lower than \"%d\"!" % min)

   408         elif max is not None and limit > max:

   409             raise ValueError("Member limit can't be upper than \"%d\"!" % max)

   410         return limit

   411     return GetLimit

   412 

   413 

   414 def GenerateEnumeratedExtraction(type, list):

   415     """

   416     Function that generates an extraction function for enumerated values

   417     @param type: name of the data type

   418     @param list: list of possible values

   419     @return: function generated

   420     """

   421     def GetEnumerated(attr, extract=True):

   422         """

   423         Function that extracts a string from a tree node or not and check that

   424         string extracted or given is in a list of values

   425         @param attr: tree node containing data to extract or data as a string

   426         @param extract: attr is a tree node or not

   427         @return: data as a string

   428         """

   429         if extract:

   430             value = GetAttributeValue(attr)

   431         else:

   432             value = attr

   433         if value in list:

   434             return value

   435         else:

   436             raise ValueError("\"%s\" isn't a valid value for %s!" % \

   437                              (value, type))

   438     return GetEnumerated

   439 

   440 

   441 def GetNamespaces(attr, extract=True):

   442     """

   443     Function that extracts a list of namespaces from a tree node or a string

   444     @param attr: tree node containing data to extract or data as a string

   445     @param extract: attr is a tree node or not

   446     @return: list of namespaces

   447     """

   448     if extract:

   449         value = GetAttributeValue(attr)

   450     else:

   451         value = attr

   452     if value == "":

   453         return []

   454     elif value == "##any" or value == "##other":

   455         namespaces = [value]

   456     else:

   457         namespaces = []

   458         for item in value.split(" "):

   459             if item == "##targetNamespace" or item == "##local":

   460                 namespaces.append(item)

   461             else:

   462                 result = URI_model.match(item)

   463                 if result is not None:

   464                     namespaces.append(item)

   465                 else:

   466                     raise ValueError("\"%s\" isn't a valid value for namespace!" % value)

   467     return namespaces

   468 

   469 

   470 def GenerateGetList(type, list):

   471     """

   472     Function that generates an extraction function for a list of values

   473     @param type: name of the data type

   474     @param list: list of possible values

   475     @return: function generated

   476     """

   477     def GetLists(attr, extract=True):

   478         """

   479         Function that extracts a list of values from a tree node or a string

   480         @param attr: tree node containing data to extract or data as a string

   481         @param extract: attr is a tree node or not

   482         @return: list of values

   483         """

   484         if extract:

   485             value = GetAttributeValue(attr)

   486         else:

   487             value = attr

   488         if value == "":

   489             return []

   490         elif value == "#all":

   491             return [value]

   492         else:

   493             values = []

   494             for item in value.split(" "):

   495                 if item in list:

   496                     values.append(item)

   497                 else:

   498                     raise ValueError("\"%s\" isn't a valid value for %s!" % \

   499                                      (value, type))

   500             return values

   501     return GetLists

   502 

   503 

   504 def GenerateModelNameListExtraction(type, model):

   505     """

   506     Function that generates an extraction function for list of string matching

   507     a model

   508     @param type: name of the data type

   509     @param model: model that list elements must match

   510     @return: function generated

   511     """

   512     def GetModelNameList(attr, extract=True):

   513         """

   514         Function that extracts a list of string from a tree node or not and

   515         check that all extracted items match the model

   516         @param attr: tree node containing data to extract or data as a string

   517         @param extract: attr is a tree node or not

   518         @return: data as a list of string if matching 

   519         """

   520         if extract:

   521             value = GetAttributeValue(attr)

   522         else:

   523             value = attr

   524         values = []

   525         for item in value.split(" "):

   526             result = model.match(item)

   527             if result is not None:

   528                 values.append(item)

   529             else:

   530                 raise ValueError("\"%s\" isn't a valid value for %s!" % \

   531                                  (value, type))

   532         return values

   533     return GetModelNameList

   534 

   535 def GenerateAnyInfos():

   536     def ExtractAny(tree):

   537         return tree.data.encode("utf-8")

   538     

   539     def GenerateAny(value, name=None, indent=0):

   540         try:

   541             value = value.decode("utf-8")

   542         except:

   543             pass

   544         return u'<![CDATA[%s]]>\n' % value

   545         

   546     return {

   547         "type": COMPLEXTYPE, 

   548         "extract": ExtractAny,

   549         "generate": GenerateAny,

   550         "initial": lambda: "",

   551         "check": lambda x: isinstance(x, (StringType, UnicodeType))

   552     }

   553 

   554 def GenerateTagInfos(name):

   555     def ExtractTag(tree):

   556         if len(tree._attrs) > 0:

   557             raise ValueError("\"%s\" musn't have attributes!" % name)

   558         if len(tree.childNodes) > 0:

   559             raise ValueError("\"%s\" musn't have children!" % name)

   560         return None

   561     

   562     def GenerateTag(value, name=None, indent=0):

   563         if name is not None:

   564             ind1, ind2 = getIndent(indent, name)

   565             return ind1 + "<%s/>\n" % name

   566         else:

   567             return ""

   568     

   569     return {

   570         "type": TAG, 

   571         "extract": ExtractTag,

   572         "generate": GenerateTag,

   573         "initial": lambda: None,

   574         "check": lambda x: x == None

   575     }

   576     

   577 def GenerateContentInfos(factory, choices):

   578     def GetContentInitial():

   579         content_name, infos = choices[0]

   580         if isinstance(infos["elmt_type"], (UnicodeType, StringType)):

   581             namespace, name = DecomposeQualifiedName(infos["elmt_type"])

   582             infos["elmt_type"] = factory.GetQualifiedNameInfos(name, namespace)

   583         if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:

   584             return {"name": content_name, 

   585                     "value": map(infos["elmt_type"]["initial"], 

   586                                  range(infos["minOccurs"]))}

   587         else:

   588             return {"name": content_name, 

   589                     "value": infos["elmt_type"]["initial"]()}

   590     

   591     def CheckContent(value):

   592         for content_name, infos in choices:

   593             if content_name == value["name"]:

   594                 if isinstance(infos["elmt_type"], (UnicodeType, StringType)):

   595                     namespace, name = DecomposeQualifiedName(infos["elmt_type"])

   596                     infos["elmt_type"] = factory.GetQualifiedNameInfos(name, namespace)

   597                 if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:

   598                     if isinstance(value["value"], ListType) and \

   599                        infos["minOccurs"] <= len(value["value"]) <= infos["maxOccurs"]:

   600                         return reduce(lambda x, y: x and y, 

   601                                       map(infos["elmt_type"]["check"], 

   602                                           value["value"]), 

   603                                       True)

   604                 else:

   605                     return infos["elmt_type"]["check"](value["value"])

   606         return False

   607         

   608     def ExtractContent(tree, content):

   609         for content_name, infos in choices:

   610             if content_name == tree.nodeName:

   611                 if isinstance(infos["elmt_type"], (UnicodeType, StringType)):

   612                     namespace, name = DecomposeQualifiedName(infos["elmt_type"])

   613                     infos["elmt_type"] = factory.GetQualifiedNameInfos(name, namespace)

   614                 if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:

   615                     if isinstance(content, ListType) and len(content) > 0 and \

   616                        content[-1]["name"] == content_name:

   617                         content_item = content.pop(-1)

   618                         content_item["value"].append(infos["elmt_type"]["extract"](tree))

   619                         return content_item

   620                     elif not isinstance(content, ListType) and \

   621                          content is not None and \

   622                          content["name"] == content_name:

   623                         return {"name": content_name, 

   624                                 "value": content["value"] + \

   625                                          [infos["elmt_type"]["extract"](tree)]}

   626                     else:

   627                         return {"name": content_name, 

   628                                 "value": [infos["elmt_type"]["extract"](tree)]}

   629                 else:

   630                     return {"name": content_name, 

   631                             "value": infos["elmt_type"]["extract"](tree)}

   632         raise ValueError("Invalid element \"%s\" for content!" % tree.nodeName)

   633     

   634     def GenerateContent(value, name=None, indent=0):

   635         for content_name, infos in choices:

   636             if content_name == value["name"]:

   637                 if isinstance(infos["elmt_type"], (UnicodeType, StringType)):

   638                     namespace, name = DecomposeQualifiedName(infos["elmt_type"])

   639                     infos["elmt_type"] = factory.GetQualifiedNameInfos(name, namespace)

   640                 if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:

   641                     text = ""

   642                     for item in value["value"]:

   643                         text += infos["elmt_type"]["generate"](item, content_name, indent)

   644                     return text

   645                 else:

   646                     return infos["elmt_type"]["generate"](value["value"], content_name, indent)

   647         return ""

   648         

   649     return {

   650         "initial": GetContentInitial,

   651         "check": CheckContent,

   652         "extract": ExtractContent,

   653         "generate": GenerateContent

   654     }

   655 

   656 #-------------------------------------------------------------------------------

   657 #                           Structure extraction functions

   658 #-------------------------------------------------------------------------------

   659 

   660 

   661 def DecomposeQualifiedName(name):

   662     result = QName_model.match(name)

   663     if not result:

   664         raise ValueError("\"%s\" isn't a valid QName value!" % name) 

   665     parts = result.groups()[0].split(':')

   666     if len(parts) == 1:

   667         return None, parts[0]

   668     return parts

   669     

   670 def GenerateElement(element_name, attributes, elements_model, 

   671                     accept_text=False):

   672     def ExtractElement(factory, node):

   673         attrs = factory.ExtractNodeAttrs(element_name, node, attributes)

   674         children_structure = ""

   675         children_infos = []

   676         children = []

   677         for child in node.childNodes:

   678             if child.nodeName not in ["#comment", "#text"]:

   679                 namespace, childname = DecomposeQualifiedName(child.nodeName)

   680                 children_structure += "%s "%childname

   681         result = elements_model.match(children_structure)

   682         if not result:

   683             raise ValueError("Invalid structure for \"%s\" children!. First element invalid." % node.nodeName)

   684         valid = result.groups()[0]

   685         if len(valid) < len(children_structure):

   686             raise ValueError("Invalid structure for \"%s\" children!. Element number %d invalid." % (node.nodeName, len(valid.split(" ")) - 1))

   687         for child in node.childNodes:

   688             if child.nodeName != "#comment" and \

   689                (accept_text or child.nodeName != "#text"):

   690                 if child.nodeName == "#text":

   691                     children.append(GetAttributeValue(node))

   692                 else:

   693                     namespace, childname = DecomposeQualifiedName(child.nodeName)

   694                     infos = factory.GetQualifiedNameInfos(childname, namespace)

   695                     if infos["type"] != SYNTAXELEMENT:

   696                         raise ValueError("\"%s\" can't be a member child!" % name)

   697                     if infos["extract"].has_key(element_name):

   698                         children.append(infos["extract"][element_name](factory, child))

   699                     else:

   700                         children.append(infos["extract"]["default"](factory, child))

   701         return node.nodeName, attrs, children

   702     return ExtractElement

   703 

   704 

   705 """

   706 Class that generate class from an XML Tree

   707 """

   708 class ClassFactory:

   709 

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

   711         self.Document = document

   712         self.Debug = debug

   713         

   714         # Dictionary for stocking Classes and Types definitions created from

   715         # the XML tree

   716         self.XMLClassDefinitions = {}

   717         

   718         self.DefinedNamespaces = {}

   719         self.Namespaces = {}

   720         self.SchemaNamespace = None

   721         self.TargetNamespace = None

   722         

   723         self.CurrentCompilations = []

   724         

   725         # Dictionaries for stocking Classes and Types generated

   726         self.ComputeAfter = []

   727         self.ComputedClasses = {}

   728         self.ComputedClassesInfos = {}

   729         self.AlreadyComputed = {}

   730 

   731     def GetQualifiedNameInfos(self, name, namespace=None, canbenone=False):

   732         if namespace is None:

   733             if self.Namespaces[self.SchemaNamespace].has_key(name):

   734                 return self.Namespaces[self.SchemaNamespace][name]

   735             for space, elements in self.Namespaces.items():

   736                 if space != self.SchemaNamespace and elements.has_key(name):

   737                     return elements[name]

   738             parts = name.split("_", 1)

   739             if len(parts) > 1:

   740                 group = self.GetQualifiedNameInfos(parts[0], namespace)

   741                 if group is not None and group["type"] == ELEMENTSGROUP:

   742                     elements = []

   743                     if group.has_key("elements"):

   744                         elements = group["elements"]

   745                     elif group.has_key("choices"):

   746                         elements = group["choices"]

   747                     for element in elements:

   748                         if element["name"] == parts[1]:

   749                             return element

   750             if not canbenone:

   751                 raise ValueError("Unknown element \"%s\" for any defined namespaces!" % name)

   752         elif self.Namespaces.has_key(namespace):

   753             if self.Namespaces[namespace].has_key(name):

   754                 return self.Namespaces[namespace][name]

   755             parts = name.split("_", 1)

   756             if len(parts) > 1:

   757                 group = self.GetQualifiedNameInfos(parts[0], namespace)

   758                 if group is not None and group["type"] == ELEMENTSGROUP:

   759                     elements = []

   760                     if group.has_key("elements"):

   761                         elements = group["elements"]

   762                     elif group.has_key("choices"):

   763                         elements = group["choices"]

   764                     for element in elements:

   765                         if element["name"] == parts[1]:

   766                             return element

   767             if not canbenone:

   768                 raise ValueError("Unknown element \"%s\" for namespace \"%s\"!" % (name, namespace))

   769         elif not canbenone:

   770             raise ValueError("Unknown namespace \"%s\"!" % namespace)

   771         return None

   772 

   773     def SplitQualifiedName(self, name, namespace=None, canbenone=False):

   774         if namespace is None:

   775             if self.Namespaces[self.SchemaNamespace].has_key(name):

   776                 return name, None

   777             for space, elements in self.Namespaces.items():

   778                 if space != self.SchemaNamespace and elements.has_key(name):

   779                     return name, None

   780             parts = name.split("_", 1)

   781             if len(parts) > 1:

   782                 group = self.GetQualifiedNameInfos(parts[0], namespace)

   783                 if group is not None and group["type"] == ELEMENTSGROUP:

   784                     elements = []

   785                     if group.has_key("elements"):

   786                         elements = group["elements"]

   787                     elif group.has_key("choices"):

   788                         elements = group["choices"]

   789                     for element in elements:

   790                         if element["name"] == parts[1]:

   791                             return part[1], part[0]

   792             if not canbenone:

   793                 raise ValueError("Unknown element \"%s\" for any defined namespaces!" % name)

   794         elif self.Namespaces.has_key(namespace):

   795             if self.Namespaces[namespace].has_key(name):

   796                 return name, None

   797             parts = name.split("_", 1)

   798             if len(parts) > 1:

   799                 group = self.GetQualifiedNameInfos(parts[0], namespace)

   800                 if group is not None and group["type"] == ELEMENTSGROUP:

   801                     elements = []

   802                     if group.has_key("elements"):

   803                         elements = group["elements"]

   804                     elif group.has_key("choices"):

   805                         elements = group["choices"]

   806                     for element in elements:

   807                         if element["name"] == parts[1]:

   808                             return parts[1], parts[0]

   809             if not canbenone:

   810                 raise ValueError("Unknown element \"%s\" for namespace \"%s\"!" % (name, namespace))

   811         elif not canbenone:

   812             raise ValueError("Unknown namespace \"%s\"!" % namespace)

   813         return None, None

   814 

   815     def ExtractNodeAttrs(self, element_name, node, valid_attrs):

   816         attrs = {}

   817         for qualified_name, attr in node._attrs.items():

   818             namespace, name =  DecomposeQualifiedName(qualified_name)

   819             if name in valid_attrs:

   820                 infos = self.GetQualifiedNameInfos(name, namespace)

   821                 if infos["type"] != SYNTAXATTRIBUTE:

   822                     raise ValueError("\"%s\" can't be a member attribute!" % name)

   823                 elif name in attrs:

   824                     raise ValueError("\"%s\" attribute has been twice!" % name)

   825                 elif element_name in infos["extract"]:

   826                     attrs[name] = infos["extract"][element_name](attr)

   827                 else:

   828                     attrs[name] = infos["extract"]["default"](attr)

   829             elif namespace == "xmlns":

   830                 infos = self.GetQualifiedNameInfos("anyURI", self.SchemaNamespace)

   831                 self.DefinedNamespaces[infos["extract"](attr)] = name

   832             else:

   833                 raise ValueError("Invalid attribute \"%s\" for member \"%s\"!" % (qualified_name, node.nodeName))

   834         for attr in valid_attrs:

   835             if attr not in attrs and \

   836                self.Namespaces[self.SchemaNamespace].has_key(attr) and \

   837                self.Namespaces[self.SchemaNamespace][attr].has_key("default"):

   838                 if self.Namespaces[self.SchemaNamespace][attr]["default"].has_key(element_name):

   839                     default = self.Namespaces[self.SchemaNamespace][attr]["default"][element_name]

   840                 else:

   841                     default = self.Namespaces[self.SchemaNamespace][attr]["default"]["default"]

   842                 if default is not None:

   843                     attrs[attr] = default

   844         return attrs

   845 

   846     def ReduceElements(self, elements, schema=False):

   847         result = []

   848         for child_infos in elements:

   849             if child_infos[1].has_key("name") and schema:

   850                 self.CurrentCompilations.append(child_infos[1]["name"])

   851             namespace, name = DecomposeQualifiedName(child_infos[0])

   852             infos = self.GetQualifiedNameInfos(name, namespace)

   853             if infos["type"] != SYNTAXELEMENT:

   854                 raise ValueError("\"%s\" can't be a member child!" % name)

   855             result.append(infos["reduce"](self, child_infos[1], child_infos[2]))

   856             if child_infos[1].has_key("name") and schema:

   857                 self.CurrentCompilations.pop(-1)

   858         annotations = []

   859         children = []

   860         for element in result:

   861             if element["type"] == "annotation":

   862                 annotations.append(element)

   863             else:

   864                 children.append(element)

   865         return annotations, children

   866 

   867     def AddComplexType(self, typename, infos):

   868         if not self.XMLClassDefinitions.has_key(typename):

   869             self.XMLClassDefinitions[typename] = infos

   870         else:

   871             raise ValueError("\"%s\" class already defined. Choose another name!" % typename)

   872 

   873     def ParseSchema(self):

   874         pass

   875 

   876     def ExtractTypeInfos(self, name, parent, typeinfos):

   877         if isinstance(typeinfos, (StringType, UnicodeType)):

   878             namespace, name = DecomposeQualifiedName(typeinfos)

   879             infos = self.GetQualifiedNameInfos(name, namespace)

   880             if infos["type"] == COMPLEXTYPE:

   881                 name, parent = self.SplitQualifiedName(name, namespace)

   882                 result = self.CreateClass(name, parent, infos)

   883                 if result is not None and not isinstance(result, (UnicodeType, StringType)):

   884                     self.Namespaces[self.TargetNamespace][result["name"]] = result

   885                 return result

   886             elif infos["type"] == ELEMENT and infos["elmt_type"]["type"] == COMPLEXTYPE:

   887                 name, parent = self.SplitQualifiedName(name, namespace)

   888                 result = self.CreateClass(name, parent, infos["elmt_type"])

   889                 if result is not None and not isinstance(result, (UnicodeType, StringType)):

   890                     self.Namespaces[self.TargetNamespace][result["name"]] = result

   891                 return result

   892             else:

   893                 return infos

   894         elif typeinfos["type"] == COMPLEXTYPE:

   895             return self.CreateClass(name, parent, typeinfos)

   896         elif typeinfos["type"] == SIMPLETYPE:

   897             return typeinfos

   898             

   899     """

   900     Methods that generates the classes

   901     """

   902     def CreateClasses(self):

   903         self.ParseSchema()

   904         for name, infos in self.Namespaces[self.TargetNamespace].items():

   905             if infos["type"] == ELEMENT:

   906                 if not isinstance(infos["elmt_type"], (UnicodeType, StringType)) and \

   907                    infos["elmt_type"]["type"] == COMPLEXTYPE:

   908                     self.ComputeAfter.append((name, None, infos["elmt_type"], True))

   909                     while len(self.ComputeAfter) > 0:

   910                         result = self.CreateClass(*self.ComputeAfter.pop(0))

   911                         if result is not None and not isinstance(result, (UnicodeType, StringType)):

   912                             self.Namespaces[self.TargetNamespace][result["name"]] = result

   913             elif infos["type"] == COMPLEXTYPE:

   914                 self.ComputeAfter.append((name, None, infos))

   915                 while len(self.ComputeAfter) > 0:

   916                     result = self.CreateClass(*self.ComputeAfter.pop(0))

   917                     if result is not None and \

   918                        not isinstance(result, (UnicodeType, StringType)):

   919                         self.Namespaces[self.TargetNamespace][result["name"]] = result

   920             elif infos["type"] == ELEMENTSGROUP:

   921                 elements = []

   922                 if infos.has_key("elements"):

   923                     elements = infos["elements"]

   924                 elif infos.has_key("choices"):

   925                     elements = infos["choices"]

   926                 for element in elements:

   927                     if not isinstance(element["elmt_type"], (UnicodeType, StringType)) and \

   928                        element["elmt_type"]["type"] == COMPLEXTYPE:

   929                         self.ComputeAfter.append((element["name"], infos["name"], element["elmt_type"]))

   930                         while len(self.ComputeAfter) > 0:

   931                             result = self.CreateClass(*self.ComputeAfter.pop(0))

   932                             if result is not None and \

   933                                not isinstance(result, (UnicodeType, StringType)):

   934                                 self.Namespaces[self.TargetNamespace][result["name"]] = result

   935         return self.ComputedClasses

   936 

   937     def CreateClass(self, name, parent, classinfos, baseclass = False):

   938         if parent is not None:

   939             classname = "%s_%s" % (parent, name)

   940         else:

   941             classname = name

   942         

   943         # Checks that classe haven't been generated yet

   944         if self.AlreadyComputed.get(classname, False):

   945             if baseclass:

   946                 self.AlreadyComputed[classname].IsBaseClass = baseclass

   947             return self.ComputedClassesInfos.get(classname, None)

   948         

   949         # If base classes haven't been generated

   950         bases = []

   951         if classinfos.has_key("base"):

   952             result = self.ExtractTypeInfos("base", name, classinfos["base"])

   953             if result is None:

   954                 namespace, base_name = DecomposeQualifiedName(classinfos["base"])                

   955                 if self.AlreadyComputed.get(base_name, False):

   956                     self.ComputeAfter.append((name, parent, classinfos))

   957                     if self.TargetNamespace is not None:

   958                         return "%s:%s" % (self.TargetNamespace, classname)

   959                     else:

   960                         return classname

   961             elif result is not None:

   962                 classinfos["base"] = self.ComputedClasses[result["name"]]

   963                 bases.append(self.ComputedClasses[result["name"]])

   964         bases.append(object)

   965         bases = tuple(bases)

   966         classmembers = {"__doc__": classinfos.get("doc", ""), "IsBaseClass": baseclass}

   967         

   968         self.AlreadyComputed[classname] = True

   969         

   970         for attribute in classinfos["attributes"]:

   971             infos = self.ExtractTypeInfos(attribute["name"], name, attribute["attr_type"])

   972             if infos is not None:                    

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

   974                     raise ValueError("\"%s\" type is not a simple type!" % attribute["attr_type"])

   975                 attrname = attribute["name"]

   976                 if attribute["use"] == "optional":

   977                     classmembers[attrname] = None

   978                     classmembers["add%s"%attrname] = generateAddMethod(attrname, self, attribute)

   979                     classmembers["delete%s"%attrname] = generateDeleteMethod(attrname)

   980                 else:

   981                     classmembers[attrname] = infos["initial"]()

   982                 classmembers["set%s"%attrname] = generateSetMethod(attrname)

   983                 classmembers["get%s"%attrname] = generateGetMethod(attrname)

   984             else:

   985                 raise ValueError("\"%s\" type unrecognized!" % attribute["attr_type"])

   986             attribute["attr_type"] = infos

   987             

   988         for element in classinfos["elements"]:

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

   990                 elmtname = element["name"]

   991                 choices = []

   992                 for choice in element["choices"]:

   993                     if choice["elmt_type"] == "tag":

   994                         choice["elmt_type"] = GenerateTagInfos(choice["name"])

   995                     else:

   996                         infos = self.ExtractTypeInfos(choice["name"], name, choice["elmt_type"])

   997                         if infos is not None:

   998                             choice["elmt_type"] = infos

   999                     choices.append((choice["name"], choice))

  1000                 classmembers["get%schoices"%elmtname] = generateGetChoicesMethod(element["choices"])

  1001                 if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:

  1002                     classmembers["append%sbytype" % elmtname] = generateAppendChoiceByTypeMethod(element["maxOccurs"], self, element["choices"])

  1003                     classmembers["insert%sbytype" % elmtname] = generateInsertChoiceByTypeMethod(element["maxOccurs"], self, element["choices"])

  1004                 else:

  1005                     classmembers["set%sbytype" % elmtname] = generateSetChoiceByTypeMethod(self, element["choices"])

  1006                 infos = GenerateContentInfos(self, choices)

  1007             elif element["type"] == ANY:

  1008                 elmtname = element["name"] = "text"

  1009                 element["minOccurs"] = element["maxOccurs"] = 1

  1010                 infos = GenerateAnyInfos()

  1011             else:

  1012                 elmtname = element["name"]

  1013                 infos = self.ExtractTypeInfos(element["name"], name, element["elmt_type"])

  1014             if infos is not None:

  1015                 element["elmt_type"] = infos

  1016             if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:

  1017                 classmembers[elmtname] = []

  1018                 classmembers["append%s" % elmtname] = generateAppendMethod(elmtname, element["maxOccurs"], self, element)

  1019                 classmembers["insert%s" % elmtname] = generateInsertMethod(elmtname, element["maxOccurs"], self, element)

  1020                 classmembers["remove%s" % elmtname] = generateRemoveMethod(elmtname, element["minOccurs"])

  1021                 classmembers["count%s" % elmtname] = generateCountMethod(elmtname)

  1022             else:

  1023                 if element["minOccurs"] == 0:

  1024                     classmembers[elmtname] = None

  1025                     classmembers["add%s" % elmtname] = generateAddMethod(elmtname, self, element)

  1026                     classmembers["delete%s" % elmtname] = generateDeleteMethod(elmtname)

  1027                 elif not isinstance(element["elmt_type"], (UnicodeType, StringType)):

  1028                     classmembers[elmtname] = element["elmt_type"]["initial"]()

  1029                 else:

  1030                     classmembers[elmtname] = None

  1031             classmembers["set%s" % elmtname] = generateSetMethod(elmtname)

  1032             classmembers["get%s" % elmtname] = generateGetMethod(elmtname)

  1033             

  1034         classmembers["__init__"] = generateInitMethod(self, classinfos)

  1035         classmembers["__setattr__"] = generateSetattrMethod(self, classinfos)

  1036         classmembers["getStructure"] = generateStructureMethod(classinfos)

  1037         classmembers["loadXMLTree"] = generateLoadXMLTree(self, classinfos)

  1038         classmembers["generateXMLText"] = generateGenerateXMLText(self, classinfos)

  1039         classmembers["getElementAttributes"] = generateGetElementAttributes(self, classinfos)

  1040         classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)

  1041         classmembers["setElementValue"] = generateSetElementValue(self, classinfos)

  1042         classmembers["singleLineAttributes"] = True

  1043         classmembers["compatibility"] = lambda x, y: None

  1044         

  1045         class_definition = classobj(str(classname), bases, classmembers)

  1046         class_infos = {"type": COMPILEDCOMPLEXTYPE,

  1047                 "name": classname,

  1048                 "check": generateClassCheckFunction(class_definition),

  1049                 "initial": generateClassCreateFunction(class_definition),

  1050                 "extract": generateClassExtractFunction(class_definition),

  1051                 "generate": class_definition.generateXMLText}

  1052         

  1053         self.ComputedClasses[classname] = class_definition

  1054         self.ComputedClassesInfos[classname] = class_infos

  1055         

  1056         return class_infos

  1057 

  1058     """

  1059     Methods that print the classes generated

  1060     """

  1061     def PrintClasses(self):

  1062         items = self.ComputedClasses.items()

  1063         items.sort()

  1064         for classname, xmlclass in items:

  1065             print "%s : %s" % (classname, str(xmlclass))

  1066         

  1067     def PrintClassNames(self):

  1068         classnames = self.XMLClassDefinitions.keys()

  1069         classnames.sort()

  1070         for classname in classnames:

  1071             print classname

  1072 

  1073 """

  1074 Method that generate the method for checking a class instance

  1075 """

  1076 def generateClassCheckFunction(class_definition):

  1077     def classCheckfunction(instance):

  1078         return isinstance(instance, class_definition)

  1079     return classCheckfunction

  1080 

  1081 """

  1082 Method that generate the method for creating a class instance

  1083 """

  1084 def generateClassCreateFunction(class_definition):

  1085     def classCreatefunction():

  1086         return class_definition()

  1087     return classCreatefunction

  1088 

  1089 """

  1090 Method that generate the method for extracting a class instance

  1091 """

  1092 def generateClassExtractFunction(class_definition):

  1093     def classExtractfunction(node):

  1094         instance = class_definition()

  1095         instance.loadXMLTree(node)

  1096         return instance

  1097     return classExtractfunction

  1098 

  1099 """

  1100 Method that generate the method for loading an xml tree by following the

  1101 attributes list defined

  1102 """

  1103 def generateSetattrMethod(factory, classinfos):

  1104     attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])

  1105     optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])

  1106     elements = dict([(element["name"], element) for element in classinfos["elements"]])

  1107     

  1108     def setattrMethod(self, name, value):

  1109         if attributes.has_key(name):

  1110             if isinstance(attributes[name]["attr_type"], (UnicodeType, StringType)):

  1111                 namespace, name = DecomposeQualifiedName(infos)

  1112                 attributes[name]["attr_type"] = factory.GetQualifiedNameInfos(name, namespace)

  1113             if value is None:

  1114                 if optional_attributes.get(name, False):

  1115                     return object.__setattr__(self, name, None)

  1116                 else:

  1117                     raise ValueError("Attribute '%s' isn't optional." % name)

  1118             elif attributes[name].has_key("fixed") and value != attributes[name]["fixed"]:

  1119                 raise ValueError, "Value of attribute '%s' can only be '%s'."%(name, str(attributes[name]["fixed"]))

  1120             elif attributes[name]["attr_type"]["check"](value):

  1121                 return object.__setattr__(self, name, value)

  1122             else:

  1123                 raise ValueError("Invalid value for attribute '%s'." % (name))

  1124         elif elements.has_key(name):

  1125             if isinstance(elements[name]["elmt_type"], (UnicodeType, StringType)):

  1126                 namespace, name = DecomposeQualifiedName(infos)

  1127                 elements[name]["elmt_type"] = factory.GetQualifiedNameInfos(name, namespace)

  1128             if value is None:

  1129                 if elements[name]["minOccurs"] == 0 and elements[name]["maxOccurs"] == 1:

  1130                     return object.__setattr__(self, name, None)

  1131                 else:

  1132                     raise ValueError("Attribute '%s' isn't optional." % name)

  1133             elif elements[name]["maxOccurs"] == "unbounded" or elements[name]["maxOccurs"] > 1:

  1134                 if isinstance(value, ListType) and elements[name]["minOccurs"] <= len(value) <= elements[name]["maxOccurs"]:

  1135                     if reduce(lambda x, y: x and y, map(elements[name]["elmt_type"]["check"], value), True):

  1136                         return object.__setattr__(self, name, value)