nectarchain.trr_test_suite.gui.TestRunner#

class TestRunner[source]#

Bases: QWidget

The TestRunner class is a GUI application that allows the user to run various tests and display the results. The class provides the following functionality: - Allows the user to select a test from a dropdown menu. - Dynamically generates input fields based on the selected test. - Runs the selected test and displays the output in a text box. - Displays the test results in a plot canvas, with navigation buttons to switch between multiple plots. - Provides a dark-themed UI with custom styling for various UI elements. The class uses the PyQt5 library for the GUI implementation and the Matplotlib library for plotting the test results.

Methods

`acceptDrops`	acceptDrops(self) -> bool
`accessibleDescription`	accessibleDescription(self) -> str
`accessibleName`	accessibleName(self) -> str
`actionEvent`
`actions`	actions(self) -> List[QAction]
`activateWindow`
`addAction`
`addActions`
`adjustSize`
`autoFillBackground`	autoFillBackground(self) -> bool
`backgroundRole`	backgroundRole(self) -> QPalette.ColorRole
`baseSize`	baseSize(self) -> QSize
`blockSignals`	blockSignals(self, b: bool) -> bool
`changeEvent`
`check_and_display_plot`
`childAt`	childAt(self, p: QPoint) -> Optional[QWidget] childAt(self, ax: int, ay: int) -> Optional[QWidget]
`childEvent`
`children`	children(self) -> List[QObject]
`childrenRect`	childrenRect(self) -> QRect
`childrenRegion`	childrenRegion(self) -> QRegion
`cleanup_tempdir`	Remove old plot files in temp directory.
`clearFocus`
`clearMask`
`close`	close(self) -> bool
`closeEvent`
`colorCount`	colorCount(self) -> int
`connectNotify`
`contentsMargins`	contentsMargins(self) -> QMargins
`contentsRect`	contentsRect(self) -> QRect
`contextMenuEvent`
`contextMenuPolicy`	contextMenuPolicy(self) -> Qt.ContextMenuPolicy
`create`
`createWindowContainer`	createWindowContainer(window: Optional[QWindow], parent: Optional[QWidget] = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = 0) -> QWidget
`cursor`	cursor(self) -> QCursor
`customEvent`
`debug_layout`
`deleteLater`
`depth`	depth(self) -> int
`destroy`
`devType`	devType(self) -> int
`devicePixelRatio`	devicePixelRatio(self) -> int
`devicePixelRatioF`	devicePixelRatioF(self) -> float
`devicePixelRatioFScale`	devicePixelRatioFScale() -> float
`disconnect`
`disconnectNotify`
`display_plot`	Loads the plots from the pickle files and displays them on the canvas.
`dragEnterEvent`
`dragLeaveEvent`
`dragMoveEvent`
`dropEvent`
`dumpObjectInfo`
`dumpObjectTree`
`dynamicPropertyNames`	dynamicPropertyNames(self) -> List[QByteArray]
`effectiveWinId`	effectiveWinId(self) -> PyQt5.sip.voidptr
`ensurePolished`
`enterEvent`
`event`	event(self, a0: Optional[QEvent]) -> bool
`eventFilter`	eventFilter(self, a0: Optional[QObject], a1: Optional[QEvent]) -> bool
`find`	find(a0: PyQt5.sip.voidptr) -> Optional[QWidget]
`findChild`	findChild(self, type: Type[QObjectT], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> QObjectT findChild(self, types: Tuple[Type[QObjectT], ...], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> QObjectT
`findChildren`	findChildren(self, type: Type[QObjectT], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, types: Tuple[Type[QObjectT], ...], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, type: Type[QObjectT], regExp: QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, types: Tuple[Type[QObjectT], ...], regExp: QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, type: Type[QObjectT], re: QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, types: Tuple[Type[QObjectT], ...], re: QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT]
`focusInEvent`
`focusNextChild`	focusNextChild(self) -> bool
`focusNextPrevChild`	focusNextPrevChild(self, next: bool) -> bool
`focusOutEvent`
`focusPolicy`	focusPolicy(self) -> Qt.FocusPolicy
`focusPreviousChild`	focusPreviousChild(self) -> bool
`focusProxy`	focusProxy(self) -> Optional[QWidget]
`focusWidget`	focusWidget(self) -> Optional[QWidget]
`font`	font(self) -> QFont
`fontInfo`	fontInfo(self) -> QFontInfo
`fontMetrics`	fontMetrics(self) -> QFontMetrics
`foregroundRole`	foregroundRole(self) -> QPalette.ColorRole
`frameGeometry`	frameGeometry(self) -> QRect
`frameSize`	frameSize(self) -> QSize
`geometry`	geometry(self) -> QRect
`getContentsMargins`
`get_parameters_from_module`
`grab`	grab(self, rectangle: QRect = QRect(QPoint(0, 0), QSize(-1, -1))) -> QPixmap
`grabGesture`
`grabKeyboard`
`grabMouse`
`grabShortcut`	grabShortcut(self, key: Union[QKeySequence, QKeySequence.StandardKey, Optional[str], int], context: Qt.ShortcutContext = Qt.WindowShortcut) -> int
`graphicsEffect`	graphicsEffect(self) -> Optional[QGraphicsEffect]
`graphicsProxyWidget`	graphicsProxyWidget(self) -> Optional[QGraphicsProxyWidget]
`hasFocus`	hasFocus(self) -> bool
`hasHeightForWidth`	hasHeightForWidth(self) -> bool
`hasMouseTracking`	hasMouseTracking(self) -> bool
`hasTabletTracking`	hasTabletTracking(self) -> bool
`height`	height(self) -> int
`heightForWidth`	heightForWidth(self, a0: int) -> int
`heightMM`	heightMM(self) -> int
`hide`
`hideEvent`
`inherits`	inherits(self, classname: Optional[str]) -> bool
`initPainter`
`init_ui`
`inputMethodEvent`
`inputMethodHints`	inputMethodHints(self) -> Qt.InputMethodHints
`inputMethodQuery`	inputMethodQuery(self, a0: Qt.InputMethodQuery) -> Any
`insertAction`
`insertActions`
`installEventFilter`
`isActiveWindow`	isActiveWindow(self) -> bool
`isAncestorOf`	isAncestorOf(self, child: Optional[QWidget]) -> bool
`isEnabled`	isEnabled(self) -> bool
`isEnabledTo`	isEnabledTo(self, a0: Optional[QWidget]) -> bool
`isFullScreen`	isFullScreen(self) -> bool
`isHidden`	isHidden(self) -> bool
`isLeftToRight`	isLeftToRight(self) -> bool
`isMaximized`	isMaximized(self) -> bool
`isMinimized`	isMinimized(self) -> bool
`isModal`	isModal(self) -> bool
`isRightToLeft`	isRightToLeft(self) -> bool
`isSignalConnected`	isSignalConnected(self, signal: QMetaMethod) -> bool
`isVisible`	isVisible(self) -> bool
`isVisibleTo`	isVisibleTo(self, a0: Optional[QWidget]) -> bool
`isWidgetType`	isWidgetType(self) -> bool
`isWindow`	isWindow(self) -> bool
`isWindowModified`	isWindowModified(self) -> bool
`isWindowType`	isWindowType(self) -> bool
`keyPressEvent`
`keyReleaseEvent`
`keyboardGrabber`	keyboardGrabber() -> Optional[QWidget]
`killTimer`
`layout`	layout(self) -> Optional[QLayout]
`layoutDirection`	layoutDirection(self) -> Qt.LayoutDirection
`leaveEvent`
`locale`	locale(self) -> QLocale
`logicalDpiX`	logicalDpiX(self) -> int
`logicalDpiY`	logicalDpiY(self) -> int
`lower`
`mapFrom`	mapFrom(self, a0: Optional[QWidget], a1: QPoint) -> QPoint
`mapFromGlobal`	mapFromGlobal(self, a0: QPoint) -> QPoint
`mapFromParent`	mapFromParent(self, a0: QPoint) -> QPoint
`mapTo`	mapTo(self, a0: Optional[QWidget], a1: QPoint) -> QPoint
`mapToGlobal`	mapToGlobal(self, a0: QPoint) -> QPoint
`mapToParent`	mapToParent(self, a0: QPoint) -> QPoint
`mask`	mask(self) -> QRegion
`maximumHeight`	maximumHeight(self) -> int
`maximumSize`	maximumSize(self) -> QSize
`maximumWidth`	maximumWidth(self) -> int
`metaObject`	metaObject(self) -> Optional[QMetaObject]
`metric`	metric(self, a0: QPaintDevice.PaintDeviceMetric) -> int
`minimumHeight`	minimumHeight(self) -> int
`minimumSize`	minimumSize(self) -> QSize
`minimumSizeHint`	minimumSizeHint(self) -> QSize
`minimumWidth`	minimumWidth(self) -> int
`mouseDoubleClickEvent`
`mouseGrabber`	mouseGrabber() -> Optional[QWidget]
`mouseMoveEvent`
`mousePressEvent`
`mouseReleaseEvent`
`move`
`moveEvent`
`moveToThread`
`nativeEvent`
`nativeParentWidget`	nativeParentWidget(self) -> Optional[QWidget]
`nextInFocusChain`	nextInFocusChain(self) -> Optional[QWidget]
`normalGeometry`	normalGeometry(self) -> QRect
`objectName`	objectName(self) -> str
`overrideWindowFlags`
`overrideWindowState`
`paintEngine`	paintEngine(self) -> Optional[QPaintEngine]
`paintEvent`
`paintingActive`	paintingActive(self) -> bool
`palette`	palette(self) -> QPalette
`parent`	parent(self) -> Optional[QObject]
`parentWidget`	parentWidget(self) -> Optional[QWidget]
`physicalDpiX`	physicalDpiX(self) -> int
`physicalDpiY`	physicalDpiY(self) -> int
`pos`	pos(self) -> QPoint
`previousInFocusChain`	previousInFocusChain(self) -> Optional[QWidget]
`process_finished`	Handle the process when it finishes.
`property`	property(self, name: Optional[str]) -> Any
`pyqtConfigure`	Each keyword argument is either the name of a Qt property or a Qt signal.
`raise_`
`read_process_output`	Reads and displays the process output in real-time.
`receivers`	receivers(self, signal: PYQT_SIGNAL) -> int
`rect`	rect(self) -> QRect
`releaseKeyboard`
`releaseMouse`
`releaseShortcut`
`removeAction`
`removeEventFilter`
`render`
`repaint`
`resize`
`resizeEvent`
`restoreGeometry`	restoreGeometry(self, geometry: Union[QByteArray, bytes, bytearray]) -> bool
`run_test`
`saveGeometry`	saveGeometry(self) -> QByteArray
`screen`	screen(self) -> Optional[QScreen]
`scroll`
`sender`	sender(self) -> Optional[QObject]
`senderSignalIndex`	senderSignalIndex(self) -> int
`setAcceptDrops`
`setAccessibleDescription`
`setAccessibleName`
`setAttribute`
`setAutoFillBackground`
`setBackgroundRole`
`setBaseSize`
`setContentsMargins`
`setContextMenuPolicy`
`setCursor`
`setDisabled`
`setEnabled`
`setFixedHeight`
`setFixedSize`
`setFixedWidth`
`setFocus`
`setFocusPolicy`
`setFocusProxy`
`setFont`
`setForegroundRole`
`setGeometry`
`setGraphicsEffect`
`setHidden`
`setInputMethodHints`
`setLayout`
`setLayoutDirection`
`setLocale`
`setMask`
`setMaximumHeight`
`setMaximumSize`
`setMaximumWidth`
`setMinimumHeight`
`setMinimumSize`
`setMinimumWidth`
`setMouseTracking`
`setObjectName`
`setPalette`
`setParent`
`setProperty`	setProperty(self, name: Optional[str], value: Any) -> bool
`setShortcutAutoRepeat`
`setShortcutEnabled`
`setSizeIncrement`
`setSizePolicy`
`setStatusTip`
`setStyle`
`setStyleSheet`
`setTabOrder`
`setTabletTracking`
`setToolTip`
`setToolTipDuration`
`setUpdatesEnabled`
`setVisible`
`setWhatsThis`
`setWindowFilePath`
`setWindowFlag`
`setWindowFlags`
`setWindowIcon`
`setWindowIconText`
`setWindowModality`
`setWindowModified`
`setWindowOpacity`
`setWindowRole`
`setWindowState`
`setWindowTitle`
`sharedPainter`	sharedPainter(self) -> Optional[QPainter]
`show`
`showEvent`
`showFullScreen`
`showMaximized`
`showMinimized`
`showNormal`
`show_help`
`show_next_plot`
`show_previous_plot`
`signalsBlocked`	signalsBlocked(self) -> bool
`size`	size(self) -> QSize
`sizeHint`	sizeHint(self) -> QSize
`sizeIncrement`	sizeIncrement(self) -> QSize
`sizePolicy`	sizePolicy(self) -> QSizePolicy
`stackUnder`
`startTimer`	startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) -> int
`statusTip`	statusTip(self) -> str
`style`	style(self) -> Optional[QStyle]
`styleSheet`	styleSheet(self) -> str
`tabletEvent`
`testAttribute`	testAttribute(self, attribute: Qt.WidgetAttribute) -> bool
`thread`	thread(self) -> Optional[QThread]
`timerEvent`
`toolTip`	toolTip(self) -> str
`toolTipDuration`	toolTipDuration(self) -> int
`tr`	tr(self, sourceText: Optional[str], disambiguation: Optional[str] = None, n: int = -1) -> str
`underMouse`	underMouse(self) -> bool
`ungrabGesture`
`unsetCursor`
`unsetLayoutDirection`
`unsetLocale`
`update`
`updateGeometry`
`updateMicroFocus`
`update_parameters`
`update_plot_canvas`	Updates the canvas with the current plot.
`updatesEnabled`	updatesEnabled(self) -> bool
`visibleRegion`	visibleRegion(self) -> QRegion
`whatsThis`	whatsThis(self) -> str
`wheelEvent`
`width`	width(self) -> int
`widthMM`	widthMM(self) -> int
`winId`	winId(self) -> PyQt5.sip.voidptr
`window`	window(self) -> Optional[QWidget]
`windowFilePath`	windowFilePath(self) -> str
`windowFlags`	windowFlags(self) -> Qt.WindowFlags
`windowHandle`	windowHandle(self) -> Optional[QWindow]
`windowIcon`	windowIcon(self) -> QIcon
`windowIconText`	windowIconText(self) -> str
`windowModality`	windowModality(self) -> Qt.WindowModality
`windowOpacity`	windowOpacity(self) -> float
`windowRole`	windowRole(self) -> str
`windowState`	windowState(self) -> Qt.WindowStates
`windowTitle`	windowTitle(self) -> str
`windowType`	windowType(self) -> Qt.WindowType
`x`	x(self) -> int
`y`	y(self) -> int

Attributes

`DrawChildren`
`DrawWindowBackground`
`IgnoreMask`
`PdmDepth`
`PdmDevicePixelRatio`
`PdmDevicePixelRatioScaled`
`PdmDpiX`
`PdmDpiY`
`PdmHeight`
`PdmHeightMM`
`PdmNumColors`
`PdmPhysicalDpiX`
`PdmPhysicalDpiY`
`PdmWidth`
`PdmWidthMM`
`customContextMenuRequested`(QPoint)	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`destroyed`(QObject*)	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`objectNameChanged`(QString)	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`staticMetaObject`
`test_modules`
`windowIconChanged`(QIcon)	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowIconTextChanged`(QString)	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowTitleChanged`(QString)	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL

cleanup_tempdir()[source]#: Remove old plot files in temp directory.

display_plot(plot_files)[source]#: Loads the plots from the pickle files and displays them on the canvas.

process_finished()[source]#: Handle the process when it finishes.

read_process_output()[source]#: Reads and displays the process output in real-time.

update_plot_canvas()[source]#: Updates the canvas with the current plot.