def run_script(self, filename=None, silent=False, set_focus=False,
args=None):
"""Run a Python script"""
if filename is None:
self.shell.interpreter.restore_stds()
filename, _selfilter = getopenfilename(
self, _("Run Python script"), getcwd_or_home(),
_("Python scripts")+" (*.py ; *.pyw ; *.ipy)")
self.shell.interpreter.redirect_stds()
if filename:
os.chdir( osp.dirname(filename) )
filename = osp.basename(filename)
else:
return
debug_print(args)
filename = osp.abspath(filename)
rbs = remove_backslashes
command = "runfile('%s', args='%s')" % (rbs(filename), rbs(args))
if set_focus:
self.shell.setFocus()
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.shell.write(command+'\n')
self.shell.run_command(command)
def keyReleaseEvent(self, e):
"""Qt override."""
self.npressed -= 1
if self.npressed <= 0:
key = e.key()
if len(self.keys) == 1 and key == Qt.Key_Tab:
self.toggle_state()
return
if len(self.keys) == 1 and key == Qt.Key_Escape:
self.set_sequence('')
self.label_warning.setText(_("Please introduce a different "
"shortcut"))
if len(self.keys) == 1 and key in [Qt.Key_Return, Qt.Key_Enter]:
self.toggle_state()
return
if not self.edit_state:
self.nonedit_keyrelease(e)
else:
debug_print('keys: {}'.format(self.keys))
if self.keys and key != Qt.Key_Escape:
self.validate_sequence()
self.keys = set()
self.key_modifiers = set()
self.key_non_modifiers = list()
self.key_text = list()
self.npressed = 0
def get_info(self, info):
"""
Find the calltip and docs
Returns a dict like the following:
{'note': 'Function of numpy.core.numeric...',
'argspec': "(shape, dtype=None, order='C')'
'docstring': 'Return an array of given...'
'name': 'ones',
'calltip': 'ones(shape, dtype=None, order='C')'}
"""
call_def = self.get_jedi_object('goto_definitions', info)
for cd in call_def:
if cd.doc and not cd.doc.rstrip().endswith(')'):
call_def = cd
break
else:
call_def = call_def[0]
name = call_def.name
if name is None:
return
if call_def.module_path:
mod_name = get_parent_until(call_def.module_path)
else:
mod_name = None
if not mod_name:
mod_name = call_def.module_name
if call_def.doc.startswith(name + '('):
calltip = getsignaturefromtext(call_def.doc, name)
argspec = calltip[calltip.find('('):]
docstring = call_def.doc[call_def.doc.find(')') + 3:]
elif '(' in call_def.doc.splitlines()[0]:
calltip = call_def.doc.splitlines()[0]
name = call_def.doc.split('(')[0]
docstring = call_def.doc[call_def.doc.find(')') + 3:]
argspec = calltip[calltip.find('('):]
else:
calltip = name + '(...)'
argspec = '()'
docstring = call_def.doc
if call_def.type == 'module':
note = 'Module %s' % mod_name
argspec = ''
calltip = name
elif call_def.type == 'class':
note = 'Class in %s module' % mod_name
elif call_def.doc.startswith('%s(self' % name):
class_name = call_def.full_name.split('.')[-2]
note = 'Method of %s class in %s module' % (
class_name.capitalize(), mod_name)
else:
note = '%s in %s module' % (call_def.type.capitalize(),
mod_name)
argspec = argspec.replace(' = ', '=')
calltip = calltip.replace(' = ', '=')
debug_print(call_def.name)
doc_info = dict(name=name, argspec=argspec,
note=note, docstring=docstring, calltip=calltip)
return doc_info
def _handle_spyder_msg(self, msg):
"""
Handle internal spyder messages
"""
spyder_msg_type = msg['content'].get('spyder_msg_type')
if spyder_msg_type == 'data':
# Deserialize data
try:
if PY2:
value = cloudpickle.loads(msg['buffers'][0])
else:
value = cloudpickle.loads(bytes(msg['buffers'][0]))
except Exception as msg:
self._kernel_value = None
self._kernel_reply = repr(msg)
else:
self._kernel_value = value
self.sig_got_reply.emit()
return
elif spyder_msg_type == 'pdb_state':
pdb_state = msg['content']['pdb_state']
if pdb_state is not None and isinstance(pdb_state, dict):
self.refresh_from_pdb(pdb_state)
elif spyder_msg_type == 'pdb_continue':
# Run Pdb continue to get to the first breakpoint
# Fixes 2034
self.write_to_stdin('continue')
else:
debug_print("No such spyder message type: %s" % spyder_msg_type)
def get_jedi_object(self, func_name, info, use_filename=True):
"""Call a desired function on a Jedi Script and return the result"""
if not jedi:
return
if DEBUG_EDITOR:
t0 = time.time()
# override IPython qt_loaders ImportDenier behavior
metas = sys.meta_path
for meta in metas:
if (meta.__class__.__name__ == 'ImportDenier'
and hasattr(meta, 'forbid')):
sys.meta_path.remove(meta)
if use_filename:
filename = info['filename']
else:
filename = None
try:
script = jedi.Script(info['source_code'], info['line_num'],
info['column'], filename)
func = getattr(script, func_name)
val = func()
except Exception as e:
val = None
debug_print('Jedi error (%s)' % func_name)
debug_print(str(e))
if DEBUG_EDITOR:
log_last_error(LOG_FILENAME, str(e))
if DEBUG_EDITOR:
log_dt(LOG_FILENAME, func_name, t0)
if not val and filename:
return self.get_jedi_object(func_name, info, False)
else:
return val
def get_completions(self, info):
"""Return a list of (completion, type) tuples"""
completions = self.get_jedi_object('completions', info)
if DEBUG_EDITOR:
log_last_error(LOG_FILENAME, str("comp: " + str(completions)[:100]))
completions = [(c.name, c.type) for c in completions]
debug_print(str(completions)[:100])
return completions
def _send(self, obj):
"""Send an object to the server.
"""
try:
self.socket.send_pyobj(obj, zmq.NOBLOCK)
except Exception as e:
debug_print(e)
self.is_initialized = False
self._on_finished()
def add(self, extension):
"""
Add a extension to the editor.
:param extension: The extension instance to add.
"""
debug_print('adding extension {}'.format(extension.name))
self._extensions[extension.name] = extension
extension.on_install(self.editor)
return extension
def setVisible(self, visible):
"""
Shows/Hides the panel.
Automatically call PanelsManager.refresh_panels.
:param visible: Visible state
"""
debug_print('{} visibility changed'.format(self.name))
super(Panel, self).setVisible(visible)
if self.editor:
self.editor.panels.refresh()
def handle_response(self, response):
name = self.ids.get(response['request_id'], None)
if not name:
return
if response.get('error', None):
debug_print('Response error:', response['error'])
return
if name == self.desired[0] or not self.waiting:
if response.get('result', None):
self._finalize(response)
else:
self.pending = response
def remove(self, name_or_klass):
"""
Remove a extension from the editor.
:param name_or_klass: The name (or class) of the extension to remove.
:returns: The removed extension.
"""
debug_print('removing extension {}'.format(name_or_klass))
extension = self.get(name_or_klass)
extension.on_uninstall()
self._extensions.pop(extension.name)
return extension
def __init__(
self, parent=None, namespace=None, commands=[], message=None, exitfunc=None, profile=False, multithreaded=False
):
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main=parent)
else:
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option("light_background")
self.shell = InternalShell(
parent,
namespace,
commands,
message,
self.get_option("max_line_count"),
self.get_plugin_font(),
exitfunc,
profile,
multithreaded,
light_background=light_background,
)
self.shell.status.connect(lambda msg: self.show_message.emit(msg, 0))
self.shell.go_to_error.connect(self.go_to_error)
self.shell.focus_changed.connect(lambda: self.focus_changed.emit())
# Redirecting some signals:
self.shell.redirect_stdio.connect(lambda state: self.redirect_stdio.emit(state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts(self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option("wrap"))
# Accepting drops
self.setAcceptDrops(True)
def remove(self, name_or_klass):
"""
Removes the specified panel.
:param name_or_klass: Name or class of the panel to remove.
:return: The removed panel
"""
debug_print('removing panel {}'.format(name_or_klass))
panel = self.get(name_or_klass)
panel.on_uninstall()
panel.hide()
panel.setParent(None)
return self._panels[panel.position].pop(panel.name, None)
def __init__(self, parent=None, namespace=None, commands=[], message=None,
exitfunc=None, profile=False, multithreaded=False):
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option('light_background')
self.shell = InternalShell(parent, namespace, commands, message,
self.get_option('max_line_count'),
self.get_plugin_font(), exitfunc, profile,
multithreaded,
light_background=light_background)
self.shell.status.connect(lambda msg: self.show_message.emit(msg, 0))
self.shell.go_to_error.connect(self.go_to_error)
self.shell.focus_changed.connect(lambda: self.focus_changed.emit())
# Redirecting some signals:
self.shell.redirect_stdio.connect(lambda state:
self.redirect_stdio.emit(state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts(self.find_widget)
# Main layout
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignLeft)
btn_layout.addStretch()
btn_layout.addWidget(self.options_button, Qt.AlignRight)
layout = create_plugin_layout(btn_layout)
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option('wrap'))
# Accepting drops
self.setAcceptDrops(True)
# Traceback MessageBox
self.error_dlg = None
self.error_traceback = ""
self.dismiss_error = False
def _finalize(self, response):
self.waiting = False
self.pending = None
if self.info:
delta = time.time() - self._start_time
debug_print('%s request from %s finished: "%s" in %.1f sec'
% (self.info.name, response['name'],
str(response['result'])[:100], delta))
response['info'] = self.info
self.introspection_complete.emit(response)
self.info = None
if self.pending_request:
info = self.pending_request
self.pending_request = None
self.send_request(info)
def stop(self):
# self.shutdown()
# self.exit()
debug_print('LSP Client ==> Stopping...')
if self.notifier is not None:
self.notifier.activated.disconnect(self.on_msg_received)
self.notifier.setEnabled(False)
self.notifier = None
# if WINDOWS:
# self.transport_client.send_signal(signal.CTRL_BREAK_EVENT)
# else:
self.transport_client.kill()
self.context.destroy()
if not self.external_server:
self.lsp_server.kill()
def _finalize(self, response):
self.waiting = False
self.pending = None
if self.info:
delta = time.time() - self._start_time
debug_print('%s request from %s finished: "%s" in %.1f sec' %
(self.info.name, response['name'],
str(response['result'])[:100], delta))
response['info'] = self.info
self.introspection_complete.emit(response)
self.info = None
if self.pending_request:
info = self.pending_request
self.pending_request = None
self.send_request(info)
def _draw_breakpoint_icon(self, top, painter, icon_name):
"""Draw the given breakpoint pixmap.
Args:
top (int): top of the line to draw the breakpoint icon.
painter (QPainter)
icon_name (srt): key of icon to draw (see: self.icons)
"""
rect = QRect(0, top, self.sizeHint().width(),
self.sizeHint().height())
try:
icon = self.icons[icon_name]
except KeyError as e:
debug_print("Breakpoint icon doen't exist, {}".format(e))
else:
icon.paint(painter, rect)
def send(self, method, params, requires_response):
if ClientConstants.CANCEL in params:
return
msg = {
'id': self.request_seq,
'method': method,
'params': params
}
if requires_response:
self.req_status[self.request_seq] = method
debug_print('\n[{0}] LSP-Client ===>'.format(self.language))
debug_print(method)
# debug_print('')
self.zmq_out_socket.send_pyobj(msg)
self.request_seq += 1
return int(msg['id'])
def __init__(self, parent=None, namespace=None, commands=[], message=None,
exitfunc=None, profile=False, multithreaded=False):
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option('light_background')
self.shell = InternalShell(parent, namespace, commands, message,
self.get_option('max_line_count'),
self.get_plugin_font(), exitfunc, profile,
multithreaded,
light_background=light_background)
self.shell.status.connect(lambda msg: self.show_message.emit(msg, 0))
self.shell.go_to_error.connect(self.go_to_error)
self.shell.focus_changed.connect(lambda: self.focus_changed.emit())
# Redirecting some signals:
self.shell.redirect_stdio.connect(lambda state:
self.redirect_stdio.emit(state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts(self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option('wrap'))
# Accepting drops
self.setAcceptDrops(True)
# Traceback MessageBox
self.msgbox_traceback= None
self.error_traceback = ""
def _on_msg_received(self):
"""Handle a message trigger from the socket.
"""
self.notifier.setEnabled(False)
while 1:
try:
resp = self.socket.recv_pyobj(flags=zmq.NOBLOCK)
except zmq.ZMQError:
self.notifier.setEnabled(True)
return
if not self.is_initialized:
self.is_initialized = True
debug_print('Initialized %s' % self.name)
self.initialized.emit()
self.timer.start(HEARTBEAT)
continue
resp['name'] = self.name
self.received.emit(resp)
def _introspection_complete(self, response):
"""
Handle an introspection response completion.
Route the response to the correct handler.
"""
result = response.get('result', None)
if result is None:
return
info = response['info']
current = self._get_code_info(response['info']['name'])
if result and current.filename == info.filename:
func = getattr(self, '_handle_%s_result' % info.name)
try:
func(result, current, info)
except Exception as e:
debug_print(e)
def _on_msg_received(self):
"""Handle a message trigger from the socket.
"""
self.notifier.setEnabled(False)
while 1:
try:
resp = self.socket.recv_pyobj(flags=zmq.NOBLOCK)
except zmq.ZMQError:
self.notifier.setEnabled(True)
return
if not self.is_initialized:
self.is_initialized = True
debug_print('Initialized %s' % self.name)
self.initialized.emit()
self.timer.start(HEARTBEAT)
continue
resp['name'] = self.name
self.received.emit(resp)
def _introspection_complete(self, response):
"""
Handle an introspection response completion.
Route the response to the correct handler.
"""
result = response.get('result', None)
if result is None:
return
info = response['info']
current = self._get_code_info(response['info']['name'])
if result and current.filename == info.filename:
func = getattr(self, '_handle_%s_result' % info.name)
try:
func(result, current, info)
except Exception as e:
debug_print(e)
def load_data(self, profdatafile):
"""Load profiler data saved by profile/cProfile module"""
import pstats
stats_indi = [pstats.Stats(profdatafile),]
self.profdata = stats_indi[0]
if self.compare_file is not None:
try:
stats_indi.append(pstats.Stats(self.compare_file))
except IOError as e:
QMessageBox.critical(
self, _("Error"),
_("Error when trying to load profiler results"))
debug_print("Error when calling pstats, {}".format(e))
self.compare_file = None
map(lambda x: x.calc_callees(), stats_indi)
self.profdata.calc_callees()
self.stats1 = stats_indi
self.stats = stats_indi[0].stats
def send_request(self, info):
"""Handle an incoming request from the user."""
if self.waiting:
if info.serialize() != self.info.serialize():
self.pending_request = info
else:
debug_print('skipping duplicate request')
return
debug_print('%s request' % info.name)
desired = None
self.info = info
editor = info.editor
if (info.name == 'completion' and 'jedi' not in self.plugins and
info.line.lstrip().startswith(('import ', 'from '))):
desired = 'fallback'
if ((not editor.is_python_like()) or
sourcecode.is_keyword(info.obj) or
(editor.in_comment_or_string() and info.name != 'info')):
desired = 'fallback'
plugins = self.plugins.values()
if desired:
plugins = [self.plugins[desired]]
self.desired = [desired]
elif (info.name == 'definition' and not info.editor.is_python() or
info.name == 'info'):
self.desired = list(self.plugins.keys())
else:
# Use all but the fallback
plugins = list(self.plugins.values())[:-1]
self.desired = list(self.plugins.keys())[:-1]
self._start_time = time.time()
self.waiting = True
method = 'get_%s' % info.name
value = info.serialize()
self.ids = dict()
for plugin in plugins:
request_id = plugin.request(method, value)
self.ids[request_id] = plugin.name
self.timer.stop()
self.timer.singleShot(LEAD_TIME_SEC * 1000, self._handle_timeout)
def send_request(self, info):
"""Handle an incoming request from the user."""
if self.waiting:
if info.serialize() != self.info.serialize():
self.pending_request = info
else:
debug_print('skipping duplicate request')
return
debug_print('%s request' % info.name)
desired = None
self.info = info
editor = info.editor
if (info.name == 'completion' and 'jedi' not in self.plugins and
info.line.lstrip().startswith(('import ', 'from '))):
desired = 'fallback'
if ((not editor.is_python_like()) or
sourcecode.is_keyword(info.obj) or
(editor.in_comment_or_string() and info.name != 'info')):
desired = 'fallback'
plugins = self.plugins.values()
if desired:
plugins = [self.plugins[desired]]
self.desired = [desired]
elif (info.name == 'definition' and not info.editor.is_python() or
info.name == 'info'):
self.desired = list(self.plugins.keys())
else:
# Use all but the fallback
plugins = list(self.plugins.values())[:-1]
self.desired = list(self.plugins.keys())[:-1]
self._start_time = time.time()
self.waiting = True
method = 'get_%s' % info.name
value = info.serialize()
self.ids = dict()
for plugin in plugins:
request_id = plugin.request(method, value)
self.ids[request_id] = plugin.name
self.timer.stop()
self.timer.singleShot(LEAD_TIME_SEC * 1000, self._handle_timeout)
def get_jedi_object(self, func_name, info, use_filename=True):
"""Call a desired function on a Jedi Script and return the result"""
if not jedi:
return
if DEBUG_EDITOR:
t0 = time.time()
# override IPython qt_loaders ImportDenier behavior
metas = sys.meta_path
for meta in metas:
if (meta.__class__.__name__ == 'ImportDenier'
and hasattr(meta, 'forbid')):
sys.meta_path.remove(meta)
if use_filename:
filename = info['filename']
else:
filename = None
try:
if JEDI_010:
script = jedi.api.Script(info['source_code'],
info['line_num'],
info['column'],
filename,
sys_path=info['sys_path'])
else:
script = jedi.api.Script(info['source_code'], info['line_num'],
info['column'], filename)
func = getattr(script, func_name)
val = func()
except Exception as e:
val = None
debug_print('Jedi error (%s)' % func_name)
debug_print(str(e))
if DEBUG_EDITOR:
log_last_error(LOG_FILENAME, str(e))
if DEBUG_EDITOR:
log_dt(LOG_FILENAME, func_name, t0)
if not val and filename:
return self.get_jedi_object(func_name, info, False)
else:
return val
def keyPressEvent(self, e):
"""Qt override."""
key = e.key()
# Check if valid keys
if key not in VALID_KEYS:
self.invalid_key_flag = True
return
self.npressed += 1
self.key_non_modifiers.append(key)
self.key_modifiers.add(key)
self.key_text.append(e.text())
self.invalid_key_flag = False
debug_print('key {0}, npressed: {1}'.format(key, self.npressed))
if key == Qt.Key_unknown:
return
# The user clicked just and only the special keys
# Ctrl, Shift, Alt, Meta.
if (key == Qt.Key_Control or
key == Qt.Key_Shift or
key == Qt.Key_Alt or
key == Qt.Key_Meta):
return
modifiers = e.modifiers()
if modifiers & Qt.ShiftModifier:
key += Qt.SHIFT
if modifiers & Qt.ControlModifier:
key += Qt.CTRL
if sys.platform == 'darwin':
self.npressed -= 1
debug_print('decrementing')
if modifiers & Qt.AltModifier:
key += Qt.ALT
if modifiers & Qt.MetaModifier:
key += Qt.META
self.keys.add(key)
def keyPressEvent(self, e):
"""Qt override."""
key = e.key()
# Check if valid keys
if key not in VALID_KEYS:
self.invalid_key_flag = True
return
self.npressed += 1
self.key_non_modifiers.append(key)
self.key_modifiers.add(key)
self.key_text.append(e.text())
self.invalid_key_flag = False
debug_print('key {0}, npressed: {1}'.format(key, self.npressed))
if key == Qt.Key_unknown:
return
# The user clicked just and only the special keys
# Ctrl, Shift, Alt, Meta.
if (key == Qt.Key_Control or
key == Qt.Key_Shift or
key == Qt.Key_Alt or
key == Qt.Key_Meta):
return
modifiers = e.modifiers()
if modifiers & Qt.ShiftModifier:
key += Qt.SHIFT
if modifiers & Qt.ControlModifier:
key += Qt.CTRL
if sys.platform == 'darwin':
self.npressed -= 1
debug_print('decrementing')
if modifiers & Qt.AltModifier:
key += Qt.ALT
if modifiers & Qt.MetaModifier:
key += Qt.META
self.keys.add(key)
def on_msg_received(self):
self.notifier.setEnabled(False)
while True:
try:
# events = self.zmq_in_socket.poll(1500)
resp = self.zmq_in_socket.recv_pyobj(flags=zmq.NOBLOCK)
debug_print('\n[{0}] LSP-Client <==='.format(self.language))
debug_print(resp)
debug_print('')
if 'method' in resp:
if resp['method'][0] != '$':
if resp['method'] in self.handler_registry:
handler_name = (
self.handler_registry[resp['method']])
handler = getattr(self, handler_name)
handler(resp['params'])
if 'id' in resp:
self.request_seq = resp['id']
elif 'result' in resp:
if resp['result'] is not None:
req_id = resp['id']
if req_id in self.req_status:
req_type = self.req_status[req_id]
if req_type in self.handler_registry:
handler_name = self.handler_registry[req_type]
handler = getattr(self, handler_name)
handler(resp['result'], req_id)
self.req_status.pop(req_id)
if req_id in self.req_reply:
self.req_reply.pop(req_id)
except zmq.ZMQError as e:
self.notifier.setEnabled(True)
return
def load_data(self, profdatafile):
"""Load profiler data saved by profile/cProfile module"""
import pstats
try:
stats_indi = [pstats.Stats(profdatafile), ]
except (OSError, IOError):
return
self.profdata = stats_indi[0]
if self.compare_file is not None:
try:
stats_indi.append(pstats.Stats(self.compare_file))
except (OSError, IOError) as e:
QMessageBox.critical(
self, _("Error"),
_("Error when trying to load profiler results"))
debug_print("Error when calling pstats, {}".format(e))
self.compare_file = None
map(lambda x: x.calc_callees(), stats_indi)
self.profdata.calc_callees()
self.stats1 = stats_indi
self.stats = stats_indi[0].stats
def document_did_close(self, params):
file_signal = params['signal']
debug_print('[{0}] File: {1}'.format(
LSPRequestTypes.DOCUMENT_DID_CLOSE, params['file']))
filename = path_as_uri(params['file'])
params = {'textDocument': {'uri': filename}}
if filename not in self.watched_files:
params[ClientConstants.CANCEL] = True
else:
signals = self.watched_files[filename]
idx = -1
for i, signal in enumerate(signals):
if id(file_signal) == id(signal):
idx = i
break
if idx > 0:
signals.pop(idx)
if len(signals) == 0:
self.watched_files.pop(filename)
return params
def register(self, panel, position=Panel.Position.LEFT):
"""
Installs a panel on the editor.
:param panel: Panel to install
:param position: Position where the panel must be installed.
:return: The installed panel
"""
assert panel is not None
pos_to_string = {
Panel.Position.BOTTOM: 'bottom',
Panel.Position.LEFT: 'left',
Panel.Position.RIGHT: 'right',
Panel.Position.TOP: 'top'
}
debug_print('adding panel {} at {}'.format(panel.name,
pos_to_string[position]))
panel.order_in_zone = len(self._panels[position])
self._panels[position][panel.name] = panel
panel.position = position
panel.on_install(self.editor)
debug_print('panel {} installed'.format(panel.name))
return panel
def register(self, panel, position=Panel.Position.LEFT):
"""
Installs a panel on the editor.
:param panel: Panel to install
:param position: Position where the panel must be installed.
:return: The installed panel
"""
assert panel is not None
pos_to_string = {
Panel.Position.BOTTOM: 'bottom',
Panel.Position.LEFT: 'left',
Panel.Position.RIGHT: 'right',
Panel.Position.TOP: 'top',
Panel.Position.FLOATING: 'floating'
}
debug_print('adding panel {} at {}'.format(panel.name,
pos_to_string[position]))
panel.order_in_zone = len(self._panels[position])
self._panels[position][panel.name] = panel
panel.position = position
panel.on_install(self.editor)
debug_print('panel {} installed'.format(panel.name))
return panel
def run_script(self, filename=None, silent=False, set_focus=False,
args=None):
"""Run a Python script"""
if filename is None:
self.shell.interpreter.restore_stds()
filename, _selfilter = getopenfilename(self, _("Run Python script"),
getcwd(), _("Python scripts")+" (*.py ; *.pyw ; *.ipy)")
self.shell.interpreter.redirect_stds()
if filename:
os.chdir( osp.dirname(filename) )
filename = osp.basename(filename)
else:
return
debug_print(args)
filename = osp.abspath(filename)
rbs = remove_backslashes
command = "runfile('%s', args='%s')" % (rbs(filename), rbs(args))
if set_focus:
self.shell.setFocus()
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.shell.write(command+'\n')
self.shell.run_command(command)
def __init__(self, executable):
super(PluginManager, self).__init__()
plugins = OrderedDict()
for name in PLUGINS:
try:
plugin = PluginClient(name, executable)
plugin.run()
except Exception as e:
debug_print('Introspection Plugin Failed: %s' % name)
debug_print(str(e))
continue
debug_print('Introspection Plugin Loaded: %s' % name)
plugins[name] = plugin
plugin.received.connect(self.handle_response)
self.plugins = plugins
self.timer = QTimer()
self.desired = []
self.ids = dict()
self.info = None
self.request = None
self.pending = None
self.pending_request = None
self.waiting = False
def __init__(self, executable):
super(PluginManager, self).__init__()
plugins = OrderedDict()
for name in PLUGINS:
try:
plugin = PluginClient(name, executable)
plugin.run()
except Exception as e:
debug_print('Introspection Plugin Failed: %s' % name)
debug_print(str(e))
continue
debug_print('Introspection Plugin Loaded: %s' % name)
plugins[name] = plugin
plugin.received.connect(self.handle_response)
self.plugins = plugins
self.timer = QTimer()
self.desired = []
self.ids = dict()
self.info = None
self.request = None
self.pending = None
self.pending_request = None
self.waiting = False
def get_info(self, info):
"""
Find the calltip and docs
Returns a dict like the following:
{'note': 'Function of numpy.core.numeric...',
'argspec': "(shape, dtype=None, order='C')'
'docstring': 'Return an array of given...'
'name': 'ones',
'calltip': 'ones(shape, dtype=None, order='C')'}
"""
call_def = self.get_jedi_object('goto_definitions', info)
for cd in call_def:
# For compatibility with Jedi 0.11
try:
cd.doc = cd.docstring()
except AttributeError:
pass
if cd.doc and not cd.doc.rstrip().endswith(')'):
call_def = cd
break
else:
call_def = call_def[0]
name = call_def.name
if name is None:
return
if call_def.module_path:
mod_name = get_parent_until(call_def.module_path)
else:
mod_name = None
if not mod_name:
mod_name = call_def.module_name
if call_def.doc.startswith(name + '('):
calltip = getsignaturefromtext(call_def.doc, name)
argspec = calltip[calltip.find('('):]
docstring = call_def.doc[call_def.doc.find(')') + 3:]
elif '(' in call_def.doc.splitlines()[0]:
calltip = call_def.doc.splitlines()[0]
name = call_def.doc.split('(')[0]
docstring = call_def.doc[call_def.doc.find(')') + 3:]
argspec = calltip[calltip.find('('):]
else:
calltip = name + '(...)'
argspec = '()'
docstring = call_def.doc
if call_def.type == 'module':
note = 'Module %s' % mod_name
argspec = ''
calltip = name
elif call_def.type == 'class':
note = 'Class in %s module' % mod_name
elif call_def.doc.startswith('%s(self' % name):
class_name = call_def.full_name.split('.')[-2]
note = 'Method of %s class in %s module' % (
class_name.capitalize(), mod_name)
else:
note = '%s in %s module' % (call_def.type.capitalize(), mod_name)
argspec = argspec.replace(' = ', '=')
calltip = calltip.replace(' = ', '=')
debug_print(call_def.name)
doc_info = dict(name=name,
argspec=argspec,
note=note,
docstring=docstring,
calltip=calltip)
return doc_info
def _handle_timeout(self):
self.waiting = False
if self.pending:
self._finalize(self.pending)
else:
debug_print('No valid responses acquired')
def get_completions(self, info):
"""Return a list of (completion, type) tuples"""
completions = self.get_jedi_object('completions', info)
completions = [(c.name, c.type) for c in completions]
debug_print(str(completions)[:100])
return completions
def get_completions(self, info):
"""Return a list of (completion, type) tuples"""
completions = self.get_jedi_object('completions', info)
completions = [(c.name, c.type) for c in completions]
debug_print(str(completions)[:100])
return completions
def _handle_timeout(self):
self.waiting = False
if self.pending:
self._finalize(self.pending)
else:
debug_print('No valid responses acquired')
def close(self):
for name, plugin in self.plugins.items():
plugin.close()
debug_print("Introspection Plugin Closed: {}".format(name))
def refresh(self):
"""Refreshes the editor panels (resize and update margins)."""
debug_print('refresh_panels')
self.resize()
self._update(self.editor.contentsRect(), 0,
force_update_margins=True)
def close(self):
for name, plugin in self.plugins.items():
plugin.close()
debug_print("Introspection Plugin Closed: {}".format(name))
def _on_finished(self):
"""Handle a finished signal from the process.
"""
if self.closing:
return
if self.is_initialized:
debug_print('Restarting %s' % self.name)
debug_print(self.process.readAllStandardOutput())
debug_print(self.process.readAllStandardError())
self.is_initialized = False
self.notifier.setEnabled(False)
self.run()
else:
debug_print('Errored %s' % self.name)
debug_print(self.process.readAllStandardOutput())
debug_print(self.process.readAllStandardError())
self.errored.emit()
def __del__(self):
debug_print('{}.__del__'.format(type(self)))
def refresh(self):
"""Refreshes the editor panels (resize and update margins)."""
debug_print('refresh_panels')
self.resize()
self._update(self.editor.contentsRect(), 0, force_update_margins=True)
def _on_finished(self):
"""Handle a finished signal from the process.
"""
if self.closing:
return
if self.is_initialized:
debug_print('Restarting %s' % self.name)
debug_print(self.process.readAllStandardOutput())
debug_print(self.process.readAllStandardError())
self.is_initialized = False
self.notifier.setEnabled(False)
self.run()
else:
debug_print('Errored %s' % self.name)
debug_print(self.process.readAllStandardOutput())
debug_print(self.process.readAllStandardError())
self.errored.emit()
def _handle_modelx_msg(self, msg):
"""
Handle internal spyder messages
"""
msg_id = msg['parent_header']['msg_id']
info = self._request_info['execute'].get(msg_id)
msgtype = msg['content'].get('mx_msgtype')
if msgtype in self.mx_msgtypes:
# Deserialize data
try:
if PY2:
value = cloudpickle.loads(msg['buffers'][0])
else:
value = cloudpickle.loads(bytes(msg['buffers'][0]))
except Exception as msg:
value = None
self._kernel_reply = repr(msg)
if msgtype == 'mxupdated':
self.sig_mxupdated.emit()
elif msgtype == 'dataview':
self.sig_mxdataview_eval.emit(value)
elif msgtype == 'dataview_getval':
if spyder.version_info > (4, ):
raise AssertionError("must not happen")
self._mx_value = value
self.sig_mxdataview_getval.emit()
elif msgtype == 'codelist':
self.sig_mxcodelist.emit(value)
elif msgtype == 'explorer':
self.sig_mxexplorer.emit(value)
elif msgtype == 'modellist':
if spyder.version_info > (4, ):
raise AssertionError("must not happen")
self._mx_value = value
self.sig_mxmodellist.emit()
elif msgtype == 'analyze_precedents_setnode':
self.sig_mxanalyzer.emit('precedents', value)
elif msgtype == 'analyze_succs_setnode':
self.sig_mxanalyzer.emit('succs', value)
elif msgtype == 'analyze_precedents':
if spyder.version_info > (4, ):
raise AssertionError("must not happen")
self._mx_value = value
self.sig_mxanalyzer_precedents.emit()
elif msgtype == 'analyze_succs':
if spyder.version_info > (4, ):
raise AssertionError("must not happen")
self._mx_value = value
self.sig_mxanalyzer_succs.emit()
elif msgtype == 'analyze_getval':
if spyder.version_info > (4, ):
raise AssertionError("must not happen")
self._mx_value = value
self.sig_mxanalyzer_getval.emit()
elif msgtype == 'property':
self.sig_mxproperty.emit(value)
elif msgtype == 'get_attrdict':
self._mx_value = value
self.sig_mxgetattrdict.emit()
elif msgtype == 'get_value_info':
self.sig_mxgetvalueinfo.emit(value)
# Copied _handle_execute_reply
if info and info.kind == 'silent_exec_method' and not self._hidden:
self._request_info['execute'].pop(msg_id)
return
else:
debug_print("No such modelx message type: %s" % msgtype)
