def get_user_stats(self, msg):
if msg.user in self.users:
tab = self.users[msg.user]
tab.speed.set_text(_("Speed: %s") % human_speed(msg.avgspeed))
tab.filesshared.set_text(_("Files: %s") % humanize(msg.files))
tab.dirsshared.set_text(_("Directories: %s") % humanize(msg.dirs))
def get_user_stats(self, msg):
if msg.avgspeed > 0:
self.speed.set_text(human_speed(msg.avgspeed))
self.filesshared.set_text(humanize(msg.files))
self.dirsshared.set_text(humanize(msg.dirs))
def get_user_stats(self, msg):
if msg.user not in self.recommendation_users:
return
self.recommendation_users_model.set(
self.recommendation_users[msg.user], 2, human_speed(msg.avgspeed),
3, humanize(msg.files), 5, msg.avgspeed, 6, msg.files)
def add_user_row(self, userdata):
username = userdata.username
status = userdata.status
country = userdata.country or "" # country can be None, ensure string is used
status_image = self.frame.get_status_image(status)
flag_image = self.frame.get_flag_image(country)
# Request user's IP address, so we can get the country
self.frame.np.queue.append(slskmessages.GetPeerAddress(username))
avgspeed = userdata.avgspeed
files = userdata.files
hspeed = human_speed(avgspeed)
hfiles = humanize(files)
iterator = self.usersmodel.insert_with_valuesv(
-1, self.column_numbers, [
GObject.Value(GObject.TYPE_OBJECT, status_image),
GObject.Value(GObject.TYPE_OBJECT, flag_image), username,
hspeed, hfiles, status,
GObject.Value(GObject.TYPE_UINT64, avgspeed),
GObject.Value(GObject.TYPE_UINT64, files), country
])
self.users[username] = iterator
def add_user_results(self, msg, user, country):
if user in self.users:
return
self.users.add(user)
counter = len(self.all_data) + 1
inqueue = msg.inqueue
ulspeed = msg.ulspeed
h_speed = human_speed(ulspeed)
if msg.freeulslots:
imdl = "Y"
inqueue = 0
else:
imdl = "N"
h_queue = humanize(inqueue)
color_id = (imdl == "Y" and "search" or "searchq")
color = config.sections["ui"][color_id] or None
update_ui, counter = self.add_result_list(msg.list, counter, user,
country, inqueue, ulspeed,
h_speed, imdl, h_queue,
color)
if config.sections["ui"]["private_search_results"] and msg.privatelist:
update_ui_private, counter = self.add_result_list(msg.privatelist,
counter,
user,
country,
inqueue,
ulspeed,
h_speed,
imdl,
h_queue,
color,
private=True)
if not update_ui and update_ui_private:
update_ui = True
if update_ui:
# If this search wasn't initiated by us (e.g. wishlist), and the results aren't spoofed, show tab
if not self.showtab:
self.searches.show_tab(self, self.id, self.text, self.mode)
self.showtab = True
# Update number of results
self.update_result_counter()
# Update tab notification
self.frame.searches.request_changed(self.Main)
self.frame.request_tab_icon(self.frame.SearchTabLabel)
def set_unrecommendations(self, title, recom):
self.unrecommendations_model.clear()
for (thing, rating) in recom.items():
self.unrecommendations_model.insert_with_valuesv(
-1, self.unrecommendations_column_numbers,
[humanize(rating), thing, rating])
self.unrecommendations_model.set_sort_column_id(
2, Gtk.SortType.ASCENDING)
def get_user_stats(self, user, avgspeed, files):
if user not in self.users:
return
self.usersmodel.set_value(self.users[user], 3, human_speed(avgspeed))
self.usersmodel.set_value(self.users[user], 4, humanize(files))
self.usersmodel.set_value(self.users[user], 6,
GObject.Value(GObject.TYPE_UINT64, avgspeed))
self.usersmodel.set_value(self.users[user], 7,
GObject.Value(GObject.TYPE_UINT64, files))
def user_info_reply(self, msg):
if msg is None:
return
if msg.descr:
self.descr_textview.clear()
self.descr_textview.append_line(msg.descr,
showstamp=False,
scroll=False)
self.uploads.set_text(humanize(msg.totalupl))
self.queuesize.set_text(humanize(msg.queuesize))
self.slotsavail.set_text(_("Yes") if msg.slotsavail else _("No"))
self.picture_data = None
self.load_picture(msg.pic)
self.info_bar.set_visible(False)
self.set_finished()
def add_user_results(self, msg, user, country):
if user in self.users:
return
self.users.add(user)
if msg.freeulslots:
inqueue = 0
h_queue = ""
else:
inqueue = msg.inqueue or 1 # Ensure value is always >= 1
h_queue = humanize(inqueue)
h_speed = ""
ulspeed = msg.ulspeed or 0
if ulspeed > 0:
h_speed = human_speed(ulspeed)
color_id = "search" if msg.freeulslots else "searchq"
color = config.sections["ui"][color_id] or None
update_ui = self.add_result_list(msg.list, user, country, inqueue,
ulspeed, h_speed, h_queue, color)
if msg.privatelist:
update_ui_private = self.add_result_list(msg.privatelist,
user,
country,
inqueue,
ulspeed,
h_speed,
h_queue,
color,
private=True)
if not update_ui and update_ui_private:
update_ui = True
if update_ui:
# If this search wasn't initiated by us (e.g. wishlist), and the results aren't spoofed, show tab
if not self.showtab:
self.searches.show_tab(self, self.text)
self.showtab = True
self.searches.request_tab_hilite(self.Main)
# Update number of results, even if they are all filtered
self.update_result_counter()
def set_recommendations(self, recommendations, item=None):
if item:
self.RecommendationsLabel.set_label(
_("Recommendations (%s)") % item)
else:
self.RecommendationsLabel.set_label(_("Recommendations"))
self.recommendations_model.clear()
for thing, rating in recommendations:
self.recommendations_model.insert_with_valuesv(
-1, self.recommendations_column_numbers,
[humanize(rating), thing, rating])
def update_current_file(self):
""" Updates the UI with properties for the selected file """
properties = self.properties[self.current_index]
self.navigation_buttons.set_visible(len(self.properties) > 1)
self.filename_value.set_text(str(properties["filename"]))
self.folder_value.set_text(str(properties["directory"]))
self.filesize_value.set_text("%s (%s B)" % (human_size(properties["size"]), humanize(properties["size"])))
self.username_value.set_text(str(properties["user"]))
path = properties.get("path") or ""
bitrate = properties.get("bitrate") or ""
length = properties.get("length") or ""
queue_position = properties.get("queue_position") or 0
speed = properties.get("speed") or 0
country = properties.get("country") or ""
self.path_value.set_text(str(path))
self.path.set_visible(bool(path))
self.bitrate_value.set_text(str(bitrate))
self.bitrate.set_visible(bool(bitrate))
self.length_value.set_text(str(length))
self.length.set_visible(bool(length))
self.queue_value.set_text(str(humanize(queue_position)))
self.queue.set_visible(bool(queue_position))
self.speed_value.set_text(str(human_speed(speed)))
self.speed.set_visible(bool(speed))
self.country_value.set_text(str(country))
self.country.set_visible(bool(country))
self.update_title()
def get_user_stats(self, msg):
user = msg.user
iterator = self.user_iterators.get(user)
if iterator is None:
return
hspeed = human_speed(msg.avgspeed)
hfiles = humanize(msg.files)
self.usersmodel.set_value(iterator, 3, hspeed)
self.usersmodel.set_value(iterator, 4, hfiles)
self.usersmodel.set_value(iterator, 11, GObject.Value(GObject.TYPE_UINT64, msg.avgspeed))
self.usersmodel.set_value(iterator, 12, GObject.Value(GObject.TYPE_UINT64, msg.files))
def get_user_stats(self, user, avgspeed, files):
iterator = self.users.get(user)
if iterator is None:
return
h_speed = ""
if avgspeed > 0:
h_speed = human_speed(avgspeed)
self.usersmodel.set_value(iterator, 3, h_speed)
self.usersmodel.set_value(iterator, 4, humanize(files))
self.usersmodel.set_value(iterator, 6,
GObject.Value(GObject.TYPE_UINT, avgspeed))
self.usersmodel.set_value(iterator, 7,
GObject.Value(GObject.TYPE_UINT, files))
def add_user_row(self, userdata):
username = userdata.username
status = userdata.status
country = userdata.country or "" # country can be None, ensure string is used
status_icon = get_status_icon(status) or get_status_icon(0)
flag_icon = get_flag_icon_name(country)
# Request user's IP address, so we can get the country and ignore messages by IP
self.frame.np.queue.append(slskmessages.GetPeerAddress(username))
h_speed = ""
avgspeed = userdata.avgspeed
if avgspeed > 0:
h_speed = human_speed(avgspeed)
files = userdata.files
h_files = humanize(files)
weight = Pango.Weight.NORMAL
underline = Pango.Underline.NONE
if self.room in self.frame.np.chatrooms.private_rooms:
if username == self.frame.np.chatrooms.private_rooms[
self.room]["owner"]:
weight = Pango.Weight.BOLD
underline = Pango.Underline.SINGLE
elif username in self.frame.np.chatrooms.private_rooms[
self.room]["operators"]:
weight = Pango.Weight.BOLD
underline = Pango.Underline.NONE
iterator = self.usersmodel.insert_with_valuesv(
-1, self.column_numbers, [
status_icon, flag_icon, username, h_speed, h_files, status,
GObject.Value(GObject.TYPE_UINT, avgspeed),
GObject.Value(GObject.TYPE_UINT, files), country, weight,
underline
])
self.users[username] = iterator
def get_user_stats(self, msg):
iterator = self.recommendation_users.get(msg.user)
if iterator is None:
return
h_speed = ""
avgspeed = msg.avgspeed
if avgspeed > 0:
h_speed = human_speed(avgspeed)
files = msg.files
h_files = humanize(msg.files)
self.recommendation_users_model.set_value(iterator, 2, h_speed)
self.recommendation_users_model.set_value(iterator, 3, h_files)
self.recommendation_users_model.set_value(
iterator, 5, GObject.Value(GObject.TYPE_UINT, avgspeed))
self.recommendation_users_model.set_value(
iterator, 6, GObject.Value(GObject.TYPE_UINT, files))
def get_user_stats(self, msg):
user = msg.user
iterator = self.user_iterators.get(user)
if iterator is None:
return
h_speed = ""
avgspeed = msg.avgspeed
if avgspeed > 0:
h_speed = human_speed(avgspeed)
files = msg.files
h_files = humanize(files)
self.usersmodel.set_value(iterator, 3, h_speed)
self.usersmodel.set_value(iterator, 4, h_files)
self.usersmodel.set_value(iterator, 11,
GObject.Value(GObject.TYPE_UINT64, avgspeed))
self.usersmodel.set_value(iterator, 12,
GObject.Value(GObject.TYPE_UINT64, files))
def parse_response(self, video_id):
if not self.settings['api_key']:
self.log('No API key specified')
return None
try:
response = http_request(
'https',
'www.googleapis.com',
'/youtube/v3/videos?part=snippet,statistics,contentDetails&id={}&key={}'
.format(video_id, self.settings['api_key']),
headers={'User-Agent': self.config.application_name})
except Exception as error:
self.log('Failed to connect to www.googleapis.com: %s', error)
return None
try:
data = json.loads(response)
except Exception as error:
self.log('Failed to parse response from www.googleapis.com: %s',
str(error))
return None
if 'error' in data:
error_message = data['error'].get('message', False)
if not error_message:
# This should not occur
error_message = str(data['error'])
self.log(error_message)
return None
total_results = data.get('pageInfo', {}).get('totalResults', False)
if not total_results:
if isinstance(total_results, int):
# Video removed / invalid id
self.log('Video unavailable')
elif isinstance(total_results, bool):
# This should not occur
self.log('Youtube API appears to be broken')
return None
try:
data = data['items'][0]
title = data['snippet']['title']
description = data['snippet']['description']
channel = data['snippet']['channelTitle']
live = data['snippet']['liveBroadcastContent']
duration = data['contentDetails']['duration']
quality = data['contentDetails']['definition'].upper()
views = data['statistics'].get('viewCount', 'RESTRICTED')
likes = data['statistics'].get('likeCount', 'LIKES')
except KeyError:
# This should not occur
self.log('An error occurred while parsing id "%s"', video_id)
return None
if likes != 'LIKES':
likes = humanize(int(likes))
if views != 'RESTRICTED':
views = humanize(int(views))
if live in ('live', 'upcoming'):
duration = live.upper()
else:
duration = self.get_duration(duration)
return {
'%title%': title,
'%description%': description,
'%duration%': duration,
'%quality%': quality,
'%channel%': channel,
'%views%': views,
'%likes%': likes
}
def get_user_stats(self, msg):
self.speed.set_text(_("Speed: %s") % human_speed(msg.avgspeed))
self.filesshared.set_text(_("Files: %s") % humanize(msg.files))
self.dirsshared.set_text(_("Directories: %s") % humanize(msg.dirs))
def add_user_results(self, msg, user, country):
if user in self.users:
return
self.users.add(user)
counter = len(self.all_data) + 1
inqueue = msg.inqueue
ulspeed = msg.ulspeed
h_speed = human_speed(ulspeed)
if msg.freeulslots:
imdl = "Y"
inqueue = 0
else:
imdl = "N"
color_id = (imdl == "Y" and "search" or "searchq")
color = config.sections["ui"][color_id] or None
h_queue = humanize(inqueue)
update_ui = False
maxstoredresults = config.sections["searches"]["max_stored_results"]
for result in msg.list:
if counter > maxstoredresults:
break
fullpath = result[1]
fullpath_lower = fullpath.lower()
if any(word in fullpath_lower
for word in self.searchterm_words_ignore):
""" Filter out results with filtered words (e.g. nicotine -music) """
log.add_search(
_("Filtered out excluded search result " + fullpath +
" from user " + user))
continue
if not any(word in fullpath_lower
for word in self.searchterm_words_include):
""" Some users may send us wrong results, filter out such ones """
log.add_search(
_("Filtered out inexact or incorrect search result " +
fullpath + " from user " + user))
continue
fullpath_split = reversed(fullpath.split('\\'))
name = next(fullpath_split)
directory = '\\'.join(fullpath_split)
size = result[2]
h_size = human_size(size)
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, result[4])
is_result_visible = self.append([
GObject.Value(GObject.TYPE_UINT64, counter), user,
GObject.Value(GObject.TYPE_OBJECT,
self.frame.get_flag_image(country)), imdl,
h_speed, h_queue, directory, name, h_size, h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT64, bitrate), fullpath, country,
GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT64, ulspeed),
GObject.Value(GObject.TYPE_UINT64, inqueue),
GObject.Value(GObject.TYPE_UINT64, length),
GObject.Value(GObject.TYPE_STRING, color)
])
if is_result_visible:
update_ui = True
counter += 1
if update_ui:
# If this search wasn't initiated by us (e.g. wishlist), and the results aren't spoofed, show tab
if not self.showtab:
self.searches.show_tab(self, self.id, self.text, self.mode)
self.showtab = True
# Update number of results
self.update_result_counter()
# Update tab notification
self.frame.searches.request_changed(self.Main)
self.frame.request_tab_icon(self.frame.SearchTabLabel)
