class ReportComponent(QGroupBox):
def __init__(self):
super().__init__()
self.setTitle("Rapport d'analyse")
main_layout = QVBoxLayout(self)
self._web_view = QWebEngineView(self)
self._web_view.setContextMenuPolicy(Qt.NoContextMenu)
web_view_container = StylizableWidget()
web_view_container.setObjectName("WebView")
web_view_container.setLayout(QVBoxLayout())
web_view_container.layout().setContentsMargins(1, 1, 1, 1)
web_view_container.layout().addWidget(self._web_view)
main_layout.addWidget(web_view_container)
def reset(self, analysis: Analysis):
if analysis is None:
self._web_view.setHtml("<html></html>", QUrl("qrc:/"))
return
html_report_writer = HTMLReportWriter(analysis)
html = html_report_writer.text()
self._web_view.setHtml(html, QUrl("qrc:/"))
self._web_view.setZoomFactor(1)
def render(html: bytes, filename: str):
page = QWebEngineView()
# printer = QPrinter()
# printer.setOutputFileName('/mnt/data/test.pdf')
page.loadFinished.connect(lambda self: print_pdf(page, filename))
page.setHtml(html, QUrl('file://'))
app.exec_()
def set_analyzed_license_tab(self):
self.remove_analyzed_license_tabs()
parsedWebEngineView = QWebEngineView()
with open("response.html", "r") as response_file:
parsedWebEngineView.setHtml(response_file.read())
self.ui.licenseTabWidget.addTab(parsedWebEngineView,
"Analyzed License")
self.ui.licenseTabWidget.setCurrentIndex(1)
class MainWindow(QMainWindow):
def __init__(self, td: ameritrade.AmeritradeAPI):
super(MainWindow, self).__init__()
self.td = td
self.setWindowTitle('Charting widget')
# A web view for the chart.
# TODO(blais): Replace this by a custom view, not web.
self.webEngineView = QWebEngineView()
# A text input for selection an expression to render.
self.instrumentEdit = QLineEdit()
self.instrumentEdit.returnPressed.connect(self.update_query)
# Layout for main portion of the screen.
layout = QVBoxLayout()
layout.addWidget(self.webEngineView)
layout.addWidget(self.instrumentEdit)
widget = QWidget(self)
widget.setLayout(layout)
self.setCentralWidget(widget)
def update_query(self):
query = self.instrumentEdit.text()
# Handle the case of an empty input.
if not query:
self.webEngineView.setHtml('')
return
# Open the template and make all src references absolute to this
# directory.
with open(template_filename) as template_file:
template = template_file.read()
template = re.sub('src="', f'src="file://{this_dir}/', template)
# Fetch the data.
data = get_pricing_data(self.td, query)
if data is None:
logging.error(f'Failed to retrieve data for "{query}"')
return
template = template.replace("DATA", data)
# Note that the setHtml() method or setContent() do not work as
# expected; loading jQuery or other libraries from within will fail,
# even with the baseUrl provided. I'm resorting to a temporary file for
# this reason.
self.htmlfile = tempfile.NamedTemporaryFile(suffix='.html', mode='w')
self.htmlfile.write(template)
url = "file://{}".format(self.htmlfile.name)
self.webEngineView.load(url)
class PDFReportWriter(HTMLReportWriter):
def __init__(self, analysis: Analysis):
super().__init__(analysis)
self._web_view = QWebEngineView()
def text(self) -> str:
return super().text()
def write(self, filepath: str):
self._web_view.page().loadFinished.connect(
lambda _: self._web_view.page().printToPdf(filepath))
self._web_view.page().pdfPrintingFinished.connect(
lambda fp, success: self.writingCompleted.emit(success))
self._web_view.setHtml(self.text(), QUrl("qrc:/"))
def isAsync(self) -> bool:
return True
class DisplaySVG(QtWidgets.QWidget):
'A simple SVG display.'
def __init__(self, url=None, parent=None):
super().__init__(parent)
self.resize(600, 600)
self.verticalLayout = QtWidgets.QVBoxLayout(self)
self.webview = QWebEngineView(self)
self.verticalLayout.addWidget(self.webview)
self.setWindowTitle('Display SVG')
act = QtWidgets.QAction('Close', self)
act.setShortcuts([QtGui.QKeySequence(QtCore.Qt.Key_Escape)])
act.triggered.connect(self.close)
self.addAction(act)
def display(self, svg):
self.webview.setHtml(svg)
self.show()
class PreviewComponent(QGroupBox):
def __init__(self):
super().__init__()
self.setTitle("Aperçu")
main_layout = QVBoxLayout(self)
self._web_view = QWebEngineView(self)
self._web_view.setContextMenuPolicy(Qt.NoContextMenu)
self._web_view.setZoomFactor(0.4)
web_view_container = StylizableWidget()
web_view_container.setObjectName("WebView")
web_view_container.setLayout(QVBoxLayout())
web_view_container.layout().setContentsMargins(1, 1, 1, 1)
web_view_container.layout().addWidget(self._web_view)
main_layout.addWidget(web_view_container)
@Slot(ReportWriter)
def update(self, report_writer: ReportWriter):
html = report_writer.toHTML()
self._web_view.setHtml(html, QUrl("qrc:/"))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.browser = QWebEngineView()
self.browser.setUrl(QUrl("http://google.com"))
self.setCentralWidget(self.browser)
# tag::navigationSignals[]
self.browser.urlChanged.connect(self.update_urlbar)
self.browser.loadFinished.connect(self.update_title)
# end::navigationSignals[]
# tag::navigation1[]
navtb = QToolBar("Navigation")
navtb.setIconSize(QSize(16, 16))
self.addToolBar(navtb)
back_btn = QAction(QIcon(os.path.join("icons", "arrow-180.png")),
"Back", self)
back_btn.setStatusTip("Back to previous page")
back_btn.triggered.connect(self.browser.back)
navtb.addAction(back_btn)
# end::navigation1[]
# tag::navigation2[]
next_btn = QAction(QIcon(os.path.join("icons", "arrow-000.png")),
"Forward", self)
next_btn.setStatusTip("Forward to next page")
next_btn.triggered.connect(self.browser.forward)
navtb.addAction(next_btn)
reload_btn = QAction(
QIcon(os.path.join("icons", "arrow-circle-315.png")), "Reload",
self)
reload_btn.setStatusTip("Reload page")
reload_btn.triggered.connect(self.browser.reload)
navtb.addAction(reload_btn)
home_btn = QAction(QIcon(os.path.join("icons", "home.png")), "Home",
self)
home_btn.setStatusTip("Go home")
home_btn.triggered.connect(self.navigate_home)
navtb.addAction(home_btn)
# end::navigation2[]
navtb.addSeparator()
# tag::navigation3[]
self.httpsicon = QLabel() # Yes, really!
self.httpsicon.setPixmap(
QPixmap(os.path.join("icons", "lock-nossl.png")))
navtb.addWidget(self.httpsicon)
self.urlbar = QLineEdit()
self.urlbar.returnPressed.connect(self.navigate_to_url)
navtb.addWidget(self.urlbar)
stop_btn = QAction(QIcon(os.path.join("icons", "cross-circle.png")),
"Stop", self)
stop_btn.setStatusTip("Stop loading current page")
stop_btn.triggered.connect(self.browser.stop)
navtb.addAction(stop_btn)
# end::navigation3[]
self.menuBar().setNativeMenuBar(False)
self.statusBar()
# tag::menuFile[]
file_menu = self.menuBar().addMenu("&File")
open_file_action = QAction(
QIcon(os.path.join("icons", "disk--arrow.png")), "Open file...",
self)
open_file_action.setStatusTip("Open from file")
open_file_action.triggered.connect(self.open_file)
file_menu.addAction(open_file_action)
save_file_action = QAction(
QIcon(os.path.join("icons", "disk--pencil.png")),
"Save Page As...", self)
save_file_action.setStatusTip("Save current page to file")
save_file_action.triggered.connect(self.save_file)
file_menu.addAction(save_file_action)
# end::menuFile[]
# tag::menuPrint[]
print_action = QAction(QIcon(os.path.join("icons", "printer.png")),
"Print...", self)
print_action.setStatusTip("Print current page")
print_action.triggered.connect(self.print_page)
file_menu.addAction(print_action)
# Create our system printer instance.
self.printer = QPrinter()
# end::menuPrint[]
# tag::menuHelp[]
help_menu = self.menuBar().addMenu("&Help")
about_action = QAction(
QIcon(os.path.join("icons", "question.png")),
"About Mozzarella Ashbadger",
self,
)
about_action.setStatusTip(
"Find out more about Mozzarella Ashbadger") # Hungry!
about_action.triggered.connect(self.about)
help_menu.addAction(about_action)
navigate_mozzarella_action = QAction(
QIcon(os.path.join("icons", "lifebuoy.png")),
"Mozzarella Ashbadger Homepage",
self,
)
navigate_mozzarella_action.setStatusTip(
"Go to Mozzarella Ashbadger Homepage")
navigate_mozzarella_action.triggered.connect(self.navigate_mozzarella)
help_menu.addAction(navigate_mozzarella_action)
# end::menuHelp[]
self.show()
self.setWindowIcon(QIcon(os.path.join("icons", "ma-icon-64.png")))
# tag::navigationTitle[]
def update_title(self):
title = self.browser.page().title()
self.setWindowTitle("%s - Mozzarella Ashbadger" % title)
# end::navigationTitle[]
# tag::menuHelpfn[]
def navigate_mozzarella(self):
self.browser.setUrl(QUrl("https://www.learnpyqt.com/"))
def about(self):
dlg = AboutDialog()
dlg.exec_()
# end::menuHelpfn[]
# tag::menuFilefnOpen[]
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(
self,
"Open file",
"",
"Hypertext Markup Language (*.htm *.html);;"
"All files (*.*)",
)
if filename:
with open(filename, "r") as f:
html = f.read()
self.browser.setHtml(html)
self.urlbar.setText(filename)
# end::menuFilefnOpen[]
# tag::menuFilefnSave[]
def save_file(self):
filename, _ = QFileDialog.getSaveFileName(
self,
"Save Page As",
"",
"Hypertext Markup Language (*.htm *html);;"
"All files (*.*)",
)
if filename:
# Define callback method to handle the write.
def writer(html):
with open(filename, "w") as f:
f.write(html)
self.browser.page().toHtml(writer)
# end::menuFilefnSave[]
# tag::menuPrintfn[]
def print_page(self):
page = self.browser.page()
def callback(*args):
pass
dlg = QPrintDialog(self.printer)
dlg.accepted.connect(callback)
if dlg.exec_() == QDialog.Accepted:
page.print(self.printer, callback)
# end::menuPrintfn[]
# tag::navigationHome[]
def navigate_home(self):
self.browser.setUrl(QUrl("http://www.google.com"))
# end::navigationHome[]
# tag::navigationURL[]
def navigate_to_url(self): # Does not receive the Url
q = QUrl(self.urlbar.text())
if q.scheme() == "":
q.setScheme("http")
self.browser.setUrl(q)
# end::navigationURL[]
# tag::navigationURLBar[]
def update_urlbar(self, q):
if q.scheme() == "https":
# Secure padlock icon
self.httpsicon.setPixmap(
QPixmap(os.path.join("icons", "lock-ssl.png")))
else:
# Insecure padlock icon
self.httpsicon.setPixmap(
QPixmap(os.path.join("icons", "lock-nossl.png")))
self.urlbar.setText(q.toString())
self.urlbar.setCursorPosition(0)
class TreeViewer(QMainWindow):
"""Phylogeny viewer with toytree"""
def __init__(self):
QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle("Toytree-viewer")
self.setGeometry(QtCore.QRect(200, 200, 800, 600))
self.setMinimumHeight(150)
self.main = QWidget(self)
self.main.setFocus()
self.setCentralWidget(self.main)
self.add_widgets()
self.create_menu(self)
self.tree = None
self.width = 400
self.height = 500
self.colors = {}
self.default_style = {
"layout": 'r',
"edge_type": 'p',
"edge_style": {
"stroke": 'black',
"stroke-width": 2,
},
"tip_labels": True,
"tip_labels_align": True,
"tip_labels_colors": 'black',
"tip_labels_style": {
"font-size": "14px"
},
"node_labels": False,
"node_sizes": 10,
"node_colors": toytree.colors[2],
"node_markers": "c",
"use_edge_lengths": True,
}
self.style = self.default_style.copy()
#self.test_tree(10)
return
def test_tree(self, n=None):
"""Load a test tree"""
if n == None:
n, ok = QInputDialog().getInt(self, "Test tree", "Nodes:", 10)
if not ok:
return
self.set_tree(self.random_tree(n=n))
self.height = 200 + self.tree.ntips * 10
self.update()
return
def random_tree(self, n=12):
"""Make a random tree"""
tre = toytree.rtree.coaltree(n)
## assign random edge lengths and supports to each node
for node in tre.treenode.traverse():
node.dist = np.random.exponential(1)
node.support = int(np.random.uniform(50, 100))
return tre
def save_data(self):
"""Save layers"""
data = tools.get_attributes(self)
data['tree'] = self.tree
return data
def load_data(self, data):
"""Load saved layers"""
try:
self.set_tree(data['tree'])
tools.set_attributes(self, data)
except:
pass
self.update()
return
def create_menu(self, parent):
"""Menu bar"""
self.menubar = self.menuBar()
self.file_menu = QMenu('File', parent)
self.file_menu.addAction('Import Tree', self.load_tree)
self.file_menu.addAction('Load Test Tree', self.test_tree)
self.file_menu.addAction('Show Newick', self.show_newick)
self.file_menu.addAction('Export Image', self.export_image)
self.menubar.addMenu(self.file_menu)
self.tree_menu = QMenu('Tree', parent)
self.tree_menu.addAction('Show Unrooted', self.unroot_tree)
self.tree_menu.addAction('Reset Format', self.reset_style)
self.menubar.addMenu(self.tree_menu)
return
def add_widgets(self):
"""Add widgets"""
vbox = QVBoxLayout(self.main)
self.splitter = QSplitter()
vbox.addWidget(self.splitter)
self.splitter.setOrientation(QtCore.Qt.Vertical)
self.splitter.setSizes([300, 100])
self.splitter.setStretchFactor(1, 0)
#layout.addWidget(self.main)
from PySide2.QtWebEngineWidgets import QWebEngineView
self.browser = QWebEngineView()
self.browser.setMinimumSize(200, 200)
self.splitter.addWidget(self.browser)
toolswidget = QWidget()
self.splitter.addWidget(toolswidget)
l = QVBoxLayout(toolswidget)
self.zoomslider = w = QSlider(QtCore.Qt.Horizontal)
w.setSingleStep(5)
w.setMinimum(5)
w.setMaximum(50)
w.setValue(10)
l.addWidget(w)
w.valueChanged.connect(self.zoom)
btn = QPushButton('Set Format')
l.addWidget(btn)
btn.clicked.connect(self.tree_style_options)
t = self.tipitems = QTreeWidget()
t.setHeaderItem(QTreeWidgetItem(["name", "visible"]))
t.setColumnWidth(0, 200)
t.setSelectionMode(QAbstractItemView.ExtendedSelection)
t.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
t.customContextMenuRequested.connect(self.show_tree_menu)
l.addWidget(t)
return
def show_tree_menu(self, pos):
"""Show right cick tree menu"""
item = self.tipitems.itemAt(pos)
menu = QMenu(self.tipitems)
colorAction = menu.addAction("Set Color")
nodecolorAction = menu.addAction("Set Node Color")
rootAction = menu.addAction("Root On")
dropAction = menu.addAction("Drop Tips")
action = menu.exec_(self.tipitems.mapToGlobal(pos))
if action == rootAction:
self.root_tree()
elif action == colorAction:
self.set_color()
elif action == nodecolorAction:
self.set_color('node')
elif action == dropAction:
self.drop_tips()
def load_tree(self, filename):
options = QFileDialog.Options()
filter = "newick files (*.newick);;All files (*.*)"
filename, _ = QFileDialog.getOpenFileName(self,
"Open tree file",
"",
filter=filter,
selectedFilter=filter,
options=options)
if not filename:
return
self.set_tree(toytree.tree(filename))
return
def set_tree(self, tree):
"""Set a new tree"""
self.tree = tree
self.colors = {}
self.style['tip_labels_colors'] = 'black'
self.tipitems.clear()
for t in self.tree.get_tip_labels():
item = QTreeWidgetItem(self.tipitems)
item.setCheckState(1, QtCore.Qt.Checked)
item.setText(0, t)
return
def update(self):
"""Update the plot"""
if self.tree == None:
return
#set colors
colorlist = [
self.colors[tip] if tip in self.colors else "black"
for tip in self.tree.get_tip_labels()
]
self.style['tip_labels_colors'] = colorlist
canvas, axes, mark = self.tree.draw(width=self.width,
height=self.height,
scalebar=True,
**self.style)
toyplot.html.render(canvas, "temp.html")
with open('temp.html', 'r') as f:
html = f.read()
self.browser.setHtml(html)
self.canvas = canvas
return
def show_newick(self):
txt = self.tree.newick
ed = PlainTextEditor(self, txt)
return
def root_tree(self):
item = self.tipitems.selectedItems()[0]
row = self.tipitems.selectedIndexes()[0].row()
name = item.text(0)
self.tree = self.tree.root(name).ladderize()
self.update()
return
def unroot_tree(self):
self.tree = self.tree.unroot().ladderize()
self.update()
return
def export_image(self):
"""Save tree as image"""
options = QFileDialog.Options()
filter = "png files (*.png);;pdf files (*.pdf);;All files (*.*)"
filename, _ = QFileDialog.getSaveFileName(self,
"Save Project",
"",
filter=filter,
selectedFilter=filter,
options=options)
if not filename:
return
ext = os.path.splitext(filename)
print(ext)
from toyplot import png
png.render(self.canvas, filename, width=(4, "inches"))
return
def zoom(self):
zoom = self.zoomslider.value() / 10
self.browser.setZoomFactor(zoom)
def tree_style_options(self):
fonts = ['%spx' % i for i in range(6, 28)]
markers = ['o', 's', 'd', '^', '>']
nlabels = ['', 'idx', 'support']
tip_labels_style = self.style['tip_labels_style']
opts = {
'layout': {
'type': 'combobox',
'default': self.style['layout'],
'items': ['r', 'd', 'c']
},
'edge_type': {
'type': 'combobox',
'default': self.style['edge_type'],
'items': ['p', 'c']
},
'tip_labels': {
'type': 'checkbox',
'default': self.style['tip_labels']
},
'tip_labels_align': {
'type': 'checkbox',
'default': self.style['tip_labels_align']
},
'node_labels': {
'type': 'combobox',
'default': self.style['node_labels'],
'items': nlabels
},
'node_sizes': {
'type': 'spinbox',
'default': self.style['node_sizes'],
'range': (2, 20),
'interval': 1
},
'node_markers': {
'type': 'combobox',
'default': self.style['node_markers'],
'items': markers
},
'font_size': {
'type': 'combobox',
'default': tip_labels_style['font-size'],
'items': fonts
},
'width': {
'type': 'entry',
'default': self.width
},
'height': {
'type': 'entry',
'default': self.height,
},
}
dlg = MultipleInputDialog(self, opts, title='Tree Style', width=300)
dlg.exec_()
if not dlg.accepted:
return False
kwds = dlg.values
self.set_style(kwds)
self.update()
return
def set_style(self, kwds):
omit = ['width', 'height', 'font_size']
for k in kwds:
if k not in omit:
self.style[k] = kwds[k]
if kwds['node_labels'] == '':
self.style['node_labels'] = False
self.style['tip_labels_style']['font-size'] = kwds['font_size']
self.width = kwds['width']
self.height = kwds['height']
self.tree = self.tree.ladderize()
return
def reset_style(self):
self.style = self.default_style
self.colors = {}
print(self.style)
self.update()
def set_color(self, kind='text'):
items = self.tipitems.selectedItems()
names = [i.text(0) for i in items]
qcolor = QColorDialog.getColor()
for item in items:
item.setBackground(0, qcolor)
for name in names:
if kind == 'text':
self.colors[name] = qcolor.name()
elif kind == 'node':
self.node_colors[name] = qcolor.name()
self.update()
return
def drop_tips(self):
items = self.tipitems.selectedItems()
names = [i.text(0) for i in items]
#for name in names:
self.tree = self.tree.drop_tips(names=names).ladderize()
self.update()
return
print("url changed to: ")
print(qulr)
app = QApplication([])
view = QWebEngineView()
page = view.page()
view.loadStarted.connect(print("loadStarted"))
view.loadProgress.connect(print("loadProgress"))
view.loadFinished.connect(finishLoading)
view.titleChanged.connect(titleChanged)
page.selectionChanged.connect(selectionChanged)
page.linkHovered.connect(linkHovered)
page.urlChanged.connect(urlChanged)
# content in unicode html format - Content larger than 2 MB cannot be displayed
html = "<h1>Heading</h1><p>paragraph</p><p><a href=\"https://marvel.bible\"><img src='marvel.png' alt='Marvel.Bible icon'></a></p>"
# External objects, such as stylesheets or images referenced in the HTML document, are located RELATIVE TO baseUrl .
# e.g. put all local files linked by html's content in folder "htmlResources"
relativePath = os.path.join("htmlResources", "marvel.png")
absolutePath = os.path.abspath(relativePath)
baseUrl = QUrl.fromLocalFile(absolutePath)
view.setHtml(html, baseUrl)
view.show()
app.exec_()
class AssistantWidget(QtWidgets.QWidget):
msg_signal = Signal(str)
hidden = False
last_position = QPoint(0, 0)
current_answer = 0
answers = []
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(
self, parent, Qt.FramelessWindowHint | Qt.WindowSystemMenuHint
| Qt.WindowStaysOnTopHint)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.runner = KeyloggerRunner()
self.runner.start_running(self.msg_signal)
self.msg_signal.connect(self.get_events)
self.webview = QWebEngineView()
self.webview.setAttribute(Qt.WA_StyledBackground)
self.webview.setStyleSheet("border: 1px solid black;")
self.webview.setContentsMargins(1, 1, 1, 1)
self.search_image = QtGui.QPixmap('dialog-search2.png')
self.search_label = QtWidgets.QLabel()
self.search_legend = QtWidgets.QLabel(text="¿Qué quieres saber?",
parent=self.search_label)
self.search_label.setPixmap(self.search_image)
self.text_input = QtWidgets.QLineEdit(self.search_label)
self.search_label.window().setStyleSheet("QLineEdit { border: none }")
self.search_label.move(0, 0)
self.search_legend.move(34, 120)
self.text_input.move(34, 145)
self.clear_button = QtWidgets.QPushButton("x")
self.progress = QtWidgets.QLabel()
movie = QtGui.QMovie("progress.gif")
self.progress.setMovie(movie)
movie.start()
self.previous_button = QtWidgets.QPushButton()
self.previous_button.setIcon(QtGui.QIcon('left.png'))
self.next_button = QtWidgets.QPushButton()
self.next_button.setIcon(QtGui.QIcon('right.png'))
self.logo = QtGui.QPixmap('stacko.png')
self.logo_label = QtWidgets.QLabel()
self.logo_label.setPixmap(self.logo)
self.build_layout()
self.clear_button.clicked.connect(self.clear_search)
self.text_input.returnPressed.connect(self.find_answers)
self.previous_button.clicked.connect(self.show_previous_answer)
self.next_button.clicked.connect(self.show_next_answer)
self.api = StackOverflowApi()
self.answers_runner = BackgroundRunner()
self.answers_runner.msg_signal.connect(self.answers_loaded)
def build_layout(self):
self.parent_layout = QtWidgets.QHBoxLayout()
self.parent_layout.addLayout(self.build_left_side())
self.parent_layout.addLayout(self.build_right_side())
self.setLayout(self.parent_layout)
def build_left_side(self):
layout = QtWidgets.QVBoxLayout()
layout.addWidget(self.logo_label)
return layout
def build_right_side(self):
layout = QtWidgets.QVBoxLayout()
layout.addWidget(self.search_label)
layout.addWidget(self.progress)
self.progress.setVisible(False)
buttons_layout = QtWidgets.QHBoxLayout()
layout.addLayout(buttons_layout)
buttons_layout.addWidget(self.clear_button)
self.clear_button.setVisible(False)
buttons_layout.addWidget(self.previous_button)
self.previous_button.setVisible(False)
buttons_layout.addWidget(self.next_button)
self.next_button.setVisible(False)
self.webview.setVisible(False)
layout.addWidget(self.webview)
return layout
@Slot(str)
def get_events(self, event):
callback = getattr(self, f'event_{event}_callback',
self.unknown_event_callback)
callback(event=event)
@Slot(str)
def answers_loaded(self, answers_json):
answers = json.loads(answers_json)
self.answers = answers
print(self.answers)
self.current_answer = 0
self.previous_button.setVisible(True)
self.previous_button.setEnabled(False)
self.next_button.setVisible(True)
if len(self.answers) > 1:
self.next_button.setEnabled(True)
self.clear_button.setVisible(True)
self.search_label.setVisible(False)
self.progress.setVisible(False)
self.webview.setWindowOpacity(80)
self.webview.setVisible(True)
self.webview.setHtml(self.answers[self.current_answer]['content'])
def event_invoke_callback(self, **kwargs):
if self.hidden:
self.show()
self.move(self.last_position.x(), self.last_position.y())
self.hidden = False
else:
self.last_position = self.pos()
self.hide()
self.hidden = True
def event_quit_callback(self, **kwargs):
QCoreApplication.quit()
def unknown_event_callback(self, event):
print(f'Unknown event {event}')
def clear_search(self):
self.current_answer = 0
self.answers = []
self.previous_button.setVisible(False)
self.next_button.setVisible(False)
self.clear_button.setVisible(False)
self.text_input.clear()
self.search_label.setVisible(True)
self.search_label.move(0, 0)
self.search_legend.move(34, 120)
self.text_input.move(34, 145)
self.text_input.setVisible(True)
self.webview.setVisible(False)
def find_answers(self):
self.search_label.setVisible(False)
self.progress.setVisible(True)
self.answers_runner.stop_jobs()
self.answers_runner.start_jobs(self.api.get_answers,
args=(self.text_input.text(), ))
def mousePressEvent(self, event):
self.last_position = event.pos()
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
diff = event.pos() - self.last_position
newpos = self.pos() + diff
self.move(newpos)
def show_previous_answer(self):
if len(self.answers) > 0 and 0 <= self.current_answer - 1 < len(
self.answers):
self.current_answer = self.current_answer - 1
self.webview.setHtml(self.answers[self.current_answer]['content'])
if self.current_answer == 0:
self.previous_button.setEnabled(False)
if not self.next_button.isEnabled():
self.next_button.setEnabled(True)
def show_next_answer(self):
if len(self.answers) > 0 and 0 <= self.current_answer + 1 < len(
self.answers):
self.current_answer = self.current_answer + 1
self.webview.setHtml(self.answers[self.current_answer]['content'])
if self.current_answer == len(self.answers) - 1:
self.next_button.setEnabled(False)
if not self.previous_button.isEnabled():
self.previous_button.setEnabled(True)
class NotebookEditorWidget(QWidget):
"""The NotebookEditorWidget class provides an interface for visualizing the graph as
a Jupyter Notebook, HTML rendered."""
def __init__(
self,
notebook_generator: "NotebookProjectGenerator",
project_manager: "ProjectManagerGUI",
parent: "QWidget" = None,
):
super().__init__(parent)
# Components
self._project_manager = project_manager
self._notebook_generator = notebook_generator
self._project_manager.active_project_changed.connect(self._set_active_project)
# Widgets
self._text_browser = QWebEngineView()
self._text_browser.show()
self._generate_notebook_button = QPushButton("Generate Notebook")
self._generate_notebook_button.clicked.connect(self._generate_html)
# Layout
self._main_layout = QVBoxLayout()
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.addWidget(self._text_browser)
self._main_layout.addWidget(self._generate_notebook_button)
self.setLayout(self._main_layout)
# Set active project and generate notebook
self._set_active_project(self._project_manager.active)
def _set_active_project(self, project: "ProjectGUI"):
"""Sets a new active project for this notebook generator."""
if project is not self._notebook_generator.get_project():
self._notebook_generator.set_project(project)
self._generate_html()
def _generate_html(self):
"""Fills the html viewer with the jupyter notebook html."""
self._notebook_generator.update_project_changes()
notebook = self._notebook_generator.notebook
html_exporter = HTMLExporter()
(body, resources) = html_exporter.from_notebook_node(notebook)
html_content = (
f'<html><style type="text/css">{resources["inlining"]["css"][0]}'
f"</style><body>{body}</body></html>"
)
with open("file.html", "w") as html_file:
html_file.write(html_content)
self._notebook_generator.save_notebook_as("nb.ipynb")
self._text_browser.setHtml(html_content)
iHost["ip"],
iHost["mac"],
get_hostname(iHost["ip"]))
query += "');"
web.page().runJavaScript(query)
def loadfinished(aIsOk):
#load jQuery stuff
with open("extern/jquery-min.js", "r") as jqFile:
content = jqFile.read()
content += "\nvar qt = { 'jQuery': jQuery.noConflict(true) };"
web.page().runJavaScript(content)
fill_web_table()
web.page().runJavaScript("qt.jQuery('#content_table tr:last').after('<tr><td>bla2a</td></tr>');")
if __name__ == '__main__':
# Create the Qt Application
app = QApplication(sys.argv)
web = QWebEngineView()
web.setHtml(WEBVIEW_CONTENT_SKELETON)
web.loadFinished.connect(loadfinished)
# Run the main Qt loop
web.show()
sys.exit(app.exec_())
if __name__ == '__main__':
print(__version_info__)
# Create the Qt Application
app = QApplication(sys.argv)
#load all javascript libraries
with open("extern/jquery-min.js",
"r") as jqFile, open("extern/qwebchannel.js") as qwFile:
content = "\n" + jqFile.read()
#content += "\n" + qwFile.read()
content += "\n" + "var qt = { 'jQuery': jQuery.noConflict(true) };"
WEBVIEW_CONTENT_SKELETON = WEBVIEW_CONTENT_SKELETON.replace(
" __replace_this_with_all_javascript_library_stuff__", content)
#socket_server = QWebSocketServer("QWebSocketServer workaround server", QWebSocketServer.NonSecureMode)##
#if not socket_server.listen(QHostAddress.LocalHost, 12345):
# raise Exception("uh cannot create socket server")
web_page = MyWebPage()
web = QWebEngineView()
web.setPage(web_page)
web.setHtml(WEBVIEW_CONTENT_SKELETON)
web.loadFinished.connect(loadfinished)
# Run the main Qt loop
web.show()
sys.exit(app.exec_())
class JobInfoPanel(QWidget):
def __init__(self):
super().__init__()
self.setStyleSheet(Style.INFO_PANEL.value)
self.__create_title()
self.__create_description_groupbox()
self.__create_res_req_groupbox()
self.__create_contact_groupbox()
main_layout = QVBoxLayout()
main_layout.addWidget(self.title)
main_layout.addWidget(self.horizontal_groupbox)
main_layout.addLayout(self.restrictions_layout)
main_layout.addLayout(self.contact_layout)
self.setLayout(main_layout)
def __create_title(self):
self.title = QLabel()
self.title.setAlignment(Qt.AlignCenter)
font = QFont()
font.setPixelSize(17)
self.title.setFont(font)
self.title.setStyleSheet(
'padding: 12px; border: 1px solid #212121; border-radius: 10px;')
def __create_description_groupbox(self):
self.horizontal_groupbox = QGroupBox('Description:')
self.description = QTextEdit()
self.description.setReadOnly(True)
layout = QHBoxLayout()
layout.addWidget(self.description, Style.TWO_THIRDS.value)
window = QWidget()
window.setMinimumSize(320, 625)
self.web = QWebEngineView(window)
self.web.setHtml(self.generate_html_map(0, 0))
self.webpage = self.web.page()
layout.addWidget(self.web, Style.ONE_THIRD.value)
self.horizontal_groupbox.setLayout(layout)
def generate_html_map(self, lat, lng):
initialize = (
"var earth; var marker; var zoomLevel = 3.5;"
"function initialize() {"
" var options={zoom: zoomLevel, position: [" + str(lat) + "," +
str(lng) + "]};"
" earth = new WE.map('earth_div', options);"
" WE.tileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(earth);"
f" add_marker({lat}, {lng})"
"}"
"function rm_marker() {marker.removeFrom(earth)}"
"function add_marker(lat,lng) {"
" try {rm_marker()} catch(e) {}"
" marker = WE.marker([lat,lng]).addTo(earth);"
" earth.setView([lat,lng], zoomLevel);}")
style = '''
html, body {
padding: 0;
margin: 0;
}
#earth_div {
top: 0;
right: 0;
bottom: 0;
left: 0;
position: absolute !important;
}
'''
return f'''
<!DOCTYPE HTML>
<html>
<head>
<script src="http://www.webglearth.com/v2/api.js"></script>
<script>{initialize}</script>
<style>{style}</style>
</head>
<body onload="initialize()">
<div id="earth_div"></div>
</body>
</html>
'''
def __create_res_req_groupbox(self):
hbox = QHBoxLayout()
restrictions_group = QGroupBox('Restrictions:')
self.restrictions = QTextEdit()
self.restrictions.setReadOnly(True)
hbox.addWidget(self.restrictions)
restrictions_group.setLayout(hbox)
hbox = QHBoxLayout()
requirements_group = QGroupBox('Requirements:')
self.requirements = QTextEdit()
self.requirements.setReadOnly(True)
hbox.addWidget(self.requirements)
requirements_group.setLayout(hbox)
self.restrictions_layout = QHBoxLayout()
self.restrictions_layout.addWidget(requirements_group,
Style.TWO_THIRDS.value)
self.restrictions_layout.addWidget(restrictions_group,
Style.ONE_THIRD.value)
def __create_contact_groupbox(self):
hbox = QHBoxLayout()
about_group = QGroupBox('About:')
self.about = QTextEdit()
self.about.setReadOnly(True)
hbox.addWidget(self.about)
about_group.setLayout(hbox)
layout = QFormLayout()
contact_group = QGroupBox('Contact Info')
self.contact_name = QLabel()
self.contact_email = QLabel()
self.contact_website = QPushButton('Apply')
self.contact_website.clicked.connect(
lambda: webbrowser.open(self.apply_website))
layout.addRow(QLabel('Contact:'), self.contact_name)
layout.addRow(QLabel('Email:'), self.contact_email)
layout.addRow(QLabel('Website:'), self.contact_website)
contact_group.setLayout(layout)
self.contact_layout = QHBoxLayout()
self.contact_layout.addWidget(about_group, Style.TWO_THIRDS.value)
self.contact_layout.addWidget(contact_group, Style.ONE_THIRD.value)
def set_contact_info(self, contact: str, email: str, website: str,
company: str):
self.contact_name.setText(contact)
self.contact_email.setText(email)
self.apply_website = website
if self.apply_website is None:
self.apply_website = f'https://duckduckgo.com/?q={company}&t=ffab&ia=web'
class QDataViewer(QWidget):
def __init__(self):
QWidget.__init__(self)
# Layout Init.
self.language = 'ud'
if len(sys.argv)>1:
self.language = sys.argv[1]
self.setGeometry(650, 300, 600, 600)
self.setWindowTitle('Data Viewer')
self.uploadButton = QPushButton('Load Conll File', self)
self.sentence_id = 0
self.column_number = 10
self.columns = ["ID", "FORM", "LEMMA", "UPOS", "XPOS", "FEATS", "HEAD", "DEPREL", "DEPS", "MISC"]
self.current_dict = {}
self.load_finished = True
self.first_time = True
self.session_start = True
self.map_col = {0:"ID", 1:"FORM", 2:"LEMMA", 3:"UPOS", 4:"XPOS", 5:"FEATS", 6:"HEAD", 7:"DEPREL", 8:"DEPS", 9:"MISC", 10:"Abbr", 11:"Animacy", 12:"Aspect", 13:"Case",
14:"Clusivity", 15:"Definite", 16:"Degree", 17:"Echo", 18:"Evident", 19:"Foreign", 20:"Gender", 21:"Mood", 22:"NounClass", 23:"Number", 24:"Number[psor]",
25:"NumType", 26:"Person", 27:"Person[psor]", 28:"Polarity", 29:"Polite", 30:"Poss", 31:"PronType", 32:"Reflex", 33:"Register", 34:"Tense", 35:"VerbForm",
36:"Voice"}
self.doc = None
self.vBoxLayout = QVBoxLayout()
self.vBoxLayout.addWidget(self.uploadButton)
self.setLayout(self.vBoxLayout)
# Signal Init.
self.connect(self.uploadButton, QtCore.SIGNAL('clicked()'), self.open)
def open(self):
filename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0]
self.notename = "notes-"+filename.split("/")[-1].split(".")[0]+".txt"
self.uploadButton.hide()
print(filename)
self.doc = Doc(filename)
if not os.path.exists(self.notename):
open(self.notename, "w").close()
self.construct()
def writeNotes(self):
if self.qTextEdit2.toPlainText() != "Write your note here...":
if self.qTextEdit2.toPlainText() == "":
if str(self.sentence_id) in self.noteDictionary:
del self.noteDictionary[str(self.sentence_id)]
else:
self.noteDictionary[str(self.sentence_id)] = self.qTextEdit2.toPlainText().rstrip().replace("\r\n", " ").replace("\n", " ").replace("\r", " ")
noteTxt = open(self.notename, "w")
for noteKey in sorted(self.noteDictionary.keys()):
noteTxt.write(noteKey+" --- "+self.noteDictionary[noteKey]+"\n")
noteTxt.close()
def go_prev(self):
self.first_time = True
self.writeNotes()
if self.sentence_id>0:
self.sentence_id-=1
self.update_table()
self.session_start = True
self.update_html()
self.check_errors()
self.qTextEdit.setText(str(self.sentence_id))
self.first_time = False
def go_next(self):
self.first_time = True
self.writeNotes()
if self.sentence_id<len(self.doc.sentences)-1:
self.sentence_id+=1
self.update_table()
self.session_start = True
self.update_html()
self.check_errors()
self.qTextEdit.setText(str(self.sentence_id))
self.first_time = False
def go(self):
self.doc.write()
self.first_time = True
self.writeNotes()
try:
self.sentence_id = int(self.qTextEdit.toPlainText())
self.update_table()
self.session_start = True
self.update_html()
self.check_errors()
except Exception as e:
print(e)
self.qTextEdit.setText(str(self.sentence_id))
self.first_time = False
def reset(self):
if not self.first_time:
self.first_time = True
self.sentence = copy.deepcopy(self.sentence_backup)
self.doc.sentences[self.sentence_id] = copy.deepcopy(self.sentence_backup)
self.session_start = True
self.doc.write()
self.update_table()
self.update_html()
self.check_errors()
self.first_time = False
def construct(self):
self.hBoxLayout = QHBoxLayout()
self.prevButton = QPushButton("Prev", self)
self.prevButton.setShortcut("Alt+O")
self.resetButton = QPushButton("Reset", self)
self.resetButton.setShortcut("Alt+R")
self.qTextEditAddRow = QTextEdit()
self.qTextEditAddRow.setFixedHeight(20)
self.qTextEditAddRow.setFixedWidth(60)
self.qTextEditDeleteRow = QTextEdit()
self.qTextEditDeleteRow.setFixedHeight(20)
self.qTextEditDeleteRow.setFixedWidth(60)
self.qTextEdit = QTextEdit()
self.qTextEdit.setFixedHeight(20)
self.qTextEdit.setFixedWidth(60)
self.qTextEdit2 = QTextEdit()
self.qTextEdit2.setFixedHeight(20)
self.qTextEdit2.setFixedWidth(500)
self.shortcutText=QShortcut(QtGui.QKeySequence("Alt+M"), self)
self.shortcutText.activated.connect(self.qTextEdit2.setFocus)
self.goButton = QPushButton("Go", self)
self.goButton.setShortcut("Alt+G")
self.nextButton = QPushButton("Next", self)
self.nextButton.setShortcut("Alt+P")
self.addRowButton = QPushButton("Add Row", self)
self.deleteRowButton = QPushButton("Delete Row", self)
self.hBoxLayout.addWidget(self.prevButton)
self.hBoxLayout.addStretch()
self.hBoxLayout.addWidget(self.resetButton)
self.hBoxLayout.addStretch()
self.hBoxLayout.addWidget(self.qTextEditAddRow)
self.hBoxLayout.addWidget(self.addRowButton)
self.hBoxLayout.addStretch()
self.hBoxLayout.addWidget(self.qTextEditDeleteRow)
self.hBoxLayout.addWidget(self.deleteRowButton)
self.hBoxLayout.addStretch()
self.hBoxLayout.addWidget(self.qTextEdit)
self.hBoxLayout.addWidget(self.goButton)
self.hBoxLayout.addStretch()
self.hBoxLayout.addWidget(self.qTextEdit2)
self.hBoxLayout.addStretch()
self.hBoxLayout.addWidget(self.nextButton)
self.vBoxLayout.addLayout(self.hBoxLayout)
self.chBoxLayout = QHBoxLayout()
self.chBoxLayout.addStretch()
cb_ids = ["ID", "FORM", "LEMMA", "UPOS", "XPOS", "FEATS", "HEAD", "DEPREL", "DEPS", "MISC"]
cb_ids2 = ["Abbr", "Animacy", "Aspect", "Case", "Clusivity", "Definite", "Degree", "Echo", "Evident", "Foreign", "Gender", "Mood", "NounClass", "Number"]
cb_ids3 = ["Number[psor]", "NumType", "Person", "Person[psor]", "Polarity", "Polite", "Poss", "PronType", "Reflex", "Register", "Tense", "VerbForm", "Voice"]
for cb_id in cb_ids:
cb = QCheckBox(cb_id)
cb.setChecked(True)
cb.stateChanged.connect(self.cb_change)
self.chBoxLayout.addWidget(cb)
self.chBoxLayout.addStretch()
self.vBoxLayout.addLayout(self.chBoxLayout)
self.chBoxLayout_2 = QHBoxLayout()
self.chBoxLayout_2.addStretch()
for cb_id in cb_ids2:
cb = QCheckBox(cb_id)
cb.setChecked(False)
cb.stateChanged.connect(self.cb_change)
self.chBoxLayout_2.addWidget(cb)
self.chBoxLayout_2.addStretch()
self.vBoxLayout.addLayout(self.chBoxLayout_2)
self.chBoxLayout_3 = QHBoxLayout()
self.chBoxLayout_3.addStretch()
for cb_id in cb_ids3:
cb = QCheckBox(cb_id)
cb.setChecked(False)
cb.stateChanged.connect(self.cb_change)
self.chBoxLayout_3.addWidget(cb)
self.chBoxLayout_3.addStretch()
self.vBoxLayout.addLayout(self.chBoxLayout_3)
self.qTextEdit.setText(str(self.sentence_id))
self.noteDictionary = {}
noteFile = open(self.notename, "r")
for note in noteFile:
noteSplitted = note.split(" --- ")
noteID = noteSplitted[0]
noteContent = noteSplitted[1].rstrip()
self.noteDictionary[noteID] = noteContent
noteFile.close()
self.connect(self.prevButton, QtCore.SIGNAL('clicked()'), self.go_prev)
self.connect(self.resetButton, QtCore.SIGNAL('clicked()'), self.reset)
self.connect(self.goButton, QtCore.SIGNAL('clicked()'), self.go)
self.connect(self.nextButton, QtCore.SIGNAL('clicked()'), self.go_next)
self.connect(self.addRowButton, QtCore.SIGNAL('clicked()'), self.add_row)
self.connect(self.deleteRowButton, QtCore.SIGNAL('clicked()'), self.delete_row)
# create table here
self.tableWidget = QTableWidget(self)
self.tableWidget.itemChanged.connect(self.handle_change)
self.connect(self.tableWidget.verticalHeader(), QtCore.SIGNAL("sectionClicked(int)"), self.agg)
self.qTextEditError = QTextEdit()
self.qTextEditError.setReadOnly(True)
self.splitter = QSplitter(Qt.Vertical)
self.splitter.addWidget(self.tableWidget)
self.splitter.addWidget(self.qTextEditError)
self.vBoxLayout.addWidget(self.splitter)
self.webView = QWebEngineView()
self.update_table()
self.update_html()
self.check_errors()
self.splitter2 = QSplitter(Qt.Vertical)
self.splitter2.addWidget(self.splitter)
self.splitter2.addWidget(self.webView)
self.vBoxLayout.addWidget(self.splitter2)
self.webView.loadFinished.connect(self.finito)
self.first_time = False
def finito(self):
self.load_finished = True
def add_row(self):
if "-" not in self.qTextEditAddRow.toPlainText():
word_id = int(self.qTextEditAddRow.toPlainText())
possible_move = True
new_sentence_words = []
for word in self.sentence.words:
if word.unitword:
x1 = int(word.id.split("-")[0])
x2 = int(word.id.split("-")[1])
if word_id == x1 or word_id == x2:
possible_move = False
if possible_move:
for word in self.sentence.words:
new_word = copy.deepcopy(word)
if new_word.head != "_" and int(new_word.head) >= word_id:
new_word.head = str(int(new_word.head) + 1)
if new_word.unitword:
new_word_id = int(new_word.id.split("-")[0])
else:
new_word_id = int(new_word.id)
if new_word_id < word_id:
new_sentence_words.append(new_word)
elif new_word_id == word_id:
if new_word.unitword:
x1 = int(new_word.id.split("-")[0])
x2 = int(new_word.id.split("-")[1])
w = Word("\t".join(
[str(x1), new_word.form, "_", "_", "_", "_", new_word.head, "_", "_", "_"]), self.sentence.sent_address)
new_word.id = str(x1 + 1) + "-" + str(x2 + 1)
else:
w = Word("\t".join(
[new_word.id, new_word.form, "_", "_", "_", "_", new_word.head, "_", "_", "_"]), self.sentence.sent_address)
new_word.id = str(int(new_word.id) + 1)
new_sentence_words.append(w)
new_sentence_words.append(new_word)
elif new_word_id > word_id:
if new_word.unitword:
x1 = int(new_word.id.split("-")[0])
x2 = int(new_word.id.split("-")[1])
new_word.id = str(x1 + 1) + "-" + str(x2 + 1)
else:
new_word.id = str(int(new_word.id) + 1)
new_sentence_words.append(new_word)
self.sentence.words = copy.deepcopy(new_sentence_words)
self.first_time = True
self.update_table()
self.update_html()
self.first_time = False
def delete_row(self):
if "-" not in self.qTextEditDeleteRow.toPlainText():
word_id = int(self.qTextEditDeleteRow.toPlainText())
possible_move = True
new_sentence_words = []
for word in self.sentence.words:
if word.unitword:
x1 = int(word.id.split("-")[0])
x2 = int(word.id.split("-")[1])
if word_id == x1 or word_id == x2:
possible_move = False
if not word.head == "_":
if int(word.head) == word_id:
possible_move = False
if possible_move:
for word in self.sentence.words:
new_word = copy.deepcopy(word)
if new_word.head != "_" and int(new_word.head) >= word_id:
new_word.head = str(int(new_word.head) - 1)
if new_word.unitword:
new_word_id = int(new_word.id.split("-")[0])
else:
new_word_id = int(new_word.id)
if new_word_id < word_id:
new_sentence_words.append(new_word)
elif new_word_id > word_id:
if new_word.unitword:
x1 = int(new_word.id.split("-")[0])
x2 = int(new_word.id.split("-")[1])
new_word.id = str(x1 - 1) + "-" + str(x2 - 1)
else:
new_word.id = str(int(new_word.id) - 1)
new_sentence_words.append(new_word)
self.sentence.words = copy.deepcopy(new_sentence_words)
self.first_time = True
self.update_table()
self.update_html()
self.first_time = False
def agg(self, x):
if self.sentence.words[x].unitword:#remove two-words thing into one
limit = int(self.sentence.words[x].id.split("-")[0])
self.sentence.words[x].head = self.sentence.words[x+1].head
self.sentence.words[x].lemma = self.sentence.words[x+1].lemma
self.sentence.words[x].upos = self.sentence.words[x+1].upos
self.sentence.words[x].xpos = self.sentence.words[x+1].xpos
self.sentence.words[x].feats = self.sentence.words[x+1].feats
self.sentence.words[x].deprel = self.sentence.words[x+1].deprel
self.sentence.words[x].deps = self.sentence.words[x+1].deps
self.sentence.words[x].misc = self.sentence.words[x+1].misc
self.sentence.words[x].id = str(limit)
self.sentence.words[x].unitword = False
del self.sentence.words[x+1]
del self.sentence.words[x+1]
for word in self.sentence.words:
if word.unitword:
first_word_id = int(word.id.split("-")[0])
if first_word_id>limit:
word.id = str(first_word_id-1)+"-"+str(first_word_id)
else:
if int(word.id) > limit:
word.id = str(int(word.id)-1)
if word.head != "_" and int(word.head) > limit:
word.head = str(int(word.head)-1)
self.first_time = True
self.update_table()
self.update_html()
self.first_time = False
else:#add two-elements below
base_word = self.sentence.words[x]
limit = int(base_word.id)
for word in self.sentence.words:
if word.unitword:
first_word_id = int(word.id.split("-")[0])
if first_word_id>limit:
word.id = str(first_word_id+1)+"-"+str(first_word_id+2)
else:
if int(word.id) > limit:
word.id = str(int(word.id)+1)
if word.head != "_" and int(word.head) > limit:
word.head = str(int(word.head)+1)
w1 = Word("\t".join([str(limit), base_word.form, base_word.lemma, base_word.upos, base_word.xpos, base_word.feats, base_word.head, base_word.deprel, base_word.deps, "_"]), self.sentence.sent_address)
w2 = Word("\t".join([str(limit+1), base_word.form, base_word.lemma, base_word.upos, base_word.xpos, base_word.feats, str(limit), base_word.deprel, base_word.deps, "_"]), self.sentence.sent_address)
self.sentence.words = self.sentence.words[:x+1]+[w1, w2]+self.sentence.words[x+1:]
base_word.id = str(limit)+"-"+str(limit+1)
base_word.lemma = "_"
base_word.upos = "_"
base_word.xpos = "_"
base_word.feats = "_"
base_word.head = "_"
base_word.deprel = "_"
base_word.deps = "_"
base_word.unitword = True
self.first_time = True
self.update_table()
self.update_html()
self.first_time = False
def update_table(self):
if str(self.sentence_id) in self.noteDictionary:
self.qTextEdit2.setText(self.noteDictionary[str(self.sentence_id)])
else:
self.qTextEdit2.setText("Write your note here...")
self.sentence = self.doc.sentences[self.sentence_id]
self.tableWidget.setRowCount(len(self.sentence.words))
self.tableWidget.setColumnCount(self.column_number)
self.tableWidget.setHorizontalHeaderLabels(self.columns)
for enum, word in enumerate(self.sentence.words):
if word.unitword:
self.tableWidget.setVerticalHeaderItem(enum, QTableWidgetItem("-"))
else:
self.tableWidget.setVerticalHeaderItem(enum, QTableWidgetItem("+"))
dict_feat = {}
uni_feats = re.split('\|', word.feats)
if uni_feats[0] != "_":
for uni_feat in uni_feats:
uf = re.split('\=', uni_feat)
dict_feat[uf[0]]=uf[1]
for i in range(self.column_number):
if self.columns[i]=="ID":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.id))
elif self.columns[i]=="FORM":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.form))
elif self.columns[i]=="LEMMA":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.lemma))
elif self.columns[i]=="UPOS":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.upos))
elif self.columns[i]=="XPOS":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.xpos))
elif self.columns[i]=="FEATS":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.feats))
elif self.columns[i]=="HEAD":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.head))
elif self.columns[i]=="DEPREL":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.deprel))
elif self.columns[i]=="DEPS":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.deps))
elif self.columns[i]=="MISC":
self.tableWidget.setItem(enum, i, QTableWidgetItem(word.misc))
else:
if self.columns[i] in dict_feat:
self.tableWidget.setItem(enum, i, QTableWidgetItem(dict_feat[self.columns[i]]))
else:
self.tableWidget.setItem(enum, i, QTableWidgetItem("_"))
self.tableWidget.resizeColumnsToContents()
def check_errors(self):
index = ""
for w in self.sentence.words:
index += w.form + "(" + w.id + ") "
index += "\n"
error_list = get_errors(self.sentence.get_raw(), self.sentence.sent_id, self.language)
if len(error_list)>0:
error_raw_string = 'ERRORS:\n'
for error in error_list:
error_raw_string+=error+'\n'
self.qTextEditError.setText(index + error_raw_string)
else:
self.qTextEditError.setText(index)
def update_html(self):
if not self.load_finished: #If the js function not loaded an image onto app it removes browser
print("Load error!")
self.splitter2.deleteLater()
self.webView = QWebEngineView()
self.splitter2 = QSplitter(Qt.Vertical)
self.splitter2.addWidget(self.splitter)
self.splitter2.addWidget(self.webView)
self.vBoxLayout.addWidget(self.splitter2)
self.webView.loadFinished.connect(self.finito)
self.sentence = self.doc.sentences[self.sentence_id]
if self.session_start:
self.sentence_backup = copy.deepcopy(self.doc.sentences[self.sentence_id])
self.session_start = False
html = process_document(self.sentence)
self.webView.setHtml(html)
self.load_finished = False
def cb_change(self):
self.column_number = 0
self.columns = []
self.map_col = {}
x = 0
for i in range(self.chBoxLayout.count()):
if isinstance(self.chBoxLayout.itemAt(i), QWidgetItem):
wid = self.chBoxLayout.itemAt(i).widget()
if wid.isChecked():
self.columns.append(wid.text())
self.column_number += 1
self.map_col[x] = wid.text()
x+=1
for i in range(self.chBoxLayout_2.count()):
if isinstance(self.chBoxLayout_2.itemAt(i), QWidgetItem):
wid = self.chBoxLayout_2.itemAt(i).widget()
if wid.isChecked():
self.columns.append(wid.text())
self.column_number += 1
self.map_col[x] = wid.text()
x+=1
for i in range(self.chBoxLayout_3.count()):
if isinstance(self.chBoxLayout_3.itemAt(i), QWidgetItem):
wid = self.chBoxLayout_3.itemAt(i).widget()
if wid.isChecked():
self.columns.append(wid.text())
self.column_number += 1
self.map_col[x] = wid.text()
x+=1
self.first_time = True
self.update_table()
self.first_time = False
def handle_change(self, item):
col = self.map_col[item.column()]
text = item.text()
#print(text)
isSpace = False
if text == "":
if col!="ID" and col!="FORM" and col!="LEMMA" and col!="UPOS" and col!="XPOS" and col!="HEAD" and col!="DEPREL" and col!="DEPS" and col!="MISC":
isSpace = True
text = "_"
row = item.row()
self.sentence = self.doc.sentences[self.sentence_id]
if col=="ID":
self.sentence.words[row].id = text
elif col=="FORM":
self.sentence.words[row].form = text
elif col=="LEMMA":
self.sentence.words[row].lemma = text
elif col=="UPOS":
self.sentence.words[row].upos = text.upper()
elif col=="XPOS":
self.sentence.words[row].xpos = text
elif col=="FEATS":
self.sentence.words[row].feats = text
elif col=="HEAD":
self.sentence.words[row].head = text
elif col=="DEPREL":
self.sentence.words[row].deprel = text
elif col=="DEPS":
self.sentence.words[row].deps = text
elif col=="MISC":
self.sentence.words[row].misc = text
else:
cur_col = col
if col=="Number[psor]":
cur_col = "Number\[psor\]"
if col=="Person[psor]":
cur_col = "Person\[psor\]"
if re.search(cur_col+'=\w*', self.sentence.words[row].feats) is None:
if text!="_":
if self.sentence.words[row].feats=="_":
self.sentence.words[row].feats = col+"="+text
else:
sorted_feats = re.split('\|', self.sentence.words[row].feats)
match_col=""
match_val=""
for sorted_feat in sorted_feats:
sf = re.split('\=', sorted_feat)
if sf[0].lower()<col.lower():
match_col = sf[0]
match_val = sf[1]
if match_col=="":
self.sentence.words[row].feats = col+"="+text+"|"+self.sentence.words[row].feats
else:
cur_match_col=match_col
if match_col == "Number[psor]":
cur_match_col = "Number\[psor\]"
if match_col == "Person[psor]":
cur_match_col = "Person\[psor\]"
self.sentence.words[row].feats = re.sub(cur_match_col+'='+match_val, match_col+'='+match_val+"|"+col+"="+text, self.sentence.words[row].feats)
elif isSpace:
old_feats = re.split('\|', self.sentence.words[row].feats)
new_feats = []
for old_feat in old_feats:
if old_feat.split("=")[0]!=cur_col:
new_feats.append(old_feat)
self.sentence.words[row].feats = "|".join(new_feats)
else:
self.sentence.words[row].feats = re.sub(cur_col+'=\w*', col+"="+text, self.sentence.words[row].feats)
if not self.first_time:
self.doc.write()
self.first_time = True
self.writeNotes()
self.update_table()
self.update_html()
self.check_errors()
self.first_time = False
class ArticleBox(QFrame):
def __init__(self, parent=None):
"""
Constructor of ArticleBox which display all content of article
Args:
parent (QWidget): GUI parent of widget. Defaults to None.
"""
super(ArticleBox, self).__init__(parent=parent)
self.setStyleSheet(
"QFrame{border: 1px solid white; border-radius: 10px;} QLabel{border: 0px solid black;} QTextEdit{border: 0px solid black;} "
)
self.__layout = QVBoxLayout(self)
__label_font = QFont()
__label_font.setPointSize(20)
__text_font = QFont()
__text_font.setPointSize(12)
__site_font = QFont()
__site_font.setPointSize(10)
self.__layout.setSpacing(10)
self.__layout.setAlignment(Qt.AlignTop)
self.__site = QLabel(parent=self)
self.__site.setWordWrap(True)
self.__site.setFont(__site_font)
self.__label = QLabel(parent=self)
self.__label.setWordWrap(True)
self.__label.setFont(__label_font)
self.__content_box = QWebEngineView()
self.__content_box.setVisible(False)
self.__content_box.setMinimumSize(300, 300)
self.__content_box.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.__content_box.loadStarted.connect(self.load_started_callback)
self.__content_box.loadFinished.connect(self.load_finished_callback)
self.__link_btn = QPushButton()
self.__link_btn.setFlat(True)
self.__link_btn.clicked.connect(self.open_link)
self.__link = ""
self.__layout.addWidget(self.__label)
self.__layout.addWidget(self.__site)
self.__layout.addWidget(self.__content_box)
self.__layout.addWidget(self.__link_btn, alignment=Qt.AlignCenter)
self.setLayout(self.__layout)
def load_started_callback(self):
"""
Method which was used to measure loading time it is executed at beginning of loading content
"""
pass
def load_finished_callback(self):
"""
Method which was used to measure loading time it is executed at the end of loading content
"""
self.__content_box.setVisible(True)
def set_data(self, site, link, title, article):
"""
Sets content data to data from args
Args:
site (string): site name
link (string): url of the whole article
title (string): title of the article
article (string): content of article
"""
self.__content_box.setHtml(article, link)
self.__link_btn.setText(f"Read more")
self.__link = link
self.__site.setText(site)
self.__label.setText(title)
def open_link(self):
"""
Opens article link in external browser
"""
webbrowser.open_new_tab(self.__link)
