def parse_plots(plot_types, table_overrides):
def get_module_base(n):
return n
def get_super_base(n):
return "plot"
module_specs = []
for plot in plot_types:
port_specs = {}
print "========================================"
print plot
print "========================================"
(plot, module_name, super_name) = \
get_names(plot, get_module_base, get_super_base, "Mpl", "")
try:
plot_obj = getattr(matplotlib.pyplot, plot)
except AttributeError:
print '*** CANNOT ADD PLOT "%s";' \
'IT DOES NOT EXIST IN THIS MPL VERSION ***' % plot
continue
port_specs_list = parse_argspec(plot_obj)
for port_spec in port_specs_list:
port_specs[port_spec.arg] = port_spec
docstring = plot_obj.__doc__
if plot == 'contour':
# want to change the double newline to single newline...
print "&*&* FINDING:", \
docstring.find("*extent*: [ *None* | (x0,x1,y0,y1) ]\n\n")
docstring = docstring.replace("*extent*: [ *None* | (x0,x1,y0,y1) ]\n\n",
"*extent*: [ *None* | (x0,x1,y0,y1) ]\n")
if plot == 'annotate':
docstring = docstring % dict((k,v) for k, v in matplotlib.docstring.interpd.params.iteritems() if k == 'Annotation')
elif plot == 'barbs':
docstring = docstring % dict((k,v) for k,v in matplotlib.docstring.interpd.params.iteritems() if k == 'barbs_doc')
cleaned_docstring, output_port_specs = \
process_docstring(docstring, port_specs, ('pyplot', plot),
table_overrides)
# for port_spec in port_specs.itervalues():
# if port_spec.defaults is not None:
# port_spec.defaults = [str(v) for v in port_spec.defaults]
# if port_spec.values is not None:
# port_spec.values = [[str(v) for v in port_spec.values[0]]]
# for alt_ps in port_spec.alternate_specs:
# if alt_ps.defaults is not None:
# alt_ps.defaults = [str(v) for v in alt_ps.defaults]
# if alt_ps.values is not None:
# alt_ps.values = [[str(v) for v in alt_ps.values[0]]]
module_specs.append(ModuleSpec(module_name, super_name,
"matplotlib.pyplot.%s" % plot,
cleaned_docstring, port_specs.values(),
output_port_specs))
my_specs = SpecList(module_specs)
return my_specs
def generate_from_specs(fname, out_fname, template_fname):
specs = SpecList.read_from_xml(fname)
template = Template(filename=template_fname, module_directory='/tmp/mako')
f = open(out_fname, 'wb') # 'b' ensures that we always use LF line endings
f.write(template.render(specs=specs))
f.close()
def generate_from_specs(fname, out_fname, template_fname):
specs = SpecList.read_from_xml(fname)
template = Template(filename=template_fname, module_directory="/tmp/mako")
f = open(out_fname, "wb") # 'b' ensures that we always use LF line endings
f.write(template.render(specs=specs))
f.close()
def apply_diff(in_fname, diff_fname, out_fname):
in_specs = SpecList.read_from_xml(in_fname)
in_refs = dict((spec.code_ref, (i, spec))
for i, spec in enumerate(in_specs.module_specs))
in_ips_refs = dict(((spec.code_ref, ps.arg), (i, ps))
for spec in in_specs.module_specs
for i, ps in enumerate(spec.port_specs))
in_ops_refs = dict(((spec.code_ref, ps.arg), (i, ps))
for spec in in_specs.module_specs
for i, ps in enumerate(spec.output_port_specs))
in_alt_refs = dict(((spec.code_ref, ps.arg, alt_ps.name), (i, ps))
for spec in in_specs.module_specs
for ps in spec.port_specs
for i, alt_ps in enumerate(ps.alternate_specs))
tree = ET.parse(diff_fname)
for elt in tree.getroot():
if elt.tag == "changeCustomCode":
val = elt.getchildren()[0].text
in_specs.custom_code = val
continue
code_ref = elt.get("code_ref")
m_spec = in_refs[code_ref][1]
port = elt.get("port", None)
if port:
port_type = elt.get("type")
if port_type == "alternate":
alt_name = elt.get("altName")
if elt.tag.startswith('delete'):
if port:
if port_type == "input":
idx = in_ips_refs[(code_ref, port)][0]
del m_spec.port_specs[idx]
elif port_type == 'output':
idx = in_ops_refs[(code_ref, port)][0]
del m_spec.output_port_specs[idx]
elif port_type == 'alternate':
ps = in_ips_refs[(code_ref, port)][1]
idx = in_alt_refs[(code_ref, port, alt_name)][0]
del ps.alternate_specs[idx]
else:
raise ValueError('Cannot access list of type "%s"' %
port_type)
else:
idx = in_refs[code_ref][0]
del in_specs.module_specs[idx]
elif elt.tag.startswith('add'):
for child in elt.getchildren():
if child.tag == 'value':
for subchild in child.getchildren():
value = subchild
if port:
if port_type == "input":
m_spec.port_specs.append(InputPortSpec.from_xml(value))
elif port_type == "output":
m_spec.output_port_specs.append(
OutputPortSpec.from_xml(value))
elif port_type == "alternate":
ps = in_ips_refs[(code_ref, port)][1]
ps.alternate_specs.append(AlternatePortSpec.from_xml(value))
else:
raise ValueError('Cannot access list of type "%s"' %
port_type)
else:
in_specs.module_specs.append(ModuleSpec.from_xml(value))
elif elt.tag.startswith('change'):
attr = elt.get("attr")
for child in elt.getchildren():
if child.tag == 'value':
value = child.text
if port:
# KLUDGE to fix change from output_type to port_type
if attr == "output_type":
attr = "port_type"
if port_type == "input":
port_spec = in_ips_refs[(code_ref, port)][1]
setattr(port_spec, attr, value)
elif port_type == "output":
port_spec = in_ops_refs[(code_ref, port)][1]
setattr(port_spec, attr, value)
elif port_type == "alternate":
port_spec = in_alt_refs[(code_ref, port, alt_name)][1]
setattr(port_spec, attr, value)
else:
setattr(m_spec, attr, value)
in_specs.write_to_xml(out_fname)
def compute_diff(in_fname, out_fname, diff_fname):
in_specs = SpecList.read_from_xml(in_fname)
out_specs = SpecList.read_from_xml(out_fname)
in_refs = dict((spec.code_ref, spec) for spec in in_specs.module_specs)
out_refs = dict((spec.code_ref, spec) for spec in out_specs.module_specs)
in_refs_set = set(in_refs.iterkeys())
out_refs_set = set(out_refs.iterkeys())
root = ET.Element("diff")
if in_specs.custom_code != out_specs.custom_code:
elt = ET.Element("changeCustomCode")
subelt = ET.Element("value")
subelt.text = out_specs.custom_code
elt.append(subelt)
root.append(elt)
for ref in in_refs_set - out_refs_set:
print "- %s" % ref
elt = ET.Element("deleteModule")
elt.set("code_ref", ref)
root.append(elt)
for code_ref, out_spec in out_refs.iteritems():
# need to check port specs, which removed, which added
if code_ref not in in_refs:
print "+ %s %s" % (ref, ET.tostring(out_spec.to_xml()))
elt = ET.Element("addModule")
elt.set("code_ref", ref)
subelt = ET.Element("value")
subelt.append(out_spec.to_xml())
elt.append(subelt)
root.append(elt)
continue
in_spec = in_refs[code_ref]
for attr in ModuleSpec.attrs:
in_val = getattr(in_spec, attr)
out_val = getattr(out_spec, attr)
if in_val != out_val:
print "C %s.%s %s" % (out_spec.code_ref, attr, out_val)
elt = ET.Element("changeModule")
elt.set("code_ref", out_spec.code_ref)
elt.set("attr", attr)
subelt = ET.Element("value")
subelt.text = str(out_val)
elt.append(subelt)
root.append(elt)
compute_ps_diff(root, in_spec.port_specs, out_spec.port_specs,
code_ref, "input")
compute_ps_diff(root, in_spec.output_port_specs,
out_spec.output_port_specs,
code_ref, "output")
tree = ET.ElementTree(root)
def indent(elem, level=0):
i = "\n" + level*" "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
indent(elem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
indent(tree.getroot())
tree.write(diff_fname)
def compute_diff(in_fname, out_fname, diff_fname):
in_specs = SpecList.read_from_xml(in_fname)
out_specs = SpecList.read_from_xml(out_fname)
in_refs = dict((spec.code_ref, spec) for spec in in_specs.module_specs)
out_refs = dict((spec.code_ref, spec) for spec in out_specs.module_specs)
in_refs_set = set(in_refs.iterkeys())
out_refs_set = set(out_refs.iterkeys())
root = ET.Element("diff")
if in_specs.custom_code != out_specs.custom_code:
elt = ET.Element("changeCustomCode")
subelt = ET.Element("value")
subelt.text = out_specs.custom_code
elt.append(subelt)
root.append(elt)
for ref in in_refs_set - out_refs_set:
# print 'code reference "%s" removed' % ref
print "- %s" % ref
elt = ET.Element("deleteModule")
elt.set("code_ref", ref)
root.append(elt)
for code_ref, out_spec in out_refs.iteritems():
# need to check port specs, which removed, which added
if code_ref not in in_refs:
# print 'code reference "%s" added' % code_ref
print "+ %s %s" % (ref, ET.tostring(out_spec.to_xml()))
elt = ET.Element("addModule")
elt.set("code_ref", ref)
subelt = ET.Element("value")
subelt.append(out_spec.to_xml())
elt.append(subelt)
root.append(elt)
continue
in_spec = in_refs[code_ref]
for attr in ModuleSpec.attrs:
in_val = getattr(in_spec, attr)
out_val = getattr(out_spec, attr)
if in_val != out_val:
print "C %s.%s %s" % (out_spec.code_ref, attr, out_val)
elt = ET.Element("changeModule")
elt.set("code_ref", out_spec.code_ref)
elt.set("attr", attr)
subelt = ET.Element("value")
subelt.text = str(out_val)
elt.append(subelt)
root.append(elt)
# if in_spec.name != out_spec.name:
# # print 'name of ref "%s" changed from "%s" to "%s"' % \
# # (out_spec.code_ref, in_spec.name, out_spec.name)
# print "C %s.name %s" % (out_spec.code_ref, out_spec.name)
# if in_spec.superklass != out_spec.superklass:
# print 'superclass of ref "%s" changed from "%s" to "%s"' % \
# (out_spec.code_ref, in_spec.superklass, out_spec.superklass)
compute_ps_diff(root, in_spec.port_specs, out_spec.port_specs,
code_ref, "input")
compute_ps_diff(root, in_spec.output_port_specs,
out_spec.output_port_specs,
code_ref, "output")
# out_port_specs = dict((ps.arg, ps) for ps in out_spec.port_specs)
# in_port_specs = dict((ps.arg, ps) for ps in in_spec.port_specs)
# out_port_specs_set = set(out_port_specs.iterkeys())
# in_port_specs_set = set(in_port_specs.iterkeys())
# for arg in in_port_specs_set - out_port_specs_set:
# # print 'argument "%s" of code reference "%s" removed' % \
# # (arg, code_ref)
# print "- %s.%s" % (code_ref, arg)
# for arg, out_ps in out_port_specs.iteritems():
# if arg not in in_port_specs:
# # print 'argument "%s" of code reference "%s" added' % \
# # (arg, code_ref)
# print "+ %s.%s" % (code_ref, arg)
# print ET.tostring(out_ps.to_xml())
# continue
# in_ps = in_port_specs[arg]
# # attrs = ['name', 'port_type', 'docstring', 'hide', 'entry_types',
# # 'values', 'defaults', 'translations']
# for attr in PortSpec.attrs:
# in_val = getattr(in_ps, attr)
# out_val = getattr(out_ps, attr)
# if in_val != out_val:
# # print '%s of argument "%s" changed from "%s" to "%s"' % \
# # (attr, arg, in_val, out_val)
# print "C %s.%s.%s %s" % (code_ref, arg, attr, out_val)
tree = ET.ElementTree(root)
def indent(elem, level=0):
i = "\n" + level*" "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
indent(elem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
indent(tree.getroot())
tree.write(diff_fname)
def apply_diff(in_fname, diff_fname, out_fname):
in_specs = SpecList.read_from_xml(in_fname)
in_refs = dict((spec.code_ref, (i, spec))
for i, spec in enumerate(in_specs.module_specs))
in_ips_refs = dict(((spec.code_ref, ps.arg), (i, ps))
for spec in in_specs.module_specs
for i, ps in enumerate(spec.port_specs))
in_ops_refs = dict(((spec.code_ref, ps.arg), (i, ps))
for spec in in_specs.module_specs
for i, ps in enumerate(spec.output_port_specs))
in_alt_refs = dict(((spec.code_ref, ps.arg, alt_ps.name), (i, ps))
for spec in in_specs.module_specs
for ps in spec.port_specs
for i, alt_ps in enumerate(ps.alternate_specs))
tree = ET.parse(diff_fname)
for elt in tree.getroot():
if elt.tag == "changeCustomCode":
val = elt.getchildren()[0].text
in_specs.custom_code = val
continue
code_ref = elt.get("code_ref")
m_spec = in_refs[code_ref][1]
port = elt.get("port", None)
if port:
port_type = elt.get("type")
if port_type == "alternate":
alt_name = elt.get("altName")
if elt.tag.startswith('delete'):
if port:
if port_type == "input":
idx = in_ips_refs[(code_ref, port)][0]
del m_spec.port_specs[idx]
elif port_type == 'output':
idx = in_ops_refs[(code_ref, port)][0]
del m_spec.output_port_specs[idx]
elif port_type == 'alternate':
ps = in_ips_refs[(code_ref, port)][1]
idx = in_alt_refs[(code_ref, port, alt_name)][0]
del ps.alternate_specs[idx]
else:
raise ValueError('Cannot access list of type "%s"' %
port_type)
else:
idx = in_refs[code_ref][0]
del in_specs.module_specs[idx]
elif elt.tag.startswith('add'):
for child in elt.getchildren():
if child.tag == 'value':
for subchild in child.getchildren():
value = subchild
if port:
if port_type == "input":
m_spec.port_specs.append(InputPortSpec.from_xml(value))
elif port_type == "output":
# print "VALUE:", ET.tostring(value)
m_spec.output_port_specs.append(
OutputPortSpec.from_xml(value))
elif port_type == "alternate":
ps = in_ips_refs[(code_ref, port)][1]
ps.alternate_specs.append(AlternatePortSpec.from_xml(value))
else:
raise ValueError('Cannot access list of type "%s"' %
port_type)
else:
in_specs.module_specs.append(ModuleSpec.from_xml(value))
elif elt.tag.startswith('change'):
attr = elt.get("attr")
for child in elt.getchildren():
if child.tag == 'value':
value = child.text
if port:
# KLUDGE to fix change from output_type to port_type
if attr == "output_type":
attr = "port_type"
if port_type == "input":
port_spec = in_ips_refs[(code_ref, port)][1]
setattr(port_spec, attr, value)
elif port_type == "output":
port_spec = in_ops_refs[(code_ref, port)][1]
setattr(port_spec, attr, value)
elif port_type == "alternate":
port_spec = in_alt_refs[(code_ref, port, alt_name)][1]
setattr(port_spec, attr, value)
else:
setattr(m_spec, attr, value)
# with f = open(diff_fname):
# f_iter = f.__iter__()
# for line in f_iter:
# line = line.strip()
# if not re.match("[+-C]", line):
# raise RuntimeError("Problem parsing line\n%s" % line)
# if line.startswith('-'):
# arr = line.split(' ', 1)
# prop = arr[1].split('.')
# if len(prop) < 2:
# idx = in_refs[prop[0]][0]
# del in_specs.module_specs[idx]
# else:
# m_specs = in_refs[prop[0]][1]
# if prop[1] == 'input':
# idx = in_ips_refs[prop[0], prop[2]][0]
# del m_specs.port_specs[idx]
# elif prop[1] == 'output':
# idx = in_ops_refs[prop[0], prop[2]][0]
# del m_specs.output_port_specs[idx]
# else:
# raise ValueError('Cannot access list of type "%s"' %
# prop[1])
# elif line.startswith('+'):
# arr = line.split(' ', 2)
# prop = arr[1].split('.')
# if len(prop) < 2:
# in_specs.module_specs.append(ModuleSpec.from_xml(arr[2]))
# line.split(' ', 2)
in_specs.write_to_xml(out_fname)
def parse_artists(artist_types, table_overrides={}):
def get_module_name(obj):
return obj.__name__
def get_super_name(obj):
for base in obj.__bases__:
if issubclass(base, Artist):
return base.__name__
return ""
module_specs = []
for klass in artist_types:
(klass, module_name, super_name) = \
get_names(klass, get_module_name, get_super_name, "Mpl",
"Properties")
port_specs = {}
insp = ArtistInspector(klass)
klass_name = klass.__name__
klass_qualname = klass.__module__ + "." + klass_name
for (s, t) in insp._get_setters_and_targets():
print "** %s **" % s
if t.rsplit('.', 1)[0] != klass_qualname:
# let inheritance work
continue
if s in port_specs:
raise ValueError('duplicate port "%s"' % s)
port_spec = InputPortSpec(s)
port_specs[s] = port_spec
accepts_raw = insp.get_valid_values(s)
(accepts, deflists, tables, call_sigs) = \
parse_docutils_str(accepts_raw)
if len(deflists) + len(tables) > 0:
raise ValueError("accepts has deflists and/or tables")
(port_types, option_strs, default_val, allows_none) = \
parse_description(accepts)
if default_val is not None:
port_spec.default_val = default_val
if len(option_strs) > 0:
port_spec.entry_types = ['enum']
port_spec.values = [option_strs]
port_spec.hide = False
docstring = getattr(insp.o, 'set_' + s).__doc__
if docstring is None:
docstring = ""
else:
docstring = docstring % matplotlib.docstring.interpd.params
match = _get_accepts_regex.search(docstring)
if match is not None:
print "STARTING DOCSTRING:", docstring
groups = match.groups()
if len(groups) > 2 and groups[2]:
docstring = groups[0] + groups[2]
else:
docstring = groups[0]
print "FIXED DOCSTRING:", docstring
(cleaned_docstring, args, tables, call_sigs) = \
parse_docutils_str(docstring)
port_spec.docstring = cleaned_docstring
translations = None
for (table_intro, header, rows) in tables:
print "TABLE:", table_intro
if (klass.__name__, s, table_intro) in table_overrides:
(override_type, opts) = \
table_overrides[(klass.__name__, s, table_intro)]
if override_type == "translation":
do_translation_override(port_specs, s, rows, opts)
continue
elif override_type == "ports":
table_intro = "kwarg"
elif override_type == "skip":
continue
if len(header) != 2:
raise ValueError("Table not two columns!")
if translations is not None:
raise ValueError("Two translations in one attr")
(translations, pt2, values) = parse_translation(rows)
port_spec.translations = translations
port_spec.values = [values]
port_types.extend(pt2)
resolve_port_type(port_types, port_spec)
constructor_port_specs = {}
port_specs_list = parse_argspec(klass.__init__)
for port_spec in port_specs_list:
constructor_port_specs[port_spec.arg] = port_spec
constructor_docstring = klass.__init__.__doc__
if constructor_docstring is not None:
_, output_port_specs = process_docstring(
constructor_docstring, constructor_port_specs,
(klass.__name__, '__init__'), table_overrides)
for arg, ps in constructor_port_specs.iteritems():
if arg not in port_specs:
ps.constructor_arg = True
ps.required = False
port_specs[arg] = ps
module_spec = ModuleSpec(module_name, super_name, klass_qualname,
klass.__doc__, port_specs.values())
module_specs.append(module_spec)
my_specs = SpecList(module_specs)
return my_specs
def apply_diff(in_fname, diff_fname, out_fname):
in_specs = SpecList.read_from_xml(in_fname)
in_refs = dict((spec.code_ref, (i, spec))
for i, spec in enumerate(in_specs.module_specs))
in_ips_refs = dict(((spec.code_ref, ps.arg), (i, ps))
for spec in in_specs.module_specs
for i, ps in enumerate(spec.port_specs))
in_ops_refs = dict(((spec.code_ref, ps.arg), (i, ps))
for spec in in_specs.module_specs
for i, ps in enumerate(spec.output_port_specs))
in_alt_refs = dict(((spec.code_ref, ps.arg, alt_ps.name), (i, ps))
for spec in in_specs.module_specs
for ps in spec.port_specs
for i, alt_ps in enumerate(ps.alternate_specs))
tree = ET.parse(diff_fname)
for elt in tree.getroot():
if elt.tag == "changeCustomCode":
val = elt.getchildren()[0].text
in_specs.custom_code = val
continue
code_ref = elt.get("code_ref")
m_spec = in_refs[code_ref][1]
port = elt.get("port", None)
if port:
port_type = elt.get("type")
if port_type == "alternate":
alt_name = elt.get("altName")
if elt.tag.startswith('delete'):
if port:
if port_type == "input":
idx = in_ips_refs[(code_ref, port)][0]
del m_spec.port_specs[idx]
elif port_type == 'output':
idx = in_ops_refs[(code_ref, port)][0]
del m_spec.output_port_specs[idx]
elif port_type == 'alternate':
ps = in_ips_refs[(code_ref, port)][1]
idx = in_alt_refs[(code_ref, port, alt_name)][0]
del ps.alternate_specs[idx]
else:
raise ValueError('Cannot access list of type "%s"' %
port_type)
else:
idx = in_refs[code_ref][0]
del in_specs.module_specs[idx]
elif elt.tag.startswith('add'):
for child in elt.getchildren():
if child.tag == 'value':
for subchild in child.getchildren():
value = subchild
if port:
if port_type == "input":
m_spec.port_specs.append(InputPortSpec.from_xml(value))
elif port_type == "output":
m_spec.output_port_specs.append(
OutputPortSpec.from_xml(value))
elif port_type == "alternate":
ps = in_ips_refs[(code_ref, port)][1]
ps.alternate_specs.append(
AlternatePortSpec.from_xml(value))
else:
raise ValueError('Cannot access list of type "%s"' %
port_type)
else:
in_specs.module_specs.append(ModuleSpec.from_xml(value))
elif elt.tag.startswith('change'):
attr = elt.get("attr")
for child in elt.getchildren():
if child.tag == 'value':
value = child.text
if port:
# KLUDGE to fix change from output_type to port_type
if attr == "output_type":
attr = "port_type"
if port_type == "input":
port_spec = in_ips_refs[(code_ref, port)][1]
setattr(port_spec, attr, value)
elif port_type == "output":
port_spec = in_ops_refs[(code_ref, port)][1]
setattr(port_spec, attr, value)
elif port_type == "alternate":
port_spec = in_alt_refs[(code_ref, port, alt_name)][1]
setattr(port_spec, attr, value)
else:
setattr(m_spec, attr, value)
in_specs.write_to_xml(out_fname)
def compute_diff(in_fname, out_fname, diff_fname):
in_specs = SpecList.read_from_xml(in_fname)
out_specs = SpecList.read_from_xml(out_fname)
in_refs = dict((spec.code_ref, spec) for spec in in_specs.module_specs)
out_refs = dict((spec.code_ref, spec) for spec in out_specs.module_specs)
in_refs_set = set(in_refs.iterkeys())
out_refs_set = set(out_refs.iterkeys())
root = ET.Element("diff")
if in_specs.custom_code != out_specs.custom_code:
elt = ET.Element("changeCustomCode")
subelt = ET.Element("value")
subelt.text = out_specs.custom_code
elt.append(subelt)
root.append(elt)
for ref in in_refs_set - out_refs_set:
print "- %s" % ref
elt = ET.Element("deleteModule")
elt.set("code_ref", ref)
root.append(elt)
for code_ref, out_spec in out_refs.iteritems():
# need to check port specs, which removed, which added
if code_ref not in in_refs:
print "+ %s %s" % (ref, ET.tostring(out_spec.to_xml()))
elt = ET.Element("addModule")
elt.set("code_ref", ref)
subelt = ET.Element("value")
subelt.append(out_spec.to_xml())
elt.append(subelt)
root.append(elt)
continue
in_spec = in_refs[code_ref]
for attr in ModuleSpec.attrs:
in_val = getattr(in_spec, attr)
out_val = getattr(out_spec, attr)
if in_val != out_val:
print "C %s.%s %s" % (out_spec.code_ref, attr, out_val)
elt = ET.Element("changeModule")
elt.set("code_ref", out_spec.code_ref)
elt.set("attr", attr)
subelt = ET.Element("value")
subelt.text = str(out_val)
elt.append(subelt)
root.append(elt)
compute_ps_diff(root, in_spec.port_specs, out_spec.port_specs,
code_ref, "input")
compute_ps_diff(root, in_spec.output_port_specs,
out_spec.output_port_specs, code_ref, "output")
tree = ET.ElementTree(root)
def indent(elem, level=0):
i = "\n" + level * " "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
indent(elem, level + 1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
indent(tree.getroot())
tree.write(diff_fname)
