beremiz: comparison xmlclass/xsdschema.py

equal deleted inserted replaced

-:c02818d7e29f
+:7e61baa047f0
 from xml.dom import minidom
 from types import *
 from xmlclass import *
 def GenerateDictFacets(facets):
 return dict([(name, (None, False)) for name in facets])
 def GenerateSimpleTypeXMLText(function):
 def generateXMLTextMethod(value, name=None, indent=0):
 text = ""
 if name is not None:
 text += function(value)
 if name is not None:
 text += "</%s>\n" % name
 return text
 return generateXMLTextMethod
 def GenerateFloatXMLText(extra_values=[], decimal=None):
 float_format = (lambda x: "{:.{width}f}".format(x, width=decimal).rstrip('0')
 if decimal is not None else str)
 def generateXMLTextMethod(value, name=None, indent=0):
 else:
 annotation["documentation"] += text
 return annotation
 # Simple type elements
 def GenerateFacetReducing(facetname, canbefixed):
 def ReduceFacet(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 if attributes.has_key("value"):
 simpleType["initial"] = SimpleTypeInitialValue
 simpleType["check"] = CheckSimpleTypeValue
 simpleType["generate"] = GenerateSimpleType
 return simpleType
 def ReduceSimpleType(factory, attributes, elements):
 # Reduce all the simple type children
 annotations, children = factory.ReduceElements(elements)
 simpleType = CreateSimpleType(factory, attributes, children[0])
 simpleType["doc"] = annotations
 return simpleType
 # Complex type
 def ExtractAttributes(factory, elements, base=None):
 attrs = []
 attrnames = {}
 if base is not None:
 any = {"type": ANY, "doc": annotations}
 any.update(attributes)
 return any
 def ReduceElement(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 types = []
 constraints = []
 else:
 element.update(attributes)
 return element
 else:
 raise ValueError("\"Element\" must have at least a \"ref\" or a \"name\" defined!")
 def ReduceAll(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 for child in children:
 group.update(attributes)
 return group
 # Constraint elements
 def ReduceUnique(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 unique = {"type": CONSTRAINT, "const_type": "unique", "selector": children[0], "fields": children[1:]}
 unique.update(attributes)
 return unique
 def ReduceKey(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 key = {"type": CONSTRAINT, "const_type": "key", "selector": children[0], "fields": children[1:]}
 key.update(attributes)
 return key
 def ReduceKeyRef(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 keyref = {"type": CONSTRAINT, "const_type": "keyref", "selector": children[0], "fields": children[1:]}
 keyref.update(attributes)
 return keyref
 def ReduceSelector(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 selector = {"type": CONSTRAINT, "const_type": "selector"}
 selector.update(attributes)
 return selector
 def ReduceField(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 field = {"type": CONSTRAINT, "const_type": "field"}
 field.update(attributes)
 # Inclusion elements
 def ReduceImport(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 raise ValueError("\"import\" element isn't supported yet!")
 def ReduceInclude(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 if factory.FileName is None:
 factory.ComputedClasses.update(include_factory.ComputedClasses)
 factory.ComputedClassesLookUp.update(include_factory.ComputedClassesLookUp)
 factory.EquivalentClassesParent.update(include_factory.EquivalentClassesParent)
 return None
 def ReduceRedefine(factory, attributes, elements):
 annotations, children = factory.ReduceElements(elements)
 raise ValueError("\"redefine\" element isn't supported yet!")
 infos = factory.GetQualifiedNameInfos(child["name"], factory.TargetNamespace, True)
 if infos is None:
 factory.Namespaces[factory.TargetNamespace][child["name"]] = child
 elif not CompareSchema(infos, child):
 raise ValueError("\"%s\" is defined twice in targetNamespace!" % child["name"])
 def CompareSchema(schema, reference):
 if isinstance(schema, ListType):
 if not isinstance(reference, ListType) or len(schema) != len(reference):
 return False
 if element_infos is not None:
 self.Namespaces[self.TargetNamespace][element_name] = element_infos
 return element_infos
 return None
-"""
-This function opens the xsd file and generate a xml parser with class lookup from
-the xml tree
-"""
 def GenerateParserFromXSD(filepath):
+"""
+This function opens the xsd file and generate a xml parser with class lookup from
+the xml tree
+"""
 xsdfile = open(filepath, 'r')
 xsdstring = xsdfile.read()
 xsdfile.close()
 cwd = os.getcwd()
 os.chdir(os.path.dirname(filepath))
 parser = GenerateParser(XSDClassFactory(minidom.parseString(xsdstring), filepath), xsdstring)
 os.chdir(cwd)
 return parser
-"""
-This function generate a xml from the xsd given as a string
-"""
 def GenerateParserFromXSDstring(xsdstring):
+"""
+This function generate a xml from the xsd given as a string
+"""
 return GenerateParser(XSDClassFactory(minidom.parseString(xsdstring)), xsdstring)
 #-------------------------------------------------------------------------------
 #                           XSD schema syntax elements

changeset 1736	7e61baa047f0
parent 1734	750eeb7230a1
child 1739	ec153828ded2