def waitForSignal(signal, message="", timeout=0):
"""Waits (max timeout msecs if given) for a signal to be emitted.
It the waiting lasts more than 2 seconds, a progress dialog is displayed
with the message.
Returns True if the signal was emitted.
Return False if the wait timed out or the dialog was canceled by the user.
"""
loop = QEventLoop()
dlg = QProgressDialog(minimum=0, maximum=0, labelText=message)
dlg.setWindowTitle(appinfo.appname)
dlg.setWindowModality(Qt.ApplicationModal)
QTimer.singleShot(2000, dlg.show)
dlg.canceled.connect(loop.quit)
if timeout:
QTimer.singleShot(timeout, dlg.cancel)
stop = lambda: loop.quit()
signal.connect(stop)
loop.exec_()
signal.disconnect(stop)
dlg.hide()
dlg.deleteLater()
return not dlg.wasCanceled()
def handle_scan(self, param):
ox_len = int(abs(Settings.settings['lrServoMax'] - Settings.settings['lrServoMin']) / Settings.settings['lrStep'])+1
oy_len = int(abs(Settings.settings['udServoMax'] - Settings.settings['udServoMin']) / Settings.settings['udStep'])+1
arduinoCtrl.set_lr_servo(Settings.settings['lrServoMin'])
arduinoCtrl.set_ud_servo(Settings.settings['udServoMin'])
total_points = ox_len * oy_len
progress = QProgressDialog('Scanning thermal image', 'Stop', 0, total_points)
self.mMatrix = np.zeros((oy_len, ox_len))+23
self.mQPixmap = QPixmap(ox_len, oy_len)
self.mQPixmap.fill()
rectangleScanJob = RectangleScanJob()
rectangleScanJob.new_value.connect(self.handle_temperature)
rectangleScanJob.progress.connect(progress.setValue)
rectangleScanJob.start()
#rectangleScanJob.run()
progress.exec_()
if progress.wasCanceled():
rectangleScanJob.terminate()
return
self.update_picture_from_matrix()
def download_catalogs(self):
dialog = QDialog()
dialog.setWindowTitle('Download Catalogs')
dialog.setLayout(QVBoxLayout())
dialog.layout().addWidget(QLabel('Select catalogues to be downloaded'))
checkboxes = dict([(c, QCheckBox(c)) for c in self.reference_catalogues.catalogues])
for name, checkbox in checkboxes.items():
checkbox.setChecked(True)
dialog.layout().addWidget(checkbox)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonbox.accepted.connect(dialog.accept)
buttonbox.rejected.connect(dialog.reject)
dialog.layout().addWidget(buttonbox)
if dialog.exec() == QDialog.Rejected:
return
for cat, checkbox in checkboxes.items():
if not checkbox.isChecked():
continue
spectra = self.reference_catalogues.spectra(cat)
progress = QProgressDialog('Downloading spectra from catalog {}'.format(cat), 'Cancel', 0, len(spectra))
progress.setWindowTitle('Downloading catalogs')
progress.setWindowModality(Qt.WindowModal)
progress.show()
for index, spectrum in enumerate(spectra):
progress.setValue(index)
if progress.wasCanceled():
return;
QApplication.instance().processEvents()
self.reference_catalogues.fits(spectrum)
def download(self):
# GET FILE
if not self.selected_file:
show_popup("Error", "Please select a file first.")
return False
if not self.save_dir:
show_popup("Error", "Please select a destination folder first.")
return False
with open(self.selected_file) as f:
album_ids = json.loads(f.read())
# GET SELECTED QUALITY
quality = self.combobox.currentData()
# LOAD COOKIES IF EXIST
cj, successful = load_cookies(COOKIE_FILE)
if successful:
self.session.cookies = cj
self.loggedIn = True
show_popup("Logged in", "Automatically logged in.")
# GET SESSION
if not self.loggedIn:
self.show_sign_in_dialog()
# CHECK IF LOGIN SUCESSFUL
if not self.loggedIn:
show_popup("Error", "Login failed.")
return
length = str(len(album_ids))
bar = QProgressDialog("Downloading songs (1/" + length + ")", "Cancel", 0, int(length))
bar.setWindowTitle("Downloading songs")
bar.setValue(0)
count = 1
downloadsuccess = True
# DOWNLOAD
for album_id in album_ids:
download_link = DOWNLOAD_BASE + album_id + "/download" + quality
success = download_file(download_link, self.save_dir, self.session)
if not success:
show_popup("Cancelled", "Download was cancelled.")
downloadsuccess = False
break
bar.setValue(count)
bar.setLabelText("Downloading songs (" + str(count) + "/" + length + ")")
count += 1
if bar.wasCanceled():
show_popup("Cancelled", "Download was cancelled.")
downloadsuccess = False
break
QApplication.processEvents()
# break # activate for testing
if downloadsuccess:
show_popup("Success!", "Download finished!")
else:
show_popup("Finished.", "Finished with errors. Probably cancelled.")
def __init__(self, parent):
flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint
QProgressDialog.__init__(self, '', "Cancel", 0, 100, parent, flags)
self.setModal(True)
self.setAutoReset(False)
self.setAutoClose(False)
self._timer = QTimer()
self._jobid = ''
self._timer.timeout.connect(self.updateProgress)
def generateBackground(self):
minFrame = self.videoPlaybackWidget.getMinRange()
maxFrame = self.videoPlaybackWidget.getMaxRange()
stride = self.strideSpinBox.value()
numFrames = int((maxFrame-minFrame)/stride)
progress = QProgressDialog("Generating background...", "Abort", 0, numFrames, self)
progress.setWindowModality(Qt.WindowModal)
fgbg = cv2.createBackgroundSubtractorMOG2()
currentFrameNo = self.videoPlaybackWidget.currentFrameNo
for i, frameNo in enumerate(range(minFrame, maxFrame+1, stride)):
progress.setValue(i)
if progress.wasCanceled():
break
ret, frame = self.videoPlaybackWidget.readFrame(frameNo)
fgbg.apply(frame)
if not progress.wasCanceled():
self.fgbg = fgbg
self.setFrame(self.cv_img)
progress.setValue(numFrames)
self.videoPlaybackWidget.currentFrameNo = currentFrameNo
def create_progress_bar(self, title):
progress = QProgressDialog(self)
progress.setAutoClose(False)
progress.setWindowTitle(title)
progress.setCancelButton(None)
progress.setWindowModality(Qt.WindowModal)
return progress
def invent(self) :
prog=QProgressDialog("Compiling inventory...","Cancel",0,100,self)
prog.open()
allconn=cursor.connection()
curs=allconn[0]
data=allconn[1]
curs.execute("""SELECT * FROM "main"."chem" WHERE "id" > 0 """)
store=curs.fetchall()
a=excel.makeinvent(store)
a.begin()
internal=0
if prog.wasCanceled() :
return None
while internal != 100 :
try :
internal=(a.returnid()/len(store))*100
except :
internal=100
prog.setValue(internal)
if prog.wasCanceled() :
return None
b=a.returnbook()
try :
fname=QFileDialog.getSaveFileName(self, 'Save File', '/','Excel File (*.xls)')[0]
b.save(fname)
QMessageBox.information(self, "Info", "Inventory was saved sucessfully.")
if prog.wasCanceled() :
return None
except :
QMessageBox.information(self, "Info", "Inventory was no saved.")
def build_assets_db(parent):
assets_db_file = Config().read("assets_db")
starbound_folder = Config().read("starbound_folder")
assets_db = assets.Assets(assets_db_file, starbound_folder)
missing_assets_text = """<html><body>
<p>starcheat couldn't find any Starbound assets. You should double check:</p>
<ol>
<li>You selected the right Starbound folder.</li>
<li>The assets you want to use have been unpacked. Instructions are
<a href="https://github.com/wizzomafizzo/starcheat#unpacking-starbound-assets">here</a>
and this includes vanilla Starbound assets.</li>
</ol>
<p>Once that's done, try restart starcheat to run the setup again.</p>
</body></html>"""
def bad_asset_dialog():
dialog = QMessageBox()
dialog.setText("Unable to index assets.")
dialog.setInformativeText(missing_assets_text)
dialog.setIcon(QMessageBox.Critical)
dialog.exec()
assets_db.db.close()
os.remove(assets_db_file)
assets_db.init_db()
asset_files = assets_db.find_assets()
total = 0
progress = QProgressDialog("Indexing Starbound assets...",
"Cancel", 0, len(asset_files),
parent)
progress.setWindowModality(QtCore.Qt.ApplicationModal)
progress.forceShow()
for i in assets_db.create_index():
total += 1
progress.setValue(total)
if progress.wasCanceled():
assets_db.db.close()
os.remove(assets_db_file)
return False
progress.hide()
if total == 0:
bad_asset_dialog()
return False
else:
return True
def _show_backup_decision(self, error=None):
text = '<p>{0}</p><p>{1}</p>'.format(
self.BACKUP_INTRO_TEXT if error is None else error,
self.BACKUP_PROMPT_TEXT,
)
dialog = QMessageBox(
QMessageBox.Question if error is None else QMessageBox.Critical,
self.BACKUP_DIALOG_CAPTION if error is None else self.BACKUP_DIALOG_ERROR_CAPTION,
text,
)
revert_button = dialog.addButton(self.REVERT_BACKUP_BUTTON_TEXT, QMessageBox.AcceptRole)
delete_button = dialog.addButton(self.DELETE_BACKUP_BUTTON_TEXT, QMessageBox.DestructiveRole)
examine_button = dialog.addButton(self.EXAMINE_BACKUP_BUTTON_TEXT, QMessageBox.ActionRole)
dialog.addButton(self.QUIT_BUTTON_TEXT, QMessageBox.RejectRole)
dialog.exec()
clicked_button = dialog.clickedButton()
if clicked_button == examine_button:
QMetaObject.invokeMethod(self, '_examine_backup', Qt.QueuedConnection)
elif clicked_button == revert_button:
self._progress_dialog = QProgressDialog(None)
self._progress_dialog.setLabelText(self.REVERT_BACKUP_PROGRESS_TEXT)
self._progress_dialog.setCancelButton(None)
self._progress_dialog.setRange(0, 0)
self._progress_dialog.forceShow()
self.request_revert_backup.emit()
elif clicked_button == delete_button:
self.request_delete_backup.emit()
else:
self.quit()
def run(self):
if self._configuration:
try:
self._configuration.check_all()
self._reinit_simu()
self._progress_bar = QProgressDialog("Simulating...", "Abort",
0, 100)
self._progress_bar.canceled.connect(self.abort)
self._progress_bar.show()
self.worker = RunSimulation()
self._model = Model(self._configuration,
callback=self.worker.updateProgress)
self.worker.set_model(self._model)
self.worker.finished.connect(self.runFinished)
self.worker.start()
self.worker.updateProgressBar.connect(self.updateProgressBar)
except Exception as msg:
QMessageBox.warning(self, "Configuration error", str(msg))
self._reinit_simu()
self.runFinished()
def setupUi(self):
self.log.debug("Initializing UI.")
self.load_ui("dta.ui")
# set up source/target autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.source.setCompleter(self.type_completion)
self.target.setCompleter(self.type_completion)
# setup indications of errors on source/target/default
self.orig_palette = self.source.palette()
self.error_palette = self.source.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_source_error()
self.clear_target_error()
# set up processing thread
self.thread = QThread()
self.worker = ResultsUpdater(self.query)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
self.thread.finished.connect(self.update_complete)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from DTA INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.dta").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.max_path_length.setEnabled(self.all_paths.isChecked())
self.source.setEnabled(not self.flows_in.isChecked())
self.target.setEnabled(not self.flows_out.isChecked())
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.buttonBox.clicked.connect(self.run)
self.source.textEdited.connect(self.clear_source_error)
self.source.editingFinished.connect(self.set_source)
self.target.textEdited.connect(self.clear_target_error)
self.target.editingFinished.connect(self.set_target)
self.all_paths.toggled.connect(self.all_paths_toggled)
self.flows_in.toggled.connect(self.flows_in_toggled)
self.flows_out.toggled.connect(self.flows_out_toggled)
self.reverse.stateChanged.connect(self.reverse_toggled)
self.exclude_types.clicked.connect(self.choose_excluded_types)
def setupUi(self):
self.load_ui("typeattrquery.ui")
# populate attr list
self.attr_model = SEToolsListModel(self)
self.attr_model.item_list = sorted(r for r in self.policy.typeattributes())
self.attrs.setModel(self.attr_model)
# populate type list
self.type_model = SEToolsListModel(self)
self.type_model.item_list = sorted(self.policy.types())
self.types.setModel(self.type_model)
# set up results
self.table_results_model = TypeAttributeTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# setup indications of errors on level/range
self.orig_palette = self.name.palette()
self.error_palette = self.name.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_name_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.typeattrquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.attrs.doubleClicked.connect(self.get_detail)
self.attrs.get_detail.triggered.connect(self.get_detail)
self.name.textEdited.connect(self.clear_name_error)
self.name.editingFinished.connect(self.set_name)
self.name_regex.toggled.connect(self.set_name_regex)
self.types.selectionModel().selectionChanged.connect(self.set_types)
self.invert_types.clicked.connect(self.invert_type_selection)
self.buttonBox.clicked.connect(self.run)
def isstarted(self, status):
if status == "True":
self.progress = QProgressDialog("Work in progress...", "Cancel", 0, 0)
self.progress.setWindowTitle(appname + version)
self.progress.setWindowModality(Qt.ApplicationModal)
self.progress.exec()
else:
self.progress.close()
def __init__(self, text):
if QApplication.instance() is None:
self.dialog = None
print(text)
else:
self.dialog = QProgressDialog(text, 'Cancel', 0, 100)
self.dialog.setWindowFlags(Qt.WindowStaysOnTopHint)
self.dialog.show()
def setupUi(self):
self.load_ui("apol/defaultquery.ui")
# set up results
self.table_results_model = DefaultTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(1, Qt.AscendingOrder)
# populate class list
self.class_model = SEToolsListModel(self)
self.class_model.item_list = sorted(self.policy.classes())
self.tclass.setModel(self.class_model)
# these two lists have empty string as their first item
# (in the .ui file):
# populate default value list
for i, e in enumerate(DefaultValue, start=1):
self.default_value.insertItem(i, e.name, e)
# populate default range value list
for i, e in enumerate(DefaultRangeValue, start=1):
self.default_range_value.insertItem(i, e.name, e)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.defaultquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.default_range_value.setEnabled(self.default_range.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.default_range.toggled.connect(self.default_range_value.setEnabled)
self.clear_ruletypes.clicked.connect(self.clear_all_ruletypes)
self.all_ruletypes.clicked.connect(self.set_all_ruletypes)
self.tclass.selectionModel().selectionChanged.connect(self.set_tclass)
self.invert_class.clicked.connect(self.invert_tclass_selection)
self.buttonBox.clicked.connect(self.run)
def swapButtonPressed(self):
n0 = self.spinBox0.value()
n1 = self.spinBox1.value()
n = 0
try:
n += len(self.df.keys())
except:
pass
try:
n += len(self.line_data_dict.keys())
except:
pass
if n0 != n1:
progress = QProgressDialog("Processing...", "Abort", 0, n, self)
progress.setWindowModality(Qt.WindowModal)
i = 0
for k, v in self.df.items():
progress.setValue(i)
array0 = v.loc[:, n0].as_matrix()
array1 = v.loc[:, n1].as_matrix()
tmp = array0.copy()
array0[:, :] = array1
array1[:, :] = tmp
i += 1
for df_key, df in self.line_data_dict.items():
progress.setValue(i)
for idx, segment in df.items():
try:
idx = int(idx)
except:
continue
list0 = segment[n0]
list1 = segment[n1]
segment[n0] = list1
segment[n1] = list0
i += 1
progress.setValue(n)
self.swapAccepted.emit()
def start(self, text, maximum):
"""Start showing a progress dialog."""
self._progress = QProgressDialog()
self._progress.setMinimumDuration(500)
self._progress.setLabelText(text)
self._progress.setMaximum(maximum)
self._progress.setCancelButton(None)
self._progress.show()
QApplication.processEvents()
def process(self,faction_name,empire_name,kingdom_name):
self.faction = faction_name
self.empire = empire_name
self.kingdom = kingdom_name
self.fullPath = os.path.join(self.basepath,self.faction,self.empire,self.kingdom,"Picture")
self.total_heros = self.estimateNbPerso(self.fullPath)
self.progress = QProgressDialog ()
self.progress.setWindowModality(QtCore.Qt.WindowModal)
self.progress.canceled.connect(self.onCanceled)
def update_library(self):
self.update_library_progress = QProgressDialog(
"Update Library...", None, 0, 100, self)
self.update_library_progress.setWindowTitle('Updating the library...')
self.update_library_progress.setLabelText('Browsing the files...')
self.update_library_progress.setWindowModality(Qt.WindowModal)
self.update_library_progress.show()
t = Thread(target=self.backend.do_update_library)
t.start()
def show(self):
flags = Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowSystemMenuHint
self._window = QProgressDialog('', "Cancel", 0, 100, self.parent, flags)
self._window.setModal(True)
self._window.setAutoReset(False)
self._window.setAutoClose(False)
self._timer = QTimer(self._window)
self._timer.timeout.connect(self.model.pulse)
self._window.show()
self._window.canceled.connect(self.model.cancel)
self._timer.start(500)
def sweep(self):
if self.idle: return
self.sweepFrame.setEnabled(False)
self.selectFrame.setEnabled(False)
self.socket.write(struct.pack('<I', 6<<28))
self.offset = 0
self.reading = True
self.progress = QProgressDialog('Sweep status', 'Cancel', 0, self.sweep_size + 1)
self.progress.setModal(True)
self.progress.setMinimumDuration(1000)
self.progress.canceled.connect(self.cancel)
def __open(self, files):
existing_files = [d['file'] for d in self.__files_data()]
progress = QProgressDialog("Loading files", None, 0, len(files), self);
progress.setWindowModality(Qt.WindowModal);
progress.show()
for index, file in enumerate(files):
progress.setValue(index+1)
QApplication.instance().processEvents()
if file not in existing_files:
self.__add_file(fits.open(file))
def download_file(url, path, session):
count = 0
chunksize = 8192
lastvalue = 0
r = session.get(url, stream=True)
if r.status_code == 401: # not logged in anymore
os.remove(COOKIE_FILE)
show_popup("ERROR", "Please restart the application and try again!")
sys.exit(1)
if r.status_code == 404: # release not found, skip
show_popup("ERROR", "There was an error downloading the release with the url: " + url)
return True
filename = str.replace(re.findall("filename=(.+)", r.headers['content-disposition'])[0], "\"", "")
fullpath = path + "/" + filename
print(fullpath)
diff = (100 / int(r.headers['Content-Length']))
# PROGRESS BAR
bar = QProgressDialog("Downloading <i>" + filename + "</i>", "Cancel", 0, 100)
bar.setWindowTitle("Downloading")
bar.setValue(0)
with open(fullpath, 'wb') as f:
for chunk in r.iter_content(chunk_size=chunksize):
if chunk: # filter out keep-alive new chunks
f.write(chunk)
percentvalue = round(count * chunksize * diff, 0)
# print(percentvalue)
if percentvalue != lastvalue:
bar.setValue(percentvalue)
lastvalue = percentvalue
count += 1
if bar.wasCanceled():
os.remove(fullpath)
return False
QApplication.processEvents()
bar.close()
return True
def progress(data, *args):
"""
A very pythonic progress dialog.
Iterate over progress(iterator)
instead of iterator. That’s pretty much it.
"""
# found at http://lateral.netmanagers.com.ar/weblog/posts/BB917.html
# © 2000-2012 Roberto Alsina
# Creative Commons Attribution-NonCommercial-ShareAlike 2.5 licence
# http://creativecommons.org/licenses/by-nc-sa/2.5/
it = iter(data)
widget = QProgressDialog(*args + (0, it.__length_hint__()))
c = 0
for v in it:
QCoreApplication.instance().processEvents()
if widget.wasCanceled():
raise StopIteration
c += 1
widget.setValue(c)
yield(v)
def setupUi(self):
self.load_ui("boundsquery.ui")
# set up results
self.table_results_model = BoundsTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(1, Qt.AscendingOrder)
# setup indications of errors on level/range
self.errors = set()
self.orig_palette = self.parent.palette()
self.error_palette = self.parent.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_parent_error()
self.clear_child_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.boundsquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.parent.textEdited.connect(self.clear_parent_error)
self.parent.editingFinished.connect(self.set_parent)
self.parent_regex.toggled.connect(self.set_parent_regex)
self.child.textEdited.connect(self.clear_child_error)
self.child.editingFinished.connect(self.set_child)
self.child_regex.toggled.connect(self.set_child_regex)
self.buttonBox.clicked.connect(self.run)
class Progress:
def __init__(self, parent):
self.parent = parent
self.dialog = None
self.application = None
def started(self, title):
self.dialog = QProgressDialog(title, "Stop", 0, 0, self.parent)
self.dialog.setCancelButton(None)
self.dialog.show()
QCoreApplication.processEvents(QEventLoop.AllEvents)
def progress(self, msg, percent):
self.dialog.setLabelText(msg)
# otherwise KProgressDialog automatically closes itself, sigh
if percent < 100:
self.dialog.setValue(percent)
QCoreApplication.processEvents(QEventLoop.AllEvents)
def finished(self):
if self.dialog:
self.dialog.done(0)
self.dialog = None
def __init__(self, parent=None):
super(HttpWindow, self).__init__(parent)
self.url = QUrl()
self.qnam = QNetworkAccessManager()
self.reply = None
self.outFile = None
self.httpGetId = 0
self.httpRequestAborted = False
self.urlLineEdit = QLineEdit('https://www.qt.io')
urlLabel = QLabel("&URL:")
urlLabel.setBuddy(self.urlLineEdit)
self.statusLabel = QLabel(
"Please enter the URL of a file you want to download.")
self.statusLabel.setWordWrap(True)
self.downloadButton = QPushButton("Download")
self.downloadButton.setDefault(True)
self.quitButton = QPushButton("Quit")
self.quitButton.setAutoDefault(False)
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.downloadButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.progressDialog = QProgressDialog(self)
self.urlLineEdit.textChanged.connect(self.enableDownloadButton)
self.qnam.authenticationRequired.connect(
self.slotAuthenticationRequired)
self.qnam.sslErrors.connect(self.sslErrors)
self.progressDialog.canceled.connect(self.cancelDownload)
self.downloadButton.clicked.connect(self.downloadFile)
self.quitButton.clicked.connect(self.close)
topLayout = QHBoxLayout()
topLayout.addWidget(urlLabel)
topLayout.addWidget(self.urlLineEdit)
mainLayout = QVBoxLayout()
mainLayout.addLayout(topLayout)
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("HTTP")
self.urlLineEdit.setFocus()
class ProgressBar():
def __init__(self, text):
if QApplication.instance() is None:
self.dialog = None
print(text)
else:
self.dialog = QProgressDialog(text, 'Cancel', 0, 100)
self.dialog.setWindowFlags(Qt.WindowStaysOnTopHint)
self.dialog.show()
def update(self, value):
if self.dialog:
self.dialog.setValue(value)
QApplication.processEvents()
else:
print('Progress: %.2f%% done' % value)
def close(self):
if self.dialog:
self.dialog.close()
def _scan(self):
cmds = self.ui.scan_type.currentData().get("cmds")
self.progress = QProgressDialog(
"Scanning...", "Cancel", 0, len(cmds), self)
self.progress.setWindowTitle("Scanning...")
self.progress.setWindowModality(Qt.WindowModal)
self.progress.setLabelText('Scanning...')
self.progress.show()
t = Thread(
target=self.backend.do_scan,
args=[
self.filename(),
self.ui.scan_type.currentData().get("cmds"),
self.ui.scan_type.currentData().get("postprocess", []),
],
)
t.start()
class Window(QWidget):
def __init__(self, *args, **kwargs):
super(Window, self).__init__(*args, **kwargs)
self.resize(600, 400)
layout = QHBoxLayout(self)
# 左侧
widgetLeft = QWidget(self)
layoutLeft = QVBoxLayout(widgetLeft)
# 右侧
self.widgetRight = QListWidget(self,
minimumWidth=200,
iconSize=QSize(150, 150))
self.widgetRight.setViewMode(QListWidget.IconMode)
layout.addWidget(widgetLeft)
layout.addWidget(self.widgetRight)
self.webView = QWebView()
layoutLeft.addWidget(self.webView)
# 截图方式一
groupBox1 = QGroupBox('截图方式一', self)
layout1 = QVBoxLayout(groupBox1)
layout1.addWidget(QPushButton('截图1', self, clicked=self.onScreenShot1))
layoutLeft.addWidget(groupBox1)
# 截图方式二（采用js）
groupBox2 = QGroupBox('截图方式二', self)
layout2 = QVBoxLayout(groupBox2)
self.codeEdit = QLineEdit(
'body',
groupBox2,
placeholderText='请输入需要截图的元素、ID或者class：如body、#id .class')
layout2.addWidget(self.codeEdit)
self.btnMethod2 = QPushButton('',
self,
clicked=self.onScreenShot2,
enabled=False)
layout2.addWidget(self.btnMethod2)
layoutLeft.addWidget(groupBox2)
# 开启开发人员工具
QWebSettings.globalSettings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, True)
self.webView.loadStarted.connect(self.onLoadStarted)
self.webView.loadFinished.connect(self.onLoadFinished)
self.webView.load(QUrl("https://pyqt5.com"))
# 暴露接口和加载完成后执行jquery等一些库文件
self.webView.page().mainFrame().javaScriptWindowObjectCleared.connect(
self.populateJavaScriptWindowObject)
def populateJavaScriptWindowObject(self):
self.webView.page().mainFrame().addToJavaScriptWindowObject(
'_self', self)
def onLoadStarted(self):
print('load started')
self.btnMethod2.setEnabled(False)
self.btnMethod2.setText('暂时无法使用（等待页面加载完成）')
def onLoadFinished(self):
# 注入脚本
mainFrame = self.webView.page().mainFrame()
# 执行jquery,promise,html2canvas
mainFrame.evaluateJavaScript(
open('Data/jquery.js', 'rb').read().decode())
mainFrame.evaluateJavaScript(
open('Data/promise-7.0.4.min.js', 'rb').read().decode())
mainFrame.evaluateJavaScript(
open('Data/html2canvas.min.js', 'rb').read().decode())
print('inject js ok')
self.btnMethod2.setText('截图2')
self.btnMethod2.setEnabled(True)
def onScreenShot1(self):
# 截图方式1
page = self.webView.page()
frame = page.mainFrame()
size = frame.contentsSize()
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
# 记录旧大小
oldSize = page.viewportSize()
# *****重点就是这里******
page.setViewportSize(size)
frame.render(painter)
painter.end()
# 截图完成后需要还原,否则界面不响应鼠标等
page.setViewportSize(oldSize)
# 添加到左侧list中
item = QListWidgetItem(self.widgetRight)
image = QPixmap.fromImage(image)
item.setIcon(QIcon(image))
item.setData(Qt.UserRole + 1, image)
def onScreenShot2(self):
# 截图方式2
code = self.codeEdit.text().strip()
if not code:
return
self.progressdialog = QProgressDialog(self, windowTitle='正在截图中')
self.progressdialog.setRange(0, 0)
self.webView.page().mainFrame().evaluateJavaScript(CODE % code)
self.progressdialog.exec_()
@pyqtSlot(str)
def saveImage(self, image):
self.progressdialog.close()
# data:image/png;base64,iVBORw0KG....
if not image.startswith('data:image'):
return
data = base64.b64decode(image.split(';base64,')[1])
image = QPixmap()
image.loadFromData(data)
# 添加到左侧list中
item = QListWidgetItem(self.widgetRight)
item.setIcon(QIcon(image))
item.setData(Qt.UserRole + 1, image)
class SensitivityQueryTab(SEToolsWidget, QScrollArea):
"""Sensitivity browser and query tab."""
def __init__(self, parent, policy, perm_map):
super(SensitivityQueryTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = SensitivityQuery(policy)
self.setupUi()
def __del__(self):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.sensitivityquery").removeHandler(self.handler)
def setupUi(self):
self.load_ui("sensitivityquery.ui")
# populate sensitivity list
self.sensitivity_model = SEToolsListModel(self)
self.sensitivity_model.item_list = sorted(self.policy.sensitivities())
self.sens.setModel(self.sensitivity_model)
# set up results
self.table_results_model = MLSComponentTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# setup indications of errors on level/range
self.orig_palette = self.name.palette()
self.error_palette = self.name.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_name_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.sensitivityquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.sens.doubleClicked.connect(self.get_detail)
self.sens.get_detail.triggered.connect(self.get_detail)
self.name.textEdited.connect(self.clear_name_error)
self.name.editingFinished.connect(self.set_name)
self.name_regex.toggled.connect(self.set_name_regex)
self.buttonBox.clicked.connect(self.run)
#
# Sensitivity browser
#
def get_detail(self):
# .ui is set for single item selection.
index = self.sens.selectedIndexes()[0]
item = self.sensitivity_model.data(index, Qt.UserRole)
self.log.debug("Generating detail window for {0}".format(item))
sensitivity_detail(self, item)
#
# Name criteria
#
def clear_name_error(self):
self.name.setToolTip("Match the sensitivity name.")
self.name.setPalette(self.orig_palette)
def set_name(self):
try:
self.query.name = self.name.text()
except Exception as ex:
self.log.error("Sensitivity name error: {0}".format(ex))
self.name.setToolTip("Error: " + str(ex))
self.name.setPalette(self.error_palette)
def set_name_regex(self, state):
self.log.debug("Setting name_regex {0}".format(state))
self.query.name_regex = state
self.clear_name_error()
self.set_name()
#
# Results runner
#
def run(self, button):
# right now there is only one button.
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self, count):
self.log.info("{0} categories found.".format(count))
# update sizes/location of result displays
if not self.busy.wasCanceled():
self.busy.setLabelText("Resizing the result table's columns; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeColumnsToContents()
# If the attrs or alias column widths are too long, pull back
# to a reasonable size
header = self.table_results.horizontalHeader()
if header.sectionSize(1) > 400:
header.resizeSection(1, 400)
if header.sectionSize(2) > 400:
header.resizeSection(2, 400)
if not self.busy.wasCanceled():
self.busy.setLabelText("Resizing the result table's rows; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeRowsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText("Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
self.busy.reset()
class Window(QWidget):
def __init__(self, *args, **kwargs):
super(Window, self).__init__(*args, **kwargs)
self.resize(600, 400)
layout = QHBoxLayout(self)
# 左侧
widgetLeft = QWidget(self)
layoutLeft = QVBoxLayout(widgetLeft)
# 右侧
self.widgetRight = QListWidget(
self, minimumWidth=200, iconSize=QSize(150, 150))
self.widgetRight.setViewMode(QListWidget.IconMode)
layout.addWidget(widgetLeft)
layout.addWidget(self.widgetRight)
self.webView = QWebEngineView()
layoutLeft.addWidget(self.webView)
# 截图方式一
groupBox1 = QGroupBox('截图方式一', self)
layout1 = QVBoxLayout(groupBox1)
layout1.addWidget(QPushButton('截图1', self, clicked=self.onScreenShot1))
layoutLeft.addWidget(groupBox1)
# 截图方式二（采用js）
groupBox2 = QGroupBox('截图方式二', self)
layout2 = QVBoxLayout(groupBox2)
self.codeEdit = QLineEdit(
'body', groupBox2, placeholderText='请输入需要截图的元素、ID或者class：如body、#id .class')
layout2.addWidget(self.codeEdit)
self.btnMethod2 = QPushButton(
'', self, clicked=self.onScreenShot2, enabled=False)
layout2.addWidget(self.btnMethod2)
layoutLeft.addWidget(groupBox2)
# 提供访问接口
self.channel = QWebChannel(self)
# 把自身对象传递进去
self.channel.registerObject('_self', self)
# 设置交互接口
self.webView.page().setWebChannel(self.channel)
# 支持截图
settings = QWebEngineSettings.globalSettings()
settings.setAttribute(QWebEngineSettings.ScreenCaptureEnabled, True)
self.webView.loadStarted.connect(self.onLoadStarted)
self.webView.loadFinished.connect(self.onLoadFinished)
self.webView.load(QUrl("https://pyqt.site"))
def onLoadStarted(self):
print('load started')
self.btnMethod2.setEnabled(False)
self.btnMethod2.setText('暂时无法使用（等待页面加载完成）')
@pyqtSlot(bool)
def onLoadFinished(self, finished):
if not finished:
return
print('load finished')
# 注入脚本
page = self.webView.page()
# 执行qwebchannel,jquery,promise,html2canvas
page.runJavaScript(
open('Data/qwebchannel.js', 'rb').read().decode())
page.runJavaScript(
open('Data/jquery.js', 'rb').read().decode())
# page.runJavaScript(
# open('Data/promise-7.0.4.min.js', 'rb').read().decode())
page.runJavaScript(
open('Data/html2canvas.min.js', 'rb').read().decode())
page.runJavaScript(CreateBridge)
print('inject js ok')
self.btnMethod2.setText('截图2')
self.btnMethod2.setEnabled(True)
def onScreenShot1(self):
# 截图方式1
page = self.webView.page()
oldSize = self.webView.size()
self.webView.resize(page.contentsSize().toSize())
def doScreenShot():
rect = self.webView.contentsRect()
size = rect.size()
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
self.webView.render(painter)
painter.end()
self.webView.resize(oldSize)
# 添加到左侧list中
item = QListWidgetItem(self.widgetRight)
image = QPixmap.fromImage(image)
item.setIcon(QIcon(image))
item.setData(Qt.UserRole + 1, image)
# 先等一下再截图吧
QTimer.singleShot(2000, doScreenShot)
def onScreenShot2(self):
# 截图方式2
code = self.codeEdit.text().strip()
if not code:
return
self.progressdialog = QProgressDialog(self, windowTitle='正在截图中')
self.progressdialog.setRange(0, 0)
self.webView.page().runJavaScript(CODE % code)
self.progressdialog.exec_()
@pyqtSlot(str)
def saveImage(self, image):
self.progressdialog.close()
# data:image/png;base64,iVBORw0KG....
if not image.startswith('data:image'):
return
data = base64.b64decode(image.split(';base64,')[1])
image = QPixmap()
image.loadFromData(data)
# 添加到左侧list中
item = QListWidgetItem(self.widgetRight)
item.setIcon(QIcon(image))
item.setData(Qt.UserRole + 1, image)
def read_data(self):
if not self.device: return
# 0: WFId <Qstring> - description
# 1: PT_Fmt { ENV | Y } - format
# 2: XINcr <NR3> - time scale
# 3: PT_Off <NR1> - always 0
# 4: XZEro <NR3> - time of the first sample
# 5: XUNit <QString> - time units
# 6: YMUlt <NR3> - sample scale
# 7: YZEro <NR3> - always 0
# 8: YOFf <NR3> - sample offset
# 9: YUNit <QString> - sample unit
# 10: NR_Pt <NR1> - number of points
# Xn = XZEro + XINcr * n
# Yn = YZEro + YMUlt * (yn - YOFf)
progress = QProgressDialog('Data transfer status', 'Cancel', 0, 5)
progress.setModal(True)
progress.setMinimumDuration(0)
try:
progress.setValue(0)
# read channel and time scales
self.transmit_command(b'CH1:SCA?;:CH2:SCA?;:HOR:MAI:SCA?')
sca = self.receive_result()[:-1].decode('utf-8').rsplit(';')
if self.sca1:
self.sca1.remove()
self.sca1 = None
self.sca1 = self.figure.text(0.01,
0.01,
'CH1 %sV' %
metric_prefix(float(sca[0])),
color=self.colors[0])
if self.sca2:
self.sca2.remove()
self.sca2 = None
self.sca2 = self.figure.text(0.31,
0.01,
'CH2 %sV' %
metric_prefix(float(sca[1])),
color=self.colors[1])
if self.scam:
self.scam.remove()
self.scam = None
self.scam = self.figure.text(
0.61, 0.01, 'M %ss' % metric_prefix(float(sca[2])))
progress.setValue(1)
# read formats
self.transmit_command(b'WFMPre:CH1?')
self.format1 = self.receive_result()[:-1].decode('utf-8').rsplit(
';')
self.transmit_command(b'WFMPre:CH2?')
self.format2 = self.receive_result()[:-1].decode('utf-8').rsplit(
';')
progress.setValue(2)
# read curves
self.transmit_command(b'DAT:SOU CH1;:CURV?')
self.buffer1[:] = self.receive_result(2507)[6:-1]
self.curve1.set_ydata(self.data1)
self.transmit_command(b'DAT:SOU CH2;:CURV?')
self.buffer2[:] = self.receive_result(2507)[6:-1]
self.curve2.set_ydata(self.data2)
self.canvas.draw()
progress.setValue(3)
# read measurements
self.transmit_command(
b'MEASU:MEAS1?;:MEASU:MEAS1:VAL?;:MEASU:MEAS2?;:MEASU:MEAS2:VAL?;:MEASU:MEAS3?;:MEASU:MEAS3:VAL?'
)
result = self.receive_result()[:-1] + b';'
self.transmit_command(
b'MEASU:MEAS4?;:MEASU:MEAS4:VAL?;:MEASU:MEAS5?;:MEASU:MEAS5:VAL?'
)
result += self.receive_result()[:-1]
meas = result.decode('utf-8').rsplit(';')
for i in range(0, 5):
typ = meas[i * 4 + 0]
uni = meas[i * 4 + 1]
sou = meas[i * 4 + 2]
val = meas[i * 4 + 3]
if typ == 'NONE':
val = ''
uni = ''
elif abs(float(val)) > 9.9E9:
val = '?'
uni = ''
else:
val = metric_prefix(float(meas[i * 4 + 3]))
uni = uni.strip('"')
getattr(self, 'meas%d' % (i + 1)).setText('%s %s %s%s' %
(sou, typ, val, uni))
progress.setValue(4)
# read cursors
self.transmit_command(
b'CURS?;:CURS:VBA:HPOS1?;:CURS:VBA:HPOS2?;:CURS:HBA:DELT?;:CURS:VBA:DELT?'
)
curs = self.receive_result()[:-1].decode('utf-8').rsplit(';')
self.curst.setText('%s %s' % (curs[1], self.cursors[curs[0]]))
if curs[0] == 'VBARS':
val = float(curs[8])
if abs(val) > 9.9E9:
self.curs1.setText('%ss' % (metric_prefix(float(curs[3]))))
self.curs2.setText('')
else:
self.curs1.setText('%ss' % (metric_prefix(float(curs[3]))))
self.curs2.setText('%sV' % (metric_prefix(float(curs[8]))))
val = float(curs[9])
if abs(val) > 9.9E9:
self.curs3.setText('%ss' % (metric_prefix(float(curs[4]))))
self.curs4.setText('')
else:
self.curs3.setText('%ss' % (metric_prefix(float(curs[4]))))
self.curs4.setText('%sV' % (metric_prefix(float(curs[9]))))
self.delta.setText('dt = %ss' %
(metric_prefix(float(curs[11]))))
elif curs[0] == 'HBARS':
self.curs1.setText('%sV' % metric_prefix(float(curs[6])))
self.curs2.setText('')
self.curs3.setText('%sV' % metric_prefix(float(curs[7])))
self.curs4.setText('')
self.delta.setText('dV = %sV' %
(metric_prefix(float(curs[10]))))
else:
self.curs1.setText('')
self.curs2.setText('')
self.curs3.setText('')
self.curs4.setText('')
self.delta.setText('')
progress.setValue(5)
except:
print('Error: %s' % sys.exc_info()[1])
progress.setValue(5)
def fill_pages(self):
self.loadingPages = True
self.pagesModel.clear()
self.pagesModel.setHorizontalHeaderLabels(
[i18n("Page"), i18n("Description")])
pagesList = []
if "pages" in self.setupDictionary.keys():
pagesList = self.setupDictionary["pages"]
progress = QProgressDialog()
progress.setMinimum(0)
progress.setMaximum(len(pagesList))
progress.setWindowTitle(i18n("Loading pages..."))
for url in pagesList:
absurl = os.path.join(self.projecturl, url)
if (os.path.exists(absurl)):
#page = Application.openDocument(absurl)
page = zipfile.ZipFile(absurl, "r")
thumbnail = QImage.fromData(page.read("preview.png"))
pageItem = QStandardItem()
dataList = self.get_description_and_title(
page.read("documentinfo.xml"))
if (dataList[0].isspace() or len(dataList[0]) < 1):
dataList[0] = os.path.basename(url)
pageItem.setText(dataList[0].replace("_", " "))
pageItem.setDragEnabled(True)
pageItem.setDropEnabled(False)
pageItem.setEditable(False)
pageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail)))
pageItem.setToolTip(url)
page.close()
description = QStandardItem()
description.setText(dataList[1])
description.setEditable(False)
listItem = []
listItem.append(pageItem)
listItem.append(description)
self.pagesModel.appendRow(listItem)
self.comicPageList.resizeRowsToContents()
self.comicPageList.setColumnWidth(0, 200)
self.comicPageList.setColumnWidth(1, 256)
progress.setValue(progress.value() + 1)
progress.setValue(len(pagesList))
self.loadingPages = False
class BoundsQueryTab(AnalysisTab):
"""Bounds browser and query tab."""
def __init__(self, parent, policy, perm_map):
super(BoundsQueryTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = BoundsQuery(policy)
self.setupUi()
def __del__(self):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.boundsquery").removeHandler(self.handler)
def setupUi(self):
self.load_ui("boundsquery.ui")
# set up results
self.table_results_model = BoundsTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(1, Qt.AscendingOrder)
# setup indications of errors on level/range
self.errors = set()
self.orig_palette = self.parent.palette()
self.error_palette = self.parent.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_parent_error()
self.clear_child_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.boundsquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.parent.textEdited.connect(self.clear_parent_error)
self.parent.editingFinished.connect(self.set_parent)
self.parent_regex.toggled.connect(self.set_parent_regex)
self.child.textEdited.connect(self.clear_child_error)
self.child.editingFinished.connect(self.set_child)
self.child_regex.toggled.connect(self.set_child_regex)
self.buttonBox.clicked.connect(self.run)
#
# Parent criteria
#
def clear_parent_error(self):
self.clear_criteria_error(self.parent, "Match the parent type.")
def set_parent(self):
try:
self.query.parent = self.parent.text()
except Exception as ex:
self.log.error("Type parent error: {0}".format(ex))
self.set_criteria_error(self.parent, ex)
def set_parent_regex(self, state):
self.log.debug("Setting parent_regex {0}".format(state))
self.query.parent_regex = state
self.clear_parent_error()
self.set_parent()
#
# Child criteria
#
def clear_child_error(self):
self.clear_criteria_error(self.child, "Match the child type.")
def set_child(self):
try:
self.query.child = self.child.text()
except Exception as ex:
self.log.error("Type child error: {0}".format(ex))
self.set_criteria_error(self.child, ex)
def set_child_regex(self, state):
self.log.debug("Setting child_regex {0}".format(state))
self.query.child_regex = state
self.clear_child_error()
self.set_child()
#
# Save/Load tab
#
def save(self):
"""Return a dictionary of settings."""
if self.errors:
raise TabFieldError("Field(s) are in error: {0}".format(" ".join(
o.objectName() for o in self.errors)))
settings = {}
save_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "typebounds",
"parent_regex", "child_regex"
])
save_lineedits(self, settings, ["parent", "child"])
save_textedits(self, settings, ["notes"])
return settings
def load(self, settings):
load_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "typebounds",
"parent_regex", "child_regex"
])
load_lineedits(self, settings, ["parent", "child"])
load_textedits(self, settings, ["notes"])
#
# Results runner
#
def run(self, button):
# right now there is only one button.
self.query.parent_regex = self.parent_regex.isChecked()
self.query.child_regex = self.child_regex.isChecked()
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self, count):
self.log.info("{0} bound(s) found.".format(count))
# update sizes/location of result displays
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's columns; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeColumnsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's rows; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeRowsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
self.busy.reset()
def progress_dialog(message):
prgr_dialog = QProgressDialog()
prgr_dialog.setFixedSize(300, 50)
prgr_dialog.setAutoFillBackground(True)
prgr_dialog.setWindowModality(Qt.WindowModal)
prgr_dialog.setWindowTitle('Please wait')
prgr_dialog.setLabelText(message)
prgr_dialog.setSizeGripEnabled(False)
prgr_dialog.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
prgr_dialog.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
prgr_dialog.setWindowFlag(Qt.WindowCloseButtonHint, False)
prgr_dialog.setModal(True)
prgr_dialog.setCancelButton(None)
prgr_dialog.setRange(0, 0)
prgr_dialog.setMinimumDuration(0)
prgr_dialog.setAutoClose(False)
return prgr_dialog
class ConstraintQueryTab(AnalysisTab):
"""A constraint query."""
section = AnalysisSection.Rules
tab_title = "Constraints"
mlsonly = False
def __init__(self, parent, policy, perm_map):
super(ConstraintQueryTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = ConstraintQuery(policy)
self.setupUi()
def __del__(self):
with suppress(RuntimeError):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.constraintquery").removeHandler(
self.handler)
def setupUi(self):
self.load_ui("apol/constraintquery.ui")
# set up user autocompletion
user_completion_list = [str(u) for u in self.policy.users()]
user_completer_model = QStringListModel(self)
user_completer_model.setStringList(sorted(user_completion_list))
self.user_completion = QCompleter()
self.user_completion.setModel(user_completer_model)
self.user.setCompleter(self.user_completion)
# set up role autocompletion
role_completion_list = [str(r) for r in self.policy.roles()]
role_completer_model = QStringListModel(self)
role_completer_model.setStringList(sorted(role_completion_list))
self.role_completion = QCompleter()
self.role_completion.setModel(role_completer_model)
self.role.setCompleter(self.role_completion)
# set up type autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.type_.setCompleter(self.type_completion)
# populate class list
self.class_model = SEToolsListModel(self)
self.class_model.item_list = sorted(self.policy.classes())
self.tclass.setModel(self.class_model)
# populate perm list
self.perms_model = PermListModel(self, self.policy)
self.perms.setModel(self.perms_model)
# setup indications of errors
self.errors = set()
self.orig_palette = self.type_.palette()
self.error_palette = self.type_.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_user_error()
self.clear_type_error()
self.clear_role_error()
# set up results
self.table_results_model = ConstraintTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.constraintquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.set_user_regex(self.user_regex.isChecked())
self.set_role_regex(self.role_regex.isChecked())
self.set_type_regex(self.type_regex.isChecked())
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# MLS constraints available only if policy is MLS
if not self.policy.mls:
self.mlsconstrain.setEnabled(False)
self.mlsvalidatetrans.setEnabled(False)
self.mlsconstrain.setToolTip("MLS is disabled in this policy.")
self.mlsvalidatetrans.setToolTip("MLS is disabled in this policy.")
# connect signals
self.buttonBox.clicked.connect(self.run)
self.clear_ruletypes.clicked.connect(self.clear_all_ruletypes)
self.all_ruletypes.clicked.connect(self.set_all_ruletypes)
self.user.textEdited.connect(self.clear_user_error)
self.user.editingFinished.connect(self.set_user)
self.user_regex.toggled.connect(self.set_user_regex)
self.role.textEdited.connect(self.clear_role_error)
self.role.editingFinished.connect(self.set_role)
self.role_regex.toggled.connect(self.set_role_regex)
self.type_.textEdited.connect(self.clear_type_error)
self.type_.editingFinished.connect(self.set_type)
self.type_regex.toggled.connect(self.set_type_regex)
self.tclass.selectionModel().selectionChanged.connect(self.set_tclass)
self.invert_class.clicked.connect(self.invert_tclass_selection)
self.perms.selectionModel().selectionChanged.connect(self.set_perms)
self.invert_perms.clicked.connect(self.invert_perms_selection)
#
# Ruletype criteria
#
def _set_ruletypes(self, value):
self.constrain.setChecked(value)
self.validatetrans.setChecked(value)
if self.policy.mls:
self.mlsconstrain.setChecked(value)
self.mlsvalidatetrans.setChecked(value)
def set_all_ruletypes(self):
self._set_ruletypes(True)
def clear_all_ruletypes(self):
self._set_ruletypes(False)
#
# Class criteria
#
def set_tclass(self):
selected_classes = []
for index in self.tclass.selectionModel().selectedIndexes():
selected_classes.append(self.class_model.data(index, Qt.UserRole))
self.query.tclass = selected_classes
self.perms_model.set_classes(selected_classes)
def invert_tclass_selection(self):
invert_list_selection(self.tclass.selectionModel())
#
# Permissions criteria
#
def set_perms(self):
selected_perms = []
for index in self.perms.selectionModel().selectedIndexes():
selected_perms.append(self.perms_model.data(index, Qt.UserRole))
self.query.perms = selected_perms
def invert_perms_selection(self):
invert_list_selection(self.perms.selectionModel())
#
# User criteria
#
def clear_user_error(self):
self.clear_criteria_error(
self.user, "Match constraints that have a user in the expression.")
def set_user(self):
try:
self.query.user = self.user.text()
except Exception as ex:
self.log.error("User error: {0}".format(ex))
self.set_criteria_error(self.user, ex)
def set_user_regex(self, state):
self.log.debug("Setting user_regex {0}".format(state))
self.query.user_regex = state
self.clear_user_error()
self.set_user()
#
# Role criteria
#
def clear_role_error(self):
self.clear_criteria_error(
self.role, "Match constraints that have a role in the expression.")
def set_role(self):
try:
self.query.role = self.role.text()
except Exception as ex:
self.log.error("Role error: {0}".format(ex))
self.set_criteria_error(self.role, ex)
def set_role_regex(self, state):
self.log.debug("Setting role_regex {0}".format(state))
self.query.role_regex = state
self.clear_role_error()
self.set_role()
#
# Type criteria
#
def clear_type_error(self):
self.clear_criteria_error(
self.type_,
"Match constraints that have a type in the expression.")
def set_type(self):
try:
self.query.type_ = self.type_.text()
except Exception as ex:
self.log.error("Type error: {0}".format(ex))
self.set_criteria_error(self.type_, ex)
def set_type_regex(self, state):
self.log.debug("Setting type_regex {0}".format(state))
self.query.type_regex = state
self.clear_type_error()
self.set_type()
#
# Save/Load tab
#
def save(self):
"""Return a dictionary of settings."""
if self.errors:
raise TabFieldError("Field(s) are in error: {0}".format(" ".join(
o.objectName() for o in self.errors)))
settings = {}
save_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "constrain", "mlsconstrain",
"validatetrans", "mlsvalidatetrans", "user_regex", "role_regex",
"type_regex", "perms_subset"
])
save_lineedits(self, settings, ["user", "role", "type_"])
save_listviews(self, settings, ["tclass", "perms"])
save_textedits(self, settings, ["notes"])
return settings
def load(self, settings):
load_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "constrain", "mlsconstrain",
"validatetrans", "mlsvalidatetrans", "user_regex", "role_regex",
"type_regex", "perms_subset"
])
load_lineedits(self, settings, ["user", "role", "type_"])
load_listviews(self, settings, ["tclass", "perms"])
load_textedits(self, settings, ["notes"])
#
# Results runner
#
def run(self, button):
# right now there is only one button.
rule_types = []
for mode in [
self.constrain, self.mlsconstrain, self.validatetrans,
self.mlsvalidatetrans
]:
if mode.isChecked():
rule_types.append(mode.objectName())
self.query.ruletype = rule_types
self.query.perms_subset = self.perms_subset.isChecked()
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self, count):
self.log.info("{0} constraint(s) found.".format(count))
# update sizes/location of result displays
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's columns; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeColumnsToContents()
# If the permissions or expression column widths are too long, pull back
# to a reasonable size
header = self.table_results.horizontalHeader()
if header.sectionSize(2) > 400:
header.resizeSection(2, 400)
if header.sectionSize(3) > 400:
header.resizeSection(3, 400)
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's rows; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeRowsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
self.busy.reset()
def setupUi(self):
self.load_ui("apol/constraintquery.ui")
# set up user autocompletion
user_completion_list = [str(u) for u in self.policy.users()]
user_completer_model = QStringListModel(self)
user_completer_model.setStringList(sorted(user_completion_list))
self.user_completion = QCompleter()
self.user_completion.setModel(user_completer_model)
self.user.setCompleter(self.user_completion)
# set up role autocompletion
role_completion_list = [str(r) for r in self.policy.roles()]
role_completer_model = QStringListModel(self)
role_completer_model.setStringList(sorted(role_completion_list))
self.role_completion = QCompleter()
self.role_completion.setModel(role_completer_model)
self.role.setCompleter(self.role_completion)
# set up type autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.type_.setCompleter(self.type_completion)
# populate class list
self.class_model = SEToolsListModel(self)
self.class_model.item_list = sorted(self.policy.classes())
self.tclass.setModel(self.class_model)
# populate perm list
self.perms_model = PermListModel(self, self.policy)
self.perms.setModel(self.perms_model)
# setup indications of errors
self.errors = set()
self.orig_palette = self.type_.palette()
self.error_palette = self.type_.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_user_error()
self.clear_type_error()
self.clear_role_error()
# set up results
self.table_results_model = ConstraintTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.constraintquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.set_user_regex(self.user_regex.isChecked())
self.set_role_regex(self.role_regex.isChecked())
self.set_type_regex(self.type_regex.isChecked())
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# MLS constraints available only if policy is MLS
if not self.policy.mls:
self.mlsconstrain.setEnabled(False)
self.mlsvalidatetrans.setEnabled(False)
self.mlsconstrain.setToolTip("MLS is disabled in this policy.")
self.mlsvalidatetrans.setToolTip("MLS is disabled in this policy.")
# connect signals
self.buttonBox.clicked.connect(self.run)
self.clear_ruletypes.clicked.connect(self.clear_all_ruletypes)
self.all_ruletypes.clicked.connect(self.set_all_ruletypes)
self.user.textEdited.connect(self.clear_user_error)
self.user.editingFinished.connect(self.set_user)
self.user_regex.toggled.connect(self.set_user_regex)
self.role.textEdited.connect(self.clear_role_error)
self.role.editingFinished.connect(self.set_role)
self.role_regex.toggled.connect(self.set_role_regex)
self.type_.textEdited.connect(self.clear_type_error)
self.type_.editingFinished.connect(self.set_type)
self.type_regex.toggled.connect(self.set_type_regex)
self.tclass.selectionModel().selectionChanged.connect(self.set_tclass)
self.invert_class.clicked.connect(self.invert_tclass_selection)
self.perms.selectionModel().selectionChanged.connect(self.set_perms)
self.invert_perms.clicked.connect(self.invert_perms_selection)
def make_progress(caption, parent):
progress = QProgressDialog(caption, None, 0, 100, parent)
progress.setMinimumDuration(500)
return progress
def upload_file(plugin, packet):
# Save the current database
plugin.core.save_netnode()
input_path = ida_loader.get_path(ida_loader.PATH_TYPE_IDB)
ida_loader.save_database(input_path, 0)
with open(input_path, "rb") as input_file:
packet.content = input_file.read()
# Create the upload progress dialog
text = "Uploading database to server, please wait..."
progress = QProgressDialog(text, "Cancel", 0, 1)
progress.setCancelButton(None) # Remove cancel button
progress.setModal(True) # Set as a modal dialog
window_flags = progress.windowFlags() # Disable close button
progress.setWindowFlags(window_flags & ~Qt.WindowCloseButtonHint)
progress.setWindowTitle("Save to server")
icon_path = plugin.plugin_resource("upload.png")
progress.setWindowIcon(QIcon(icon_path))
# Send the packet to upload the file
packet.upback = partial(SaveActionHandler._on_progress, progress)
d = plugin.network.send_packet(packet)
if d:
d.add_callback(
partial(SaveActionHandler.file_uploaded, plugin, progress)
)
d.add_errback(plugin.logger.exception)
progress.show()
def _dialog_accepted(self, dialog):
project, database = dialog.get_result()
# Create the download progress dialog
text = "Downloading database from server, please wait..."
progress = QProgressDialog(text, "Cancel", 0, 1)
progress.setCancelButton(None) # Remove cancel button
progress.setModal(True) # Set as a modal dialog
window_flags = progress.windowFlags() # Disable close button
progress.setWindowFlags(window_flags & ~Qt.WindowCloseButtonHint)
progress.setWindowTitle("Open from server")
icon_path = self._plugin.plugin_resource("download.png")
progress.setWindowIcon(QIcon(icon_path))
# Send a packet to download the file
packet = DownloadFile.Query(project.name, database.name)
callback = partial(self._on_progress, progress)
def set_download_callback(reply):
reply.downback = callback
d = self._plugin.network.send_packet(packet)
d.add_initback(set_download_callback)
d.add_callback(partial(self._file_downloaded, database, progress))
d.add_errback(self._plugin.logger.exception)
progress.show()
class CommonQueryTab(AnalysisTab):
"""Common browser and query tab."""
def __init__(self, parent, policy, perm_map):
super(CommonQueryTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = CommonQuery(policy)
self.setupUi()
def __del__(self):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.commonquery").removeHandler(self.handler)
def setupUi(self):
self.load_ui("commonquery.ui")
# populate commons list
self.common_model = SEToolsListModel(self)
self.common_model.item_list = sorted(c for c in self.policy.commons())
self.commons.setModel(self.common_model)
# populate perm list
self.perms_model = SEToolsListModel(self)
perms = set()
for com in self.policy.commons():
perms.update(com.perms)
self.perms_model.item_list = sorted(perms)
self.perms.setModel(self.perms_model)
# set up results
self.table_results_model = CommonTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# setup indications of errors
self.errors = set()
self.orig_palette = self.name.palette()
self.error_palette = self.name.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_name_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.commonquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.set_name_regex(self.name_regex.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.commons.doubleClicked.connect(self.get_detail)
self.commons.get_detail.triggered.connect(self.get_detail)
self.name.textEdited.connect(self.clear_name_error)
self.name.editingFinished.connect(self.set_name)
self.name_regex.toggled.connect(self.set_name_regex)
self.perms.selectionModel().selectionChanged.connect(self.set_perms)
self.invert_perms.clicked.connect(self.invert_perms_selection)
self.buttonBox.clicked.connect(self.run)
#
# Class browser
#
def get_detail(self):
# .ui is set for single item selection.
index = self.commons.selectedIndexes()[0]
item = self.common_model.data(index, Qt.UserRole)
self.log.debug("Generating detail window for {0}".format(item))
common_detail(self, item)
#
# Name criteria
#
def clear_name_error(self):
self.clear_criteria_error(self.name, "Match the common name.")
def set_name(self):
try:
self.query.name = self.name.text()
except Exception as ex:
self.log.error("Common name error: {0}".format(ex))
self.set_criteria_error(self.name, ex)
def set_name_regex(self, state):
self.log.debug("Setting name_regex {0}".format(state))
self.query.name_regex = state
self.clear_name_error()
self.set_name()
#
# Permissions criteria
#
def set_perms(self):
selected_perms = []
for index in self.perms.selectionModel().selectedIndexes():
selected_perms.append(self.perms_model.data(index, Qt.UserRole))
self.query.perms = selected_perms
def invert_perms_selection(self):
invert_list_selection(self.perms.selectionModel())
#
# Save/Load tab
#
def save(self):
"""Return a dictionary of settings."""
if self.errors:
raise TabFieldError("Field(s) are in error: {0}".format(" ".join(
o.objectName() for o in self.errors)))
settings = {}
save_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "name_regex", "perms_equal"
])
save_lineedits(self, settings, ["name"])
save_listviews(self, settings, ["perms"])
save_textedits(self, settings, ["notes"])
return settings
def load(self, settings):
load_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "name_regex", "perms_equal"
])
load_lineedits(self, settings, ["name"])
load_listviews(self, settings, ["perms"])
load_textedits(self, settings, ["notes"])
#
# Results runner
#
def run(self, button):
# right now there is only one button.
self.query.perms_equal = self.perms_equal.isChecked()
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self, count):
self.log.info("{0} common(s) found.".format(count))
# update sizes/location of result displays
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's columns; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeColumnsToContents()
# If the permissions column width is too long, pull back
# to a reasonable size
header = self.table_results.horizontalHeader()
if header.sectionSize(1) > 400:
header.resizeSection(1, 400)
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's rows; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeRowsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
self.busy.reset()
def waitForSignal(signal, message="", timeout=0):
"""Waits (max timeout msecs if given) for a signal to be emitted.
It the waiting lasts more than 2 seconds, a progress dialog is displayed
with the message.
Returns True if the signal was emitted.
Return False if the wait timed out or the dialog was canceled by the user.
"""
loop = QEventLoop()
dlg = QProgressDialog(minimum=0, maximum=0, labelText=message)
dlg.setWindowTitle(appinfo.appname)
dlg.setWindowModality(Qt.ApplicationModal)
QTimer.singleShot(2000, dlg.show)
dlg.canceled.connect(loop.quit)
if timeout:
QTimer.singleShot(timeout, dlg.cancel)
stop = lambda: loop.quit()
signal.connect(stop)
loop.exec_()
signal.disconnect(stop)
dlg.hide()
dlg.deleteLater()
return not dlg.wasCanceled()
def setupUi(self):
self.load_ui("commonquery.ui")
# populate commons list
self.common_model = SEToolsListModel(self)
self.common_model.item_list = sorted(c for c in self.policy.commons())
self.commons.setModel(self.common_model)
# populate perm list
self.perms_model = SEToolsListModel(self)
perms = set()
for com in self.policy.commons():
perms.update(com.perms)
self.perms_model.item_list = sorted(perms)
self.perms.setModel(self.perms_model)
# set up results
self.table_results_model = CommonTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# setup indications of errors
self.errors = set()
self.orig_palette = self.name.palette()
self.error_palette = self.name.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_name_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.commonquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.set_name_regex(self.name_regex.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.commons.doubleClicked.connect(self.get_detail)
self.commons.get_detail.triggered.connect(self.get_detail)
self.name.textEdited.connect(self.clear_name_error)
self.name.editingFinished.connect(self.set_name)
self.name_regex.toggled.connect(self.set_name_regex)
self.perms.selectionModel().selectionChanged.connect(self.set_perms)
self.invert_perms.clicked.connect(self.invert_perms_selection)
self.buttonBox.clicked.connect(self.run)
def importSheetsToDb(self, filePath, openPassword, editPassword,
sheet_info):
progressDlg = QProgressDialog("正在读取数据表", "Cancel", 0, len(sheet_info),
self)
progressDlg.setWindowTitle("正在导入") # 注意：这里即使关闭窗口，导入过程仍然会正常进行
progressDlg.setAutoClose(True)
progressDlg.setWindowModality(Qt.ApplicationModal)
progressDlg.setWindowFlags(Qt.Dialog | Qt.FramelessWindowHint)
progressDlg.setStyleSheet(
"""QDialog{ border: 1px solid rgb(85,85,85); }
QProgressBar{border: 2px solid grey; border-radius: 5px; color: black; text-align: center;}"""
)
progressDlg.setCancelButton(None)
progressDlg.show()
def slot(value, text):
progressDlg.setValue(value)
progressDlg.setLabelText(text)
if value == progressDlg.maximum():
QMessageBox.information(self, "数据表导入成功",
f"数据表'{filePath}'已成功导入")
self.importPushButton.setEnabled(True)
self.progressSignal.connect(slot)
def error_slot(err):
progressDlg.close()
self.importPushButton.setEnabled(True)
QMessageBox.warning(self, "导入出错", str(err))
self.errorSignal.connect(error_slot)
def process():
try:
pythoncom.CoInitialize()
ex = Easyexcel(filePath,
visible=False,
access_password=openPassword,
write_res_password=editPassword)
dm = DataManager() # 子线程要创建一个单独的数据管理类
for i, sheet in enumerate(
sheet_info): # sheet_info格式为[(Sheet名, 数据表类型, 数据表名称)]
sheet_name, table_type, table_name = sheet
self.progressSignal.emit(
i, f"正在导入工作簿'{sheet_name}'({i}/{len(sheet_info)})")
header_dict, sheet_data = ex.get_sheet(sheet_name)
flag, msg = ExcelCheck.characters_check(sheet_data)
if not flag:
ex.close()
raise Exception(msg)
if table_type == '售后员提成明细':
sheet_data = ExcelCheck.formatted_after_sales(
header_dict, sheet_data)
dm.create_table(table_type, table_name,
ExcelCheck.headers["售后员提成明细"])
dm.insert_data(table_name,
ExcelCheck.headers["售后员提成明细"],
sheet_data)
else:
# 过滤掉列名中的特殊字符以防导致SQL命令格式错误
f_header_dict = {
k.replace('\n', ''): v
for k, v in header_dict.items()
}
columns = sorted(
f_header_dict.keys(),
key=lambda x: f_header_dict[x]) # 与Excel表格列顺序相同
dm.create_table(table_type, table_name, columns)
# 此处将表头按照顺序排列。如果header_dict和sheet_data不匹配的话可能会出问题
dm.insert_data(table_name, columns, sheet_data)
ex.close()
self.progressSignal.emit(len(sheet_info), "导入完成")
except Exception as err:
logging.exception(err)
self.errorSignal.emit(err)
threading.Thread(target=process, daemon=True).start()
class ProgressBarDialog(QWidget):
def __init__(self,
title='',
label='',
minValue=0,
maxValue=100,
parent=None):
super(ProgressBarDialog, self).__init__(parent)
self.process_bar = QProgressDialog(self)
self.set_bar_window_title(title)
self.set_label_text(label)
self.set_min_value(minValue)
self.set_max_value(maxValue)
self.process_bar.setWindowModality(Qt.WindowModal)
self.setGeometry(800, 300, 580, 570)
self.process_bar.canceled.connect(self.close_bar)
def set_bar_window_title(self, text):
self.process_bar.setWindowTitle(text)
self.setWindowTitle(text)
def set_label_text(self, text):
self.process_bar.setLabelText(text)
def set_min_value(self, minValue):
self.process_bar.setMinimum(minValue)
def set_max_value(self, maxvalue):
self.process_bar.setMaximum(maxvalue)
def set_value(self, value):
self.process_bar.setValue(value)
def close_bar(self):
self.process_bar.close()
def reset_bar(self):
self.process_bar = None
def show(self):
self.process_bar.show()
def is_valid(self):
return bool(self.process_bar)
def fill_pages(self):
self.loadingPages = True
self.pagesModel.clear()
if len(self.pagesWatcher.files())>0:
self.pagesWatcher.removePaths(self.pagesWatcher.files())
pagesList = []
if "pages" in self.setupDictionary.keys():
pagesList = self.setupDictionary["pages"]
progress = QProgressDialog()
progress.setMinimum(0)
progress.setMaximum(len(pagesList))
progress.setWindowTitle(i18n("Loading Pages..."))
for url in pagesList:
absurl = os.path.join(self.projecturl, url)
relative = os.path.relpath(absurl, self.projecturl)
if (os.path.exists(absurl)):
#page = Application.openDocument(absurl)
page = zipfile.ZipFile(absurl, "r")
# Note: We load preview.png instead of mergedimage.png as each mergedimage.png can take hundreds of MiB
# when loaded in memory.
thumbnail = QImage.fromData(page.read("preview.png"))
thumbnail.setDevicePixelRatio(self.devicePixelRatioF())
pageItem = QStandardItem()
dataList = self.get_description_and_title(page.read("documentinfo.xml"))
if (dataList[0].isspace() or len(dataList[0]) < 1):
dataList[0] = os.path.basename(url)
pageItem.setText(dataList[0].replace("_", " "))
pageItem.setDragEnabled(True)
pageItem.setDropEnabled(False)
pageItem.setEditable(False)
pageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail)))
pageItem.setData(dataList[1], role = CPE.DESCRIPTION)
pageItem.setData(relative, role = CPE.URL)
self.pagesWatcher.addPath(absurl)
pageItem.setData(dataList[2], role = CPE.KEYWORDS)
pageItem.setData(dataList[3], role = CPE.LASTEDIT)
pageItem.setData(dataList[4], role = CPE.EDITOR)
pageItem.setToolTip(relative)
page.close()
self.pagesModel.appendRow(pageItem)
progress.setValue(progress.value() + 1)
progress.setValue(len(pagesList))
self.loadingPages = False
def setupUi(self):
self.load_ui("apol/nodeconquery.ui")
# set up user autocompletion
user_completion_list = [str(u) for u in self.policy.users()]
user_completer_model = QStringListModel(self)
user_completer_model.setStringList(sorted(user_completion_list))
self.user_completion = QCompleter()
self.user_completion.setModel(user_completer_model)
self.user.setCompleter(self.user_completion)
# set up role autocompletion
role_completion_list = [str(r) for r in self.policy.roles()]
role_completer_model = QStringListModel(self)
role_completer_model.setStringList(sorted(role_completion_list))
self.role_completion = QCompleter()
self.role_completion.setModel(role_completer_model)
self.role.setCompleter(self.role_completion)
# set up type autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.type_.setCompleter(self.type_completion)
# setup IP version
# item 0 is empty string (in the .ui file)
self.ip_version.insertItem(1, "IPv4", NodeconIPVersion.ipv4)
self.ip_version.insertItem(2, "IPv6", NodeconIPVersion.ipv6)
# setup indications of errors on source/target/default
self.errors = set()
self.orig_palette = self.type_.palette()
self.error_palette = self.type_.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_network_error()
self.clear_user_error()
self.clear_type_error()
self.clear_role_error()
self.clear_range_error()
# set up results
self.table_results_model = NodeconTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.nodeconquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# Range criteria is available only if policy is MLS
if not self.policy.mls:
self.range_criteria.setEnabled(False)
self.range_criteria.setToolTip("MLS is disabled in this policy.")
self.range_.setToolTip("MLS is disabled in this policy.")
self.range_exact.setToolTip("MLS is disabled in this policy.")
self.range_overlap.setToolTip("MLS is disabled in this policy.")
self.range_subset.setToolTip("MLS is disabled in this policy.")
self.range_superset.setToolTip("MLS is disabled in this policy.")
# connect signals
self.buttonBox.clicked.connect(self.run)
self.network.textEdited.connect(self.clear_network_error)
self.network.editingFinished.connect(self.set_network)
self.user.textEdited.connect(self.clear_user_error)
self.user.editingFinished.connect(self.set_user)
self.user_regex.toggled.connect(self.set_user_regex)
self.role.textEdited.connect(self.clear_role_error)
self.role.editingFinished.connect(self.set_role)
self.role_regex.toggled.connect(self.set_role_regex)
self.type_.textEdited.connect(self.clear_type_error)
self.type_.editingFinished.connect(self.set_type)
self.type_regex.toggled.connect(self.set_type_regex)
self.range_.textEdited.connect(self.clear_range_error)
self.range_.editingFinished.connect(self.set_range)
class InfoFlowAnalysisTab(AnalysisTab):
"""An information flow analysis tab."""
@property
def perm_map(self):
return self.query.perm_map
@perm_map.setter
def perm_map(self, pmap):
# copy permission map to keep enabled/disabled
# settings private to this map.
perm_map = copy.deepcopy(pmap)
# transfer enabled/disabled settings from
# current permission map, to the new map
for classname in self.query.perm_map.classes():
for mapping in self.query.perm_map.perms(classname):
with suppress(UnmappedClass, UnmappedPermission):
perm_map.mapping(classname,
mapping.perm).enabled = mapping.enabled
# apply updated permission map
self.query.perm_map = perm_map
def __init__(self, parent, policy, perm_map):
super(InfoFlowAnalysisTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = InfoFlowAnalysis(policy, perm_map)
self.query.source = None
self.query.target = None
self.setupUi()
def __del__(self):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.infoflow").removeHandler(self.handler)
def setupUi(self):
self.log.debug("Initializing UI.")
self.load_ui("apol/infoflow.ui")
# set up error message for missing perm map
self.error_msg = QMessageBox(self)
self.error_msg.setStandardButtons(QMessageBox.Ok)
# set up perm map editor
self.permmap_editor = PermissionMapEditor(self, False)
# set up source/target autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.source.setCompleter(self.type_completion)
self.target.setCompleter(self.type_completion)
# setup indications of errors on source/target/default
self.errors = set()
self.orig_palette = self.source.palette()
self.error_palette = self.source.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_source_error()
self.clear_target_error()
# set up processing thread
self.thread = ResultsUpdater(self.query)
self.thread.raw_line.connect(self.raw_results.appendPlainText)
self.thread.finished.connect(self.update_complete)
self.thread.flows.connect(self.reset_browser)
# set up browser thread
self.browser_thread = BrowserUpdater(self.query)
self.browser_thread.flows.connect(self.add_browser_children)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.setCancelButton(None)
self.busy.reset()
# update busy dialog from infoflow INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.infoflow").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.max_path_length.setEnabled(self.all_paths.isChecked())
self.source.setEnabled(not self.flows_in.isChecked())
self.target.setEnabled(not self.flows_out.isChecked())
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
self.browser_tab.setEnabled(self.flows_in.isChecked()
or self.flows_out.isChecked())
# connect signals
self.buttonBox.clicked.connect(self.run)
self.source.textEdited.connect(self.clear_source_error)
self.source.editingFinished.connect(self.set_source)
self.target.textEdited.connect(self.clear_target_error)
self.target.editingFinished.connect(self.set_target)
self.all_paths.toggled.connect(self.all_paths_toggled)
self.flows_in.toggled.connect(self.flows_in_toggled)
self.flows_out.toggled.connect(self.flows_out_toggled)
self.min_perm_weight.valueChanged.connect(self.set_min_weight)
self.exclude_types.clicked.connect(self.choose_excluded_types)
self.edit_permmap.clicked.connect(self.open_permmap_editor)
self.browser.currentItemChanged.connect(self.browser_item_selected)
#
# Analysis mode
#
def all_paths_toggled(self, value):
self.clear_source_error()
self.clear_target_error()
self.max_path_length.setEnabled(value)
def flows_in_toggled(self, value):
self.clear_source_error()
self.clear_target_error()
self.source.setEnabled(not value)
self.limit_paths.setEnabled(not value)
self.browser_tab.setEnabled(value)
def flows_out_toggled(self, value):
self.clear_source_error()
self.clear_target_error()
self.target.setEnabled(not value)
self.limit_paths.setEnabled(not value)
self.browser_tab.setEnabled(value)
#
# Source criteria
#
def clear_source_error(self):
self.clear_criteria_error(self.source,
"The source type of the analysis.")
def set_source(self):
try:
# look up the type here, so invalid types can be caught immediately
text = self.source.text()
if text:
self.query.source = self.policy.lookup_type(text)
else:
self.query.source = None
except Exception as ex:
self.log.error("Source type error: {0}".format(str(ex)))
self.set_criteria_error(self.source, ex)
#
# Target criteria
#
def clear_target_error(self):
self.clear_criteria_error(self.target,
"The target type of the analysis.")
def set_target(self):
try:
# look up the type here, so invalid types can be caught immediately
text = self.target.text()
if text:
self.query.target = self.policy.lookup_type(text)
else:
self.query.target = None
except Exception as ex:
self.log.error("Target type error: {0}".format(str(ex)))
self.set_criteria_error(self.target, ex)
#
# Options
#
def set_min_weight(self, value):
self.query.min_weight = value
def choose_excluded_types(self):
chooser = ExcludeTypes(self, self.policy)
chooser.show()
def open_permmap_editor(self):
self.permmap_editor.show(self.perm_map)
def apply_permmap(self, pmap):
# used only by permission map editor
self.query.perm_map = pmap
#
# Save/Load tab
#
def save(self):
"""Return a dictionary of settings."""
if self.errors:
raise TabFieldError("Field(s) are in error: {0}".format(" ".join(
o.objectName() for o in self.errors)))
settings = {}
save_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "all_paths",
"all_shortest_paths", "flows_in", "flows_out"
])
save_lineedits(self, settings, ["source", "target"])
save_spinboxes(self, settings,
["max_path_length", "limit_paths", "min_perm_weight"])
save_textedits(self, settings, ["notes"])
settings["exclude"] = [str(t) for t in self.query.exclude]
settings["exclude_perms"] = defaultdict(list)
for mapping in self.perm_map:
if not mapping.enabled:
settings["exclude_perms"][mapping.class_].append(mapping.perm)
return settings
def load(self, settings):
load_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "all_paths",
"all_shortest_paths", "flows_in", "flows_out"
])
load_lineedits(self, settings, ["source", "target"])
load_spinboxes(self, settings,
["max_path_length", "limit_paths", "min_perm_weight"])
load_textedits(self, settings, ["notes"])
try:
self.query.exclude = settings["exclude"]
except KeyError:
self.log.warning(
"Excluded types criteria missing from settings file.")
if "exclude_perms" not in settings:
self.log.warning(
"Excluded permissions missing from settings file.")
else:
for mapping in self.perm_map:
# iterate over the map so that any permission
# not in the setting file's exclude list is enabled.
try:
mapping.enabled = mapping.perm not in settings[
"exclude_perms"][mapping.class_]
except KeyError:
mapping.enabled = True
#
# Infoflow browser
#
def _new_browser_item(self, type_, parent, rules=None, children=None):
# build main item
item = QTreeWidgetItem(parent if parent else self.browser)
item.setText(0, str(type_))
item.type_ = type_
item.children = children if children else []
item.rules = rules if rules else []
item.child_populated = children is not None
# add child items
for child_type, child_rules in item.children:
child_item = self._new_browser_item(child_type,
item,
rules=child_rules)
item.addChild(child_item)
item.setExpanded(children is not None)
self.log.debug(
"Built item for {0} with {1} children and {2} rules".format(
type_, len(item.children), len(item.rules)))
return item
def reset_browser(self, root_type, out, children):
self.log.debug("Resetting browser.")
# clear results
self.browser.clear()
self.browser_details.clear()
# save browser details independent
# from main analysis UI settings
self.browser_root_type = root_type
self.browser_mode = out
root = self._new_browser_item(self.browser_root_type,
self.browser,
children=children)
self.browser.insertTopLevelItem(0, root)
def browser_item_selected(self, current, previous):
if not current:
# browser is being reset
return
self.log.debug("{0} selected in browser.".format(current.type_))
self.browser_details.clear()
try:
parent_type = current.parent().type_
except AttributeError:
# should only hit his on the root item
pass
else:
self.browser_details.appendPlainText(
"Information flows {0} {1} {2}\n".format(
current.parent().type_,
"->" if self.browser_mode else "<-", current.type_))
for rule in current.rules:
self.browser_details.appendPlainText(rule)
self.browser_details.moveCursor(QTextCursor.Start)
if not current.child_populated:
self.busy.setLabelText(
"Gathering additional browser details for {0}...".format(
current.type_))
self.busy.show()
self.browser_thread.out = self.browser_mode
self.browser_thread.type_ = current.type_
self.browser_thread.start()
def add_browser_children(self, children):
item = self.browser.currentItem()
item.children = children
self.log.debug("Adding children for {0}".format(item.type_))
for child_type, child_rules in item.children:
child_item = self._new_browser_item(child_type,
item,
rules=child_rules)
item.addChild(child_item)
item.child_populated = True
self.busy.reset()
#
# Results runner
#
def run(self, button):
# right now there is only one button.
fail = False
if self.source.isEnabled() and not self.query.source:
self.set_criteria_error(self.source, "A source type is required")
fail = True
if self.target.isEnabled() and not self.query.target:
self.set_criteria_error(self.target, "A target type is required.")
fail = True
if not self.perm_map:
self.log.critical(
"A permission map is required to begin the analysis.")
self.error_msg.critical(
self, "No permission map available.",
"Please load a permission map to begin the analysis.")
fail = True
if fail:
return
for mode in [
self.all_paths, self.all_shortest_paths, self.flows_in,
self.flows_out
]:
if mode.isChecked():
break
self.query.mode = mode.objectName()
self.query.max_path_len = self.max_path_length.value()
self.query.limit = self.limit_paths.value()
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self):
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
if self.flows_in.isChecked() or self.flows_out.isChecked():
# move to browser tab for flows in/out
self.results_frame.setCurrentIndex(1)
else:
self.results_frame.setCurrentIndex(0)
self.busy.reset()
def copy_reaction(self, move=False):
""" Copy or move reactions between compartmsntes
Parameters
----------
move : bool
Returns
-------
"""
# Get selected items
rows = self.dataView.get_selected_rows()
reactions = [self.dataTable.item_from_row(i) for i in rows]
# Only continue if rows are selected
if not rows:
return
# Collect compartments of metabolites in the selected reactions
compartments = set()
for reaction in reactions:
compartments.update([metabolite.compartment for metabolite in reaction.metabolites])
# Get compartment mapping from user
compartment_mapping = dict()
for compartment in compartments:
value, status = QInputDialog().getItem(self, "Choose target compartment", 'Choose target for compartment "{}":'.format(compartment), list(self.model.gem_compartments.keys()), 0, False)
if not status:
return
else:
compartment_mapping[compartment] = value
progress = QProgressDialog("{} reactions".format("Moving" if move else "Copying"),
"Cancel", 0, len(reactions), self)
# Copy reactions using matching metabolite from other compartment
for n, reaction in enumerate(reactions):
# Check user input and update progress dialog
if progress.wasCanceled():
progress.close()
return
else:
progress.setValue(n)
QApplication.processEvents()
metabolites = dict()
# Collect corresponding metabolites in target compartment
for key, value in reaction.metabolites.items():
target_compartment = compartment_mapping[key.compartment]
putative_target_metabolits = find_duplicate_metabolite(key,
[x for x in self.model.metabolites if x.compartment == target_compartment],
same_compartment=False)
corresponding_metabolite = None
if putative_target_metabolits:
best_hit, score = putative_target_metabolits[0]
if best_hit.compartment == target_compartment and score >= 2.:
corresponding_metabolite = best_hit
if not corresponding_metabolite:
corresponding_metabolite = self.model.copy_metabolite(key, target_compartment)
metabolites[corresponding_metabolite] = value
# Create new reaction if the move flag is false
if not move:
new_reaction = Reaction(id=generate_copy_id(reaction.id, self.model.reactions),
name=reaction.name,
subsystem=reaction.subsystem,
lower_bound=reaction.lower_bound,
upper_bound=reaction.upper_bound,
comment=reaction.comment)
new_reaction.annotation = reaction.annotation.copy()
new_reaction.add_metabolites(metabolites)
self.model.add_reactions([new_reaction])
# Set objective coefficient after adding reaction to model
new_reaction.objective_coefficient = reaction.objective_coefficient
self.model.QtReactionTable.update_row_from_item(new_reaction)
# Update existing reactions with new metabolites if moving
else:
reaction.clear_metabolites()
reaction.add_metabolites(metabolites)
self.model.QtReactionTable.update_row_from_link(rows[n])
progress.close()
def rebuildIndex(self):
if not self.hasProject:
return False
logger.debug("Rebuilding indices ...")
self.treeView.saveTreeOrder()
self.theIndex.clearIndex()
nItems = len(self.theProject.treeOrder)
dlgProg = QProgressDialog("Scanning files ...", "Cancel", 0, nItems, self)
dlgProg.setWindowModality(Qt.WindowModal)
dlgProg.setMinimumDuration(0)
dlgProg.setFixedWidth(480)
dlgProg.setLabelText("Starting file scan ...")
dlgProg.setValue(0)
dlgProg.show()
time.sleep(0.5)
nDone = 0
for tHandle in self.theProject.treeOrder:
tItem = self.theProject.getItem(tHandle)
dlgProg.setValue(nDone)
dlgProg.setLabelText("Scanning: %s" % tItem.itemName)
logger.verbose("Scanning: %s" % tItem.itemName)
if tItem is not None and tItem.itemType == nwItemType.FILE:
theDoc = NWDoc(self.theProject, self)
theText = theDoc.openDocument(tHandle, False)
# Run Word Count
cC, wC, pC = countWords(theText)
tItem.setCharCount(cC)
tItem.setWordCount(wC)
tItem.setParaCount(pC)
self.treeView.propagateCount(tHandle, wC)
self.treeView.projectWordCount()
# Build tag index
self.theIndex.scanText(tHandle, theText)
nDone += 1
if dlgProg.wasCanceled():
break
dlgProg.setValue(nItems)
return True
class NodeconQueryTab(AnalysisTab):
"""An nodecon query."""
def __init__(self, parent, policy, perm_map):
super(NodeconQueryTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = NodeconQuery(policy)
self.setupUi()
def __del__(self):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.nodeconquery").removeHandler(self.handler)
def setupUi(self):
self.load_ui("apol/nodeconquery.ui")
# set up user autocompletion
user_completion_list = [str(u) for u in self.policy.users()]
user_completer_model = QStringListModel(self)
user_completer_model.setStringList(sorted(user_completion_list))
self.user_completion = QCompleter()
self.user_completion.setModel(user_completer_model)
self.user.setCompleter(self.user_completion)
# set up role autocompletion
role_completion_list = [str(r) for r in self.policy.roles()]
role_completer_model = QStringListModel(self)
role_completer_model.setStringList(sorted(role_completion_list))
self.role_completion = QCompleter()
self.role_completion.setModel(role_completer_model)
self.role.setCompleter(self.role_completion)
# set up type autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.type_.setCompleter(self.type_completion)
# setup IP version
# item 0 is empty string (in the .ui file)
self.ip_version.insertItem(1, "IPv4", NodeconIPVersion.ipv4)
self.ip_version.insertItem(2, "IPv6", NodeconIPVersion.ipv6)
# setup indications of errors on source/target/default
self.errors = set()
self.orig_palette = self.type_.palette()
self.error_palette = self.type_.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_network_error()
self.clear_user_error()
self.clear_type_error()
self.clear_role_error()
self.clear_range_error()
# set up results
self.table_results_model = NodeconTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.nodeconquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# Range criteria is available only if policy is MLS
if not self.policy.mls:
self.range_criteria.setEnabled(False)
self.range_criteria.setToolTip("MLS is disabled in this policy.")
self.range_.setToolTip("MLS is disabled in this policy.")
self.range_exact.setToolTip("MLS is disabled in this policy.")
self.range_overlap.setToolTip("MLS is disabled in this policy.")
self.range_subset.setToolTip("MLS is disabled in this policy.")
self.range_superset.setToolTip("MLS is disabled in this policy.")
# connect signals
self.buttonBox.clicked.connect(self.run)
self.network.textEdited.connect(self.clear_network_error)
self.network.editingFinished.connect(self.set_network)
self.user.textEdited.connect(self.clear_user_error)
self.user.editingFinished.connect(self.set_user)
self.user_regex.toggled.connect(self.set_user_regex)
self.role.textEdited.connect(self.clear_role_error)
self.role.editingFinished.connect(self.set_role)
self.role_regex.toggled.connect(self.set_role_regex)
self.type_.textEdited.connect(self.clear_type_error)
self.type_.editingFinished.connect(self.set_type)
self.type_regex.toggled.connect(self.set_type_regex)
self.range_.textEdited.connect(self.clear_range_error)
self.range_.editingFinished.connect(self.set_range)
#
# Network criteria
#
def clear_network_error(self):
self.clear_criteria_error(self.network, "Match the network.")
def set_network(self):
try:
self.query.network = self.network.text()
except Exception as ex:
self.log.error("Network error: {0}".format(ex))
self.set_criteria_error(self.network, ex)
#
# User criteria
#
def clear_user_error(self):
self.clear_criteria_error(self.user, "Match the user of the context.")
def set_user(self):
try:
self.query.user = self.user.text()
except Exception as ex:
self.log.error("Context user error: {0}".format(ex))
self.set_criteria_error(self.user, ex)
def set_user_regex(self, state):
self.log.debug("Setting user_regex {0}".format(state))
self.query.user_regex = state
self.clear_user_error()
self.set_user()
#
# Role criteria
#
def clear_role_error(self):
self.clear_criteria_error(self.role, "Match the role of the context.")
def set_role(self):
try:
self.query.role = self.role.text()
except Exception as ex:
self.log.error("Context role error: {0}".format(ex))
self.set_criteria_error(self.role, ex)
def set_role_regex(self, state):
self.log.debug("Setting role_regex {0}".format(state))
self.query.role_regex = state
self.clear_role_error()
self.set_role()
#
# Type criteria
#
def clear_type_error(self):
self.clear_criteria_error(self.type_, "Match the type of the context.")
def set_type(self):
try:
self.query.type_ = self.type_.text()
except Exception as ex:
self.log.error("Context type error: {0}".format(ex))
self.set_criteria_error(self.type_, ex)
def set_type_regex(self, state):
self.log.debug("Setting type_regex {0}".format(state))
self.query.type_regex = state
self.clear_type_error()
self.set_type()
#
# Range criteria
#
def clear_range_error(self):
self.clear_criteria_error(self.range_, "Match the range of the context.")
def set_range(self):
try:
self.query.range_ = self.range_.text()
except Exception as ex:
self.log.info("Context range error: " + str(ex))
self.set_criteria_error(self.range_, ex)
#
# Save/Load tab
#
def save(self):
"""Return a dictionary of settings."""
if self.errors:
raise TabFieldError("Field(s) are in error: {0}".
format(" ".join(o.objectName() for o in self.errors)))
settings = {}
save_checkboxes(self, settings, ["criteria_expander", "notes_expander",
"network_exact", "network_overlap",
"user_regex", "role_regex", "type_regex", "range_exact",
"range_overlap", "range_subset", "range_superset"])
save_lineedits(self, settings, ["network", "user", "role", "type_", "range_"])
save_comboboxes(self, settings, ["ip_version"])
save_textedits(self, settings, ["notes"])
return settings
def load(self, settings):
load_checkboxes(self, settings, ["criteria_expander", "notes_expander",
"network_exact", "network_overlap",
"user_regex", "role_regex", "type_regex", "range_exact",
"range_overlap", "range_subset", "range_superset"])
load_lineedits(self, settings, ["network", "user", "role", "type_", "range_"])
load_comboboxes(self, settings, ["ip_version"])
load_textedits(self, settings, ["notes"])
#
# Results runner
#
def run(self, button):
# right now there is only one button.
self.query.network_overlap = self.network_overlap.isChecked()
self.query.ip_version = self.ip_version.currentData(Qt.UserRole)
self.query.range_overlap = self.range_overlap.isChecked()
self.query.range_subset = self.range_subset.isChecked()
self.query.range_superset = self.range_superset.isChecked()
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self, count):
self.log.info("{0} nodecon statement(s) found.".format(count))
# update sizes/location of result displays
if not self.busy.wasCanceled():
self.busy.setLabelText("Resizing the result table's columns; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeColumnsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText("Resizing the result table's rows; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeRowsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText("Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
self.busy.reset()
def set_charge(self):
rows = self.dataView.get_selected_rows()
value, status = QInputDialog().getInt(self, "Set Bound", "New bound value:", 0)
if status:
# Set dialog manually in order to prevent dialog popup before user input
progress = QProgressDialog(self)
progress.setWindowModality(QtCore.Qt.WindowModal)
# Keep track of all reactions that need to be updated
update_reactions = set()
self.model.QtReactionTable.blockSignals(True)
self.model.QtMetaboliteTable.blockSignals(True)
# Update metabolites
progress.setRange(0, len(rows))
progress.setLabelText("Changing metabolite..")
for i, row in enumerate(rows):
progress.setValue(i)
QApplication.processEvents()
metabolite = self.model.QtMetaboliteTable.item(row).link
if metabolite.charge != value:
metabolite.charge = value
update_reactions.update(metabolite.reactions)
self.model.QtMetaboliteTable.item(row, 3).setData(value, 2)
# Update reaction table
progress.setRange(0, len(update_reactions))
progress.setLabelText("Updating reactions..")
for i, reaction in enumerate(update_reactions):
progress.setValue(i)
QApplication.processEvents()
reaction.update_balancing_status()
self.model.QtReactionTable.update_row_from_id(reaction.id)
# Make views update
self.model.QtReactionTable.blockSignals(False)
self.model.QtReactionTable.all_data_changed()
self.model.QtMetaboliteTable.blockSignals(False)
self.model.QtMetaboliteTable.all_data_changed()
def export(self):
export_success = False
path = Path(self.projectURL)
if path.exists():
# Make a meta-data folder so we keep the export folder nice and clean.
exportPath = path / self.configDictionary["exportLocation"]
if Path(exportPath / "metadata").exists() is False:
Path(exportPath / "metadata").mkdir()
# Get to which formats to export, and set the sizeslist.
lengthProcess = len(self.configDictionary["pages"])
sizesList = {}
if "CBZ" in self.configDictionary.keys():
if self.configDictionary["CBZactive"]:
lengthProcess += 5
sizesList["CBZ"] = self.configDictionary["CBZ"]
if "EPUB" in self.configDictionary.keys():
if self.configDictionary["EPUBactive"]:
lengthProcess += 1
sizesList["EPUB"] = self.configDictionary["EPUB"]
if "TIFF" in self.configDictionary.keys():
if self.configDictionary["TIFFactive"]:
sizesList["TIFF"] = self.configDictionary["TIFF"]
# Export the pngs according to the sizeslist.
# Create a progress dialog.
self.progress = QProgressDialog(i18n("Preparing export."), str(), 0, lengthProcess)
self.progress.setWindowTitle(i18n("Exporting Comic..."))
self.progress.setCancelButton(None)
self.timer = QElapsedTimer()
self.timer.start()
self.progress.show()
qApp.processEvents()
export_success = self.save_out_pngs(sizesList)
# Export acbf metadata.
if export_success:
if "CBZ" in sizesList.keys():
title = self.configDictionary["projectName"]
if "title" in self.configDictionary.keys():
title = str(self.configDictionary["title"]).replace(" ", "_")
self.acbfLocation = str(exportPath / "metadata" / str(title + ".acbf"))
locationStandAlone = str(exportPath / str(title + ".acbf"))
self.progress.setLabelText(i18n("Saving out ACBF and\nACBF standalone"))
self.progress.setValue(self.progress.value()+2)
export_success = exporters.ACBF.write_xml(self.configDictionary, self.acbfPageData, self.pagesLocationList["CBZ"], self.acbfLocation, locationStandAlone, self.projectURL)
print("CPMT: Exported to ACBF", export_success)
# Export and package CBZ and Epub.
if export_success:
if "CBZ" in sizesList.keys():
export_success = self.export_to_cbz(exportPath)
print("CPMT: Exported to CBZ", export_success)
if "EPUB" in sizesList.keys():
self.progress.setLabelText(i18n("Saving out EPUB"))
self.progress.setValue(self.progress.value()+1)
export_success = exporters.EPUB.export(self.configDictionary, self.projectURL, self.pagesLocationList["EPUB"], self.acbfPageData)
print("CPMT: Exported to EPUB", export_success)
else:
QMessageBox.warning(self, i18n("Export not Possible"), i18n("Nothing to export, URL not set."), QMessageBox.Ok)
print("CPMT: Nothing to export, url not set.")
return export_success
class DefaultQueryTab(AnalysisTab):
"""Default browser and query tab."""
def __init__(self, parent, policy, perm_map):
super(DefaultQueryTab, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.policy = policy
self.query = DefaultQuery(policy)
self.setupUi()
def __del__(self):
self.thread.quit()
self.thread.wait(5000)
logging.getLogger("setools.defaultquery").removeHandler(self.handler)
def setupUi(self):
self.load_ui("defaultquery.ui")
# set up results
self.table_results_model = DefaultTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(1, Qt.AscendingOrder)
# populate class list
self.class_model = SEToolsListModel(self)
self.class_model.item_list = sorted(self.policy.classes())
self.tclass.setModel(self.class_model)
# these two lists have empty string as their first item
# (in the .ui file):
# populate default value list
for i, e in enumerate(DefaultValue, start=1):
self.default_value.insertItem(i, e.name, e)
# populate default range value list
for i, e in enumerate(DefaultRangeValue, start=1):
self.default_range_value.insertItem(i, e.name, e)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.defaultquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.default_range_value.setEnabled(self.default_range.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.default_range.toggled.connect(self.default_range_value.setEnabled)
self.clear_ruletypes.clicked.connect(self.clear_all_ruletypes)
self.all_ruletypes.clicked.connect(self.set_all_ruletypes)
self.tclass.selectionModel().selectionChanged.connect(self.set_tclass)
self.invert_class.clicked.connect(self.invert_tclass_selection)
self.buttonBox.clicked.connect(self.run)
#
# Ruletype criteria
#
def _set_ruletypes(self, value):
self.default_user.setChecked(value)
self.default_role.setChecked(value)
self.default_type.setChecked(value)
self.default_range.setChecked(value)
def set_all_ruletypes(self):
self._set_ruletypes(True)
def clear_all_ruletypes(self):
self._set_ruletypes(False)
#
# Class criteria
#
def set_tclass(self):
selected_classes = []
for index in self.tclass.selectionModel().selectedIndexes():
selected_classes.append(self.class_model.data(index, Qt.UserRole))
self.query.tclass = selected_classes
def invert_tclass_selection(self):
invert_list_selection(self.tclass.selectionModel())
#
# Save/Load tab
#
def save(self):
"""Return a dictionary of settings."""
settings = {}
save_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "default_user",
"default_role", "default_type", "default_range"
])
save_comboboxes(self, settings,
["default_value", "default_range_value"])
save_listviews(self, settings, ["tclass"])
save_textedits(self, settings, ["notes"])
return settings
def load(self, settings):
load_checkboxes(self, settings, [
"criteria_expander", "notes_expander", "default_user",
"default_role", "default_type", "default_range"
])
load_comboboxes(self, settings,
["default_value", "default_range_value"])
load_listviews(self, settings, ["tclass"])
load_textedits(self, settings, ["notes"])
#
# Results runner
#
def run(self, button):
# right now there is only one button.
rule_types = []
for mode in [
self.default_user, self.default_role, self.default_type,
self.default_range
]:
if mode.isChecked():
rule_types.append(mode.objectName())
self.query.ruletype = rule_types
self.query.default = self.default_value.currentData(Qt.UserRole)
if self.default_range_value.isEnabled():
self.query.default_range = self.default_range_value.currentData(
Qt.UserRole)
else:
self.query.default_range = None
# start processing
self.busy.setLabelText("Processing query...")
self.busy.show()
self.raw_results.clear()
self.thread.start()
def update_complete(self, count):
self.log.info("{0} default(s) found.".format(count))
# update sizes/location of result displays
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's columns; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeColumnsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Resizing the result table's rows; GUI may be unresponsive")
self.busy.repaint()
self.table_results.resizeRowsToContents()
if not self.busy.wasCanceled():
self.busy.setLabelText(
"Moving the raw result to top; GUI may be unresponsive")
self.busy.repaint()
self.raw_results.moveCursor(QTextCursor.Start)
self.busy.reset()
class comicsExporter():
acbfLocation = str()
acbfPageData = []
cometLocation = str()
comicRackInfo = str()
pagesLocationList = {}
# set of keys used to define specific export behaviour for this page.
pageKeys = ["acbf_title", "acbf_none", "acbf_fade", "acbf_blend", "acbf_horizontal", "acbf_vertical", "epub_spread"]
def __init__(self):
pass
"""
The configuration of the exporter.
@param config: A dictionary containing all the config.
@param projectUrl: the main location of the project folder.
"""
def set_config(self, config, projectURL):
self.configDictionary = config
self.projectURL = projectURL
self.pagesLocationList = {}
self.acbfLocation = str()
self.acbfPageData = []
self.cometLocation = str()
self.comicRackInfo = str()
"""
Export everything according to config and get yourself a coffee.
This won't work if the config hasn't been set.
"""
def export(self):
export_success = False
path = Path(self.projectURL)
if path.exists():
# Make a meta-data folder so we keep the export folder nice and clean.
exportPath = path / self.configDictionary["exportLocation"]
if Path(exportPath / "metadata").exists() is False:
Path(exportPath / "metadata").mkdir()
# Get to which formats to export, and set the sizeslist.
lengthProcess = len(self.configDictionary["pages"])
sizesList = {}
if "CBZ" in self.configDictionary.keys():
if self.configDictionary["CBZactive"]:
lengthProcess += 5
sizesList["CBZ"] = self.configDictionary["CBZ"]
if "EPUB" in self.configDictionary.keys():
if self.configDictionary["EPUBactive"]:
lengthProcess += 1
sizesList["EPUB"] = self.configDictionary["EPUB"]
if "TIFF" in self.configDictionary.keys():
if self.configDictionary["TIFFactive"]:
sizesList["TIFF"] = self.configDictionary["TIFF"]
# Export the pngs according to the sizeslist.
# Create a progress dialog.
self.progress = QProgressDialog(i18n("Preparing export."), str(), 0, lengthProcess)
self.progress.setWindowTitle(i18n("Exporting Comic..."))
self.progress.setCancelButton(None)
self.timer = QElapsedTimer()
self.timer.start()
self.progress.show()
qApp.processEvents()
export_success = self.save_out_pngs(sizesList)
# Export acbf metadata.
if export_success:
if "CBZ" in sizesList.keys():
title = self.configDictionary["projectName"]
if "title" in self.configDictionary.keys():
title = str(self.configDictionary["title"]).replace(" ", "_")
self.acbfLocation = str(exportPath / "metadata" / str(title + ".acbf"))
locationStandAlone = str(exportPath / str(title + ".acbf"))
self.progress.setLabelText(i18n("Saving out ACBF and\nACBF standalone"))
self.progress.setValue(self.progress.value()+2)
export_success = exporters.ACBF.write_xml(self.configDictionary, self.acbfPageData, self.pagesLocationList["CBZ"], self.acbfLocation, locationStandAlone, self.projectURL)
print("CPMT: Exported to ACBF", export_success)
# Export and package CBZ and Epub.
if export_success:
if "CBZ" in sizesList.keys():
export_success = self.export_to_cbz(exportPath)
print("CPMT: Exported to CBZ", export_success)
if "EPUB" in sizesList.keys():
self.progress.setLabelText(i18n("Saving out EPUB"))
self.progress.setValue(self.progress.value()+1)
export_success = exporters.EPUB.export(self.configDictionary, self.projectURL, self.pagesLocationList["EPUB"], self.acbfPageData)
print("CPMT: Exported to EPUB", export_success)
else:
QMessageBox.warning(self, i18n("Export not Possible"), i18n("Nothing to export, URL not set."), QMessageBox.Ok)
print("CPMT: Nothing to export, url not set.")
return export_success
"""
This calls up all the functions necessary for making a cbz.
"""
def export_to_cbz(self, exportPath):
title = self.configDictionary["projectName"]
if "title" in self.configDictionary.keys():
title = str(self.configDictionary["title"]).replace(" ", "_")
self.progress.setLabelText(i18n("Saving out CoMet\nmetadata file"))
self.progress.setValue(self.progress.value()+1)
self.cometLocation = str(exportPath / "metadata" / str(title + " CoMet.xml"))
export_success = exporters.CoMet.write_xml(self.configDictionary, self.pagesLocationList["CBZ"], self.cometLocation)
self.comicRackInfo = str(exportPath / "metadata" / "ComicInfo.xml")
self.progress.setLabelText(i18n("Saving out Comicrack\nmetadata file"))
self.progress.setValue(self.progress.value()+1)
export_success = exporters.comic_rack_xml.write_xml(self.configDictionary, self.pagesLocationList["CBZ"], self.comicRackInfo)
self.package_cbz(exportPath)
return export_success
def save_out_pngs(self, sizesList):
# A small fix to ensure crop to guides is set.
if "cropToGuides" not in self.configDictionary.keys():
self.configDictionary["cropToGuides"] = False
# Check if we have pages at all...
if "pages" in self.configDictionary.keys():
# Check if there's export methods, and if so make sure the appropriate dictionaries are initialised.
if len(sizesList.keys()) < 1:
print("CPMT: Export failed because there's no export methods set.")
return False
else:
for key in sizesList.keys():
self.pagesLocationList[key] = []
# Get the appropriate paths.
path = Path(self.projectURL)
exportPath = path / self.configDictionary["exportLocation"]
pagesList = self.configDictionary["pages"]
fileName = str(exportPath)
"""
Mini function to handle the setup of this string.
"""
def timeString(timePassed, timeEstimated):
return str(i18n("Time passed: {passedString}\n Estimated: {estimated}")).format(passedString=timePassed, estimated=timeEstimated)
for p in range(0, len(pagesList)):
pagesDone = str(i18n("{pages} of {pagesTotal} done.")).format(pages=p, pagesTotal=len(pagesList))
# Update the label in the progress dialog.
self.progress.setValue(p)
timePassed = self.timer.elapsed()
if p > 0:
timeEstimated = (len(pagesList) - p) * (timePassed / p)
estimatedString = self.parseTime(timeEstimated)
else:
estimatedString = str(u"\u221E")
passedString = self.parseTime(timePassed)
self.progress.setLabelText("\n".join([pagesDone, timeString(passedString, estimatedString), i18n("Opening next page")]))
qApp.processEvents()
# Get the appropriate url and open the page.
url = str(Path(self.projectURL) / pagesList[p])
page = Application.openDocument(url)
page.waitForDone()
# Update the progress bar a little
self.progress.setLabelText("\n".join([pagesDone, timeString(self.parseTime(self.timer.elapsed()), estimatedString), i18n("Cleaning up page")]))
# remove layers and flatten.
labelList = self.configDictionary["labelsToRemove"]
panelsAndText = []
# These three lines are what is causing the page not to close.
root = page.rootNode()
self.getPanelsAndText(root, panelsAndText)
self.removeLayers(labelList, root)
page.refreshProjection()
# We'll need the offset and scale for aligning the panels and text correctly. We're getting this from the CBZ
pageData = {}
pageData["vector"] = panelsAndText
tree = ET.fromstring(page.documentInfo())
pageData["title"] = page.name()
calligra = "{http://www.calligra.org/DTD/document-info}"
about = tree.find(calligra + "about")
keywords = about.find(calligra + "keyword")
keys = str(keywords.text).split(",")
pKeys = []
for key in keys:
if key in self.pageKeys:
pKeys.append(key)
pageData["keys"] = pKeys
page.flatten()
page.waitForDone()
batchsave = Application.batchmode()
Application.setBatchmode(True)
# Start making the format specific copy.
for key in sizesList.keys():
# Update the progress bar a little
self.progress.setLabelText("\n".join([pagesDone, timeString(self.parseTime(self.timer.elapsed()), estimatedString), str(i18n("Exporting for {key}")).format(key=key)]))
w = sizesList[key]
# copy over data
projection = page.clone()
projection.setBatchmode(True)
# Crop. Cropping per guide only happens if said guides have been found.
if w["Crop"] is True:
listHGuides = []
listHGuides = page.horizontalGuides()
listHGuides.sort()
for i in range(len(listHGuides) - 1, 0, -1):
if listHGuides[i] < 0 or listHGuides[i] > page.height():
listHGuides.pop(i)
listVGuides = page.verticalGuides()
listVGuides.sort()
for i in range(len(listVGuides) - 1, 0, -1):
if listVGuides[i] < 0 or listVGuides[i] > page.width():
listVGuides.pop(i)
if self.configDictionary["cropToGuides"] and len(listVGuides) > 1:
cropx = listVGuides[0]
cropw = listVGuides[-1] - cropx
else:
cropx = self.configDictionary["cropLeft"]
cropw = page.width() - self.configDictionary["cropRight"] - cropx
if self.configDictionary["cropToGuides"] and len(listHGuides) > 1:
cropy = listHGuides[0]
croph = listHGuides[-1] - cropy
else:
cropy = self.configDictionary["cropTop"]
croph = page.height() - self.configDictionary["cropBottom"] - cropy
projection.crop(cropx, cropy, cropw, croph)
projection.waitForDone()
qApp.processEvents()
# resize appropriately
else:
cropx = 0
cropy = 0
res = page.resolution()
listScales = [projection.width(), projection.height(), res, res]
projectionOldSize = [projection.width(), projection.height()]
sizesCalc = sizesCalculator()
listScales = sizesCalc.get_scale_from_resize_config(config=w, listSizes=listScales)
projection.unlock()
projection.scaleImage(listScales[0], listScales[1], listScales[2], listScales[3], "bicubic")
projection.waitForDone()
qApp.processEvents()
# png, gif and other webformats should probably be in 8bit srgb at maximum.
if key != "TIFF":
if (projection.colorModel() != "RGBA" and projection.colorModel() != "GRAYA") or projection.colorDepth() != "U8":
projection.setColorSpace("RGBA", "U8", "sRGB built-in")
else:
# Tiff on the other hand can handle all the colormodels, but can only handle integer bit depths.
# Tiff is intended for print output, and 16 bit integer will be sufficient.
if projection.colorDepth() != "U8" or projection.colorDepth() != "U16":
projection.setColorSpace(page.colorModel(), "U16", page.colorProfile())
# save
# Make sure the folder name for this export exists. It'll allow us to keep the
# export folders nice and clean.
folderName = str(key + "-" + w["FileType"])
if Path(exportPath / folderName).exists() is False:
Path.mkdir(exportPath / folderName)
# Get a nice and descriptive fle name.
fn = str(Path(exportPath / folderName) / str("page_" + format(p, "03d") + "_" + str(listScales[0]) + "x" + str(listScales[1]) + "." + w["FileType"]))
# Finally save and add the page to a list of pages. This will make it easy for the packaging function to
# find the pages and store them.
projection.exportImage(fn, InfoObject())
projection.waitForDone()
qApp.processEvents()
if key == "CBZ" or key == "EPUB":
transform = {}
transform["offsetX"] = cropx
transform["offsetY"] = cropy
transform["resDiff"] = page.resolution() / 72
transform["scaleWidth"] = projection.width() / projectionOldSize[0]
transform["scaleHeight"] = projection.height() / projectionOldSize[1]
pageData["transform"] = transform
self.pagesLocationList[key].append(fn)
projection.close()
self.acbfPageData.append(pageData)
page.close()
self.progress.setValue(len(pagesList))
Application.setBatchmode(batchsave)
# TODO: Check what or whether memory leaks are still caused and otherwise remove the entry below.
print("CPMT: Export has finished. If there are memory leaks, they are caused by file layers.")
return True
print("CPMT: Export not happening because there aren't any pages.")
QMessageBox.warning(self, i18n("Export not Possible"), i18n("Export not happening because there are no pages."), QMessageBox.Ok)
return False
"""
Function to get the panel and text data.
"""
def getPanelsAndText(self, node, list):
textLayersToSearch = ["text"]
panelLayersToSearch = ["panels"]
if "textLayerNames" in self.configDictionary.keys():
textLayersToSearch = self.configDictionary["textLayerNames"]
if "panelLayerNames" in self.configDictionary.keys():
panelLayersToSearch = self.configDictionary["panelLayerNames"]
if node.type() == "vectorlayer":
for name in panelLayersToSearch:
if str(name).lower() in str(node.name()).lower():
for shape in node.shapes():
if (shape.type() == "groupshape"):
self.getPanelsAndTextVector(shape, list)
else:
self.handleShapeDescription(shape, list)
for name in textLayersToSearch:
if str(name).lower() in str(node.name()).lower():
for shape in node.shapes():
if (shape.type() == "groupshape"):
self.getPanelsAndTextVector(shape, list, True)
else:
self.handleShapeDescription(shape, list, True)
else:
if node.childNodes():
for child in node.childNodes():
self.getPanelsAndText(node=child, list=list)
def parseTime(self, time = 0):
timeList = []
timeList.append(str(int(time / 60000)))
timeList.append(format(int((time%60000) / 1000), "02d"))
timeList.append(format(int(time % 1000), "03d"))
return ":".join(timeList)
"""
Function to get the panel and text data from a group shape
"""
def getPanelsAndTextVector(self, group, list, textOnly=False):
for shape in group.shapes():
if (shape.type() == "groupshape"):
self.getPanelsAndTextVector(shape, list, textOnly)
else:
self.handleShapeDescription(shape, list, textOnly)
"""
Function to get text and panels in a format that acbf will accept
"""
def handleShapeDescription(self, shape, list, textOnly=False):
if (shape.type() != "KoSvgTextShapeID" and textOnly is True):
return
shapeDesc = {}
shapeDesc["name"] = shape.name()
rect = shape.boundingBox()
listOfPoints = [rect.topLeft(), rect.topRight(), rect.bottomRight(), rect.bottomLeft()]
shapeDoc = minidom.parseString(shape.toSvg())
docElem = shapeDoc.documentElement
svgRegExp = re.compile('[MLCSQHVATmlzcqshva]\d+\.?\d* \d+\.?\d*')
transform = docElem.getAttribute("transform")
coord = []
adjust = QTransform()
# TODO: If we get global transform api, use that instead of parsing manually.
if "translate" in transform:
transform = transform.replace('translate(', '')
for c in transform[:-1].split(" "):
coord.append(float(c))
if len(coord) < 2:
coord.append(coord[0])
adjust = QTransform(1, 0, 0, 1, coord[0], coord[1])
if "matrix" in transform:
transform = transform.replace('matrix(', '')
for c in transform[:-1].split(" "):
coord.append(float(c))
adjust = QTransform(coord[0], coord[1], coord[2], coord[3], coord[4], coord[5])
path = QPainterPath()
if docElem.localName == "path":
dVal = docElem.getAttribute("d")
listOfSvgStrings = [" "]
listOfSvgStrings = svgRegExp.findall(dVal)
if listOfSvgStrings:
listOfPoints = []
for l in listOfSvgStrings:
line = l[1:]
coordinates = line.split(" ")
if len(coordinates) < 2:
coordinates.append(coordinates[0])
x = float(coordinates[-2])
y = float(coordinates[-1])
offset = QPointF()
if l.islower():
offset = listOfPoints[0]
if l.lower().startswith("m"):
path.moveTo(QPointF(x, y) + offset)
elif l.lower().startswith("h"):
y = listOfPoints[-1].y()
path.lineTo(QPointF(x, y) + offset)
elif l.lower().startswith("v"):
x = listOfPoints[-1].x()
path.lineTo(QPointF(x, y) + offset)
elif l.lower().startswith("c"):
path.cubicTo(coordinates[0], coordinates[1], coordinates[2], coordinates[3], x, y)
else:
path.lineTo(QPointF(x, y) + offset)
path.setFillRule(Qt.WindingFill)
for polygon in path.simplified().toSubpathPolygons(adjust):
for point in polygon:
listOfPoints.append(point)
elif docElem.localName == "rect":
listOfPoints = []
if (docElem.hasAttribute("x")):
x = float(docElem.getAttribute("x"))
else:
x = 0
if (docElem.hasAttribute("y")):
y = float(docElem.getAttribute("y"))
else:
y = 0
w = float(docElem.getAttribute("width"))
h = float(docElem.getAttribute("height"))
path.addRect(QRectF(x, y, w, h))
for point in path.toFillPolygon(adjust):
listOfPoints.append(point)
elif docElem.localName == "ellipse":
listOfPoints = []
if (docElem.hasAttribute("cx")):
x = float(docElem.getAttribute("cx"))
else:
x = 0
if (docElem.hasAttribute("cy")):
y = float(docElem.getAttribute("cy"))
else:
y = 0
ry = float(docElem.getAttribute("ry"))
rx = float(docElem.getAttribute("rx"))
path.addEllipse(QPointF(x, y), rx, ry)
for point in path.toFillPolygon(adjust):
listOfPoints.append(point)
elif docElem.localName == "text":
# NOTE: This only works for horizontal preformated text. Vertical text needs a different
# ordering of the rects, and wraparound should try to take the shape it is wrapped in.
family = "sans-serif"
if docElem.hasAttribute("font-family"):
family = docElem.getAttribute("font-family")
size = "11"
if docElem.hasAttribute("font-size"):
size = docElem.getAttribute("font-size")
multilineText = True
for el in docElem.childNodes:
if el.nodeType == minidom.Node.TEXT_NODE:
multilineText = False
if multilineText:
listOfPoints = []
listOfRects = []
# First we collect all the possible line-rects.
for el in docElem.childNodes:
if docElem.hasAttribute("font-family"):
family = docElem.getAttribute("font-family")
if docElem.hasAttribute("font-size"):
size = docElem.getAttribute("font-size")
fontsize = int(size)
font = QFont(family, fontsize)
string = el.toxml()
string = re.sub("\<.*?\>", " ", string)
string = string.replace(" ", " ")
width = min(QFontMetrics(font).width(string.strip()), rect.width())
height = QFontMetrics(font).height()
anchor = "start"
if docElem.hasAttribute("text-anchor"):
anchor = docElem.getAttribute("text-anchor")
top = rect.top()
if len(listOfRects)>0:
top = listOfRects[-1].bottom()
if anchor == "start":
spanRect = QRectF(rect.left(), top, width, height)
listOfRects.append(spanRect)
elif anchor == "end":
spanRect = QRectF(rect.right()-width, top, width, height)
listOfRects.append(spanRect)
else:
# Middle
spanRect = QRectF(rect.center().x()-(width*0.5), top, width, height)
listOfRects.append(spanRect)
# Now we have all the rects, we can check each and draw a
# polygon around them.
heightAdjust = (rect.height()-(listOfRects[-1].bottom()-rect.top()))/len(listOfRects)
for i in range(len(listOfRects)):
span = listOfRects[i]
addtionalHeight = i*heightAdjust
if i == 0:
listOfPoints.append(span.topLeft())
listOfPoints.append(span.topRight())
else:
if listOfRects[i-1].width()< span.width():
listOfPoints.append(QPointF(span.right(), span.top()+addtionalHeight))
listOfPoints.insert(0, QPointF(span.left(), span.top()+addtionalHeight))
else:
bottom = listOfRects[i-1].bottom()+addtionalHeight-heightAdjust
listOfPoints.append(QPointF(listOfRects[i-1].right(), bottom))
listOfPoints.insert(0, QPointF(listOfRects[i-1].left(), bottom))
listOfPoints.append(QPointF(span.right(), rect.bottom()))
listOfPoints.insert(0, QPointF(span.left(), rect.bottom()))
path = QPainterPath()
path.moveTo(listOfPoints[0])
for p in range(1, len(listOfPoints)):
path.lineTo(listOfPoints[p])
path.closeSubpath()
listOfPoints = []
for point in path.toFillPolygon(adjust):
listOfPoints.append(point)
shapeDesc["boundingBox"] = listOfPoints
if (shape.type() == "KoSvgTextShapeID" and textOnly is True):
shapeDesc["text"] = shape.toSvg()
list.append(shapeDesc)
"""
Function to remove layers when they have the given labels.
If not, but the node does have children, check those too.
"""
def removeLayers(self, labels, node):
if node.colorLabel() in labels:
node.remove()
else:
if node.childNodes():
for child in node.childNodes():
self.removeLayers(labels, node=child)
"""
package cbz puts all the meta-data and relevant files into an zip file ending with ".cbz"
"""
def package_cbz(self, exportPath):
# Use the project name if there's no title to avoid sillyness with unnamed zipfiles.
title = self.configDictionary["projectName"]
if "title" in self.configDictionary.keys():
title = str(self.configDictionary["title"]).replace(" ", "_")
# Get the appropriate path.
url = str(exportPath / str(title + ".cbz"))
# Create a zip file.
cbzArchive = zipfile.ZipFile(url, mode="w", compression=zipfile.ZIP_STORED)
# Add all the meta data files.
cbzArchive.write(self.acbfLocation, Path(self.acbfLocation).name)
cbzArchive.write(self.cometLocation, Path(self.cometLocation).name)
cbzArchive.write(self.comicRackInfo, Path(self.comicRackInfo).name)
comic_book_info_json_dump = str()
self.progress.setLabelText(i18n("Saving out Comicbook\ninfo metadata file"))
self.progress.setValue(self.progress.value()+1)
comic_book_info_json_dump = exporters.comic_book_info.writeJson(self.configDictionary)
cbzArchive.comment = comic_book_info_json_dump.encode("utf-8")
# Add the pages.
if "CBZ" in self.pagesLocationList.keys():
for page in self.pagesLocationList["CBZ"]:
if (Path(page).exists()):
cbzArchive.write(page, Path(page).name)
self.progress.setLabelText(i18n("Packaging CBZ"))
self.progress.setValue(self.progress.value()+1)
# Close the zip file when done.
cbzArchive.close()
class VNA(QMainWindow, Ui_VNA):
max_size = 16384
def __init__(self):
super(VNA, self).__init__()
self.setupUi(self)
# IP address validator
rx = QRegExp(
'^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$'
)
self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue))
# state variables
self.idle = True
self.reading = False
# sweep parameters
self.sweep_start = 10
self.sweep_stop = 60000
self.sweep_size = 6000
# buffer and offset for the incoming samples
self.buffer = bytearray(24 * VNA.max_size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.complex64)
self.open = Measurement(self.sweep_start, self.sweep_stop,
self.sweep_size)
self.short = Measurement(self.sweep_start, self.sweep_stop,
self.sweep_size)
self.load = Measurement(self.sweep_start, self.sweep_stop,
self.sweep_size)
self.dut = Measurement(self.sweep_start, self.sweep_stop,
self.sweep_size)
self.mode = 'dut'
# create figure
self.figure = Figure()
self.figure.set_facecolor('none')
self.canvas = FigureCanvas(self.figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# initialize cursor
self.cursor = None
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
# connect signals from buttons and boxes
self.sweepFrame.setEnabled(False)
self.dutSweep.setEnabled(False)
self.connectButton.clicked.connect(self.start)
self.writeButton.clicked.connect(self.write_cfg)
self.readButton.clicked.connect(self.read_cfg)
self.openSweep.clicked.connect(self.sweep_open)
self.shortSweep.clicked.connect(self.sweep_short)
self.loadSweep.clicked.connect(self.sweep_load)
self.dutSweep.clicked.connect(self.sweep_dut)
self.csvButton.clicked.connect(self.write_csv)
self.s1pButton.clicked.connect(self.write_s1p)
self.s2pButton.clicked.connect(self.write_s2p)
self.startValue.valueChanged.connect(self.set_start)
self.stopValue.valueChanged.connect(self.set_stop)
self.sizeValue.valueChanged.connect(self.set_size)
self.rateValue.addItems([
'50000', '10000', '5000', '1000', '500', '100', '50', '10', '5',
'1'
])
self.rateValue.lineEdit().setReadOnly(True)
self.rateValue.lineEdit().setAlignment(Qt.AlignRight)
for i in range(0, self.rateValue.count()):
self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole)
self.rateValue.currentIndexChanged.connect(self.set_rate)
self.corrValue.valueChanged.connect(self.set_corr)
self.levelValue.valueChanged.connect(self.set_level)
self.openPlot.clicked.connect(self.plot_open)
self.shortPlot.clicked.connect(self.plot_short)
self.loadPlot.clicked.connect(self.plot_load)
self.dutPlot.clicked.connect(self.plot_dut)
self.smithPlot.clicked.connect(self.plot_smith)
self.impPlot.clicked.connect(self.plot_imp)
self.rcPlot.clicked.connect(self.plot_rc)
self.swrPlot.clicked.connect(self.plot_swr)
self.rlPlot.clicked.connect(self.plot_rl)
self.gainPlot.clicked.connect(self.plot_gain)
# create timer
self.startTimer = QTimer(self)
self.startTimer.timeout.connect(self.timeout)
def start(self):
if self.idle:
self.connectButton.setEnabled(False)
self.socket.connectToHost(self.addrValue.text(), 1001)
self.startTimer.start(5000)
else:
self.stop()
def stop(self):
self.idle = True
self.socket.abort()
self.connectButton.setText('Connect')
self.connectButton.setEnabled(True)
self.sweepFrame.setEnabled(False)
self.selectFrame.setEnabled(True)
self.dutSweep.setEnabled(False)
def timeout(self):
self.display_error('timeout')
def connected(self):
self.startTimer.stop()
self.idle = False
self.set_start(self.startValue.value())
self.set_stop(self.stopValue.value())
self.set_size(self.sizeValue.value())
self.set_rate(self.rateValue.currentIndex())
self.set_corr(self.corrValue.value())
self.set_level(self.levelValue.value())
self.connectButton.setText('Disconnect')
self.connectButton.setEnabled(True)
self.sweepFrame.setEnabled(True)
self.dutSweep.setEnabled(True)
def read_data(self):
while (self.socket.bytesAvailable() > 0):
if not self.reading:
self.socket.readAll()
return
size = self.socket.bytesAvailable()
self.progress.setValue((self.offset + size) / 24)
limit = 24 * self.sweep_size
if self.offset + size < limit:
self.buffer[self.offset:self.offset +
size] = self.socket.read(size)
self.offset += size
else:
self.buffer[self.offset:limit] = self.socket.read(limit -
self.offset)
adc1 = self.data[0::3]
adc2 = self.data[1::3]
dac = self.data[2::3]
attr = getattr(self, self.mode)
size = attr.freq.size
attr.data = adc1[0:size] / dac[0:size]
getattr(self, 'plot_%s' % self.mode)()
self.reading = False
self.sweepFrame.setEnabled(True)
self.selectFrame.setEnabled(True)
def display_error(self, socketError):
self.startTimer.stop()
if socketError == 'timeout':
QMessageBox.information(self, 'VNA', 'Error: connection timeout.')
else:
QMessageBox.information(self, 'VNA',
'Error: %s.' % self.socket.errorString())
self.stop()
def set_start(self, value):
self.sweep_start = value
def set_stop(self, value):
self.sweep_stop = value
def set_size(self, value):
self.sweep_size = value
def set_rate(self, value):
if self.idle: return
rate = [1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000][value]
self.socket.write(struct.pack('<I', 3 << 28 | int(rate)))
def set_corr(self, value):
if self.idle: return
self.socket.write(struct.pack('<I', 4 << 28 | int(value)))
def set_level(self, value):
if self.idle: return
self.socket.write(
struct.pack('<I',
5 << 28 | int(32767 * np.power(10.0, value / 20.0))))
def sweep(self, mode):
if self.idle: return
self.sweepFrame.setEnabled(False)
self.selectFrame.setEnabled(False)
self.mode = mode
attr = getattr(self, mode)
attr.freq = np.linspace(self.sweep_start, self.sweep_stop,
self.sweep_size) * 1000
self.offset = 0
self.reading = True
self.socket.write(
struct.pack('<I', 0 << 28 | int(self.sweep_start * 1000)))
self.socket.write(
struct.pack('<I', 1 << 28 | int(self.sweep_stop * 1000)))
self.socket.write(struct.pack('<I', 2 << 28 | int(self.sweep_size)))
self.socket.write(struct.pack('<I', 6 << 28))
self.progress = QProgressDialog('Sweep status', 'Cancel', 0,
self.sweep_size)
self.progress.setModal(True)
self.progress.setMinimumDuration(1000)
self.progress.canceled.connect(self.cancel)
def cancel(self):
self.offset = 0
self.reading = False
self.socket.write(struct.pack('<I', 7 << 28))
self.sweepFrame.setEnabled(True)
self.selectFrame.setEnabled(True)
def sweep_open(self):
self.sweep('open')
def sweep_short(self):
self.sweep('short')
def sweep_load(self):
self.sweep('load')
def sweep_dut(self):
self.sweep('dut')
def interp(self, freq, data):
real = np.interp(self.dut.freq, freq, data.real)
imag = np.interp(self.dut.freq, freq, data.imag)
return real + 1j * imag
def gain(self):
return self.dut.data / self.interp(self.short.freq, self.short.data)
def impedance(self):
open = self.interp(self.open.freq, self.open.data)
short = self.interp(self.short.freq, self.short.data)
load = self.interp(self.load.freq, self.load.data)
dut = self.dut.data
return 50.0 * (open - load) * (dut - short) / ((load - short) *
(open - dut))
def gamma(self):
z = self.impedance()
return (z - 50.0) / (z + 50.0)
def plot_gain(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left=0.12,
bottom=0.12,
right=0.88,
top=0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.tick_params('y', color='blue', labelcolor='blue')
axes1.yaxis.label.set_color('blue')
gain = self.gain()
axes1.plot(self.dut.freq,
20.0 * np.log10(np.absolute(gain)),
color='blue',
label='Gain')
axes2 = axes1.twinx()
axes2.spines['left'].set_color('blue')
axes2.spines['right'].set_color('red')
axes1.set_xlabel('Hz')
axes1.set_ylabel('Gain, dB')
axes2.set_ylabel('Phase angle')
axes2.tick_params('y', color='red', labelcolor='red')
axes2.yaxis.label.set_color('red')
axes2.plot(self.dut.freq,
np.angle(gain, deg=True),
color='red',
label='Phase angle')
self.cursor = datacursor(axes=self.figure.get_axes(),
formatter=LabelFormatter(),
display='multiple')
self.canvas.draw()
def plot_magphase(self, freq, data):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left=0.12,
bottom=0.12,
right=0.88,
top=0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.tick_params('y', color='blue', labelcolor='blue')
axes1.yaxis.label.set_color('blue')
axes1.plot(freq, np.absolute(data), color='blue', label='Magnitude')
axes2 = axes1.twinx()
axes2.spines['left'].set_color('blue')
axes2.spines['right'].set_color('red')
axes1.set_xlabel('Hz')
axes1.set_ylabel('Magnitude')
axes2.set_ylabel('Phase angle')
axes2.tick_params('y', color='red', labelcolor='red')
axes2.yaxis.label.set_color('red')
axes2.plot(freq,
np.angle(data, deg=True),
color='red',
label='Phase angle')
self.cursor = datacursor(axes=self.figure.get_axes(),
formatter=LabelFormatter(),
display='multiple')
self.canvas.draw()
def plot_open(self):
self.plot_magphase(self.open.freq, self.open.data)
def plot_short(self):
self.plot_magphase(self.short.freq, self.short.data)
def plot_load(self):
self.plot_magphase(self.load.freq, self.load.data)
def plot_dut(self):
self.plot_magphase(self.dut.freq, self.dut.data)
def plot_smith_grid(self, axes, color):
load = 50.0
ticks = np.array([0.0, 0.2, 0.5, 1.0, 2.0, 5.0])
for tick in ticks * load:
axis = np.logspace(-4, np.log10(1.0e3), 200) * load
z = tick + 1.0j * axis
gamma = (z - load) / (z + load)
axes.plot(gamma.real,
gamma.imag,
color=color,
linewidth=0.4,
alpha=0.3)
axes.plot(gamma.real,
-gamma.imag,
color=color,
linewidth=0.4,
alpha=0.3)
z = axis + 1.0j * tick
gamma = (z - load) / (z + load)
axes.plot(gamma.real,
gamma.imag,
color=color,
linewidth=0.4,
alpha=0.3)
axes.plot(gamma.real,
-gamma.imag,
color=color,
linewidth=0.4,
alpha=0.3)
if tick == 0.0:
axes.text(1.0,
0.0,
u'\u221E',
color=color,
ha='left',
va='center',
clip_on=True,
fontsize=18.0)
axes.text(-1.0,
0.0,
u'0\u03A9',
color=color,
ha='left',
va='bottom',
clip_on=True,
fontsize=12.0)
continue
lab = u'%d\u03A9' % tick
x = (tick - load) / (tick + load)
axes.text(x,
0.0,
lab,
color=color,
ha='left',
va='bottom',
clip_on=True,
fontsize=12.0)
lab = u'j%d\u03A9' % tick
z = 1.0j * tick
gamma = (z - load) / (z + load) * 1.05
x = gamma.real
y = gamma.imag
angle = np.angle(gamma) * 180.0 / np.pi - 90.0
axes.text(x,
y,
lab,
color=color,
ha='center',
va='center',
clip_on=True,
rotation=angle,
fontsize=12.0)
lab = u'-j%d\u03A9' % tick
axes.text(x,
-y,
lab,
color=color,
ha='center',
va='center',
clip_on=True,
rotation=-angle,
fontsize=12.0)
def plot_smith(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left=0.0, bottom=0.0, right=1.0, top=1.0)
axes1 = self.figure.add_subplot(111)
self.plot_smith_grid(axes1, 'blue')
gamma = self.gamma()
plot, = axes1.plot(gamma.real, gamma.imag, color='red')
axes1.axis('equal')
axes1.set_xlim(-1.12, 1.12)
axes1.set_ylim(-1.12, 1.12)
axes1.xaxis.set_visible(False)
axes1.yaxis.set_visible(False)
for loc, spine in axes1.spines.items():
spine.set_visible(False)
self.cursor = datacursor(plot,
formatter=SmithFormatter(self.dut.freq),
display='multiple')
self.canvas.draw()
def plot_imp(self):
self.plot_magphase(self.dut.freq, self.impedance())
def plot_rc(self):
self.plot_magphase(self.dut.freq, self.gamma())
def plot_swr(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left=0.12,
bottom=0.12,
right=0.88,
top=0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.set_xlabel('Hz')
axes1.set_ylabel('SWR')
magnitude = np.absolute(self.gamma())
swr = np.maximum(
1.0,
np.minimum(100.0, (1.0 + magnitude) /
np.maximum(1.0e-20, 1.0 - magnitude)))
axes1.plot(self.dut.freq, swr, color='blue', label='SWR')
self.cursor = datacursor(axes=self.figure.get_axes(),
formatter=LabelFormatter(),
display='multiple')
self.canvas.draw()
def plot_rl(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left=0.12,
bottom=0.12,
right=0.88,
top=0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.set_xlabel('Hz')
axes1.set_ylabel('Return loss, dB')
magnitude = np.absolute(self.gamma())
axes1.plot(self.dut.freq,
20.0 * np.log10(magnitude),
color='blue',
label='Return loss')
self.cursor = datacursor(axes=self.figure.get_axes(),
formatter=LabelFormatter(),
display='multiple')
self.canvas.draw()
def write_cfg(self):
dialog = QFileDialog(self, 'Write configuration settings', '.',
'*.ini')
dialog.setDefaultSuffix('ini')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
settings = QSettings(name[0], QSettings.IniFormat)
self.write_cfg_settings(settings)
def read_cfg(self):
dialog = QFileDialog(self, 'Read configuration settings', '.', '*.ini')
dialog.setDefaultSuffix('ini')
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
settings = QSettings(name[0], QSettings.IniFormat)
self.read_cfg_settings(settings)
def write_cfg_settings(self, settings):
settings.setValue('addr', self.addrValue.text())
settings.setValue('rate', self.rateValue.currentIndex())
settings.setValue('corr', self.corrValue.value())
settings.setValue('open_start', int(self.open.freq[0]))
settings.setValue('open_stop', int(self.open.freq[-1]))
settings.setValue('open_size', self.open.freq.size)
settings.setValue('short_start', int(self.short.freq[0]))
settings.setValue('short_stop', int(self.short.freq[-1]))
settings.setValue('short_size', self.short.freq.size)
settings.setValue('load_start', int(self.load.freq[0]))
settings.setValue('load_stop', int(self.load.freq[-1]))
settings.setValue('load_size', self.load.freq.size)
settings.setValue('dut_start', int(self.dut.freq[0]))
settings.setValue('dut_stop', int(self.dut.freq[-1]))
settings.setValue('dut_size', self.dut.freq.size)
data = self.open.data
for i in range(0, self.open.freq.size):
settings.setValue('open_real_%d' % i, float(data.real[i]))
settings.setValue('open_imag_%d' % i, float(data.imag[i]))
data = self.short.data
for i in range(0, self.short.freq.size):
settings.setValue('short_real_%d' % i, float(data.real[i]))
settings.setValue('short_imag_%d' % i, float(data.imag[i]))
data = self.load.data
for i in range(0, self.load.freq.size):
settings.setValue('load_real_%d' % i, float(data.real[i]))
settings.setValue('load_imag_%d' % i, float(data.imag[i]))
data = self.dut.data
for i in range(0, self.dut.freq.size):
settings.setValue('dut_real_%d' % i, float(data.real[i]))
settings.setValue('dut_imag_%d' % i, float(data.imag[i]))
def read_cfg_settings(self, settings):
self.addrValue.setText(settings.value('addr', '192.168.1.100'))
self.rateValue.setCurrentIndex(settings.value('rate', 0, type=int))
self.corrValue.setValue(settings.value('corr', 0, type=int))
open_start = settings.value('open_start', 10000, type=int) // 1000
open_stop = settings.value('open_stop', 60000000, type=int) // 1000
open_size = settings.value('open_size', 6000, type=int)
short_start = settings.value('short_start', 10000, type=int) // 1000
short_stop = settings.value('short_stop', 60000000, type=int) // 1000
short_size = settings.value('short_size', 6000, type=int)
load_start = settings.value('load_start', 10000, type=int) // 1000
load_stop = settings.value('load_stop', 60000000, type=int) // 1000
load_size = settings.value('load_size', 6000, type=int)
dut_start = settings.value('dut_start', 10000, type=int) // 1000
dut_stop = settings.value('dut_stop', 60000000, type=int) // 1000
dut_size = settings.value('dut_size', 6000, type=int)
self.startValue.setValue(dut_start)
self.stopValue.setValue(dut_stop)
self.sizeValue.setValue(dut_size)
self.open = Measurement(open_start, open_stop, open_size)
for i in range(0, open_size):
real = settings.value('open_real_%d' % i, 0.0, type=float)
imag = settings.value('open_imag_%d' % i, 0.0, type=float)
self.open.data[i] = real + 1.0j * imag
self.short = Measurement(short_start, short_stop, short_size)
for i in range(0, short_size):
real = settings.value('short_real_%d' % i, 0.0, type=float)
imag = settings.value('short_imag_%d' % i, 0.0, type=float)
self.short.data[i] = real + 1.0j * imag
self.load = Measurement(load_start, load_stop, load_size)
for i in range(0, load_size):
real = settings.value('load_real_%d' % i, 0.0, type=float)
imag = settings.value('load_imag_%d' % i, 0.0, type=float)
self.load.data[i] = real + 1.0j * imag
self.dut = Measurement(dut_start, dut_stop, dut_size)
for i in range(0, dut_size):
real = settings.value('dut_real_%d' % i, 0.0, type=float)
imag = settings.value('dut_imag_%d' % i, 0.0, type=float)
self.dut.data[i] = real + 1.0j * imag
def write_csv(self):
dialog = QFileDialog(self, 'Write csv file', '.', '*.csv')
dialog.setDefaultSuffix('csv')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
fh = open(name[0], 'w')
o = self.interp(self.open.freq, self.open.data)
s = self.interp(self.short.freq, self.short.data)
l = self.interp(self.load.freq, self.load.data)
d = self.dut.data
f = self.dut.freq
fh.write(
'frequency;open.real;open.imag;short.real;short.imag;load.real;load.imag;dut.real;dut.imag\n'
)
for i in range(0, f.size):
fh.write(
'0.0%.8d;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f\n'
% (f[i], o.real[i], o.imag[i], s.real[i], s.imag[i],
l.real[i], l.imag[i], d.real[i], d.imag[i]))
fh.close()
def write_s1p(self):
dialog = QFileDialog(self, 'Write s1p file', '.', '*.s1p')
dialog.setDefaultSuffix('s1p')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
fh = open(name[0], 'w')
gamma = self.gamma()
freq = self.dut.freq
fh.write('# GHz S MA R 50\n')
for i in range(0, freq.size):
fh.write('0.0%.8d %8.6f %7.2f\n' %
(freq[i], np.absolute(
gamma[i]), np.angle(gamma[i], deg=True)))
fh.close()
def write_s2p(self):
dialog = QFileDialog(self, 'Write s2p file', '.', '*.s2p')
dialog.setDefaultSuffix('s2p')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
fh = open(name[0], 'w')
gain = self.gain()
gamma = self.gamma()
freq = self.dut.freq
fh.write('# GHz S MA R 50\n')
for i in range(0, freq.size):
fh.write(
'0.0%.8d %8.6f %7.2f %8.6f %7.2f 0.000000 0.00 0.000000 0.00\n'
% (freq[i], np.absolute(gamma[i]),
np.angle(gamma[i], deg=True), np.absolute(
gain[i]), np.angle(gain[i], deg=True)))
fh.close()
def setupUi(self):
self.log.debug("Initializing UI.")
self.load_ui("apol/infoflow.ui")
# set up error message for missing perm map
self.error_msg = QMessageBox(self)
self.error_msg.setStandardButtons(QMessageBox.Ok)
# set up perm map editor
self.permmap_editor = PermissionMapEditor(self, False)
# set up source/target autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.source.setCompleter(self.type_completion)
self.target.setCompleter(self.type_completion)
# setup indications of errors on source/target/default
self.errors = set()
self.orig_palette = self.source.palette()
self.error_palette = self.source.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_source_error()
self.clear_target_error()
# set up processing thread
self.thread = ResultsUpdater(self.query)
self.thread.raw_line.connect(self.raw_results.appendPlainText)
self.thread.finished.connect(self.update_complete)
self.thread.flows.connect(self.reset_browser)
# set up browser thread
self.browser_thread = BrowserUpdater(self.query)
self.browser_thread.flows.connect(self.add_browser_children)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.setCancelButton(None)
self.busy.reset()
# update busy dialog from infoflow INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.infoflow").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.max_path_length.setEnabled(self.all_paths.isChecked())
self.source.setEnabled(not self.flows_in.isChecked())
self.target.setEnabled(not self.flows_out.isChecked())
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
self.browser_tab.setEnabled(self.flows_in.isChecked()
or self.flows_out.isChecked())
# connect signals
self.buttonBox.clicked.connect(self.run)
self.source.textEdited.connect(self.clear_source_error)
self.source.editingFinished.connect(self.set_source)
self.target.textEdited.connect(self.clear_target_error)
self.target.editingFinished.connect(self.set_target)
self.all_paths.toggled.connect(self.all_paths_toggled)
self.flows_in.toggled.connect(self.flows_in_toggled)
self.flows_out.toggled.connect(self.flows_out_toggled)
self.min_perm_weight.valueChanged.connect(self.set_min_weight)
self.exclude_types.clicked.connect(self.choose_excluded_types)
self.edit_permmap.clicked.connect(self.open_permmap_editor)
self.browser.currentItemChanged.connect(self.browser_item_selected)
def showDialog(self):
'''
显示进度对话框
'''
num = int(self.edit.text())
progress = QProgressDialog(self)
progress.setWindowTitle("请稍等")
progress.setLabelText("正在操作...")
progress.setCancelButtonText("取消")
progress.setMinimumDuration(5)
# 估计操作所花费的时间（基于步骤的时间），并且只有当该估计值超出minimumDuration() （默认为4秒）时才显示
progress.setWindowModality(Qt.WindowModal)
# 此属性保留由模态小部件阻止的窗口。这个属性只对Windows有意义。
# 模态小部件防止其他窗口中的小部件获取输入。该属性的值控制在窗口小部件可见时阻止哪些窗口。
# 窗口可见时更改此属性无效；您必须首先hide()小部件，然后再次show()。
progress.setRange(0, num)#设置进度范围
for i in range(num):
progress.setValue(i)
if progress.wasCanceled():#判断我们是否按下取消按钮
QMessageBox.warning(self, "提示", "操作失败")
break
else:
progress.setValue(num)
QMessageBox.information(self, "提示", "操作成功")
