def __init__(self, source, coremodel, core_selection, grilo):
super().__init__()
self._coremodel = coremodel
self._core_selection = core_selection
self._grilo = grilo
self._source = source
self._model = self._coremodel.props.songs
self._albums_model = self._coremodel.props.albums
self._album_ids = {}
self._artists_model = self._coremodel.props.artists
Grl.init(None)
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._full_options = Grl.OperationOptions()
self._full_options.set_resolution_flags(
Grl.ResolutionFlags.FULL | Grl.ResolutionFlags.IDLE_RELAY)
# self._initial_fill(self._source)
# self._initial_albums_fill(self._source)
self._initial_artists_fill(self._source)
def __init__(self):
GObject.GObject.__init__(self)
self.playlist_path = GLib.build_filenamev([GLib.get_user_data_dir(),
"gnome-music", "playlists"])
if not (GLib.file_test(self.playlist_path, GLib.FileTest.IS_DIR)):
GLib.mkdir_with_parents(self.playlist_path, int("0755", 8))
Grl.init(None)
self.options = Grl.OperationOptions()
self.options.set_resolution_flags(Grl.ResolutionFlags.FAST_ONLY |
Grl.ResolutionFlags.IDLE_RELAY)
self.full_options = Grl.OperationOptions()
self.full_options.set_resolution_flags(Grl.ResolutionFlags.FULL |
Grl.ResolutionFlags.IDLE_RELAY)
self.sources = {}
self.blacklist = ['grl-filesystem', 'grl-bookmarks', 'grl-metadata-store', 'grl-podcasts']
self.tracker = None
self.changed_media_ids = []
self.pending_event_id = 0
self.changes_pending = {'Albums': False, 'Artists': False, 'Songs': False}
self.pending_changed_medias = []
self.registry = Grl.Registry.get_default()
self.sparqltracker = TrackerWrapper().tracker
def __init__(self, source, application, tracker_wrapper):
"""Initialize the Tracker wrapper
:param Grl.TrackerSource source: The Tracker source to wrap
:param Application application: Application instance
:param TrackerWrapper tracker_wrapper: The TrackerWrapper instance
"""
super().__init__()
self._application = application
coremodel = application.props.coremodel
self._log = application.props.log
self._songs_model = Gio.ListStore.new(CoreSong)
coremodel.props.songs_proxy.append(self._songs_model)
self._source = None
self._albums_model = Gio.ListStore.new(CoreAlbum)
coremodel.props.albums_proxy.append(self._albums_model)
self._album_ids = {}
self._artists_model = Gio.ListStore.new(CoreArtist)
coremodel.props.artists_proxy.append(self._artists_model)
self._artist_ids = {}
self._hash = {}
self._song_search_proxy = coremodel.props.songs_search_proxy
self._album_search_model = coremodel.props.albums_search
self._artist_search_model = coremodel.props.artists_search
self._batch_changed_media_ids = {}
self._content_changed_timeout = None
self._tracker_playlists = None
self._tracker_wrapper = tracker_wrapper
self._notificationmanager = application.props.notificationmanager
self._song_search_tracker = Gfm.FilterListModel.new(self._songs_model)
self._song_search_tracker.set_filter_func(lambda a: False)
self._song_search_proxy.append(self._song_search_tracker)
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._full_options = Grl.OperationOptions()
self._full_options.set_resolution_flags(
Grl.ResolutionFlags.FULL | Grl.ResolutionFlags.IDLE_RELAY)
self._content_changed_id = None
self.props.source = source
self._initial_songs_fill()
self._initial_albums_fill()
self._initial_artists_fill()
def test_default_values(self):
options = Grl.OperationOptions()
self.assertEqual(options.get_skip(), 0)
self.assertEqual(options.get_count(), Grl.COUNT_INFINITY)
self.assertEqual(options.get_flags(),
Grl.MetadataResolutionFlags.NORMAL)
self.assertEqual(options.get_type_filter(), Grl.TypeFilter.ALL)
def __init__(self, source, coremodel, coreselection, grilo,
tracker_wrapper):
"""Initialize GrlTrackerPlaylists.
:param Grl.TrackerSource source: The Tracker source to wrap
:param CoreModel coremodel: CoreModel instance to use models
from
:param CoreSelection coreselection: CoreSelection instance to
use
:param CoreGrilo grilo: The CoreGrilo instance
:param TrackerWrapper tracker_wrapper: The TrackerWrapper
instance
"""
super().__init__()
self._coremodel = coremodel
self._coreselection = coreselection
self._grilo = grilo
self._source = source
self._model = self._coremodel.props.playlists
self._model_filter = self._coremodel.props.playlists_filter
self._pls_todelete = []
self._tracker = tracker_wrapper.props.tracker
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._initial_playlists_fill()
def __init__(self, source, application, tracker_wrapper, songs_hash):
"""Initialize GrlTrackerPlaylists.
:param Grl.TrackerSource source: The Tracker source to wrap
:param Application application: Application instance
:param TrackerWrapper tracker_wrapper: The TrackerWrapper
instance
:param dict songs_hash: The songs hash table
"""
super().__init__()
self._application = application
self._coremodel = application.props.coremodel
self._log = application.props.log
self._source = source
self._model = self._coremodel.props.playlists
self._model_filter = self._coremodel.props.playlists_filter
self._user_model_filter = self._coremodel.props.user_playlists_filter
self._pls_todelete = []
self._songs_hash = songs_hash
self._tracker = tracker_wrapper.props.local_db
self._tracker_wrapper = tracker_wrapper
self._notificationmanager = application.props.notificationmanager
self._window = application.props.window
self._user_model_filter.set_filter_func(self._user_playlists_filter)
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._initial_playlists_fill()
def __init__(self, source, application):
"""Initialize a search wrapper
Initialize a generic Grilo source search wrapper.
:param Grl.Source source: The Grilo source to wrap
:param Application application: Application instance
"""
super().__init__()
self._application = application
self._coreselection = application.props.coreselection
self._log = application.props.log
self._source = source
coremodel = application.props.coremodel
self._song_search_proxy = coremodel.props.songs_search_proxy
self._song_search_store = Gio.ListStore.new(CoreSong)
# FIXME: Workaround for adding the right list type to the proxy
# list model.
self._song_search_model = Gfm.FilterListModel.new(
self._song_search_store)
self._song_search_model.set_filter_func(lambda a: True)
self._song_search_proxy.append(self._song_search_model)
self._fast_options = Grl.OperationOptions()
self._fast_options.set_count(25)
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
def __init__(self,
media=None,
query=None,
tag_text=None,
source=None,
coremodel=None,
coreselection=None,
grilo=None,
tracker=None):
super().__init__()
if media:
self.props.pl_id = media.get_id()
self.props.title = utils.get_media_title(media)
self.props.count = media.get_childcount()
self.props.creation_date = media.get_creation_date()
self.props.query = query
self.props.tag_text = tag_text
self._model = None
self._source = source
self._coremodel = coremodel
self._coreselection = coreselection
self._grilo = grilo
self._tracker = tracker
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._songs_todelete = []
def __init__(self):
super().__init__()
self.playlist_path = GLib.build_filenamev(
[GLib.get_user_data_dir(), "gnome-music", "playlists"])
if not (GLib.file_test(self.playlist_path, GLib.FileTest.IS_DIR)):
GLib.mkdir_with_parents(self.playlist_path, int("0755", 8))
Grl.init(None)
self.options = Grl.OperationOptions()
self.options.set_resolution_flags(Grl.ResolutionFlags.FAST_ONLY
| Grl.ResolutionFlags.IDLE_RELAY)
self.full_options = Grl.OperationOptions()
self.full_options.set_resolution_flags(
Grl.ResolutionFlags.FULL | Grl.ResolutionFlags.IDLE_RELAY)
self.props.sources = {}
self.blacklist = [
'grl-filesystem', 'grl-bookmarks', 'grl-metadata-store',
'grl-podcasts', 'grl-spotify-cover'
]
self.tracker = None
self.changed_media_ids = []
self.pending_event_id = 0
self.changes_pending = {
'Albums': False,
'Artists': False,
'Songs': False
}
self.pending_changed_medias = []
self._thumbnail_sources = []
self._thumbnail_sources_timeout = None
self.registry = Grl.Registry.get_default()
self._tracker_wrapper = TrackerWrapper()
self.tracker_sparql = self._tracker_wrapper.props.tracker
self._tracker_wrapper.bind_property(
"tracker-available", self, "tracker-available",
GObject.BindingFlags.BIDIRECTIONAL
| GObject.BindingFlags.SYNC_CREATE)
self._find_sources()
def _populate_model(self):
query = """
SELECT
rdf:type(?song)
?song AS ?tracker_urn
tracker:id(?entry) AS ?id
nie:url(?song) AS ?url
nie:title(?song) AS ?title
nmm:artistName(nmm:performer(?song)) AS ?artist
nie:title(nmm:musicAlbum(?song)) AS ?album
nfo:duration(?song) AS ?duration
?tag AS ?favourite
nie:contentAccessed(?song) AS ?last_played_time
nie:usageCounter(?song) AS ?play_count
WHERE {
?playlist a nmm:Playlist ;
a nfo:MediaList ;
nfo:hasMediaFileListEntry ?entry .
?entry a nfo:MediaFileListEntry ;
nfo:entryUrl ?url .
?song a nmm:MusicPiece ;
a nfo:FileDataObject ;
nie:url ?url .
OPTIONAL {
?song nao:hasTag ?tag .
FILTER( ?tag = nao:predefined-tag-favorite )
}
FILTER (
%(filter_clause)s
)
FILTER (
NOT EXISTS { ?song a nmm:Video }
&& NOT EXISTS { ?song a nmm:Playlist }
)
}
ORDER BY nfo:listPosition(?entry)
""".replace('\n', ' ').strip() % {
'filter_clause': 'tracker:id(?playlist) = ' + self.props.pl_id
}
def _add_to_playlist_cb(source, op_id, media, remaining, user_data,
error):
if not media:
self.props.count = self._model.get_n_items()
self.emit("playlist-loaded")
return
coresong = CoreSong(media, self._coreselection, self._grilo)
if coresong not in self._songs_todelete:
self._model.append(coresong)
options = Grl.OperationOptions()
options.set_resolution_flags(Grl.ResolutionFlags.FAST_ONLY
| Grl.ResolutionFlags.IDLE_RELAY)
self._source.query(query, self.METADATA_KEYS, options,
_add_to_playlist_cb, None)
def __init__(self, source, coremodel, coreselection, grilo,
tracker_wrapper):
"""Initialize the Tracker wrapper
:param Grl.TrackerSource source: The Tracker source to wrap
:param CoreModel coremodel: CoreModel instance to use models
from
:param CoreSelection coreselection: CoreSelection instance to
use
:param CoreGrilo grilo: The CoreGrilo instance
:param TrackerWrapper tracker_wrapper: The TrackerWrapper instance
"""
super().__init__()
self._coremodel = coremodel
self._coreselection = coreselection
self._grilo = grilo
self._source = source
self._model = self._coremodel.props.songs
self._albums_model = self._coremodel.props.albums
self._album_ids = {}
self._artists_model = self._coremodel.props.artists
self._artist_ids = {}
self._hash = {}
self._song_search_proxy = self._coremodel.props.songs_search_proxy
self._album_search_model = self._coremodel.props.albums_search
self._artist_search_model = self._coremodel.props.artists_search
self._batch_changed_media_ids = {}
self._content_changed_timeout = None
self._song_search_tracker = Gfm.FilterListModel.new(self._model)
self._song_search_tracker.set_filter_func(lambda a: False)
self._song_search_proxy.append(self._song_search_tracker)
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._initial_songs_fill(self._source)
self._initial_albums_fill(self._source)
self._initial_artists_fill(self._source)
self._tracker_playlists = GrlTrackerPlaylists(source, coremodel,
coreselection, grilo,
tracker_wrapper)
self._source.notify_change_start()
self._source.connect("content-changed", self._batch_content_changed)
def get_album_art_for_item(self, coresong, callback):
"""Placeholder until we got a better solution
"""
item_id = coresong.props.media.get_id()
if coresong.props.media.is_audio():
query = self._get_album_for_song_id(item_id)
else:
query = self._get_album_for_album_id(item_id)
full_options = Grl.OperationOptions()
full_options.set_resolution_flags(Grl.ResolutionFlags.FULL
| Grl.ResolutionFlags.IDLE_RELAY)
full_options.set_count(1)
self._source.query(query, self.METADATA_THUMBNAIL_KEYS, full_options,
callback)
def __init__(self,
media=None,
query=None,
tag_text=None,
source=None,
application=None,
tracker_wrapper=None,
songs_hash=None):
super().__init__()
"""Initialize a playlist
:param Grl.Media media: A media object
:param string query: Tracker query that returns the playlist
:param string tag_text: The non translatable unique identifier
of the playlist
:param Grl.Source source: The Grilo Tracker source object
:param Application application: The Application instance
:param TrackerWrapper tracker_wrapper: The TrackerWrapper instance
:param dict songs_hash: The songs hash table
"""
if media:
self.props.pl_id = media.get_id()
self._title = utils.get_media_title(media)
self.props.count = media.get_childcount()
self.props.creation_date = media.get_creation_date()
else:
self._title = None
self.props.query = query
self.props.tag_text = tag_text
self._application = application
self._model = None
self._source = source
self._coremodel = application.props.coremodel
self._coreselection = application.props.coreselection
self._log = application.props.log
self._songs_hash = songs_hash
self._tracker = tracker_wrapper.props.local_db
self._tracker_wrapper = tracker_wrapper
self._notificationmanager = application.props.notificationmanager
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._songs_todelete = []
def _on_try_load_finished(self, icon, data=None):
if icon:
self.finish(icon)
return
options = Grl.OperationOptions()
options.set_flags(Grl.ResolutionFlags.FULL
| Grl.ResolutionFlags.IDLE_RELAY)
uri = self.item.get_thumbnail()
if uri is None:
self.finish(None)
return
AlbumArtCache.get_default().get_from_uri(uri, self.artist, self.album,
self.width, self.height,
self.callback, self.data)
def __init__(self, source, coremodel, coreselection, grilo):
super().__init__()
self._coremodel = coremodel
self._coreselection = coreselection
self._grilo = grilo
self._source = source
self._model = self._coremodel.props.playlists
self._model_filter = self._coremodel.props.playlists_filter
self._pls_todelete = []
self._tracker = TrackerWrapper().props.tracker
self._fast_options = Grl.OperationOptions()
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
self._initial_playlists_fill()
def get_artist_art(self, coreartist):
media = coreartist.props.media
def _resolve_cb(source, op_id, resolved_media, data, error):
if resolved_media.get_thumbnail() is None:
coreartist.props.thumbnail = ""
return
media.set_thumbnail(resolved_media.get_thumbnail())
coreartist.props.thumbnail = media.get_thumbnail()
full_options = Grl.OperationOptions()
full_options.set_resolution_flags(Grl.ResolutionFlags.FULL
| Grl.ResolutionFlags.IDLE_RELAY)
self._source.resolve(media, [Grl.METADATA_KEY_THUMBNAIL], full_options,
_resolve_cb, None)
def test_value_setting_no_caps(self):
options = Grl.OperationOptions()
options.set_skip(12)
self.assertEqual(options.get_skip(), 12)
options.set_count(28)
self.assertEqual(options.get_count(), 28)
flags =Grl.MetadataResolutionFlags.FAST_ONLY \
| Grl.MetadataResolutionFlags.IDLE_RELAY
options.set_flags(flags)
self.assertEqual(options.get_flags(), flags)
fltr = Grl.TypeFilter.AUDIO | Grl.TypeFilter.VIDEO
options.set_type_filter(fltr)
self.assertEqual(options.get_type_filter(), fltr)
def __init__(self):
GObject.GObject.__init__(self)
self.options = Grl.OperationOptions()
self.options.set_flags(Grl.ResolutionFlags.FULL
| Grl.ResolutionFlags.IDLE_RELAY)
self.registry = Grl.Registry.get_default()
try:
self.registry.load_all_plugins()
except GLib.GError:
print('Failed to load plugins.')
self.sources = {}
self.tracker = None
self.registry.connect('source_added', self._on_source_added)
self.registry.connect('source_removed', self._on_source_removed)
def __init__(self, source, coremodel, coreselection, grilo):
super().__init__()
self._coremodel = coremodel
self._coreselection = coreselection
self._grilo = grilo
self._source = source
self._song_search_proxy = self._coremodel.props.songs_search_proxy
self._song_search_store = Gio.ListStore.new(CoreSong)
# FIXME: Workaround for adding the right list type to the proxy
# list model.
self._song_search_model = Gfm.FilterListModel.new(
self._song_search_store)
self._song_search_model.set_filter_func(lambda a: True)
self._song_search_proxy.append(self._song_search_model)
self._fast_options = Grl.OperationOptions()
self._fast_options.set_count(25)
self._fast_options.set_resolution_flags(
Grl.ResolutionFlags.FAST_ONLY | Grl.ResolutionFlags.IDLE_RELAY)
def _populate_model(self):
self._notificationmanager.push_loading()
query = """
SELECT
%(media_type)s AS ?type
?song AS ?id
?url
?title
?artist
?album
?duration
?tag AS ?favorite
nie:contentAccessed(?song) AS ?lastPlayed
nie:usageCounter(?song) AS ?playCount
WHERE {
?playlist a nmm:Playlist ;
a nfo:MediaList ;
nfo:hasMediaFileListEntry ?entry .
?entry a nfo:MediaFileListEntry ;
nfo:entryUrl ?url .
SERVICE <dbus:%(miner_fs_busname)s> {
GRAPH tracker:Audio {
SELECT
?song
nie:title(?song) AS ?title
nmm:artistName(nmm:artist(?song)) AS ?artist
nie:title(nmm:musicAlbum(?song)) AS ?album
nfo:duration(?song) AS ?duration
?url
WHERE {
?song a nmm:MusicPiece ;
nie:isStoredAs ?url .
%(location_filter)s
}
}
}
OPTIONAL {
?song nao:hasTag ?tag .
FILTER( ?tag = nao:predefined-tag-favorite )
}
FILTER (
%(filter_clause)s
)
}
ORDER BY nfo:listPosition(?entry)
""".replace('\n', ' ').strip() % {
"media_type": int(Grl.MediaType.AUDIO),
"filter_clause": 'tracker:id(?playlist) = ' + self.props.pl_id,
"location_filter": self._tracker_wrapper.location_filter(),
"miner_fs_busname": self._tracker_wrapper.props.miner_fs_busname,
}
def _add_to_playlist_cb(source, op_id, media, remaining, user_data,
error):
if not media:
self.props.count = self._model.get_n_items()
self.emit("playlist-loaded")
self._notificationmanager.pop_loading()
return
coresong = CoreSong(self._application, media)
self._bind_to_main_song(coresong)
if coresong not in self._songs_todelete:
self._model.append(coresong)
options = Grl.OperationOptions()
options.set_resolution_flags(Grl.ResolutionFlags.FAST_ONLY
| Grl.ResolutionFlags.IDLE_RELAY)
self._source.query(query, self._METADATA_PLAYLIST_KEYS, options,
_add_to_playlist_cb, None)
def test_creation(self):
caps = Grl.Caps()
self.assertFalse(caps is None)
options = Grl.OperationOptions.new(caps)
self.assertFalse(options is None)
self.assertFalse(Grl.OperationOptions() is None)
