beremiz: comparison xmlclass/xsdschema.py

equal deleted inserted replaced

-:14b40afccd69
+:6198190bc121
 def GenerateSimpleTypeXMLText(function):
 def generateXMLTextMethod(value, name=None, indent=0):
 text = ""
 if name is not None:
-ind1, ind2 = getIndent(indent, name)
+ind1, _ind2 = getIndent(indent, name)
 text += ind1 + "<%s>" % name
 text += function(value)
 if name is not None:
 text += "</%s>\n" % name
 return text
 if decimal is not None else str)
 def generateXMLTextMethod(value, name=None, indent=0):
 text = ""
 if name is not None:
-ind1, ind2 = getIndent(indent, name)
+ind1, _ind2 = getIndent(indent, name)
 text += ind1 + "<%s>" % name
 if isinstance(value, IntType):
 text += str(value)
 elif value in extra_values or value % 1 != 0:
 text += float_format(value)
 return {"type": "documentation", "source": attributes.get("source", None),
 "language": attributes.get("lang", "any"), "content": "\n".join(elements)}
 def ReduceAnnotation(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+_annotations, children = factory.ReduceElements(elements)
 annotation = {"type": "annotation", "appinfo": [], "documentation": {}}
 for child in children:
 if child["type"] == "appinfo":
 annotation["appinfo"].append((child["source"], child["content"]))
 elif child["type"] == "documentation":
 # Simple type elements
 def GenerateFacetReducing(facetname, canbefixed):
 def ReduceFacet(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+annotations, _children = factory.ReduceElements(elements)
 if "value" in attributes:
 facet = {"type": facetname, "value": attributes["value"], "doc": annotations}
 if canbefixed:
 facet["fixed"] = attributes.get("fixed", False)
 return facet
 facets[facettype] = facetvalue
 # Generate extract value for new created type
 def ExtractSimpleTypeValue(attr, extract=True):
 value = basetypeinfos["extract"](attr, extract)
-for facetname, (facetvalue, facetfixed) in facets.items():
+for facetname, (facetvalue, _facetfixed) in facets.items():
 if facetvalue is not None:
 if facetname == "enumeration" and value not in facetvalue:
 raise ValueError("\"%s\" not in enumerated values" % value)
 elif facetname == "length" and len(value) != facetvalue:
 raise ValueError("value must have a length of %d" % facetvalue)
 elif facetvalue == "collapse":
 value = GetToken(value, False)
 return value
 def CheckSimpleTypeValue(value):
-for facetname, (facetvalue, facetfixed) in facets.items():
+for facetname, (facetvalue, _facetfixed) in facets.items():
 if facetvalue is not None:
 if facetname == "enumeration" and value not in facetvalue:
 return False
 elif facetname == "length" and len(value) != facetvalue:
 return False
 else:
 raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])
 return True
 def SimpleTypeInitialValue():
-for facetname, (facetvalue, facetfixed) in facets.items():
+for facetname, (facetvalue, _facetfixed) in facets.items():
 if facetvalue is not None:
 if facetname == "enumeration":
 return facetvalue[0]
 elif facetname == "length":
 return " "*facetvalue
 simpleContent["type"] = "simpleContent"
 return simpleContent
 def ReduceComplexContent(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+_annotations, children = factory.ReduceElements(elements)
 complexContent = children[0].copy()
 complexContent["type"] = "complexContent"
 return complexContent
 # Elements groups
 def ReduceAny(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+annotations, _children = factory.ReduceElements(elements)
 any = {"type": ANY, "doc": annotations}
 any.update(attributes)
 return any
 # Constraint elements
 def ReduceUnique(factory, attributes, elements):
-annotations, children = factory.ReduceElements(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)
+_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)
+_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)
+factory.ReduceElements(elements)
 selector = {"type": CONSTRAINT, "const_type": "selector"}
 selector.update(attributes)
 return selector
 def ReduceField(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+factory.ReduceElements(elements)
 field = {"type": CONSTRAINT, "const_type": "field"}
 field.update(attributes)
 return field
 # Inclusion elements
 def ReduceImport(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+factory.ReduceElements(elements)
 raise ValueError("\"import\" element isn't supported yet!")
 def ReduceInclude(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+factory.ReduceElements(elements)
 if factory.FileName is None:
 raise ValueError("Include in XSD string not yet supported")
 filepath = attributes["schemaLocation"]
 if filepath is not None and not os.path.exists(filepath):
 factory.EquivalentClassesParent.update(include_factory.EquivalentClassesParent)
 return None
 def ReduceRedefine(factory, attributes, elements):
-annotations, children = factory.ReduceElements(elements)
+factory.ReduceElements(elements)
 raise ValueError("\"redefine\" element isn't supported yet!")
 # Schema element
 factory.TargetNamespace = factory.DefinedNamespaces.get(targetNamespace, None)
 if factory.TargetNamespace is not None:
 factory.etreeNamespaceFormat = "{%s}%%s" % targetNamespace
 factory.Namespaces[factory.TargetNamespace] = {}
-annotations, children = factory.ReduceElements(elements, True)
+_annotations, children = factory.ReduceElements(elements, True)
 for child in children:
 if "name" in child:
 infos = factory.GetQualifiedNameInfos(child["name"], factory.TargetNamespace, True)
 if infos is None:
 raise ValueError("\"%s\" isn't of the expected type!" % element_name)
 return element
 def CreateSchemaElement(self, element_name, element_type):
 for type, attributes, elements in self.Schema[2]:
-namespace, name = DecomposeQualifiedName(type)
+_namespace, name = DecomposeQualifiedName(type)
 if attributes.get("name", None) == element_name:
 element_infos = None
 if element_type in (ATTRIBUTE, None) and name == "attribute":
 element_infos = ReduceAttribute(self, attributes, elements)
 elif element_type in (ELEMENT, None) and name == "element":

changeset 1847	6198190bc121
parent 1846	14b40afccd69
child 1849	6811021e3d94