def edx(self, out_dir):
        # Copy the Pdf to the static directory
        static_dir = os.path.join(out_dir, 'static')
        if not os.path.exists(static_dir):
            os.makedirs(static_dir)
        # In order to get an unique filename inside edx, we have to prefix the project and group name
        _, fileExtension = os.path.splitext(self.path)
        target_filename = self.url_name()+fileExtension
        target_path = os.path.join(static_dir,target_filename)
        shutil.copyfile(os.path.join(self.parent.path, self.path), target_path);

        html_dir = os.path.join(out_dir, 'html')
        if not os.path.exists(html_dir):
            os.makedirs(html_dir)
        html = Element('html', {'filename':self.url_name(), 'display_name':"File"});
        tree = ElementTree(html)
        tree.write(os.path.join(html_dir, "{0}.xml".format(self.url_name())) )


        (_ , filename) = os.path.split(self.path)
        html = '''
        <a href="/static/%(file)s">Download %(filename)s</a>
        ''' % {'file':target_filename, 'filename':filename}

        with codecs.open(os.path.join(html_dir, "{0}.html".format(self.url_name())), mode='w', encoding='utf-8') as f:
            f.write(html)

    def run(self):
        creds = []
        directory = constant.profile['USERPROFILE'] + u'\\Documents\\Rogue\'s Tale\\users'

        # The actual user details are stored in *.userdata files
        if os.path.exists(directory):
            files = os.listdir(directory)

            for f in files:
                if re.match('.*\.userdata', f):
                    # We've found a user file, now extract the hash and username

                    xmlfile = directory + '\\' + f
                    tree = ElementTree(file=xmlfile)
                    root = tree.getroot()

                    # Double check to make sure that the file is valid
                    if root.tag != 'user':
                        self.warning(u'Profile %s does not appear to be valid' % f)
                        continue

                    # Now save it to credentials
                    creds.append({
                        'Login': root.attrib['username'],
                        'Hash': root.attrib['password']
                    })

            return creds

def get_package_name(path):
    """
    Get the name of the ROS package that contains *path*. This is
    determined by finding the nearest parent ``manifest.xml`` file.
    This routine may not traverse package setups that rely on internal
    symlinks within the package itself.
    
    :param path: filesystem path
    :return: Package name or ``None`` if package cannot be found, ``str``
    """
    #NOTE: the realpath is going to create issues with symlinks, most
    #likely.
    parent = os.path.dirname(os.path.realpath(path))
    #walk up until we hit ros root or ros/pkg
    while not os.path.exists(os.path.join(path, MANIFEST_FILE)) and not os.path.exists(os.path.join(path, PACKAGE_FILE)) and parent != path:
        path = parent
        parent = os.path.dirname(path)
    # check termination condition
    if os.path.exists(os.path.join(path, MANIFEST_FILE)):
        return os.path.basename(os.path.abspath(path))
    elif os.path.exists(os.path.join(path, PACKAGE_FILE)):
        root = ElementTree(None, os.path.join(path, PACKAGE_FILE))
        return root.findtext('name')
    else:
        return None

 def load(cls, filename):
     project_root = ElementTree().parse(filename)
     settings_node = project_root.find(cls.__PROJECT_SETTINGS_NODE_NAME)
     tracks_node = project_root.find(cls.__PROJECT_TRACKS_NODE_NAME)
     track_nodes = tracks_node.findall(cls.__PROJECT_TRACK_NODE_NAME)
     for node in track_nodes:
         print node

    def scrape_pkg_uri(self, uri, pkg):
        """
        Scrape package metadata from PyPi when it's running
        as the Clue Release Manager.

        Parameters
        ----------
        uri : `str`
            URI to page containing package's homepage
        pkg : `str`
            Package name
        """
        # Example entry:
        #<div class="distro-block distro-metadata">
        #  <h4>Metadata</h4>
        #  <dl>
        #    <dt>Distro Index Owner:</dt>
        #    <dd>acmepypi</dd>
        #    <dt>Home Page:</dt>
        #    <dd><a href="http://mysvn/acme.helloworld">
        #           http://mysvn/acme.helloworld</a></dd>
        #  </dl>
        #</div>
        tree = ElementTree()
        try:
            tree.parse(urllib2.urlopen(uri))
        except urllib2.HTTPError, e:
            raise UserError("Can't find repository URL for package %s (%s). "
                            "Has it been registered in PyPi?" % (pkg, e))

    def merge(self):
        last_hr = 0
        self.tacx_tcx = self._parse_file(self.tacx_tcx_file)
        self.hr_tcx = self._parse_file(self.hr_tcx_file)

        for tp in self.tacx_tcx.dom_trackpoints:
            timestamp = tp.find('role:Time', ns).text
            timestamp_key = timestamp[0:19]
            if timestamp_key in self.hr_tcx.TrackPoints.keys():
                heartrate_from_other_file = self.hr_tcx.TrackPoints[timestamp_key].HeartRateBpm
                if heartrate_from_other_file is not None:
                    hr_node = self._create_heartrate(heartrate_from_other_file)
                    tp.append(hr_node)
                    last_hr = heartrate_from_other_file
            else:
                hr_node = self._create_heartrate(last_hr)
                tp.append(hr_node)

        tree = ElementTree(self.tacx_tcx.root)

        tree.write(open(self.file_name, 'wb'), encoding="utf-8", xml_declaration=True)

        # Add UGLY! temporary fix for namespace "ns1-issue"
        f = open (self.file_name, "r")
        data = f.read()
        data = data.replace('ns1:TPX', 'TPX')
        data = data.replace('ns1:Speed', 'Speed')
        data = data.replace('ns1:Watts', 'Watts')
        f.close

        f = open(self.file_name, "w")
        f.write(data)
        f.close()
        return self.file_name

    def fulltext_search(self, query, rows=None, start=None):
        """Does an advanced search on fulltext:blah.
        You get back a pair (x,y) where x is the total # of hits
        and y is a list of identifiers like ["foo", "bar", etc.]"""

        query = self._prefix_query('fulltext', query)
        result_list = self.raw_search(query, rows=rows, start=start)
        e = ElementTree()
        try:
            e.parse(StringIO(result_list))
        except SyntaxError as e:
            raise SolrError(e)

        total_nbr_text = e.find('info/range_info/total_nbr').text
        # total_nbr_text = e.find('result').get('numFound')  # for raw xml
        total_nbr = int(total_nbr_text) if total_nbr_text else 0

        out = []
        for r in e.getiterator('hit'):
            for d in r.find('metadata'):
                for x in list(d.getiterator()):
                    if x.tag == "identifier":
                        xid = six.text_type(x.text).encode('utf-8')
                        if xid.startswith('OCA/'):
                            xid = xid[4:]
                        elif xid.endswith('.txt'):
                            xid = xid.split('/')[-1].split('_')[0]
                        elif xid.endswith('_ZZ'):
                            xid = xid[:-3]
                        out.append(xid)
                        break
        return (total_nbr, out)

def loadLanguageFile(langfile):
    """ Loads one or more languages from disk
    Returns list of language codes found."""
    
    global languagenames, languages
    
    tree = ElementTree(file=langfile)
    
    foundlangs = []
    
    langslist = tree.find("wurmlanguages")
    langs     = langslist.findall("languagedef")
    
    for language in langs:
        code = language.attrib["code"]
        name = language.attrib.get("name", code)
        
        languagenames[code] = name
        languages.setdefault(code, {}) # make sure the base map is ready
        
        if code not in foundlangs:
            foundlangs.append(code)
        
        lstrings = language.findall("string")
        for lstr in lstrings:
            orig = _parse(lstr.find("original").text.strip())
            tran = _parse(lstr.find("translation").text.strip())
            languages[code][orig] = tran
    
    return foundlangs

	def write(self, filename, midi):
		

		midifile = Element('MidiFile')
		header = HeaderChunk()
		
		header.write(midifile, midi.header)

		i = 0
		for cur in midi.tracks:
			node = SubElement(midifile, '_' + str(i)) #garantit l'ordre des datas
			temp = TrackChunk()
			temp.write(node, cur)
			i += 1

		tree = ElementTree(midifile)
		tree.write(filename, encoding="utf-8")

		

		import xml.dom.minidom 

		root = xml.dom.minidom.parse(filename)

		f = open(filename, "w")
		f.write(root.toprettyxml())

def serialize(data, name='object'):
    content_elem = Element(name)
    _serialize(content_elem, data)
    tree = ElementTree(content_elem)
    f = StringIO()
    tree.write(f, 'UTF-8')
    return f.getvalue()

    def updatebq(self):
        from xml.etree.cElementTree import ElementTree
        tree = ElementTree()
        tree.parse(GSXML)
        tvlist = []
        for iptv in tree.findall("iptv"):
            name = iptv.findtext("name").title()
            (protocol, serviceType, bufferSize, epgId) = iptv.findtext("type").split(":")
            uri = iptv.findtext("uri")
            if protocol in "livestreamer":
                uri = "http://localhost:88/" + uri
            uri = uri.replace(":", "%3a")
            service = "#SERVICE {s}:0:1:{e}:{e}:0:0:0:0:0:{u}:{n}\n".format(s=serviceType,e=epgId,u=uri,n=name)
            tvlist.append((name,service))

        tvlist=sorted(tvlist, key=lambda channel: channel[0]) #sort by name
        with open(GSBQ, "w") as f:
            f.write("#NAME GreekStreamTV\n")
            for (name, service) in tvlist:
                f.write(service)

	com = "cat /usr/lib/enigma2/python/Plugins/Satdreamgr/UpdateBouquet/stream.xml ; rm /usr/lib/enigma2/python/Plugins/Satdreamgr/UpdateBouquet/stream.xml"
	out = os.popen(com)

        return list

def parse_operator_xml(f):

    et = ElementTree(file=f)
    r = et.getroot()

    def _get_value_from_first_element(r_, e_name):
        return r_.findall(e_name)[0].text

    operator_id = r.attrib["id"]
    task_id = _get_value_from_first_element(r, "task-id")

    s = r.findall("scatter")[0]
    scatter_task_id = _get_value_from_first_element(s, "scatter-task-id")

    sgs = s.findall("chunks")[0]
    schunks = [ScatterChunk(x.attrib["out"], x.attrib["in"]) for x in sgs.findall("chunk")]
    scatter = Scatter(task_id, scatter_task_id, schunks)

    gs = r.findall("gather")[0].findall("chunks")[0].findall("chunk")

    def _to_c(x):
        return (
            _get_value_from_first_element(x, "gather-task-id"),
            _get_value_from_first_element(x, "chunk-key"),
            _get_value_from_first_element(x, "task-output"),
        )

    gchunks = [GatherChunk(*_to_c(x)) for x in gs]

    gather = Gather(gchunks)
    return ChunkOperator(operator_id, scatter, gather)

    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 exportGEXF(self, fileName):
        rootNode = Element("gexf")
        rootNode.attrib['xmlns'] = "http://www.gexf.net/1.2draft"
        rootNode.attrib['version'] = "1.2"

        graphNode = Element("graph")
        graphNode.attrib['mode'] = "static"
        graphNode.attrib['defaultedgetype'] = "directed"
        rootNode.append(graphNode)

        graphNode.append(Node.getGexfAttributeNode())
        graphNode.append(Vertex.getGexfAttributeNode())

        NodesList = Element("nodes")
        for n in self.nodes:
            NodesList.append(n.exportToGexfNode())
        graphNode.append(NodesList)

        EdgesList = Element("edges")
        for e in self.vertices:
            EdgesList.append(e.exportToGexfNode())
        graphNode.append(EdgesList)

        doc = ElementTree(rootNode)
        doc.write(fileName, "utf8", '<?xml version="1.0" encoding="UTF-8"?>')

def parse_categories(fn):
    categories = {}
    et = ElementTree()
    tree = et.parse(fn)
    for elem in tree.findall('Category'):
        parse_category(elem, None, categories)
    return categories

def extract_positions(url):
	tree = ElementTree()
	parser = XMLParser(encoding="iso-8859-1")
	data = urllib.urlopen(url)
	tree.parse(data, parser=parser)
	positions = tree.getroot().findall("team")
	allpos = []
	for pos in positions:
		realpos = pos.find("pos")
		latitude = float(realpos.attrib['a'])
		longitude = float(realpos.attrib['o'])
		speed = float(realpos.attrib['s'])
		course = float(realpos.attrib['c'])
		last_update = datetime.utcfromtimestamp(int(realpos.attrib["w"]))
		dtf = float(realpos.attrib['d'])

		_id = pos.attrib["id"]
		# pos = geo.xyz(latitude, latitude)

		# final object
		result = {}
		result["str_latitude"] = format_deg(latitude, "N", "S")
		result["str_longitude"] = format_deg(longitude, "E", "W")
		result["speed"] = speed
		result["course"] = course
		result["_id"] = _id
		result["dtf"] = dtf
		result["last_update"] = last_update

		allpos.append(result)
	return allpos

def list_articles(target_directory, supplementary_materials=False, skip=[]):
    listing = listdir(target_directory)
    for filename in listing:
        result_tree = ElementTree()
        result_tree.parse(path.join(target_directory, filename))
        for tree in result_tree.iterfind('article'):
            pmcid = _get_pmcid(tree)
            if pmcid in skip:
                continue

            result = {}
            result['name'] = pmcid
            result['doi'] = _get_article_doi(tree)
            result['article-categories'] = _get_article_categories(tree)
            result['article-contrib-authors'] = _get_article_contrib_authors(tree)
            result['article-title'] = _get_article_title(tree)
            result['article-abstract'] = _get_article_abstract(tree)
            result['journal-title'] = _get_journal_title(tree)
            result['article-year'], \
                result['article-month'], \
                result['article-day'] = _get_article_date(tree)
            result['article-url'] = _get_article_url(tree)
            result['article-license-url'], \
                result['article-license-text'], \
                result['article-copyright-statement'] = _get_article_licensing(tree)
            result['article-copyright-holder'] = _get_article_copyright_holder(tree)

            if supplementary_materials:
                result['supplementary-materials'] = _get_supplementary_materials(tree)
            yield result

    def pagetext_search(self, locator, query, rows=None, start=None):
        """Does an advanced search on
               pagetext:blah locator:identifier
        where identifier is one of the id's from fulltext search.
        You get back a list of page numbers like [21, 25, 39]."""

        def extract(page_id):
            """TODO: DjVu format is deprecated. Is this function
            still even used?
            A page id is something like
            'adventsuburbanit00butlrich_0065.djvu',
            which this function extracts asa a locator and
            a leaf number ('adventsuburbanit00butlrich', 65). """

            g = re.search('(.*)_(\d{4})\.djvu$', page_id)
            a,b = g.group(1,2)
            return a, int(b)

        # try using qf= parameter here and see if it gives a speedup. @@
        # pdb.set_trace()
        query = self._prefix_query('pagetext', query)
        page_hits = self.raw_search(query,
                                    fq='locator:' + locator,
                                    rows=rows,
                                    start=start)
        XML = ElementTree()
        try:
            XML.parse(StringIO(page_hits))
        except SyntaxError as e:
            raise SolrError(e)
        page_ids = list(e.text for e in XML.getiterator('identifier'))
        return [extract(x)[1] for x in page_ids]

def main(argv):
  import getopt
  def usage():
    print 'usage: %s [-d] [-p basedir] xml files ...' % argv[0]
    return 100
  try:
    (opts, args) = getopt.getopt(argv[1:], 'dp:')
  except getopt.GetoptError:
    return usage()
  if not args:
    return usage()
  debug = 0
  basedir = '.'
  for (k, v) in opts:
    if k == '-d': debug += 1
    elif k == '-p': basedir = v
  modules = {}
  root = ElementTree().parse(args.pop(0))
  for module in root.getchildren():
    if module.tag != 'module': continue
    modules[module.get('name')] = module
    modules[module.get('src')] = module
  for name in args:
    try:
      module = modules[name]
    except KeyError:
      print >>sys.stderr, 'not found: %r' % name
      continue
    src = os.path.join(basedir, module.get('src'))
    fp = file(src)
    annot(fp, module)
    fp.close()
  return 0

    def run(self):
        settings = [
            os.path.join(constant.profile['LOCALAPPDATA'],
                         u'Microsoft Corporation\\Remote Desktop Connection Manager\\RDCMan.settings'),
            os.path.join(constant.profile['LOCALAPPDATA'],
                         u'Microsoft\\Remote Desktop Connection Manager\\RDCMan.settings')
        ]

        for setting in settings:
            if os.path.exists(setting):
                self.debug(u'Setting file found: {setting}'.format(setting=setting))

                tree = ElementTree(file=setting)
                root = tree.getroot()
                pwd_found = []

                elements = [
                    'CredentialsProfiles/credentialsProfiles/credentialsProfile',
                    'DefaultGroupSettings/defaultSettings/logonCredentials',
                    'file/server',
                ]

                for element in elements:
                    pwd_found += self.parse_element(root, element)

                try:
                    for r in root.find('FilesToOpen'):
                        if os.path.exists(r.text):
                            self.debug(u'New setting file found: %s' % r.text)
                            pwd_found += self.parse_xml(r.text)
                except Exception:
                    pass

                return pwd_found