def path(self):
"""
Get track file path
Alias to Track.path
@return str
"""
return GLib.filename_from_uri(self.uri)[0]
def _on_button_press(self, widget, event):
"""
On button press, set album popularity
@param widget as Gtk.EventBox
@param event as Gdk.Event
"""
if Lp().scanner.is_locked():
return
user_rating = self.__object.get_rate() != Type.NONE
event_star = widget.get_children()[0]
if event_star in self._stars:
position = self._stars.index(event_star)
else:
position = -1
pop = position + 1
if pop == 0:
if user_rating:
self.__object.set_rate(Type.NONE)
else:
self.__object.set_popularity(0)
elif event.button == 1:
self.__object.set_rate(pop)
else:
self.__object.set_popularity(pop)
if isinstance(self.__object, Track):
Lp().player.emit('rate-changed')
# Save to tags if needed
if Lp().settings.get_value('save-to-tags') and\
GLib.find_program_in_path("kid3-cli") is not None and\
isinstance(self.__object, Track) and\
not self.__object.is_web:
if pop == 0:
value = 0
elif pop == 1:
value = 1
elif pop == 2:
value = 64
elif pop == 3:
value = 128
elif pop == 4:
value = 196
else:
value = 255
path = GLib.filename_from_uri(self.__object.uri)[0]
try:
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(
bus, Gio.DBusProxyFlags.NONE, None,
'org.gnome.Lollypop.Portal',
'/org/gnome/LollypopPortal',
'org.gnome.Lollypop.Portal', None)
proxy.call_sync('SetPopularity',
GLib.Variant(
'(is)', (value,
path)),
Gio.DBusCallFlags.NO_AUTO_START,
500, None)
except Exception as e:
print("RatingWidget::_on_button_press():", e)
return True
def export(self, export_type, text=""):
"""Export the given text using the specified format.
For advanced export, this includes special flags for the enabled options.
Keyword Arguments:
text {str} -- Text to export (default: {""})
"""
args = []
if export_type == "advanced":
filename = self.adv_export_name.get_text()
# TODO: use walrust operator
output_uri = self.adv_export_folder.get_uri()
if output_uri:
output_dir = GLib.filename_from_uri(output_uri)[0]
else:
raise NotADirectoryError(
_("A folder must be selected before proceeding"))
basename = os.path.basename(filename)
fmt = self.formats[self.format_field.get_active()]
to = fmt["to"]
ext = fmt["ext"]
if self.builder.get_object("html5").get_active() and to == "html":
to = "html5"
if self.builder.get_object("smart").get_active():
to += "+smart"
args.extend(self.get_advanced_arguments(to, ext))
else:
args = ["--variable=papersize:a4"]
filename = self.dialog.get_filename()
if filename.endswith("." + export_type):
filename = filename[:-len(export_type) - 1]
output_dir = os.path.abspath(os.path.join(filename,
os.path.pardir))
basename = os.path.basename(filename)
to = export_type
ext = export_type
if export_type == "html":
to = "html5"
args.append("--self-contained")
args.append("--css=%s" % Theme.get_current().web_css_path)
args.append("--mathjax")
args.append(
"--lua-filter=%s" %
helpers.get_script_path('relative_to_absolute.lua'))
args.append("--lua-filter=%s" %
helpers.get_script_path('task-list.lua'))
helpers.pandoc_convert(text,
to=to,
args=args,
outputfile="%s/%s.%s" %
(output_dir, basename, ext))
def __on_map(self, widget):
"""
Connect signals
@param widget as Gtk.Widget
"""
self.__download_previous_time = None
self.__download.connect("finished", self.__on_finished)
self.__download.connect("received-data", self.__on_received_data)
self.__download.connect("failed", self.__on_failed)
response = self.__download.get_response()
if response is None:
return
destination = self.__download.get_destination()
try:
f = GLib.filename_from_uri(destination)[0]
(mime, uncertain) = Gio.content_type_guess(f, None)
if uncertain:
self.__preview.set_from_icon_name("text-x-generic",
Gtk.IconSize.DIALOG)
else:
icon = Gio.content_type_get_icon(mime)
self.__preview.set_from_gicon(icon, Gtk.IconSize.DIALOG)
except:
self.__preview.set_from_icon_name("text-x-generic",
Gtk.IconSize.DIALOG)
def on_drag_data_received(self, widget: Gtk.Widget,
drag_context: Gdk.DragContext, x: int, y: int,
data: Gtk.SelectionData, info: int,
time: int) -> None:
drop_source: Tuple[str, Any] = GLib.filename_from_uri(data.get_text())
folder_path: str = drop_source[0].rstrip()
saved_folders: List[str] = self.settings.get_value(
'saved-folders').unpack()
try:
if GLib.file_test(folder_path, GLib.FileTest.IS_DIR):
self._main_label_box.props.visible = False
label: str = folder_path
folder: FolderBox = FolderBox(label)
self._main_list_box.props.visible = True
folder.set_title(label)
self._main_list_box.add(folder)
saved_folders.append(label)
self.settings.set_value('saved-folders',
GLib.Variant('as', saved_folders))
else:
raise GLib.Error(
message=f'Error: {folder_path} is not a folder.')
except GLib.Error as err:
print('%s' % err.message)
def ___reset_database(self, track_ids, count, history, progress):
"""
Backup database and reset
@param track ids as [int]
@param count as int
@param history as History
@param progress as Gtk.ProgressBar
"""
if track_ids:
track_id = track_ids.pop(0)
uri = Lp().tracks.get_uri(track_id)
filepath = GLib.filename_from_uri(uri)[0]
name = GLib.path_get_basename(filepath)
album_id = Lp().tracks.get_album_id(track_id)
popularity = Lp().tracks.get_popularity(track_id)
ltime = Lp().tracks.get_ltime(track_id)
mtime = Lp().albums.get_mtime(album_id)
duration = Lp().tracks.get_duration(track_id)
album_popularity = Lp().albums.get_popularity(album_id)
history.add(name, duration, popularity,
ltime, mtime, album_popularity)
progress.set_fraction((count - len(track_ids))/count)
GLib.idle_add(self.___reset_database, track_ids,
count, history, progress)
else:
Lp().db.del_tracks(Lp().tracks.get_ids())
progress.hide()
Lp().db = Database()
Lp().window.show_genres(Lp().settings.get_value('show-genres'))
Lp().window.update_db()
progress.get_toplevel().set_deletable(True)
def __save_artwork_tags(self, data, album):
"""
Save artwork in tags
@param data as bytes
@param album as Album
"""
if album.is_youtube:
return
stream = Gio.MemoryInputStream.new_from_data(data, None)
pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(stream,
ArtSize.MONSTER,
ArtSize.MONSTER,
True,
None)
pixbuf.savev("/tmp/lollypop_cover_tags.jpg",
"jpeg", ["quality"], ["90"])
del pixbuf
f = Gio.File.new_for_path("/tmp/lollypop_cover_tags.jpg")
if f.query_exists():
argv = ["kid3-cli", "-c", "select all", "-c",
"set picture:'/tmp/lollypop_cover_tags.jpg' ''"]
for uri in Lp().albums.get_track_uris(album.id, [], []):
try:
path = GLib.filename_from_uri(uri)[0]
argv.append(path)
except: # Gvfs can't find a path for uri
pass
argv.append(None)
GLib.spawn_sync(None, argv, None,
GLib.SpawnFlags.SEARCH_PATH, None)
f = Gio.File.new_for_path("/tmp/lollypop_cover_tags.jpg")
f.delete()
self.clean_album_cache(album)
GLib.idle_add(self.album_artwork_update, album.id)
def get_path(self, album_id):
"""
Get album path for album id
@param Album id as int
@return Album path as string
"""
with SqlCursor(Lp().db) as sql:
result = sql.execute("SELECT path FROM albums WHERE rowid=?",
(album_id, ))
path = ""
v = result.fetchone()
if v is not None:
path = v[0]
if path != "" and not os.path.exists(path):
tracks = self.get_track_ids(album_id, [], [])
if tracks:
uri = Lp().tracks.get_uri(tracks[0])
filepath = GLib.filename_from_uri(uri)[0]
path = os.path.dirname(filepath)
if os.path.exists(path):
sql.execute(
"UPDATE albums SET path=? "
"WHERE rowid=?", (path, album_id))
sql.commit()
return path
def __update_metadata(self):
if self.__get_status() == "Stopped":
self.__metadata = {}
else:
if Lp().player.current_track.id >= 0:
track_id = Lp().player.current_track.id
else:
track_id = randint(10000000, 90000000)
self.__metadata["mpris:trackid"] = self.__get_media_id(track_id)
track_number = Lp().player.current_track.number
if track_number is None:
track_number = 1
self.__metadata["xesam:trackNumber"] = GLib.Variant("i",
track_number)
self.__metadata["xesam:title"] = GLib.Variant(
"s",
Lp().player.current_track.name)
self.__metadata["xesam:album"] = GLib.Variant(
"s",
Lp().player.current_track.album.name)
self.__metadata["xesam:artist"] = GLib.Variant(
"as",
Lp().player.current_track.artists)
self.__metadata["xesam:albumArtist"] = GLib.Variant(
"as",
Lp().player.current_track.album_artists)
self.__metadata["mpris:length"] = GLib.Variant(
"x",
Lp().player.current_track.duration * 1000 * 1000)
self.__metadata["xesam:genre"] = GLib.Variant(
"as",
Lp().player.current_track.genres)
self.__metadata["xesam:url"] = GLib.Variant(
"s",
Lp().player.current_track.uri)
rate = Lp().player.current_track.get_rate()
if rate == Type.NONE:
rate = Lp().player.current_track.get_popularity()
self.__metadata["xesam:userRating"] = GLib.Variant("d", rate / 5)
if Lp().player.current_track.id == Type.RADIOS:
cover_path = Lp().art.get_radio_cache_path(
", ".join(Lp().player.current_track.artists),
ArtSize.MONSTER)
elif Lp().player.current_track.id == Type.EXTERNALS:
cover_path = "/tmp/lollypop_mpris.jpg"
pixbuf = Lp().art.pixbuf_from_tags(
GLib.filename_from_uri(Lp().player.current_track.uri)[0],
ArtSize.MONSTER)
if pixbuf is not None:
pixbuf.savev(cover_path, "jpeg",
["quality"], ["90"])
else:
cover_path = Lp().art.get_album_cache_path(
Lp().player.current_track.album, ArtSize.MONSTER)
if cover_path is not None:
self.__metadata["mpris:artUrl"] = GLib.Variant(
"s",
"file://" + cover_path)
elif "mpris:artUrl" in self.__metadata:
self.__metadata["mpris:artUrl"] = GLib.Variant("s", "")
def __on_save_artwork_tags(self, source, result, album_id):
"""
Save image to tags
@param source as GObject.Object
@param result as Gio.AsyncResult
@param album_id as int
"""
try:
can_set_cover = source.call_finish(result)[0]
except:
can_set_cover = False
if can_set_cover:
dbus_helper = DBusHelper()
for uri in Lp().albums.get_track_uris(album_id, [], []):
path = GLib.filename_from_uri(uri)[0]
dbus_helper.call(
"SetCover",
GLib.Variant("(ss)", (path, "%s/lollypop_cover_tags.jpg" %
self._CACHE_PATH)), None, None)
self.clean_album_cache(Album(album_id))
# FIXME Should be better to send all covers at once and listen
# to as signal but it works like this
GLib.timeout_add(2000, self.album_artwork_update, album_id)
else:
# Lollypop-portal or kid3-cli removed?
Lp().settings.set_value("save-to-tags", GLib.Variant("b", False))
def _add(self, cmd_args):
"""
Add track to mpd playlist
@syntax add filepath
@param args as str
@return msg as str
"""
tracks = []
arg = self._get_args(cmd_args)[0]
try:
arg = GLib.filename_from_uri(arg)[0]
except:
pass
track_id = Lp().tracks.get_id_by_path(arg)
if track_id is None:
path = ""
for musicpath in Lp().settings.get_music_paths():
search = musicpath.replace("/", "_")
if search in arg:
path = musicpath + arg.replace(search, path)
if os.path.isdir(path):
tracks_ids = Lp().tracks.get_ids_by_path(path)
for track_id in tracks_ids:
tracks.append(Track(track_id))
elif os.path.isfile(path):
track_id = Lp().tracks.get_id_by_path(path)
tracks.append(Track(track_id))
else:
tracks.append(Track(track_id))
Lp().playlists.add_tracks(Type.MPD, tracks, False)
return ""
def __set_popularity(self, pop):
"""
Set popularity as kid3 is installed
@param pop as int
"""
try:
if App().art.kid3_available:
if pop == 0:
value = 0
elif pop == 1:
value = 1
elif pop == 2:
value = 64
elif pop == 3:
value = 128
elif pop == 4:
value = 196
else:
value = 255
path = GLib.filename_from_uri(self.__object.uri)[0]
if GLib.find_program_in_path("flatpak-spawn") is not None:
argv = ["flatpak-spawn", "--host", "kid3-cli", "-c",
"set POPM %s" % value, path]
else:
argv = ["kid3-cli", "-c", "set POPM %s" % value, path]
(pid, stdin, stdout, stderr) = GLib.spawn_async(
argv, flags=GLib.SpawnFlags.SEARCH_PATH |
GLib.SpawnFlags.STDOUT_TO_DEV_NULL,
standard_input=False,
standard_output=False,
standard_error=False
)
except Exception as e:
Logger.error("RatingWidget::__on_can_set_popularity(): %s" % e)
def _on_button_press(self, widget, event):
"""
On button press, set album popularity
@param widget as Gtk.EventBox
@param event as Gdk.Event
"""
if Lp().scanner.is_locked():
return
user_rating = self.__object.get_rate() != Type.NONE
event_star = widget.get_children()[0]
if event_star in self._stars:
position = self._stars.index(event_star)
else:
position = -1
pop = position + 1
if pop == 0:
if user_rating:
self.__object.set_rate(Type.NONE)
else:
self.__object.set_popularity(0)
elif event.button == 1:
self.__object.set_rate(pop)
else:
self.__object.set_popularity(pop)
if isinstance(self.__object, Track):
Lp().player.emit("rate-changed")
# Save to tags if needed
# FIXME We really need a radio object
if Lp().settings.get_value("save-to-tags") and\
GLib.find_program_in_path("kid3-cli") is not None and\
isinstance(self.__object, Track) and\
self.__object.id >= 0 and\
not self.__object.is_web:
if pop == 0:
value = 0
elif pop == 1:
value = 1
elif pop == 2:
value = 64
elif pop == 3:
value = 128
elif pop == 4:
value = 196
else:
value = 255
path = GLib.filename_from_uri(self.__object.uri)[0]
try:
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(bus, Gio.DBusProxyFlags.NONE,
None,
"org.gnome.Lollypop.Portal",
"/org/gnome/LollypopPortal",
"org.gnome.Lollypop.Portal",
None)
proxy.call_sync("SetPopularity",
GLib.Variant("(is)", (value, path)),
Gio.DBusCallFlags.NO_AUTO_START, 500, None)
except Exception as e:
print("RatingWidget::_on_button_press():", e)
return True
def add_to_stash(self, target, data):
from urllib.parse import urlparse
import time
if str(target) == "text/uri-list":
uris = data.get_uris()
for uri in uris:
parsed_uri = urlparse(uri)
path, hostname = GLib.filename_from_uri(uri)
try:
iconstack_child = [
child for child in self.stash_stacked.get_children()
if path == child.path
][0]
except:
if os.path.exists(path):
if os.path.isdir(path):
mime_type = "inode/directory"
elif os.path.isfile(path):
mime_type, val = Gio.content_type_guess(path,
data=None)
GLib.idle_add(self.update_stash, path, mime_type)
# self.update_stash(path, mime_type)
time.sleep(0.05)
def __save_artwork_tags(self, data, album):
"""
Save artwork in tags
@param data as bytes
@param album as Album
"""
stream = Gio.MemoryInputStream.new_from_data(data, None)
pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(
stream, ArtSize.MONSTER, ArtSize.MONSTER, True, None)
pixbuf.savev("/tmp/lollypop_cover_tags.jpg", "jpeg", ["quality"],
["90"])
del pixbuf
if os.path.exists("/tmp/lollypop_cover_tags.jpg"):
argv = [
"kid3-cli", "-c", "select all", "-c",
"set picture:'/tmp/lollypop_cover_tags.jpg' ''"
]
for uri in Lp().albums.get_track_uris(album.id, [], []):
path = GLib.filename_from_uri(uri)[0]
argv.append(path)
argv.append(None)
GLib.spawn_sync(None, argv, None, GLib.SpawnFlags.SEARCH_PATH,
None)
os.remove("/tmp/lollypop_cover_tags.jpg")
self.clean_album_cache(album)
GLib.idle_add(self.album_artwork_update, album.id)
def _add(self, cmd_args):
"""
Add track to mpd playlist
@syntax add filepath
@param args as str
@return msg as str
"""
tracks = []
arg = self._get_args(cmd_args)[0]
try:
arg = GLib.filename_from_uri(arg)[0]
except:
pass
track_id = Lp().tracks.get_id_by_path(arg)
if track_id is None:
path = ""
for musicpath in Lp().settings.get_music_paths():
search = musicpath.replace("/", "_")
if search in arg:
path = musicpath + arg.replace(search, path)
if os.path.isdir(path):
tracks_ids = Lp().tracks.get_ids_by_path(path)
for track_id in tracks_ids:
tracks.append(Track(track_id))
elif os.path.isfile(path):
track_id = Lp().tracks.get_id_by_path(path)
tracks.append(Track(track_id))
else:
tracks.append(Track(track_id))
Lp().playlists.add_tracks(Type.MPD, tracks, False)
return ""
def path(self):
"""
Get track file path
Alias to Track.path
@return str
"""
return GLib.filename_from_uri(self.uri)[0]
def file_add(self, widget, *args):
uris = self.filedlg.get_uris()
for uri in uris:
fn = GLib.filename_from_uri(uri)[0]
if os.path.isfile(fn):
self.filestore.append(
[uri, os.path.basename(fn), Pango.Weight.NORMAL])
def remove_album_artwork(self, album):
"""
Remove album artwork
@param album as Album
"""
try:
for uri in self.get_album_artworks(album):
f = Gio.File.new_for_uri(uri)
try:
f.trash()
except:
f.delete(None)
if Lp().settings.get_value('save-to-tags') and\
GLib.find_program_in_path("kid3-cli") is not None:
argv = ["kid3-cli", "-c", "select all", "-c",
"set picture:'' ''"]
for uri in Lp().albums.get_track_uris(album.id, [], []):
try:
path = GLib.filename_from_uri(uri)[0]
argv.append(path)
except: # Gvfs can't find path for uri
pass
argv.append(None)
GLib.spawn_sync(None, argv, None,
GLib.SpawnFlags.SEARCH_PATH, None)
except Exception as e:
print("AlbumArt::remove_album_artwork():", e)
def __del_from_db(self, uri):
"""
Delete track from db
@param uri as str
"""
path = GLib.filename_from_uri(uri)[0]
name = GLib.path_get_basename(path)
track_id = Lp().tracks.get_id_by_uri(uri)
album_id = Lp().tracks.get_album_id(track_id)
genre_ids = Lp().tracks.get_genre_ids(track_id)
album_artist_ids = Lp().albums.get_artist_ids(album_id)
artist_ids = Lp().tracks.get_artist_ids(track_id)
popularity = Lp().tracks.get_popularity(track_id)
ltime = Lp().tracks.get_ltime(track_id)
mtime = Lp().albums.get_mtime(album_id)
duration = Lp().tracks.get_duration(track_id)
album_popularity = Lp().albums.get_popularity(album_id)
self.__history.add(name, duration, popularity, ltime, mtime,
album_popularity)
Lp().tracks.remove(track_id)
Lp().tracks.clean(track_id)
modified = Lp().albums.clean(album_id)
if modified:
with SqlCursor(Lp().db) as sql:
sql.commit()
GLib.idle_add(self.emit, 'album-updated', album_id)
for artist_id in album_artist_ids + artist_ids:
ret = Lp().artists.clean(artist_id)
if ret:
GLib.idle_add(self.emit, 'artist-updated', artist_id, album_id,
False)
for genre_id in genre_ids:
ret = Lp().genres.clean(genre_id)
if ret:
GLib.idle_add(self.emit, 'genre-updated', genre_id, False)
def __clip_dialog_cb(self, widget, clip):
clip = clip.bClip
asset = clip.get_asset()
filename = GLib.filename_from_uri(clip.props.uri)[0]
self.__current_builder = Gtk.Builder()
self.__current_builder.add_from_file(os.path.join(here, 'clip-dialog.ui'))
self.__current_builder.connect_signals(self)
self.__current_builder.get_object('step-spinner').set_range(1, 100)
dialog = self.__current_builder.get_object('clip-dialog')
dialog.set_transient_for(self.app.gui)
self.__analyse_track(filename, self.__display_track_analysis,
(self.__current_builder, asset, filename,))
res = dialog.run()
# We gud
dialog.destroy()
self.__add_markers_to_timeline(clip)
self.__clap_mixer.reset()
for handler_id in self.__clap_mixer_handlers:
GObject.signal_handler_disconnect(self.__clap_mixer.pipeline,
handler_id)
self.__clap_mixer_handlers = []
self.__current_builder = None
self.__selected_beats = None
def __on_can_set_cover(self, source, result, pop):
"""
Remove album image from tags
@param source as GObject.Object
@param result as Gio.AsyncResult
@param pop as int
"""
try:
can_set_cover = source.call_finish(result)
except:
can_set_cover = False
if can_set_cover:
if pop == 0:
value = 0
elif pop == 1:
value = 1
elif pop == 2:
value = 64
elif pop == 3:
value = 128
elif pop == 4:
value = 196
else:
value = 255
path = GLib.filename_from_uri(self.__object.uri)[0]
dbus_helper = DBusHelper()
dbus_helper.call("SetPopularity",
GLib.Variant("(is)", (value, path)), None, None)
return True
def __update_metadata(self):
if self.__get_status() == 'Stopped':
self.__metadata = {}
else:
if Lp().player.current_track.id >= 0:
track_id = Lp().player.current_track.id
else:
track_id = randint(10000000, 90000000)
self.__metadata['mpris:trackid'] = self.__get_media_id(track_id)
track_number = Lp().player.current_track.number
if track_number is None:
track_number = 1
self.__metadata['xesam:trackNumber'] = GLib.Variant('i',
track_number)
self.__metadata['xesam:title'] = GLib.Variant(
's',
Lp().player.current_track.name)
self.__metadata['xesam:album'] = GLib.Variant(
's',
Lp().player.current_track.album.name)
self.__metadata['xesam:artist'] = GLib.Variant(
'as',
Lp().player.current_track.artists)
self.__metadata['xesam:albumArtist'] = GLib.Variant(
'as',
Lp().player.current_track.album_artists)
self.__metadata['mpris:length'] = GLib.Variant(
'x',
Lp().player.current_track.duration * 1000000)
self.__metadata['xesam:genre'] = GLib.Variant(
'as',
Lp().player.current_track.genres)
self.__metadata['xesam:url'] = GLib.Variant(
's',
Lp().player.current_track.uri)
self.__metadata["xesam:userRating"] = GLib.Variant(
'd',
Lp().player.current_track.get_popularity() / 5)
if Lp().player.current_track.id == Type.RADIOS:
cover_path = Lp().art.get_radio_cache_path(
", ".join(Lp().player.current_track.artists),
ArtSize.MONSTER)
elif Lp().player.current_track.id == Type.EXTERNALS:
cover_path = "/tmp/lollypop_mpris.jpg"
pixbuf = Lp().art.pixbuf_from_tags(
GLib.filename_from_uri(Lp().player.current_track.uri)[0],
ArtSize.MONSTER)
if pixbuf is not None:
pixbuf.savev(cover_path, "jpeg",
["quality"], ["90"])
else:
cover_path = Lp().art.get_album_cache_path(
Lp().player.current_track.album, ArtSize.MONSTER)
if cover_path is not None:
self.__metadata['mpris:artUrl'] = GLib.Variant(
's',
"file://" + cover_path)
elif 'mpris:artUrl' in self.__metadata:
self.__metadata['mpris:artUrl'] = GLib.Variant('s', '')
def test_decode_not_encoded_uri():
filename = "/path name/with spaces"
uri = f"file://{filename}"
decoded_filename, hostname = GLib.filename_from_uri(uri)
decoded_posix_filename = pathlib.PurePath(decoded_filename).as_posix()
assert decoded_posix_filename == filename
assert hostname is None
def get_cover_for_uri(self, uri, size, selected):
pixbuf = self._pixbuf_from_tags(GLib.filename_from_uri(uri)[0], size)
if pixbuf is not None:
return self._make_icon_frame(pixbuf, selected)
else:
return self._make_icon_frame(self._get_default_icon(
size,
'folder-music-symbolic'),
selected)
def test_uri_conversion_with_spaces():
filename = "/path name/with spaces"
uri = GLib.filename_to_uri(filename)
decoded_filename, hostname = GLib.filename_from_uri(uri)
decoded_posix_filename = pathlib.PurePath(decoded_filename).as_posix()
assert uri == "file:///path%20name/with%20spaces"
assert decoded_posix_filename == filename
assert hostname is None
def set_uri(self, uri):
"""
Set uri and path
@param uri as string
"""
self._uri = uri
try:
self.path = GLib.filename_from_uri(uri)[0]
except:
pass
def set_uri(self, uri):
"""
Set uri and path
@param uri as string
"""
self._uri = uri
try:
self.path = GLib.filename_from_uri(uri)[0]
except:
pass
def __edit_tag(self, action, variant):
"""
Run tag editor
@param SimpleAction
@param GVariant
"""
path = GLib.filename_from_uri(self._object.uri)[0]
dbus_helper = DBusHelper()
dbus_helper.call("LaunchTagEditor", GLib.Variant("(s)", (path,)),
None, None)
def __edit_tags(self, args):
"""
Run tags editor
@param args as unused
"""
path = GLib.filename_from_uri(self.__object.uri)[0]
dbus_helper = DBusHelper()
dbus_helper.call("LaunchTagEditor", GLib.Variant("(s)", (path, )),
None, None)
self.__button.emit("clicked")
def on_recent_activated(self, widget):
#item = recentchoosermenu.get_current_item()
#if item:
# name = item.get_display_name()
# uri = item.get_uri()
# log.debug(f"Recent item selected: {name}, {uri}")
rom_uri = widget.get_current_uri()
raw_path = GLib.filename_from_uri(rom_uri)
self.parent.rom = raw_path[0]
self.parent.action.thread_rom()
def __edit_tag(self, action, variant):
"""
Run tag editor
@param SimpleAction
@param GVariant
"""
try:
path = GLib.filename_from_uri(self._object.uri)[0]
Gio.bus_get(Gio.BusType.SESSION, None, self.__on_get_bus,
"LaunchTagEditor", GLib.Variant('(s)', (path, )), None)
except Exception as e:
print("EditMenu::__edit_tag():", e)
def __edit_tags(self, args):
"""
Edit tags
@param args as []
"""
try:
path = GLib.filename_from_uri(self.__object.uri)[0]
Gio.bus_get(Gio.BusType.SESSION, None, self.__on_get_bus,
"LaunchTagEditor", GLib.Variant("(s)", (path, )), None)
except Exception as e:
print("ContextWidget::__edit_tags", e)
self.__button.emit("clicked")
def on_drag_data_received(self, widget, drag_context, x, y, data, info, time):
if info == TARGET_ENTRY_TEXT:
text = data.get_text()
print "Got: %s" % text
print data.get_text().split('\r\n')
self.app.convert(GLib.filename_from_uri (text)[0])
elif info == TARGET_ENTRY_PIXBUF:
pixbuf = data.get_pixbuf()
width = pixbuf.get_width()
height = pixbuf.get_height()
print "Received pixbuf with width %spx and height %spx" % (width, height)
def get_bookmark_dirs(self):
filename = Path(GLib.get_user_config_dir()) / 'gtk-3.0' / 'bookmarks'
if not filename.is_file():
filename = Path.home() / '.gtk-bookmarks'
try:
with filename.open() as bookmarks:
for bookmark in bookmarks:
uri = bookmark.strip().split(' ')[0]
if Pluma.utils_uri_has_file_scheme(uri):
yield GLib.filename_from_uri(uri)[0]
except FileNotFoundError:
pass
def _on_button_press(self, widget, event):
"""
On button press, set album popularity
@param widget as Gtk.EventBox
@param event as Gdk.Event
"""
if Lp().scanner.is_locked():
return
user_rating = self.__object.get_rate() != Type.NONE
event_star = widget.get_children()[0]
if event_star in self._stars:
position = self._stars.index(event_star)
else:
position = -1
pop = position + 1
if pop == 0:
if user_rating:
self.__object.set_rate(Type.NONE)
else:
self.__object.set_popularity(0)
elif event.button == 1:
self.__object.set_rate(pop)
else:
self.__object.set_popularity(pop)
if isinstance(self.__object, Track):
Lp().player.emit("rate-changed")
# Save to tags if needed
# FIXME We really need a radio object
# FIXME We look to kid3-cli here!
if Lp().settings.get_value("save-to-tags") and\
GLib.find_program_in_path("kid3-cli") is not None and\
isinstance(self.__object, Track) and\
self.__object.id >= 0 and\
not self.__object.is_web:
if pop == 0:
value = 0
elif pop == 1:
value = 1
elif pop == 2:
value = 64
elif pop == 3:
value = 128
elif pop == 4:
value = 196
else:
value = 255
path = GLib.filename_from_uri(self.__object.uri)[0]
dbus_helper = DBusHelper()
dbus_helper.call("SetPopularity",
GLib.Variant("(is)", (value, path)), None, None)
return True
def _on_entry_parsed(self, parser, uri, metadata, playlist_id):
"""
Import entry
@param parser as TotemPlParser.Parser
@param playlist uri as str
@param metadata as GLib.HastTable
@param playlist id as int
"""
try:
track_id = Lp().tracks.get_id_by_path(GLib.filename_from_uri(uri)[0])
if track_id is not None:
self.add_tracks(playlist_id, [Track(track_id)])
except Exception as e:
print("Playlists::_on_entry_parsed: %s" % e)
def _addid(self, cmd_args):
"""
Add track to mpd playlist at pos
@syntax add filepath
@param args as str
@return msg as str
"""
arg = self._get_args(cmd_args)[0]
self._add(cmd_args)
try:
arg = GLib.filename_from_uri(arg)[0]
except:
pass
return "Id: %s" % Lp().tracks.get_id_by_path(arg)
def _update_metadata(self):
if self._get_status() == 'Stopped':
self._metadata = {}
else:
if Lp.player.current_track.id >= 0:
self._metadata['mpris:trackid'] = dbus.ObjectPath(
'/org/lollypop/%s' % Lp.player.current_track.id)
else:
# MPRIS SUX
track_id = randint(10000000, 90000000)
self._metadata['mpris:trackid'] = dbus.ObjectPath(
'/org/lollypop/%s' % track_id)
self._metadata['xesam:trackNumber'] =\
Lp.player.current_track.number
self._metadata['xesam:title'] = Lp.player.current_track.name
self._metadata['xesam:album'] = Lp.player.current_track.album.name
self._metadata['xesam:artist'] = [Lp.player.current_track.artist]
self._metadata['xesam:albumArtist'] = [
Lp.player.current_track.album_artist]
self._metadata['mpris:length'] = dbus.Int64(
Lp.player.current_track.duration * 1000000)
self._metadata['xesam:genre'] = [Lp.player.current_track.genre]
self._metadata['xesam:url'] = Lp.player.current_track.uri
self._metadata["xesam:userRating"] = \
Lp.player.current_track.get_popularity() / 5
if Lp.player.current_track.id == Type.RADIOS:
cover_path = Lp.art.get_radio_cache_path(
Lp.player.current_track.artist, ArtSize.BIG)
elif Lp.player.current_track.id == Type.EXTERNALS:
cover_path = "/tmp/lollypop_mpris.jpg"
pixbuf = Lp.art.pixbuf_from_tags(
GLib.filename_from_uri(Lp.player.current_track.uri)[0],
ArtSize.BIG)
if pixbuf is not None:
# Gdk < 3.15 was missing save method
# > 3.15 is missing savev method
try:
pixbuf.save(cover_path, "jpeg",
["quality"], ["90"])
except:
pixbuf.savev(cover_path, "jpeg",
["quality"], ["90"])
else:
cover_path = Lp.art.get_album_cache_path(
Lp.player.current_track.album, ArtSize.BIG)
if cover_path is not None:
self._metadata['mpris:artUrl'] = "file://" + cover_path
elif 'mpris:artUrl' in self._metadata:
del self._metadata['mpris:artUrl']
def get_album_artwork2(self, uri, size):
"""
Return a cairo surface with borders for uri
No cache usage
@param uri as string
@param size as int
@return cairo surface
"""
pixbuf = self.pixbuf_from_tags(GLib.filename_from_uri(uri)[0], size)
if pixbuf is not None:
surface = Gdk.cairo_surface_create_from_pixbuf(pixbuf, 0, None)
del pixbuf
return surface
else:
return self._get_default_icon(size, 'folder-music-symbolic')
def _update_metadata(self):
if self._get_status() == 'Stopped':
self._metadata = {}
else:
if Lp().player.current_track.id >= 0:
self._metadata['mpris:trackid'] = dbus.ObjectPath(
'/org/lollypop/%s' % Lp().player.current_track.id)
else:
# MPRIS SUX
track_id = randint(10000000, 90000000)
self._metadata['mpris:trackid'] = dbus.ObjectPath(
'/org/lollypop/%s' % track_id)
track_number = Lp().player.current_track.number
if track_number is None:
track_number = 1
self._metadata['xesam:trackNumber'] = track_number
self._metadata['xesam:title'] = Lp().player.current_track.name
self._metadata['xesam:album'] = Lp(
).player.current_track.album.name
self._metadata['xesam:artist'] = Lp().player.current_track.artists
self._metadata['xesam:albumArtist'] = \
", ".join(Lp().player.current_track.album_artists)
self._metadata['mpris:length'] = dbus.Int64(
Lp().player.current_track.duration * 1000000)
self._metadata['xesam:genre'] = Lp().player.current_track.genres\
or "Web"
self._metadata['xesam:url'] = Lp().player.current_track.uri
self._metadata["xesam:userRating"] = \
Lp().player.current_track.get_popularity() / 5
if Lp().player.current_track.id == Type.RADIOS:
cover_path = Lp().art.get_radio_cache_path(
", ".join(Lp().player.current_track.artists),
ArtSize.MONSTER)
elif Lp().player.current_track.id == Type.EXTERNALS:
cover_path = "/tmp/lollypop_mpris.jpg"
pixbuf = Lp().art.pixbuf_from_tags(
GLib.filename_from_uri(Lp().player.current_track.uri)[0],
ArtSize.MONSTER)
if pixbuf is not None:
pixbuf.savev(cover_path, "jpeg",
["quality"], ["90"])
else:
cover_path = Lp().art.get_album_cache_path(
Lp().player.current_track.album, ArtSize.MONSTER)
if cover_path is not None:
self._metadata['mpris:artUrl'] = "file://" + cover_path
elif 'mpris:artUrl' in self._metadata:
self._metadata['mpris:artUrl'] = ''
def load_external(self, uri, name=''):
"""
Load external tracks
@param uri as str
@param name as string
"""
track = Track()
track.set_album_artists([name])
track.set_uri(uri)
if track.uri.startswith('file://'):
track.id = Type.EXTERNALS
track.name = GLib.path_get_basename(GLib.filename_from_uri(uri)[0])
else:
track.name = uri
track.id = Type.RADIOS
self._external_tracks.append(track)
def _UpdatePreview(self,e) :
uri = self.FileChooserDialog.get_preview_uri()
if uri!=None :
if not GLib.file_test(GLib.filename_from_uri(uri,""),GLib.FileTest.IS_DIR) :
file = Gio.File.new_for_uri(uri)
file_info = file.query_info("*",Gio.FileQueryInfoFlags.NONE,None)
mtime = file_info.get_attribute_uint64(Gio.FILE_ATTRIBUTE_TIME_MODIFIED)
ThumbnailFactory = GnomeDesktop.DesktopThumbnailFactory.new(GnomeDesktop.DesktopThumbnailSize.NORMAL)
thumbpath = ThumbnailFactory.lookup(uri,mtime)
pixbuf = GdkPixbuf.Pixbuf.new_from_file(thumbpath)
self.PreviewImage.set_from_pixbuf(pixbuf)
self.FileChooserDialog.set_preview_widget_active(True)
else :
self.FileChooserDialog.set_preview_widget_active(False)
else :
self.FileChooserDialog.set_preview_widget_active(False)
def _media_files_drag_received(widget, context, x, y, data, info, timestamp):
uris = data.get_uris()
files = []
for uri in uris:
try:
uri_tuple = GLib.filename_from_uri(uri)
except:
continue
uri, unused = uri_tuple
if os.path.exists(uri) == True:
if utils.is_media_file(uri) == True:
files.append(uri)
if len(files) == 0:
return
open_dropped_files(files)
def __save_artwork_tags(self, data, album):
"""
Save artwork in tags
@param data as bytes
@param album as Album
"""
if album.is_web:
return
stream = Gio.MemoryInputStream.new_from_data(data, None)
pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(stream,
ArtSize.MONSTER,
ArtSize.MONSTER,
True,
None)
stream.close()
pixbuf.savev("%s/lollypop_cover_tags.jpg" % self._CACHE_PATH,
"jpeg", ["quality"], [str(Lp().settings.get_value(
'cover-quality').get_int32())])
del pixbuf
f = Lio.File.new_for_path("%s/lollypop_cover_tags.jpg" %
self._CACHE_PATH)
if f.query_exists():
for uri in Lp().albums.get_track_uris(album.id, [], []):
try:
path = GLib.filename_from_uri(uri)[0]
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(
bus, Gio.DBusProxyFlags.NONE, None,
'org.gnome.Lollypop.Portal',
'/org/gnome/LollypopPortal',
'org.gnome.Lollypop.Portal', None)
proxy.call_sync('SetCover',
GLib.Variant(
'(ss)', (path,
"%s/lollypop_cover_tags.jpg" %
self._CACHE_PATH)),
Gio.DBusCallFlags.NO_AUTO_START,
500, None)
except Exception as e:
print("You are missing lollypop-portal: "
"https://github.com/gnumdk/lollypop-portal", e)
f = Lio.File.new_for_path("%s/lollypop_cover_tags.jpg" %
self._CACHE_PATH)
f.delete()
self.clean_album_cache(album)
GLib.idle_add(self.album_artwork_update, album.id)
def get_cover_for_uri(self, uri, size, selected):
"""
Return a cairo surface with borders for uri
No cache usage
@param uri as string
@param size as int
@param selected as bool
@return cairo surface
"""
pixbuf = self.pixbuf_from_tags(GLib.filename_from_uri(uri)[0], size)
if pixbuf is not None:
return self.make_icon_frame(pixbuf, selected)
else:
return self.make_icon_frame(self._get_default_icon(
size,
'folder-music-symbolic'),
selected)
def __init__(self, src, dst=None, destdir=None):
GObject.GObject.__init__(self)
self.errstr = ''
self.fail = False
src = GLib.filename_from_uri (src)[0]
if (dst == None):
if (destdir):
dst = destdir + '/' + src.split('/')[-1].strip() + '.m4v'
else:
dst = src.strip() + '.m4v'
self.src = src
self.dst = dst
(fd, self.mlt) = tempfile.mkstemp('.mlt')
os.close(fd)
def _populate(self, tracks):
"""
Populate popover
@param tracks as [Track]
@thread safe
"""
for track in tracks:
if track.duration == 0.0:
try:
path = GLib.filename_from_uri(track.uri)[0]
infos = self._tagreader.get_infos(path)
if infos is not None:
tags = infos.get_tags()
track.duration = infos.get_duration()/1000000000
track.title = self._tagreader.get_title(tags, path)
track.artist = self._tagreader.get_artists(tags)
except:
track.title = track.uri
GLib.idle_add(self._add_track, track)
def __edit_tag(self, action, variant):
"""
Run tag editor
@param SimpleAction
@param GVariant
"""
try:
path = GLib.filename_from_uri(self._object.uri)[0]
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(
bus, Gio.DBusProxyFlags.NONE, None,
'org.gnome.Lollypop.Portal',
'/org/gnome/LollypopPortal',
'org.gnome.Lollypop.Portal', None)
proxy.call('LaunchTagEditor',
GLib.Variant('(s)', (path,)),
Gio.DBusCallFlags.NO_AUTO_START,
500, None)
except Exception as e:
print("EditMenu::__edit_tag():", e)
def __edit_tags(self, args):
"""
Edit tags
@param args as []
"""
try:
path = GLib.filename_from_uri(self.__object.uri)[0]
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(
bus, Gio.DBusProxyFlags.NONE, None,
'org.gnome.Lollypop.Portal',
'/org/gnome/LollypopPortal',
'org.gnome.Lollypop.Portal', None)
proxy.call('LaunchTagEditor',
GLib.Variant('(s)', (path,)),
Gio.DBusCallFlags.NO_AUTO_START,
500, None)
except Exception as e:
print("ContextWidget::__edit_tag():", e)
self.__button.emit('clicked')
def remove_album_artwork(self, album):
"""
Remove album artwork
@param album as Album
"""
try:
for uri in self.get_album_artworks(album):
f = Lio.File.new_for_uri(uri)
try:
f.trash()
except:
f.delete(None)
# Check portal for kid3-cli
can_set_cover = False
try:
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(
bus, Gio.DBusProxyFlags.NONE, None,
'org.gnome.Lollypop.Portal',
'/org/gnome/LollypopPortal',
'org.gnome.Lollypop.Portal', None)
can_set_cover = proxy.call_sync(
'CanSetCover', None,
Gio.DBusCallFlags.NO_AUTO_START,
500, None)[0]
except Exception as e:
print("You are missing lollypop-portal: "
"https://github.com/gnumdk/lollypop-portal", e)
if Lp().settings.get_value('save-to-tags') and can_set_cover:
for uri in Lp().albums.get_track_uris(album.id, [], []):
try:
path = GLib.filename_from_uri(uri)[0]
proxy.call_sync('SetCover',
GLib.Variant('(ss)', (path, "")),
Gio.DBusCallFlags.NO_AUTO_START,
500, None)
except Exception as e:
print("AlbumArt::remove_album_artwork2():", e)
except Exception as e:
print("AlbumArt::remove_album_artwork3():", e)
def __save_artwork_tags(self, data, album):
"""
Save artwork in tags
@param data as bytes
@param album as Album
"""
if album.is_web:
return
stream = Gio.MemoryInputStream.new_from_data(data, None)
pixbuf = GdkPixbuf.Pixbuf.new_from_stream_at_scale(stream,
ArtSize.MONSTER,
ArtSize.MONSTER,
True,
None)
pixbuf.savev("/tmp/lollypop_cover_tags.jpg",
"jpeg", ["quality"], ["90"])
del pixbuf
f = Gio.File.new_for_path("/tmp/lollypop_cover_tags.jpg")
if f.query_exists():
for uri in Lp().albums.get_track_uris(album.id, [], []):
try:
path = GLib.filename_from_uri(uri)[0]
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
proxy = Gio.DBusProxy.new_sync(
bus, Gio.DBusProxyFlags.NONE, None,
'org.gnome.Lollypop.Portal',
'/org/gnome/LollypopPortal',
'org.gnome.Lollypop.Portal', None)
proxy.call_sync('SetCover',
GLib.Variant(
'(ss)', (path,
"/tmp/lollypop_cover_tags.jpg")),
Gio.DBusCallFlags.NO_AUTO_START,
500, None)
except Exception as e:
print("AlbumArt::__save_artwork_tags():", e)
f = Gio.File.new_for_path("/tmp/lollypop_cover_tags.jpg")
f.delete()
self.clean_album_cache(album)
GLib.idle_add(self.album_artwork_update, album.id)
def __populate(self, tracks):
"""
Populate popover
@param tracks as [Track]
@thread safe
"""
for track in tracks:
if track.duration == 0.0:
try:
info = self.__tagreader.get_info(track.uri)
track_name = GLib.path_get_basename(
GLib.filename_from_uri(track.uri)[0])
if info is not None:
tags = info.get_tags()
track.duration = info.get_duration()/1000000000
track.name = self.__tagreader.get_title(tags,
track_name)
track.artist_names = self.__tagreader.get_artists(tags)
else:
track.name = track_name
except Exception as e:
print("ExternalsPopover::__populate(): %s" % e)
track.name = track_name
GLib.idle_add(self.__add_track, track)
def _on_entry_parsed(self, parser, uri, metadata):
# Check if it's really a file uri
if uri.startswith('file://'):
self._external_files.append(GLib.filename_from_uri(uri)[0])
else:
self._external_files.append(uri)
def do_drag_data_received(self, context, x, y, selection, target, time):
if target == self._DND_URI:
self._library.add_fonts(
(GLib.filename_from_uri(uri)[0] for uri in
selection.get_uris() if uri.startswith('file://')))
context.finish(True, False, time)
def _on_entry_parsed(self, parser, uri, metadata, data=None):
filename = GLib.filename_from_uri(uri)[0]
if filename and not os.path.isfile(filename):
return
grilo.get_media_from_uri(uri, data)
def __run_analysis_clicked_cb(self, widget, asset_uri):
self.__analyse_track(GLib.filename_from_uri(asset_uri)[0], None, None)
