def search_top_albums(self, aritst_name):
if not self.connect():
return None
artist = self.network.get_artist(aritst_name)
if not artist:
return None
try:
albums = artist.get_top_albums()
except WSError:
logging.info("No artist with that name")
return None
beans = []
for album in albums:
try:
album_txt = album.item
except AttributeError:
album_txt = album['item']
name = album_txt.get_name()
#year = album_txt.get_release_year()
year = None
if year:
bean = FModel(name + "(" + year + ")").add_album(
name).add_artist(aritst_name).add_year(year)
else:
bean = FModel(name).add_album(name).add_artist(
aritst_name).add_year(year)
beans.append(bean)
return beans
def simple_scanner(path, level):
try:
path = path.encode("utf-8")
except:
pass
results = []
if not os.path.exists(path):
return
dir = os.path.abspath(path)
list = sort_by_name(path, os.listdir(dir))
for file in list:
full_path = os.path.join(path, file)
if os.path.isfile(full_path):
if file_extension(file) not in FC().all_support_formats:
continue;
if os.path.isdir(full_path):
if is_dir_with_music(full_path):
b_bean = FModel(file, full_path).add_parent(level).add_is_file(False)
results.append(b_bean)
results.extend(simple_scanner(full_path, b_bean.get_level()))
elif os.path.isfile(full_path):
results.append(FModel(file, full_path).add_parent(level).add_is_file(True))
return results
def _scanner(path, level):
results = []
if not os.path.exists(path):
return
dir = os.path.abspath(path)
list = sort_by_name(path, os.listdir(dir))
for file in list:
full_path = os.path.join(path, file)
if os.path.isfile(full_path):
#pr_window.analyzed_files += 1
if file_extension(file) not in FC().all_support_formats:
continue
if os.path.isdir(full_path):
#pr_window.analyzed_folders += 1
if is_dir_with_music(full_path):
#pr_window.media_folders += 1
b_bean = FModel(file, full_path).add_parent(level).add_is_file(False)
results.append(b_bean)
results.extend(_scanner(full_path, b_bean.get_level()))
elif os.path.isfile(full_path):
results.append(FModel(file, full_path).add_parent(level).add_is_file(True))
#pr_window.media_files +=1
return results
def simple_scanner(path, level):
try:
path = path.encode("utf-8")
except:
pass
results = []
if not os.path.exists(path):
return
dir = os.path.abspath(path)
list = sort_by_name(path, os.listdir(dir))
for file in list:
full_path = os.path.join(path, file)
if os.path.isfile(full_path):
if file_extension(file) not in FC().all_support_formats:
continue;
if os.path.isdir(full_path):
if is_dir_with_music(full_path):
b_bean = FModel(file, full_path).add_parent(level).add_is_file(False)
results.append(b_bean)
results.extend(simple_scanner(full_path, b_bean.get_level()))
elif os.path.isfile(full_path):
results.append(FModel(file, full_path).add_parent(level).add_is_file(True))
return results
def task(user):
logging.debug(user)
name = user['first_name'] + " " + user['last_name']
parent = FModel(name)
parent.user_id = user['uid']
bean = FDModel(_("loading...")).parent(parent).add_is_file(True)
self.append(parent)
self.append(bean)
def task(user):
logging.debug(user)
name = user['first_name'] + " " + user['last_name']
parent = FModel(name)
parent.user_id = user['uid']
bean = FDModel(
_("loading...")).parent(parent).add_is_file(True)
self.append(parent)
self.append(bean)
def auto_add_user_station(self):
if os.path.isfile(CACHE_RADIO_FILE) and os.path.getsize(CACHE_RADIO_FILE) > 0:
with open(CACHE_RADIO_FILE, 'r') as f:
list = f.readlines()
parent_level_for_depth = {}
previous = {"bean": None, "depth": 0, "name": '', "url": ''}
for line in list:
depth = self.simbol_counter(line, '-')
try:
name = line[depth : line.index('#')]
except ValueError, e:
logging.warning('\'#\' ' + str(e) + ' in line \"' + line + '\"')
continue
url = line[line.index('#') + 1 : -1]
bean = FModel(name)
if url:
bean.add_is_file(True).add_path(url).add_type(FTYPE_RADIO)
if previous["depth"] < depth:
bean.add_parent(previous["bean"].level)
elif previous["depth"] > depth:
bean.add_parent(parent_level_for_depth[depth])
else:
if previous["bean"]:
bean.add_parent(previous["bean"].parent_level)
self.append(bean)
parent_level_for_depth[depth] = bean.parent_level
previous = {"bean": bean, "depth": depth, "name": name, "url": url}
def create_playlist(self):
name = one_line_dialog(_("Create new playlist"), self.controls.main_window, message_text1=_("Enter playlist name"))
if not name:
return
bean = self.get_selected_bean()
folder_bean = FModel(name)
if bean:
if bean.is_file:
folder_bean.add_parent(bean.parent_level)
else:
folder_bean.add_parent(bean.level)
self.append(folder_bean)
def create_folder(self, a):
model, tree_path, row = a # @UnusedVariable
file_path = row[self.path[0]]
new_folder_path = create_folder_dialog(file_path)
bean = FModel(os.path.basename(new_folder_path), new_folder_path).add_is_file(False)
if os.path.isfile(file_path):
bean.add_parent(row[self.parent_level[0]])
elif os.path.isdir(file_path):
bean.add_parent(row[self.level[0]])
else:
logging.error("So path doesn't exist")
self.tree_append(bean)
self.save_tree()
def update_radio_tree(self):
logging.info("in update radio")
self.clear_tree()
self.radio_folder = RadioFolder()
files = self.radio_folder.get_radio_FPLs()
for fpl in files:
parent = FModel(fpl.name).add_is_file(False)
self.append(parent)
keys = fpl.urls_dict.keys()
for radio in sorted(keys):
child = FModel(radio, fpl.urls_dict[radio][0]).parent(
parent).add_type(FTYPE_RADIO).add_is_file(True)
self.append(child)
def events_to_models(self, events):
results = []
for event in events:
try:
name = event.get_title()
event_model = FModel(name).add_is_file(False).add_font("bold")
results.append(event_model)
artists = event.get_artists()
for artist in artists:
bean = FModel(
artist.get_name()).parent(event_model).add_artist(
artist.get_name()).add_is_file(True)
results.append(bean)
except Exception as e:
pass
return results
def artists_to_models(self, artists):
results = []
for track in artists:
artist = track.get_name()
bean = FModel(artist).add_artist(artist)
results.append(bean)
return results
def search_top_tracks(self, artist_name):
if not self.connect():
return None
artist = self.network.get_artist(artist_name)
if not artist:
return []
try:
tracks = artist.get_top_tracks()
except WSError:
logging.info("No artist with that name")
return []
beans = []
for track in tracks:
try:
track_item = track.item
except AttributeError:
track_item = track['item']
#LOG.info(track_item.get_duration())
#bean = CommonBean(name=str(track_item), path="", type=CommonBean.TYPE_MUSIC_URL, parent=query);
artist = track_item.get_artist().get_name()
title = track_item.get_title()
text = artist + " - " + title
bean = FModel(text).add_artist(artist).add_title(title)
beans.append(bean)
return beans
def search_top_similar_tags(self, artist, title):
if not self.connect():
return None
if not artist or not title:
logging.warn("search_top_similar_tags artist or title is empty")
return []
track = self.cache.get_track(artist, title)
if not track:
logging.warn("search_top_similar_tags track not found")
return []
tags = track.get_top_tags()
beans = []
for tag in tags:
try:
tag_item = tag.item
except AttributeError:
tag_item = tag['item']
tag_name = tag_item.get_name()
model = FModel(tag_name).add_genre(tag_name).add_is_file(True)
beans.append(model)
return beans
def get_friends(self, username):
lfm_tracks = self.get_user(username).get_friends()
list = self.get_sub_childs(lfm_tracks, 'name')
result = []
for item in list:
result.append(FModel(item))
return result
def search_top_similar_artist(self, artist_name, count=45):
if not self.connect():
return None
if not artist_name:
logging.warn("search_top_similar_artist, Artist name is empty")
return []
artist = self.network.get_artist(artist_name)
if not artist:
return []
artists = artist.get_similar(count)
beans = []
for artist in artists:
try:
artist_txt = artist.item
except AttributeError:
artist_txt = artist['item']
artist_name = artist_txt.get_name()
bean = FModel(artist_name).add_artist(artist_name).add_is_file(
True)
beans.append(bean)
return beans
def search_top_similar_tracks(self, artist, title):
if not self.connect():
return None
if not artist or not title:
logging.warn("search_top_similar_tags artist or title is empty")
return []
track = self.cache.get_track(artist, title)
if not track:
logging.warn("search_top_similar_tracks track not found")
return []
similars = track.get_similar()
beans = []
for tsong in similars:
try:
tsong_item = tsong.item
except AttributeError:
tsong_item = tsong['item']
artist = tsong_item.get_artist().get_name()
title = tsong_item.get_title()
model = FModel(artist + " - " + title).add_artist(
artist).add_title(title).add_is_file(True)
beans.append(model)
return beans
def search_top_tag_tracks(self, tag_name):
logging.warn("search_top_tag tracks" + tag_name)
if not self.connect():
return None
if not tag_name:
logging.warn("search_top_tags TAG is empty")
return []
tag = Tag(tag_name, self.network)
tracks = tag.get_top_tracks()
beans = []
for track in tracks:
try:
track_item = track.item
except AttributeError:
track_item = track['item']
#LOG.info(track_item.get_duration())
#bean = CommonBean(name=str(track_item), path="", type=CommonBean.TYPE_MUSIC_URL, parent=query);
artist = track_item.get_artist().get_name()
title = track_item.get_title()
text = artist + " - " + title
bean = FModel(text).add_artist(artist).add_title(title)
beans.append(bean)
return beans
def get_bean_from_row(self, row):
bean = FModel()
id_dict = FTreeModel().cut().__dict__
for key in id_dict.keys():
num = id_dict[key]
setattr(bean, key, row[num])
return bean
class TrayIconControls(Gtk.StatusIcon, ImageBase, FControl, LoadSave):
def __init__(self, controls):
FControl.__init__(self, controls)
Gtk.StatusIcon.__init__(self)
self.hide()
ImageBase.__init__(self, ICON_FOOBNIX, 150)
self.popup_menu = PopupMenuWindow(self.controls)
self.popup_volume_contol = PopupVolumeWindow(self.controls,
self.popup_menu)
self.connect("activate", self.on_activate)
self.connect("popup-menu", self.on_popup_menu)
try:
self.set_has_tooltip(True)
self.tooltip = Gtk.Tooltip()
self.set_tooltip("Foobnix music player")
self.connect("query-tooltip", self.on_query_tooltip)
self.connect("button-press-event", self.on_button_press)
self.connect("scroll-event", self.on_scroll)
except Exception, e:
logging.warn("On debian it doesn't work" + str(e))
self.current_bean = FModel().add_artist("Artist").add_title("Title")
self.tooltip_image = ImageBase(ICON_FOOBNIX, 75)
self._previous_notify = None
def on_add_station(self):
name, url = two_line_dialog(_("Add New Radio Station"),
parent = self.controls.main_window,
message_text1 = _("Enter station name and URL"),
message_text2 = None,
entry_text1 = None,
entry_text2 = "http://")
if not name or not url:
return
bean = self.get_selected_bean()
new_bean = FModel(name, url).add_type(FTYPE_RADIO).add_is_file(True)
if bean:
if bean.is_file:
new_bean.add_parent(bean.parent_level)
else:
new_bean.add_parent(bean.level)
self.append(new_bean)
def get_neighbours(self, username):
lfm_tracks = self.get_user(username).get_neighbours()
list = self.get_sub_childs(lfm_tracks, 'name')
result = []
for item in list:
parent = FModel(item)
result.append(parent)
return result
def find_tracks_by_url(self, url):
logging.debug("Search By URL")
index = url.rfind("#")
if index > 0:
url = url[:index]
index = url.find("id=")
if index < 0:
return None
id = url[index + 3:]
id = int(id)
if id > 0:
results = self.get_result('audio.get', "uid=" + str(id))
else:
results = self.get_result('audio.get', "gid=" + str(abs(id)))
childs = []
for line in results:
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url']
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
childs.append(bean)
return childs
def tracks_to_models(self, tracks):
results = []
for track in tracks:
artist = track.get_artist().get_name()
title = track.get_title()
bean = FModel(artist + " - " +
title).add_artist(artist).add_title(title)
results.append(bean)
return results
def get_common_beans(self):
paths_and_texts = self.parse()
if not paths_and_texts:
return []
beans = [FModel(path=path_and_text[0],
text=path_and_text[1])
.add_is_file(True)
for path_and_text in paths_and_texts]
return beans
def show_similar_tracks(self):
if self.info_cache.similar_tracks_bean == self.bean:
return None
self.info_cache.similar_tracks_bean = self.bean
"""similar songs"""
similar_tracks = self.controls.lastfm_service.search_top_similar_tracks(self.bean.artist, self.bean.title)
parent = FModel(_("Similar Tracks:") + " " + self.bean.title)
update_parent_for_beans(similar_tracks, parent)
self.tracks.populate_all([parent] + similar_tracks)
def get_user_tracks_as_beans(self, user_id):
beans = []
result = self.controls.vk_service.get_result('audio.get',
"uid=" + user_id)
if not result:
beans = [FDModel(_("No results found")).add_is_file(True)]
else:
for line in result:
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url']
bean.aid = line['aid']
bean.oid = line['owner_id']
bean.is_file = True
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
beans.append(bean)
return beans
def show_best_songs(self):
if self.info_cache.best_songs_bean == self.bean:
return None
self.info_cache.best_songs_bean = self.bean
best_songs = self.controls.lastfm_service.search_top_tracks(self.bean.artist)
parent = FModel(_("Best Songs:") + " " + self.bean.artist)
update_parent_for_beans(best_songs, parent)
self.best_songs.populate_all([parent] + best_songs)
def show_similar_artists(self):
if self.info_cache.similar_artists_bean == self.bean:
return None
self.info_cache.similar_artists_bean = self.bean
"""similar artists"""
if self.bean.artist:
similar_artists = self.controls.lastfm_service.search_top_similar_artist(self.bean.artist)
parent = FModel(_("Similar Artists:") + " " + self.bean.artist)
update_parent_for_beans(similar_artists, parent)
self.artists.populate_all([parent] + similar_artists)
def search_vk_page_tracks(self, vk_ulr):
logging.debug("Search vk_service page tracks")
results = self.vk_service.find_tracks_by_url(vk_ulr)
all = []
p_bean = FModel(vk_ulr).add_font("bold")
all.append(p_bean)
for i, bean in enumerate(results):
bean.tracknumber = i + 1
bean.parent(p_bean).add_is_file(True)
all.append(bean)
self.notetabs.append_tab(vk_ulr, all)
def _get_bean_by_path(self, path):
model = self.model
path = self.filter_model.convert_path_to_child_path(path)
iter = model.get_iter(path)
if iter:
bean = FModel()
dt = FTreeModel().__dict__
for key in dt.keys():
setattr(bean, key, model.get_value(iter, dt[key][0]))
return bean
return None
def find_tracks_by_url(self, url):
logging.debug("Search By URL")
index = url.rfind("#")
if index > 0:
url = url[:index]
index = url.find("id=")
if index < 0:
return None
id = url[index + 3:]
id = int(id)
if id > 0:
results = self.get_result('audio.get', "uid=" + str(id))
else:
results = self.get_result('audio.get', "gid=" + str(abs(id)))
childs = []
for line in results:
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url'].replace("https://", "http://")
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
childs.append(bean)
return childs
def get_user_tracks_as_beans(self, user_id):
beans = []
result = self.controls.vk_service.get_result('audio.get', "uid=" + user_id)
if not result:
beans = [FDModel(_("No results found")).add_is_file(True)]
else:
for line in result:
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url']
bean.aid = line['aid']
bean.oid = line['owner_id']
bean.is_file = True
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
beans.append(bean)
return beans
def get_bean_from_model_iter(self, model, iter):
if not model or not iter:
return None
bean = FModel()
id_dict = FTreeModel().cut().__dict__
for key in id_dict.keys():
num = id_dict[key]
try:
val = model.get_value(iter, num)
except GError:
val = None
setattr(bean, key, val)
return bean
def find_track_by_id(self, id):
result = self.get_result("audio.get", "audios=" + str(id))
if not result:
return None
line = result[0]
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url']
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
return bean
def auto_add_user_station(self):
if os.path.isfile(
CACHE_RADIO_FILE) and os.path.getsize(CACHE_RADIO_FILE) > 0:
with open(CACHE_RADIO_FILE, 'r') as f:
list = f.readlines()
parent_level_for_depth = {}
previous = {"bean": None, "depth": 0, "name": '', "url": ''}
for line in list:
depth = self.simbol_counter(line, '-')
try:
name = line[depth:line.index('#')]
except ValueError, e:
logging.warning('\'#\' ' + str(e) + ' in line \"' +
line + '\"')
continue
url = line[line.index('#') + 1:-1]
bean = FModel(name)
if url:
bean.add_is_file(True).add_path(url).add_type(
FTYPE_RADIO)
if previous["depth"] < depth:
bean.add_parent(previous["bean"].level)
elif previous["depth"] > depth:
bean.add_parent(parent_level_for_depth[depth])
else:
if previous["bean"]:
bean.add_parent(previous["bean"].parent_level)
self.append(bean)
parent_level_for_depth[depth] = bean.parent_level
previous = {
"bean": bean,
"depth": depth,
"name": name,
"url": url
}
def search_top_tags(self, tag):
logging.debug("Search tag " + tag)
if not self.connect():
return None
if not tag:
logging.warn("search_top_tags TAG is empty")
return []
beans = []
tags = self.network.search_for_tag(tag)
for tag in tags.get_next_page():
tag_name = tag.get_name()
bean = FModel(tag_name).add_genre(tag_name)
beans.append(bean)
return beans
def search_top_tracks_task(query):
analytics.action("SEARCH_search_top_tracks")
results = self.lastfm_service.search_top_tracks(query)
if not results:
results = []
all = []
parent_bean = FModel(query)
all.append(parent_bean)
for i, bean in enumerate(results):
bean.tracknumber = i + 1
bean.parent(parent_bean).add_is_file(True)
all.append(bean)
if not results:
all = self.show_google_results(query)
self.notetabs.append_tab(query, all)
def find_track_by_id(self, id):
result = self.get_result("audio.get", "audios=" + str(id))
if not result:
return None
line = result[0]
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url']
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
return bean
def find_track_by_id(self, id):
if id is not None:
parts = id.split("_")
result = self.get_result("audio.get", "owner_id=%s&audio_ids=%s" % (str(parts[0]), str(parts[1])))
line = result[1]
else:
result = self.get_result("audio.get", "audios=" + str(id))
line = result[0]
if not result:
return None
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url'].replace("https://", "http://")
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
return bean
def find_tracks_by_query(self, query):
logging.info("start search songs " + query)
query = urllib.quote(query.encode("utf-8"))
list = self.get_result("audio.search", "q=" + query)
childs = []
if not list:
return childs
for line in list[1:]:
bean = FModel(line['artist'] + ' - ' + line['title'])
bean.aritst = line['artist']
bean.title = line['title']
bean.time = convert_seconds_to_text(line['duration'])
bean.path = line['url'].replace("https://", "http://")
bean.vk_audio_id = "%s_%s" % (line['owner_id'], line['aid'])
childs.append(bean)
return childs
def get_common_beans(self):
beans = []
cue = self.parse()
if not self.is_cue_valid():
return []
for i, track in enumerate(cue.tracks):
bean = FModel(text=track.performer + " - " + track.title, path=track.path)
bean.artist = track.performer
bean.tracknumber = i + 1
bean.title = track.title
bean.album = self.cue_file.title
bean.name = bean.text
bean.start_sec = track.get_start_time_sec()
bean.duration_sec = track.duration
bean.time = convert_seconds_to_text(track.duration)
bean.is_file = True
try:
bean.info = foobnix.util.id3_util.normalized_info(get_mutagen_audio(track.path).info, bean)
except Exception, e:
logging.warn(str(e) + " " + bean.path)
bean.info = ""
if not bean.title or not bean.artist:
bean = udpate_id3(bean)
beans.append(bean)
