def test_space_in_uri(self):
     if sys.platform == 'win32':
         result = path.uri_to_path('file:///C://test%20this')
         self.assertEqual(result, 'C:/test this'.encode('utf-8'))
     else:
         result = path.uri_to_path('file:///tmp/test%20this')
         self.assertEqual(result, '/tmp/test this'.encode('utf-8'))

 def test_simple_uri(self):
     if sys.platform == 'win32':
         result = path.uri_to_path('file:///C://WINDOWS/clock.avi')
         self.assertEqual(result, 'C:/WINDOWS/clock.avi'.encode('utf-8'))
     else:
         result = path.uri_to_path('file:///etc/fstab')
         self.assertEqual(result, '/etc/fstab'.encode('utf-8'))

 def test_space_in_uri(self):
     if sys.platform == "win32":
         result = uri_to_path("file:///C://test%20this")
         self.assertEqual(result, u"C:/test this")
     else:
         result = uri_to_path(u"file:///tmp/test%20this")
         self.assertEqual(result, u"/tmp/test this")

 def test_unicode_in_uri(self):
     if sys.platform == 'win32':
         result = path.uri_to_path('file:///C://%C3%A6%C3%B8%C3%A5')
         self.assertEqual(result, 'C:/æøå'.encode('utf-8'))
     else:
         result = path.uri_to_path('file:///tmp/%C3%A6%C3%B8%C3%A5')
         self.assertEqual(result, '/tmp/æøå'.encode('utf-8'))

 def test_unicode_in_uri(self):
     if sys.platform == "win32":
         result = uri_to_path("file:///C://%C3%A6%C3%B8%C3%A5")
         self.assertEqual(result, u"C:/æøå")
     else:
         result = uri_to_path(u"file:///tmp/%C3%A6%C3%B8%C3%A5")
         self.assertEqual(result, u"/tmp/æøå")

 def test_latin1_in_uri(self):
     if sys.platform == 'win32':
         result = path.uri_to_path('file:///C://%E6%F8%E5')
         self.assertEqual(result, 'C:/æøå'.encode('latin-1'))
     else:
         result = path.uri_to_path('file:///tmp/%E6%F8%E5')
         self.assertEqual(result, '/tmp/æøå'.encode('latin-1'))

 def test_simple_uri(self):
     if sys.platform == "win32":
         result = uri_to_path("file:///C://WINDOWS/clock.avi")
         self.assertEqual(result, u"C:/WINDOWS/clock.avi")
     else:
         result = uri_to_path("file:///etc/fstab")
         self.assertEqual(result, u"/etc/fstab")

 def test_unicode_in_uri(self):
     if sys.platform == 'win32':
         result = uri_to_path( 'file:///C://%C3%A6%C3%B8%C3%A5')
         self.assertEqual(result, u'C:/æøå')
     else:
         result = uri_to_path(u'file:///tmp/%C3%A6%C3%B8%C3%A5')
         self.assertEqual(result, u'/tmp/æøå')

 def _save_m3u(self, playlist):
     file_path = path.uri_to_path(playlist.uri)
     path.check_file_path_is_inside_base_dir(file_path, self._path)
     with open(file_path, 'w') as file_handle:
         for track in playlist.tracks:
             if track.uri.startswith('file://'):
                 uri = path.uri_to_path(track.uri)
             else:
                 uri = track.uri
             file_handle.write(uri + '\n')

 def translate(self, track):
     base_path = self.media_dir.encode('utf-8')
     result = dict(translator.track_to_mpd_format(track))
     result['file'] = uri_to_path(result['file'])[len(base_path) + 1:]
     result['key'] = os.path.basename(result['file'])
     result['mtime'] = mtime('')
     return translator.order_mpd_track_info(result.items())

 def change_track(self, track):
     media_dir = self.backend.config['local']['media_dir']
     # TODO: check that type is correct.
     file_path = path.uri_to_path(track.uri).split(b':', 1)[1]
     file_path = os.path.join(media_dir, file_path)
     track = track.copy(uri=path.path_to_uri(file_path))
     return super(LocalPlaybackProvider, self).change_track(track)

 def translate(self, track):
     base_path = self.media_dir.encode("utf-8")
     result = dict(translator.track_to_mpd_format(track))
     result["file"] = uri_to_path(result["file"])[len(base_path) + 1 :]
     result["key"] = os.path.basename(result["file"])
     result["mtime"] = mtime("")
     return translator.order_mpd_track_info(result.items())

 def translate(self, track):
     folder = settings.LOCAL_MUSIC_PATH
     result = dict(translator.track_to_mpd_format(track))
     result['file'] = uri_to_path(result['file'])
     result['file'] = result['file'][len(folder)+1:]
     result['key'] = os.path.basename(result['file'])
     result['mtime'] = mtime('')
     return translator.order_mpd_track_info(result.items())

    def _rename_m3u(self, playlist):
        src_file_path = path.uri_to_path(playlist.uri)
        path.check_file_path_is_inside_base_dir(src_file_path, self._path)

        dst_file_path = self._get_m3u_path(playlist.name)
        path.check_file_path_is_inside_base_dir(dst_file_path, self._path)

        shutil.move(src_file_path, dst_file_path)

        return playlist.copy(uri=path.path_to_uri(dst_file_path))

def tracks_to_directory_tree(tracks):
    directories = ({}, [])

    for track in tracks:
        path = b""
        current = directories

        absolute_track_dir_path = os.path.dirname(uri_to_path(track.uri))
        relative_track_dir_path = re.sub("^" + re.escape(settings.LOCAL_MUSIC_PATH), b"", absolute_track_dir_path)

        for part in split_path(relative_track_dir_path):
            path = os.path.join(path, part)
            if path not in current[0]:
                current[0][path] = ({}, [])
            current = current[0][path]
        current[1].append(track)
    return directories

    def process_application(self, bus, message):
        if message.src != self.fakesink:
            return

        if message.structure.get_name() != 'handoff':
            return

        uri = unicode(self.uribin.get_property('uri'))
        self.data['uri'] = uri
        self.data['mtime'] = os.path.getmtime(path.uri_to_path(uri))
        self.data[gst.TAG_DURATION] = self.get_duration()

        try:
            self.data_callback(self.data)
            self.next_uri()
        except KeyboardInterrupt:
            self.stop()

 def scan(self, uri):
     logger.debug('Scanning %s for images', uri)
     data = self.scanner.scan(uri)
     images = []
     # Use image 'image' tag if available, or smaller, lower quality 'preview-image' otherwise
     for image in data['tags'].get('image', []) or data['tags'].get('preview-image', []):
         try:
             images.append(self.get_or_create_image_file(None, image.data))
         except Exception as e:
             logger.warn('Cannot extract images for %s: %s', uri, e)
     dirname = os.path.dirname(uri_to_path(uri))
     for pattern in self.patterns:
         for path in glob.glob(os.path.join(dirname, pattern)):
             try:
                 images.append(self.get_or_create_image(path))
             except Exception as e:
                 logger.warn('Cannot read album art from %s: %s', path, e)
     return images

def tracks_to_directory_tree(tracks, media_dir):
    directories = ({}, [])

    for track in tracks:
        path = b''
        current = directories

        absolute_track_dir_path = os.path.dirname(uri_to_path(track.uri))
        relative_track_dir_path = re.sub(
            '^' + re.escape(media_dir), b'', absolute_track_dir_path)

        for part in split_path(relative_track_dir_path):
            path = os.path.join(path, part)
            if path not in current[0]:
                current[0][path] = ({}, [])
            current = current[0][path]
        current[1].append(track)
    return directories

def tracks_to_directory_tree(tracks):
    directories = ({}, [])
    for track in tracks:
        path = u''
        current = directories

        local_folder = settings.LOCAL_MUSIC_PATH
        track_path = uri_to_path(track.uri)
        track_path = re.sub('^' + re.escape(local_folder), '', track_path)
        track_dir = os.path.dirname(track_path)

        for part in split_path(track_dir):
            path = os.path.join(path, part)
            if path not in current[0]:
                current[0][path] = ({}, [])
            current = current[0][path]
        current[1].append(track)
    return directories

def _add_to_tag_cache(result, dirs, files, media_dir):
    base_path = media_dir.encode('utf-8')

    for path, (entry_dirs, entry_files) in dirs.items():
        try:
            text_path = path.decode('utf-8')
        except UnicodeDecodeError:
            text_path = urllib.quote(path).decode('utf-8')
        name = os.path.split(text_path)[1]
        result.append(('directory', text_path))
        result.append(('mtime', get_mtime(os.path.join(base_path, path))))
        result.append(('begin', name))
        _add_to_tag_cache(result, entry_dirs, entry_files, media_dir)
        result.append(('end', name))

    result.append(('songList begin',))

    for track in files:
        track_result = dict(track_to_mpd_format(track))

        # XXX Don't save comments to the tag cache as they may span multiple
        # lines. We'll start saving track comments when we move from tag_cache
        # to a JSON file. See #579 for details.
        if 'Comment' in track_result:
            del track_result['Comment']

        path = uri_to_path(track_result['file'])
        try:
            text_path = path.decode('utf-8')
        except UnicodeDecodeError:
            text_path = urllib.quote(path).decode('utf-8')
        relative_path = os.path.relpath(path, base_path)
        relative_uri = urllib.quote(relative_path)

        # TODO: use track.last_modified
        track_result['file'] = relative_uri
        track_result['mtime'] = get_mtime(path)
        track_result['key'] = os.path.basename(text_path)
        track_result = order_mpd_track_info(track_result.items())

        result.extend(track_result)

    result.append(('songList end',))