def test():
url = 'https://github.com/tody411/PyIntroduction'
#QCoreApplication.setAttribute()
app = QApplication(sys.argv)
browser = QWebEngineView()
browser.load(QUrl(url))
browser.resize(1024, 750)
browser.show()
sys.exit(app.exec_())
def main():
import sys
QCoreApplication.setOrganizationName("QtExamples")
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
WebUiHandler.registerUrlScheme()
app = QApplication(sys.argv)
profile = QWebEngineProfile()
handler = WebUiHandler()
profile.installUrlSchemeHandler(WebUiHandler.schemeName, handler)
page = QWebEnginePage(profile)
page.load(WebUiHandler.aboutUrl)
view = QWebEngineView()
view.setPage(page)
view.setContextMenuPolicy(Qt.NoContextMenu)
view.resize(500, 600)
view.show()
sys.exit(app.exec_())
class GraphWidget(QWidget):
def __init__(self, log_console):
logger.debug(locals())
QWidget.__init__(self)
log_console.add_loggers(logger)
self.graph = None
self.webview = QWebEngineView(parent=self)
self.index = QWebEnginePage(self)
worklayout = QHBoxLayout(parent=self)
worklayout.addWidget(self.webview)
self.setLayout(worklayout)
def draw_index(self):
if not self.graph:
logger.warning("No graph to draw found!")
width = self.contentsRect().width()
height = self.contentsRect().height()
pagewidth = int(width) - 10
pageheight = int(height) - 10
logger.info(f"{width}x{height}")
html = importlib.resources.read_text(__package__,
"index.thtml",
encoding="utf-8-sig")
html = (html.replace(
"$graph",
"'" + json.dumps(networkx.node_link_data(self.graph)) +
"'" if self.graph else
"""'{"directed":true,"multigraph":true,"graph":[],"nodes":[],"links":[]}'""",
).replace("$width", str(pagewidth)).replace("$height",
str(pageheight)))
path = pathlib.Path(
QStandardPaths.writableLocation(
QStandardPaths.AppLocalDataLocation)) / "index.html"
logger.info(f"""Saving html to {path.absolute()}""")
path.write_text(html)
self.index.setHtml(html)
self.index.settings().setAttribute(QWebEngineSettings.ShowScrollBars,
False)
self.webview.setPage(self.index)
self.webview.resize(width, height)
self.webview.show()
self.update()
@Slot()
def draw_graph(self):
logger.debug(locals())
self.draw_index()
@Slot()
def get_open_file_extensions(self):
logger.debug(locals())
return ";;".join([
"Node Link Graph (*.json)",
"Adjacency Graph (*.json)",
"GraphML (.graphml)",
"LEDA (*.gw, *.lgr, *.leda)",
"Pajek (*.net)",
])
@Slot()
def get_save_file_extensions(self):
logger.debug(locals())
return ";;".join(
["Node Link Graph (*.json)", "Adjacency Graph (*.json)"])
@Slot(str, str)
def open_file(self, path: str, file_type: str):
logger.debug(locals())
if "json" in file_type.lower():
if "node link graph" in file_type.lower():
self.graph = networkx.node_link_graph(
json.loads(pathlib.Path(path).read_text()))
elif "adjacency graph" in file_type.lower():
self.graph = networkx.adjacency_graph(
json.loads(pathlib.Path(path).read_text()))
else:
raise NotImplementedError()
elif "graphml" in file_type.lower():
self.graph = networkx.read_graphml(path)
elif "leda" in file_type.lower():
self.graph = networkx.read_leda(path)
elif "pajek" in file_type.lower():
self.graph = networkx.read_pajek(path)
else:
raise NotImplementedError()
@Slot(str, str)
def save_file(self, path: str, file_type: str):
logger.debug(locals())
if not self.graph:
raise ValueError("No graph to save!")
if "json" in file_type.lower():
if "node link graph" in file_type.lower():
with pathlib.Path(path).open("w") as file_p:
data = networkx.node_link_data(self.graph)
json.dump(data, file_p)
del data
elif "adjacency graph" in file_type.lower():
with pathlib.Path(path).open("w") as file_p:
data = networkx.adjacency_data(self.graph)
json.dump(data, file_p)
del data
else:
raise NotImplementedError()
else:
raise NotImplementedError()
class BrowserDialog(QMainWindow):
logMessage = Signal(str)
captureData = Signal(dict, dict, dict)
newCookie = Signal(str, str)
#loadFinished = Signal(bool)
#urlChanged = Signal(str)
#urlNotFound = Signal(QUrl)
def __init__(self, parent=None, caption="", width=600, height=600):
super(BrowserDialog, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.resize(width, height)
self.setWindowTitle(caption)
self.url = None
self.domain = None
self.headers = {}
self.stopped = False
self.cookie = ''
self.ready = False
central = QWidget()
self.setCentralWidget(central)
self.mainLayout = QVBoxLayout(central)
self.topLayout = QHBoxLayout()
self.mainLayout.addLayout(self.topLayout)
# Status bar
self.statusBar = self.statusBar()
self.cookieLabel = QScrollLabel()
self.cookieLabel.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Ignored)
self.statusBar.addWidget(self.cookieLabel)
self.cookieLabel.textVisible(False)
self.loadingLabel = QLabel()
self.statusBar.addPermanentWidget(self.loadingLabel)
# Adress bar
self.addressBar = QLineEdit()
self.addressBar.returnPressed.connect(self.addressChanged)
self.topLayout.addWidget(self.addressBar)
self.addressBar.setVisible(False)
# Create WebView
self.webview = QWebEngineView(self)
QWebEngineSettings.globalSettings().setAttribute(
QWebEngineSettings.PluginsEnabled, True)
QWebEngineSettings.globalSettings().setAttribute(
QWebEngineSettings.ScreenCaptureEnabled, True)
self.webpage = WebPageCustom(self.webview)
self.webview.setPage(self.webpage)
self.mainLayout.addWidget(self.webview)
self.webview.show()
# Signals
self.webpage.logMessage.connect(self.logMessage)
self.webpage.cookieChanged.connect(self.cookieChanged)
self.webview.urlChanged.connect(self.urlChanged)
self.webpage.loadFinished.connect(self.loadFinished)
self.webpage.loadStarted.connect(self.loadStarted)
#self.webpage.urlNotFound.connect(self.urlNotFound)
#self.browserWebview.loadFinished.connect(self.loadFinished)
#self.browserWebview.loadStarted.connect(self.loadStarted)
# Button layout
self.buttonLayout = QHBoxLayout()
self.topLayout.addLayout(self.buttonLayout)
# Buttons
buttonDismiss = QPushButton(self)
buttonDismiss.setText("Close")
buttonDismiss.setDefault(True)
buttonDismiss.clicked.connect(self.close)
self.buttonLayout.addWidget(buttonDismiss)
def loadPage(self,
url="",
headers={},
options={},
foldername=None,
filename=None,
fileext=None):
self.url = url
self.headers = headers
self.options = options
self.strip = self.options.get('access_token', '')
self.foldername = foldername
self.filename = filename
self.fileext = fileext
try:
targeturl = urllib.parse.urlparse(url)
self.domain = targeturl.netloc
except:
self.domain = None
request = QWebEngineHttpRequest(QUrl(self.url))
for key, val in self.headers.items():
key = key.encode('utf-8')
val = val.encode('utf-8')
request.setHeader(QByteArray(key), QByteArray(val))
self.webview.load(request)
self.show()
@Slot()
def loadStarted(self):
self.ready = False
self.loadingLabel.setText('Loading...')
@Slot()
def loadFinished(self, ok):
if ok:
self.ready = True
self.loadingLabel.setText('Loading finished.')
else:
self.ready = False
self.loadingLabel.setText('Loading failed.')
@Slot()
def urlChanged(self, url):
url = url.toString().replace(self.strip, '')
self.addressBar.setText(url)
@Slot()
def addressChanged(self):
url = self.addressBar.text()
request = QWebEngineHttpRequest(QUrl(url))
self.webview.load(request)
# Scrape HTML
def activateCaptureButton(self, handler):
self.captureData.connect(handler)
buttonCapture = QPushButton(self)
buttonCapture.setText("Capture")
buttonCapture.setDefault(True)
buttonCapture.clicked.connect(self.captureDataClicked)
self.buttonLayout.addWidget(buttonCapture)
self.addressBar.setVisible(True)
@Slot()
def captureDataClicked(self):
# Metadata
data = {}
data['title'] = self.webpage.title()
try:
data['url'] = {
'final':
self.webpage.url().toString().replace(self.strip, ''),
'requested':
self.webpage.requestedUrl().toString().replace(self.strip, '')
}
# Fetch HTML
data['text'] = self.getHtml()
# Fetch plain text
data['plaintext'] = self.getText()
if self.foldername is not None:
# Screenshot
try:
fullfilename = makefilename(data['url']['final'],
self.foldername,
self.filename,
fileext='.png',
appendtime=True)
data['screenshot'] = self.getScreenShot(fullfilename)
except Exception as e:
self.logMessage.emit('Error capturing screenshot: ' +
str(e))
# HTML file
try:
fullfilename = makefilename(data['url']['final'],
self.foldername,
self.filename,
self.fileext,
appendtime=True)
file = open(fullfilename, 'wb')
if file is not None:
try:
file.write(data['text'].encode())
finally:
file.close()
except Exception as e:
self.logMessage.emit('Error saving HTML: ' + str(e))
# PDF
try:
fullfilename = makefilename(data['url']['final'],
self.foldername,
self.filename,
fileext='.pdf',
appendtime=True)
self.webpage.printToPdf(fullfilename)
data['pdf'] = fullfilename
except Exception as e:
self.logMessage.emit('Error printing to PDF: ' + str(e))
except Exception as e:
data['error'] = str(e)
self.logMessage.emit(str(e))
# Options
options = self.options
options['querytime'] = str(datetime.now())
options['querystatus'] = 'captured'
options['querytype'] = 'captured'
#options['objectid'] = 'url.final'
#options['nodedata'] = None
# Headers
headers = {}
self.captureData.emit(data, options, headers)
def getHtml(self):
def newHtmlData(html):
self.capturedhtml = html
self.capturedhtml = None
self.webpage.toHtml(newHtmlData)
waitstart = QDateTime.currentDateTime()
while (self.capturedhtml is None) and (waitstart.msecsTo(
QDateTime.currentDateTime()) < 1000):
QApplication.processEvents()
time.sleep(0.01)
return self.capturedhtml
def getText(self):
def newTextData(txt):
self.capturedtext = txt
self.capturedtext = None
self.webpage.toPlainText(newTextData)
waitstart = QDateTime.currentDateTime()
while (self.capturedtext is None) and (waitstart.msecsTo(
QDateTime.currentDateTime()) < 1000):
QApplication.processEvents()
time.sleep(0.01)
return self.capturedtext
# https://stackoverflow.com/questions/55231170/taking-a-screenshot-of-a-web-page-in-pyqt5
#screenshots: https://stackoverrun.com/de/q/12970119
def getScreenShot(self, filename):
try:
# Resize
oldSize = self.webview.size()
newSize = self.webpage.contentsSize().toSize()
self.webview.settings().setAttribute(
QWebEngineSettings.ShowScrollBars, False)
self.webview.setAttribute(Qt.WA_DontShowOnScreen, True)
self.webview.resize(newSize)
#self.webview.repaint()
#self.webview.show()
# Wait for resize
waitstart = QDateTime.currentDateTime()
while (waitstart.msecsTo(QDateTime.currentDateTime()) < 500):
QApplication.processEvents()
time.sleep(0.01)
# Capture
pixmap = QPixmap(newSize)
self.webview.render(pixmap, QPoint(0, 0))
pixmap.save(filename, 'PNG')
self.webview.resize(oldSize)
self.webview.setAttribute(Qt.WA_DontShowOnScreen, False)
self.webview.settings().setAttribute(
QWebEngineSettings.ShowScrollBars, True)
self.repaint()
except Exception as e:
self.logMessage.emit(str(e))
return filename
# Get cookie from initial domain
def activateCookieButton(self, handler):
self.newCookie.connect(handler)
self.cookieLabel.textVisible(True)
buttonCookie = QPushButton(self)
buttonCookie.setText("Transfer cookie")
buttonCookie.setDefault(True)
buttonCookie.clicked.connect(self.transferCookieClicked)
self.buttonLayout.addWidget(buttonCookie)
self.addressBar.setVisible(True)
@Slot()
def transferCookieClicked(self):
self.newCookie.emit(self.domain, self.cookie)
@Slot(str, str)
def cookieChanged(self, domain, cookie):
if domain == self.domain:
self.cookie = cookie
self.cookieLabel.setText("Cookie for domain: " + domain + ": " +
cookie)
def __init__(self, *args, **kwargs):
super(WebEnginePage, self).__init__(*args, **kwargs)
def javaScriptConsoleMessage(self, level, message, lineNumber, sourceId):
print("WebEnginePage Console: ", level, message, lineNumber, sourceId)
if __name__ == "__main__":
# Set up the main application
app = QApplication([])
app.setApplicationDisplayName("Greetings from the other side")
# Use a webengine view
view = QWebEngineView()
view.resize(500, 200)
# Set up backend communication via web channel
handler = Handler()
channel = QWebChannel()
# Make the handler object available, naming it "backend"
channel.registerObject("backend", handler)
# Use a custom page that prints console messages to make debugging easier
page = WebEnginePage()
page.setWebChannel(channel)
view.setPage(page)
# Finally, load our file in the view
url = QUrl.fromLocalFile(f"{data_dir}/index.html")
view.load(url)
if args.is_pos:
if args.x_pos < 0:
parser.print_usage()
print('error: --x-pos must be ≥ 0')
sys.exit(1)
if args.y_pos < 0:
parser.print_usage()
print('error: --y-pos must be ≥ 0')
sys.exit(1)
# create view
app = QApplication(sys.argv)
window = QWebEngineView()
# apply args
window.setUrl(args.url)
window.resize(args.width, args.height)
window.setWindowTitle(args.title)
if args.is_pos:
window.move(args.x_pos, args.y_pos)
# show
window.show()
sys.exit(app.exec_())
