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, 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, 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, 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, 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, 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, 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):
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()
