def interceptRequest(self, info):
url = info.requestUrl()
if url.hasQuery() and url.path().endswith('api'):
query = QUrlQuery(url.query())
p = query.queryItemValue('p')
model = query.queryItemValue('model')
r18 = query.queryItemValue('r18')
self.get_live2d_data(p, model, r18)
# 重定向
info.redirect(
QUrl('http://127.0.0.1:{0}/model/model.json'.format(
self.port)))
def key(self, job, url):
key = url.path().lstrip("/")
query = QUrlQuery(url)
command = query.queryItemValue("command")
keymap = query.queryItemValue("keymap")
if ":" in command:
modname, fname = command.split(":", 1)
fn = getattr(importlib.import_module(modname), fname)
command_name = fn.__name__
named_command = False
else:
command_name = command
cmd = COMMANDS[command]
fn = cmd.binding
named_command = True
modname = fn.__module__
command_doc = fn.__doc__
src_url = get_src_url(fn)
def _get_all_keys(km):
acc = []
cmd = command_name if named_command else fn
def add(prefix, cmd_):
if cmd == cmd_:
acc.append(" ".join(str(k) for k in prefix))
km.traverse_commands(add)
return acc
try:
all_keys = _get_all_keys(KEYMAPS[keymap])
except KeyError:
all_keys = (key, )
self.reply_template(
job, "key", {
"command_name": command_name,
"keymap": keymap,
"key": key,
"command_doc": command_doc,
"named_command": named_command,
"command_src_url": src_url,
"modname": modname,
"all_keys": all_keys,
})
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 requestPixmap(self, id, size):
url = QUrl(id)
query = QUrlQuery(url.query())
map_dir = QDir(url.toLocalFile()).path()
dot_size = round(float(query.queryItemValue('dot_size')))
should_flip = query.queryItemValue('flip') in ['True', 'true']
opacity = round(float(query.queryItemValue('opacity')))
try:
img, size = self._generate_heatmap(map_dir, dot_size, opacity)
if should_flip:
img = flip(img)
p = QPixmap.fromImage(img.toqimage())
return p, size
except Exception:
return QPixmap(), QSize(-1, -1)
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 acceptNavigationRequest(self, url, _type, isMainFrame):
query = QUrlQuery(url)
if query.hasQueryItem("requrl"):
orig_url = query.queryItemValue("requrl", QUrl.FullyDecoded)
url = QUrl(orig_url)
QDesktopServices.openUrl(url)
return False
return super().acceptNavigationRequest(url, _type, isMainFrame)
def _qute_settings_set(url):
"""Handler for qute://settings/set."""
query = QUrlQuery(url)
option = query.queryItemValue('option', QUrl.FullyDecoded)
value = query.queryItemValue('value', QUrl.FullyDecoded)
# https://github.com/qutebrowser/qutebrowser/issues/727
if option == 'content.javascript.enabled' and value == 'false':
msg = ("Refusing to disable javascript via qute://settings "
"as it needs javascript support.")
message.error(msg)
return 'text/html', b'error: ' + msg.encode('utf-8')
try:
config.instance.set_str(option, value, save_yaml=True)
return 'text/html', b'ok'
except configexc.Error as e:
message.error(str(e))
return 'text/html', b'error: ' + str(e).encode('utf-8')
def _qute_settings_set(url):
"""Handler for qute://settings/set."""
query = QUrlQuery(url)
option = query.queryItemValue('option', QUrl.FullyDecoded)
value = query.queryItemValue('value', QUrl.FullyDecoded)
# https://github.com/qutebrowser/qutebrowser/issues/727
if option == 'content.javascript.enabled' and value == 'false':
msg = ("Refusing to disable javascript via qute://settings "
"as it needs javascript support.")
message.error(msg)
return 'text/html', b'error: ' + msg.encode('utf-8')
try:
config.instance.set_str(option, value, save_yaml=True)
return 'text/html', b'ok'
except configexc.Error as e:
message.error(str(e))
return 'text/html', b'error: ' + str(e).encode('utf-8')
def __adBlockPage(self):
"""
Private method to build the AdBlock page.
@return built AdBlock page
@rtype str
"""
query = QUrlQuery(self.__job.requestUrl())
rule = query.queryItemValue("rule")
subscription = query.queryItemValue("subscription")
title = self.tr("Content blocked by AdBlock Plus")
message = self.tr("Blocked by rule: <i>{0} ({1})</i>").format(
rule, subscription)
page = readAllFileContents(":/html/adblockPage.html")
page = page.replace("@FAVICON@", "qrc:icons/adBlockPlus16.png")
page = page.replace("@IMAGE@", "qrc:icons/adBlockPlus64.png")
page = page.replace("@TITLE@", title)
page = page.replace("@MESSAGE@", message)
return page
def qute_log(url: QUrl) -> _HandlerRet:
"""Handler for qute://log.
There are three query parameters:
- level: The minimum log level to print.
For example, qute://log?level=warning prints warnings and errors.
Level can be one of: vdebug, debug, info, warning, error, critical.
- plain: If given (and not 'false'), plaintext is shown.
- logfilter: A filter string like the --logfilter commandline argument
accepts.
"""
query = QUrlQuery(url)
plain = (query.hasQueryItem('plain')
and query.queryItemValue('plain').lower() != 'false')
if log.ram_handler is None:
content = "Log output was disabled." if plain else None
else:
level = query.queryItemValue('level')
if not level:
level = 'vdebug'
filter_str = query.queryItemValue('logfilter')
try:
logfilter = (log.LogFilter.parse(filter_str, only_debug=False)
if filter_str else None)
except log.InvalidLogFilterError as e:
raise UrlInvalidError(e)
content = log.ram_handler.dump_log(html=not plain,
level=level,
logfilter=logfilter)
template = 'pre.html' if plain else 'log.html'
src = jinja.render(template, title='log', content=content)
return 'text/html', src
def __pageLoadFinished(self):
"""
Private slot handling the loadFinished signal.
"""
url = self.__browser.url()
if url.toString().startswith(
"https://accounts.google.com/o/oauth2/approval/v2"):
urlQuery = QUrlQuery(url)
approvalCode = urlQuery.queryItemValue("approvalCode",
QUrl.FullyDecoded)
if approvalCode:
self.approvalCodeReceived.emit(approvalCode)
self.close()
def __parseUrl(self, url):
"""
Private method to parse the AdBlock URL for the subscription.
@param url AdBlock URL for the subscription (QUrl)
"""
if url.scheme() != "abp":
return
if url.path() != "subscribe":
return
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
urlQuery = QUrlQuery(url)
self.__title = urlQuery.queryItemValue("title")
self.__enabled = urlQuery.queryItemValue("enabled") != "false"
self.__location = QByteArray(urlQuery.queryItemValue("location"))
# Check for required subscription
self.__requiresLocation = urlQuery.queryItemValue(
"requiresLocation")
self.__requiresTitle = urlQuery.queryItemValue("requiresTitle")
if self.__requiresLocation and self.__requiresTitle:
import Helpviewer.HelpWindow
Helpviewer.HelpWindow.HelpWindow.adBlockManager()\
.loadRequiredSubscription(self.__requiresLocation,
self.__requiresTitle)
lastUpdateString = urlQuery.queryItemValue("lastUpdate")
self.__lastUpdate = QDateTime.fromString(lastUpdateString,
Qt.ISODate)
else:
self.__title = \
QUrl.fromPercentEncoding(url.encodedQueryItemValue("title"))
self.__enabled = QUrl.fromPercentEncoding(
url.encodedQueryItemValue("enabled")) != "false"
self.__location = QByteArray(
QUrl.fromPercentEncoding(
url.encodedQueryItemValue("location")))
# Check for required subscription
self.__requiresLocation = QUrl.fromPercentEncoding(
url.encodedQueryItemValue("requiresLocation"))
self.__requiresTitle = QUrl.fromPercentEncoding(
url.encodedQueryItemValue("requiresTitle"))
if self.__requiresLocation and self.__requiresTitle:
import Helpviewer.HelpWindow
Helpviewer.HelpWindow.HelpWindow.adBlockManager()\
.loadRequiredSubscription(self.__requiresLocation,
self.__requiresTitle)
lastUpdateByteArray = url.encodedQueryItemValue("lastUpdate")
lastUpdateString = QUrl.fromPercentEncoding(lastUpdateByteArray)
self.__lastUpdate = QDateTime.fromString(lastUpdateString,
Qt.ISODate)
self.__loadRules()
def __parseUrl(self, url):
"""
Private method to parse the AdBlock URL for the subscription.
@param url AdBlock URL for the subscription (QUrl)
"""
if url.scheme() != "abp":
return
if url.path() != "subscribe":
return
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
urlQuery = QUrlQuery(url)
self.__title = urlQuery.queryItemValue("title")
self.__enabled = urlQuery.queryItemValue("enabled") != "false"
self.__location = QByteArray(urlQuery.queryItemValue("location"))
# Check for required subscription
self.__requiresLocation = urlQuery.queryItemValue(
"requiresLocation")
self.__requiresTitle = urlQuery.queryItemValue("requiresTitle")
if self.__requiresLocation and self.__requiresTitle:
import Helpviewer.HelpWindow
Helpviewer.HelpWindow.HelpWindow.adBlockManager()\
.loadRequiredSubscription(self.__requiresLocation,
self.__requiresTitle)
lastUpdateString = urlQuery.queryItemValue("lastUpdate")
self.__lastUpdate = QDateTime.fromString(lastUpdateString,
Qt.ISODate)
else:
self.__title = \
QUrl.fromPercentEncoding(url.encodedQueryItemValue("title"))
self.__enabled = QUrl.fromPercentEncoding(
url.encodedQueryItemValue("enabled")) != "false"
self.__location = QByteArray(QUrl.fromPercentEncoding(
url.encodedQueryItemValue("location")))
# Check for required subscription
self.__requiresLocation = QUrl.fromPercentEncoding(
url.encodedQueryItemValue("requiresLocation"))
self.__requiresTitle = QUrl.fromPercentEncoding(
url.encodedQueryItemValue("requiresTitle"))
if self.__requiresLocation and self.__requiresTitle:
import Helpviewer.HelpWindow
Helpviewer.HelpWindow.HelpWindow.adBlockManager()\
.loadRequiredSubscription(self.__requiresLocation,
self.__requiresTitle)
lastUpdateByteArray = url.encodedQueryItemValue("lastUpdate")
lastUpdateString = QUrl.fromPercentEncoding(lastUpdateByteArray)
self.__lastUpdate = QDateTime.fromString(lastUpdateString,
Qt.ISODate)
self.__loadRules()
def search_and_render(url, fulltext_hp, fulltext_de):
query = QUrlQuery(url)
mode = query.queryItemValue('mode')
phrase = query.queryItemValue('phrase')
filters = query.queryItemValue('filters')
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 onAnchorClicked(self, url: QUrl):
from notes.ui.MainWindow import MainWindow
import webbrowser
host = url.host()
scheme = url.scheme()
if scheme == "http" or scheme == "https":
webbrowser.open(url.toString())
elif scheme == "notesmanager":
url.setScheme("file")
local_path = url.toLocalFile()
query = QUrlQuery(url)
uuid = query.queryItemValue("uuid")
if local_path == self.notebook.attachment_base.filename:
self.noteViewManager.openNote(self.noteViewManager.notebook.get_note_by_uuid(uuid))
else:
spawn = MainWindow(None, local_path, uuid)
spawn.show()
def __parseUrl(self, url):
"""
Private method to parse the AdBlock URL for the subscription.
@param url AdBlock URL for the subscription
@type QUrl
"""
if url.scheme() != "abp":
return
if url.path() != "subscribe":
return
urlQuery = QUrlQuery(url)
self.__title = QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue("title").encode()))
self.__enabled = urlQuery.queryItemValue("enabled") != "false"
self.__location = QByteArray(QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue("location").encode()))
.encode("utf-8"))
# Check for required subscription
self.__requiresLocation = QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue(
"requiresLocation").encode()))
self.__requiresTitle = QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue("requiresTitle").encode()))
if self.__requiresLocation and self.__requiresTitle:
from WebBrowser.WebBrowserWindow import WebBrowserWindow
WebBrowserWindow.adBlockManager().loadRequiredSubscription(
self.__requiresLocation, self.__requiresTitle)
lastUpdateString = urlQuery.queryItemValue("lastUpdate")
self.__lastUpdate = QDateTime.fromString(lastUpdateString,
Qt.ISODate)
self.__loadRules()
def acceptNavigationRequest(self, url, type_, isMainFrame):
"""
Public method to determine, if a request may be accepted.
@param url URL to navigate to
@type QUrl
@param type_ type of the navigation request
@type QWebEnginePage.NavigationType
@param isMainFrame flag indicating, that the request originated from
the main frame
@type bool
@return flag indicating acceptance
@rtype bool
"""
scheme = url.scheme()
if scheme == "mailto":
QDesktopServices.openUrl(url)
return False
# AdBlock
if url.scheme() == "abp":
if WebBrowserWindow.adBlockManager().addSubscriptionFromUrl(url):
return False
# GreaseMonkey
if PYQT_WEBENGINE_VERSION >= 0x50e00: # PyQtWebEngine >= 5.14.0
navigationType = type_ in [
QWebEnginePage.NavigationTypeLinkClicked,
QWebEnginePage.NavigationTypeRedirect
]
else:
navigationType = type_ == QWebEnginePage.NavigationTypeLinkClicked
if navigationType and url.toString().endswith(".user.js"):
WebBrowserWindow.greaseMonkeyManager().downloadScript(url)
return False
if url.scheme() == "eric":
if url.path() == "AddSearchProvider":
query = QUrlQuery(url)
self.view().mainWindow().openSearchManager().addEngine(
QUrl(query.queryItemValue("url")))
return False
elif url.path() == "PrintPage":
self.printPageRequested.emit()
return False
# Safe Browsing
self.__badSite = False
from WebBrowser.SafeBrowsing.SafeBrowsingManager import (
SafeBrowsingManager)
if (SafeBrowsingManager.isEnabled() and url.scheme()
not in SafeBrowsingManager.getIgnoreSchemes()):
threatLists = (
WebBrowserWindow.safeBrowsingManager().lookupUrl(url)[0])
if threatLists:
threatMessages = (WebBrowserWindow.safeBrowsingManager().
getThreatMessages(threatLists))
res = E5MessageBox.warning(
WebBrowserWindow.getWindow(),
self.tr("Suspicuous URL detected"),
self.tr("<p>The URL <b>{0}</b> was found in the Safe"
" Browsing database.</p>{1}").format(
url.toString(), "".join(threatMessages)),
E5MessageBox.StandardButtons(E5MessageBox.Abort
| E5MessageBox.Ignore),
E5MessageBox.Abort)
if res == E5MessageBox.Abort:
self.safeBrowsingAbort.emit()
return False
self.__badSite = True
threatType = (
WebBrowserWindow.safeBrowsingManager().getThreatType(
threatLists[0]))
self.safeBrowsingBad.emit(threatType, "".join(threatMessages))
result = QWebEnginePage.acceptNavigationRequest(
self, url, type_, isMainFrame)
if result:
if isMainFrame:
isWeb = url.scheme() in ("http", "https", "ftp", "ftps",
"file")
globalJsEnabled = WebBrowserWindow.webSettings().testAttribute(
QWebEngineSettings.JavascriptEnabled)
if isWeb:
enable = globalJsEnabled
else:
enable = True
self.settings().setAttribute(
QWebEngineSettings.JavascriptEnabled, enable)
self.__channelUrl = url
self.__setupChannelTimer.start()
self.navigationRequestAccepted.emit(url, type_, isMainFrame)
return result
