def _wrap_request(self, request): req = QNetworkRequest(request) req_id = next(self._request_ids) req.setAttribute(self._REQUEST_ID, req_id) if hasattr(request, 'timeout'): req.timeout = request.timeout return req, req_id
def checkPluginUpdatesAvailable(self): """ Public method to check the availability of updates of plug-ins. """ period = Preferences.getPluginManager("UpdatesCheckInterval") if period == 0: return elif period in [1, 2, 3]: lastModified = QFileInfo(self.pluginRepositoryFile).lastModified() if lastModified.isValid() and lastModified.date().isValid(): lastModifiedDate = lastModified.date() now = QDate.currentDate() if period == 1 and lastModifiedDate.day() == now.day(): # daily return elif period == 2 and lastModifiedDate.daysTo(now) < 7: # weekly return elif period == 3 and \ (lastModifiedDate.daysTo(now) < lastModifiedDate.daysInMonth()): # monthly return self.__updateAvailable = False request = QNetworkRequest( QUrl(Preferences.getUI("PluginRepositoryUrl6"))) request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.AlwaysNetwork) reply = self.__networkManager.get(request) reply.finished.connect(self.__downloadRepositoryFileDone) self.__replies.append(reply)
def _makeRequestByType(self, request_type: str) -> None: Logger.log("i", "Requesting %s metadata from server.", request_type) request = QNetworkRequest(self._request_urls[request_type]) for header_name, header_value in self._request_headers: request.setRawHeader(header_name, header_value) if self._network_manager: self._network_manager.get(request)
def on_searchPushButton_clicked(self, checked): if self.categoryID != '' and self.categoryID != '-1': merchandising = Merchandising(warnings = False) response = merchandising.execute( 'getMostWatchedItems', { 'categoryId': self.categoryID, 'maxResults': self.ui.spinBox.value() } ) reply = response.reply itemRecommendations = reply.itemRecommendations.item row = self.ui.tableWidget.rowCount() for item in itemRecommendations: self.ui.tableWidget.insertRow(row) imageUrl = 'http://thumbs3.ebaystatic.com/pict/%s4040.jpg' % item.itemId request = QNetworkRequest(QUrl(imageUrl)) request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.PreferCache) reply = self.manager.get(request) self.replyMap[reply] = row viewItemURL = QLabel() viewItemURL.setOpenExternalLinks(True) #viewItemURL.setTextInteractionFlags(Qt.TextBrowserInteraction) title = '<a href="%s">%s</a>' % (item.viewItemURL, item.title) viewItemURL.setText(title) self.ui.tableWidget.setCellWidget(row, 1, viewItemURL) self.ui.tableWidget.setItem(row, 2, QTableWidgetItem(item.primaryCategoryName)) self.ui.tableWidget.setItem(row, 3, QTableWidgetItem(item.buyItNowPrice.value)) self.ui.tableWidget.setItem(row, 4, QTableWidgetItem(item.watchCount)) row += 1
def _createEmptyRequest(self, target: str, content_type: Optional[str] = "application/json") -> QNetworkRequest: url = QUrl("http://" + self._address + self._api_prefix + target) request = QNetworkRequest(url) if content_type is not None: request.setHeader(QNetworkRequest.ContentTypeHeader, content_type) request.setHeader(QNetworkRequest.UserAgentHeader, self._user_agent) return request
def __downloadFile(self, url, filename, doneMethod=None): """ Private slot to download the given file. @param url URL for the download (string) @param filename local name of the file (string) @param doneMethod method to be called when done """ self.__updateButton.setEnabled(False) self.__downloadButton.setEnabled(False) self.__downloadInstallButton.setEnabled(False) self.__downloadCancelButton.setEnabled(True) self.statusLabel.setText(url) self.__doneMethod = doneMethod self.__downloadURL = url self.__downloadFileName = filename self.__downloadIODevice = QFile(self.__downloadFileName + ".tmp") self.__downloadCancelled = False request = QNetworkRequest(QUrl(url)) request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.AlwaysNetwork) reply = self.__networkManager.get(request) reply.finished.connect(self.__downloadFileDone) reply.downloadProgress.connect(self.__downloadProgress) self.__replies.append(reply)
def _createRequest(self, url: str, basic_auth_username: str = "", basic_auth_password: str = "") -> QNetworkRequest: request = QNetworkRequest(url) request.setRawHeader("User-Agent".encode(), self._user_agent) if basic_auth_username and basic_auth_password: data = base64.b64encode(("%s:%s" % (basic_auth_username, basic_auth_password)).encode()).decode("utf-8") request.setRawHeader("Authorization".encode(), ("Basic %s" % data).encode()) return request
def _wrap_request(self, request): req = QNetworkRequest(request) req_id = next(self._request_ids) req.setAttribute(self._REQUEST_ID, req_id) for attr in ['timeout', 'track_response_body']: if hasattr(request, attr): setattr(req, attr, getattr(request, attr)) return req, req_id
def _createEmptyRequest(self, path: str, content_type: Optional[str] = "application/json") -> QNetworkRequest: request = QNetworkRequest(QUrl(path)) if content_type: request.setHeader(QNetworkRequest.ContentTypeHeader, content_type) access_token = self._account.accessToken if access_token: request.setRawHeader(b"Authorization", "Bearer {}".format(access_token).encode()) return request
def _update(self): ## Request 'general' printer data url = QUrl("http://" + self._address + self._api_prefix + "printer") self._printer_request = QNetworkRequest(url) self._printer_request.setRawHeader(self._api_header.encode(), self._api_key.encode()) self._printer_reply = self._manager.get(self._printer_request) ## Request print_job data url = QUrl("http://" + self._address + self._api_prefix + "job") self._job_request = QNetworkRequest(url) self._job_request.setRawHeader(self._api_header.encode(), self._api_key.encode()) self._job_reply = self._manager.get(self._job_request)
def perform_put(self, endpoint, data, url): """ Perform an HTTP PUT request. :param endpoint: the name of the Tribler endpoint. :param data: the data/body to send with the request. :param url: the url to send the request to. """ request = QNetworkRequest(QUrl(url)) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") reply = self.put(request, data) return reply
def _load_content(self, content_type, content): """ This method is for displaying some content of such types: local web pages, remote web pages, local pdf`s, local videos. It should be called like in the following example to work correctly: self._load_content('local_video', 'some_video.mp4') """ self._main_browser_reset_zoom() # reset zoom if content_type == 'local_url': source = config['flask_server_home'] + \ config['flask_server_local_page_client'] + \ content # simply get the file from flask-server by its relative path-id # specify type of currently opened file for zoom and scroll methods self._cur_filetype = "webpage" elif content_type == 'external_url': self._cur_filetype = "webpage" # no needs required as, link should be given in # 'http://yoursite.com/yourpage' source = content elif content_type == 'local_pdf': # to render PDF`s we use PDF.js, so we open its page and send it a # path for the target file. source = config['flask_server_home'] + \ config['flask_server_local_page_client'] + \ content self._cur_filetype = "pdf" elif content_type == 'local_video': # in case of opening local videos we need to modify the path to the video in the source code of # the videoplayer, so don`t die after reading this code. It works just in the same style as other # filetypes, but in a very weird way. source = config['flask_server_home'] + \ config['flask_server_video_addr_client'] + content logger.info('Opening video at {}'.format(source)) self._cur_filetype = "video" # Set a custom user agent to avoid message about deprecated version of # browser self._main_browser.page().userAgentForUrl = self._custom_ua logger.info('Loading data on address: {}'.format(source)) # Create a request to be able to set user-agent data. Without # it, it`s impossible to customize request data. request = QNetworkRequest() request.setUrl(QUrl(source)) request.setRawHeader("USER-AGENT", config['output_user_agent']) # and finally load the result self._main_browser.load(request)
def junk(app): userapi = "https://api.gitter.im/v1/user" roomapi = "https://api.gitter.im/v1/rooms/{}/rooms" streamapi = 'https://stream.gitter.im/v1/rooms/{}/chatMessages' userurl = QUrl(userapi) #roomsurl = QUrl(roomapi.format(user_id)) #encoded = QUrl(streamapi.format(encoded_id)) req = QNetworkRequest(userurl) req.setRawHeader("Accept", "application/json") req.setRawHeader("Authorization", 'Bearer '+token) resp = app.net.get(req) resp.readyRead.connect(lambda : viewresp(resp))
def __tabContextMenuClone(self): """ Private method to clone the selected tab. """ idx = self.__tabContextMenuIndex if idx < 0: idx = self.currentIndex() if idx < 0 or idx > self.count(): return req = QNetworkRequest(self.widget(idx).url()) req.setRawHeader(b"X-Eric6-UserLoadAction", b"1") self.newBrowser(None, (req, QNetworkAccessManager.GetOperation, b""))
def _doGet(self, path): url = urlunsplit(('http', self.addr, path, '', '')) sig = self._sign(b'GET', path.encode('utf-8'), b'') headers = { HMAC_HEADER: b64encode(sig) } request = QNetworkRequest(QUrl(url)) for hname in headers: request.setRawHeader(hname, headers[hname]) reply = self.network.get(request) return reply
def _doPost(self, path, **params): url = urlunsplit(('http', self.addr, path, '', '')) body = json.dumps(params) sig = self._sign(b'POST', path.encode('utf-8'), body.encode('utf-8')) headers = { HMAC_HEADER: b64encode(sig), 'Content-Type': 'application/json' } request = QNetworkRequest(QUrl(url)) for hname in headers: request.setRawHeader(hname, headers[hname]) reply = self.network.post(request, body) return reply
def post(self, url, param=None, data=None, json=True): if isinstance(data, dict): f = '' for i in data: f += '{}={}&'.format(i, data[i]) data = f[:-1] byte_data = QtCore.QByteArray() byte_data.append(data) url = QtCore.QUrl(parse_url(url, param)) request = QNetworkRequest(url) if json: request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json') reply = self.session.post(request, byte_data) return reply
def __lineEditReturnPressed(self): """ Private slot to handle the entering of an URL. """ edit = self.sender() url = self.__guessUrlFromPath(edit.text()) request = QNetworkRequest(url) request.setRawHeader(b"X-Eric6-UserLoadAction", b"1") if e5App().keyboardModifiers() == Qt.AltModifier: self.newBrowser( None, (request, QNetworkAccessManager.GetOperation, b"")) else: self.currentBrowser().setSource( None, (request, QNetworkAccessManager.GetOperation, b"")) self.currentBrowser().setFocus()
def _setJobState(self, job_state): if not self._selected_printer: return selected_printer_uuid = self._printers_dict[self._selected_printer["unique_name"]]["uuid"] if selected_printer_uuid not in self._print_job_by_printer_uuid: return print_job_uuid = self._print_job_by_printer_uuid[selected_printer_uuid]["uuid"] url = QUrl(self._api_base_uri + "print_jobs/" + print_job_uuid + "/action") put_request = QNetworkRequest(url) put_request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json") data = '{"action": "' + job_state + '"}' self._manager.put(put_request, data.encode())
def getSearchRequestData(cls, term): """ Class method to assemble the search request data structure. @param term search term (string) @return tuple of network request object, operation and parameters (QNetworkRequest, QNetworkAccessManager.Operation, QByteArray) """ request = QNetworkRequest(QUrl(cls.SearchUrl)) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") op = QNetworkAccessManager.PostOperation params = QByteArray("chain=").append(QUrl.toPercentEncoding(term)) return (request, op, params)
def download(self, requestOrUrl, requestFileName=False, mainWindow=None): """ Public method to download a file. @param requestOrUrl reference to a request object (QNetworkRequest) or a URL to be downloaded (QUrl) @keyparam requestFileName flag indicating to ask for the download file name (boolean) @keyparam mainWindow reference to the main window (HelpWindow) """ request = QNetworkRequest(requestOrUrl) if request.url().isEmpty(): return self.handleUnsupportedContent( self.__manager.get(request), requestFileName=requestFileName, download=True, mainWindow=mainWindow )
def acceptNavigationRequest(self, _frame: QWebFrame, request: QNetworkRequest, typ: QWebPage.NavigationType): """Override acceptNavigationRequest to handle clicked links. Setting linkDelegationPolicy to DelegateAllLinks and using a slot bound to linkClicked won't work correctly, because when in a frameset, we have no idea in which frame the link should be opened. Checks if it should open it in a tab (middle-click or control) or not, and then conditionally opens the URL. Opening it in a new tab/window is handled in the slot connected to link_clicked. """ url = request.url() target = self._tabdata.combined_target() log.webview.debug("navigation request: url {}, type {}, " "target {}".format( url.toDisplayString(), debug.qenum_key(QWebPage, typ), target)) if typ == QWebPage.NavigationTypeReload: self.reloading.emit(url) return True elif typ != QWebPage.NavigationTypeLinkClicked: return True self.link_clicked.emit(url) return url.isValid() and target == usertypes.ClickTarget.normal
def __getFileScanReportUrl(self, scanId): """ Private method to get the report URL for a file scan. @param scanId ID of the scan to get the report URL for (string) """ request = QNetworkRequest(QUrl(self.GetUrlReportUrl)) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") params = QByteArray("key={0}&resource={1}".format( Preferences.getHelp("VirusTotalServiceKey"), scanId)) import Helpviewer.HelpWindow nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager() reply = nam.post(request, params) reply.finished.connect(self.__getFileScanReportUrlFinished) self.__replies.append(reply)
def __init__(self, url): super(FLNetwork, self).__init__() self.url = url from PyQt5.QtNetwork import QNetworkRequest, QNetworkAccessManager self.request = QNetworkRequest() self.manager = QNetworkAccessManager() # self.manager.readyRead.connect(self._slotNetworkStart) self.manager.finished['QNetworkReply*'].connect(self._slotNetworkFinished)
def get(self, url, *, user_agent=None, **kwargs): """Start a download with a link URL. Args: url: The URL to get, as QUrl user_agent: The UA to set for the request, or None. **kwargs: passed to get_request(). Return: The created DownloadItem. """ if not url.isValid(): urlutils.invalid_url_error(url, "start download") return None req = QNetworkRequest(url) if user_agent is not None: req.setHeader(QNetworkRequest.UserAgentHeader, user_agent) return self.get_request(req, **kwargs)
class DownloadManager(QNetworkAccessManager): def __init__(self, parent=None): super().__init__(parent) def addUrl(self, url): print(url) self.request = QNetworkRequest(QUrl(url)) self.request.setRawHeader(b"User-Agent", b"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1") self.reply = self.get(self.request) self.reply.downloadProgress.connect(self.setProgress) return self.request def setProgress(self, a, s): print(a, s)
def submitUrl(self, url): """ Public method to submit an URL to be scanned. @param url url to be scanned (QUrl) """ request = QNetworkRequest(QUrl(self.ScanUrlUrl)) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") params = QByteArray("key={0}&url=".format( Preferences.getHelp("VirusTotalServiceKey")))\ .append(QUrl.toPercentEncoding(url.toString())) import Helpviewer.HelpWindow nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager() reply = nam.post(request, params) reply.finished.connect(self.__submitUrlFinished) self.__replies.append(reply)
def downloadBinPackage(packageUrl, destinationFileName): request = QNetworkRequest(QUrl(packageUrl)) request.setRawHeader(b'Accept-Encoding', b'gzip,deflate') reply = QgsNetworkAccessManager.instance().get(request) evloop = QEventLoop() reply.finished.connect(evloop.quit) evloop.exec_(QEventLoop.ExcludeUserInputEvents) content_type = reply.rawHeader(b'Content-Type') if content_type == b'application/zip': if os.path.isfile(destinationFileName): os.unlink(destinationFileName) destinationFile = open(destinationFileName, 'wb') destinationFile.write(bytearray(reply.readAll())) destinationFile.close() else: ret_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) raise IOError("{} {}".format(ret_code, packageUrl))
def downloadAndInstallPlugin(self, url): Logger.log("i", "Attempting to download & install plugin from %s", url) url = QUrl(url) self._download_plugin_request = QNetworkRequest(url) self._download_plugin_request.setRawHeader(*self._request_header) self._download_plugin_reply = self._network_manager.get(self._download_plugin_request) self._download_progress = 0 self.setIsDownloading(True) self.onDownloadProgressChanged.emit() self._download_plugin_reply.downloadProgress.connect(self._onDownloadPluginProgress)
def checkServiceKeyValidity(self, key, protocol=""): """ Public method to check the validity of the given service key. @param key service key (string) @param protocol protocol used to access VirusTotal (string) """ if protocol == "": urlStr = self.GetFileReportUrl else: urlStr = self.GetFileReportPattern.format(protocol) request = QNetworkRequest(QUrl(urlStr)) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") params = QByteArray("apikey={0}&resource={1}".format( key, self.TestServiceKeyScanID).encode("utf-8")) import WebBrowser.WebBrowserWindow nam = (WebBrowser.WebBrowserWindow.WebBrowserWindow.networkManager()) reply = nam.post(request, params) reply.finished.connect( lambda: self.__checkServiceKeyValidityFinished(reply)) self.__replies.append(reply)
def get_update_bg(self): """ 获取更新时的背景图 """ old_update_file = os.path.join(BASE_DIR, "classini/update_{}_{}.json".format(PLATEFORM, self.sys_bit)) if not os.path.exists(old_update_file): pixmap = QPixmap('media/update_bg.png') scaled_map = pixmap.scaled(QSize(500, 200), Qt.KeepAspectRatio) self.setPixmap(scaled_map) else: with open(old_update_file, "r", encoding="utf-8") as old_fp: old_json = json.load(old_fp) server = old_json.get("SERVER", "http://210.13.218.130:9004/static/") url = server + "update_image_bg.png" reply = self.network_manager.get(QNetworkRequest(QUrl(url))) reply.finished.connect(self.start_image_reply)
def start(self) -> None: self.stop() # Ensure that previous requests (if any) are stopped. if not self._source_url: Logger.log("w", "Unable to start camera stream without target!") return self._started = True Logger.log("w", "MJPEG starting stream...") self._image_request = QNetworkRequest(self._source_url) if self._network_manager is None: self._network_manager = QNetworkAccessManager() self._image_reply = self._network_manager.get(self._image_request) self._image_reply.downloadProgress.connect(self._onStreamDownloadProgress)
def __init__(self, url, parent=None): """ Constructor @param url xmlrpc handler URL (string or QUrl) @param parent parent object (QObject) """ super(E5XmlRpcClient, self).__init__(parent) # attributes for the network objects self.__networkManager = QNetworkAccessManager(self) self.__networkManager.proxyAuthenticationRequired.connect( proxyAuthenticationRequired) self.__networkManager.finished.connect(self.__replyFinished) if SSL_AVAILABLE: self.__sslErrorHandler = E5SslErrorHandler(self) self.__networkManager.sslErrors.connect(self.__sslErrors) self.__callmap = {} self.__request = QNetworkRequest(QUrl(url)) self.__request.setRawHeader(b"User-Agent", b"E5XmlRpcClient/1.0") self.__request.setHeader(QNetworkRequest.ContentTypeHeader, "text/xml")
def get_resource( name: str, dominode_base_url: str, network_manager: QgsNetworkAccessManager, feedback: typing.Optional[QgsFeedback] = None, ) -> typing.Optional[typing.Dict]: url_query = QUrlQuery() url_query.addQueryItem('name', name) url = QUrl( f'{dominode_base_url}/dominode-validation/api/dominode-resources/') url.setQuery(url_query) request = QNetworkRequest(url) request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json') reply = network_manager.blockingGet(request, '', True, feedback=feedback) status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) result = None if status_code == 200: raw_string_contents = bytes(reply.content()).decode('utf-8') contents = json.loads(raw_string_contents) exists = contents.get('count', 0) > 0 if exists: result = contents['results'][0] return result
def save_option_to_server(self, chart_type): """ 保存图形的配置到服务器 """ chart_option = self.get_chart_option() # 作图配置 chart_option["chart_category"] = chart_type # 图表类型(普通图形:normal,季节图形:season) title = chart_option["title"]["text"] if not title: QMessageBox.information(self, "提示", "请填写图形标题!") return is_private = 1 if self.chart_widget.private_check.checkState() else 0 json_option = { "title": title, "variety_en": self.variety_en, "decipherment": self.chart_widget.decipherment_edit.text().strip(), "is_private": is_private, "option": chart_option.copy() } network_manager = getattr(qApp, "_network") url = SERVER_API + "sheet/{}/chart/".format(self.sheet_id) request = QNetworkRequest(QUrl(url)) user_token = get_user_token() request.setRawHeader("Authorization".encode("utf-8"), user_token.encode("utf-8")) reply = network_manager.post(request, json.dumps(json_option).encode("utf-8")) reply.finished.connect(self.save_option_reply)
def _startCamera(self): global_container_stack = Application.getInstance( ).getGlobalContainerStack() if not global_container_stack or not parseBool( global_container_stack.getMetaDataEntry( "octoprint_show_camera", False)) or self._camera_url == "": return # Start streaming mjpg stream url = QUrl(self._camera_url) self._image_request = QNetworkRequest(url) self._image_reply = self._manager.get(self._image_request) self._image_reply.downloadProgress.connect( self._onStreamDownloadProgress)
def connect(self): self._createNetworkManager() self.setConnectionState(ConnectionState.connecting) self._update( ) # Manually trigger the first update, as we don't want to wait a few secs before it starts. Logger.log("d", "Connection with instance %s with url %s started", self._key, self._base_url) self._update_timer.start() self._last_response_time = None self.setAcceptsCommands(False) self.setConnectionText( i18n_catalog.i18nc("@info:status", "Connecting to OctoPrint on {0}").format( self._key)) ## Request 'settings' dump url = QUrl(self._api_url + "settings") self._settings_request = QNetworkRequest(url) self._settings_request.setRawHeader(self._api_header.encode(), self._api_key.encode()) self._settings_reply = self._manager.get(self._settings_request)
def startDownload(self, req): loop = QtCore.QEventLoop() QtCore.QTimer.singleShot(5000, loop.quit) self.reply = self.networkmanager.get(req) self.reply.metaDataChanged.connect(loop.quit) loop.exec_() #wait(1000) if self.reply.hasRawHeader(b'Location'): URL = QtCore.QUrl.fromUserInput( _str(self.reply.rawHeader(b'Location'))) self.reply.abort() req = QNetworkRequest(URL) req.setRawHeader(b'User-Agent', self.useragent) self.startDownload(req) return #print(self.reply.url().toString()) if self.reply.isFinished(): self.dataReceived() self.downloadStopped() return self.reply.finished.connect(self.downloadStopped) #self.reply.readyRead.connect(self.dataReceived) self.reply.error.connect(self.downloadError)
def get_daily_source_file(self): """ 获取日交易源数据xls文件 """ if self.date is None: raise DateValueError("请先使用`set_date`设置`DCESpider`日期.") url = "http://www.dce.com.cn/publicweb/quotesdata/exportDayQuotesChData.html" form_params = { "dayQuotes.variety": "all", "dayQuotes.trade_type": "0", "year": str(self.date.year), "month": str(self.date.month - 1), "day": self.date.strftime("%d"), "exportFlag": "excel" } form_data = generate_multipart_data(text_dict=form_params) network_manager = getattr(qApp, "_network") request = QNetworkRequest(QUrl(url)) request.setHeader(QNetworkRequest.UserAgentHeader, random.choice(USER_AGENTS)) reply = network_manager.post(request, form_data) reply.finished.connect(self.daily_source_file_reply) form_data.setParent(reply)
def _wrap_request(self, request): req = QNetworkRequest(request) req_id = next(self._request_ids) req.setAttribute(self._REQUEST_ID, req_id) if self.disable_browser_caches: # disables the network cache # see http://doc.qt.io/qt-5/qnetworkrequest.html#CacheLoadControl-enum req.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.AlwaysNetwork) req.setAttribute(QNetworkRequest.CacheSaveControlAttribute, False) for attr in ['timeout', 'track_request_body', 'track_response_body']: if hasattr(request, attr): setattr(req, attr, getattr(request, attr)) return req, req_id
def __init__(self, scene): QWidget.__init__(self) self.scene = scene self.properties = scene[PROPERTIES] self.setMouseTracking(True) datetime = iso8601.parse_date(self.properties["acquired"]) time = datetime.strftime("%H:%M:%S") date = datetime.strftime("%b %d, %Y") text = f"""{date}<span style="color: rgb(100,100,100);"> {time} UTC</span><br> <b>{PlanetClient.getInstance().item_types_names()[self.properties['item_type']]}</b> """ self.nameLabel = QLabel(text) self.iconLabel = QLabel() self.toolsButton = QLabel() self.toolsButton.setPixmap(COG_ICON.pixmap(QSize(18, 18))) self.toolsButton.mousePressEvent = self.showContextMenu pixmap = QPixmap(PLACEHOLDER_THUMB, "SVG") thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio, Qt.SmoothTransformation) self.iconLabel.setPixmap(thumb) layout = QHBoxLayout() layout.setMargin(2) vlayout = QVBoxLayout() vlayout.setMargin(0) vlayout.addWidget(self.iconLabel) self.iconWidget = QWidget() self.iconWidget.setFixedSize(48, 48) self.iconWidget.setLayout(vlayout) layout.addWidget(self.iconWidget) layout.addWidget(self.nameLabel) layout.addStretch() layout.addWidget(self.toolsButton) layout.addSpacing(10) self.setLayout(layout) self.nam = QNetworkAccessManager() self.nam.finished.connect(self.iconDownloaded) url = f"{scene['_links']['thumbnail']}?api_key={PlanetClient.getInstance().api_key()}" self.nam.get(QNetworkRequest(QUrl(url))) self.footprint = QgsRubberBand(iface.mapCanvas(), QgsWkbTypes.PolygonGeometry) self.footprint.setStrokeColor(PLANET_COLOR) self.footprint.setWidth(2) self.geom = qgsgeometry_from_geojson(scene[GEOMETRY]) self.setStyleSheet("SceneItemWidget{border: 2px solid transparent;}")
def __init__(self): super().__init__() self.settings = QSettings("tasmotizer.cfg", QSettings.IniFormat) self.nam = QNetworkAccessManager() self.nrRelease = QNetworkRequest( QUrl("http://thehackbox.org/tasmota/release/release.php")) self.nrDevelopment = QNetworkRequest( QUrl("http://thehackbox.org/tasmota/development.php")) self.setWindowTitle("Tasmotizer 1.1") self.setMinimumWidth(480) self.mode = 0 # BIN file self.bin_file = "" self.release_data = b"" self.development_data = b"" self.createUI() self.refreshPorts() self.getHackBoxFeeds()
def start_load(self, url): """Create a Poppler.Document from the given URL, QUrl or filename. Return, then asynchronously call self.load_cb. """ # If it's not a local file, we'll need to load it. # http://doc.qt.io/qt-5/qnetworkaccessmanager.html qurl = QUrl(url) if not qurl.scheme(): qurl = QUrl.fromLocalFile(url) if not self.network_manager: self.network_manager = QNetworkAccessManager() self.network_manager.finished.connect(self.download_finished) self.network_manager.get(QNetworkRequest(qurl))
def login(self, name_field, pass_field): print("Logging in...") self.statusBar().showMessage('Logging in...') self.Username = name_field.text() url = QtCore.QUrl(self.url_list['login']) request = QNetworkRequest() request.setUrl(url) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") data = QtCore.QByteArray() data.append(''.join(['user='******'&'])) data.append(''.join(['password=', pass_field.text()])) self.replyObjectLogin = self.manager.post(request, data) self.replyObjectLogin.finished.connect(self.loginFinalize)
def __init__(self, api_port, api_key, error_handler): QNetworkAccessManager.__init__(self) url = QUrl("http://localhost:%d/events" % api_port) self.request = QNetworkRequest(url) self.request.setRawHeader(b'X-Api-Key', api_key.encode('ascii')) self.remaining_connection_attempts = CORE_CONNECTION_ATTEMPTS_LIMIT self.connect_timer = QTimer() self.current_event_string = "" self.reply = None self.shutting_down = False self.error_handler = error_handler self._logger = logging.getLogger(self.__class__.__name__) # This flag is used to prevent race condition when starting GUI tests self.tribler_started_flag = False self.connect_timer.setSingleShot(True) connect(self.connect_timer.timeout, self.connect) self.notifier = notifier = Notifier() notifier.add_observer(notifications.events_start, self.on_events_start) notifier.add_observer(notifications.tribler_exception, self.on_tribler_exception) notifier.add_observer(notifications.channel_entity_updated, self.on_channel_entity_updated) notifier.add_observer(notifications.tribler_new_version, self.on_tribler_new_version) notifier.add_observer(notifications.channel_discovered, self.on_channel_discovered) notifier.add_observer(notifications.torrent_finished, self.on_torrent_finished) notifier.add_observer(notifications.low_space, self.on_low_space) notifier.add_observer(notifications.remote_query_results, self.on_remote_query_results) notifier.add_observer(notifications.tribler_shutdown_state, self.on_tribler_shutdown_state) notifier.add_observer(notifications.report_config_error, self.on_report_config_error)
def __downloadFile(self, url, filename, doneMethod=None): """ Private slot to download the given file. @param url URL for the download (string) @param filename local name of the file (string) @param doneMethod method to be called when done """ if self.__networkConfigurationManager.isOnline(): self.__updateButton.setEnabled(False) self.__downloadButton.setEnabled(False) self.__downloadInstallButton.setEnabled(False) self.__downloadCancelButton.setEnabled(True) self.statusLabel.setText(url) self.__doneMethod = doneMethod self.__downloadURL = url self.__downloadFileName = filename self.__downloadIODevice = QFile(self.__downloadFileName + ".tmp") self.__downloadCancelled = False request = QNetworkRequest(QUrl(url)) request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.AlwaysNetwork) reply = self.__networkManager.get(request) reply.finished.connect(self.__downloadFileDone) reply.downloadProgress.connect(self.__downloadProgress) self.__replies.append(reply) else: E5MessageBox.warning( self, self.tr("Error downloading file"), self.tr( """<p>Could not download the requested file""" """ from {0}.</p><p>Error: {1}</p>""" ).format(url, self.tr("Computer is offline.")))
def start(self) -> None: self.stop() # Ensure that previous requests (if any) are stopped. if not self._source_url: Logger.log("w", "Unable to start camera stream without target!") return auth_data = "" if self._source_url.userInfo(): # move auth data to basic authorization header auth_data = base64.b64encode( self._source_url.userInfo().encode()).decode("utf-8") authority = self._source_url.authority() self._source_url.setAuthority(authority.rsplit("@", 1)[1]) self._image_request = QNetworkRequest(self._source_url) self._image_request.setAttribute( QNetworkRequest.FollowRedirectsAttribute, True) if auth_data: self._image_request.setRawHeader(b"Authorization", ("basic %s" % auth_data).encode()) if self._source_url.scheme().lower() == "https": # ignore SSL errors (eg for self-signed certificates) ssl_configuration = QSslConfiguration.defaultConfiguration() ssl_configuration.setPeerVerifyMode(QSslSocket.VerifyNone) self._image_request.setSslConfiguration(ssl_configuration) if self._network_manager is None: self._network_manager = QNetworkAccessManager() self._image_reply = self._network_manager.get(self._image_request) self._image_reply.downloadProgress.connect( self._onStreamDownloadProgress) self._started = True
def download_tile(self, tile: "Tile"): self.__url = QUrl(self.server_pattern.format(tile.zoom, tile.x, tile.y)) if (tile.x, tile.y) not in self.__visited: request = QNetworkRequest() request.setUrl(self.__url) request.setAttribute(QNetworkRequest.User, (tile.x, tile.y)) self.__manager.get(request) self.__visited.add((tile.x, tile.y))
def get(self, url, **kwargs): """Start a download with a link URL. Args: url: The URL to get, as QUrl **kwargs: passed to get_request(). Return: The created DownloadItem. """ if not url.isValid(): urlutils.invalid_url_error(url, "start download") return req = QNetworkRequest(url) return self.get_request(req, **kwargs)
def fill_async_data(self): if self.window.pkgs: for idx, app_v in enumerate(self.window.pkgs): if app_v.status == PackageViewStatus.LOADING and app_v.model.status == PackageStatus.READY: if self.download_icons: self.network_man.get( QNetworkRequest(QUrl(app_v.model.icon_url))) self._update_row(app_v, change_update_col=False) app_v.status = PackageViewStatus.READY self.window.resize_and_center()
def download(self, url: str, path: Path): url = QUrl(url) req = QNetworkRequest(url) worker_loop = QEventLoop(self) reply = self._nam.get(req) reply.finished.connect(worker_loop.quit) reply.downloadProgress.connect(self._download_update) worker_loop.exec() qbytes = reply.readAll() # type: QByteArray with path.open("wb") as file: file.write(qbytes.data()) self.finished.emit()
def start(self): # Ensure that previous requests (if any) are stopped. self.stop() if self._target is None: Logger.log("w", "Unable to start camera stream without target!") return self._started = True url = QUrl(self._target) self._image_request = QNetworkRequest(url) if self._manager is None: self._manager = QNetworkAccessManager() self._image_reply = self._manager.get(self._image_request) self._image_reply.downloadProgress.connect( self._onStreamDownloadProgress)
def edit_user_module_authority(self): """ 编辑用户权限 """ row_index = getattr(self.sender(), "row_index") module_id = self.module_auth.module_auth_table.item(row_index, 0).text() module_text = self.module_auth.module_auth_table.item(row_index, 1).text() expire_date = self.module_auth.module_auth_table.item(row_index, 3).text() body_data = { "modify_user": self.module_auth.current_user_id, "module_id": module_id, "module_text": module_text, "expire_date": expire_date } network_manager = getattr(qApp, "_network") user_token = get_user_token() url = SERVER_API + "user/module-authenticate/" request = QNetworkRequest(QUrl(url)) request.setRawHeader("Authorization".encode("utf-8"), user_token.encode("utf-8")) reply = network_manager.put(request, json.dumps(body_data).encode("utf-8")) reply.finished.connect(self.modify_module_authority_reply)
def confirm_user_variety_authority(self): """ 确定修改用户的品种权限 """ current_row = getattr(self.sender(), "row_index") variety_id = self.variety_auth.variety_auth_table.item(current_row, 0).text() variety_en = self.variety_auth.variety_auth_table.item(current_row, 2).text() expire_date = self.variety_auth.variety_auth_table.item( current_row, 6).text() body_data = { "modify_user": self.variety_auth.current_user_id, "variety_id": variety_id, "variety_en": variety_en, "expire_date": expire_date } network_manager = getattr(qApp, "_network") user_token = get_user_token() url = SERVER_API + "user/variety-authenticate/" request = QNetworkRequest(QUrl(url)) request.setRawHeader("Authorization".encode("utf-8"), user_token.encode("utf-8")) reply = network_manager.put(request, json.dumps(body_data).encode("utf-8")) reply.finished.connect(self.modify_variety_authority_reply)
def _sendRequest(self, url, params, headers={}): if self.asynchonous: if self.reply is not None: self.reply.finished.disconnect(self.reply_finished) self.reply.abort() self.reply = None url = QUrl(url) q = QUrlQuery(url) for key, value in params.items(): q.addQueryItem(key, value) url.setQuery(q) QgsLogger.debug('Request: {}'.format(url.toEncoded())) request = QNetworkRequest(url) for key, value in headers.items(): request.setRawHeader(key, value) self.reply = QgsNetworkAccessManager.instance().get(request) self.reply.finished.connect(self.reply_finished) else: response = urlopen(self.url + '?' + urllib.urlencode(params)) data = json.load(response) self.load_data(data)
def startDownload(self, url: str) -> None: Logger.log("i", "Toolbox: Attempting to download & install package from %s.", url) url = QUrl(url) self._download_request = QNetworkRequest(url) if hasattr(QNetworkRequest, "FollowRedirectsAttribute"): # Patch for Qt 5.6-5.8 cast(QNetworkRequest, self._download_request).setAttribute(QNetworkRequest.FollowRedirectsAttribute, True) if hasattr(QNetworkRequest, "RedirectPolicyAttribute"): # Patch for Qt 5.9+ cast(QNetworkRequest, self._download_request).setAttribute(QNetworkRequest.RedirectPolicyAttribute, True) cast(QNetworkRequest, self._download_request).setRawHeader(*self._request_header) self._download_reply = cast(QNetworkAccessManager, self._network_manager).get(self._download_request) self.setDownloadProgress(0) self.setIsDownloading(True) cast(QNetworkReply, self._download_reply).downloadProgress.connect(self._onDownloadProgress)
def post(self, url, data=None): """Create a new POST request. Args: url: The URL to post to, as QUrl. data: A dict of data to send. """ if data is None: data = {} encoded_data = urllib.parse.urlencode(data).encode('utf-8') request = QNetworkRequest(url) request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/x-www-form-urlencoded;charset=utf-8') reply = self._nam.post(request, encoded_data) self._handle_reply(reply)
def _setJobState(self, job_state): # if job_state == "abort": # command = "cancel" # elif job_state == "print": # if self.jobState == "paused": # command = "pause" # else: # command = "start" # elif job_state == "pause": # command = "pause" urlString = "" if job_state == "abort": command = "cancel" urlString = self._api_url + '?a=stopJob' elif job_state == "print": if self.jobState == "paused": command = "pause" urlString = self._api_url + '?a=send&data={"cmd":"@pause"}' else: command = "start" urlString = self._api_url + '?a=continueJob' elif job_state == "pause": command = "pause" urlString = self._api_url + '?a=send&data={"cmd":"@pause"}' Logger.log("d", "XXX:Command:" + command) Logger.log("d", "XXX:Command:" + urlString) if urlString: url = QUrl(urlString) self._printer_request = QNetworkRequest(url) self._printer_request.setRawHeader(self._api_header.encode(), self._api_key.encode()) self._printer_reply = self._manager.get(self._printer_request)
def perform_delete(self, endpoint, data, url): """ Perform an HTTP DELETE request. :param endpoint: the name of the Tribler endpoint. :param data: the data/body to send with the request. :param url: the url to send the request to. """ buf = QBuffer() buf.setData(data) buf.open(QIODevice.ReadOnly) delete_request = QNetworkRequest(QUrl(url)) reply = self.sendCustomRequest(delete_request, "DELETE", buf) buf.setParent(reply) return reply
def send(params): url = self.formatUrl(endpoint, params) request = QNetworkRequest(url) headers['User-Agent'] = 'Divi QGIS Plugin/%s' % PLUGIN_VERSION QgsMessageLog.logMessage(str(headers), 'DIVI') for key, value in headers.items(): request.setRawHeader(key.encode('utf-8'), value.encode('utf-8')) if method == 'delete': reply = manager.sendCustomRequest(request, 'DELETE'.encode('utf-8'), data) else: if not data: reply = getattr(manager, method)(request) elif isinstance(data, QHttpMultiPart) == True: reply = getattr(manager, method)(request, data) elif isinstance(data, str) == True: reply = getattr(manager, method)(request, data.encode('utf-8')) loop = QEventLoop() reply.uploadProgress.connect(self.uploadProgress) reply.downloadProgress.connect(self.downloadProgress) reply.metaDataChanged.connect(self.metaDataChanged) #reply.error.connect(self._error) reply.finished.connect(loop.exit) self.abort_sig.connect( reply.abort ) loop.exec_() self.abort_sig.disconnect( reply.abort ) return reply