def delete_rows(self, rows):
patch_data = []
delete_data = []
for entry in [row.model().data_items[row.row()] for row in rows]:
if entry["status"] == NEW:
delete_data.append({
"public_key": entry['public_key'],
"id": entry['id']
})
else:
patch_data.append({
"public_key": entry['public_key'],
"id": entry['id'],
"status": COMMIT_STATUS_TODELETE
})
if patch_data:
TriblerNetworkRequest("metadata",
self.remove_items,
raw_data=json.dumps(patch_data),
method='PATCH')
if delete_data:
TriblerNetworkRequest("metadata",
self.remove_items,
raw_data=json.dumps(delete_data),
method='DELETE')
def delete_rows(self, rows):
patch_data = []
delete_data = []
for entry in [row.model().data_items[row.row()] for row in rows]:
if entry["status"] == NEW:
delete_data.append({
"public_key": entry[u'public_key'],
"id": entry[u'id']
})
else:
patch_data.append({
"public_key": entry[u'public_key'],
"id": entry[u'id'],
"status": COMMIT_STATUS_TODELETE
})
def on_torrents_deleted(json_result):
if not json_result:
return
self.remove_items(json_result)
self.info_changed.emit(json_result)
if patch_data:
TriblerNetworkRequest("metadata",
on_torrents_deleted,
raw_data=json.dumps(patch_data),
method='PATCH')
if delete_data:
TriblerNetworkRequest("metadata",
on_torrents_deleted,
raw_data=json.dumps(delete_data),
method='DELETE')
def on_tab_changed(self, index):
if index == 1 and self.torrent_info:
if "trackers" in self.torrent_info:
for tracker in self.torrent_info["trackers"]:
item = QTreeWidgetItem(self.torrent_detail_trackers_list)
item.setText(0, tracker)
else:
self.rest_request1 = TriblerNetworkRequest(
"metadata/%s/%s" %
(self.torrent_info["public_key"], self.torrent_info["id"]),
self.on_torrent_info)
def showEvent(self, show_event):
if self.ipv8_health_widget and self.ipv8_health_widget.isVisible():
self.ipv8_health_widget.resume()
TriblerNetworkRequest("ipv8/asyncio/drift",
self.on_ipv8_health_enabled,
data={"enable": True},
method='PUT')
def load_ipv8_community_details_tab(self):
if self.ipv8_statistics_enabled:
self.window().ipv8_statistics_error_label.setHidden(True)
TriblerNetworkRequest("ipv8/overlays/statistics", self.on_ipv8_community_detail_stats)
else:
self.window().ipv8_statistics_error_label.setHidden(False)
self.window().ipv8_communities_details_widget.setHidden(True)
def on_force_recheck_download(self, checked):
for selected_item in self.selected_items:
infohash = selected_item.download_info["infohash"]
TriblerNetworkRequest(f"downloads/{infohash}",
self.on_forced_recheck,
method='PATCH',
data={"state": "recheck"})
def delete_rows(self, rows):
patch_data = []
delete_data = []
for entry in [row.model().data_items[row.row()] for row in rows]:
if entry["status"] == NEW:
delete_data.append({
"public_key": entry['public_key'],
"id": entry['id']
})
else:
patch_data.append({
"public_key": entry['public_key'],
"id": entry['id'],
"status": COMMIT_STATUS_TODELETE
})
# We don't wait for the Core to report back and emit
# the info_changed signal speculativley to prevent the race condition between
# Python object deletion and PyQT one. Otherwise, if the users e.g. clicks the back
# button, by the moment the request callback triggers some actions on the model,
# QT could have already deleted the underlying model object, which will result in
# "wrapped C/C++ object has been deleted" error (see e.g. https://github.com/Tribler/tribler/issues/6083)
for data, method in ((patch_data, "PATCH"), (delete_data, "DELETE")):
if data:
self.remove_items(data)
TriblerNetworkRequest("metadata",
lambda _: None,
raw_data=json.dumps(data),
method=method)
def fetch_graph_data(self, checked=False):
if self.rest_request:
self.rest_request.cancel_request()
self.rest_request = TriblerNetworkRequest(
"trustview?refresh=1",
self.on_received_data,
priority=QNetworkRequest.LowPriority)
def check_torrent_health(self, data_item, forced=False):
# ACHTUNG: The health check can be triggered multiple times for a single infohash
# by e.g. selection and click signals
if not dict_item_is_any_of(data_item, 'type', [REGULAR_TORRENT]):
return
infohash = data_item['infohash']
if Column.HEALTH not in self.model.column_position:
return
# Check if the entry still exists in the table
row = self.model.item_uid_map.get(infohash)
items = self.model.data_items
if row is None or row >= len(items):
return
data_item = items[row]
if not forced and data_item.get('health',
HEALTH_UNCHECKED) != HEALTH_UNCHECKED:
return
data_item['health'] = HEALTH_CHECKING
health_cell_index = self.model.index(
row, self.model.column_position[Column.HEALTH])
self.model.dataChanged.emit(health_cell_index, health_cell_index, [])
TriblerNetworkRequest(
f"metadata/torrents/{infohash}/health",
self.on_health_response,
url_params={
"nowait": True,
"refresh": True
},
capture_core_errors=False,
priority=QNetworkRequest.LowPriority,
)
def on_send_clicked(self, checked):
self.send_report_button.setEnabled(False)
self.send_report_button.setText(tr("SENDING..."))
endpoint = 'http://reporter.tribler.org/report'
sys_info = ""
sys_info_dict = defaultdict(lambda: [])
for ind in range(self.env_variables_list.topLevelItemCount()):
item = self.env_variables_list.topLevelItem(ind)
key = item.text(0)
value = item.text(1)
sys_info += f"{key}\t{value}\n"
sys_info_dict[key].append(value)
comments = self.comments_text_edit.toPlainText()
if len(comments) == 0:
comments = tr("Not provided")
stack = self.error_text_edit.toPlainText()
post_data = {
"version": self.tribler_version,
"machine": platform.machine(),
"os": platform.platform(),
"timestamp": int(time.time()),
"sysinfo": sys_info,
"comments": comments,
"stack": stack,
}
SentryReporter.send_event(self.sentry_event, post_data, sys_info_dict, self.additional_tags)
TriblerNetworkRequest(endpoint, self.on_report_sent, raw_data=tribler_urlencode(post_data), method='POST')
def on_search_text_change(self, text):
# We do not want to bother the database on petty 1-character queries
if len(text) < 2:
return
TriblerNetworkRequest(
"search/completions", self.on_received_search_completions, url_params={'q': sanitize_for_fts(text)}
)
def on_start_download_clicked(self):
for selected_item in self.selected_items:
infohash = selected_item.download_info["infohash"]
TriblerNetworkRequest("downloads/%s" % infohash,
self.on_download_resumed,
method='PATCH',
data={"state": "resume"})
def on_move_files(self):
if len(self.selected_items) != 1:
return
dest_dir = QFileDialog.getExistingDirectory(
self,
"Please select the destination directory",
self.selected_items[0].download_info["destination"],
QFileDialog.ShowDirsOnly,
)
if not dest_dir:
return
_infohash = self.selected_items[0].download_info["infohash"]
_name = self.selected_items[0].download_info["name"]
data = {"state": "move_storage", "dest_dir": dest_dir}
TriblerNetworkRequest(
"downloads/%s" % _infohash,
lambda res, _, name=_name, target=dest_dir: self.on_files_moved(
res, name, target),
data=data,
method='PATCH',
)
def perform_files_request(self):
if self.closed or self.has_metainfo:
return
direct = not self.dialog_widget.anon_download_checkbox.isChecked()
params = {'uri': self.download_uri}
if direct:
params['hops'] = 0
self.rest_request = TriblerNetworkRequest('torrentinfo',
self.on_received_metainfo,
capture_core_errors=False,
url_params=params)
if self.metainfo_retries <= METAINFO_MAX_RETRIES:
fetch_mode = tr("directly") if direct else tr("anonymously")
loading_message = tr("Loading torrent files %s...") % fetch_mode
timeout_message = tr(
"Timeout in fetching files %s. Retrying %i/%i") % (
fetch_mode,
self.metainfo_retries,
METAINFO_MAX_RETRIES,
)
self.dialog_widget.loading_files_label.setText(
loading_message
if not self.metainfo_retries else timeout_message)
self.metainfo_fetch_timer = QTimer()
connect(self.metainfo_fetch_timer.timeout,
self.perform_files_request)
self.metainfo_fetch_timer.setSingleShot(True)
self.metainfo_fetch_timer.start(METAINFO_TIMEOUT)
self.metainfo_retries += 1
def setData(self, index, new_value, role=None):
if role != Qt.EditRole:
return True
item = self.data_items[index.row()]
attribute_name = self.columns[index.column()].dict_key
attribute_name = 'tags' if attribute_name == 'category' else attribute_name
attribute_name = 'title' if attribute_name == 'name' else attribute_name
if attribute_name == 'subscribed':
return True
def on_row_update_results(response):
if not response:
return
item_row = self.item_uid_map.get(get_item_uid(item))
if item_row is None:
return
data_item_dict = index.model().data_items[item_row]
data_item_dict.update(response)
self.info_changed.emit([data_item_dict])
TriblerNetworkRequest(
f"metadata/{item['public_key']}/{item['id']}",
on_row_update_results,
method='PATCH',
raw_data=json.dumps({attribute_name: new_value}),
)
# ACHTUNG: instead of reloading the whole row from DB, this line just changes the displayed value!
self.data_items[index.row()][attribute_name] = new_value
return True
def perform_query(self, **kwargs):
"""
Fetch results for a given query.
"""
self.query_started.emit()
if 'first' not in kwargs or 'last' not in kwargs:
kwargs["first"], kwargs['last'] = self.rowCount(
) + 1, self.rowCount() + self.item_load_batch
if self.sort_by is not None:
kwargs.update({
"sort_by": self.sort_by,
"sort_desc": self.sort_desc
})
if self.text_filter:
kwargs.update({"txt_filter": self.text_filter})
if self.max_rowid is not None:
kwargs["max_rowid"] = self.max_rowid
if self.hide_xxx is not None:
kwargs.update({"hide_xxx": self.hide_xxx})
rest_endpoint_url = kwargs.pop(
"rest_endpoint_url"
) if "rest_endpoint_url" in kwargs else self.endpoint_url
TriblerNetworkRequest(rest_endpoint_url,
self.on_query_results,
url_params=kwargs)
def on_skip_conversion_dialog(self, action):
if action == 0:
TriblerNetworkRequest("upgrader", lambda _: None, data={"skip_db_upgrade": True}, method='POST')
if self.dialog:
self.dialog.close_dialog()
self.dialog = None
def preview_clicked(self, checked=False): # pylint: disable=W0613
params = dict()
if "public_key" in self.model.channel_info:
# This is a channel contents query, limit the search by channel_pk and origin_id
params.update({
'channel_pk': self.model.channel_info["public_key"],
'origin_id': self.model.channel_info["id"]
})
if self.model.text_filter:
params.update({'txt_filter': self.model.text_filter})
if self.model.hide_xxx is not None:
params.update({'hide_xxx': self.model.hide_xxx})
if self.model.sort_by is not None:
params.update({'sort_by': self.model.sort_by})
if self.model.sort_desc is not None:
params.update({'sort_desc': self.model.sort_desc})
if self.model.category_filter is not None:
params.update({'category_filter': self.model.category_filter})
def add_request_uuid(response):
request_uuid = response["request_uuid"]
if self.model:
self.model.remote_queries.add(uuid.UUID(request_uuid))
TriblerNetworkRequest('remote_query',
add_request_uuid,
method="PUT",
url_params=params)
def create_channel_callback(channel_name):
TriblerNetworkRequest(
"channels/mychannel/0/channels",
self.channels_menu_list.load_channels,
method='POST',
raw_data=json.dumps({"name": channel_name}) if channel_name else None,
)
def on_create_clicked(self, checked):
if self.window().create_torrent_files_list.count() == 0:
self.dialog = ConfirmationDialog(
self, "Notice",
"You should add at least one file to your torrent.",
[('CLOSE', BUTTON_TYPE_NORMAL)])
connect(self.dialog.button_clicked, self.on_dialog_ok_clicked)
self.dialog.show()
return
self.window().edit_channel_create_torrent_button.setEnabled(False)
files_list = []
for ind in range(self.window().create_torrent_files_list.count()):
file_str = self.window().create_torrent_files_list.item(ind).text()
files_list.append(file_str)
name = self.window().create_torrent_name_field.text()
description = self.window(
).create_torrent_description_field.toPlainText()
post_data = {
"name": name,
"description": description,
"files": files_list
}
url = "createtorrent?download=1" if self.window(
).seed_after_adding_checkbox.isChecked() else "createtorrent"
TriblerNetworkRequest(url,
self.on_torrent_created,
data=post_data,
method='POST')
# Show creating torrent text
self.window().edit_channel_create_torrent_progress_label.show()
def on_add_button_pressed(channel_id):
TriblerNetworkRequest(
f"collections/mychannel/{channel_id}/torrents",
lambda _: self.tray_show_message("Channels update", f"{self.chosen_dir} added to your channel"),
method='PUT',
data={"torrents_dir": self.chosen_dir},
)
def load_channels(self, request=None):
TriblerNetworkRequest(self.base_url,
self.on_query_results,
url_params={
"subscribed": True,
"last": 1000
})
def _add_torrent_request(self, data):
TriblerNetworkRequest(
f'collections/mychannel/{self.model.channel_info["id"]}/torrents',
self._on_torrent_to_channel_added,
method='PUT',
data=data,
)
def set_included_files(self, files):
post_data = {"selected_files": [ind for ind in files]}
TriblerNetworkRequest("downloads/%s" %
self.current_download['infohash'],
lambda _: None,
method='PATCH',
data=post_data)
def search(self, query: Query) -> bool:
if not self.check_can_show(query.original_query):
return False
fts_query = to_fts_query(query.original_query)
if not fts_query:
return False
self.last_search_query = query.original_query
self.last_search_time = time.time()
# Trigger remote search
def register_request(response):
self._logger.info(f'Request registered: {response}')
self.search_request = SearchRequest(response["request_uuid"],
query, set(response["peers"]))
self.state_label.setText(
format_search_loading_label(self.search_request))
self.timeout_progress_bar.start()
self.setCurrentWidget(self.loading_page)
params = {
'txt_filter': fts_query,
'hide_xxx': self.hide_xxx,
'tags': list(query.tags)
}
TriblerNetworkRequest('remote_query',
register_request,
method="PUT",
url_params=params)
return True
def perform_files_request(self):
if self.closed:
return
direct = not self.dialog_widget.anon_download_checkbox.isChecked()
request = f"torrentinfo?uri={quote_plus_unicode(self.download_uri)}"
if direct is True:
request = request + f"&hops=0"
self.rest_request = TriblerNetworkRequest(request,
self.on_received_metainfo,
capture_core_errors=False)
if self.metainfo_retries <= METAINFO_MAX_RETRIES:
fetch_mode = 'directly' if direct else 'anonymously'
loading_message = f"Loading torrent files {fetch_mode}..."
timeout_message = (
f"Timeout in fetching files {fetch_mode}. Retrying ({self.metainfo_retries}/{METAINFO_MAX_RETRIES})"
)
self.dialog_widget.loading_files_label.setText(
loading_message
if not self.metainfo_retries else timeout_message)
self.metainfo_fetch_timer = QTimer()
connect(self.metainfo_fetch_timer.timeout,
self.perform_files_request)
self.metainfo_fetch_timer.setSingleShot(True)
self.metainfo_fetch_timer.start(METAINFO_TIMEOUT)
self.metainfo_retries += 1
def on_stop_download_clicked(self, checked):
for selected_item in self.selected_items:
infohash = selected_item.download_info["infohash"]
TriblerNetworkRequest(f"downloads/{infohash}",
self.on_download_stopped,
method='PATCH',
data={"state": "stop"})
def on_send_clicked(self):
self.send_report_button.setEnabled(False)
self.send_report_button.setText("SENDING...")
endpoint = 'http://reporter.tribler.org/report'
sys_info = ""
for ind in range(self.env_variables_list.topLevelItemCount()):
item = self.env_variables_list.topLevelItem(ind)
sys_info += "%s\t%s\n" % (item.text(0), item.text(1))
comments = self.comments_text_edit.toPlainText()
if len(comments) == 0:
comments = "Not provided"
stack = self.error_text_edit.toPlainText()
post_data = {
"version": self.tribler_version,
"machine": platform.machine(),
"os": platform.platform(),
"timestamp": int(time.time()),
"sysinfo": sys_info,
"comments": comments,
"stack": stack,
}
TriblerNetworkRequest(endpoint,
self.on_report_sent,
raw_data=tribler_urlencode(post_data),
method='POST')
def change_anonymity(self, hops):
for selected_item in self.selected_items:
infohash = selected_item.download_info["infohash"]
TriblerNetworkRequest(f"downloads/{infohash}",
self.on_change_anonymity,
method='PATCH',
data={"anon_hops": hops})
def __init__(self, parent: QWidget, infohash: str) -> None:
DialogContainer.__init__(self, parent, left_right_margin=400)
self.index: Optional[QModelIndex] = None
self.infohash = infohash
uic.loadUi(get_ui_file_path('add_tags_dialog.ui'), self.dialog_widget)
self.dialog_widget.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Expanding)
connect(self.dialog_widget.close_button.clicked, self.close_dialog)
connect(self.dialog_widget.save_button.clicked,
self.on_save_tags_button_clicked)
connect(self.dialog_widget.edit_tags_input.enter_pressed,
lambda: self.on_save_tags_button_clicked(None))
connect(self.dialog_widget.edit_tags_input.escape_pressed,
self.close_dialog)
self.dialog_widget.edit_tags_input.setFocus()
self.dialog_widget.error_text_label.hide()
self.dialog_widget.suggestions_container.hide()
# Fetch suggestions
TriblerNetworkRequest(f"tags/{infohash}/suggestions",
self.on_received_suggestions)
self.update_window()
