def qute_history(url): """Handler for qute://history. Display and serve history.""" if url.path() == '/data': try: offset = QUrlQuery(url).queryItemValue("offset") offset = int(offset) if offset else None except ValueError as e: raise QuteSchemeError("Query parameter offset is invalid", e) # Use start_time in query or current time. try: start_time = QUrlQuery(url).queryItemValue("start_time") start_time = float(start_time) if start_time else time.time() except ValueError as e: raise QuteSchemeError("Query parameter start_time is invalid", e) return 'text/html', json.dumps(history_data(start_time, offset)) else: if (config.get('content', 'allow-javascript') and (objects.backend == usertypes.Backend.QtWebEngine or qtutils.is_qtwebkit_ng())): return 'text/html', jinja.render('history.html', title='History', session_interval=config.get( 'ui', 'history-session-interval')) else: # Get current date from query parameter, if not given choose today. curr_date = datetime.date.today() try: query_date = QUrlQuery(url).queryItemValue("date") if query_date: curr_date = datetime.datetime.strptime( query_date, "%Y-%m-%d").date() except ValueError: log.misc.debug("Invalid date passed to qute:history: " + query_date) one_day = datetime.timedelta(days=1) next_date = curr_date + one_day prev_date = curr_date - one_day # start_time is the last second of curr_date start_time = time.mktime(next_date.timetuple()) - 1 history = [(i["url"], i["title"], datetime.datetime.fromtimestamp(i["time"]), QUrl(i["url"]).host()) for i in history_data(start_time)] return 'text/html', jinja.render( 'history_nojs.html', title='History', history=history, curr_date=curr_date, next_date=next_date, prev_date=prev_date, today=datetime.date.today(), )
def qute_pdfjs(url: QUrl) -> _HandlerRet: """Handler for qute://pdfjs. Return the pdf.js viewer or redirect to original URL if the file does not exist. """ if url.path() == '/file': filename = QUrlQuery(url).queryItemValue('filename') if not filename: raise UrlInvalidError("Missing filename") if '/' in filename or os.sep in filename: raise RequestDeniedError("Path separator in filename.") path = _pdf_path(filename) with open(path, 'rb') as f: data = f.read() mimetype = utils.guess_mimetype(filename, fallback=True) return mimetype, data if url.path() == '/web/viewer.html': query = QUrlQuery(url) filename = query.queryItemValue("filename") if not filename: raise UrlInvalidError("Missing filename") path = _pdf_path(filename) if not os.path.isfile(path): source = query.queryItemValue('source') if not source: # This may happen with old URLs stored in history raise UrlInvalidError("Missing source") raise Redirect(QUrl(source)) data = pdfjs.generate_pdfjs_page(filename, url) return 'text/html', data try: data = pdfjs.get_pdfjs_res(url.path()) except pdfjs.PDFJSNotFound as e: # Logging as the error might get lost otherwise since we're not showing # the error page if a single asset is missing. This way we don't lose # information, as the failed pdfjs requests are still in the log. log.misc.warning( "pdfjs resource requested but not found: {}".format(e.path)) raise NotFoundError("Can't find pdfjs resource '{}'".format(e.path)) else: mimetype = utils.guess_mimetype(url.fileName(), fallback=True) return mimetype, data
def getIpAddressReport(self, ipAddress): """ Public method to retrieve a report for an IP address. @param ipAddress valid IPv4 address in dotted quad notation @type str """ self.__lastIP = ipAddress queryItems = [ ("apikey", Preferences.getHelp("VirusTotalServiceKey")), ("ip", ipAddress), ] url = QUrl(self.GetIpAddressReportUrl) if qVersion() >= "5.0.0": from PyQt5.QtCore import QUrlQuery query = QUrlQuery() query.setQueryItems(queryItems) url.setQuery(query) else: url.setQueryItems(queryItems) request = QNetworkRequest(url) import Helpviewer.HelpWindow nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager() reply = nam.get(request) reply.finished.connect(self.__getIpAddressReportFinished) self.__replies.append(reply)
def pydoc(self, job, url): from pygments.formatters import HtmlFormatter from pygments.lexers.python import Python3Lexer from pygments import highlight modname = url.path().lstrip("/") query = QUrlQuery(url) extras = {} if query.hasQueryItem("hl_lines"): start, end = query.queryItemValue("hl_lines").split("-") extras["hl_lines"] = list(range(int(start), int(end) + 1)) mod = importlib.import_module(modname) filepath = inspect.getsourcefile(mod) formatter = HtmlFormatter(title="Module %s" % modname, full=True, lineanchors="line", **extras) with open(filepath) as f: code = highlight(f.read(), Python3Lexer(), formatter) buffer = QBuffer(self) buffer.setData(code.encode("utf-8")) job.reply(b"text/html", buffer)
def check_for_updates(self): if self.checkBox_UpdateCheck.isChecked(): print("check for updates") update_key = self.updateKey.displayText() if len(update_key) == 50: data = QUrlQuery() data.addQueryItem("update_key", update_key) data.addQueryItem("product", "OnAirScreen") data.addQueryItem("current_version", versionString) data.addQueryItem("distribution", distributionString) data.addQueryItem("mac", self.get_mac()) data.addQueryItem( "include_beta", f'{self.checkBox_IncludeBetaVersions.isChecked()}') req = QtNetwork.QNetworkRequest(QUrl(update_url)) req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") self.nam_update_check = QtNetwork.QNetworkAccessManager() self.nam_update_check.finished.connect( self.handle_update_check_response) self.nam_update_check.post( req, data.toString(QUrl.FullyEncoded).encode("UTF-8")) else: print("error, update key in wrong format") self.error_dialog = QErrorMessage() self.error_dialog.setWindowTitle("Update Check Error") self.error_dialog.showMessage( 'Update key is in the wrong format!', 'UpdateKeyError')
def _generate_pdfjs_script(filename): """Generate the script that shows the pdf with pdf.js. Args: filename: The name of the file to open. """ url = QUrl('qute://pdfjs/file') url_query = QUrlQuery() url_query.addQueryItem('filename', filename) url.setQuery(url_query) js_url = javascript.to_js( url.toString(QUrl.FullyEncoded)) # type: ignore[arg-type] return jinja.js_environment.from_string(""" document.addEventListener("DOMContentLoaded", function() { if (typeof window.PDFJS !== 'undefined') { // v1.x window.PDFJS.verbosity = window.PDFJS.VERBOSITY_LEVELS.info; } else { // v2.x const options = window.PDFViewerApplicationOptions; options.set('verbosity', pdfjsLib.VerbosityLevel.INFOS); } const viewer = window.PDFView || window.PDFViewerApplication; viewer.open({{ url }}); }); """).render(url=js_url)
def url(self): """ Public method to generate the URL for this subscription. @return AdBlock URL for the subscription (QUrl) """ url = QUrl() url.setScheme("abp") url.setPath("subscribe") queryItems = [] queryItems.append(("location", bytes(self.__location).decode())) queryItems.append(("title", self.__title)) if self.__requiresLocation and self.__requiresTitle: queryItems.append(("requiresLocation", self.__requiresLocation)) queryItems.append(("requiresTitle", self.__requiresTitle)) if not self.__enabled: queryItems.append(("enabled", "false")) if self.__lastUpdate.isValid(): queryItems.append( ("lastUpdate", self.__lastUpdate.toString(Qt.ISODate))) if qVersion() >= "5.0.0": from PyQt5.QtCore import QUrlQuery query = QUrlQuery() query.setQueryItems(queryItems) url.setQuery(query) else: url.setQueryItems(queryItems) return url
def url_with_param(url, params) -> str: url = QUrl(url) q = QUrlQuery(url) for key, value in params.items(): q.addQueryItem(key, value) url.setQuery(q) return url.url()
def suggestionsUrl(self, searchTerm): """ Public method to get a URL ready for suggestions. @param searchTerm term to search for (string) @return URL (QUrl) """ if not self._suggestionsUrlTemplate: return QUrl() ret = QUrl.fromEncoded( QByteArray( self.parseTemplate( searchTerm, self._suggestionsUrlTemplate).encode("utf-8"))) if self.__searchMethod != "post": if qVersion() >= "5.0.0": from PyQt5.QtCore import QUrlQuery urlQuery = QUrlQuery(ret) for parameter in self._suggestionsParameters: urlQuery.addQueryItem( parameter[0], self.parseTemplate(searchTerm, parameter[1])) ret.setQuery(urlQuery) else: for parameter in self._suggestionsParameters: ret.addQueryItem( parameter[0], self.parseTemplate(searchTerm, parameter[1])) return ret
def addSubscriptionFromUrl(self, url): """ Public method to ad an AdBlock subscription given the abp URL. @param url URL to subscribe an AdBlock subscription @type QUrl @return flag indicating success @rtype bool """ if url.path() != "subscribe": return False title = QUrl.fromPercentEncoding( QByteArray(QUrlQuery(url).queryItemValue("title").encode())) if not title: return False res = E5MessageBox.yesNo( None, self.tr("Subscribe?"), self.tr("""<p>Subscribe to this AdBlock subscription?</p>""" """<p>{0}</p>""").format(title)) if res: from .AdBlockSubscription import AdBlockSubscription from WebBrowser.WebBrowserWindow import WebBrowserWindow dlg = WebBrowserWindow.adBlockManager().showDialog() subscription = AdBlockSubscription( url, False, WebBrowserWindow.adBlockManager()) WebBrowserWindow.adBlockManager().addSubscription(subscription) dlg.addSubscription(subscription, False) dlg.setFocus() dlg.raise_() return res
def init(main_widget, my_id='', oppenent_id=''): WebChatFrame.q_widget = QtWidgets.QWidget() WebChatFrame.q_widget.show() WebChatFrame.q_widget.setFixedSize(300, 600) WebChatFrame.q_widget.move( main_widget.mapToGlobal(QPoint(main_widget.width() + 1, -23))) horizontalLayout = QtWidgets.QHBoxLayout(WebChatFrame.q_widget) horizontalLayout.setContentsMargins(0, 0, 0, 0) view = QtWebEngineWidgets.QWebEngineView(WebChatFrame.q_widget) horizontalLayout.addWidget(view) view.settings().setAttribute( QtWebEngineWidgets.QWebEngineSettings.PluginsEnabled, True) view.settings().setAttribute( QtWebEngineWidgets.QWebEngineSettings.JavascriptEnabled, True) url = QUrl(WebChatFrame.url + '/chat') urldata = QUrlQuery() urldata.addQueryItem('my_id', my_id) urldata.addQueryItem('oppenent_id', oppenent_id) url.setQuery(urldata) view.setUrl(url) view.show()
def __dataRequest(self, page, client_id, client_secret, date_from, date_to, polygon): if not self.isAuthorized(): self.authRequest(client_id, client_secret, page, date_from, date_to, polygon) return print("page=", page) # print("accessTokenExpires=", self.__accessTokenExpires.toString(Qt.ISODate)) date_format = "yyyy-MM-ddThh:mm" url = QUrl(THERMAL_ANOMALY_URL) url_query = QUrlQuery() if polygon is not None: url_query.addQueryItem("polygon", polygon) if date_from is not None: url_query.addQueryItem("shooting", "ge" + date_from.toString(date_format)) if date_to is not None: url_query.addQueryItem("shooting", "le" + date_to.toString(date_format)) # _take=1000&_skip=0&_lastUpdated=ge2020-04-08T00%3A00%3A00 url_query.addQueryItem("_take", str(TAKE)) url_query.addQueryItem("_skip", str(page * TAKE).zfill(1)) # url.setQuery(url_query) print(url_query.queryItems()) request = QtNetwork.QNetworkRequest() request.setRawHeader(b'Authorization', ('Bearer ' + self.__accessToken).encode()) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json".encode()) request.setUrl(url) # print("request: ", url) self.dataReply = self.__manager.post(request, url_query.toString(QUrl.FullyEncoded).encode()) self.dataReply.finished.connect(lambda dr=self.dataReply: self.__data_request_finished(dr, client_id, client_secret, date_from, date_to, polygon))
def _generate_pdfjs_script(filename): """Generate the script that shows the pdf with pdf.js. Args: filename: The name of the file to open. """ url = QUrl('qute://pdfjs/file') url_query = QUrlQuery() url_query.addQueryItem('filename', filename) url.setQuery(url_query) return jinja.js_environment.from_string(""" document.addEventListener("DOMContentLoaded", function() { {% if disable_create_object_url %} PDFJS.disableCreateObjectURL = true; {% endif %} PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info; const viewer = window.PDFView || window.PDFViewerApplication; viewer.open("{{ url }}"); }); """).render( url=javascript.string_escape(url.toString(QUrl.FullyEncoded)), # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-70420 disable_create_object_url=( not qtutils.version_check('5.12') and not qtutils.version_check('5.7.1', exact=True, compiled=False) and objects.backend == usertypes.Backend.QtWebEngine))
def getDomainReport(self, domain): """ Public method to retrieve a report for a domain. @param domain domain name @type str """ self.__lastDomain = domain queryItems = [ ("apikey", Preferences.getHelp("VirusTotalServiceKey")), ("domain", domain), ] url = QUrl(self.GetDomainReportUrl) if qVersion() >= "5.0.0": from PyQt5.QtCore import QUrlQuery query = QUrlQuery() query.setQueryItems(queryItems) url.setQuery(query) else: url.setQueryItems(queryItems) request = QNetworkRequest(url) import Helpviewer.HelpWindow nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager() reply = nam.get(request) reply.finished.connect(self.__getDomainReportFinished) self.__replies.append(reply)
def exchange_authorization_code(self, authorization_code, scopes, callback): log.debug( "OAuth: exchanging authorization_code %s for an access_token", authorization_code) host, port = config.setting['server_host'], config.setting[ 'server_port'] path = "/oauth2/token" url = QUrl() url_query = QUrlQuery() url_query.addQueryItem("grant_type", "authorization_code") url_query.addQueryItem("code", authorization_code) url_query.addQueryItem("client_id", MUSICBRAINZ_OAUTH_CLIENT_ID) url_query.addQueryItem("client_secret", MUSICBRAINZ_OAUTH_CLIENT_SECRET) url_query.addQueryItem("redirect_uri", "urn:ietf:wg:oauth:2.0:oob") url.setQuery(url_query.query(QUrl.FullyEncoded)) data = string_(url.query()) self.xmlws.post(host, port, path, data, partial(self.on_exchange_authorization_code_finished, scopes, callback), xml=False, mblogin=True, priority=True, important=True)
def getHttp(self, uri, params): QgsApplication.setOverrideCursor(Qt.WaitCursor) try: rq = QUrl(uri) q = QUrlQuery() for (k, v) in params.items(): q.addQueryItem(k, v) rq.setQuery(q) req = QNetworkRequest(rq) try: reply = self.nominatim_networkAccessManager.blockingGet(req) resource = reply.content().data().decode('utf8') r = json.loads(resource) if (isinstance(r, list)): self.populateTable(r) else: self.populateTable([r]) except: self.tableResult.clearContents() finally: QgsApplication.restoreOverrideCursor()
def refresh_access_token(self, callback): refresh_token = config.persist["oauth_refresh_token"] log.debug("OAuth: refreshing access_token with a refresh_token %s", refresh_token) host, port = config.setting['server_host'], config.setting[ 'server_port'] path = "/oauth2/token" url = QUrl() url_query = QUrlQuery() url_query.addQueryItem("grant_type", "refresh_token") url_query.addQueryItem("refresh_token", refresh_token) url_query.addQueryItem("client_id", MUSICBRAINZ_OAUTH_CLIENT_ID) url_query.addQueryItem("client_secret", MUSICBRAINZ_OAUTH_CLIENT_SECRET) url.setQuery(url_query.query(QUrl.FullyEncoded)) data = string_(url.query()) self.xmlws.post(host, port, path, data, partial(self.on_refresh_access_token_finished, callback), xml=False, mblogin=True, priority=True, important=True)
def auto_suggest(self): text = self._editor.text() if self.catch_coordinates(text): pass elif text: is_offline = False if QgsSettings().value("/kadas/isOffline") == "false" else True LOG.debug("is_offline %s" % is_offline) if is_offline: url = QgsSettings().value( "search/locationofflinesearchurl", "http://localhost:5000/SearchServerCh", ) else: url = QgsSettings().value( "search/locationsearchurl", "https://api3.geo.admin.ch/rest/services/api/SearchServer", ) url = QUrl(url) query = QUrlQuery() query.addQueryItem("sr", "2056") query.addQueryItem("searchText", text) query.addQueryItem("lang", "en") query.addQueryItem("type", "locations") query.addQueryItem("limit", "10") url.setQuery(query) LOG.debug(url) self._network_manager.get(QNetworkRequest(url))
def _render_header(title, mode, phrase, filters): r = [] r.append(ADV_HEADER) r.append('<h1>{0}</h1>'.format(title)) r.append('<ul class="nav">\n') modes = [(name, spec) for (name, spec) in MODE_DICT.items()] modes.sort(key=itemgetter(0)) for (name, spec) in modes: href = QUrl('search:///') urlquery = QUrlQuery() if phrase: urlquery.addQueryItem('phrase', phrase) if filters: urlquery.addQueryItem('filters', filters) urlquery.addQueryItem('mode', name) href.setQuery(urlquery) if name != mode: r.append('<li><a href="{href}">{title}</a></li>\n'.format( href=href.toEncoded(), title=spec['title'])) else: r.append('<li><span class="sel">{title}<span></li>\n'.format( href=href.toEncoded(), title=spec['title'])) r.append('</ul>\n') return ''.join(r)
def _render_header(title, mode, phrase, filters): r = [] r.append(ADV_HEADER) r.append("<h1>{0}</h1>".format(title)) r.append('<ul class="nav">\n') modes = [(name, spec) for (name, spec) in MODE_DICT.items()] modes.sort(key=itemgetter(0)) for (name, spec) in modes: q = QUrlQuery() if phrase: q.addQueryItem("phrase", phrase) if filters: q.addQueryItem("filters", filters) q.addQueryItem("mode", name) href = QUrl("search:///?" + q.toString()) if name != mode: r.append( '<li><a href="{href}">{title}</a></li>\n'.format( href=href.toString(), title=spec["title"] ) ) else: r.append( '<li><span class="sel">{title}<span></li>\n'.format(title=spec["title"]) ) r.append("</ul>\n") return "".join(r)
def getRemoteTiles(self): query = QUrlQuery() url = QUrl(f"{self.url}/search") query.addQueryItem("q", self.search_str) query.addQueryItem("f", "pjson") url.setQuery(query.query()) response = QgsNetworkAccessManager.blockingGet( QNetworkRequest(QUrl(url))) if response.error() != QNetworkReply.NoError: raise Exception(response.errorString()) responsejson = json.loads(response.content().data()) LOG.debug("response from data repository: %s" % responsejson) tiles = [] for result in responsejson["results"]: itemid = result["id"] timestamp = self.dataTimestamp(itemid) if timestamp is None: status = self.NOT_INSTALLED elif timestamp < result["modified"]: status = self.UPDATABLE else: status = self.UP_TO_DATE tile = dict(result) tile["status"] = status tiles.append(tile) return tiles
def search_and_render(url, fulltext_hp, fulltext_de): query = dict((k, v) for (k, v) in QUrlQuery(url).queryItems()) mode = query.get("mode", None) phrase = query.get("phrase", None) filters = query.get("filters", None) r = [] if mode in MODE_DICT: spec = MODE_DICT[mode] searcher = fulltext_hp if (spec["searcher"] == "hp") else fulltext_de collector = searcher.make_collector(spec["limit"]) res = searcher.search( collector, query_str1=phrase, query_str2=filters, itemtypes=spec["itemtypes"], highlight=spec["highlight"], ) r.append(_render_header(spec["title"], mode, phrase, filters)) r.append(spec["renderer"](res, mode)) r.append(_render_footer()) else: r.append(_render_header("Advanced Search", mode, phrase, filters)) r.append(_render_footer()) return "".join(r)
def exchange_authorization_code(self, authorization_code, scopes, callback): log.debug( "OAuth: exchanging authorization_code %s for an access_token", authorization_code) path = "/oauth2/token" url = QUrl() url_query = QUrlQuery() url_query.addQueryItem("grant_type", "authorization_code") url_query.addQueryItem("code", authorization_code) url_query.addQueryItem("client_id", MUSICBRAINZ_OAUTH_CLIENT_ID) url_query.addQueryItem("client_secret", MUSICBRAINZ_OAUTH_CLIENT_SECRET) url_query.addQueryItem("redirect_uri", "urn:ietf:wg:oauth:2.0:oob") url.setQuery(url_query.query(QUrl.FullyEncoded)) data = url.query() self.webservice.post( self.host, self.port, path, data, partial(self.on_exchange_authorization_code_finished, scopes, callback), mblogin=True, priority=True, important=True, request_mimetype="application/x-www-form-urlencoded")
def test_file_pathsep(self, sep): url = QUrl('qute://pdfjs/file') query = QUrlQuery() query.addQueryItem('filename', 'foo{}bar'.format(sep)) url.setQuery(query) with pytest.raises(qutescheme.RequestDeniedError): qutescheme.data_for_url(url)
def _handle_reply(self, reply, request, handler, xml, refresh): error = int(reply.error()) if error: log.error("Network request error for %s: %s (QT code %d, HTTP code %s)", reply.request().url().toString(QUrl.RemoveUserInfo), reply.errorString(), error, repr(reply.attribute(QtNetwork.QNetworkRequest.HttpStatusCodeAttribute)) ) if handler is not None: handler(reply.readAll(), reply, error) else: redirect = reply.attribute(QtNetwork.QNetworkRequest.RedirectionTargetAttribute) fromCache = reply.attribute(QtNetwork.QNetworkRequest.SourceIsFromCacheAttribute) cached = ' (CACHED)' if fromCache else '' log.debug("Received reply for %s: HTTP %d (%s) %s", reply.request().url().toString(QUrl.RemoveUserInfo), reply.attribute(QtNetwork.QNetworkRequest.HttpStatusCodeAttribute), reply.attribute(QtNetwork.QNetworkRequest.HttpReasonPhraseAttribute), cached ) if handler is not None: # Redirect if found and not infinite if redirect: url = request.url() # merge with base url (to cover the possibility of the URL being relative) redirect = url.resolved(redirect) if not XmlWebService.urls_equivalent(redirect, reply.request().url()): log.debug("Redirect to %s requested", redirect.toString(QUrl.RemoveUserInfo)) redirect_host = string_(redirect.host()) redirect_port = self.url_port(redirect) redirect_query = dict(QUrlQuery(redirect).queryItems(QUrl.FullyEncoded)) redirect_path = redirect.path() original_host = string_(url.host()) original_port = self.url_port(url) if ((original_host, original_port) in REQUEST_DELAY and (redirect_host, redirect_port) not in REQUEST_DELAY): log.debug("Setting rate limit for %s:%i to %i" % (redirect_host, redirect_port, REQUEST_DELAY[(original_host, original_port)])) REQUEST_DELAY[(redirect_host, redirect_port)] =\ REQUEST_DELAY[(original_host, original_port)] self.get(redirect_host, redirect_port, redirect_path, handler, xml, priority=True, important=True, refresh=refresh, queryargs=redirect_query, cacheloadcontrol=request.attribute(QtNetwork.QNetworkRequest.CacheLoadControlAttribute)) else: log.error("Redirect loop: %s", reply.request().url().toString(QUrl.RemoveUserInfo) ) handler(reply.readAll(), reply, error) elif xml: document = _read_xml(QXmlStreamReader(reply)) handler(document, reply, error) else: handler(reply.readAll(), reply, error)
def encode_uri(ds_uri, schema_name, project_name=None): u = QUrl() urlQuery = QUrlQuery() u.setScheme("postgresql") u.setHost(ds_uri.host()) if ds_uri.port() != '': u.setPort(int(ds_uri.port())) if ds_uri.username() != '': u.setUserName(ds_uri.username()) if ds_uri.password() != '': u.setPassword(ds_uri.password()) if ds_uri.service() != '': urlQuery.addQueryItem("service", ds_uri.service()) if ds_uri.authConfigId() != '': urlQuery.addQueryItem("authcfg", ds_uri.authConfigId()) if ds_uri.sslMode() != QgsDataSourceUri.SslPrefer: urlQuery.addQueryItem("sslmode", QgsDataSourceUri.encodeSslMode(ds_uri.sslMode())) urlQuery.addQueryItem("dbname", ds_uri.database()) urlQuery.addQueryItem("schema", schema_name) if project_name: urlQuery.addQueryItem("project", project_name) u.setQuery(urlQuery) return str(u.toEncoded(), 'utf-8')
def _handle_redirect(self, reply, request, redirect): url = request.url() error = int(reply.error()) # merge with base url (to cover the possibility of the URL being relative) redirect = url.resolved(redirect) if not WebService.urls_equivalent(redirect, reply.request().url()): log.debug("Redirect to %s requested", redirect.toString(QUrl.RemoveUserInfo)) redirect_host = redirect.host() redirect_port = self.url_port(redirect) redirect_query = dict(QUrlQuery(redirect).queryItems(QUrl.FullyEncoded)) redirect_path = redirect.path() original_host = url.host() original_port = self.url_port(url) original_host_key = (original_host, original_port) redirect_host_key = (redirect_host, redirect_port) ratecontrol.copy_minimal_delay(original_host_key, redirect_host_key) self.get(redirect_host, redirect_port, redirect_path, request.handler, request.parse_response_type, priority=True, important=True, refresh=request.refresh, queryargs=redirect_query, cacheloadcontrol=request.attribute(QNetworkRequest.CacheLoadControlAttribute)) else: log.error("Redirect loop: %s", reply.request().url().toString(QUrl.RemoveUserInfo) ) request.handler(reply.readAll(), reply, error)
def handle_form_submitted(self, qurl, elements=dict()): # print("\n\ngot url: ", qurl) qqurl = QUrlQuery(qurl) for key, value in qqurl.queryItems(): elements[key] = value self.render(qurl.path(), elements)
def get_main_url(filename): """Get the URL to be opened to view a local PDF.""" url = QUrl('qute://pdfjs/web/viewer.html') query = QUrlQuery() query.addQueryItem('filename', filename) # read from our JS query.addQueryItem('file', '') # to avoid pdfjs opening the default PDF url.setQuery(query) return url
def test3(self): url = QUrl("http://localhost:18080/user") query = QUrlQuery() query.addQueryItem("username", "yqfcpy"); query.addQueryItem("password", "111111"); url.setQuery(query.query()) print(query.query()) print(url)