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 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 __init__(self):
    self.data = Element("data")

    entityRendererElement = SubElement(self.data, "mtg:EntityRenderer")

    entityRendererElement.attrib['xmlns:mtg'] = 'http://maltego.paterva.com/xml/mtgx'

    self.position = SubElement(entityRendererElement, "mtg:Position")

	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 add_entity_property(self, parent, prop, value):
    propertyElement = SubElement(parent, "mtg:Property")

    propertyElement.attrib = {
      'name': prop.get('name'),
      'type': prop.get('dataType', 'string')
    }

    SubElement(propertyElement, "mtg:Value").text = value

 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 _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 _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 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 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 save_project(project):
        root = Element("project")
        root.set("name", project.get_name())
        files_node = SubElement(root, "files")
        for filename in project.get_files():
            f_node = SubElement(files_node, "file")
            f_node.set("path", filename)

        with open(project.get_file(), "w") as f:
            f.write(utils.get_pretty_xml(root))
            f.flush()

 def save_edge(edge, parent_node_el):
     edge_el = SubElement(parent_node_el, "arc")
     edge_el.set("node-id", edge.get_target().get_id())
     edge_el.set("label", edge.get_label())
     edge_el.set("events-count", str(edge.get_events_count()))
     edge_el.set("time", str(edge.get_time()))
     edge_el.set("pids", str(edge.get_pids()))
     return edge_el

    def _create_embedded_devices(self):
        if self.device.is_root_device():
            embedded_devices = self.device.devices

            if len(embedded_devices) > 0:
                device_list_element = SubElement(self.device_element,
                                                 "deviceList")
                for embedded_device in embedded_devices.values():
                    embedded_device_description = DeviceXMLGenerator(
                                                            embedded_device)
                    device_list_element.append(embedded_device_description.
                                               generate())

    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 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 edx(self, out_dir):
        chapter_dir = os.path.join(out_dir, 'chapter')
        if not os.path.exists(chapter_dir):
            os.makedirs(chapter_dir)
        chapter = Element('chapter', {'display_name':escape(self.project)});
        for group in self.groups:
            e = SubElement(chapter, 'sequential')
            e.set('url_name', group.url_name())
        tree = ElementTree(chapter)
        tree.write(os.path.join(chapter_dir, "{0}.xml".format(self.url_name())) )

        for group in self.groups:
            group.edx(out_dir)

 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

	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 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")