Python ElementTree.write方法代码示例

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def _convert_internal(parsed_ctds, **kwargs):
    # parse all input files into models using CTDopts (via utils)
    # the output is a tuple containing the model, output destination, origin file
    for parsed_ctd in parsed_ctds:
        model = parsed_ctd.ctd_model
        origin_file = parsed_ctd.input_file
        output_file = parsed_ctd.suggested_output_file

        if kwargs["skip_tools"] is not None and model.name in kwargs["skip_tools"]:
            logger.info("Skipping tool %s" % model.name, 0)
            continue
        elif kwargs["required_tools"] is not None and model.name not in kwargs["required_tools"]:
            logger.info("Tool %s is not required, skipping it" % model.name, 0)
            continue
        else:
            logger.info("Converting %s (source %s)" % (model.name, utils.get_filename(origin_file)), 0)
            tool = create_tool(model)
            write_header(tool, model)
            create_description(tool, model)
            expand_macros(tool, model, **kwargs)
            create_command(tool, model, **kwargs)
            create_inputs(tool, model, **kwargs)
            create_outputs(tool, model, **kwargs)
            create_help(tool, model)

            # wrap our tool element into a tree to be able to serialize it
            tree = ElementTree(tool)
            logger.info("Writing to %s" % utils.get_filename(output_file), 1)
            tree.write(open(output_file, 'w'), encoding="UTF-8", xml_declaration=True, pretty_print=True)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def generate_tool_conf(parsed_ctds, tool_conf_destination, galaxy_tool_path, default_category):
    # for each category, we keep a list of models corresponding to it
    categories_to_tools = dict()
    for parsed_ctd in parsed_ctds:
        category = strip(parsed_ctd.ctd_model.opt_attribs.get("category", ""))
        if not category.strip():
            category = default_category
        if category not in categories_to_tools:
            categories_to_tools[category] = []
        categories_to_tools[category].append(utils.get_filename(parsed_ctd.suggested_output_file))
                
    # at this point, we should have a map for all categories->tools
    toolbox_node = Element("toolbox")
    
    if galaxy_tool_path is not None and not galaxy_tool_path.strip().endswith("/"):
        galaxy_tool_path = galaxy_tool_path.strip() + "/"
    if galaxy_tool_path is None:
        galaxy_tool_path = ""
    
    for category, file_names in categories_to_tools.iteritems():
        section_node = add_child_node(toolbox_node, "section")
        section_node.attrib["id"] = "section-id-" + "".join(category.split())
        section_node.attrib["name"] = category
    
        for filename in file_names:
            tool_node = add_child_node(section_node, "tool")
            tool_node.attrib["file"] = galaxy_tool_path + filename

    toolconf_tree = ElementTree(toolbox_node)
    toolconf_tree.write(open(tool_conf_destination,'w'), encoding="UTF-8", xml_declaration=True, pretty_print=True)
    logger.info("Generated Galaxy tool_conf.xml in %s" % tool_conf_destination, 0)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
    def saveConfigFile(self, overrideTraces=[]):
        """This functions allows to save the current (and only)
        instance of the Workspace. You can supply a list of traces
        that should be written on-disk through the `overrideTraces`
        variable. This allows to override specific traces that where
        modified.

        :param overrideTraces: a list of trace identifiers that should
        be written on-disk, even if they already exists.
        """

        workspaceFile = os.path.join(self.path, Workspace.CONFIGURATION_FILENAME)

        logging.info("Save the config file of the workspace {0} in {1}".format(self.getName(), workspaceFile))

        # Register the namespace
        etree.register_namespace('netzob', WORKSPACE_NAMESPACE)
        etree.register_namespace('netzob-common', COMMON_NAMESPACE)

        # Dump the file
        root = etree.Element("{" + WORKSPACE_NAMESPACE + "}workspace")
        root.set("creation_date", TypeConvertor.pythonDatetime2XSDDatetime(self.getCreationDate()))
        root.set("name", str(self.getName()))

        xmlWorkspaceConfig = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}configuration")

        relTracePath = os.path.relpath(self.getPathOfTraces(), self.path)
        xmlTraces = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}traces")
        xmlTraces.text = str(self.getPathOfTraces())

        xmlLogging = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}logging")
        xmlLogging.text = str(self.getPathOfLogging())

        xmlPrototypes = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}prototypes")
        xmlPrototypes.text = str(self.getPathOfPrototypes())

        xmlPrototypes = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}enable_bug_reporting")
        xmlPrototypes.text = str(self.enableBugReporting).lower()

        xmlWorkspaceProjects = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}projects")
        for projectPath in self.getProjectsPath():
            xmlProject = etree.SubElement(xmlWorkspaceProjects, "{" + WORKSPACE_NAMESPACE + "}project")
            xmlProject.set("path", projectPath)

        xmlWorkspaceImported = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}traces")
        for importedTrace in self.getImportedTraces():
            # overrideTraces variable contains the list of
            # ImportedTraces that should be overriden. This is useful
            # in case of message removal for example.
            forceOverride = (importedTrace.id in overrideTraces)

            importedTrace.save(xmlWorkspaceImported, WORKSPACE_NAMESPACE, COMMON_NAMESPACE,
                               os.path.join(self.path, self.getPathOfTraces()), forceOverride)

        xmlWorkspaceFunctions = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}functions")
        for function in self.getCustomFunctions():
            function.save(xmlWorkspaceFunctions, WORKSPACE_NAMESPACE)

        tree = ElementTree(root)
        tree.write(workspaceFile, pretty_print=True)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
    def exportProjectAction(self, widget, data):
        chooser = gtk.FileChooserDialog(title=_("Export as (XML)"), action=gtk.FILE_CHOOSER_ACTION_SAVE,
                                        buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
        res = chooser.run()
        if res == gtk.RESPONSE_OK:
            fileName = chooser.get_filename()
        chooser.destroy()

        doCreateFile = False
        isFile = os.path.isfile(fileName)
        if not isFile:
            doCreateFile = True
        else:
            md = gtk.MessageDialog(None,
                                   gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION,
                                   gtk.BUTTONS_OK_CANCEL, _("Are you sure to override the file '{0}'?").format(fileName))
            resp = md.run()
            md.destroy()
            if resp == gtk.RESPONSE_OK:
                doCreateFile = True

        if doCreateFile:
            root = self.netzob.getCurrentProject().generateXMLConfigFile()
            tree = ElementTree(root)
            tree.write(fileName)
            NetzobInfoMessage(_("Project correctly exported to '{0}'").format(fileName))

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def dump_xml(inf, outf, pretty_print=True):
    root = Element("wild")
    game = to_xml(inf, "firered")  # XXX
    root.append(game)
    outf.write("""<?xml version="1.0" encoding="utf-8"?>\n""")
    xml = ElementTree(root)

    xml.write(outf, pretty_print=pretty_print)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
    def exportProjectApplyButton_clicked_cb(self, button):
        """Display the dialog in order to export the current project
        when the user request it through the menu."""

        logging.debug("Export project")

        try:
            selectedFolder = self.view.exportProjectFileChooserButton.get_current_folder()
            filename = self.view.exportProjectFilenameEntry.get_text()

            if selectedFolder is None:
                raise Exception(_("No directory selected"))
            elif filename is None or len(filename) == 0:
                raise Exception(_("No filename provided"))
            else:
                outputFilename = os.path.join(selectedFolder, filename)
                logging.debug("Output filename: {0}".format(outputFilename))
                overwrite = True

                if os.path.exists(outputFilename):
                    questionMsg = _("A file named \"{0}\" already exists. Do you want to replace it?").format(filename)

                    dialog = Gtk.MessageDialog(self.view.exportProject,
                                               Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
                                               Gtk.MessageType.WARNING,
                                               Gtk.ButtonsType.NONE,
                                               questionMsg)

                    dialog.format_secondary_text(_("The file already exists in \"{0}\". Replacing it will overwrite its contents.").format(selectedFolder))

                    dialog.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
                    dialog.add_button(_("Replace"), Gtk.ResponseType.YES)
                    dialog.set_default_response(Gtk.ResponseType.YES)

                    response = dialog.run()
                    dialog.destroy()

                    if response == Gtk.ResponseType.CANCEL:
                        self.view.destroy()
                        self.log.info("Export was cancelled")
                        return

                xmlDefinitionOfProject = self.project.generateXMLConfigFile()
                tree = ElementTree(xmlDefinitionOfProject)
                tree.write(outputFilename, pretty_print=True)
                self.view.destroy()

        except Exception, e:
            self.view.showErrorMessage(_("An error occurred while exporting the project."))
            logging.warn("Error when exporting project: {0}".format(e))

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
    def produce_settings_file(self, printer):
        printer_name = printer['name']
        
        tree = ElementTree()
        tree.parse(StringIO(XML_TEMPLATE.replace('\n', '').replace('\r', '').replace('\t', '')))

        name_node = tree.find('name')
        name_node.text = 'AirPrint %s @ %%h' % printer_name

        service_node = tree.find('service')

        port_node = service_node.find('port')
        port_node.text = '%d' % printer['port']
        
        host = printer['host']
        if host:
            if self.dnsdomain:
                pair = host.rsplit('.', 1)
                if len(pair) > 1:
                    host = '.'.join((pair[0], self.dnsdomain))
            service_node.append(self.new_node('host-name', host))

        txt = printer['txt']
        for key in txt:
            if self.adminurl or key != 'adminurl':
                service_node.append(self.new_txtrecord_node('%s=%s' % (key, txt[key])))

        source = printer['SOURCE'] if printer.has_key('SOURCE') else ''

        fname = '%s%s%s.service' % (self.prefix, '%s-' % source if len(source) > 0 else '', printer_name)
        
        if self.directory:
            fname = os.path.join(self.directory, fname)
        
        f = open(fname, 'w')

        if etree:
            tree.write(f, pretty_print=True, xml_declaration=True, encoding="UTF-8")
        else:
            xmlstr = tostring(tree.getroot())
            doc = parseString(xmlstr)
            dt= minidom.getDOMImplementation('').createDocumentType('service-group', None, 'avahi-service.dtd')
            doc.insertBefore(dt, doc.documentElement)
            doc.writexml(f)
        f.close()
        
        if self.verbose:
            src = source if len(source) > 0 else 'unknown'
            sys.stderr.write('Created from %s: %s%s' % (src, fname, os.linesep))

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def serialize_browse_layers(browse_layers, stream=None, pretty_print=False):
    if not stream:
        stream = StringIO()
    browse_layers_elem = Element(ns_cfg("browseLayers"), 
                                 nsmap={"cfg": ns_cfg.uri})
    
    for browse_layer in browse_layers:
        bl_elem = SubElement(
            browse_layers_elem, ns_cfg("browseLayer"), 
            attrib={"browseLayerId": browse_layer.id}
        )
        
        rgb = browse_layer.r_band, browse_layer.g_band, browse_layer.b_band
        has_rgb = len(filter(lambda v: v is not None, rgb)) == 3
        
        ri = browse_layer.radiometric_interval_min, browse_layer.radiometric_interval_max
        has_ri = len(filter(lambda v: v is not None, ri)) == 2 
        
        SubElement(bl_elem, ns_cfg("browseType")).text = browse_layer.browse_type
        SubElement(bl_elem, ns_cfg("title")).text = browse_layer.title
        if browse_layer.description is not None:
            SubElement(bl_elem, ns_cfg("description")).text = browse_layer.description
        SubElement(bl_elem, ns_cfg("grid")).text = browse_layer.grid
        SubElement(bl_elem, ns_cfg("browseAccessPolicy")).text = browse_layer.browse_access_policy
        SubElement(bl_elem, ns_cfg("hostingBrowseServerName")).text = ""
        rel_ds_elem = SubElement(bl_elem, ns_cfg("relatedDatasetIds"))
        for rel_ds_id in browse_layer.related_dataset_ids:
            SubElement(rel_ds_elem, ns_cfg("datasetId")).text = rel_ds_id
        SubElement(bl_elem, ns_cfg("containsVerticalCurtains")).text = "true" if browse_layer.contains_vertical_curtains else "false"
        SubElement(bl_elem, ns_cfg("contains_volumes")).text = "true" if browse_layer.contains_volumes else "false"
        if has_rgb:
            SubElement(bl_elem, ns_cfg("rgbBands")).text = ",".join(map(str, rgb))
        
        if has_ri:
            ri_elem = SubElement(bl_elem, ns_cfg("radiometricInterval"))
            SubElement(ri_elem, ns_cfg("min")).text = str(ri[0])
            SubElement(ri_elem, ns_cfg("max")).text = str(ri[1])
        
        SubElement(bl_elem, ns_cfg("highestMapLevel")).text = str(browse_layer.highest_map_level)
        SubElement(bl_elem, ns_cfg("lowestMapLevel")).text = str(browse_layer.lowest_map_level)
        SubElement(bl_elem, ns_cfg("timeDimensionDefault")).text = str(browse_layer.timedimension_default)
        SubElement(bl_elem, ns_cfg("tileQueryLimit")).text = str(browse_layer.tile_query_limit)
    
    # TODO: encoding
    et = ElementTree(browse_layers_elem)
    et.write(stream, pretty_print=pretty_print, encoding="utf-8", 
             xml_declaration=True)
    
    return stream

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
    def saveConfigFile(self, workspace):
        projectPath = os.path.join(workspace.getPath(), self.getPath())
        projectFile = os.path.join(projectPath, Project.CONFIGURATION_FILENAME)

        logging.info("Save the config file of project {0} in {1}".format(self.getName(), projectFile))

        # First we verify and create if necessary the directory of the project
        if not os.path.exists(projectPath):
            logging.info("Creation of the directory: {0}".format(projectPath))
            os.mkdir(projectPath)

        # We generate the XML Config file
        root = self.generateXMLConfigFile()
        tree = ElementTree(root)
        tree.write(projectFile, pretty_print=True)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def export(info_root, config_root, package_path):
    """
    Exports the root elements and saves them to installer files.

    :param info_root: The root element of the info.xml file.
    :param config_root: The root element of the moduleconfig.xml file.
    :param package_path: The path to save the files to.
    :param hidden_nodes: The currently hidden nodes in either tree.
    """
    hidden_nodes_pairs = []
    for root in (info_root, config_root):
        for node in root:
            if node.hidden_children:
                for hidden_node in node.hidden_children:
                    hidden_nodes_pairs.append((node, hidden_node, node.index(hidden_node)))
                    node.remove(hidden_node)

    try:
        fomod_folder = _check_file(package_path, "fomod")
    except MissingFileError as e:
        makedirs(join(package_path, e.file))
        fomod_folder = join(package_path, e.file)

    fomod_folder_path = join(package_path, fomod_folder)

    try:
        info_file = _check_file(fomod_folder_path, "Info.xml")
    except MissingFileError as e:
        info_file = e.file

    try:
        config_file = _check_file(fomod_folder_path, "ModuleConfig.xml")
    except MissingFileError as e:
        config_file = e.file

    info_path = join(fomod_folder_path, info_file)
    config_path = join(fomod_folder_path, config_file)

    with open(info_path, "wb") as infofile:
        info_tree = ElementTree(info_root)
        info_tree.write(infofile, pretty_print=True)

    with open(config_path, "wb") as configfile:
        config_tree = ElementTree(config_root)
        config_tree.write(configfile, pretty_print=True)

    for pair in hidden_nodes_pairs:
        pair[0].insert(pair[2], pair[1])

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def xml(data, xmlFileName):
  from lxml.etree import ElementTree, Element, SubElement, Comment, tostring
  from collections import OrderedDict

  xsi = 'http://www.w3.org/2001/XMLSchema-instance'
  noNamespaceSchemaLocation = "{%s}noNamespaceSchemaLocation" % xsi
  doc = Element('transcript', {noNamespaceSchemaLocation: 'transcript_new.xsd'})
  
  #, { 'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
  #                              'xsi:noNamespaceSchemaLocation': 'transcript_new.xsd' })
  head = SubElement(doc, 'head')
  recording = SubElement(head, 'recording')
  annotations = SubElement(head, 'annotations')
  annotation_id = 'transcript_manual'
  annotation = SubElement(annotations, 'annotation', {'id':annotation_id})
  speakers = SubElement(head, 'speakers')
  speakerSet = data['speaker'] if 'speaker' in data else set() 
  programSet = set()
  body = SubElement(doc, 'body')
  segments = SubElement(body, 'segments', {'annotation_id':annotation_id})
  programId = data['id']
  wordCount = 0
  for i, e in enumerate(data['turn']):
    tokens = e.text.split()
    startTime = e.startTime
    endTime = e.endTime
    averageWordDuration = (e.endTime - e.startTime) / len(tokens)
    speakerName = e.speaker if e.speaker else "{}_unknown_{}".format(programId, i)
    if speakerName not in speakerSet:
      speaker = SubElement(speakers, 'speaker', OrderedDict([('id', speakerName), ('name', speakerName)]))
      speakerSet.add(speaker)
    segment = SubElement(segments, 'segment', OrderedDict([('id',"{}_utt_{}".format(programId,i)),
                                               ('starttime', str(startTime)),
                                               ('endtime', str(endTime)),
                                               ('AWD', "{:2f}".format(averageWordDuration)),
                                               ('PMER', "0.0"),
                                               ('WMER', "0.0"),
                                               ('who', speakerName)]))
    for word in tokens:
      element = SubElement(segment, 'element', OrderedDict([('id',"{}_w{}".format(programId, wordCount)),
                                                ('type','word')]))
      element.text = word
      wordCount += 1

  tree = ElementTree(doc)
  tree.write(xmlFileName, encoding='utf-8', xml_declaration=True, pretty_print=True)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def dump_xml(data, outfile):
  root = Element('database')
  tree = ElementTree(root)
  group = Element('group')
  root.append(group)
  group.append(build_element('title', 'All'))
  group.append(build_element('icon', '1'))
  group.append(build_element('expire', 'Never'))
  for password in data:
    entry = Element('entry')
    entry.append(build_element('icon', '1'))
    for target, source in mapping.iteritems():
      value = getattr(password, source)
      entry.append(build_element(target, encode(value)))
    for target in ['creation', 'lastaccess']: 
      entry.append(build_element(target, time.strftime("%Y-%m-%dT%H:%M:%S")))
    group.append(entry)
    
  tree.write(outfile, encoding='UTF-8', pretty_print=True)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def serialize_browse_report(browse_report, stream=None, pretty_print=False):
    if not stream:
        stream = StringIO()

    browse_report_elem = Element(ns_rep("browseReport"),
                                 nsmap={"rep": ns_rep.uri},
                                 attrib={"version": "1.3"})

    SubElement(browse_report_elem, ns_rep("responsibleOrgName")).text = browse_report.responsible_org_name
    SubElement(browse_report_elem, ns_rep("dateTime")).text = browse_report.date_time.isoformat("T")
    SubElement(browse_report_elem, ns_rep("browseType")).text = browse_report.browse_type

    for browse in browse_report:
        browse_report_elem.append(_serialize_browse(browse))

    et = ElementTree(browse_report_elem)
    et.write(stream, pretty_print=pretty_print, encoding="utf-8",
             xml_declaration=True)

    return stream

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
def generate_data_type_conf(supported_file_formats, data_types_destination):
    data_types_node = Element("datatypes")
    registration_node = add_child_node(data_types_node, "registration")
    registration_node.attrib["converters_path"] = "lib/galaxy/datatypes/converters"
    registration_node.attrib["display_path"] = "display_applications"

    for format_name in supported_file_formats:
        data_type = supported_file_formats[format_name]
        # add only if it's a data type that does not exist in Galaxy
        if data_type.galaxy_type is not None:
            data_type_node = add_child_node(registration_node, "datatype")
            # we know galaxy_extension is not None
            data_type_node.attrib["extension"] = data_type.galaxy_extension
            data_type_node.attrib["type"] = data_type.galaxy_type
            if data_type.mimetype is not None:
                data_type_node.attrib["mimetype"] = data_type.mimetype

    data_types_tree = ElementTree(data_types_node)
    data_types_tree.write(open(data_types_destination,'w'), encoding="UTF-8", xml_declaration=True, pretty_print=True)
    logger.info("Generated Galaxy datatypes_conf.xml in %s" % data_types_destination, 0)

# 需要导入模块: from lxml.etree import ElementTree [as 别名]
# 或者: from lxml.etree.ElementTree import write [as 别名]
    def saveConfigFile(self):
        workspaceFile = os.path.join(self.path, Workspace.CONFIGURATION_FILENAME)

        logging.info("Save the config file of the workspace " + self.getName() + " in " + workspaceFile)

        # Register the namespace
        etree.register_namespace('netzob', WORKSPACE_NAMESPACE)
        etree.register_namespace('netzob-common', COMMON_NAMESPACE)

        # Dump the file
        root = etree.Element("{" + WORKSPACE_NAMESPACE + "}workspace")
        root.set("creation_date", TypeConvertor.pythonDatetime2XSDDatetime(self.getCreationDate()))
        root.set("name", str(self.getName()))

        xmlWorkspaceConfig = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}configuration")

        relTracePath = os.path.relpath(self.getPathOfTraces(), self.path)
        xmlTraces = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}traces")
        xmlTraces.text = str(self.getPathOfTraces())

        xmlLogging = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}logging")
        xmlLogging.text = str(self.getPathOfLogging())

        xmlPrototypes = etree.SubElement(xmlWorkspaceConfig, "{" + WORKSPACE_NAMESPACE + "}prototypes")
        xmlPrototypes.text = str(self.getPathOfPrototypes())

        xmlWorkspaceProjects = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}projects")
        logging.info("Projects included in workspace.xml :")
        for project in self.getProjects():
            xmlProject = etree.SubElement(xmlWorkspaceProjects, "{" + WORKSPACE_NAMESPACE + "}project")
            xmlProject.set("path", project.getPath())

        xmlWorkspaceImported = etree.SubElement(root, "{" + WORKSPACE_NAMESPACE + "}traces")
        for importedTrace in self.getImportedTraces():
            importedTrace.save(xmlWorkspaceImported, WORKSPACE_NAMESPACE, COMMON_NAMESPACE, os.path.join(self.path, self.getPathOfTraces()))

        tree = ElementTree(root)
        tree.write(workspaceFile)