def to_juniper(self, device=None, commands=None, extra=None):
"""
Configure a Juniper device using JunoScript.
:returns:
list
"""
if self.verbose:
print "generating JunOS commands"
files = self.files
cmds = [Element('lock-configuration')]
for fname in files:
# fname is required to contain the full path
lc = Element('load-configuration', action='replace', format='text')
body = SubElement(lc, 'configuration-text')
if self.debug:
print "fname: " + fname
body.text = file(fname).read()
cmds.append(lc)
#commands = self.commands
if len(commands) > 0:
lc = Element('load-configuration', action='replace', format='text')
body = SubElement(lc, 'configuration-text')
body.text = '\n'.join(commands)
cmds.append(lc)
cmds.append(Element('commit-configuration'))
if self.debug:
for xml in cmds:
ET.dump(xml)
return cmds
def mapPolygons(self, polygons, atts):
att = {}
att['xmlns'] = "http://www.opengis.net/kml/2.2"
root = Element('kml')
self._addAttributes(root, att)
doc = SubElement(root, "Documemt")
folder = SubElement(doc, "Folder")
name = SubElement(folder, "name")
name.text = "IHIS Frame"
# for each polygon in the list
for bbox, polygonData, shapeAtts in polygons:
mark = SubElement(folder, "Placemark")
keys = shapeAtts.keys()
for key in keys:
keye = SubElement(mark, key)
keye.text = str(shapeAtts[key])
bbe = SubElement(mark, "bounding_box")
boundBox = {
"minx": bbox[0],
"miny": bbox[1],
"maxx": bbox[2],
"maxy": bbox[3]
}
self._addAttributes(bbe, boundBox)
# polygonsE = SubElement(pge, "polygons")
self._encodePolygons(mark, polygonData)
return ElementTree.tostring(root)
def rss2(feed, pretty_print=True):
indent = '\n ' if pretty_print else ''
indent2 = '\n ' if pretty_print else ''
rss = Element('rss', version='2.0')
rss.text = '\n ' if pretty_print else ''
channel = SubElement(rss, 'channel')
channel.text = indent
channel.tail = '\n' if pretty_print else ''
set_rss2_text(SubElement(channel, 'title'), feed.title)
set_rss2_text(SubElement(channel, 'description'), feed.subtitle or '')
SubElement(channel, 'link').text = feed.link
SubElement(channel, 'lastBuildDate').text = rss2_date(feed.updated)
if feed.language: SubElement(channel, 'language').text = feed.language
if feed.rights: SubElement(channel, 'copyright').text = feed.rights
if feed.logo:
image = SubElement(channel, 'image')
image.text = indent2
SubElement(image, 'url').text = feed.logo
SubElement(image, 'title').text = ''
SubElement(image, 'link').text = feed.link
for child in image: child.tail = indent2
image[-1].tail = '\n ' if pretty_print else ''
for entry in feed.entries:
item = entry.rss2(pretty_print)
item[-1].tail = indent
channel.append(item)
for child in channel: child.tail = indent
channel[-1].tail = '\n ' if pretty_print else ''
return rss
def _encodePolygons(self, root, polygons):
pgE = SubElement(root, "Polygon")
se = SubElement(pgE, "extrude")
se.text = "1"
ame = SubElement(pgE, "altitudeMode")
ame.text = "relativeToGround"
for incFlag, polygon in polygons:
if incFlag:
ore = SubElement(pgE, "outerBoundaryIs")
else:
ore = SubElement(pgE, "innerBoundaryIs")
lre = SubElement(ore, "LinearRing")
ce = SubElement(lre, "coordinates")
#according to the KML documentation, coordinates must follow the
#right-hand rule, i.e., coordinates specified in counterclockwise
#order.
if self._clockwise(polygon):
polygon = self._reversePolygon(polygon)
text = ""
polygon = self.reducePolygon(polygon)
for i in xrange(0, len(polygon), 2):
text = text + str(polygon[i]) + "," + str(
polygon[i + 1]) + "\n"
ce.text = text
def test_3x32mb_download_from_xml(self):
'''Download three randomly-generated 32MB files from a GT server
via an XML manifest'''
uuid1 = self.data_upload_test(1024 * 1024 * 32)
uuid2 = self.data_upload_test(1024 * 1024 * 32)
uuid3 = self.data_upload_test(1024 * 1024 * 32)
uuids = [uuid1, uuid2, uuid3]
# build a XML result set
result_set = Element('ResultSet')
result_1 = SubElement(result_set, 'Result')
analysis_data_uri_1 = SubElement(result_1, 'analysis_data_uri')
analysis_data_uri_1.text = '%s/cghub/data/analysis/download/' \
% TestConfig.HUB_SERVER + str(uuid1)
result_2 = SubElement(result_set, 'Result')
analysis_data_uri_2 = SubElement(result_2, 'analysis_data_uri')
analysis_data_uri_2.text = '%s/cghub/data/analysis/download/' \
% TestConfig.HUB_SERVER + str(uuid2)
result_3 = SubElement(result_set, 'Result')
analysis_data_uri_3 = SubElement(result_3, 'analysis_data_uri')
analysis_data_uri_3.text = '%s/cghub/data/analysis/download/' \
% TestConfig.HUB_SERVER + str(uuid3)
doc = ElementTree(result_set)
f = NamedTemporaryFile(delete=False, suffix='.xml')
doc.write(f)
f.close()
self.data_download_test_xml(f.name, uuids)
os.remove(f.name)
def _create_variables(self, state_variables):
for var_name, var in state_variables.iteritems():
var_element = SubElement(self.service_state_table_element,
"stateVariable")
if var.send_events:
var_element.attrib['sendEvents'] = 'yes'
else:
var_element.attrib['sendEvents'] = 'no'
element = SubElement(var_element, "name")
element.text = var.name
element = SubElement(var_element, "dataType")
element.text = var.data_type
element = SubElement(var_element, "defaultValue")
element.text = var.get_value()
# <allowedValueList>
allowed_value_list_element = SubElement(var_element,
"allowedValueList")
for allowed_value in var.allowed_values:
element = SubElement(allowed_value_list_element,
"allowedValue")
element.text = allowed_value
def to_juniper(self, device=None, commands=None, extra=None):
"""
Configure a Juniper device using JunoScript.
:returns:
list
"""
if self.verbose:
print "generating JunOS commands"
files = self.files
cmds = [Element('lock-configuration')]
for fname in files:
# fname is required to contain the full path
lc = Element('load-configuration', action='replace', format='text')
body = SubElement(lc, 'configuration-text')
if self.debug:
print "fname: " + fname
body.text = file(fname).read()
cmds.append(lc)
#commands = self.commands
if len(commands) > 0:
lc = Element('load-configuration', action='replace', format='text')
body = SubElement(lc, 'configuration-text')
body.text = '\n'.join(commands)
cmds.append(lc)
cmds.append(Element('commit-configuration'))
if self.debug:
for xml in cmds:
ET.dump(xml)
return cmds
def inner_get(self, request, type=""):
from xml.etree.cElementTree import Element, SubElement, tostring
import httplib2
import json
if not type.lower() in self.recognised_types:
raise InvalidPlutoType(
"{0} is not a recognised pluto type".format(type))
xmlroot = Element(
'ItemSearchDocument',
{'xmlns': 'http://xml.vidispine.com/schema/vidispine'})
fieldEl = SubElement(xmlroot, 'field')
nameEl = SubElement(fieldEl, 'name')
nameEl.text = 'gnm_type'
valueEl = SubElement(fieldEl, 'value')
valueEl.text = type
facetEl = SubElement(xmlroot, 'facet', {'count': 'true'})
ffieldEl = SubElement(facetEl, 'field')
ffieldEl.text = self.recognised_types[type]['status_field']
searchDoc = tostring(xmlroot, encoding="UTF-8")
(headers, content) = self._make_vidispine_request(
httplib2.Http(), "PUT", "/API/search;number=0", searchDoc,
{'Accept': 'application/json'})
data = json.loads(content)
return Response({'status': 'ok', 'data': self.process_facets(data)})
def generateFeature (self):
featureMember = Element('gml:featureMember')
feature = SubElement(featureMember, 'ogr:' + self.featuretag)
# set the fid.
for node in self.nodes:
if node['name'] == 'fid':
feature.attrib['fid'] = node['text'].strip()
# generate the id node.
SubElement(feature, "ogr:id").text = self.featureid
# generate the child nodes.
for node in self.nodes:
newElement = SubElement(feature, 'ogr:' + node['name'])
newElement.text = node['text'].strip()
if node['type'] in {'gml:CurvePropertyType', 'gml:DiscreteCoverageType',
'gml:PointPropertyType', 'gml:SurfacePropertyType'}:
geomElement = SubElement(newElement, 'ogr:geometryProperty')
geomElement.text = node['text'].strip()
for n in node['node']:
self.rebuildElement(geomElement, n)
# set the 'srsName' in child node.
iter = geomElement.iter("*")
gmlElement = next(islice(iter, 1, None), None)
gmlElement.attrib['srsName'] = 'EPSG:4612'
elif node['type'] == 'gml:TimeInstantType':
lastElement = deque(node['node'], maxlen=1).pop()
newElement.text = lastElement['text'].strip()
ElementTree(featureMember).write(self.fh, 'utf-8')
self.fh.write("\n")
def _addElements(self,
element,
atts,
mappings={},
timeFields=[],
skipFields=[]):
if atts is not None:
keys = atts.keys()
for key in keys:
if key in skipFields:
continue #don't want this in the output XML
value = atts[key]
if value is not None:
elementMappings = mappings.get(key, key)
if type(elementMappings) in [tuple, list]:
elementName = elementMappings[0]
subElementName = elementMappings[1]
else:
elementName = elementMappings
subElementName = "item"
subE = SubElement(element, elementName)
if type(value) in [tuple, list]:
for indValue in value:
indE = SubElement(subE, subElementName)
if key in timeFields:
self._encodeTimeField(indE, value)
else:
indE.text = str(indValue)
else:
if key in timeFields:
self._encodeTimeField(subE, value)
else:
subE.text = str(value)
def to_juniper(self, dev, commands=None, extra=None):
if commands is None:
commands = []
cmds = [Element('lock-configuration')]
files = self.files
action = self.action
if action == 'overwrite':
action = 'override'
for fname in files:
#log.msg("fname: %s" % fname)
filecontents = ''
if not os.path.isfile(fname):
fname = tftp_dir + fname
try:
filecontents = file(fname).read()
except IOError as e:
log.msg("Unable to open file: %s" % fname)
if filecontents == '':
continue
lc = Element('load-configuration', action=action, format='text')
body = SubElement(lc, 'configuration-text')
body.text = filecontents
cmds.append(lc)
if len(commands) > 0:
lc = Element('load-configuration', action=action, format='text')
body = SubElement(lc, 'configuration-text')
body.text = "\n".join(commands)
cmds.append(lc)
cmds.append(Element('commit-configuration'))
return cmds
def test_process_data(self):
import os
# Write input MDF file
in_out = InOut()
test_file = in_out.open_write(self.mdf_format.options.input)
test_file.write(
"\_sh v3.0 123 MDF 4.0\n\_DateStampHasFourDigitYear\n\n")
test_file.write("\lx hello\n\\test toto\n")
test_file.close()
del in_out
# Build expected XML result
tb_data = Element("toolbox_data")
header = SubElement(tb_data, "header")
sh = SubElement(header, "_sh")
sh.text = "v3.0 123 MDF 4.0"
lx_group = SubElement(tb_data, "lxGroup")
lx = SubElement(lx_group, "lx")
lx.text = "hello"
test = SubElement(lx_group, "test")
test.text = "toto"
tree = ElementTree(element=tb_data)
# Process with NLTK
self.mdf_format.process_data()
# Test XML result
self.assertEqual(tostring(self.mdf_format.first_element),
tostring(tb_data))
# Remove input file
os.remove(self.mdf_format.options.input)
# Release
del tree, tb_data
def returnStatus(self, status, messageString=None):
root = Element('ihis')
ele = SubElement(root, "status")
ele.text = str(status)
if messageString is not None:
msgE = SubElement(ele, "message")
msgE.text = str(messageString)
return ElementTree.tostring(root)
def atom(feed, pretty_print=True):
indent = '\n ' if pretty_print else ''
xml = Element(atomtag('feed')) #, **nsmap_keyargs) # lxml
xml.text = indent
if feed.base:
xml.set('{http://www.w3.org/XML/1998/namespace}base', feed.base)
if feed.language:
xml.set('{http://www.w3.org/XML/1998/namespace}lang',
feed.language)
title = SubElement(xml, atomtag('title'))
set_atom_text(title, feed.title)
if feed.subtitle:
subtitle = SubElement(xml, atomtag('summary'))
set_atom_text(subtitle, feed.subtitle)
link = SubElement(xml, atomtag('link'), href=feed.link)
if feed.feed_link:
feed_link = SubElement(xml,
atomtag('link'),
rel='self',
href=feed.feed_link)
updated = SubElement(xml, atomtag('updated'))
updated.text = atom_date(feed.updated)
id = SubElement(xml, atomtag('id'))
id.text = feed.id
if feed.author:
author = atom_author(feed.author)
xml.append(author)
if feed.rights:
rights = SubElement(xml, atomtag('rights'))
set_atom_text(rights, feed.rights)
if feed.icon:
icon = SubElement(xml, atomtag('icon'))
icon.text = feed.icon
if feed.logo:
logo = SubElement(xml, atomtag('logo'))
logo.text = feed.logo
for entry in feed.entries:
entry_xml = entry.atom(pretty_print)
entry_xml[-1].tail = indent
xml.append(entry_xml)
for child in xml:
child.tail = indent
xml[-1].tail = '\n' if pretty_print else ''
return xml
def _update_xml_item(self, xml_item, item):
if item.image:
image_el = SubElement(xml_item, 'image')
image_el.text = item.image
addons_el = SubElement(xml_item, 'addons')
for addon_id in item:
addon_id_el = SubElement(addons_el, 'addon_id')
addon_id_el.text = addon_id
return xml_item
def _update_xml_item(self, xml_item, item):
if item.image:
image_el = SubElement(xml_item, 'image')
image_el.text = item.image
addons_el = SubElement(xml_item, 'addons')
for addon_id in item:
addon_id_el = SubElement(addons_el, 'addon_id')
addon_id_el.text = addon_id
return xml_item
def _convert_command(
element: str,
elements: List[Any],
index: int,
iterable: Iterator[int],
parent: Element,
):
_get_prefix_element(element, parent)
if element == r"\substack":
parent = SubElement(parent, "mstyle", scriptlevel="1")
params, tag, attributes = COMMANDS[element]
if len(elements) - 1 < params:
mo = SubElement(parent, "mo")
mo.text = element[1:]
return
new_parent = SubElement(parent, tag, attributes)
alignment = ""
if element in MATRICES and (element.endswith("*") or element == r"\array"):
index += 1
alignment = elements[index]
next(iterable)
if element in (r"\lim", r"\inf", r"\sup", r"\max", r"\min"):
limit = SubElement(new_parent, "mo")
limit.text = element[1:]
for j in range(params):
index += 1
param = elements[index]
if element == "_" and index == 1 and param == r"\sum":
new_parent.tag = "munder"
_classify(param, new_parent)
elif element == r"\left" or element == r"\right":
if param == ".":
pass
else:
symbol = convert_symbol(param)
new_parent.text = param if symbol is None else "&#x{};".format(
symbol)
elif element == r"\array":
_convert_array_content(param, new_parent, alignment)
elif element in MATRICES:
_convert_matrix_content(param, new_parent, alignment,
element == r"\substack")
else:
if isinstance(param, list):
_parent = SubElement(new_parent, "mrow")
_classify_subgroup(param, _parent)
else:
_classify(param, new_parent)
_get_postfix_element(element, parent)
if element in (r"\overline", r"\bar"):
mo = SubElement(new_parent, "mo", stretchy="true")
mo.text = "¯"
elif element == r"\underline":
mo = SubElement(new_parent, "mo", stretchy="true")
mo.text = "̲"
[next(iterable) for _ in range(params)]
def atom(entry, pretty_print=True):
indent = '\n ' if pretty_print else ''
xml = Element(atomtag('entry')) #, **nsmap_keyargs) # lxml
xml.text = indent
if entry.base:
xml.set('{http://www.w3.org/XML/1998/namespace}base', entry.base)
if entry.language:
xml.set('{http://www.w3.org/XML/1998/namespace}lang',
entry.language)
link = SubElement(xml, atomtag('link'), href=entry.link)
title = SubElement(xml, atomtag('title'))
set_atom_text(title, entry.title)
updated = SubElement(xml, atomtag('updated'))
updated.text = atom_date(entry.updated)
id = SubElement(xml, atomtag('id'))
id.text = entry.id
if entry.summary:
summary = SubElement(xml, atomtag('summary'))
set_atom_text(summary, entry.summary)
if entry.content:
content = SubElement(xml, atomtag('content'))
set_atom_text(content, entry.content)
if entry.enclosure:
href, media_type, length = entry.enclosure
enclosure = SubElement(xml,
atomtag('link'),
rel='enclosure',
href=href,
type=media_type,
length=length)
if entry.author:
author = atom_author(entry.author)
xml.append(author)
if entry.rights:
rights = SubElement(xml, atomtag('rights'))
set_atom_text(rights, entry.rights)
if entry.published:
published = SubElement(xml, atomtag('published'))
published.text = atom_date(entry.published)
for child in xml:
child.tail = indent
xml[-1].tail = '\n' if pretty_print else ''
return xml
def veto_xml(veto_root, freq, band, comment):
vetoIdx = SubElement(veto_root, "veto_band")
indent(vetoIdx, 2)
vetoIdx.set('comment', 'notch (' + comment + ')')
vetoIdx_band = SubElement(vetoIdx, "band")
vetoIdx_band.text = str(band)
indent(vetoIdx_band, 3)
vetoIdx_band = SubElement(vetoIdx, "freq")
vetoIdx_band.text = str(freq)
indent(vetoIdx_band, 3)
return vetoIdx
def rebuildElement (self, parentElement, node):
newElement = SubElement(parentElement, node['name'])
newElement.text = node['text'].strip()
if node['name'] in {'gml:pos', 'gml:posList'}:
# convert the lat/lon -> lon/lat.
contentlist = newElement.text.split("\n")
newElement.text = ' '.join( [ x[1] + "," + x[0] for x in [x.split() for x in contentlist if x != ""]] )
for n in node['node']:
self.rebuildElement(newElement, n)
def _add_dataset_to_element(dataset, element):
"""Adds a dataset object to an element, which is the parent in
the ElementTree."""
dataset_el = SubElement(element, 'dataset')
for key in parameters.keys_required:
sub_el = SubElement(dataset_el, key)
sub_el.text = str(getattr(dataset, key))
for key in parameters.keys_optional:
if getattr(dataset, key) is not None:
sub_el = SubElement(dataset_el, key)
sub_el.text = str(getattr(dataset, key))
def _create_arguments(self, argument_list_element, arguments):
for arg in arguments:
arg_element = SubElement(argument_list_element, "argument")
element = SubElement(arg_element, "name")
element.text = arg.name
element = SubElement(arg_element, "direction")
element.text = arg.direction
element = SubElement(arg_element, "relatedStateVariable")
element.text = arg.state_var.name
def _create_arguments(self, argument_list_element, arguments):
for arg in arguments:
arg_element = SubElement(argument_list_element, "argument")
element = SubElement(arg_element, "name")
element.text = arg.name
element = SubElement(arg_element, "direction")
element.text = arg.direction
element = SubElement(arg_element, "relatedStateVariable")
element.text = arg.state_var.name
def create_new_epg(args, original_epg_filename, m3u_entries):
output_str("creating new xml epg for {} m3u items".format(
len(m3u_entries)))
original_tree = parse(original_epg_filename)
original_root = original_tree.getroot()
new_root = Element("tv")
new_root.set("source-info-name", "py-m3u-epg-editor")
new_root.set("generator-info-name", "py-m3u-epg-editor")
new_root.set("generator-info-url", "py-m3u-epg-editor")
# create a channel element for every channel present in the m3u
for channel in original_root.iter('channel'):
channel_id = channel.get("id")
if any(x.tvg_id == channel_id for x in m3u_entries):
output_str("creating channel element for {}".format(channel_id))
new_channel = SubElement(new_root, "channel")
new_channel.set("id", channel_id)
for elem in channel:
new_elem = SubElement(new_channel, elem.tag)
new_elem.text = elem.text
for attr_key in elem.keys():
attr_val = elem.get(attr_key)
new_elem.set(attr_key, attr_val)
# now copy all programme elements from the original epg for every channel present in the m3u
no_epg_channels = []
for entry in m3u_entries:
if entry.tvg_id is not None and entry.tvg_id != "" and entry.tvg_id != "None":
output_str("creating programme elements for {}".format(
entry.tvg_name))
channel_xpath = 'programme[@channel="' + entry.tvg_id + '"]'
for elem in original_tree.iterfind(channel_xpath):
if is_in_range(args, elem):
programme = SubElement(new_root, elem.tag)
for attr_key in elem.keys():
attr_val = elem.get(attr_key)
programme.set(attr_key, attr_val)
for sub_elem in elem:
new_elem = SubElement(programme, sub_elem.tag)
new_elem.text = sub_elem.text
for attr_key in sub_elem.keys():
attr_val = sub_elem.get(attr_key)
new_elem.set(attr_key, attr_val)
else:
no_epg_channels.append("'{}'".format(entry.tvg_name.lower()))
indent(new_root)
tree = ElementTree(new_root)
save_no_epg_channels(args, no_epg_channels)
return tree
def atom(feed, pretty_print=True):
indent = '\n ' if pretty_print else ''
xml = Element(atomtag('feed')) #, **nsmap_keyargs) # lxml
xml.text = indent
if feed.base: xml.set('{http://www.w3.org/XML/1998/namespace}base', feed.base)
if feed.language: xml.set('{http://www.w3.org/XML/1998/namespace}lang', feed.language)
title = SubElement(xml, atomtag('title'))
set_atom_text(title, feed.title)
if feed.subtitle:
subtitle = SubElement(xml, atomtag('summary'))
set_atom_text(subtitle, feed.subtitle)
link = SubElement(xml, atomtag('link'), href=feed.link)
if feed.feed_link:
feed_link = SubElement(xml, atomtag('link'), rel='self', href=feed.feed_link)
updated = SubElement(xml, atomtag('updated'))
updated.text = atom_date(feed.updated)
id = SubElement(xml, atomtag('id'))
id.text = feed.id
if feed.author:
author = atom_author(feed.author)
xml.append(author)
if feed.rights:
rights = SubElement(xml, atomtag('rights'))
set_atom_text(rights, feed.rights)
if feed.icon:
icon = SubElement(xml, atomtag('icon'))
icon.text = feed.icon
if feed.logo:
logo = SubElement(xml, atomtag('logo'))
logo.text = feed.logo
for entry in feed.entries:
entry_xml = entry.atom(pretty_print)
entry_xml[-1].tail = indent
xml.append(entry_xml)
for child in xml: child.tail = indent
xml[-1].tail = '\n' if pretty_print else ''
return xml
def generateWay (self, attr):
featureMember = Element("gml:featureMember")
feature = SubElement(featureMember, "way")
FID = SubElement(feature, "osm_id")
FID.text = str(attr["id"])
geometryProperty = SubElement(feature, "gml:geometryProperty")
lineString = SubElement(geometryProperty, "gml:LineString")
coordinates = SubElement(lineString, "gml:coordinates")
coordinates.text = " ".join(map(lambda x: "%s,%s" % x, attr['nodes']))
for k, v in attr.iteritems():
if (k != "nodes") and (k!="") and ((k in exportTags) or exportAll):
SubElement(feature, "" + k).text = v
ElementTree(featureMember).write(self.fh, "utf-8")
self.fh.write("\n")
def rebuildElement(self, parentElement, node):
newElement = SubElement(parentElement, node['name'])
newElement.text = node['text'].strip()
if node['name'] in {'gml:pos', 'gml:posList'}:
# convert the lat/lon -> lon/lat.
contentlist = newElement.text.split("\n")
newElement.text = ' '.join([
x[1] + "," + x[0]
for x in [x.split() for x in contentlist if x != ""]
])
for n in node['node']:
self.rebuildElement(newElement, n)
def generateNode (self, attr):
featureMember = Element("gml:featureMember")
feature = SubElement(featureMember, "node")
FID = SubElement(feature, "osm_id")
FID.text = str(attr["id"])
geometryProperty = SubElement(feature, "gml:geometryProperty")
lineString = SubElement(geometryProperty, "gml:Point")
coordinates = SubElement(lineString, "gml:coordinates")
coordinates.text = ("%s,%s" % self.node[attr["id"]])
for k, v in attr.iteritems():
if (k!="") and ((k in exportTags) or exportAll):
SubElement(feature, "" + k).text = v
ElementTree(featureMember).write(self.fh, "utf-8")
self.fh.write("\n")
def test_writer(self):
a = Element('a')
b = SubElement(a, 'b')
b.append(Comment('a comment'))
c = SubElement(b, 'c', d = 'e')
f = SubElement(c, 'f')
f.text = 'g'
h = SubElement(c, 'h')
h.text = 'i << >> << &&'
b.append(ProcessingInstruction('pdk', 'processing instruction'))
tree = ElementTree(a)
output = stringio()
write_pretty_xml(tree, output)
self.assert_equals_long(expected_xml_output, output.getvalue())
def create_document_annotation(doc_class,src):
"""Creates a document-level 'Fluid collection-status' annotation."""
root = Element('annotations')
root.set('textSource',src)
annotation_body = SubElement(root,'annotation')
mentionid = random.randint(1,200000)
mention = SubElement(annotation_body,'mention')
mention.set('id',str(mentionid))
annotatorID = SubElement(annotation_body,'annotator')
annotatorID.set('id','eHOST_2010')
annotatorID.text = 'FC_FINDER'
token_span = (0,15)
span = SubElement(annotation_body,"span",{"start":str(token_span[0]),"end":str(token_span[1])})
spannedText = SubElement(annotation_body,'spannedText')
spannedText.text = 'first word'
creationDate = SubElement(annotation_body,"creationDate")
creationDate.text = time.strftime("%c")
stringSlotMention = SubElement(root,'stringSlotMention')
stringSlotMention.set('id',str(mentionid+1))
mentionSlot = SubElement(stringSlotMention,'mentionSlot')
mentionSlot.set('id','existence')
stringSlotValue = SubElement(stringSlotMention,'stringSlotMentionValue')
stringSlotValue.set('value',doc_class)
classMention = SubElement(root,'classMention')
classMention.set('id',str(mentionid))
hasSlotMention = SubElement(classMention,'hasSlotMention')
hasSlotMention.set('id',str(mentionid+1))
mentionClass = SubElement(classMention,'mentionClass')
mentionClass.set('id','Fluid collection-status')
mentionClass.text = 'first word'
adjudication_status = SubElement(root,'eHOST_Adjudication_Status')
adjudication_status.set('version','1.0')
selected_annotators = SubElement(adjudication_status,'Adjudication_Selected_Annotators')
selected_annotators.set('version','1.0')
selected_classes = SubElement(adjudication_status,'Adjudication_Selected_Classes')
selected_classes.set('version','1.0')
adjudication_others = SubElement(adjudication_status,'Adjudication_Others')
check_spans = SubElement(adjudication_others,'CHECK_OVERLAPPED_SPANS')
check_spans.text = 'false'
check_attributes = SubElement(adjudication_others,'CHECK_ATTRIBUTES')
check_attributes.text = 'false'
check_relationship = SubElement(adjudication_others,'CHECK_RELATIONSHIP')
check_relationship.text = 'false'
check_class = SubElement(adjudication_others,'CHECK_CLASS')
check_class.text = 'false'
check_comment = SubElement(adjudication_others,'CHECK_COMMENT')
check_comment.text = 'false'
XMLstring = prettify(root)
return XMLstring
def mapType(self, maptype, atts):
root = Element('ihis')
ele = SubElement(root, "map_type")
if maptype is not None:
ele.text = maptype
self._addAttributes(ele, atts)
return ElementTree.tostring(root)
def create_xml_item(self, item):
log.logDebug("%s create xml item - %s"%(self,item))
log.debug("{0} create xml item - {1}".format(self, toString(item)))
import time
from datetime import datetime
t = datetime.now()
t1 = t.timetuple()
uid = int(time.mktime(t1))
if item.id:
item.id = uid
#log.logDebug("%s create xml item - %s already exists, skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
item_id = item.get_id()
if self.find_item_by_id(item_id):
item_id = uid
item.id = uid
#log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
addon_id = item.addon_id
xml_item = SubElement(self.xml_root_element.find('items'), 'item')
xml_item.set('id', toUnicode(item_id))
xml_item.set('ctime', str(datetime.now()))
if addon_id:
xml_item.set('addon_id', toUnicode(addon_id))
name = SubElement(xml_item, 'name')
name.text = toUnicode(item.name)
params = SubElement(xml_item, 'params')
for key, value in item.params.iteritems():
params.set(toUnicode(key), toUnicode(value))
item.id = item_id
return xml_item
def setMentionXML(self):
classMention = Element("classMention")
classMention.set("id", self.getMentionID())
mentionClass = SubElement(classMention, "mentionClass")
mentionClass.set("id", self.getMentionClass())
mentionClass.text = self.getText()
self.MentionXML = classMention
def create_xml_item(self, item):
log.logDebug("%s create xml item - %s" % (self, item))
log.debug("{0} create xml item - {1}".format(self, toString(item)))
import time
from datetime import datetime
t = datetime.now()
t1 = t.timetuple()
uid = int(time.mktime(t1))
if item.id:
item.id = uid
#log.logDebug("%s create xml item - %s already exists, skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
item_id = item.get_id()
if self.find_item_by_id(item_id):
item_id = uid
item.id = uid
#log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
addon_id = item.addon_id
xml_item = SubElement(self.xml_root_element.find('items'), 'item')
xml_item.set('id', toUnicode(item_id))
xml_item.set('ctime', str(datetime.now()))
if addon_id:
xml_item.set('addon_id', toUnicode(addon_id))
name = SubElement(xml_item, 'name')
name.text = toUnicode(item.name)
params = SubElement(xml_item, 'params')
for key, value in item.params.iteritems():
params.set(toUnicode(key), toUnicode(value))
item.id = item_id
return xml_item
def create_xml_item(self, item):
log.debug("{0} create xml item - {1}".format(self, item))
if item.id:
log.debug(
'{0} create xml item - {1} already exists, skipping'.format(
self, item))
return
item_id = item.get_id()
if self.find_item_by_id(item_id):
log.debug(
'{0} create xml item - {1} already exists, skipping'.format(
self, item))
return
addon_id = item.addon_id
xml_item = SubElement(self.xml_root_element.find('items'), 'item')
xml_item.set('id', str(item_id))
xml_item.set('ctime', str(datetime.now()))
if addon_id:
xml_item.set('addon_id', str(addon_id))
name = SubElement(xml_item, 'name')
name.text = item.name
params = SubElement(xml_item, 'params')
for key, value in item.params.iteritems():
params.set(str(key), str(value))
item.id = item_id
return xml_item
def save_config(path, save_name, config_string):
songbook_xml = parse(path)
config_section = songbook_xml.find('configuration')
# create the config section if we must
if config_section is None:
config_section = SubElement(songbook_xml.getroot(), 'configuration')
# search for formatter config section named save_name
formatter_node = None
for node in config_section.findall('formatter'):
if node.get('name').lower().strip() == save_name.lower().strip():
formatter_node = node
break # we found our formatter node
if formatter_node is None: # didn't find existing formatter_node
formatter_node = SubElement(config_section, 'formatter')
formatter_node.set('name', save_name.strip())
# now we have a formatter node
formatter_node.text = config_string
# now save back to file
songbook_xml.write(path)
def get_element(self):
# <root>
elt = Element('scpd', xmlns = 'urn:schemas-upnp-org:' +
UPnPDefaults.SERVICE_SCHEMA_VERSION)
# <specVersion>
spec_version_element = SubElement(elt, 'specVersion')
element = SubElement(spec_version_element, 'major')
element.text = UPnPDefaults.SCHEMA_VERSION_MAJOR
element = SubElement(spec_version_element, 'minor')
element.text = UPnPDefaults.SCHEMA_VERSION_MINOR
# <actionList> and <serviceStateTable>
action_list_element, service_state_table_element = ServiceXMLGenerator(self.service).generate()
elt.append(action_list_element)
elt.append(service_state_table_element)
return elt
def mapBasename(self, basename, atts):
root = Element('ihis')
ele = SubElement(root, "map_basename")
if basename is not None:
ele.text = basename
self._addAttributes(ele, atts)
return ElementTree.tostring(root)
def asMvXml(self, parentnode):
""" Return an XML node for this player suitable for MumbleViewer-ng. """
from xml.etree.cElementTree import SubElement
me = SubElement(parentnode, "item", id=self.id, rel='user')
content = SubElement(me, "content")
name = SubElement(content, "name")
name.text = self.name
def atom(entry, pretty_print=True):
indent = '\n ' if pretty_print else ''
xml = Element(atomtag('entry')) #, **nsmap_keyargs) # lxml
xml.text = indent
if entry.base: xml.set('{http://www.w3.org/XML/1998/namespace}base', entry.base)
if entry.language: xml.set('{http://www.w3.org/XML/1998/namespace}lang', entry.language)
link = SubElement(xml, atomtag('link'), href=entry.link)
title = SubElement(xml, atomtag('title'))
set_atom_text(title, entry.title)
updated = SubElement(xml, atomtag('updated'))
updated.text = atom_date(entry.updated)
id = SubElement(xml, atomtag('id'))
id.text = entry.id
if entry.summary:
summary = SubElement(xml, atomtag('summary'))
set_atom_text(summary, entry.summary)
if entry.content:
content = SubElement(xml, atomtag('content'))
set_atom_text(content, entry.content)
if entry.enclosure:
href, media_type, length = entry.enclosure
enclosure = SubElement(xml, atomtag('link'),
rel='enclosure', href=href, type=media_type, length=length)
if entry.author:
author = atom_author(entry.author)
xml.append(author)
if entry.rights:
rights = SubElement(xml, atomtag('rights'))
set_atom_text(rights, entry.rights)
if entry.published:
published = SubElement(xml, atomtag('published'))
published.text = atom_date(entry.published)
for child in xml: child.tail = indent
xml[-1].tail = '\n' if pretty_print else ''
return xml
def hazardDetails(self, details, atts):
root = Element('ihis')
ele = SubElement(root, "hazard_details")
self._addAttributes(ele, atts)
if details is not None:
for hazCode, actions, category in details:
pe = SubElement(ele, "hazard_detail")
hazCodeE = SubElement(pe, "hazard_code")
hazCodeE.text = hazCode
ae = SubElement(pe, "action_codes")
for action in actions:
ase = SubElement(ae, "action_code")
ase.text = action
ce = SubElement(pe, "hazard_category")
ce.text = category
return ElementTree.tostring(root)
def products(self, productList, atts):
root = Element('ihis')
ele = SubElement(root, "product_categories")
self._addAttributes(ele, atts)
for product in productList:
pe = SubElement(ele, "product_category")
pe.text = product
return ElementTree.tostring(root)
def write(self, node, data): dt = SubElement(node, 'dt') dt.text = str(data.dt) midi_event = SubElement(node, 'MidiEvent') event = MidiEventFactory.get(data.event.value) event.write(midi_event, data.event)
def write(self, node, data): dt = SubElement(node, 'dt') dt.text = str(data.dt) meta_event = SubElement(node, 'MetaEvent') event = MetaEventFactory.get(data.event.type) event.write(meta_event, data.event)
def write(self, node, data): dt = SubElement(node, 'dt') dt.text = str(data.dt) sysex_event = SubElement(node, 'SysExEvent') event = SysExEventFactory.get(data.event.value) event.write(sysex_event, data.event)
def __build(self, node, builder):
for child in node.children:
if child.namespace != child.rootNamespace:
if child.nsMapper.get(child.namespace):
child.tag = child.nsMapper[child.namespace] + ":" + child.tag
_sub = SubElement(builder, child.tag, child.attrib)
if child.hasText:
_sub.text = child.text
self.__build(child, _sub)
def write(self, data, filename):
"""Creates a sportstracker weights file at filename containing the
data; data is an AllDatasets instance."""
id_ = 1
weightlist_el = Element('weight-list')
for dataset in data:
weight_el = SubElement(weightlist_el, 'weight')
id_el = SubElement(weight_el, 'id')
id_el.text = str(id_)
date_el = SubElement(weight_el, 'date')
date_el.text = str(dataset.date) + 'T12:00:00'
value_el = SubElement(weight_el, 'value')
value_el.text = str(dataset.weight)
comment_el = SubElement(weight_el, 'comment')
comment_el.text = dataset.note
id_ += 1
st_tree = ElementTree(weightlist_el)
st_tree.write(filename, encoding='UTF-8')
def get_element(self):
# <root>
elt = Element('root', xmlns = 'urn:schemas-upnp-org:' +
UPnPDefaults.SCHEMA_VERSION)
# <specVersion>
spec_version_element = SubElement(elt, 'specVersion')
element = SubElement(spec_version_element, 'major')
element.text = UPnPDefaults.SCHEMA_VERSION_MAJOR
element = SubElement(spec_version_element, 'minor')
element.text = UPnPDefaults.SCHEMA_VERSION_MINOR
# <urlBase>
if self.url_base != None:
element = SubElement(elt, 'URLBase')
element.text = self.url_base
# <device>
elt.append(DeviceXMLGenerator(self.device, self.extra_elts).generate())
return elt
def _create_actions(self, actions):
for action_name, action in actions.iteritems():
action_element = SubElement(self.action_list_element, "action")
element = SubElement(action_element, "name")
element.text = action.name
# <argumentList>
argument_list_element = SubElement(action_element, "argumentList")
if action.arguments:
self._create_arguments(argument_list_element, action.arguments)
def xmlnode(root, name, text="", **attrs):
"Simple way to attach an ElementTree node."
elem = SubElement(root, name) if root is not None else Element(name)
if text:
elem.text = text
for k, v in attrs.iteritems():
elem.set(k, v)
return elem
def _dict_xml_node(data, parent):
"""Traverse the dict data under the root key"""
if isinstance(data, dict):
for elem, value in six.iteritems(data):
sub = SubElement(parent, elem)
sub.text = _dict_xml_node(value, sub)
elif isinstance(data, list):
for entry in data:
_dict_xml_node(entry, parent)
else:
return data
def set_comment(self, text):
meta_data_elem = self._graph_pair.get_meta_data()
comment_elem = meta_data_elem.find("comment")
if text.strip():
if comment_elem is None:
comment_elem = SubElement(meta_data_elem, "comment")
comment_elem.text = text
elif comment_elem:
meta_data_elem.remove(comment_elem)
self._changed = True
def to_xml(self, filename, id2name):
results_tag = Element("Results")
dataset_tag = SubElement(results_tag, "Dataset")
dataset_tag.text = "Test"
stories_tag = SubElement(results_tag, "Stories")
for story in self:
story_elem = SubElement(stories_tag, "Story", {"StoryId": str(story["story_id"])})
tags = SubElement(story_elem, "Tags")
for tag in story["tags"]:
SubElement(tags, "Tag", {"OrgID": str(tag), "Company": id2name[tag], "Relevance": "H"})
ET.ElementTree(results_tag).write(filename)
def _create_icon_list(self):
#<device><iconList>
device_icons = self.device.icons
if len(device_icons) > 0:
icon_list_element = SubElement(self.device_element, "iconList")
for device_icon in device_icons:
icon_element = SubElement(icon_list_element, "icon")
element = SubElement(icon_element, "mimetype")
element.text = device_icon.get_mimetype()
element = SubElement(icon_element, "width")
element.text = device_icon.get_width()
element = SubElement(icon_element, "height")
element.text = device_icon.get_height()
element = SubElement(icon_element, "depth")
element.text = device_icon.get_depth()
element = SubElement(icon_element, "url")
element.text = device_icon.get_url()
def _create_variables(self, state_variables):
for var_name, var in state_variables.iteritems():
var_element = SubElement(self.service_state_table_element, "stateVariable")
if var.send_events:
var_element.attrib['sendEvents'] = 'yes'
else:
var_element.attrib['sendEvents'] = 'no'
element = SubElement(var_element, "name")
element.text = var.name
element = SubElement(var_element, "dataType")
element.text = var.data_type
element = SubElement(var_element, "defaultValue")
element.text = var.get_value()
# <allowedValueList>
allowed_value_list_element = SubElement(var_element, "allowedValueList")
for allowed_value in var.allowed_values:
element = SubElement(allowed_value_list_element, "allowedValue")
element.text = allowed_value
def build(root, channels):
if channels:
for reference, namealternatives in channels.iteritems():
name, alternatives = namealternatives[:]
if alternatives:
# Add channel
web = alternatives[0]
element = SubElement(root, "channel", name=stringToXML(name), id=stringToXML(web))
element.text = stringToXML(reference)
del alternatives[0]
if alternatives:
for web in alternatives:
SubElement(element, "web").text = stringToXML(web)
return root
