class GUIapp(QWidget):
def __init__(self, *args, **kwargs):
super(GUIapp, self).__init__(*args, **kwargs)
self.setWindowTitle("TEST 1.0")
self.resize(800, 600)
self.button1 = QPushButton("Input File")
self.button1.clicked.connect(self.getFile)
self.label1 = QLabel("Prediction")
self.table = QTableWidget()
self.label2 = QLabel("Insert CSV File")
self.textEditor = QTextEdit()
#self.setCentralWidget(self.graphWidget)
#https: // stackoverflow.com / questions / 31775468 / show - string - values - on - x - axis - in -pyqtgraph
# plot data: x, y values
layout = QVBoxLayout()
layout.addWidget(self.button1)
layout.addWidget(self.label2)
layout.addWidget(self.textEditor)
layout.addWidget(self.label1)
layout.addWidget(self.table)
self.setLayout(layout)
def getFile(self):
dialg = QFileDialog()
dialg.setFileMode(QFileDialog.AnyFile)
dialg.setNameFilter("CSV Files (*.csv)")
if dialg.exec_():
fileName = dialg.selectedFiles()
f = open(fileName[0], 'r')
ml = machineLearning(f)
with open(fileName[0], 'r') as f:
data = f.read()
self.textEditor.setPlainText(data)
self.table.setRowCount(len(ml))
self.table.setColumnCount(1)
x = -1
while x <= len(ml) - 2:
x += 1
self.table.setItem(x, 0, QTableWidgetItem(ml[x]))
header = self.table.horizontalHeader()
header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
f.close()
else:
pass
def updateObjectFilter(self):
# -- Add message filter rows -- #
font = self.getFont()
self.filterTabs.clear()
self.filterTabs.addTab(self.filterTable, 'Information ID')
# For each object in objectList, create a new Table and add it to the tabs.
for keys, values in Globals.objectDict.items():
objectFilterTable = QTableWidget()
objectFilterTable.setRowCount(0)
objectFilterTable.setColumnCount(2)
strSplit = keys + ';Enable'
objectFilterTable.setHorizontalHeaderLabels(strSplit.split(';'))
objectFilterTable.resizeColumnsToContents()
filterTableHeader = objectFilterTable.horizontalHeader()
filterTableHeader.setSectionResizeMode(0, QHeaderView.Stretch)
filterTableHeader.setSectionResizeMode(
1, QHeaderView.ResizeToContents)
checkBoxFilter = self.createCheckBox()
objectFilterTable.itemChanged.connect(
lambda *a, table=objectFilterTable: self.filterAllObjectIDs(
*a, table=table))
objectTableIndex = 0
objectFilterTable.insertRow(objectTableIndex)
objCat = QTableWidgetItem('FILTER ALL')
objCat.setFont(font)
objectFilterTable.setItem(objectTableIndex, 0, objCat)
objectFilterTable.setItem(objectTableIndex, 1, checkBoxFilter)
objectTableIndex = objectTableIndex + 1
for keys2, values2 in values.items():
objectFilterTable.insertRow(objectTableIndex)
checkBoxFilter = self.createCheckBox()
objectFilterTable.setItem(
objectTableIndex, 0,
QTableWidgetItem('ID: ' + str(keys2) + ' Name: ' +
str(values2)))
objectFilterTable.setItem(objectTableIndex, 1, checkBoxFilter)
objectTableIndex = objectTableIndex + 1
# Add the newly create table to the tabs.
self.filterTabs.addTab(objectFilterTable, keys)
self.objectTabDict[keys] = objectFilterTable
class SyncWidget(QWidget):
def __init__(self, gui, do_user_config, selected_book_ids,
is_sync_selected):
QWidget.__init__(self, gui)
api.build_request('/limits')
self.logger = Logger(
path.join(gui.current_db.library_path, 'bookfusion_sync.log'))
self.logger.info(
'Open sync dialog: selected_book_ids={}; is_sync_selected={}'.
format(selected_book_ids, is_sync_selected))
if len(selected_book_ids) == 0:
is_sync_selected = False
self.worker_thread = None
self.do_user_config = do_user_config
self.db = gui.current_db.new_api
self.selected_book_ids = selected_book_ids
self.l = QVBoxLayout()
self.l.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.l)
self.radio_layout = QVBoxLayout()
self.l.addLayout(self.radio_layout)
self.sync_all_radio = QRadioButton('Sync all books')
self.sync_all_radio.setChecked(not is_sync_selected)
self.radio_layout.addWidget(self.sync_all_radio)
sync_selected_radio_label = 'Sync selected books'
if len(selected_book_ids) > 0:
sync_selected_radio_label = 'Sync {} selected {}'.format(
len(selected_book_ids),
'book' if len(selected_book_ids) == 1 else 'books')
self.sync_selected_radio = QRadioButton(sync_selected_radio_label)
self.sync_selected_radio.toggled.connect(self.toggle_sync_selected)
self.sync_selected_radio.setChecked(is_sync_selected)
self.sync_selected_radio.setEnabled(len(selected_book_ids) > 0)
self.radio_layout.addWidget(self.sync_selected_radio)
self.reupload_possible = len(selected_book_ids) > 0 and len(
selected_book_ids) <= 100
if self.reupload_possible:
for book_id in selected_book_ids:
identifiers = self.db.get_proxy_metadata(book_id).identifiers
if not identifiers.get('bookfusion'):
self.reupload_possible = False
self.reupload_checkbox = QCheckBox('Re-upload book files', self)
self.reupload_checkbox.setVisible(is_sync_selected
and self.reupload_possible)
self.radio_layout.addWidget(self.reupload_checkbox)
self.btn_layout = QHBoxLayout()
self.l.addLayout(self.btn_layout)
self.config_btn = QPushButton('Configure')
self.config_btn.clicked.connect(self.config)
self.btn_layout.addWidget(self.config_btn)
self.btn_layout.addStretch()
self.start_btn = QPushButton('Start')
self.start_btn.clicked.connect(self.start)
self.btn_layout.addWidget(self.start_btn)
self.cancel_btn = QPushButton('Cancel')
self.cancel_btn.clicked.connect(self.cancel)
self.cancel_btn.hide()
self.btn_layout.addWidget(self.cancel_btn)
self.info = QHBoxLayout()
self.info.setContentsMargins(0, 0, 0, 0)
self.l.addLayout(self.info)
self.msg = QLabel()
self.info.addWidget(self.msg)
self.info.addStretch()
self.log_btn = QLabel('<a href="#">Log</a>')
self.log_btn.linkActivated.connect(self.toggle_log)
self.log_btn.hide()
self.info.addWidget(self.log_btn)
self.log = QTableWidget(0, 2)
self.log.setHorizontalHeaderLabels(['Book', 'Message'])
self.log.horizontalHeader().setStretchLastSection(True)
self.log.hide()
self.l.addWidget(self.log)
self.apply_config()
def __del__(self):
if self.worker_thread:
self.worker_thread.quit()
self.worker_thread.terminate()
def config(self):
self.do_user_config(parent=self)
self.apply_config()
def apply_config(self):
configured = bool(prefs['api_key'])
self.start_btn.setEnabled(configured)
def toggle_sync_selected(self, is_sync_selected):
if hasattr(self, 'reupload_checkbox'):
self.reupload_checkbox.setVisible(is_sync_selected
and self.reupload_possible)
def start(self):
if self.sync_selected_radio.isChecked(
) and self.reupload_checkbox.isChecked():
reply = QMessageBox.question(
self, 'BookFusion Sync',
'Re-uploading book files can potentially result in previous highlights or bookmarks no longer working.\n\nPreviously uploaded files will be overwritten. Are you sure you want to re-upload?',
QMessageBox.No | QMessageBox.Yes, QMessageBox.Yes)
if reply != QMessageBox.Yes:
return
self.worker = None
self.valid_book_ids = None
self.book_log_map = {}
self.book_progress_map = {}
if self.sync_selected_radio.isChecked():
book_ids = list(self.selected_book_ids)
else:
book_ids = list(self.db.all_book_ids())
self.logger.info('Start sync: sync_selected={}; book_ids={}'.format(
self.sync_selected_radio.isChecked(), book_ids))
self.in_progress = True
self.total = len(book_ids)
self.update_progress(None)
self.start_btn.hide()
self.cancel_btn.show()
self.config_btn.setEnabled(False)
self.sync_all_radio.setEnabled(False)
self.sync_selected_radio.setEnabled(False)
self.worker_thread = QThread(self)
self.worker = CheckWorker(self.db, self.logger, book_ids)
self.worker.finished.connect(self.finish_check)
self.worker.finished.connect(self.worker_thread.quit)
self.worker.progress.connect(self.update_progress)
self.worker.limitsAvailable.connect(self.apply_limits)
self.worker.resultsAvailable.connect(self.apply_results)
self.worker.aborted.connect(self.abort)
self.worker.moveToThread(self.worker_thread)
self.worker_thread.started.connect(self.worker.start)
self.worker_thread.start()
def apply_limits(self, limits):
self.logger.info('Limits: {}'.format(limits))
self.limits = limits
def apply_results(self, books_count, valid_ids):
self.logger.info('Check results: books_count={}; valid_ids={}'.format(
books_count, valid_ids))
self.valid_book_ids = valid_ids
self.books_count = books_count
def finish_check(self):
if self.valid_book_ids:
is_filesize_exceeded = len(self.valid_book_ids) < self.books_count
is_total_books_exceeded = self.limits[
'total_books'] and self.books_count > self.limits['total_books']
if is_filesize_exceeded or is_total_books_exceeded:
if self.limits['message']:
msg_box = QMessageBox(self)
msg_box.setWindowTitle('BookFusion Sync')
msg_box.addButton(QMessageBox.No)
msg_box.addButton(QMessageBox.Yes)
msg_box.setText(self.limits['message'])
msg_box.setDefaultButton(QMessageBox.Yes)
reply = msg_box.exec_()
if reply == QMessageBox.Yes:
self.start_sync()
else:
self.in_progress = False
self.msg.setText('Canceled.')
self.finish_sync()
else:
self.start_sync()
else:
self.start_sync()
else:
if self.in_progress:
self.in_progress = False
self.msg.setText('No supported books selected.')
self.finish_sync()
def start_sync(self):
self.log_btn.show()
self.log.setRowCount(0)
self.log.show()
self.worker_thread = QThread(self)
book_ids = self.valid_book_ids
if self.limits['total_books']:
book_ids = book_ids[:self.limits['total_books']]
self.total = len(book_ids)
self.worker = UploadManager(
self.db, self.logger, book_ids,
self.sync_selected_radio.isChecked()
and self.reupload_checkbox.isChecked())
self.worker.finished.connect(self.finish_sync)
self.worker.finished.connect(self.worker_thread.quit)
self.worker.progress.connect(self.update_progress)
self.worker.uploadProgress.connect(self.update_upload_progress)
self.worker.started.connect(self.log_start)
self.worker.skipped.connect(self.log_skip)
self.worker.failed.connect(self.log_fail)
self.worker.uploaded.connect(self.log_upload)
self.worker.updated.connect(self.log_update)
self.worker.aborted.connect(self.abort)
self.worker.moveToThread(self.worker_thread)
self.worker_thread.started.connect(self.worker.start)
self.worker_thread.start()
def finish_sync(self):
if self.in_progress:
self.msg.setText('Done.')
self.cancel_btn.hide()
self.cancel_btn.setEnabled(True)
self.start_btn.show()
self.config_btn.setEnabled(True)
self.sync_all_radio.setEnabled(True)
self.sync_selected_radio.setEnabled(len(self.selected_book_ids) > 0)
def abort(self, error):
self.in_progress = False
self.msg.setText(error)
def cancel(self):
self.in_progress = False
self.msg.setText('Canceled.')
self.cancel_btn.setEnabled(False)
self.worker.cancel()
def update_progress(self, progress):
if self.in_progress:
if isinstance(self.worker, UploadManager):
msg = 'Synchronizing...'
else:
msg = 'Preparing...'
if progress:
msg += ' {} of {}'.format(progress + 1, self.total)
self.msg.setText(msg)
def update_upload_progress(self, book_id, sent, total):
if not book_id in self.book_progress_map:
return
progress = self.book_progress_map[book_id]
if sent < total:
progress.setValue(sent)
progress.setMaximum(total)
else:
progress.setMaximum(0)
def log_start(self, book_id):
self.update_log(book_id, None)
def log_fail(self, book_id, msg):
self.update_log(book_id, msg)
def log_skip(self, book_id):
self.update_log(book_id, 'skipped')
def log_upload(self, book_id):
self.update_log(book_id, 'uploaded')
def log_update(self, book_id):
self.update_log(book_id, 'updated')
def toggle_log(self, _):
self.log.setVisible(not self.log.isVisible())
def update_log(self, book_id, msg):
if book_id in self.book_log_map:
index = self.book_log_map[book_id]
else:
index = self.log.rowCount()
self.book_log_map[book_id] = index
self.log.insertRow(index)
title = self.db.get_proxy_metadata(book_id).title
title_item = QTableWidgetItem(title)
title_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemNeverHasChildren)
self.log.setItem(index, 0, title_item)
progress = QProgressBar()
progress.setMaximum(0)
self.log.setCellWidget(index, 1, progress)
self.book_progress_map[book_id] = progress
if not msg is None:
del (self.book_progress_map[book_id])
self.log.setCellWidget(index, 1, None)
msg_item = QTableWidgetItem(msg)
msg_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemNeverHasChildren)
self.log.setItem(index, 1, msg_item)
def maybe_cancel(self):
if self.worker_thread and self.worker_thread.isRunning():
reply = QMessageBox.question(
self, 'BookFusion Sync',
'Are you sure you want to cancel the currently running process?',
QMessageBox.No | QMessageBox.Yes, QMessageBox.Yes)
if reply == QMessageBox.Yes:
self.cancel()
else:
return False
return True
class ModelGroupsTable(QWidget):
EditableAttrs = [
attr for attr in PlotStyles.StyleAttributes
if attr in PlotStyles.StyleAttributeOptions
]
ColList = 3
ColPlot = 4
ColApply = 5
AttrByCol = dict([(i + 6, attr) for i, attr in enumerate(EditableAttrs)])
def __init__(self, parent, *args):
QWidget.__init__(self, parent, *args)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
lo = QVBoxLayout(self)
lo.setContentsMargins(0, 0, 0, 0)
lo1 = QHBoxLayout()
lo.addLayout(lo1)
lo1.setContentsMargins(0, 0, 0, 0)
lbl = QLabel(QString("<nobr><b>Source groupings:</b></nobr>"), self)
lo1.addWidget(lbl, 0)
lo1.addStretch(1)
# add show/hide button
self._showattrbtn = QPushButton(self)
self._showattrbtn.setMinimumWidth(256)
lo1.addWidget(self._showattrbtn, 0)
lo1.addStretch()
self._showattrbtn.clicked.connect(self._togglePlotControlsVisibility)
# add table
self.table = QTableWidget(self)
lo.addWidget(self.table)
self.table.cellChanged[int, int].connect(self._valueChanged)
self.table.setSelectionMode(QTableWidget.NoSelection)
# setup basic columns
self.table.setColumnCount(6 + len(self.EditableAttrs))
for i, label in enumerate(
("grouping", "total", "selection", "list", "plot", "style")):
self.table.setHorizontalHeaderItem(i, QTableWidgetItem(label))
self.table.horizontalHeader().setSectionHidden(self.ColApply, True)
# setup columns for editable grouping attributes
for i, attr in self.AttrByCol.items():
self.table.setHorizontalHeaderItem(
i, QTableWidgetItem(PlotStyles.StyleAttributeLabels[attr]))
self.table.horizontalHeader().setSectionHidden(i, True)
self.table.verticalHeader().hide()
# other internal init
self._attrs_shown = False
self._togglePlotControlsVisibility()
self.model = None
self._setting_model = False
self._currier = PersistentCurrier()
# row of 'selected' grouping
self._irow_selgroup = 0
def clear(self):
self.table.setRowCount(0)
self.model = None
# setup mappings from the group.show_plot attribute to check state
ShowAttrToCheckState = {
PlotStyles.ShowNot: Qt.Unchecked,
PlotStyles.ShowDefault: Qt.PartiallyChecked,
PlotStyles.ShowAlways: Qt.Checked
}
CheckStateToShowAttr = dict([(val, key)
for key, val in ShowAttrToCheckState.items()])
def _makeCheckItem(self, name, group, attr):
item = QTableWidgetItem(name)
if group is self.model.defgroup:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
item.setCheckState(
Qt.Checked if getattr(group.style, attr) else Qt.Unchecked)
else:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable
| Qt.ItemIsTristate)
item.setCheckState(self.ShowAttrToCheckState[getattr(
group.style, attr)])
return item
def _updateModel(self, what=SkyModel.UpdateAll, origin=None):
if origin is self or not what & (SkyModel.UpdateTags
| SkyModel.UpdateGroupStyle):
return
model = self.model
self._setting_model = True # to ignore cellChanged() signals (in valueChanged())
# _item_cb is a dict (with row,col keys) containing the widgets (CheckBoxes ComboBoxes) per each cell
self._item_cb = {}
# lists of "list" and "plot" checkboxes per each grouping (excepting the default grouping); each entry is an (row,col,item) tuple.
# used as argument to self._showControls()
self._list_controls = []
self._plot_controls = []
# list of selection callbacks (to which signals are connected)
self._callbacks = []
# set requisite number of rows,and start filling
self.table.setRowCount(len(model.groupings))
for irow, group in enumerate(model.groupings):
self.table.setItem(irow, 0, QTableWidgetItem(group.name))
if group is model.selgroup:
self._irow_selgroup = irow
# total # source in group: skip for "current"
if group is not model.curgroup:
self.table.setItem(irow, 1, QTableWidgetItem(str(group.total)))
# selection controls: skip for current and selection
if group not in (model.curgroup, model.selgroup):
btns = QWidget()
lo = QHBoxLayout(btns)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(0)
# make selector buttons (depending on which group we're in)
if group is model.defgroup:
Buttons = (("+", lambda src, grp=group: True,
"select all sources"),
("-", lambda src, grp=group: False,
"unselect all sources"))
else:
Buttons = (
("=", lambda src, grp=group: grp.func(src),
"select only this grouping"),
("+",
lambda src, grp=group: src.selected or grp.func(src),
"add grouping to selection"),
("-", lambda src, grp=group: src.selected and not grp.
func(src), "remove grouping from selection"),
("&&",
lambda src, grp=group: src.selected and grp.func(src),
"intersect selection with grouping"))
lo.addStretch(1)
for label, predicate, tooltip in Buttons:
btn = QToolButton(btns)
btn.setText(label)
btn.setMinimumWidth(24)
btn.setMaximumWidth(24)
btn.setToolTip(tooltip)
lo.addWidget(btn)
# add callback
btn.clicked.connect(
self._currier.curry(self.selectSources, predicate))
lo.addStretch(1)
self.table.setCellWidget(irow, 2, btns)
# "list" checkbox (not for current and selected groupings: these are always listed)
if group not in (model.curgroup, model.selgroup):
item = self._makeCheckItem("", group, "show_list")
self.table.setItem(irow, self.ColList, item)
item.setToolTip(
"""<P>If checked, sources in this grouping will be listed in the source table. If un-checked, sources will be
excluded from the table. If partially checked, then the default list/no list setting of "all sources" will be in effect.
</P>""")
# "plot" checkbox (not for the current grouping, since that's always plotted)
if group is not model.curgroup:
item = self._makeCheckItem("", group, "show_plot")
self.table.setItem(irow, self.ColPlot, item)
item.setToolTip(
"""<P>If checked, sources in this grouping will be included in the plot. If un-checked, sources will be
excluded from the plot. If partially checked, then the default plot/no plot setting of "all sources" will be in effect.
</P>""")
# custom style control
# for default, current and selected, this is just a text label
if group is model.defgroup:
item = QTableWidgetItem("default:")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the default plot style used for all sources for which a custom grouping style is not selected.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
elif group is model.curgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the plot style used for the highlighted source, if any.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
elif group is model.selgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the plot style used for the currently selected sources.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
# for the rest, a combobox with custom priorities
else:
cb = QComboBox()
cb.addItems(["default"] +
["custom %d" % p for p in range(1, 10)])
index = max(0, min(group.style.apply, 9))
# dprint(0,group.name,"apply",index)
cb.setCurrentIndex(index)
cb.activated[int].connect(
self._currier.xcurry(self._valueChanged,
(irow, self.ColApply)))
self.table.setCellWidget(irow, self.ColApply, cb)
cb.setToolTip(
"""<P>This controls whether sources within this group are plotted with a customized
plot style. Customized styles have numeric priority; if a source belongs to multiple groups, then
the style with the lowest priority takes precedence.<P>""")
# attribute comboboxes
for icol, attr in self.AttrByCol.items():
# get list of options for this style attribute. If dealing with first grouping (i==0), which is
# the "all sources" grouping, then remove the "default" option (which is always first in the list)
options = PlotStyles.StyleAttributeOptions[attr]
if irow == 0:
options = options[1:]
# make combobox
cb = QComboBox()
cb.addItems(list(map(str, options)))
# the "label" option is also editable
if attr == "label":
cb.setEditable(True)
try:
index = options.index(getattr(group.style, attr))
cb.setCurrentIndex(index)
except ValueError:
cb.setEditText(str(getattr(group.style, attr)))
slot = self._currier.xcurry(self._valueChanged, (irow, icol))
cb.activated[int].connect(slot)
cb.editTextChanged['QString'].connect(slot)
cb.setEnabled(group is model.defgroup or group.style.apply)
self.table.setCellWidget(irow, icol, cb)
label = attr
if irow:
cb.setToolTip(
"""<P>This is the %s used to plot sources in this group, when a "custom" style for the group
is enabled via the style control.<P>""" % label)
else:
cb.setToolTip(
"<P>This is the default %s used for all sources for which a custom style is not specified below.<P>"
% label)
self.table.resizeColumnsToContents()
# re-enable processing of cellChanged() signals
self._setting_model = False
def setModel(self, model):
self.model = model
self.model.connect("updated", self._updateModel)
self.model.connect("selected", self.updateModelSelection)
self._updateModel(SkyModel.UpdateAll)
def _valueChanged(self, row, col):
"""Called when a cell has been edited"""
if self._setting_model:
return
group = self.model.groupings[row]
item = self.table.item(row, col)
if col == self.ColList:
if group is not self.model.defgroup:
# tri-state items go from unchecked to checked when user clicks them. Make them partially checked instead.
if group.style.show_list == PlotStyles.ShowNot and item.checkState(
) == Qt.Checked:
item.setCheckState(Qt.PartiallyChecked)
group.style.show_list = self.CheckStateToShowAttr[
item.checkState()]
self.model.emitChangeGroupingVisibility(group, origin=self)
return
elif col == self.ColPlot:
if group is not self.model.defgroup:
# tri-state items go from unchecked to checked by default. Make them partially checked instead.
if group.style.show_plot == PlotStyles.ShowNot and item.checkState(
) == Qt.Checked:
item.setCheckState(Qt.PartiallyChecked)
group.style.show_plot = self.CheckStateToShowAttr[
item.checkState()]
elif col == self.ColApply:
group.style.apply = self.table.cellWidget(row, col).currentIndex()
# enable/disable editable cells
for j in list(self.AttrByCol.keys()):
item1 = self.table.item(row, j)
if item1:
fl = item1.flags() & ~Qt.ItemIsEnabled
if group.style.apply:
fl |= Qt.ItemIsEnabled
item1.setFlags(fl)
cw = self.table.cellWidget(row, j)
cw and cw.setEnabled(group.style.apply)
elif col in self.AttrByCol:
cb = self.table.cellWidget(row, col)
txt = str(cb.currentText())
attr = self.AttrByCol[col]
if txt == "default":
setattr(group.style, attr, PlotStyles.DefaultValue)
else:
setattr(group.style, attr,
PlotStyles.StyleAttributeTypes.get(attr, str)(txt))
# all other columns: return so we don't emit a signal
else:
return
# in all cases emit a signal
self.model.emitChangeGroupingStyle(group, origin=self)
def selectSources(self, predicate, curry=False):
"""Selects sources according to predicate(src)"""
busy = BusyIndicator()
for src in self.model.sources:
src.selected = predicate(src)
self.model.emitSelection(origin=self)
busy.reset_cursor()
def updateModelSelection(self, nsel, origin=None):
"""This is called when some other widget changes the set of selected model sources"""
self.table.clearSelection()
if self.model:
self.table.item(self._irow_selgroup, 1).setText(str(nsel))
def _togglePlotControlsVisibility(self):
if self._attrs_shown:
self._attrs_shown = False
self.table.hideColumn(self.ColApply)
for col in self.AttrByCol.keys():
self.table.hideColumn(col)
self._showattrbtn.setText("Show plot styles >>")
else:
self._attrs_shown = True
self.table.showColumn(self.ColApply)
for col in self.AttrByCol.keys():
self.table.showColumn(col)
self._showattrbtn.setText("<< Hide plot styles")
class TableTab(TraceDocks):
## The constructor
# initialize the super-class, assign a name and first configItems
def __init__(self,parent):
super(TableTab, self).__init__(parent,'TableTab')
self.tabName = 'TableTab'
self.parent = parent
self.logger.logEvent('Creating Tab now: '+ self.tabName)
# Set a couple of default-values, in case the configParser does not work
self.snifferConfig.configAutoClearCheck = 1
self.snifferConfig.configFilterState = 'Local'
self.snifferConfig.configFilterList = self.snifferFilter.filteredIdList
# By parsing the config now, we assure that we re-load everything
# the way we left it
self.snifferConfig.parseConfigFromFile()
self.lastSearchedText = 'nullthiswillneverbefound'
self.lastMatch = 'purge'
self.lastIndex = 0
## Create the visible UI
def setTableTabLayout(self):
# Create Table Tab --------------------###
# Create Layouts
self.Vlayout = QVBoxLayout()
self.H1layout = QHBoxLayout()
self.H11layout = QHBoxLayout()
self.H12layout = QHBoxLayout()
self.H21layout = QHBoxLayout()
self.V11layout = QVBoxLayout()
self.V21layout = QVBoxLayout()
# Create Widgets for H1layout
# First buttons
self.clearTableButt = QPushButton('Clear Table')
self.clearTableButt.clicked.connect(self.clearTable)
self.autoClearCheck = QCheckBox('Auto Clear')
self.autoClearCheck.stateChanged.connect(self.checkAutoClearChanged)
self.searchInputField = QLineEdit()
self.searchInputField.setPlaceholderText('Enter search term, then click search')
self.searchButt = QPushButton('Search Table')
self.searchButt.clicked.connect(lambda: self.searchInTable(self.searchInputField.text(),2))
self.showSummaryButt = QPushButton('Show Summary')
self.showSummaryButt.clicked.connect(self.showSummary)
self.filterGroup = QButtonGroup()
self.localFilterRadio = QRadioButton('Local',self)
self.globalFilterRadio = QRadioButton('Global', self)
self.configureFilterButt = QPushButton('Configure Filter')
self.configureFilterButt.clicked.connect(self.configureFilter)
self.localFilterRadio.clicked.connect(self.localRadioSelected)
self.globalFilterRadio.clicked.connect(self.globalRadioSelected)
self.H21layout.addWidget(self.localFilterRadio)
self.H21layout.addWidget(self.globalFilterRadio)
self.H21layout.addWidget(self.showSummaryButt)
self.V21layout.addLayout(self.H21layout)
self.V21layout.addWidget(self.configureFilterButt)
# Add Widgets to H11layout
self.H11layout.addWidget(self.clearTableButt)
self.H11layout.addWidget(self.autoClearCheck)
# Add Widgets to H12layout
self.H12layout.addWidget(self.searchInputField)
self.H12layout.addWidget(self.searchButt)
self.H12layout.addStretch()
self.V11layout.addLayout(self.H11layout)
self.V11layout.addLayout(self.H12layout)
self.H1layout.addLayout(self.V11layout)
self.H1layout.addLayout(self.V21layout)
self.syncUiToConfig()
#------------------------------------
# Create Table
self.detailTableIndex = 0
self.detailTable = QTableWidget()
self.detailTableItem = QTableWidgetItem()
self.detailTable.setRowCount(0)
self.detailTable.setColumnCount(6)
self.detailTable.setHorizontalHeaderLabels('packID;Tick;Timer;Type;Message;Length'.split(';'))
self.detailTable.resizeColumnsToContents()
self.detailTableHeader = self.detailTable.horizontalHeader()
self.detailTableHeader.setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.detailTableHeader.setSectionResizeMode(1, QHeaderView.ResizeToContents)
self.detailTableHeader.setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.detailTableHeader.setSectionResizeMode(3, QHeaderView.ResizeToContents)
self.detailTableHeader.setSectionResizeMode(4, QHeaderView.Stretch)
self.detailTableHeader.setSectionResizeMode(5, QHeaderView.ResizeToContents)
#------------------------------------
self.Vlayout.addLayout(self.H1layout)
self.Vlayout.addWidget(self.detailTable)
self.dockContents.setLayout(self.Vlayout)
## Fill the main table with the entries from the given list
# @param fillTableList the list which is to be parsed into the table
def fillTable(self,fillTableList):
print('Filling Table with all items in PayloadList')
self.detailTable.scrollToTop() # Scrolls to the top of the table
self.configAutoClearCheck = True
if self.configAutoClearCheck == True:
self.detailTable.setRowCount(0)
self.detailTableIndex = 0
Globals.dockDict['dockStart'].progressShotBar.setMaximum(len(Globals.payloadList))
for self.tablePayload in fillTableList:
self.detailTable.insertRow(self.detailTableIndex)
self.detailTable.setItem(self.detailTableIndex,0,QTableWidgetItem(str(self.tablePayload.payloadHead.packetID)))
self.detailTable.setItem(self.detailTableIndex,1,QTableWidgetItem(str(self.tablePayload.payloadHead.tickCountHigh << 8 | self.tablePayload.payloadHead.tickCountLow)))
self.detailTable.setItem(self.detailTableIndex,2,QTableWidgetItem(str(self.tablePayload.payloadHead.timerByteHigh << 8 | self.tablePayload.payloadHead.timerByteLow)))
self.detailTable.setItem(self.detailTableIndex,3,QTableWidgetItem(Globals.tspDict[self.tablePayload.payloadHead.informationID][0]))
testPayload = self.tablePayload.toDict()
# This a little messy: We check whether an objectDict is available, and if it is
# we check for the different DataTypes there might be, since the message section is unified.
# Basically, we need to handle all the different cases there can be, payload0-payload3 and the actual objectType
if Globals.objectDict:
if getDataType(self.tablePayload) == 1:
if getObjectType(self.tablePayload) == 5:
try:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem(str(self.tablePayload.data1)+': '+Globals.objectDict['TASK'][str(self.tablePayload.data1)]))
except:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem('FAILED WITH KEYERROR - see printOutput'))
print('KEYERROR DETAILS:')
print(testPayload)
elif getDataType(self.tablePayload) == 2:
try:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem(str(self.tablePayload.data1)+': '+Globals.objectDict[Globals.objectTypeDict[self.tablePayload.data1]][str(self.tablePayload.data2)]))
except:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem('FAILED WITH KEYERROR - see printOutput'))
print('KEYERROR DETAILS:')
print(testPayload)
# If the objectDict does not exist, we can just dump the raw information into the message-section -> no lookup will be happening
# and it is up to the user to interpret the data
else:
if getDataType(self.tablePayload) == 1:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem(str(self.tablePayload.data1)))
elif getDataType(self.tablePayload) == 2:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem(str(self.tablePayload.data1)+';'+str(self.tablePayload.data2)))
elif getDataType(self.tablePayload) == 3:
self.detailTable.setItem(self.detailTableIndex,4,QTableWidgetItem(str(self.tablePayload.data1)+';'+str(self.tablePayload.data2)+';'+str(self.tablePayload.data3)))
self.detailTable.setItem(self.detailTableIndex,5,QTableWidgetItem('payload'+str(getDataType(self.tablePayload))))
self.detailTableIndex+=1
Globals.dockDict['dockStart'].progressShotBar.setValue(self.detailTableIndex)
Globals.dockDict['dockStart'].progressShotBar.setValue(len(Globals.payloadList))
Globals.dockDict['dockStart'].displayStatusMessage('Table filled completely, check the tab')
self.lastSearchedText = 'thisisAWorkAround' # No idea why this is there...
# --- DOCK-SPECIFIC UI FUNCTIONS --- #
# -----------------------------------#
## Disable all UI-buttons belonging to the tab. This is implementation specific
def disableButtons(self):
self.clearTableButt.setEnabled(False)
self.autoClearCheck.setEnabled(False)
print('Disable TabTable Buttons')
## CB: clearTableButton // Clear the main table
def clearTable(self):
self.logger.logEvent('clear Table clicked')
self.detailTable.setRowCount(0)
self.detailTableIndex = 0
## CB: autoClearCheckbox // set the configAutoClearCheck state according to the checkbox
def checkAutoClearChanged(self):
self.snifferConfig.configAutoClearCheck ^= 1
self.logger.logEvent('changed Auto Clear Checkbox to - '+ str(self.snifferConfig.configAutoClearCheck))
## CB: localRadioButt // set the configFilterState to 'Local'
def localRadioSelected(self):
self.snifferConfig.configFilterState = 'Local'
self.logger.logEvent('changed Filter Radio to - '+ str(self.snifferConfig.configFilterState))
## CB: globalRadioButt // set the configFilterState to 'Global'
def globalRadioSelected(self):
self.snifferConfig.configFilterState = 'Global'
self.logger.logEvent('changed Filter Radio to - '+ str(self.snifferConfig.configFilterState))
## CB: Show Stats // opens the Stat-Dialog to show misc. information about the measurement
def showSummary(self):
self.snifferStats.show()
self.snifferStats.showStats()
## Searches the table for a string and scrolls to the found item.
# @param textToSearch the string that needs to be found in the table
# @param column the column where the search needs to take place
def searchInTable(self, textToSearch, column):
if textToSearch not in Globals.IDList:
QMessageBox.about(self,'Not Found','SearchText not Found!')
return
if self.lastSearchedText == textToSearch:
self.detailTable.setCurrentItem(self.lastFound[self.lastIndex])
self.detailTable.scrollToItem(self.lastFound[self.lastIndex])
self.lastIndex = self.lastIndex + 1
if self.lastIndex == len(self.lastFound):
self.lastIndex = 0
else:
foundItems = self.detailTable.findItems(textToSearch, Qt.MatchExactly)
self.lastSearchedText = textToSearch
if len(foundItems) != 0:
self.lastFound = foundItems
self.lastIndex = 1
self.detailTable.setCurrentItem(foundItems[0])
self.detailTable.scrollToItem(self.lastFound[self.lastIndex])
# --- MANDATORY UI FUNCTIONS --- #
# -------------------------------#
## Read out all components of snifferConfig and set the UI elements according to
# the saved values.
def syncUiToConfig(self):
self.autoClearCheck.setChecked(self.snifferConfig.configAutoClearCheck)
if self.snifferConfig.configFilterState == 'Local':
self.localFilterRadio.click()
elif self.snifferConfig.configFilterState == 'Global':
self.globalFilterRadio.click()
else:
print('Error, neither local nor global in config')
## Open the correct filter based on the radioButton. If the Global-filter is checked
# we assign its calledby variable in order to execute the right callback after the filter is saved.
def configureFilter(self):
if self.localFilterRadio.isChecked():
self.snifferFilter.show()
elif self.globalFilterRadio.isChecked():
Globals.globalFilter.show()
Globals.globalFilter.calledBy = 'dockTable'
else:
print('neither radios checked. Error!')
## CB: // Updates the UI-contents with after filtering has taken place.
# This function should not be called by the tab itself, but by the filter
# @param filteredIDs the IDs that are to be kept in the payloadList (obsolete)
# @param filteredPayloads the new payloadList, which only contains the payloads filtered by the SnifferFilter
def filterUpdated(self, filteredIDs, filteredPayloads):
print('we arrive from SnifferFilter')
self.clearTable()
self.fillTable(filteredPayloads)
class SnifferFilter(QDialog):
## The constructor.
# Initialize lists to be filled with filtered payloads and
# create the dialog.
def __init__(self, parent):
super(SnifferFilter, self).__init__()
self.parent = parent
self.setWindowTitle('SnifferFilter')
self.filteredPayloadList = []
self.filteredIdList = []
self.layoutingComplete = False
self.calledBy = 'NONE' # We store here which tab the filter belongs to, if there is no parent.(Like when the filter is global!)
self.objectTabDict = {}
self.filteredObjectDict = {}
self.resize(670, 700)
## Filters the global payloadList by ID by iterating through it and
# appending to a new list by filter-criteria
# @param filterList a list of IDs that are to be transferred to the new list
def filterPayloadsByID(self, filterList):
for payload in Globals.payloadList:
if hasattr(payload, 'payloadHead'):
if Globals.tspDict[
payload.payloadHead.informationID][0] in filterList:
self.filteredPayloadList.append(payload)
else:
#print('informationID is in filteredIdList, skipping packet')
pass
## Filters the global payloadList by Message by iterating through it and
# appending to a new list by filter-criteria
# @param filterDict a dictionary of Key: ObjectType and Value: ObjectsToKeep as a template
# of which items are to be kept in the filteredList
def filterPayloadsByMessage(self, filterDict):
localFilteredList = []
for payload in self.filteredPayloadList:
print('payloadID:' + str(payload.payloadHead.informationID))
# If the ID has nothing to do with the object, we can safely add it.
if payload.payloadHead.informationID is 23:
x = 0
pass
if isRelatedToObject(payload):
for objType, messageID in filterDict.items():
print(Globals.objectTypeDict[getObjectType(payload)])
if Globals.objectTypeDict[getObjectType(
payload
)] == objType: # If the objectType matches the one in the dictionary
if objType == 0:
x = 0
pass
if getDataType(payload) == 2:
if payload.data2 not in messageID: # and the message does not match the dictionary
print(
'Passing data with msgid: ' +
str(payload.data2)
) # don't append, but print that we skipped this one
else:
localFilteredList.append(
payload
) # the message does match the dictionary -> we want to keep it, so we add it to the list
elif getDataType(payload) == 1:
if payload.data1 not in messageID:
print('Passing data with msgid: ' +
str(payload.data1))
else:
localFilteredList.append(payload)
else:
localFilteredList.append(payload)
else:
# If the ID has nothing to do with the object, we can safely add it.
# Also, is the object is not even in the filterDict, we can add it too (this should not happen, but
# it's there for safety purposes
if getDataType(payload) == 0 or Globals.objectTypeDict[
getObjectType(payload)] not in filterDict:
localFilteredList.append(payload)
else:
localFilteredList.append(payload)
# In every other case, append it to the list, since we only want to filter out specific objects
self.filteredPayloadList = list(localFilteredList)
## Create the visible UI
# like the different tables, the searchbar etc.
def setSnifferFilterUi(self):
self.filterTabs = QTabWidget()
self.H1layout = QHBoxLayout()
self.Vlayout = QVBoxLayout()
self.searchInputField = QLineEdit()
self.searchInputField.setPlaceholderText(
'Enter search term, then click search')
self.searchButt = QPushButton('Search Table')
self.saveFilterButt = QPushButton('Save Filter')
self.filterTable = QTableWidget()
self.saveFilterButt.clicked.connect(self.saveFilterList)
self.searchButt.clicked.connect(
lambda: self.searchInTable(self.searchInputField.text(), 0))
# Create Table
self.filterTableIndex = 0
self.filterTable = QTableWidget()
self.filterTableItem = QTableWidgetItem()
self.filterTable.setRowCount(0)
self.filterTable.setColumnCount(2)
self.filterTable.setHorizontalHeaderLabels(
'informationID;Enable'.split(';'))
self.filterTable.resizeColumnsToContents()
self.filterTableHeader = self.filterTable.horizontalHeader()
self.filterTableHeader.setSectionResizeMode(0, QHeaderView.Stretch)
self.filterTableHeader.setSectionResizeMode(
1, QHeaderView.ResizeToContents)
font = self.getFont()
self.checkBoxAllIds = self.createCheckBox()
self.filterTable.itemChanged.connect(self.filterAllIDs)
self.checkBoxAllMessages = self.createCheckBox()
# -- Add first Row for all -- #
self.filterTable.insertRow(self.filterTableIndex)
idFilterItem = QTableWidgetItem('FILTER ALL IDs')
idFilterItem.setFont(font)
messageFilterItem = QTableWidgetItem('FILTER ALL Messages')
messageFilterItem.setFont(font)
self.filterTable.setItem(self.filterTableIndex, 0, idFilterItem)
self.filterTable.setItem(self.filterTableIndex, 1, self.checkBoxAllIds)
self.filterTableIndex = self.filterTableIndex + 1
# -- Add informationID filter rows -- #
for keys, values in Globals.tspDict.items():
if values[0].startswith('ID'):
checkBoxFilter = self.createCheckBox()
self.filterTable.insertRow(self.filterTableIndex)
self.filterTable.setItem(self.filterTableIndex, 0,
QTableWidgetItem(values[0]))
self.filterTable.setItem(self.filterTableIndex, 1,
checkBoxFilter)
self.filterTableIndex = self.filterTableIndex + 1
self.filterTabs.addTab(self.filterTable, 'Information ID')
self.H1layout.addWidget(self.searchInputField)
self.H1layout.addWidget(self.searchButt)
self.Vlayout.addLayout(self.H1layout)
self.Vlayout.addWidget(self.filterTabs)
self.Vlayout.addWidget(self.saveFilterButt)
#------------------------------------
self.setLayout(self.Vlayout)
self.layoutingComplete = True
## Updates the visible filter UI to the new objectList
# This function is called, when either a new measurement was executed or an old measurement was loaded.
# Since the objects shown in the Filter need to be updated.
def updateObjectFilter(self):
# -- Add message filter rows -- #
font = self.getFont()
self.filterTabs.clear()
self.filterTabs.addTab(self.filterTable, 'Information ID')
# For each object in objectList, create a new Table and add it to the tabs.
for keys, values in Globals.objectDict.items():
objectFilterTable = QTableWidget()
objectFilterTable.setRowCount(0)
objectFilterTable.setColumnCount(2)
strSplit = keys + ';Enable'
objectFilterTable.setHorizontalHeaderLabels(strSplit.split(';'))
objectFilterTable.resizeColumnsToContents()
filterTableHeader = objectFilterTable.horizontalHeader()
filterTableHeader.setSectionResizeMode(0, QHeaderView.Stretch)
filterTableHeader.setSectionResizeMode(
1, QHeaderView.ResizeToContents)
checkBoxFilter = self.createCheckBox()
objectFilterTable.itemChanged.connect(
lambda *a, table=objectFilterTable: self.filterAllObjectIDs(
*a, table=table))
objectTableIndex = 0
objectFilterTable.insertRow(objectTableIndex)
objCat = QTableWidgetItem('FILTER ALL')
objCat.setFont(font)
objectFilterTable.setItem(objectTableIndex, 0, objCat)
objectFilterTable.setItem(objectTableIndex, 1, checkBoxFilter)
objectTableIndex = objectTableIndex + 1
for keys2, values2 in values.items():
objectFilterTable.insertRow(objectTableIndex)
checkBoxFilter = self.createCheckBox()
objectFilterTable.setItem(
objectTableIndex, 0,
QTableWidgetItem('ID: ' + str(keys2) + ' Name: ' +
str(values2)))
objectFilterTable.setItem(objectTableIndex, 1, checkBoxFilter)
objectTableIndex = objectTableIndex + 1
# Add the newly create table to the tabs.
self.filterTabs.addTab(objectFilterTable, keys)
self.objectTabDict[keys] = objectFilterTable
## Searches the table for a string and scrolls to the found item.
# @param textToSearch the string that needs to be found in the table
# @param column the column where the search needs to take place
def searchInTable(self, textToSearch, column):
# Create a model of the table, so we can match a text
tableModel = self.filterTable.model()
start = tableModel.index(0, column)
matches = tableModel.match(start, Qt.DisplayRole, textToSearch, 1,
Qt.MatchContains)
# If there are multiple matches, we take the first one, select it and scroll to it
if matches:
index = matches[0]
self.filterTable.selectionModel().select(
index, QItemSelectionModel.Select)
self.filterTable.scrollToItem(
self.filterTable.itemFromIndex(index))
## CB: SaveFilterButton // Call the filterFunctions -> Filter the unfiltered list by ID and Object and call the update
# function of the executing tab in order to update their UI.
def saveFilterList(self):
self.filteredPayloadList.clear()
#--Save by ID--#
rowCnt = self.filterTable.rowCount()
self.filteredIdList.clear()
for rows in range(0, rowCnt):
if self.filterTable.item(rows, 1).checkState() == Qt.Checked:
#print(self.filterTable.item(rows,0).text())
self.filteredIdList.append(
self.filterTable.item(rows, 0).text())
self.filterPayloadsByID(self.filteredIdList)
print(len(self.filteredPayloadList))
print(len(Globals.payloadList))
#--Save By Objects--#
self.filteredObjectDict.clear()
for objType, objectTable in self.objectTabDict.items():
rowCnt = objectTable.rowCount()
objectsToFilter = []
for rows in range(0, rowCnt):
if objectTable.item(rows, 1).checkState() == Qt.Checked:
#print(objectTable.item(rows,0).text())
try:
objectsToFilter.append(
int(
re.search('ID: (.*) Name:.*',
objectTable.item(
rows, 0).text()).group(1)))
self.filteredObjectDict[objType] = objectsToFilter
#print('Found Regex: '+re.search('ID: (.*) Name:.*',objectTable.item(rows,0).text()).group(1))
except:
print('Error when parsing TableRegex...this is okay')
self.filterPayloadsByMessage(self.filteredObjectDict)
# We filtered the list, now we hide the windows and call the update-function
# If the maintainer of the tab did not follow the implementation guide, there is no update-function to call.
# We still save the filtered list, so we print a message to show where to find it.
self.hide()
try:
self.parent.filterUpdated(self.filteredIdList,
self.filteredPayloadList)
except AttributeError:
print(
'No corresponding callable function filterUpdated was found, you can access the most recent filteredList via self.snifferFilter.filteredIdList'
)
try:
Globals.dockDict[self.calledBy].filterUpdated(
self.filteredIdList, self.filteredPayloadList)
except:
print('not global!')
## Check whether the first checkbox was checked and then update the entire ID table to either checked or unchecked state
# @param checkBox a checkBox we perform the query on
def filterAllIDs(self, checkBox):
if self.layoutingComplete == True:
if checkBox.column() == 1 and checkBox.row(
) == 0: # We clicked the toggle ID checkbox
if checkBox.checkState() == Qt.Checked:
rowCnt = self.filterTable.rowCount()
for rows in range(0, rowCnt):
try:
self.filterTable.item(rows,
1).setCheckState(Qt.Checked)
except AttributeError:
print(
'no items after' + str(rows) +
'found...Maybe this column has less items than'
+ str(rowCnt) + '?')
elif checkBox.checkState() == Qt.Unchecked:
rowCnt = self.filterTable.rowCount()
for rows in range(0, rowCnt):
try:
self.filterTable.item(rows, 1).setCheckState(
Qt.Unchecked)
except AttributeError:
print(
'no items after' + str(rows) +
'found...Maybe this column has less items than'
+ str(rowCnt) + '?')
else:
print(
'neither checked nor unchecked...should never be here..'
)
## Check whether the first checkbox was checked and then update the entire ObjectIDtable to either checked or unchecked state
# @param checkBox a checkBox we perform the query on
# @param table the table that is to be updated
def filterAllObjectIDs(self, checkBox, table):
if (self.objectTabDict):
if checkBox.column() == 1 and checkBox.row(
) == 0: # We clicked the toggle ID checkbox
if checkBox.checkState() == Qt.Checked:
rowCnt = table.rowCount()
for rows in range(0, rowCnt):
try:
table.item(rows, 1).setCheckState(Qt.Checked)
except AttributeError:
print(
'no items after' + str(rows) +
'found...Maybe this column has less items than'
+ str(rowCnt) + '?')
elif checkBox.checkState() == Qt.Unchecked:
rowCnt = table.rowCount()
for rows in range(0, rowCnt):
try:
table.item(rows, 1).setCheckState(Qt.Unchecked)
except AttributeError:
print(
'no items after' + str(rows) +
'found...Maybe this column has less items than'
+ str(rowCnt) + '?')
else:
print(
'neither checked nor unchecked...should never be here..'
)
# --- HELPER FUNCTIONS --- #
## Create a defined checkbox within a tableWidgetItem to facilitate filling the table
# @return the created checkbox
def createCheckBox(self):
myCheck = QTableWidgetItem()
myCheck.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
myCheck.setCheckState(Qt.Checked)
return myCheck
## Create a defined font (bold,underlined) to facilitate filling the table
# @return the created font
def getFont(self):
font = QFont()
font.setBold(True)
font.setUnderline(True)
return font
class SnifferStats(QDialog):
## The constructor.
def __init__(self):
super().__init__()
print('Stating')
self.iDList = []
self.packetCount = 0
self.counter = 0
self.statsTableIndex = 0
self.setWindowTitle('SnifferStats')
self.snifferAPI = SnifferAPI()
self.contentBox = QLabel()
self.statsTable = QTableWidget()
self.tabs = QTabWidget()
self.tabBasic = QWidget()
self.tabAdvanced = QWidget()
self.layout = QVBoxLayout()
self.tabs.addTab(self.tabBasic,"Basic")
self.tabs.addTab(self.tabAdvanced,"Advanced")
self.tabBasic.layout = QVBoxLayout()
self.tabAdvanced.layout = QVBoxLayout()
## Shows the stats in Label and Table (Basic and Advanced Tab).
def showStats(self):
self.clearTableStats()
self.clearLabelStats()
#-Advanced Tab
self.iDList = self.snifferAPI.getAllInfoIDs(Globals.payloadList)
self.counter = self.snifferAPI.getCountedInfoIDs(self.iDList)
self.fillStatTable(Globals.payloadList, self.counter, self.statsTable, self.statsTableIndex)
#-Basic Tab
self.setBasicCount(self.contentBox, Globals.payloadList)
## Counts identical informationIDs of the list given as the first parameter
# and fills the StatTable in SnifferStats.
# This function can be further used to modify SnifferStats table.
# Note: This function requires access to the tspDict
# @param rList payloadList or filteredList
# @param counter as counted list
# @param statsTable member
# @param statsTableIndex variable
def fillStatTable(self, rList, counter, statsTable, statsTableIndex):
try:
for iD,amount in counter.items():
statsTable.insertRow(statsTableIndex)
statsTable.setItem(statsTableIndex, 0, QTableWidgetItem(Globals.tspDict[iD][0]))
statsTable.setItem(statsTableIndex, 1, QTableWidgetItem(str(iD)))
statsTable.setItem(statsTableIndex, 2,QTableWidgetItem(str(amount)))
statsTableIndex = statsTableIndex + 1
tList = self.snifferAPI.getSizeOfObjects(rList)
statsTableIndex = 0
for size in tList:
statsTable.setItem(statsTableIndex, 3, QTableWidgetItem(str(size)))
statsTableIndex = statsTableIndex + 1
except Exception as e:
print("Exception occurred: "+str(e))
## Writes the PacketCount using getAllPayloadCount() to the label
# specified as parameter
# @param cLabel content label
# @param rList payloadList or filteredList
def setBasicCount(self, cLabel, rList):
try:
tList = self.snifferAPI.getSizeOfObjects(Globals.payloadList)
myString = ("Total Packet Count (without failed): "+ str(self.snifferAPI.getAllPayloadCountWithoutFailed(Globals.payloadList, Globals.tspDict))+"\n"
+"\nTotal Packet Count (all): "+ str(self.snifferAPI.getAllPayloadCountWithFailed(Globals.payloadList))+"\n"
+ "\nTotal load size: "+ str(self.snifferAPI.getListSize(Globals.payloadList))+"\n"
+ "\nMinimal packet size: "+str(self.snifferAPI.getMinSizeOfList(Globals.payloadList))+"\n"
+ "\nMaximal packet size: "+str(self.snifferAPI.getMaxSizeOfList(Globals.payloadList))+"\n"
+ "\nInfoID of minimal packet size: "+str(self.snifferAPI.getInfoIdOfMinObj(Globals.payloadList, Globals.tspDict)[0])
+" ("+str(self.snifferAPI.getInfoIdOfMinObj(Globals.payloadList, Globals.tspDict)[1])+")\n"
+ "\nInfoID of maximal packet size: "+str(self.snifferAPI.getInfoIdOfMaxObj(Globals.payloadList, Globals.tspDict)[0])
+" ("+str(self.snifferAPI.getInfoIdOfMaxObj(Globals.payloadList, Globals.tspDict)[1])+")\n"
+"\nOccurrence of ID_MOVED_TASK_TO_READY_STATE: "+str(self.snifferAPI.getInfoIdTickCount(Globals.payloadList, 11))+" ticks \n" #id is here fix, group evaluates which types are most relevant
+"\nCount of all non task objects : "+str(self.snifferAPI.getCountNonTaskObj(Globals.objectDict))+"\n"
+"\nCount of task objects : "+str(self.snifferAPI.getCountTaskObj(Globals.objectDict))+"\n"
+"\nAll objects: "+str(self.snifferAPI.getObjTypesList(Globals.objectDict))+"\n"
+"\nTime of Measurement : "+str(self.snifferAPI.getMeasurementTimeSingleShot(Globals.payloadList))+" sec\n"
+"\nAverage data rate : "+str(self.snifferAPI.getDatarate(Globals.payloadList))+" kbit/sec\n")
cLabel.setText(myString)
except Exception as e:
print("Exception occurred: "+str(e))
## Sets the SnifferUI
def setSnifferStatsUi(self):
self.setAdvancedTab()
self.setBasicTab()
## Sets the Advanced Tab
def setAdvancedTab(self):
self.statsTableItem = QTableWidgetItem()
self.statsTable.setRowCount(0)
self.statsTable.setColumnCount(4)
self.statsTable.setHorizontalHeaderLabels('InformationID;NumericID;Occurrence;PacketSize'.split(';'))
self.statsTable.resizeColumnsToContents()
self.statsTableHeader = self.statsTable.horizontalHeader()
self.statsTableHeader.setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.statsTableHeader.setSectionResizeMode(1, QHeaderView.ResizeToContents)
self.statsTableHeader.setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.statsTableHeader.setSectionResizeMode(3, QHeaderView.ResizeToContents)
self.closeButt = QPushButton('Clear')
self.closeButt.clicked.connect(self.clearTableStats)
self.tabAdvanced.layout.addWidget(self.statsTable)
self.tabAdvanced.layout.addWidget(self.closeButt)
self.tabAdvanced.setLayout(self.tabAdvanced.layout)
#------------------------------------
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
## Sets the Basic Tab
def setBasicTab(self):
self.scrollArea = QScrollArea()
self.scrollArea.setWidget(self.contentBox)
self.contentBox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.scrollArea.setWidgetResizable(True)
self.closeButt = QPushButton('Clear')
self.closeButt.clicked.connect(self.clearLabelStats)
self.tabBasic.layout.addWidget(self.scrollArea)
self.tabBasic.layout.addWidget(self.closeButt)
self.tabBasic.setLayout(self.tabBasic.layout)
## Clears the SnifferStats by calling an API function
def clearTableStats(self):
self.deleteStats(self.iDList)
## Clears the SnifferStats by calling an API function
def clearLabelStats(self):
self.contentBox.clear()
## Clears the StatsView and resets according lists
# @param list2 with all infoIDs (corresponding to second parameter in getAllInfoIDs()
def deleteStats(self, list2):
self.statsTable.setRowCount(0)
self.statsTableIndex = 0
self.counter = 0
list2[:] = []
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle(WINDOW_TITLE)
from pathlib import Path
file_name = str(Path(__file__).resolve().parent / 'favicon.ico')
icon = QIcon(file_name)
self.setWindowIcon(icon)
self.tray = QSystemTrayIcon(icon)
self.tray.setToolTip(self.windowTitle())
self.tray.activated.connect(self._on_tray_activated)
self.tray.show()
self.logged_dict = dict()
self.pb_refresh = QPushButton('REFRESH')
self.pb_refresh.clicked.connect(self.refresh)
self.cb_show_log = QCheckBox()
self.cb_show_log.setChecked(True)
self.log = QPlainTextEdit()
self.log.setReadOnly(True)
self.log.setWordWrapMode(QTextOption.NoWrap)
log_font = self.log.font()
log_font.setFamily('Courier New')
self.log.setFont(log_font)
self.cb_show_log.clicked.connect(self.log.setVisible)
self.log.setVisible(self.cb_show_log.isChecked())
header_labels = ['DATE', 'TOTAL LOGGED TIME']
self.table_logged = QTableWidget()
self.table_logged.setEditTriggers(QTableWidget.NoEditTriggers)
self.table_logged.setSelectionBehavior(QTableWidget.SelectRows)
self.table_logged.setSelectionMode(QTableWidget.SingleSelection)
self.table_logged.setColumnCount(len(header_labels))
self.table_logged.setHorizontalHeaderLabels(header_labels)
self.table_logged.horizontalHeader().setStretchLastSection(True)
self.table_logged.itemClicked.connect(
self._on_table_logged_item_clicked)
header_labels = ['TIME', 'LOGGED', 'JIRA']
self.table_logged_info = QTableWidget()
self.table_logged_info.setEditTriggers(QTableWidget.NoEditTriggers)
self.table_logged_info.setSelectionBehavior(QTableWidget.SelectRows)
self.table_logged_info.setSelectionMode(QTableWidget.SingleSelection)
self.table_logged_info.setColumnCount(len(header_labels))
self.table_logged_info.setHorizontalHeaderLabels(header_labels)
self.table_logged_info.horizontalHeader().setSectionResizeMode(
1, QHeaderView.ResizeToContents)
self.table_logged_info.horizontalHeader().setStretchLastSection(True)
self.table_logged_info.itemDoubleClicked.connect(
self._on_table_logged_info_item_double_clicked)
main_layout = QVBoxLayout()
central_widget = QWidget()
central_widget.setLayout(main_layout)
self.setCentralWidget(central_widget)
self.pb_refresh.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred))
h_layout = QHBoxLayout()
h_layout.addWidget(self.pb_refresh)
h_layout.addWidget(self.cb_show_log)
layout_table_widget = QVBoxLayout()
layout_table_widget.setContentsMargins(0, 0, 0, 0)
layout_table_widget.addWidget(self.table_logged)
layout_table_widget.addWidget(self.table_logged_info)
table_widget = QWidget()
table_widget.setLayout(layout_table_widget)
splitter = QSplitter(Qt.Horizontal)
splitter.addWidget(table_widget)
splitter.addWidget(self.log)
main_layout.addLayout(h_layout)
main_layout.addWidget(splitter)
def _fill_tables(self, xml_data: bytes):
import io
buffer_io = io.StringIO()
from contextlib import redirect_stdout
try:
with redirect_stdout(buffer_io):
print(len(xml_data), repr(xml_data[:50]))
# Структура документа -- xml
self.logged_dict = parse_logged_dict(xml_data)
print(self.logged_dict)
if not self.logged_dict:
return
import json
print(
json.dumps(self.logged_dict, indent=4, ensure_ascii=False))
print()
logged_list = get_logged_list_by_now_utc_date(self.logged_dict)
logged_total_seconds = get_logged_total_seconds(logged_list)
logged_total_seconds_str = seconds_to_str(logged_total_seconds)
print('entry_logged_list:', logged_list)
print('today seconds:', logged_total_seconds)
print('today time:', logged_total_seconds_str)
print()
# Для красоты выводим результат в табличном виде
lines = []
# Удаление строк таблицы
while self.table_logged.rowCount():
self.table_logged.removeRow(0)
for i, (date_str, logged_list) in enumerate(
get_sorted_logged(self.logged_dict)):
total_seconds = get_logged_total_seconds(logged_list)
total_seconds_str = seconds_to_str(total_seconds)
row = date_str, total_seconds_str, total_seconds
lines.append(row)
self.table_logged.setRowCount(
self.table_logged.rowCount() + 1)
self.table_logged.setItem(i, 0, QTableWidgetItem(date_str))
item = QTableWidgetItem(total_seconds_str)
item.setToolTip('Total seconds: {}'.format(total_seconds))
self.table_logged.setItem(i, 1, item)
self.table_logged.setCurrentCell(0, 0)
self.table_logged.setFocus()
self._on_table_logged_item_clicked(
self.table_logged.currentItem())
# Список строк станет списком столбцов, у каждого столбца подсчитается максимальная длина
max_len_columns = [
max(map(len, map(str, col))) for col in zip(*lines)
]
# Создание строки форматирования: [30, 14, 5] -> "{:<30} | {:<14} | {:<5}"
my_table_format = ' | '.join('{:<%s}' % max_len
for max_len in max_len_columns)
for line in lines:
print(my_table_format.format(*line))
finally:
text = buffer_io.getvalue()
self.log.setPlainText(text)
print(text)
def refresh(self):
progress_dialog = QProgressDialog(self)
thread = RunFuncThread(func=get_rss_jira_log)
thread.run_finished.connect(self._fill_tables)
thread.run_finished.connect(progress_dialog.close)
thread.start()
progress_dialog.setWindowTitle('Please wait...')
progress_dialog.setLabelText(progress_dialog.windowTitle())
progress_dialog.setRange(0, 0)
progress_dialog.exec()
from datetime import datetime
self.setWindowTitle(WINDOW_TITLE + ". Last refresh date: " +
datetime.now().strftime('%d/%m/%Y %H:%M:%S'))
def _on_table_logged_item_clicked(self, item: QTableWidgetItem):
# Удаление строк таблицы
while self.table_logged_info.rowCount():
self.table_logged_info.removeRow(0)
row = item.row()
date_str = self.table_logged.item(row, 0).text()
logged_list = self.logged_dict[date_str]
logged_list = reversed(logged_list)
for i, logged in enumerate(logged_list):
self.table_logged_info.setRowCount(
self.table_logged_info.rowCount() + 1)
self.table_logged_info.setItem(i, 0,
QTableWidgetItem(logged['time']))
self.table_logged_info.setItem(
i, 1, QTableWidgetItem(logged['logged_human_time']))
item = QTableWidgetItem(logged['jira_id'])
item.setToolTip(logged['jira_title'])
self.table_logged_info.setItem(i, 2, item)
def _on_table_logged_info_item_double_clicked(self,
item: QTableWidgetItem):
row = item.row()
jira_id = self.table_logged_info.item(row, 2).text()
url = 'https://jira.compassplus.ru/browse/' + jira_id
import webbrowser
webbrowser.open(url)
def _on_tray_activated(self, reason):
self.setVisible(not self.isVisible())
if self.isVisible():
self.showNormal()
self.activateWindow()
def changeEvent(self, event: QEvent):
if event.type() == QEvent.WindowStateChange:
# Если окно свернули
if self.isMinimized():
# Прячем окно с панели задач
QTimer.singleShot(0, self.hide)
class HistoryQWidget(QWidget):
"""
Class who create the History QWidget for host
"""
def __init__(self, parent=None):
super(HistoryQWidget, self).__init__(parent)
self.setStyleSheet(settings.css_style)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setObjectName('dialog')
self.setMinimumSize(800, 670)
# Fields
self.history_table = QTableWidget()
self.table_headers = [_('Events')]
self.history_title = QLabel()
self.offset = None
def initialize(self):
"""
Initialize History QWidget
"""
main_layout = QVBoxLayout(self)
main_layout.setContentsMargins(0, 0, 0, 0)
# Title Window
main_layout.addWidget(get_logo_widget(self, _('History')))
# History QWidget
history_widget = QWidget()
history_layout = QVBoxLayout(history_widget)
# History QTableWidget
self.history_table.setObjectName('history')
self.history_table.verticalHeader().hide()
self.history_table.verticalHeader().setDefaultSectionSize(100)
self.history_table.setColumnCount(len(self.table_headers))
self.history_table.setColumnWidth(0, 600)
self.history_table.setSortingEnabled(True)
self.history_table.setHorizontalScrollMode(QAbstractItemView.ScrollPerItem)
self.history_table.setHorizontalHeaderLabels(self.table_headers)
self.history_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.history_table.horizontalHeader().setStretchLastSection(True)
self.history_table.horizontalHeader().setMinimumHeight(30)
history_layout.addWidget(self.history_table)
main_layout.addWidget(history_widget)
center_widget(self)
def update_history_data(self, hostname, host_history):
"""
Update data of history QTableWidget
:param hostname: name of the host
:type hostname: str
:param host_history: history of host
:type host_history: History
"""
logger.debug('Open History for %s', hostname)
self.history_table.setRowCount(len(host_history.data))
self.history_table.setHorizontalHeaderLabels(
[_("The last 25 events for %s") % hostname.capitalize()]
)
row = 0
for event in host_history.data:
event_widget = self.get_event_widget(hostname, event)
self.history_table.setCellWidget(row, 0, event_widget)
row += 1
def get_event_widget(self, hostname, event):
"""
Return event QWidget with icon, event text and event message
:param hostname: name of host attached to event
:type hostname: str
:param event: data of an event
:type event: dict
:return: widget of event
:rtype: QWidget
"""
event_widget = QWidget()
event_widget.setObjectName('history')
event_widget.setToolTip(event['type'])
event_layout = QGridLayout(event_widget)
# Event icon
icon_pixmap = self.get_icon_label(event)
event_layout.addWidget(icon_pixmap, 0, 0, 2, 1)
# Event type (with date)
event_title = QLabel()
event_title.setObjectName(
History.get_history_icon_name(event['message'], event['type'])
)
local_timestamp = get_local_datetime_from_date(event['_updated'])
created_since = get_diff_since_last_timestamp(local_timestamp.timestamp())
event_type = self.get_event_type(event, hostname)
event_type_dated = '%s (%s)' % (event_type, created_since)
event_title.setText(event_type_dated)
event_layout.addWidget(event_title, 0, 1, 1, 1)
# Event message
event_msg = QLabel()
event_msg.setWordWrap(True)
event_msg.setText(event['message'])
event_layout.addWidget(event_msg, 1, 1, 1, 1)
return event_widget
@staticmethod
def get_icon_label(event):
"""
Return QWidget with corresponding icon to item state
:param event: data of an event
:type event: dict
:return: icon QWidget
:rtype: QWidget
"""
icon_label = QLabel()
icon = QPixmap(
settings.get_image(
History.get_history_icon_name(event['message'], event['type'])
)
)
icon_label.setPixmap(icon)
icon_label.setFixedSize(32, 32)
icon_label.setScaledContents(True)
return icon_label
@staticmethod
def get_event_type(event, hostname):
"""
Return event type for history
:param event: event of history
:type event: dict
:param hostname: name of host attached to event
:type hostname: str
:return: the event type
:rtype: str
"""
event_type = ''
if 'service_name' in event:
if event['service_name']:
event_type = _('Service: %s') % event['service_name'].capitalize()
if not event_type:
event_type = _('Host: %s') % hostname.capitalize()
return event_type
def paintEvent(self, _): # pragma: no cover
"""Override to apply "background-color" property of QWidget"""
opt = QStyleOption()
opt.initFrom(self)
painter = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
def mousePressEvent(self, event): # pragma: no cover
""" QWidget.mousePressEvent(QMouseEvent) """
self.offset = event.pos()
def mouseMoveEvent(self, event): # pragma: no cover
""" QWidget.mousePressEvent(QMouseEvent) """
try:
x = event.globalX()
y = event.globalY()
x_w = self.offset.x()
y_w = self.offset.y()
self.move(x - x_w, y - y_w)
except AttributeError as e:
logger.warning('Move Event %s: %s', self.objectName(), str(e))
class CustomsQWidget(QWidget):
"""
Class who create Customs Qwidget for host
"""
def __init__(self, parent=None):
super(CustomsQWidget, self).__init__(parent)
self.setStyleSheet(settings.css_style)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setObjectName('dialog')
self.setMinimumSize(420, 330)
# Fields
self.customs_table = QTableWidget()
self.table_headers = ['Variable', 'Value']
self.offset = None
def initialize(self):
"""
Initialize Customs QWidget
"""
main_layout = QVBoxLayout(self)
main_layout.setContentsMargins(0, 0, 0, 0)
# Title Window
main_layout.addWidget(
get_logo_widget(self, _('Custom variables'))
)
# Customs QWidget
customs_widget = QWidget()
customs_layout = QVBoxLayout(customs_widget)
# Customs QTableWidget
self.customs_table.setObjectName('history')
self.customs_table.verticalHeader().hide()
self.customs_table.setColumnCount(len(self.table_headers))
self.customs_table.setColumnWidth(0, 200)
self.customs_table.setColumnWidth(1, 200)
self.customs_table.setSortingEnabled(True)
self.customs_table.setHorizontalScrollMode(QAbstractItemView.ScrollPerItem)
self.customs_table.setHorizontalHeaderLabels(self.table_headers)
self.customs_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.customs_table.horizontalHeader().setStretchLastSection(True)
self.customs_table.horizontalHeader().setMinimumHeight(30)
customs_layout.addWidget(self.customs_table)
main_layout.addWidget(customs_widget)
center_widget(self)
def update_customs(self, host_item):
"""
Update customs QTableWidget with customs of host item
:param host_item: Host item
:type host_item: alignak_app.items.host.Host
"""
logger.debug('Open Customs for %s', host_item.name)
self.customs_table.clear()
self.customs_table.setHorizontalHeaderLabels(self.table_headers)
self.customs_table.setRowCount(len(host_item.data['customs']))
row = 0
for custom in host_item.data['customs']:
title_item = QTableWidgetItem()
title = ''
if '_' in custom[:1]:
title = custom[1:]
title = title.replace('_', ' ').capitalize()
title_item.setText(title)
title_item.setToolTip(custom)
self.customs_table.setItem(row, 0, title_item)
data_item = QTableWidgetItem()
data_item.setText(str(host_item.data['customs'][custom]))
self.customs_table.setItem(row, 1, data_item)
row += 1
def paintEvent(self, _): # pragma: no cover
"""Override to apply "background-color" property of QWidget"""
opt = QStyleOption()
opt.initFrom(self)
painter = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
def mousePressEvent(self, event): # pragma: no cover
""" QWidget.mousePressEvent(QMouseEvent) """
self.offset = event.pos()
def mouseMoveEvent(self, event): # pragma: no cover
""" QWidget.mousePressEvent(QMouseEvent) """
try:
x = event.globalX()
y = event.globalY()
x_w = self.offset.x()
y_w = self.offset.y()
self.move(x - x_w, y - y_w)
except AttributeError as e:
logger.warning('Move Event %s: %s', self.objectName(), str(e))
