def toresource(self, obj, res, indent=True):
root = ElementTree.Element("metadata")
root.set('xmlns', self.NAMESPACES[0])
if not obj.__class__ == Metadata:
raise exceptions.IncorrectClassError(
'The given object is not a instance of %s' % Metadata)
for key in obj.data.keys():
prop = ElementTree.SubElement(root, 'property')
self.set_property(prop, key, obj.data[key])
if indent:
persistence.indent(root)
# To make the output the same in linux and windows
# (needed to make testing easier)
class LinesepNormalizerResource(object):
def __init__(self, resource):
self.resource = resource
def write(self, data):
if os.linesep != '\r\n':
data = data.replace(os.linesep, '\r\n')
self.resource.write(data)
res = LinesepNormalizerResource(res)
# some smarter way to implement adding of the encoding to the beginning of file
res.write('<?xml version="1.0" encoding="%s"?>%s' %
(self.encoding, os.linesep))
ElementTree.ElementTree(root).write(res)
def dumps(self, obj):
"""
@param obj: The Configuration object
"""
elem = ElementTree.Element("extensions")
for extension in obj._objects():
if isinstance(extension, api.RulemlEvalGlobals):
writer = EvalGlobalsWriter()
childelem = writer.dumps(extension)
if childelem != None:
elem.append(childelem)
else:
if extension.ns != None and extension.ns != "":
childelem = ElementTree.Element("{%s}%s" % (extension.ns, extension.tag))
else:
childelem = ElementTree.Element(extension.tag)
if extension.value != None:
childelem.text = extension.value
for attr in extension.attrs:
childelem.set(attr, extension.attrs[attr])
childs = self._dump_childen(extension._objects())
for ch in childs:
childelem.append(ch)
elem.append(childelem)
return elem
def write(self, file):
"""
write(file) -> None
Write XML to filename of file object in 'file'
"""
if DEBUG >= 0: print "in write(self, file)"
et = ElementTree(self.root)
et.write(file)
def write_element_tempfile(element, tempfile):
"""
Writes element to temp file
"""
if element != None and ElementTree.iselement(element):
try:
tempfile.write(ElementTree.tostring(element))
except Exception, e:
raise exceptions.ConeException(
'Cannot write Element to file (%s). Exception: %s' %
(tempfile, e))
def read_programmes(fp=None, tree=None):
"""
read_programmes(fp=None, tree=None) -> list
Return a list of programme dictionaries from file object 'fp' or the
ElementTree 'tree'
"""
if DEBUG >= 2: print "in read_programmes(fp=None, tree=None)"
if fp:
et = ElementTree()
tree = et.parse(fp)
return [elem_to_programme(elem) for elem in tree.findall('programme')]
def post_process_flattening(self, element):
"""
Pick just data element and build document out of it
"""
data_element = element.find("data")
if data_element == None:
self.logger.warning('No data to generate!!')
new_doc = "<?xml version=\"1.0\"?><configuration>" + "</configuration>"
else:
new_doc = "<?xml version=\"1.0\"?><configuration>" + ElementTree.tostring(
data_element) + "</configuration>"
return ElementTree.fromstring(new_doc)
def __init__(self, filename):
self.fd = gzip.open(filename)
self.xml = ElementTree()
self.xml.parse(self.fd)
self.prjs = {}
self.tasks = {}
self.resources = {}
self.vacations = []
self._process_projects()
self._process_resources()
self._process_tasks()
self._process_bookings()
self._process_vacations()
def test_read_hcrml_flag(self):
xml = '<flags Uninitialised="0" Modifiable="0" Persistent="0"/>'
etree = ElementTree.fromstring(xml)
flag = self.reader.read_hrcml_flags(etree)
self.assertEquals(flag.Uninitialised, '0')
self.assertEquals(flag.Modifiable, '0')
self.assertEquals(flag.Persistent, '0')
def _run_test_read_invalid_hcrml_setting(self, xml, expected_exception):
try:
etree = ElementTree.fromstring(xml)
setting = self.reader.read_hcrml_setting(etree)
self.fail("Expected exception not raised!")
except expected_exception:
pass
def test_parse_template_filter_2(self):
class DummyConfiguration(object):
def get_resource(self, ref):
class DummyResource(object):
def read(self): return ''
def close(self): return None
return DummyResource()
def get_default_view(self): return None
reader = templatemlplugin.TemplatemlImplReader('foo/implml/bar.implml', DummyConfiguration())
reader.fromstring(TEMPML_DOC4)
filters1 = reader.filters
filter2 = templatemlplugin.Filter()
filter2.set_code(None)
filter2.set_name("test_filter")
filter2.set_path("../../filter/filter.py")
temp1 = reader.parse_template(ElementTree.fromstring(TEMPML4))
temp2 = templatemlplugin.TempFile()
temp2.set_template('')
temp2.set_path('')
self.assertEqual(filters1[0].name, filter2.name)
self.assertEqual(filters1[0].code, filter2.code)
self.assertEqual(filters1[0].path, filter2.path)
self.assertEqual(filters1[0], filter2)
self.assertEqual(temp1.template, temp2.template)
self.assertEqual(temp1.extensions, temp2.extensions)
self.assertEqual(temp1.filters, temp2.filters)
self.assertEqual(temp1, temp2)
def dumps(self, obj):
"""
@param obj: The Option object
"""
elem = ElementTree.Element('icon',
{'xlink:href' : obj.href})
return elem
def dumps(self, obj):
"""
@param obj: The Configuration object
"""
elem = ElementTree.Element('feature',
{'ref' : obj.get_ref()})
if obj.get_name():
elem.set('name', obj.get_name())
if obj.get_type():
elem.set('type', obj.get_type())
if obj.get_id() != None:
elem.set('id', obj.get_id())
if obj.get_relevant() != None:
elem.set('relevant', obj.get_relevant())
if obj.get_constraint() != None:
elem.set('constraint', obj.get_constraint())
dump_extension_attributes(obj, elem)
for child in obj._objects():
""" Make sure that the object is mapped to an object in this model """
mobj = child._get_mapper('confml').map_object(child)
writer = get_writer_for_class(mobj.__class__.__name__)
childelem = writer.dumps(child)
if childelem != None:
elem.append(childelem)
return elem
def dumps(self, obj):
"""
@param obj: The Configuration object
"""
elem = ElementTree.Element('desc')
elem.text = obj.text
return elem
def _run_test_read_invalid_hcrml_output(self, xml, expected_exception):
try:
self.reader.doc = ElementTree.fromstring(xml)
self.reader.read_hcrml_output()
self.fail("Expected exception not raised!")
except expected_exception:
pass
def test_parse_subdir_with_definition(self):
etree = ElementTree.fromstring(
genconfgml_string.replace("target=\"output\"",
"subdir=\"include\""))
reader = genconfmlplugin.GenconfmlImplReader()
subdir = reader.parse_subdir(etree)
self.assertEquals(subdir, "include")
def test_read_hcrml_setting(self):
xml = '<setting ref="hcrexample.DebounceInterval" name="KElmGPIO_DebounceInterval" type="int32" id="0"/>'
etree = ElementTree.fromstring(xml)
setting = self.reader.read_hcrml_setting(etree)
self.assertEquals(setting.ref, 'hcrexample.DebounceInterval')
self.assertEquals(setting.name, 'KElmGPIO_DebounceInterval')
self.assertEquals(setting.type, 'int32')
self.assertEquals(setting.id, 0)
def dumps(self, obj):
"""
@param obj: The Configuration object
"""
elem = ElementTree.Element('setting',
{'ref' : obj.get_ref()})
self._set_setting_properties(elem, obj)
return elem
def read_data(fp=None, tree=None):
"""
read_data(fp=None, tree=None) -> dict
Get the source and other info from file object fp or the ElementTree
'tree'
"""
if DEBUG >= 2: print "in read_data(fp=None, tree=None)"
if fp:
et = ElementTree()
tree = et.parse(fp)
d = {}
set_attrs(d, tree,
('date', 'source-info-url', 'source-info-name',
'source-data-url', 'generator-info-name', 'generator-info-url'))
return d
def dumps(self, obj):
"""
@param obj: The ConfmlLocalPath object
"""
elem = ElementTree.Element('targetPath')
if obj.readOnly:
elem.set('readOnly', unicode(obj.readOnly))
return elem
def write_element(element, output, linesep=os.linesep):
"""
"""
if element != None and ElementTree.iselement(element):
enc = None
try:
out_file = open(output, 'w')
out_string = ElementTree.tostring(element)
out_string = out_string.replace('\r\n', linesep)
out_string = out_string.replace('\n', linesep)
out_file.write(out_string)
out_file.close()
except Exception, e:
raise exceptions.ConeException(
'Cannot write Element to file (%s). Exception: %s' %
(output, e))
def test_read_hcrml_output(self):
xml = '<hcr xmlns="%s"><output file="some/test/file.h" type="header"/></hcr>' % NAMESPACE
self.reader.doc = ElementTree.fromstring(xml)
output = self.reader.read_hcrml_output()
self.assertEquals(output.type, 'header')
self.assertEquals(output.file, 'some/test/file.h')
self.assertEquals(output.version, None)
self.assertEquals(output.read_only, None)
self.assertEquals(output.categories, [])
def dumps(self, obj):
"""
@param obj: The Configuration object
"""
ref = obj.fqr.replace('.','/')
elem = ElementTree.Element('setting',
{'ref' : ref})
self._set_setting_properties(elem, obj)
return elem
def test_parse_rules(self):
etree = ElementTree.fromstring(ruleml_string)
reader = ruleml.RuleImplReader2(None, None)
rules = reader.parse_rules("", etree)
self.assertTrue(isinstance(rules[0], relations.ConfigureRelation))
self.assertTrue(isinstance(rules[1], relations.ConfigureRelation))
self.assertTrue(rules[0].has_ref('imaker.imagetarget'))
self.assertFalse(rules[0].has_ref('imakerapi.imagename'))
self.assertTrue(rules[0].has_ref('imakerapi.outputLocation'))
def dumps(self, obj):
"""
@param obj: The facet object
"""
classname = obj.__class__.__name__
elem = ElementTree.Element(self.MAPPING[classname])
if obj.value != None:
elem.set('value', str(obj.value))
return elem
def test_parse_template_from_xinclude(self):
try:
reader = templatemlplugin.TemplatemlImplReader()
reader.fromstring(TEMPML_DOC2)
temp1 = reader.parse_template(ElementTree.fromstring(TEMPML2))
temp2 = templatemlplugin.TempFile()
temp2.set_template("include AABBCC")
except exceptions.ParseError, e:
self.fail("Known bug: ticket #2007")
def parse_stylesheet(self, etree):
"""
Parses stylesheet from getree
"""
stylesheet = ""
stylesheet_elem = etree.find("{%s}stylesheet" % self.namespaces[0])
if stylesheet_elem != None:
stylesheet = ElementTree.tostring(stylesheet_elem)
return stylesheet
def fromstring(self, xml_as_string):
meta = Metadata()
try:
etree = ElementTree.fromstring(xml_as_string)
for elem in etree.getiterator("{%s}property" % self.NAMESPACES[0]):
(key, value) = self.get_property(elem)
meta.data[key] = value
except Exception, e:
logging.getLogger('cone').warning(
"Could not read metadata! Exception %s" % (e))
def test_parse_outputs(self):
etree = ElementTree.fromstring(contentml2_string)
reader = contentmlparser.Content2Parser()
outputs = reader.parse_outputs(etree)
self.assertEquals(outputs[0].dir, 'content')
self.assertEquals(len(outputs[0].inputs), 1)
self.assertEquals(outputs[0].inputs[0].dir, 'test')
self.assertEquals(outputs[0].inputs[0].include, {'pattern': ['prod']})
self.assertEquals(outputs[1].inputs[0].dir, '${features.inputref}')
self.assertEquals(outputs[1].dir, '${features.outputref}')
def write_element_enc(element, output, enc, linesep=os.linesep):
"""
Writes element to file
"""
if element != None and ElementTree.iselement(element):
enc = None
try:
remove_namespace(element, 'http://www.s60.com/xml/genconfml/1')
out_file = codecs.open(output, 'w', enc)
output_string = ElementTree.tostring(element)
output_string = output_string.replace('\r\n', linesep)
output_string = output_string.replace('\n', linesep)
out_file.write(output_string)
out_file.close()
except Exception, e:
raise exceptions.ConeException(
'Cannot write Element to file (%s). Exception: %s' %
(output, e))
def fromstring(self, xml_as_string):
etree = ElementTree.fromstring(xml_as_string)
# Loop through parsers and try to find a match
(namespace, elemname) = get_elemname(etree.tag)
pclass = self.PARSERS.get(namespace, None)
self.parser = pclass()
self.desc = self.parser.parse_desc(etree)
self.outputs = self.parser.parse_outputs(etree)
self.phase = self.parser.parse_phase(etree)
self.tags = self.parser.parse_tags(etree)
return
def GetElementsFromXML(self,filename):
'Extracts a dictionary of elements from the gcc_xml file.'
tree = ElementTree()
try:
tree.parse(filename)
except ExpatError:
raise InvalidXMLError, 'Not a XML file: %s' % filename
root = tree.getroot()
if root.tag != 'GCC_XML':
raise InvalidXMLError, 'Not a valid GCC_XML file'
# build a dictionary of id -> element, None
elementlist = root.getchildren()
elements = {}
for element in elementlist:
id = element.get('id')
if id:
elements[id] = element, None
return elements
def __init__(self, filename):
self.fd = gzip.open(filename)
self.xml = ElementTree()
self.xml.parse(self.fd)
self.prjs = {}
self.tasks = {}
self.resources = {}
self.vacations = []
self._process_projects()
self._process_resources()
self._process_tasks()
self._process_vacations()
class Document(object):
def __init__(self, filename):
self.fd = gzip.open(filename)
self.xml = ElementTree()
self.xml.parse(self.fd)
self.prjs = {}
self.tasks = {}
self.resources = {}
self.vacations = []
self._process_projects()
self._process_resources()
self._process_tasks()
self._process_vacations()
# __init__()
def _process_projects(self):
for node in self.xml.findall("project"):
prj = Project(self, node)
self.prjs[prj.id] = prj
# _process_projects()
def _process_tasks(self):
for tl in self.xml.findall("taskList"):
for node in tl.findall("task"):
prj = self.prjs[node.get("projectId")]
task = Task(self, prj, node)
prj.tasks.append(task)
prj.register_task(task)
# _process_tasks()
def _process_resources(self):
for rl in self.xml.findall("resourceList"):
for node in rl.findall("resource"):
Resource(self, node)
# _process_resources()
def _process_vacations(self):
for vl in self.xml.findall("vacationList"):
for node in vl.findall("vacation"):
self.vacations.append(Vacation(node))
# _process_vacations()
def __str__(self):
lst = []
for p in self.prjs.itervalues():
lst.append(str(p))
return "%s(projects=[%s])" % (self.__class__.__name__, ", ".join(lst))
class Document(object):
def __init__(self, filename):
self.fd = gzip.open(filename)
self.xml = ElementTree()
self.xml.parse(self.fd)
self.prjs = {}
self.tasks = {}
self.resources = {}
self.vacations = []
self._process_projects()
self._process_resources()
self._process_tasks()
self._process_bookings()
self._process_vacations()
# __init__()
def _process_projects(self):
for node in self.xml.findall("project"):
prj = Project(self, node)
self.prjs[prj.id] = prj
# _process_projects()
def _process_tasks(self):
for tl in self.xml.findall("taskList"):
for node in tl.findall("task"):
prj = self.prjs[node.get("projectId")]
task = Task(self, prj, node)
prj.tasks.append(task)
prj.register_task(task)
# _process_tasks()
def _process_resources(self):
for rl in self.xml.findall("resourceList"):
for node in rl.findall("resource"):
Resource(self, node)
# _process_resources()
def _process_bookings(self):
for bl in self.xml.findall("bookingList"):
for rb in bl.findall("resourceBooking"):
resource = self.resources[rb.get("resourceId")]
scenario = resource.booking.setdefault(rb.get("scenarioId"), {})
for node in rb.findall("booking"):
task = scenario.setdefault(node.get("taskId"), [])
start = get_child_int(node, "start")
end = get_child_int(node, "end")
task.append(Booking(start, end))
# _process_bookings()
def _process_vacations(self):
for vl in self.xml.findall("vacationList"):
for node in vl.findall("vacation"):
self.vacations.append(Vacation(node))
#_process_vacations()
def __str__(self):
lst = []
for p in self.prjs.itervalues():
lst.append(str(p))
return "%s(projects=[%s])" % (self.__class__.__name__,
", ".join(lst))
