def set_wishlist_interval(self, msg):
self.wishlist_interval = msg.seconds
if self.ui_callback:
self.ui_callback.set_wishlist_interval(msg)
log.add_search(_("Wishlist wait period set to %s seconds"),
msg.seconds)
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)
append = False
maxstoredresults = self.searches.maxstoredresults
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 = get_result_bitrate_length(size, result[4])
self.append([counter, user, self.get_flag(user, country), imdl, h_speed, h_queue, directory, name, h_size, h_bitrate, h_length, bitrate, fullpath, country, size, ulspeed, inqueue])
append = True
counter += 1
if append:
# 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 counter
self.Counter.set_text("Results: %d/%d" % (self.numvisibleresults, len(self.all_data)))
# Update tab notification
self.frame.searches.request_changed(self.Main)
if self.frame.MainNotebook.get_current_page() != self.frame.MainNotebook.page_num(self.frame.searchvbox):
self.frame.SearchTabLabel.get_child().set_image(self.frame.images["online"])
def add_result_list(self,
result_list,
user,
country,
inqueue,
ulspeed,
h_speed,
h_queue,
color,
private=False):
""" Adds a list of search results to the treeview. Lists can either contain publicly or
privately shared files. """
update_ui = False
for result in result_list:
if self.num_results_found >= self.max_limit:
self.max_limited = True
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_debug((
"Filtered out excluded search result %(filepath)s from user %(user)s for "
"search term \"%(query)s\""), {
"filepath": fullpath,
"user": user,
"query": self.text
})
continue
if not any(word in fullpath_lower
for word in self.searchterm_words_include):
# Certain users may send us wrong results, filter out such ones
log.add_search(
_("Filtered out incorrect search result %(filepath)s from user %(user)s for "
"search query \"%(query)s\""), {
"filepath": fullpath,
"user": user,
"query": self.text
})
continue
self.num_results_found += 1
fullpath_split = fullpath.split('\\')
if config.sections["ui"]["reverse_file_paths"]:
# Reverse file path, file name is the first item. next() retrieves the name and removes
# it from the iterator.
fullpath_split = reversed(fullpath_split)
name = next(fullpath_split)
else:
# Regular file path, file name is the last item. Retrieve it and remove it from the list.
name = fullpath_split.pop()
# Join the resulting items into a folder path
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])
if private:
name = _("[PRIVATE] %s") % name
is_result_visible = self.append([
self.num_results_found, user,
get_flag_icon_name(country), h_speed, h_queue, directory, name,
h_size, h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT, bitrate), fullpath, country,
GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT, ulspeed),
GObject.Value(GObject.TYPE_UINT64, inqueue),
GObject.Value(GObject.TYPE_UINT, length),
GObject.Value(GObject.TYPE_STRING, color)
])
if is_result_visible:
update_ui = True
return update_ui
def process_search_request(self, searchterm, user, token, direct=False):
""" Note: since this section is accessed every time a search request arrives several
times per second, please keep it as optimized and memory sparse as possible! """
if not searchterm:
return
if not self.config.sections["searches"]["search_results"]:
# Don't return _any_ results when this option is disabled
return
if not direct and user == self.core.login_username:
# We shouldn't send a search response if we initiated the search request,
# unless we're specifically searching our own username
return
maxresults = self.config.sections["searches"]["maxresults"]
if maxresults == 0:
return
# Remember excluded/partial words for later
excluded_words = []
partial_words = []
if '-' in searchterm or '*' in searchterm:
for word in searchterm.split():
if len(word) < 1:
continue
if word.startswith('-'):
for subword in word.translate(
self.translatepunctuation).split():
excluded_words.append(subword)
elif word.startswith('*'):
for subword in word.translate(
self.translatepunctuation).split():
partial_words.append(subword)
# Strip punctuation
searchterm_old = searchterm
searchterm = searchterm.lower().translate(
self.translatepunctuation).strip()
if len(searchterm
) < self.config.sections["searches"]["min_search_chars"]:
# Don't send search response if search term contains too few characters
return
checkuser, _reason = self.core.network_filter.check_user(user, None)
if not checkuser:
return
if checkuser == 2:
wordindex = self.share_dbs.get("buddywordindex")
else:
wordindex = self.share_dbs.get("wordindex")
if wordindex is None:
return
# Find common file matches for each word in search term
resultlist = self.create_search_result_list(searchterm, wordindex,
excluded_words,
partial_words)
if not resultlist:
return
if checkuser == 2:
fileindex = self.share_dbs.get("buddyfileindex")
else:
fileindex = self.share_dbs.get("fileindex")
if fileindex is None:
return
fileinfos = []
numresults = min(len(resultlist), maxresults)
for index in islice(resultlist, numresults):
fileinfo = fileindex.get(repr(index))
if fileinfo is not None:
fileinfos.append(fileinfo)
if numresults != len(fileinfos):
log.add_debug(
("Error: File index inconsistency while responding to search request \"%(query)s\". "
"Expected %(expected_num)i results, but found %(total_num)i results in database."
), {
"query": searchterm_old,
"expected_num": numresults,
"total_num": len(fileinfos)
})
numresults = len(fileinfos)
if not numresults:
return
uploadspeed = self.core.transfers.upload_speed
queuesize = self.core.transfers.get_upload_queue_size()
slotsavail = self.core.transfers.allow_new_uploads()
fifoqueue = self.config.sections["transfers"]["fifoqueue"]
message = slskmessages.FileSearchResult(None, self.core.login_username,
token, fileinfos, slotsavail,
uploadspeed, queuesize,
fifoqueue)
self.core.send_message_to_peer(user, message)
log.add_search(
_("User %(user)s is searching for \"%(query)s\", found %(num)i results"
), {
'user': user,
'query': searchterm_old,
'num': numresults
})
def process_search_request(self, searchterm, user, searchid, direct=False):
""" Note: since this section is accessed every time a search request arrives,
several times a second, please keep it as optimized and memory
sparse as possible! """
if not self.config.sections["searches"]["search_results"]:
# Don't return _any_ results when this option is disabled
return
if searchterm is None:
return
if not direct and user == self.config.sections["server"]["login"]:
# We shouldn't send a search response if we initiated the search request,
# unless we're specifically searching our own username
return
maxresults = self.config.sections["searches"]["maxresults"]
if maxresults == 0:
return
# Don't count excluded words as matches (words starting with -)
# Strip punctuation
searchterm = re.sub(r'(\s)-\w+', r'\1', searchterm).lower().translate(
self.translatepunctuation).strip()
if len(searchterm
) < self.config.sections["searches"]["min_search_chars"]:
# Don't send search response if search term contains too few characters
return
checkuser, reason = self.np.check_user(user, None)
if not checkuser:
return
if checkuser == 2:
wordindex = self.share_dbs["buddywordindex"]
else:
wordindex = self.share_dbs["wordindex"]
# Find common file matches for each word in search term
resultlist = self.create_search_result_list(searchterm, wordindex,
maxresults)
if not resultlist:
return
if self.np.transfers is not None:
numresults = min(len(resultlist), maxresults)
queuesizes = self.np.transfers.get_upload_queue_sizes()
slotsavail = self.np.transfers.allow_new_uploads()
if checkuser == 2:
fileindex = self.share_dbs["buddyfileindex"]
else:
fileindex = self.share_dbs["fileindex"]
fifoqueue = self.config.sections["transfers"]["fifoqueue"]
message = slskmessages.FileSearchResult(
None, self.config.sections["server"]["login"], searchid,
resultlist, fileindex, slotsavail, self.np.speed, queuesizes,
fifoqueue, numresults)
self.np.send_message_to_peer(user, message)
if direct:
log.add_search(
_("User %(user)s is directly searching for \"%(query)s\", returning %(num)i results"
), {
'user': user,
'query': searchterm,
'num': numresults
})
else:
log.add_search(
_("User %(user)s is searching for \"%(query)s\", returning %(num)i results"
), {
'user': user,
'query': searchterm,
'num': numresults
})
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)
def add_result_list(self,
result_list,
counter,
user,
country,
inqueue,
ulspeed,
h_speed,
imdl,
h_queue,
color,
private=False):
""" Adds a list of search results to the treeview. Lists can either contain publicly or
privately shared files. """
update_ui = False
max_results = config.sections["searches"]["max_displayed_results"]
for result in result_list:
if counter > max_results:
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 = fullpath.split('\\')
if config.sections["ui"]["reverse_file_paths"]:
# Reverse file path, file name is the first item. next() retrieves the name and removes
# it from the iterator.
fullpath_split = reversed(fullpath_split)
name = next(fullpath_split)
else:
# Regular file path, file name is the last item. Retrieve it and remove it from the list.
name = fullpath_split.pop()
# Join the resulting items into a folder path
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])
if private:
name = "[PRIVATE FILE] " + name
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
return update_ui, counter