def __init__(self, fileName, parent=None): QObject.__init__(self) sweepCollection = IvSweepCollection(str(fileName)) self.sweepCollection = sweepCollection tableModel = SweepTableModel(sweepCollection) tableView = QTableView() tableView.setModel(tableModel) tableView.setItemDelegateForColumn(0, CheckBoxDelegate(parent=tableView)) tableView.setItemDelegateForColumn(1, CheckBoxDelegate(parent=tableView)) self.tableModel = tableModel tableView.resizeColumnsToContents() tableView.setSelectionMode(QAbstractItemView.SingleSelection) tableView.setSelectionBehavior(QAbstractItemView.SelectRows) sm = tableView.selectionModel() sm.currentRowChanged.connect(self.selectedRowChanged) self.tableView = tableView dockWidget = QDockWidget('Sweeps') dockWidget.setWidget(tableView) self.sweepTableDock = dockWidget hkDock = HkDockWidget(sweepCollection.hk) hkDock.setWindowTitle('HK - %s' % str(fileName)) self.hkDock = hkDock ivGraphWidget = IvGraphWidget(sweepCollection) tableModel.plotToggled.connect(ivGraphWidget.showSweep) #tableModel.badToggled.connect(self.toggleBad) self.ivGraphWidget = ivGraphWidget
def __init__(self, dock_tabbar, main): QObject.__init__(self) self.dock_tabbar = dock_tabbar self.main = main self.moving = False self.from_index = None self.to_index = None
def __init__(self, name, parent): QObject.__init__(self, parent) self.name = name self._active = None self._holdoff = 10*1000 # acts as low limit on high limit self._last = Disconnected()
def eventFilter(self, obj: QObject, event: QEvent) -> bool: """Event filter to process an event for the given destination. In this case, this widget listens for Enter events on the application level (during this widget's init, this eventFilter is installed on the app instance). When the destination object is a QWidget, we can try to update this widget's help_text with the destination widget's what's this help text. If there is no what's this text, we set the help_text back to its placeholderText. """ if event.type() == QEvent.Enter: if isinstance(obj, QWidget): help_text = obj.whatsThis() # When the obj has help text, let's update the help text widget if help_text != "": self._help_display.setText(help_text) # Store a ref to the entered widget so we can maintain the help text if its children don't have any self._cached_entered_widget = weakref.ref(obj) if event.type() == QEvent.Leave: if isinstance(obj, QWidget): # When we leave a widget, if it didn't have help text, # we want to check if the previously cached (entered) widget is its ancestor. # This will maintain the ancestor's help text in the help text widget when the child has not help text. if obj.whatsThis() == "": # Revert to placeholder text when we have left a widget and the cached widget is not its ancestor # (i.e. the previously entered widget with help text is not related). if not self._is_child_of_previously_entered_widget_with_help_text( obj): self._help_display.setText( self._help_display.placeholderText()) return super(HelpWidget, self).eventFilter(obj, event)
def __init__(self, parent=None, params_state=None): QObject.__init__(self) self.parent_parameters_path = [ ] # this is to be added in the send_param_status to take into account when the current class instance parameter list is a child of some other class self.settings = Parameter.create(name='Settings', type='group', children=self.params) if params_state is not None: if isinstance(params_state, dict): self.settings.restoreState(params_state) elif isinstance(params_state, Parameter): self.settings.restoreState(params_state.saveState()) if '0D' in str(self.__class__): self.plugin_type = '0D' elif '1D' in str(self.__class__): self.plugin_type = '1D' else: self.plugin_type = '2D' self.settings.sigTreeStateChanged.connect(self.send_param_status) self.parent = parent self.status = edict(info="", controller=None, initialized=False) self.scan_parameters = None self.x_axis = None self.y_axis = None
def __init__(self, parent, repo_files, prefix, root_prefix, pip_packages): QObject.__init__(self) self._parent = parent self._repo_files = repo_files self._prefix = prefix self._root_prefix = root_prefix self._pip_packages_names = {} for p in pip_packages: n, v, b = conda_api_q.CondaProcess.split_canonical_name(p) local = '' if '(' in n: name = n.split('-(') n = name[0] local = name[-1].replace(')', '') self._pip_packages_names[n] = {} self._pip_packages_names[n]['version'] = v self._pip_packages_names[n]['local'] = local self._pip_packages_names[n]['build'] = b self.packages_names = None self.row_data = None self.packages_versions = None self._packages = None # Define helper function locally self._get_package_metadata = parent.get_package_metadata
def __init__(self, client_type='GRABBER'): QObject.__init__(self) self.serversocket = None self.connected_clients = [] self.listening = True self.processing = False self.client_type = client_type
def __init__(self, original_out): QObject.__init__(self) # If the file descriptor of the stream is < 0 then we are running in a no-external-console mode if not hasattr(original_out, 'fileno') or original_out.fileno() < 0: self._original_out = None else: self._original_out = original_out
def __init__(self, parent, startup, version=""): QObject.__init__(self) self._parent = parent self.error = None self.latest_release = None self.startup = startup self.version = version
def __init__(self, parent, server_settings={}, folder=getcwd_or_home(), language='python'): QObject.__init__(self) # LSPMethodProviderMixIn.__init__(self) self.manager = parent self.zmq_in_socket = None self.zmq_out_socket = None self.zmq_in_port = None self.zmq_out_port = None self.transport_client = None self.language = language self.initialized = False self.ready_to_close = False self.request_seq = 1 self.req_status = {} self.watched_files = {} self.req_reply = {} self.transport_args = [ sys.executable, '-u', osp.join(LOCATION, 'transport', 'main.py') ] self.external_server = server_settings.get('external', False) self.stdio = server_settings.get('stdio', False) # Setting stdio on implies that external_server is off if self.stdio and self.external_server: error = ('If server is set to use stdio communication, ' 'then it cannot be an external server') logger.error(error) raise AssertionError(error) self.folder = folder self.plugin_configurations = server_settings.get('configurations', {}) self.client_capabilites = CLIENT_CAPABILITES self.server_capabilites = SERVER_CAPABILITES self.context = zmq.Context() server_args_fmt = server_settings.get('args', '') server_args = server_args_fmt.format(**server_settings) transport_args = self.external_server_fmt % (server_settings) self.server_args = [] if language == 'python': self.server_args += [sys.executable, '-m'] self.server_args += [server_settings['cmd']] if len(server_args) > 0: self.server_args += server_args.split(' ') self.transport_args += transport_args.split(' ') self.transport_args += ['--folder', folder] self.transport_args += ['--transport-debug', str(get_debug_level())] if not self.stdio: self.transport_args += ['--external-server'] else: self.transport_args += ['--stdio-server'] self.external_server = True
def __init__(self, parent=None, params_state=None): QObject.__init__(self) # to make sure this is the parent class self.move_is_done = False self.parent = parent self.shamrock_controller = None self.stage = None self.status = edict(info="", controller=None, stage=None, initialized=False) self.current_position = 0. self.target_position = 0. self._ispolling = True self.parent_parameters_path = [ ] # this is to be added in the send_param_status to take into account when the # current class instance parameter list is a child of some other class self.settings = Parameter.create(name='Settings', type='group', children=self.params) if params_state is not None: if isinstance(params_state, dict): self.settings.restoreState(params_state) elif isinstance(params_state, Parameter): self.settings.restoreState(params_state.saveState()) self.settings.sigTreeStateChanged.connect(self.send_param_status) self.controller_units = self._controller_units self.settings.child('epsilon').setValue(self._epsilon) self.poll_timer = QTimer() self.poll_timer.setInterval(config('actuator', 'polling_interval_ms')) self._poll_timeout = config('actuator', 'polling_timeout_s') self.poll_timer.timeout.connect(self.check_target_reached)
def __init__(self, callee, blocking=True): QObject.__init__(self) self.callee = callee self.blocking = blocking functools.update_wrapper(self.__call__.__func__, callee) self._moved_to_app = False self._store_function_args(None, None)
def __init__(self, validation_target): """ @type validation_target: QWidget """ QObject.__init__(self) self._validation_target = validation_target self._validation_message = None self._validation_type = None self._error_popup = ErrorPopup() self._originalEnterEvent = validation_target.enterEvent self._originalLeaveEvent = validation_target.leaveEvent self._originalHideEvent = validation_target.hideEvent def enterEvent(event): self._originalEnterEvent(event) if not self.isValid(): self._error_popup.presentError(self._validation_target, self._validation_message) validation_target.enterEvent = enterEvent def leaveEvent(event): self._originalLeaveEvent(event) if self._error_popup is not None: self._error_popup.hide() validation_target.leaveEvent = leaveEvent def hideEvent(hide_event): self._error_popup.hide() self._originalHideEvent(hide_event) validation_target.hideEvent = hideEvent
def __init__(self, parent, server_settings={}, folder=getcwd_or_home(), language='python'): QObject.__init__(self) self.manager = parent self.zmq_in_socket = None self.zmq_out_socket = None self.zmq_in_port = None self.zmq_out_port = None self.transport = None self.server = None self.stdio_pid = None self.notifier = None self.language = language self.initialized = False self.ready_to_close = False self.request_seq = 1 self.req_status = {} self.watched_files = {} self.watched_folders = {} self.req_reply = {} self.server_unresponsive = False self.transport_unresponsive = False # Select a free port to start the server. # NOTE: Don't use the new value to set server_setttings['port']!! # That's not required because this doesn't really correspond to a # change in the config settings of the server. Else a server # restart would be generated when doing a # workspace/didChangeConfiguration request. if not server_settings['external']: self.server_port = select_port( default_port=server_settings['port']) else: self.server_port = server_settings['port'] self.server_host = server_settings['host'] self.external_server = server_settings.get('external', False) self.stdio = server_settings.get('stdio', False) # Setting stdio on implies that external_server is off if self.stdio and self.external_server: error = ('If server is set to use stdio communication, ' 'then it cannot be an external server') logger.error(error) raise AssertionError(error) self.folder = folder self.plugin_configurations = server_settings.get('configurations', {}) self.client_capabilites = CLIENT_CAPABILITES self.server_capabilites = SERVER_CAPABILITES self.context = zmq.Context() # To set server args self._server_args = server_settings.get('args', '') self._server_cmd = server_settings['cmd']
def __init__(self, input_condition): QObject.__init__(self) # External editor self._gotoline = None self._path = None self.input_data = None self.input_condition = input_condition
def disconnect(self): """ Disconnect the tool from everything """ QObject.disconnect(self) for cid in self._cids: self.canvas.mpl_disconnect(cid) self.fit_range.remove()
def __init__(self, stdin, stdout, locals=None): QObject.__init__(self) InteractiveInterpreter.__init__(self, locals) self.locals['exit'] = Exit() self.stdin = stdin self.stdout = stdout self._executing = False self.compile = partial(compile_multi, self.compile)
def disconnect(self): """ Disconnect the tool from everything """ QObject.disconnect(self) for cid in self._cids: self.canvas.mpl_disconnect(cid) self.fit_start_x.remove() self.fit_end_x.remove()
def eventFilter(self, qobject: QObject, event: QEvent) -> bool: if event.type() == QEvent.ToolTipChange and isinstance( qobject, QWidget): tooltip = qobject.toolTip() if tooltip and not qt_might_be_rich_text(tooltip): qobject.setToolTip(f'<qt>{html.escape(tooltip)}</qt>') return True return super().eventFilter(qobject, event)
def __init__(self, dock_tabbar, main): QObject.__init__(self) self.dock_tabbar = dock_tabbar self.main = main self.from_index = None # Center dockwidget tabs to differentiate them from plugin tabs. # See spyder-ide/spyder#9763 self.dock_tabbar.setStyleSheet("QTabBar {alignment: center;}")
def indexFromWidget(self, widget: QtCore.QObject) -> Tuple[int, int]: for _ in range(5): # only go 5 layers recursively if isinstance(widget.parent().parent(), QtWidgets.QTableWidget): index = self.indexAt(widget.pos()) return index.row(), index.column() widget = widget.parent() else: logging.error('Could not find appropriate widget to map') raise IndexError
def __init__(self, parent, debug=False): """QGarbageCollector.""" QObject.__init__(self, parent) self.debug = debug self.timer = QTimer(self) self.timer.timeout.connect(self.check) self.threshold = gc.get_threshold()
def __init__(self, editor): super(TextDecorationsManager, self).__init__(editor) QObject.__init__(self, None) self._decorations = [] # Timer to not constantly update decorations. self.update_timer = QTimer(self) self.update_timer.setSingleShot(True) self.update_timer.setInterval(UPDATE_TIMEOUT) self.update_timer.timeout.connect(self._update)
def __init__(self, callee): QObject.__init__(self) self.moveToThread(qApp.thread()) self.callee = callee # Help should then give the correct doc self.__call__.__func__.__doc__ = callee.__doc__ self._args = None self._kwargs = None self._result = None self._exc_info = None
def __init__(self, servo): QObject.__init__(self) self._servo = servo self._watched = {} self._running = False self._timer = QTimer() self._timer.timeout.connect(self.onTimerExpired)
def __init__(self, parent, startup, version="", releases=None): QObject.__init__(self) self._parent = parent self.error = None self.latest_release = None self.startup = startup self.releases = releases if not version: self.version = __version__ else: self.version = version
def __init__(self, parent, reactor, watcher, socketType): QObject.__init__(self, parent) self.reactor = reactor self.watcher = watcher fd = watcher.fileno() self.notifier = QSocketNotifier(fd, socketType, parent) self.notifier.setEnabled(True) if socketType == QSocketNotifier.Read: self.fn = self.read else: self.fn = self.write self.notifier.activated.connect(self.fn)
def __init__(self, parent): QObject.__init__(self, parent) self.endpoint = None self.requests = {} self.languages = [] self.mutex = QMutex() self.opened_files = {} self.thread_started = False self.thread = QThread() self.moveToThread(self.thread) self.thread.started.connect(self.started) self.sig_perform_request.connect(self.perform_request)
def __init__(self, parent): QObject.__init__(self) self.stopped = False self.daemon = True self.mutex = QMutex() self.file_tokens = {} self.diff_patch = diff_match_patch() self.thread = QThread() self.moveToThread(self.thread) self.thread.started.connect(self.started) self.sig_mailbox.connect(self.handle_msg)
def __init__(self, parent): QObject.__init__(self) self.stopped = False self.daemon = True self.mutex = QMutex() self.language_snippets = {} self.thread = QThread() self.moveToThread(self.thread) self.thread.started.connect(self.started) self.sig_mailbox.connect(self.handle_msg) self.sig_update_snippets.connect(self.update_snippets)
def __init__(self, original_out): QObject.__init__(self) # If the file descriptor of the stream is < 0 then we are running in a no-external-console mode try: self._original_out = original_out if not hasattr(original_out, 'fileno') or original_out.fileno() < 0: self._original_out = None except UnsupportedOperation: # In some cases fileno may be defined but throw this instead, # such as in the case of io.StringIO self._original_out = None
def __init__(self): QObject.__init__(self) Thread.__init__(self) self.cli = Popen(PATH, encoding='utf-16-le', stdin=PIPE, stdout=PIPE, stderr=PIPE) self.setDaemon(True) self.start() Hooker.__instance = self
def __init__(self, callee): QObject.__init__(self) qapp = QApplication.instance() if qapp is not None: self.moveToThread(qapp.thread()) self.qApp = qapp self.callee = callee # Help should then give the correct doc self.__call__.__func__.__doc__ = callee.__doc__ self._args = None self._kwargs = None self._result = None self._exc_info = None
def __init__(self, parent, repo_files, env, prefix): QObject.__init__(self) self._parent = parent self._repo_files = repo_files self._env = env self._prefix = prefix self.packages_names = None self.row_data = None self.packages_versions = None # define helper function locally self._get_package_metadata = parent.get_package_metadata
def __init__(self, cacheSize=DEFAULT_CACHE_SIZE, userAgent='(PyQt) TileMap 1.0', parent=None): QObject.__init__(self, parent=parent) self._manager = None self._cache = None self._cacheSize = cacheSize try: # Convert user agent to bytes userAgent = userAgent.encode() except: # no encode method exists. This hsould be the Python 2 case pass self._userAgent = userAgent self._tileInDownload = dict()
def __init__(self, parent): QObject.__init__(self, parent) self._parent = parent self._output = None self._partial = None self._stdout = None self._error = None self._parse = False self._function_called = "" self._name = None self._process = QProcess() self.set_root_prefix() # Signals self._process.finished.connect(self._call_conda_ready) self._process.readyReadStandardOutput.connect(self._call_conda_partial)
def __init__(self, parent): QObject.__init__(self) self.main = parent self.clients = {} self.requests = {} self.register_queue = {} # Register languages to create clients for for language in self.get_languages(): self.clients[language] = { 'status': self.STOPPED, 'config': self.get_language_config(language), 'instance': None } self.register_queue[language] = []
def __init__(self, widget, resultfilename=None): """ Construct test runner. Parameters ---------- widget : UnitTestWidget Unit test widget which constructs the test runner. resultfilename : str or None Name of file in which to store test results. If None, use default. """ QObject.__init__(self, widget) self.process = None if resultfilename is None: self.resultfilename = os.path.join(tempfile.gettempdir(), 'unittest.results') else: self.resultfilename = resultfilename
def __init__(self, parent, server_args_fmt='', server_settings={}, external_server=False, folder=getcwd(), language='python', plugin_configurations={}): QObject.__init__(self) # LSPMethodProviderMixIn.__init__(self) self.manager = parent self.zmq_in_socket = None self.zmq_out_socket = None self.zmq_in_port = None self.zmq_out_port = None self.transport_client = None self.language = language self.initialized = False self.ready_to_close = False self.request_seq = 1 self.req_status = {} self.plugin_registry = {} self.watched_files = {} self.req_reply = {} self.transport_args = [sys.executable, '-u', osp.join(LOCATION, 'transport', 'main.py')] self.external_server = external_server self.folder = folder self.plugin_configurations = plugin_configurations self.client_capabilites = CLIENT_CAPABILITES self.server_capabilites = SERVER_CAPABILITES self.context = zmq.Context() server_args = server_args_fmt % (server_settings) # transport_args = self.local_server_fmt % (server_settings) # if self.external_server: transport_args = self.external_server_fmt % (server_settings) self.server_args = [server_settings['cmd']] self.server_args += server_args.split(' ') self.transport_args += transport_args.split(' ') self.transport_args += ['--folder', folder] self.transport_args += ['--transport-debug', str(get_debug_level())]
def __init__(self, parent, on_finished=None, on_partial=None): QObject.__init__(self, parent) self._parent = parent self.output = None self.partial = None self.stdout = None self.error = None self._parse = False self._function_called = '' self._name = None self._process = QProcess() self._on_finished = on_finished self._process.finished.connect(self._call_conda_ready) self._process.readyReadStandardOutput.connect(self._call_conda_partial) if on_finished is not None: self._process.finished.connect(on_finished) if on_partial is not None: self._process.readyReadStandardOutput.connect(on_partial) self.set_root_prefix()
def __init__(self, input_condition): QObject.__init__(self) self.input_data = None self.input_condition = input_condition
def __init__(self, original_out): QObject.__init__(self) self.__original_out = original_out
def __init__(self, level=logging.NOTSET, parent=None): logging.Handler.__init__(self, level=level) QObject.__init__(self, parent=parent)
def __init__(self): QObject.__init__(self) self.dialogs = {} self.namespace = None
def __init__(self): QObject.__init__(self) self.dialogs = {}
def __init__(self): QObject.__init__(self) self.editor = EditorMock()
def __init__(self): QObject.__init__(self) self.lsp_editor_settings = {}
def __init__(self, canvas, num): QObject.__init__(self) FigureManagerBase.__init__(self, canvas, num) # Patch show/destroy to be thread aware self._destroy_orig = self.destroy self.destroy = QAppThreadCall(self._destroy_orig) self._show_orig = self.show self.show = QAppThreadCall(self._show_orig) self._window_activated_orig = self._window_activated self._window_activated = QAppThreadCall(self._window_activated_orig) self._widgetclosed_orig = self._widgetclosed self._widgetclosed = QAppThreadCall(self._widgetclosed_orig) self.set_window_title_orig = self.set_window_title self.set_window_title = QAppThreadCall(self.set_window_title_orig) self.fig_visibility_changed_orig = self.fig_visibility_changed self.fig_visibility_changed = QAppThreadCall(self.fig_visibility_changed_orig) self.window = FigureWindow(canvas) self.window.activated.connect(self._window_activated) self.window.closing.connect(canvas.close_event) self.window.closing.connect(self._widgetclosed) self.window.visibility_changed.connect(self.fig_visibility_changed) self.window.setWindowTitle("Figure %d" % num) canvas.figure.set_label("Figure %d" % num) # Give the keyboard focus to the figure instead of the # manager; StrongFocus accepts both tab and click to focus and # will enable the canvas to process event w/o clicking. # ClickFocus only takes the focus is the window has been # clicked # on. http://qt-project.org/doc/qt-4.8/qt.html#FocusPolicy-enum or # http://doc.qt.digia.com/qt/qt.html#FocusPolicy-enum canvas.setFocusPolicy(Qt.StrongFocus) canvas.setFocus() self.window._destroying = False # add text label to status bar self.statusbar_label = QLabel() self.window.statusBar().addWidget(self.statusbar_label) self.toolbar = self._get_toolbar(canvas, self.window) if self.toolbar is not None: self.window.addToolBar(self.toolbar) self.toolbar.message.connect(self.statusbar_label.setText) self.toolbar.sig_grid_toggle_triggered.connect(self.grid_toggle) self.toolbar.sig_toggle_fit_triggered.connect(self.fit_toggle) tbs_height = self.toolbar.sizeHint().height() else: tbs_height = 0 # resize the main window so it will display the canvas with the # requested size: cs = canvas.sizeHint() sbs = self.window.statusBar().sizeHint() self._status_and_tool_height = tbs_height + sbs.height() height = cs.height() + self._status_and_tool_height self.window.resize(cs.width(), height) self.fit_browser = FitPropertyBrowser(canvas) self.fit_browser.closing.connect(self.handle_fit_browser_close) self.window.setCentralWidget(canvas) self.window.addDockWidget(Qt.LeftDockWidgetArea, self.fit_browser) self.fit_browser.hide() if matplotlib.is_interactive(): self.window.show() canvas.draw_idle() def notify_axes_change(fig): # This will be called whenever the current axes is changed if self.toolbar is not None: self.toolbar.update() canvas.figure.add_axobserver(notify_axes_change) # Register canvas observers self._cids = [] self._cids.append(self.canvas.mpl_connect('button_press_event', self.on_button_press)) self.window.raise_()
def __init__(self, parent): QObject.__init__(self) self._parent = parent self.error = None self.latest_release = None
def __init__(self, editor, lsp_manager): QObject.__init__(self) self.editor = editor self.lsp_manager = lsp_manager
def __init__(self, parent, editor, lsp_manager): QObject.__init__(self, parent) self.editor = editor self.lsp_manager = lsp_manager self.editor.sig_perform_lsp_request.connect(self.perform_request) self.sig_initialize.connect(self.initialize_callback)
def __init__(self): QObject.__init__(self) self.queue = [] self.lock = threading.Lock()