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()