Mercurial Mercurial > beremiz / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
xmlclass/xmlclass.py
changeset 1291 42ea51d083ce
parent 1290 13ee5f4ab612
child 1293 40117d02601b
equal deleted inserted replaced
1290:13ee5f4ab612 1291:42ea51d083ce 
   533                                  (value, type))
 
   533                                  (value, type))
 
   534         return values
 
   534         return values
 
   535     return GetModelNameList
 
   535     return GetModelNameList
 
   536 
   536 
   537 def GenerateAnyInfos(infos):
 
   537 def GenerateAnyInfos(infos):
 
       
   538     
   538     def ExtractAny(tree):
 
   539     def ExtractAny(tree):
 
   539         if tree.nodeName in ["#text", "#cdata-section"]:
 
   540         if infos["namespace"][0] == "##any":
 
   540             return unicode(unescape(tree.data))
 
   541             return tree.xpath("p/text()")[0]
 
   541         else:
 
   542         return tree.xpath("ns:p/text()", namespaces={"ns": infos["namespace"][0]})[0]
 
   542             return tree
 
   543     
   543     
   544     def GenerateAny(tree, value):
 
   544     def GenerateAny(value, name=None, indent=0):
 
   545         if infos["namespace"][0] == "##any":
 
   545         if isinstance(value, (StringType, UnicodeType)):
 
   546             p = tree.xpath("p")[0]
 
   546             try:
 
   547         else:
 
   547                 value = value.decode("utf-8")
 
   548             p = tree.xpath("ns:p", namespaces={"ns": infos["namespace"][0]})[0]
 
   548             except:
 
   549         p.text = etree.CDATA(value)
 
   549                 pass
 
   550         
   550             return u'<![CDATA[%s]]>\n' % value
 
   551     def InitialAny():
 
   551         else:
 
   552         text = etree.CDATA(value)
 
   552             return value.toprettyxml(indent=" "*indent, encoding="utf-8")
 
   553         if infos["namespace"][0] == "##any":
 
       
   554             element_name = "p"
 
       
   555         else:
 
       
   556             element_name = "{%s}p" % infos["namespace"][0]
 
       
   557         return etree.Element(element_name, text)
 
   553         
   558         
   554     return {
 
   559     return {
 
   555         "type": COMPLEXTYPE, 
   560         "type": COMPLEXTYPE, 
   556         "extract": ExtractAny,
 
   561         "extract": ExtractAny,
 
   557         "generate": GenerateAny,
 
   562         "generate": GenerateAny,
 
   558         "initial": lambda: "",
 
   563         "initial": lambda: GenerateAny(""),
 
   559         "check": lambda x: isinstance(x, (StringType, UnicodeType, minidom.Node))
 
   564         "check": lambda x: isinstance(x, (StringType, UnicodeType, etree.ElementBase))
 
   560     }
 
   565     }
 
   561 
   566 
   562 def GenerateTagInfos(infos):
 
   567 def GenerateTagInfos(infos):
 
   563     def ExtractTag(tree):
 
   568     def ExtractTag(tree):
 
   564         if len(tree._attrs) > 0:
 
   569         if len(tree._attrs) > 0:
 
   655                     element_infos = factory.ExtractTypeInfos(sequence_element["name"], name, sequence_element["elmt_type"])
 
   660                     element_infos = factory.ExtractTypeInfos(sequence_element["name"], name, sequence_element["elmt_type"])
 
   656                     if element_infos is not None:
 
   661                     if element_infos is not None:
 
   657                         sequence_element["elmt_type"] = element_infos
 
   662                         sequence_element["elmt_type"] = element_infos
 
   658         elif choice["elmt_type"] == "tag":
 
   663         elif choice["elmt_type"] == "tag":
 
   659             choice["elmt_type"] = GenerateTagInfos(choice)
 
   664             choice["elmt_type"] = GenerateTagInfos(choice)
 
       
   665             factory.AddToLookupClass(choice["name"], name, DefaultElementClass)
 
   660         else:
 
   666         else:
 
   661             choice_infos = factory.ExtractTypeInfos(choice["name"], name, choice["elmt_type"])
 
   667             choice_infos = factory.ExtractTypeInfos(choice["name"], name, choice["elmt_type"])
 
   662             if choice_infos is not None:
 
   668             if choice_infos is not None:
 
   663                 choice["elmt_type"] = choice_infos
 
   669                 choice["elmt_type"] = choice_infos
 
   664         choices.append((choice["name"], choice))
 
   670         choices.append((choice["name"], choice))
 
  1082 
  1088 
  1083     def ParseSchema(self):
 
  1089     def ParseSchema(self):
 
  1084         pass
 
  1090         pass
 
  1085     
  1091     
  1086     def AddEquivalentClass(self, name, base):
 
  1092     def AddEquivalentClass(self, name, base):
 
  1087         equivalences = self.EquivalentClassesParent.setdefault(self.etreeNamespaceFormat % name, {})
 
  1093         if name != base:
 
  1088         equivalences[self.etreeNamespaceFormat % base] = True
 
  1094             equivalences = self.EquivalentClassesParent.setdefault(self.etreeNamespaceFormat % base, {})
 
       
  1095             equivalences[self.etreeNamespaceFormat % name] = True
 
  1089         
  1096         
  1090     def AddToLookupClass(self, name, parent, typeinfos):
 
  1097     def AddToLookupClass(self, name, parent, typeinfos):
 
  1091         lookup_name = self.etreeNamespaceFormat % name
 
  1098         lookup_name = self.etreeNamespaceFormat % name
 
  1092         if isinstance(typeinfos, (StringType, UnicodeType)):
 
  1099         if isinstance(typeinfos, (StringType, UnicodeType)):
 
  1093             self.AddEquivalentClass(name, typeinfos)
 
  1100             self.AddEquivalentClass(name, typeinfos)
 
  1127                 return infos
 
  1134                 return infos
 
  1128         elif typeinfos["type"] == COMPLEXTYPE:
 
  1135         elif typeinfos["type"] == COMPLEXTYPE:
 
  1129             return self.CreateClass(name, parent, typeinfos)
 
  1136             return self.CreateClass(name, parent, typeinfos)
 
  1130         elif typeinfos["type"] == SIMPLETYPE:
 
  1137         elif typeinfos["type"] == SIMPLETYPE:
 
  1131             return typeinfos
 
  1138             return typeinfos
 
  1132             
  1139     
       
  1140     def GetEquivalentParents(self, parent):
 
       
  1141         return reduce(lambda x, y: x + y,
 
       
  1142             [[p] + self.GetEquivalentParents(p)
 
       
  1143              for p in self.EquivalentClassesParent.get(parent, {}).keys()], [])
 
       
  1144     
  1133     """
 
  1145     """
 
  1134     Methods that generates the classes
 
  1146     Methods that generates the classes
 
  1135     """
 
  1147     """
 
  1136     def CreateClasses(self):
 
  1148     def CreateClasses(self):
 
  1137         self.ParseSchema()
 
  1149         self.ParseSchema()
 
  1164                         while len(self.ComputeAfter) > 0:
 
  1176                         while len(self.ComputeAfter) > 0:
 
  1165                             result = self.CreateClass(*self.ComputeAfter.pop(0))
 
  1177                             result = self.CreateClass(*self.ComputeAfter.pop(0))
 
  1166                             if result is not None and \
 
  1178                             if result is not None and \
 
  1167                                not isinstance(result, (UnicodeType, StringType)):
 
  1179                                not isinstance(result, (UnicodeType, StringType)):
 
  1168                                 self.Namespaces[self.TargetNamespace][result["name"]] = result
 
  1180                                 self.Namespaces[self.TargetNamespace][result["name"]] = result
 
       
  1181         
       
  1182         for name, parents in self.ComputedClassesLookUp.iteritems():
 
       
  1183             if isinstance(parents, DictType):
 
       
  1184                 computed_classes = parents.items()
 
       
  1185             elif parents[1] is not None:
 
       
  1186                 computed_classes = [(self.etreeNamespaceFormat % parents[1], parents[0])]
 
       
  1187             else:
 
       
  1188                 computed_classes = []
 
       
  1189             for parent, computed_class in computed_classes:
 
       
  1190                 for equivalent_parent in self.GetEquivalentParents(parent):
 
       
  1191                     if not isinstance(parents, DictType):
 
       
  1192                         parents = dict(computed_classes)
 
       
  1193                         self.ComputedClassesLookUp[name] = parents
 
       
  1194                     parents[equivalent_parent] = computed_class
 
       
  1195         
  1169         return self.ComputedClasses
 
  1196         return self.ComputedClasses
 
  1170 
  1197 
  1171     def CreateClass(self, name, parent, classinfos, baseclass = False):
 
  1198     def CreateClass(self, name, parent, classinfos, baseclass = False):
 
  1172         if parent is not None:
 
  1199         if parent is not None:
 
  1173             classname = "%s_%s" % (parent, name)
 
  1200             classname = "%s_%s" % (parent, name)
 
  1241                     classmembers["insert%sbytype" % elmtname] = generateInsertChoiceByTypeMethod(element["maxOccurs"], self, element["choices"])
 
  1268                     classmembers["insert%sbytype" % elmtname] = generateInsertChoiceByTypeMethod(element["maxOccurs"], self, element["choices"])
 
  1242                 else:
 
  1269                 else:
 
  1243                     classmembers["set%sbytype" % elmtname] = generateSetChoiceByTypeMethod(self, element["choices"])
 
  1270                     classmembers["set%sbytype" % elmtname] = generateSetChoiceByTypeMethod(self, element["choices"])
 
  1244                 infos = GenerateContentInfos(self, name, choices)
 
  1271                 infos = GenerateContentInfos(self, name, choices)
 
  1245             elif element["type"] == ANY:
 
  1272             elif element["type"] == ANY:
 
  1246                 elmtname = element["name"] = "text"
 
  1273                 elmtname = element["name"] = "anyText"
 
  1247                 element["minOccurs"] = element["maxOccurs"] = 1
 
  1274                 element["minOccurs"] = element["maxOccurs"] = 1
 
  1248                 infos = GenerateAnyInfos(element)
 
  1275                 infos = GenerateAnyInfos(element)
 
  1249             else:
 
  1276             else:
 
  1250                 elmtname = element["name"]
 
  1277                 elmtname = element["name"]
 
  1251                 if element["elmt_type"] == "tag":
 
  1278                 if element["elmt_type"] == "tag":
 
  1252                     infos = GenerateTagInfos(element)
 
  1279                     infos = GenerateTagInfos(element)
 
       
  1280                     self.AddToLookupClass(element["name"], name, DefaultElementClass)
 
  1253                 else:
 
  1281                 else:
 
  1254                     infos = self.ExtractTypeInfos(element["name"], name, element["elmt_type"])
 
  1282                     infos = self.ExtractTypeInfos(element["name"], name, element["elmt_type"])
 
  1255             if infos is not None:
 
  1283             if infos is not None:
 
  1256                 element["elmt_type"] = infos
 
  1284                 element["elmt_type"] = infos
 
  1257             if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:
 
  1285             if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:
 
  1264                     classmembers["add%s" % elmtname] = generateAddMethod(elmtname, self, element)
 
  1292                     classmembers["add%s" % elmtname] = generateAddMethod(elmtname, self, element)
 
  1265                     classmembers["delete%s" % elmtname] = generateDeleteMethod(elmtname)
 
  1293                     classmembers["delete%s" % elmtname] = generateDeleteMethod(elmtname)
 
  1266             classmembers["set%s" % elmtname] = generateSetMethod(elmtname)
 
  1294             classmembers["set%s" % elmtname] = generateSetMethod(elmtname)
 
  1267             classmembers["get%s" % elmtname] = generateGetMethod(elmtname)
 
  1295             classmembers["get%s" % elmtname] = generateGetMethod(elmtname)
 
  1268             
  1296             
  1269         classmembers["_init"] = generateInitMethod(self, classinfos)
 
  1297         classmembers["init"] = generateInitMethod(self, classinfos)
 
  1270         classmembers["getStructure"] = generateStructureMethod(classinfos)
 
  1298         classmembers["getStructure"] = generateStructureMethod(classinfos)
 
  1271         classmembers["loadXMLTree"] = generateLoadXMLTree(self, classinfos)
 
  1299         classmembers["loadXMLTree"] = generateLoadXMLTree(self, classinfos)
 
  1272         classmembers["generateXMLText"] = generateGenerateXMLText(self, classinfos)
 
  1300         classmembers["generateXMLText"] = generateGenerateXMLText(self, classinfos)
 
  1273         classmembers["getElementAttributes"] = generateGetElementAttributes(self, classinfos)
 
  1301         classmembers["getElementAttributes"] = generateGetElementAttributes(self, classinfos)
 
  1274         classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)
 
  1302         classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)
 
  1364             return attribute_infos["attr_type"]["initial"]()
 
  1392             return attribute_infos["attr_type"]["initial"]()
 
  1365         
  1393         
  1366         elif elements.has_key(name):
 
  1394         elif elements.has_key(name):
 
  1367             element_infos = elements[name]
 
  1395             element_infos = elements[name]
 
  1368             element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
 
  1396             element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
 
  1369             if name == "content":
 
  1397             if element_infos["type"] == CHOICE:
 
  1370                 content = self.xpath(element_infos["elmt_type"]["choices_xpath"](), namespaces=factory.NSMAP)
 
  1398                 content = self.xpath(element_infos["elmt_type"]["choices_xpath"](), namespaces=factory.NSMAP)
 
  1371                 if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
 
  1399                 if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
 
  1372                     return content
 
  1400                     return content
 
  1373                 elif len(content) > 0:
 
  1401                 elif len(content) > 0:
 
  1374                     return content[0]
 
  1402                     return content[0]
 
  1375                 return None 
  1403                 return None 
       
  1404             elif element_infos["type"] == ANY:
 
       
  1405                 return element_infos["elmt_type"]["extract"](self)
 
  1376             else:
 
  1406             else:
 
  1377                 element_name = factory.etreeNamespaceFormat % name
 
  1407                 element_name = factory.etreeNamespaceFormat % name
 
  1378                 if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
 
  1408                 if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
 
  1379                     return self.findall(element_name)
 
  1409                     return self.findall(element_name)
 
  1380                 else:
 
  1410                 else:
 
  1401             attribute_infos = attributes[name]
 
  1431             attribute_infos = attributes[name]
 
  1402             attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])
 
  1432             attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])
 
  1403             if optional_attributes.get(name, False):
 
  1433             if optional_attributes.get(name, False):
 
  1404                 default = attribute_infos.get("default", None)
 
  1434                 default = attribute_infos.get("default", None)
 
  1405                 if value is None or value == default:
 
  1435                 if value is None or value == default:
 
  1406                     self.attrib.pop(name)
 
  1436                     self.attrib.pop(name, None)
 
  1407                     return
 
  1437                     return
 
  1408             elif attribute_infos.has_key("fixed"):
 
  1438             elif attribute_infos.has_key("fixed"):
 
  1409                 return
 
  1439                 return
 
  1410             return self.set(name, attribute_infos["attr_type"]["generate"](value))
 
  1440             return self.set(name, attribute_infos["attr_type"]["generate"](value))
 
  1411         
  1441         
  1412         elif elements.has_key(name):
 
  1442         elif elements.has_key(name):
 
  1413             element_infos = elements[name]
 
  1443             element_infos = elements[name]
 
  1414             element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
 
  1444             element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
 
  1415             element_xpath = ("%s:%s" % (factory.TargetNamespace, name)
 
  1445             if element_infos["type"] == ANY:
 
  1416                              if name != "content"
 
  1446                 element_infos["elmt_type"]["generate"](self, value)
 
  1417                              else elements["content"]["elmt_type"]["choices_xpath"]())
 
       
  1418             
  1447             
  1419             for element in self.xpath(element_xpath, namespaces=factory.NSMAP):
 
  1448             else:
 
  1420                 self.remove(element)
 
  1449                 element_xpath = ("%s:%s" % (factory.TargetNamespace, name)
 
  1421             
  1450                                  if name != "content"
 
  1422             if value is not None:
 
  1451                                  else elements["content"]["elmt_type"]["choices_xpath"]())
 
  1423                 previous_elements_xpath = "|".join(map(
 
       
  1424                     lambda x: "%s:%s" % (factory.TargetNamespace, x)
 
       
  1425                               if x != "content"
 
       
  1426                               else elements["content"]["elmt_type"]["choices_xpath"](),
 
       
  1427                     elements.keys()[elements.keys().index(name)]))
 
       
  1428                 
  1452                 
  1429                 insertion_point = len(self.xpath(previous_elements_xpath, namespaces=factory.NSMAP))
 
  1453                 for element in self.xpath(element_xpath, namespaces=factory.NSMAP):
 
       
  1454                     self.remove(element)
 
  1430                 
  1455                 
  1431                 if not isinstance(value, ListType):
 
  1456                 if value is not None:
 
  1432                     value = [value]
 
  1457                     previous_elements_xpath = "|".join(map(
 
       
  1458                         lambda x: "%s:%s" % (factory.TargetNamespace, x)
 
       
  1459                                   if x != "content"
 
       
  1460                                   else elements["content"]["elmt_type"]["choices_xpath"](),
 
       
  1461                         elements.keys()[elements.keys().index(name)]))
 
  1433                     
  1462                     
  1434                 for element in reversed(value):
 
  1463                     insertion_point = len(self.xpath(previous_elements_xpath, namespaces=factory.NSMAP))
 
  1435                     self.insert(insertion_point, element)
 
  1464                     
       
  1465                     if not isinstance(value, ListType):
 
       
  1466                         value = [value]
 
       
  1467                         
       
  1468                     for element in reversed(value):
 
       
  1469                         self.insert(insertion_point, element)
 
  1436         
  1470         
  1437         elif classinfos.has_key("base"):
 
  1471         elif classinfos.has_key("base"):
 
  1438             return classinfos["base"].__setattr__(self, name, value)
 
  1472             return classinfos["base"].__setattr__(self, name, value)
 
  1439         
  1473         
  1440         elif class_definition.__dict__.has_key(name):
 
  1474         elif class_definition.__dict__.has_key(name):
 
  1825 """
 
  1859 """
 
  1826 def generateInitMethod(factory, classinfos):
 
  1860 def generateInitMethod(factory, classinfos):
 
  1827     def initMethod(self):
 
  1861     def initMethod(self):
 
  1828         self.extraAttrs = {}
 
  1862         self.extraAttrs = {}
 
  1829         if classinfos.has_key("base"):
 
  1863         if classinfos.has_key("base"):
 
  1830             classinfos["base"]._init(self)
 
  1864             classinfos["base"].init(self)
 
  1831         for attribute in classinfos["attributes"]:
 
  1865         for attribute in classinfos["attributes"]:
 
  1832             attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])
 
  1866             attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])
 
  1833             if attribute["use"] == "required" and self.get(attribute["name"]) is None:
 
  1867             if attribute["use"] == "required":
 
  1834                 self.set(attribute["name"], attribute["attr_type"]["generate"](attribute["attr_type"]["initial"]()))
 
  1868                 self.set(attribute["name"], attribute["attr_type"]["generate"](attribute["attr_type"]["initial"]()))
 
  1835         for element in classinfos["elements"]:
 
  1869         for element in classinfos["elements"]:
 
  1836             if element["name"] != "content":
 
  1870             if element["type"] != CHOICE:
 
  1837                 element_name = (
 
  1871                 element_name = (
 
  1838                     etree.QName(factory.NSMAP["xhtml"], "p")
 
  1872                     etree.QName(factory.NSMAP["xhtml"], "p")
 
  1839                     if element["type"] == ANY
 
  1873                     if element["type"] == ANY
 
  1840                     else factory.etreeNamespaceFormat % element["name"])
 
  1874                     else factory.etreeNamespaceFormat % element["name"])
 
  1841                 if self.find(element_name) is None:
 
  1875                 initial = GetElementInitialValue(factory, element)
 
  1842                     initial = GetElementInitialValue(factory, element)
 
  1876                 if initial is not None:
 
  1843                     if initial is not None:
 
  1877                     for value in initial:
 
  1844                         map(self.append, initial)
 
  1878                         DefaultElementClass.__setattr__(value, "tag", element_name)
 
       
  1879                         value.init()
 
       
  1880                         self.append(value)
 
  1845     return initMethod
 
  1881     return initMethod
 
  1846 
  1882 
  1847 def generateSetMethod(attr):
 
  1883 def generateSetMethod(attr):
 
  1848     def setMethod(self, value):
 
  1884     def setMethod(self, value):
 
  1849         setattr(self, attr, value)
 
  1885         setattr(self, attr, value)
 
  1964 """
 
  2000 """
 
  1965 This function generate a xml parser from a class factory
 
  2001 This function generate a xml parser from a class factory
 
  1966 """
 
  2002 """
 
  1967 
  2003 
  1968 class DefaultElementClass(etree.ElementBase):
 
  2004 class DefaultElementClass(etree.ElementBase):
 
  1969     toto = True
 
  2005     
       
  2006     def init(self):
 
       
  2007         pass
 
  1970     
  2008     
  1971     def getLocalTag(self):
 
  2009     def getLocalTag(self):
 
  1972         return etree.QName(self.tag).localname
 
  2010         return etree.QName(self.tag).localname
 
  1973         
  2011         
  1974     def tostring(self):
 
  2012     def tostring(self):
 
  1975         return etree.tostring(self, pretty_print=True)
 
  2013         return etree.tostring(self, pretty_print=True)
 
  1976 
  2014 
  1977 class XMLElementClassLookUp(etree.PythonElementClassLookup):
 
  2015 class XMLElementClassLookUp(etree.PythonElementClassLookup):
 
  1978     
  2016     
  1979     def __init__(self, classes, class_equivalence, *args, **kwargs):
 
  2017     def __init__(self, classes, *args, **kwargs):
 
  1980         etree.PythonElementClassLookup.__init__(self, *args, **kwargs)
 
  2018         etree.PythonElementClassLookup.__init__(self, *args, **kwargs)
 
  1981         self.LookUpClasses = classes
 
  2019         self.LookUpClasses = classes
 
  1982         self.ClassEquivalence = class_equivalence
 
       
  1983     
  2020     
  1984     def GetElementClass(self, element_tag, parent_tag=None, default=DefaultElementClass):
 
  2021     def GetElementClass(self, element_tag, parent_tag=None, default=DefaultElementClass):
 
  1985         element_class = self.LookUpClasses.get(element_tag, (default, None))
 
  2022         element_class = self.LookUpClasses.get(element_tag, (default, None))
 
  1986         if not isinstance(element_class, DictType):
 
  2023         if not isinstance(element_class, DictType):
 
  1987             if isinstance(element_class[0], (StringType, UnicodeType)):
 
  2024             if isinstance(element_class[0], (StringType, UnicodeType)):
 
  1989             return element_class[0]
 
  2026             return element_class[0]
 
  1990         
  2027         
  1991         element_with_parent_class = element_class.get(parent_tag, default)
 
  2028         element_with_parent_class = element_class.get(parent_tag, default)
 
  1992         if isinstance(element_with_parent_class, (StringType, UnicodeType)):
 
  2029         if isinstance(element_with_parent_class, (StringType, UnicodeType)):
 
  1993             return self.GetElementClass(element_with_parent_class, default=default)
 
  2030             return self.GetElementClass(element_with_parent_class, default=default)
 
  1994         elif element_with_parent_class == DefaultElementClass:
 
       
  1995             for equivalent_parent in self.ClassEquivalence.get(parent_tag, {}).keys():
 
       
  1996                 return self.GetElementClass(element_tag, equivalent_parent, default)
 
       
  1997         return element_with_parent_class
 
  2031         return element_with_parent_class
 
  1998         
  2032         
  1999     def lookup(self, document, element):
 
  2033     def lookup(self, document, element):
 
  2000         parent = element.getparent()
 
  2034         parent = element.getparent()
 
  2001         return self.GetElementClass(element.tag, 
  2035         return self.GetElementClass(element.tag, 
  2020         etree.XMLParser.set_element_class_lookup(self, class_lookup)
 
  2054         etree.XMLParser.set_element_class_lookup(self, class_lookup)
 
  2021         self.ClassLookup = class_lookup
 
  2055         self.ClassLookup = class_lookup
 
  2022     
  2056     
  2023     def CreateRoot(self):
 
  2057     def CreateRoot(self):
 
  2024         if self.BaseClass is not None:
 
  2058         if self.BaseClass is not None:
 
  2025             return self.makeelement(
 
  2059             root = self.makeelement(
 
  2026                 self.DefaultNamespaceFormat % self.BaseClass[0],
 
  2060                 self.DefaultNamespaceFormat % self.BaseClass[0],
 
  2027                 nsmap=self.RootNSMAP)
 
  2061                 nsmap=self.RootNSMAP)
 
       
  2062             root.init()
 
       
  2063             return root
 
  2028         return None
 
  2064         return None
 
  2029     
  2065     
  2030     def GetElementClass(self, element_tag, parent_tag=None):
 
  2066     def GetElementClass(self, element_tag, parent_tag=None):
 
  2031         return self.ClassLookup.GetElementClass(
 
  2067         return self.ClassLookup.GetElementClass(
 
  2032             self.DefaultNamespaceFormat % element_tag, 
  2068             self.DefaultNamespaceFormat % element_tag, 
  2035             None)
 
  2071             None)
 
  2036     
  2072     
  2037     def CreateElement(self, element_tag, parent_tag=None):
 
  2073     def CreateElement(self, element_tag, parent_tag=None):
 
  2038         new_element = self.GetElementClass(element_tag, parent_tag)()
 
  2074         new_element = self.GetElementClass(element_tag, parent_tag)()
 
  2039         DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag)
 
  2075         DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag)
 
       
  2076         new_element.init()
 
  2040         return new_element
 
  2077         return new_element
 
  2041     
  2078     
  2042 def GenerateParser(factory, xsdstring):
 
  2079 def GenerateParser(factory, xsdstring):
 
  2043     ComputedClasses = factory.CreateClasses()
 
  2080     ComputedClasses = factory.CreateClasses()
 
  2044     if factory.FileName is not None and len(ComputedClasses) == 1:
 
  2081     if factory.FileName is not None and len(ComputedClasses) == 1:
 
  2052         factory.NSMAP,
 
  2089         factory.NSMAP,
 
  2053         factory.etreeNamespaceFormat,
 
  2090         factory.etreeNamespaceFormat,
 
  2054         BaseClass[0] if len(BaseClass) == 1 else None,
 
  2091         BaseClass[0] if len(BaseClass) == 1 else None,
 
  2055         schema = etree.XMLSchema(etree.fromstring(xsdstring)),
 
  2092         schema = etree.XMLSchema(etree.fromstring(xsdstring)),
 
  2056         strip_cdata = False, remove_blank_text=True)
 
  2093         strip_cdata = False, remove_blank_text=True)
 
  2057     class_lookup = XMLElementClassLookUp(factory.ComputedClassesLookUp, factory.EquivalentClassesParent)
 
  2094     class_lookup = XMLElementClassLookUp(factory.ComputedClassesLookUp)
 
  2058     parser.set_element_class_lookup(class_lookup)
 
  2095     parser.set_element_class_lookup(class_lookup)
 
       
  2096     
  2059     return parser
 
  2097     return parser
 
  2060 
  2098 
  2061 def UpdateXMLClassGlobals(classes):
 
  2099 def UpdateXMLClassGlobals(classes):
 
  2062     globals().update(classes)
 
  2100     globals().update(classes)
 
  2063 
  2101
beremiz