class KernelConnectionDialog(QDialog):
"""Dialog to connect to existing kernels (either local or remote)."""
def __init__(self, parent=None):
super(KernelConnectionDialog, self).__init__(parent)
self.setWindowTitle(_('Connect to an existing kernel'))
main_label = QLabel(_(
"<p>Please select the JSON connection file (<i>e.g.</i> "
"<tt>kernel-1234.json</tt>) of the existing kernel, and enter "
"the SSH information if connecting to a remote machine. "
"To learn more about starting external kernels and connecting "
"to them, see <a href=\"https://docs.spyder-ide.org/"
"ipythonconsole.html#connect-to-an-external-kernel\">"
"our documentation</a>.</p>"))
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setOpenExternalLinks(True)
# Connection file
cf_label = QLabel(_('Connection file:'))
self.cf = QLineEdit()
self.cf.setPlaceholderText(_('Kernel connection file path'))
self.cf.setMinimumWidth(350)
cf_open_btn = QPushButton(_('Browse'))
cf_open_btn.clicked.connect(self.select_connection_file)
cf_layout = QHBoxLayout()
cf_layout.addWidget(cf_label)
cf_layout.addWidget(self.cf)
cf_layout.addWidget(cf_open_btn)
# Remote kernel groupbox
self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)"))
# SSH connection
hn_label = QLabel(_('Hostname:'))
self.hn = QLineEdit()
pn_label = QLabel(_('Port:'))
self.pn = QLineEdit()
self.pn.setMaximumWidth(75)
self.pn.setText('22')
un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:'))
self.pw = QLineEdit()
self.pw.setEchoMode(QLineEdit.Password)
self.pw_radio.toggled.connect(self.pw.setEnabled)
self.kf_radio.toggled.connect(self.pw.setDisabled)
self.kf = QLineEdit()
kf_open_btn = QPushButton(_('Browse'))
kf_open_btn.clicked.connect(self.select_ssh_key)
kf_layout = QHBoxLayout()
kf_layout.addWidget(self.kf)
kf_layout.addWidget(kf_open_btn)
kfp_label = QLabel(_('Passphase:'))
self.kfp = QLineEdit()
self.kfp.setPlaceholderText(_('Optional'))
self.kfp.setEchoMode(QLineEdit.Password)
self.kf_radio.toggled.connect(self.kf.setEnabled)
self.kf_radio.toggled.connect(self.kfp.setEnabled)
self.kf_radio.toggled.connect(kf_open_btn.setEnabled)
self.kf_radio.toggled.connect(kfp_label.setEnabled)
self.pw_radio.toggled.connect(self.kf.setDisabled)
self.pw_radio.toggled.connect(self.kfp.setDisabled)
self.pw_radio.toggled.connect(kf_open_btn.setDisabled)
self.pw_radio.toggled.connect(kfp_label.setDisabled)
# SSH layout
ssh_layout = QGridLayout()
ssh_layout.addWidget(hn_label, 0, 0, 1, 2)
ssh_layout.addWidget(self.hn, 0, 2)
ssh_layout.addWidget(pn_label, 0, 3)
ssh_layout.addWidget(self.pn, 0, 4)
ssh_layout.addWidget(un_label, 1, 0, 1, 2)
ssh_layout.addWidget(self.un, 1, 2, 1, 3)
# SSH authentication layout
auth_layout = QGridLayout()
auth_layout.addWidget(self.pw_radio, 1, 0)
auth_layout.addWidget(pw_label, 1, 1)
auth_layout.addWidget(self.pw, 1, 2)
auth_layout.addWidget(self.kf_radio, 2, 0)
auth_layout.addWidget(kf_label, 2, 1)
auth_layout.addLayout(kf_layout, 2, 2)
auth_layout.addWidget(kfp_label, 3, 1)
auth_layout.addWidget(self.kfp, 3, 2)
auth_group.setLayout(auth_layout)
# Remote kernel layout
rm_layout = QVBoxLayout()
rm_layout.addLayout(ssh_layout)
rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
rm_layout.addWidget(auth_group)
self.rm_group.setLayout(rm_layout)
self.rm_group.setCheckable(True)
self.rm_group.setChecked(False)
self.rm_group.toggled.connect(self.pw_radio.setChecked)
# Ok and Cancel buttons
self.accept_btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Dialog layout
layout = QVBoxLayout(self)
layout.addWidget(main_label)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
layout.addLayout(cf_layout)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12)))
layout.addWidget(self.rm_group)
layout.addWidget(self.accept_btns)
def select_connection_file(self):
cf = getopenfilename(self, _('Select kernel connection file'),
jupyter_runtime_dir(), '*.json;;*.*')[0]
self.cf.setText(cf)
def select_ssh_key(self):
kf = getopenfilename(self, _('Select SSH keyfile'),
get_home_dir(), '*.pem;;*')[0]
self.kf.setText(kf)
@staticmethod
def get_connection_parameters(parent=None, dialog=None):
if not dialog:
dialog = KernelConnectionDialog(parent)
result = dialog.exec_()
is_remote = bool(dialog.rm_group.isChecked())
accepted = result == QDialog.Accepted
if is_remote:
def falsy_to_none(arg):
return arg if arg else None
if dialog.hn.text() and dialog.un.text():
port = dialog.pn.text() if dialog.pn.text() else '22'
hostname = "{0}@{1}:{2}".format(dialog.un.text(),
dialog.hn.text(),
port)
else:
hostname = None
if dialog.pw_radio.isChecked():
password = falsy_to_none(dialog.pw.text())
keyfile = None
elif dialog.kf_radio.isChecked():
keyfile = falsy_to_none(dialog.kf.text())
password = falsy_to_none(dialog.kfp.text())
else: # imposible?
keyfile = None
password = None
return (dialog.cf.text(), hostname, keyfile, password, accepted)
else:
path = dialog.cf.text()
_dir, filename = osp.dirname(path), osp.basename(path)
if _dir == '' and not filename.endswith('.json'):
path = osp.join(jupyter_runtime_dir(), 'kernel-'+path+'.json')
return (path, None, None, None, accepted)
class DlgGitHubLogin(QDialog):
"""Dialog to submit error reports to Github."""
def __init__(self, parent, username, password, token, remember=False,
remember_token=False):
QDialog.__init__(self, parent)
title = _("Sign in to Github")
self.resize(415, 375)
self.setWindowTitle(title)
self.setWindowFlags(
self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
# Header
html = ('<html><head/><body><p align="center">'
'{title}</p></body></html>')
lbl_html = QLabel(html.format(title=title))
lbl_html.setStyleSheet('font-size: 16px;')
# Tabs
self.tabs = QTabWidget()
# Basic form layout
basic_form_layout = QFormLayout()
basic_form_layout.setContentsMargins(-1, 0, -1, -1)
basic_lbl_msg = QLabel(_("For regular users, i.e. users <b>without</b>"
" two-factor authentication enabled"))
basic_lbl_msg.setWordWrap(True)
basic_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_user = QLabel(_("Username:"******"", QWidget())
lbl_password = QLabel(_("Password: "******"Remember me"))
self.cb_remember.setToolTip(_("Spyder will save your credentials "
"safely"))
self.cb_remember.setChecked(remember)
basic_form_layout.setWidget(4, QFormLayout.FieldRole,
self.cb_remember)
# Basic auth tab
basic_auth = QWidget()
basic_layout = QVBoxLayout()
basic_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
basic_layout.addWidget(basic_lbl_msg)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
basic_layout.addLayout(basic_form_layout)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
basic_auth.setLayout(basic_layout)
self.tabs.addTab(basic_auth, _("Password Only"))
# Token form layout
token_form_layout = QFormLayout()
token_form_layout.setContentsMargins(-1, 0, -1, -1)
token_lbl_msg = QLabel(_("For users <b>with</b> two-factor "
"authentication enabled, or who prefer a "
"per-app token authentication.<br><br>"
"You can go <b><a href=\"{}\">here</a></b> "
"and click \"Generate token\" at the bottom "
"to create a new token to use for this, with "
"the appropriate permissions.").format(
TOKEN_URL))
token_lbl_msg.setOpenExternalLinks(True)
token_lbl_msg.setWordWrap(True)
token_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_token = QLabel("Token: ")
token_form_layout.setWidget(1, QFormLayout.LabelRole, lbl_token)
self.le_token = QLineEdit()
self.le_token.setEchoMode(QLineEdit.Password)
self.le_token.textChanged.connect(self.update_btn_state)
token_form_layout.setWidget(1, QFormLayout.FieldRole, self.le_token)
self.cb_remember_token = None
# Same validation as with cb_remember
if self.is_keyring_available() and valid_py_os:
self.cb_remember_token = QCheckBox(_("Remember token"))
self.cb_remember_token.setToolTip(_("Spyder will save your "
"token safely"))
self.cb_remember_token.setChecked(remember_token)
token_form_layout.setWidget(3, QFormLayout.FieldRole,
self.cb_remember_token)
# Token auth tab
token_auth = QWidget()
token_layout = QVBoxLayout()
token_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
token_layout.addWidget(token_lbl_msg)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
token_layout.addLayout(token_form_layout)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 50, vPolicy=QSizePolicy.Expanding)))
token_auth.setLayout(token_layout)
self.tabs.addTab(token_auth, _("Access Token"))
# Sign in button
self.bt_sign_in = QPushButton(_("Sign in"))
self.bt_sign_in.clicked.connect(self.accept)
self.bt_sign_in.setDisabled(True)
# Main layout
layout = QVBoxLayout()
layout.addWidget(lbl_html)
layout.addWidget(self.tabs)
layout.addWidget(self.bt_sign_in)
self.setLayout(layout)
# Final adjustments
if username and password:
self.le_user.setText(username)
self.le_password.setText(password)
self.bt_sign_in.setFocus()
elif username:
self.le_user.setText(username)
self.le_password.setFocus()
elif token:
self.le_token.setText(token)
else:
self.le_user.setFocus()
self.setFixedSize(self.width(), self.height())
self.le_password.installEventFilter(self)
self.le_user.installEventFilter(self)
self.tabs.currentChanged.connect(self.update_btn_state)
def eventFilter(self, obj, event):
interesting_objects = [self.le_password, self.le_user]
if obj in interesting_objects and event.type() == QEvent.KeyPress:
if (event.key() == Qt.Key_Return and
event.modifiers() & Qt.ControlModifier and
self.bt_sign_in.isEnabled()):
self.accept()
return True
return False
def update_btn_state(self):
user = to_text_string(self.le_user.text()).strip() != ''
password = to_text_string(self.le_password.text()).strip() != ''
token = to_text_string(self.le_token.text()).strip() != ''
enable = ((user and password and
self.tabs.currentIndex() == 0) or
(token and self.tabs.currentIndex() == 1))
self.bt_sign_in.setEnabled(enable)
def is_keyring_available(self):
"""Check if keyring is available for password storage."""
try:
import keyring # analysis:ignore
return True
except Exception:
return False
@classmethod
def login(cls, parent, username, password, token,
remember, remember_token):
dlg = DlgGitHubLogin(parent, username, password, token, remember,
remember_token)
if dlg.exec_() == dlg.Accepted:
user = dlg.le_user.text()
password = dlg.le_password.text()
token = dlg.le_token.text()
if dlg.cb_remember:
remember = dlg.cb_remember.isChecked()
else:
remember = False
if dlg.cb_remember_token:
remember_token = dlg.cb_remember_token.isChecked()
else:
remember_token = False
credentials = dict(username=user,
password=password,
token=token,
remember=remember,
remember_token=remember_token)
return credentials
return dict(username=None,
password=None,
token=None,
remember=False,
remember_token=False)
class AuthenticationDialog(DialogBase):
"""Login dialog."""
# See https://github.com/Anaconda-Platform/anaconda-server settings
USER_RE = QRegExp('^[A-Za-z0-9_][A-Za-z0-9_-]+$')
FORGOT_USERNAME_URL = 'account/forgot_username'
FORGOT_PASSWORD_URL = 'account/forgot_password'
sig_authentication_succeeded = Signal()
sig_authentication_failed = Signal()
sig_url_clicked = Signal(object)
def __init__(self, api, parent=None):
"""Login dialog."""
super(AuthenticationDialog, self).__init__(parent)
self._parent = parent
self.config = CONF
self.api = api
self.token = None
self.error = None
self.tracker = GATracker()
self.forgot_username_url = None
self.forgot_password_url = None
# Widgets
self.label_username = QLabel('Username:'******'Password:'******'<hr><br><b>Already a member? '
'Sign in!</b><br>')
# For styling purposes the label next to a ButtonLink is also a button
# so they align adequately
self.button_register_text = ButtonLabel('You can register by '
'visiting the ')
self.button_register = ButtonLink('Anaconda Cloud')
self.button_register_after_text = ButtonLabel('website.')
self.label_information = QLabel('''
<strong>Anaconda Cloud</strong> is where packages, notebooks,
and <br> environments are shared. It provides powerful <br>
collaboration and package management for open <br>
source and private projects.<br>
''')
self.label_message = QLabel('')
self.button_forgot_username = ButtonLink('I forgot my username')
self.button_forgot_password = ButtonLink('I forgot my password')
self.button_login = ButtonPrimary('Login')
self.button_cancel = ButtonNormal('Cancel')
# Widgets setup
self.button_login.setDefault(True)
username_validator = QRegExpValidator(self.USER_RE)
self.text_username.setValidator(username_validator)
self.setMinimumWidth(260)
self.setWindowTitle('Sign in')
# This allows to completely style the dialog with css using the frame
self.text_password.setEchoMode(QLineEdit.Password)
self.label_message.setVisible(False)
# Layout
grid_layout = QVBoxLayout()
grid_layout.addWidget(self.label_username)
# grid_layout.addWidget(SpacerVertical())
grid_layout.addWidget(self.text_username)
grid_layout.addWidget(SpacerVertical())
grid_layout.addWidget(self.label_password)
# grid_layout.addWidget(SpacerVertical())
grid_layout.addWidget(self.text_password)
main_layout = QVBoxLayout()
main_layout.addWidget(self.label_information)
register_layout = QHBoxLayout()
register_layout.addWidget(self.button_register_text)
register_layout.addWidget(self.button_register)
register_layout.addWidget(self.button_register_after_text)
register_layout.addStretch()
main_layout.addLayout(register_layout)
main_layout.addWidget(self.label_signin_text)
main_layout.addLayout(grid_layout)
main_layout.addWidget(SpacerVertical())
main_layout.addWidget(self.label_message)
main_layout.addWidget(self.button_forgot_username, 0, Qt.AlignRight)
main_layout.addWidget(self.button_forgot_password, 0, Qt.AlignRight)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_login)
main_layout.addWidget(SpacerVertical())
main_layout.addWidget(SpacerVertical())
main_layout.addLayout(layout_buttons)
self.setLayout(main_layout)
# Signals
self.text_username.textEdited.connect(self.check_text)
self.text_password.textEdited.connect(self.check_text)
self.button_login.clicked.connect(self.login)
self.button_cancel.clicked.connect(self.reject)
# Setup
self.check_text()
self.update_style_sheet()
self.text_username.setFocus()
self.setup()
def setup(self):
"""Setup login dialog."""
self.update_links()
def update_links(self):
"""Update links."""
for button in [
self.button_forgot_username,
self.button_forgot_password,
self.button_register,
]:
try:
button.disconnect()
except TypeError: # pragma: no cover
pass
# TODO, get this from anaconda client directly?
# from binstar_client.utils import get_config, set_config
# config = get_config()
anaconda_api_url = self.config.get('main', 'anaconda_api_url', None)
if anaconda_api_url:
# Remove api if using a subdomain
base_url = anaconda_api_url.lower().replace('//api.', '//')
self.base_url = base_url
# Remove api if not using a subdomain
parts = base_url.lower().split('/')
if parts[-1] == 'api':
base_url = '/'.join(parts[:-1])
self.forgot_username_url = (base_url + '/' +
self.FORGOT_USERNAME_URL)
self.forgot_password_url = (base_url + '/' +
self.FORGOT_PASSWORD_URL)
self.button_register.clicked.connect(
lambda: self.open_url(base_url))
self.button_forgot_username.clicked.connect(
lambda: self.open_url(self.forgot_username_url))
self.button_forgot_password.clicked.connect(
lambda: self.open_url(self.forgot_password_url))
@property
def username(self):
"""Return the logged username."""
return self.text_username.text().lower()
def update_style_sheet(self, style_sheet=None):
"""Update custom css style sheet."""
if style_sheet is None:
style_sheet = load_style_sheet()
self.setStyleSheet(style_sheet)
def check_text(self):
"""Check that `username` and `password` are valid.
If not empty and disable/enable buttons accordingly.
"""
username = self.text_username.text()
password = self.text_password.text()
if len(username) == 0 or len(password) == 0:
self.button_login.setDisabled(True)
else:
self.button_login.setDisabled(False)
def login(self):
"""Try to log the user in the specified anaconda api endpoint."""
self.button_login.setEnabled(False)
self.text_username.setText(self.text_username.text().lower())
QApplication.setOverrideCursor(Qt.WaitCursor)
self.label_message.setText('')
worker = self.api.login(self.text_username.text().lower(),
self.text_password.text())
worker.sig_finished.connect(self._finished)
def _finished(self, worker, output, error):
"""Callback for the login procedure after worker has finished."""
token = output
if token:
self.token = token
self.sig_authentication_succeeded.emit()
self.accept()
elif error:
username = self.text_username.text().lower()
bold_username = '******'.format(username)
# The error might come in (error_message, http_error) format
try:
error_message = ast.literal_eval(str(error))[0]
except Exception: # pragma: no cover
error_message = str(error)
error_message = error_message.lower().capitalize()
error_message = error_message.split(', ')[0]
error_text = '<i>{0}</i>'.format(error_message)
error_text = error_text.replace(username, bold_username)
self.label_message.setText(error_text)
self.label_message.setVisible(True)
if error_message:
domain = self.api.client_domain()
label = '{0}/{1}: {2}'.format(domain, username,
error_message.lower())
self.tracker.track_event(
'authenticate',
'login failed',
label=label,
)
self.text_password.setFocus()
self.text_password.selectAll()
self.sig_authentication_failed.emit()
self.button_login.setDisabled(False)
self.check_text()
QApplication.restoreOverrideCursor()
def open_url(self, url):
"""Open given url in the default browser and log the action."""
self.tracker.track_event('content', 'click', url)
self.sig_url_clicked.emit(url)
QDesktopServices.openUrl(QUrl(url))
class AuthenticationDialog(DialogBase):
FORGOT_USERNAME_URL = 'https://anaconda.org/account/forgot_username'
FORGOT_PASWORD_URL = 'https://anaconda.org/account/forgot_password'
REGISTER_URL = 'https://anaconda.org'
def __init__(self, api, parent=None):
super(AuthenticationDialog, self).__init__(parent)
self.api = api
self._parent = parent
self.token = None
self.error = None
self.tracker = GATracker()
# Widgets
self.label_username = QLabel('Username:'******'Password:'******'You can register ')
self.label_signin_text = QLabel('<hr><br><b>Already a member? '
'Sign in!</b><br>')
# For styling purposes the label next to a ButtonLink is also a button
# so they align adequately
self.button_register_text = ButtonLabel('You can register by '
'visiting the')
self.button_register = ButtonLink('Anaconda Cloud')
self.button_register_after_text = ButtonLabel('website.')
self.label_information = QLabel('''
<strong>Anaconda Cloud</strong> is where packages, notebooks,
and <br> environments are shared. It provides powerful <br>
collaboration and package management for open <br>
source and private projects.<br>
''')
self.label_message = QLabel('')
self.button_forgot_username = ButtonLink('I forgot my username')
self.button_forgot_password = ButtonLink('I forgot my password')
self.button_login = QPushButton('Login')
self.button_cancel = ButtonCancel('Cancel')
self.bbox = QDialogButtonBox(Qt.Horizontal)
# Widgets setup
self.bbox.addButton(self.button_cancel, QDialogButtonBox.RejectRole)
self.bbox.addButton(self.button_login, QDialogButtonBox.AcceptRole)
self.text_username.setAttribute(Qt.WA_MacShowFocusRect, False)
self.text_password.setAttribute(Qt.WA_MacShowFocusRect, False)
self.setMinimumWidth(260)
self.setWindowTitle('Sign in')
# This allows to completely style the dialog with css using the frame
self.text_password.setEchoMode(QLineEdit.Password)
self.label_message.setVisible(False)
# Layout
grid_layout = QGridLayout()
grid_layout.addWidget(self.label_username, 0, 0)
grid_layout.addWidget(self.text_username, 0, 1)
grid_layout.addWidget(self.label_password, 1, 0)
grid_layout.addWidget(self.text_password, 1, 1)
main_layout = QVBoxLayout()
main_layout.addWidget(self.label_information)
register_layout = QHBoxLayout()
register_layout.addWidget(self.button_register_text, 0)
register_layout.addWidget(self.button_register, 0, Qt.AlignLeft)
register_layout.addWidget(self.button_register_after_text, 0,
Qt.AlignLeft)
register_layout.addStretch()
register_layout.setContentsMargins(0, 0, 0, 0)
main_layout.addLayout(register_layout)
main_layout.addWidget(self.label_signin_text)
main_layout.addLayout(grid_layout)
main_layout.addSpacing(5)
main_layout.addWidget(self.label_message)
main_layout.addWidget(self.button_forgot_username, 0, Qt.AlignRight)
main_layout.addWidget(self.button_forgot_password, 0, Qt.AlignRight)
main_layout.addSpacing(15)
main_layout.addWidget(self.bbox)
self.setLayout(main_layout)
# Signals
self.button_forgot_username.clicked.connect(
lambda: self.open_url(self.FORGOT_USERNAME_URL))
self.button_forgot_password.clicked.connect(
lambda: self.open_url(self.FORGOT_PASWORD_URL))
self.button_register.clicked.connect(
lambda: self.open_url(self.REGISTER_URL))
self.text_username.textEdited.connect(self.check_text)
self.text_password.textEdited.connect(self.check_text)
self.button_login.clicked.connect(self.login)
self.button_cancel.clicked.connect(self.reject)
# Setup
self.check_text()
self.update_style_sheet()
self.text_username.setFocus()
@property
def username(self):
return self.text_username.text()
def update_style_sheet(self, style_sheet=None):
if style_sheet is None:
style_sheet = load_style_sheet()
self.setStyleSheet(style_sheet)
def check_text(self):
"""
Check that `username` and `password` are not empty and disabel/enable
buttons accordingly.
"""
username = self.text_username.text()
password = self.text_password.text()
if len(username) == 0 or len(password) == 0:
self.button_login.setDisabled(True)
else:
self.button_login.setDisabled(False)
def login(self):
self.button_login.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.label_message.setText('')
worker = self.api.client_login(self.text_username.text(),
self.text_password.text(),
'Anaconda Navigator',
'')
worker.sig_finished.connect(self._finished)
def _finished(self, worker, output, error):
"""
Method called when the anaconda-client Api has finished a process
that runs in a separate worker thread.
"""
token = output
if token:
self.token = token
self.accept()
elif error:
username = self.text_username.text()
bold_username = '******'.format(username)
# The error might come in (error_message, http_error) format
try:
error_message = eval(str(error))[0]
except Exception:
error_message = str(error)
error_message = error_message.lower().capitalize()
error_message = error_message.split(', ')[0]
error_text = '<i>{0}</i>'.format(error_message)
error_text = error_text.replace(username, bold_username)
self.label_message.setText(error_text)
self.label_message.setVisible(True)
if error_message:
domain = self.api.client_domain()
label = '{0}/{1}: {2}'.format(domain, username,
error_message.lower())
self.tracker.track_event('authenticate', 'login failed',
label=label)
self.text_password.setFocus()
self.text_password.selectAll()
self.button_login.setDisabled(False)
self.check_text()
QApplication.restoreOverrideCursor()
def open_url(self, url):
self.tracker.track_event('content', 'click', url)
QDesktopServices.openUrl(QUrl(url))
class Email(QWidget):
def __init__(self,
email=None,
password=None,
server=None,
port=25,
parent=None):
super().__init__(parent=parent)
self._email = email
self._password = password
self._server = server
self._port = port
mainLayout = QVBoxLayout(self)
mainLayout.setContentsMargins(0, 0, 0, 0)
mainLayout.setSpacing(0)
# server widget
serverportWidget = QWidget(self)
serverportLayout = QHBoxLayout(serverportWidget)
serverportLayout.setContentsMargins(10, 10, 10, 10)
serverLabel = QLabel("SMTP服务器:")
serverLabel.setStyleSheet("color:rgb(70,70,20); padding:10px;")
self.serverLineEdit = QLineEdit(self._server)
self.serverLineEdit.setValidator(
QRegExpValidator(QRegExp(r"[\w\-_]+(\.[\w\-_]+)+")))
self.serverLineEdit.setPlaceholderText("SMTP服务器地址")
self.serverLineEdit.textChanged.connect(self._setServer)
portLabel = QLabel("端口:")
portLabel.setStyleSheet("color:rgb(70,70,20); padding:10px;")
self.portLineEdit = QLineEdit(str(self._port))
self.portLineEdit.setValidator(QRegExpValidator(QRegExp(r"^[0-9]+$")))
self.portLineEdit.setPlaceholderText("端口号")
self.portLineEdit.textChanged.connect(self._setPort)
serverportLayout.addWidget(serverLabel)
serverportLayout.addWidget(self.serverLineEdit)
serverportLayout.addWidget(portLabel)
serverportLayout.addWidget(self.portLineEdit)
serverportLayout.setStretch(0, 1)
serverportLayout.setStretch(1, 5)
serverportLayout.setStretch(2, 1)
serverportLayout.setStretch(3, 1)
# email widget
emailWidget = QWidget(self)
emailLayout = QHBoxLayout(emailWidget)
emailLayout.setContentsMargins(0, 0, 0, 0)
emailLabel = QLabel("邮箱:")
emailLabel.setStyleSheet("color:rgb(70,70,20); padding:10px;")
self.emailLineEdit = QLineEdit(self._email)
self.emailLineEdit.setValidator(
QRegExpValidator(
QRegExp(
"^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$"
)))
self.emailLineEdit.setPlaceholderText("请输入邮箱地址")
self.emailLineEdit.textChanged.connect(self._setEmail)
emailLayout.addWidget(emailLabel)
emailLayout.addWidget(self.emailLineEdit)
# password widget
passwordWidget = QWidget(self)
passwordLayout = QHBoxLayout(passwordWidget)
passwordLayout.setContentsMargins(0, 0, 0, 0)
passwordLabel = QLabel("密码:")
passwordLabel.setStyleSheet("color:rgb(70,70,20); padding:10px;")
self.passwordLineEdit = QLineEdit(self._password)
self.passwordLineEdit.setPlaceholderText("请输入密码")
self.passwordLineEdit.textChanged.connect(self._setPassword)
self.passwordLineEdit.setEchoMode(QLineEdit.Password)
passwordLayout.addWidget(passwordLabel)
passwordLayout.addWidget(self.passwordLineEdit)
# 插入widget
mainLayout.addWidget(serverportWidget)
mainLayout.addWidget(emailWidget)
mainLayout.addWidget(passwordWidget)
def server(self):
return self._server
def _setServer(self, server):
self._server = server
def setServer(self, server):
self.serverLineEdit.setText(server)
def port(self):
return self._port
def _setPort(self, port):
self._port = int(port)
def setPort(self, port):
self.portLineEdit.setText(str(port))
def email(self):
return self._email
def _setEmail(self, email):
self._email = email
def setEmail(self, email):
self.emailLineEdit.setText(email)
def password(self):
return self._password
def _setPassword(self, password):
self._password = password
def setPassword(self, password):
self.passwordLineEdit.setText(password)
class DlgGitHubLogin(QDialog):
"""Dialog to submit error reports to Github."""
def __init__(self,
parent,
username,
password,
token,
remember=False,
remember_token=False):
super(DlgGitHubLogin, self).__init__(parent)
title = _("Sign in to Github")
self.resize(415, 375)
self.setWindowTitle(title)
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
# Header
html = ('<html><head/><body><p align="center">'
'{title}</p></body></html>')
lbl_html = QLabel(html.format(title=title))
lbl_html.setStyleSheet('font-size: 16px;')
# Tabs
self.tabs = QTabWidget()
# Basic form layout
basic_form_layout = QFormLayout()
basic_form_layout.setContentsMargins(-1, 0, -1, -1)
basic_lbl_msg = QLabel(
_("For regular users, i.e. users <b>without</b>"
" two-factor authentication enabled"))
basic_lbl_msg.setWordWrap(True)
basic_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_user = QLabel(_("Username:"******"", QWidget())
lbl_password = QLabel(_("Password: "******"Remember me"))
self.cb_remember.setToolTip(
_("Spyder will save your credentials "
"safely"))
self.cb_remember.setChecked(remember)
basic_form_layout.setWidget(4, QFormLayout.FieldRole,
self.cb_remember)
# Basic auth tab
basic_auth = QWidget()
basic_layout = QVBoxLayout()
basic_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
basic_layout.addWidget(basic_lbl_msg)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 1000, vPolicy=QSizePolicy.Expanding)))
basic_layout.addLayout(basic_form_layout)
basic_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 1000, vPolicy=QSizePolicy.Expanding)))
basic_auth.setLayout(basic_layout)
self.tabs.addTab(basic_auth, _("Password Only"))
# Token form layout
token_form_layout = QFormLayout()
token_form_layout.setContentsMargins(-1, 0, -1, -1)
token_lbl_msg = QLabel(
_("For users <b>with</b> two-factor "
"authentication enabled, or who prefer a "
"per-app token authentication.<br><br>"
"You can go <b><a href=\"{}\">here</a></b> "
"and click \"Generate token\" at the bottom "
"to create a new token to use for this, with "
"the appropriate permissions.").format(TOKEN_URL))
token_lbl_msg.setOpenExternalLinks(True)
token_lbl_msg.setWordWrap(True)
token_lbl_msg.setAlignment(Qt.AlignJustify)
lbl_token = QLabel("Token: ")
token_form_layout.setWidget(1, QFormLayout.LabelRole, lbl_token)
self.le_token = QLineEdit()
self.le_token.setEchoMode(QLineEdit.Password)
self.le_token.textChanged.connect(self.update_btn_state)
token_form_layout.setWidget(1, QFormLayout.FieldRole, self.le_token)
self.cb_remember_token = None
# Same validation as with cb_remember
if self.is_keyring_available() and valid_py_os:
self.cb_remember_token = QCheckBox(_("Remember token"))
self.cb_remember_token.setToolTip(
_("Spyder will save your "
"token safely"))
self.cb_remember_token.setChecked(remember_token)
token_form_layout.setWidget(3, QFormLayout.FieldRole,
self.cb_remember_token)
# Token auth tab
token_auth = QWidget()
token_layout = QVBoxLayout()
token_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
token_layout.addWidget(token_lbl_msg)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 1000, vPolicy=QSizePolicy.Expanding)))
token_layout.addLayout(token_form_layout)
token_layout.addSpacerItem(
QSpacerItem(QSpacerItem(0, 1000, vPolicy=QSizePolicy.Expanding)))
token_auth.setLayout(token_layout)
self.tabs.addTab(token_auth, _("Access Token"))
# Sign in button
self.bt_sign_in = QPushButton(_("Sign in"))
self.bt_sign_in.clicked.connect(self.accept)
self.bt_sign_in.setDisabled(True)
# Main layout
layout = QVBoxLayout()
layout.addWidget(lbl_html)
layout.addWidget(self.tabs)
layout.addWidget(self.bt_sign_in)
self.setLayout(layout)
# Final adjustments
if username and password:
self.le_user.setText(username)
self.le_password.setText(password)
self.bt_sign_in.setFocus()
elif username:
self.le_user.setText(username)
self.le_password.setFocus()
elif token:
self.le_token.setText(token)
else:
self.le_user.setFocus()
self.setFixedSize(self.width(), self.height())
self.le_password.installEventFilter(self)
self.le_user.installEventFilter(self)
self.tabs.currentChanged.connect(self.update_btn_state)
def eventFilter(self, obj, event):
interesting_objects = [self.le_password, self.le_user]
if obj in interesting_objects and event.type() == QEvent.KeyPress:
if (event.key() == Qt.Key_Return
and event.modifiers() & Qt.ControlModifier
and self.bt_sign_in.isEnabled()):
self.accept()
return True
return False
def update_btn_state(self):
user = to_text_string(self.le_user.text()).strip() != ''
password = to_text_string(self.le_password.text()).strip() != ''
token = to_text_string(self.le_token.text()).strip() != ''
enable = ((user and password and self.tabs.currentIndex() == 0)
or (token and self.tabs.currentIndex() == 1))
self.bt_sign_in.setEnabled(enable)
def is_keyring_available(self):
"""Check if keyring is available for password storage."""
try:
import keyring # analysis:ignore
return True
except Exception:
return False
@classmethod
def login(cls, parent, username, password, token, remember,
remember_token):
dlg = DlgGitHubLogin(parent, username, password, token, remember,
remember_token)
if dlg.exec_() == dlg.Accepted:
user = dlg.le_user.text()
password = dlg.le_password.text()
token = dlg.le_token.text()
if dlg.cb_remember:
remember = dlg.cb_remember.isChecked()
else:
remember = False
if dlg.cb_remember_token:
remember_token = dlg.cb_remember_token.isChecked()
else:
remember_token = False
credentials = dict(username=user,
password=password,
token=token,
remember=remember,
remember_token=remember_token)
return credentials
return dict(username=None,
password=None,
token=None,
remember=False,
remember_token=False)
class KernelConnectionDialog(QDialog, SpyderConfigurationAccessor):
"""Dialog to connect to existing kernels (either local or remote)."""
CONF_SECTION = 'existing-kernel'
def __init__(self, parent=None):
super(KernelConnectionDialog, self).__init__(parent)
self.setWindowTitle(_('Connect to an existing kernel'))
main_label = QLabel(
_("<p>Please select the JSON connection file (<i>e.g.</i> "
"<tt>kernel-1234.json</tt>) of the existing kernel, and enter "
"the SSH information if connecting to a remote machine. "
"To learn more about starting external kernels and connecting "
"to them, see <a href=\"https://docs.spyder-ide.org/"
"ipythonconsole.html#connect-to-an-external-kernel\">"
"our documentation</a>.</p>"))
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setOpenExternalLinks(True)
# Connection file
cf_label = QLabel(_('Connection file:'))
self.cf = QLineEdit()
self.cf.setPlaceholderText(_('Kernel connection file path'))
self.cf.setMinimumWidth(350)
cf_open_btn = QPushButton(_('Browse'))
cf_open_btn.clicked.connect(self.select_connection_file)
cf_layout = QHBoxLayout()
cf_layout.addWidget(cf_label)
cf_layout.addWidget(self.cf)
cf_layout.addWidget(cf_open_btn)
# Remote kernel groupbox
self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)"))
# SSH connection
hn_label = QLabel(_('Hostname:'))
self.hn = QLineEdit()
pn_label = QLabel(_('Port:'))
self.pn = QLineEdit()
self.pn.setMaximumWidth(75)
un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:'))
self.pw = QLineEdit()
self.pw.setEchoMode(QLineEdit.Password)
self.pw_radio.toggled.connect(self.pw.setEnabled)
self.kf_radio.toggled.connect(self.pw.setDisabled)
self.kf = QLineEdit()
kf_open_btn = QPushButton(_('Browse'))
kf_open_btn.clicked.connect(self.select_ssh_key)
kf_layout = QHBoxLayout()
kf_layout.addWidget(self.kf)
kf_layout.addWidget(kf_open_btn)
kfp_label = QLabel(_('Passphase:'))
self.kfp = QLineEdit()
self.kfp.setPlaceholderText(_('Optional'))
self.kfp.setEchoMode(QLineEdit.Password)
self.kf_radio.toggled.connect(self.kf.setEnabled)
self.kf_radio.toggled.connect(self.kfp.setEnabled)
self.kf_radio.toggled.connect(kf_open_btn.setEnabled)
self.kf_radio.toggled.connect(kfp_label.setEnabled)
self.pw_radio.toggled.connect(self.kf.setDisabled)
self.pw_radio.toggled.connect(self.kfp.setDisabled)
self.pw_radio.toggled.connect(kf_open_btn.setDisabled)
self.pw_radio.toggled.connect(kfp_label.setDisabled)
# SSH layout
ssh_layout = QGridLayout()
ssh_layout.addWidget(hn_label, 0, 0, 1, 2)
ssh_layout.addWidget(self.hn, 0, 2)
ssh_layout.addWidget(pn_label, 0, 3)
ssh_layout.addWidget(self.pn, 0, 4)
ssh_layout.addWidget(un_label, 1, 0, 1, 2)
ssh_layout.addWidget(self.un, 1, 2, 1, 3)
# SSH authentication layout
auth_layout = QGridLayout()
auth_layout.addWidget(self.pw_radio, 1, 0)
auth_layout.addWidget(pw_label, 1, 1)
auth_layout.addWidget(self.pw, 1, 2)
auth_layout.addWidget(self.kf_radio, 2, 0)
auth_layout.addWidget(kf_label, 2, 1)
auth_layout.addLayout(kf_layout, 2, 2)
auth_layout.addWidget(kfp_label, 3, 1)
auth_layout.addWidget(self.kfp, 3, 2)
auth_group.setLayout(auth_layout)
# Remote kernel layout
rm_layout = QVBoxLayout()
rm_layout.addLayout(ssh_layout)
rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
rm_layout.addWidget(auth_group)
self.rm_group.setLayout(rm_layout)
self.rm_group.setCheckable(True)
self.rm_group.toggled.connect(self.pw_radio.setChecked)
# Ok and Cancel buttons
self.accept_btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.accept_btns.accepted.connect(self.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# Dialog layout
layout = QVBoxLayout(self)
layout.addWidget(main_label)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
layout.addLayout(cf_layout)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12)))
layout.addWidget(self.rm_group)
layout.addLayout(btns_layout)
self.cf.setFocus()
self.load_connection_settings()
def load_connection_settings(self):
"""Load the user's previously-saved kernel connection settings."""
existing_kernel = self.get_conf("settings", {})
connection_file_path = existing_kernel.get("json_file_path", "")
is_remote = existing_kernel.get("is_remote", False)
username = existing_kernel.get("username", "")
hostname = existing_kernel.get("hostname", "")
port = str(existing_kernel.get("port", 22))
is_ssh_kf = existing_kernel.get("is_ssh_keyfile", False)
ssh_kf = existing_kernel.get("ssh_key_file_path", "")
if connection_file_path != "":
self.cf.setText(connection_file_path)
if username != "":
self.un.setText(username)
if hostname != "":
self.hn.setText(hostname)
if ssh_kf != "":
self.kf.setText(ssh_kf)
self.rm_group.setChecked(is_remote)
self.pn.setText(port)
self.kf_radio.setChecked(is_ssh_kf)
self.pw_radio.setChecked(not is_ssh_kf)
try:
import keyring
ssh_passphrase = keyring.get_password("spyder_remote_kernel",
"ssh_key_passphrase")
ssh_password = keyring.get_password("spyder_remote_kernel",
"ssh_password")
if ssh_passphrase:
self.kfp.setText(ssh_passphrase)
if ssh_password:
self.pw.setText(ssh_password)
except Exception:
pass
def save_connection_settings(self):
"""Save user's kernel connection settings."""
if not self.save_layout.isChecked():
return
is_ssh_key = bool(self.kf_radio.isChecked())
connection_settings = {
"json_file_path": self.cf.text(),
"is_remote": self.rm_group.isChecked(),
"username": self.un.text(),
"hostname": self.hn.text(),
"port": self.pn.text(),
"is_ssh_keyfile": is_ssh_key,
"ssh_key_file_path": self.kf.text()
}
self.set_conf("settings", connection_settings)
try:
import keyring
if is_ssh_key:
keyring.set_password("spyder_remote_kernel",
"ssh_key_passphrase", self.kfp.text())
else:
keyring.set_password("spyder_remote_kernel", "ssh_password",
self.pw.text())
except Exception:
pass
def select_connection_file(self):
cf = getopenfilename(self, _('Select kernel connection file'),
jupyter_runtime_dir(), '*.json;;*.*')[0]
self.cf.setText(cf)
def select_ssh_key(self):
kf = getopenfilename(self, _('Select SSH keyfile'), get_home_dir(),
'*.pem;;*')[0]
self.kf.setText(kf)
@staticmethod
def get_connection_parameters(parent=None, dialog=None):
if not dialog:
dialog = KernelConnectionDialog(parent)
result = dialog.exec_()
is_remote = bool(dialog.rm_group.isChecked())
accepted = result == QDialog.Accepted
if is_remote:
def falsy_to_none(arg):
return arg if arg else None
if dialog.hn.text() and dialog.un.text():
port = dialog.pn.text() if dialog.pn.text() else '22'
hostname = "{0}@{1}:{2}".format(dialog.un.text(),
dialog.hn.text(), port)
else:
hostname = None
if dialog.pw_radio.isChecked():
password = falsy_to_none(dialog.pw.text())
keyfile = None
elif dialog.kf_radio.isChecked():
keyfile = falsy_to_none(dialog.kf.text())
password = falsy_to_none(dialog.kfp.text())
else: # imposible?
keyfile = None
password = None
return (dialog.cf.text(), hostname, keyfile, password, accepted)
else:
path = dialog.cf.text()
_dir, filename = osp.dirname(path), osp.basename(path)
if _dir == '' and not filename.endswith('.json'):
path = osp.join(jupyter_runtime_dir(),
'kernel-' + path + '.json')
return (path, None, None, None, accepted)
class KernelConnectionDialog(QDialog):
"""Dialog to connect to existing kernels (either local or remote)."""
def __init__(self, parent=None):
super(KernelConnectionDialog, self).__init__(parent)
self.setWindowTitle(_('Connect to an existing kernel'))
main_label = QLabel(
_("<p>Please select a local JSON connection file (<i>e.g.</i> "
"<tt>kernel-1234.json</tt>) of the existing kernel. "
"<br><br>"
"If connecting to a remote machine, enter the SSH information, "
"adjust the command how to get jupyter runtime directory (if needed) "
"push the button to fetch remote configuration files and select one "
"of the loaded options."
"<br><br>"
"To learn more about starting external kernels and connecting "
"to them, see <a href=\"https://docs.spyder-ide.org/"
"ipythonconsole.html#connect-to-an-external-kernel\">"
"our documentation</a>.</p>"))
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setOpenExternalLinks(True)
self.TEXT_FETCH_REMOTE_CONN_FILES_BTN = 'Fetch remote connection files'
self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME = 'jupyter --runtime-dir'
# Connection file
cf_label = QLabel(_('Connection file:'))
self.cf = QLineEdit()
self.cf.setPlaceholderText(_('Kernel connection file path'))
self.cf.setMinimumWidth(350)
cf_open_btn = QPushButton(_('Browse'))
cf_open_btn.clicked.connect(self.select_connection_file)
cf_layout = QHBoxLayout()
cf_layout.addWidget(cf_label)
cf_layout.addWidget(self.cf)
cf_layout.addWidget(cf_open_btn)
# Remote kernel groupbox
self.rm_group = QGroupBox(_("This is a remote kernel (via SSH)"))
# SSH connection
hn_label = QLabel(_('Hostname:'))
self.hn = QLineEdit()
pn_label = QLabel(_('Port:'))
self.pn = QLineEdit()
self.pn.setMaximumWidth(75)
un_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:'))
self.pw = QLineEdit()
self.pw.setEchoMode(QLineEdit.Password)
self.pw_radio.toggled.connect(self.pw.setEnabled)
self.kf_radio.toggled.connect(self.pw.setDisabled)
self.kf = QLineEdit()
kf_open_btn = QPushButton(_('Browse'))
kf_open_btn.clicked.connect(self.select_ssh_key)
kf_layout = QHBoxLayout()
kf_layout.addWidget(self.kf)
kf_layout.addWidget(kf_open_btn)
kfp_label = QLabel(_('Passphase:'))
self.kfp = QLineEdit()
self.kfp.setPlaceholderText(_('Optional'))
self.kfp.setEchoMode(QLineEdit.Password)
self.kf_radio.toggled.connect(self.kf.setEnabled)
self.kf_radio.toggled.connect(self.kfp.setEnabled)
self.kf_radio.toggled.connect(kf_open_btn.setEnabled)
self.kf_radio.toggled.connect(kfp_label.setEnabled)
self.pw_radio.toggled.connect(self.kf.setDisabled)
self.pw_radio.toggled.connect(self.kfp.setDisabled)
self.pw_radio.toggled.connect(kf_open_btn.setDisabled)
self.pw_radio.toggled.connect(kfp_label.setDisabled)
# Button to fetch JSON files listing
self.kf_fetch_conn_files_btn = QPushButton(
_(self.TEXT_FETCH_REMOTE_CONN_FILES_BTN))
self.kf_fetch_conn_files_btn.clicked.connect(
self.fill_combobox_with_fetched_remote_connection_files)
self.cb_remote_conn_files = QComboBox()
self.cb_remote_conn_files.currentIndexChanged.connect(
self._take_over_selected_remote_configuration_file)
# Remote kernel groupbox
self.start_remote_kernel_group = QGroupBox(_("Start remote kernel"))
# Advanced settings to get remote connection files
jupyter_runtime_location_cmd_label = QLabel(
_('Command to get Jupyter runtime:'))
self.jupyter_runtime_location_cmd_lineedit = QLineEdit()
self.jupyter_runtime_location_cmd_lineedit.setPlaceholderText(
_(self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME))
# SSH layout
ssh_layout = QGridLayout()
ssh_layout.addWidget(hn_label, 0, 0, 1, 2)
ssh_layout.addWidget(self.hn, 0, 2)
ssh_layout.addWidget(pn_label, 0, 3)
ssh_layout.addWidget(self.pn, 0, 4)
ssh_layout.addWidget(un_label, 1, 0, 1, 2)
ssh_layout.addWidget(self.un, 1, 2, 1, 3)
# SSH authentication layout
auth_layout = QGridLayout()
auth_layout.addWidget(self.pw_radio, 1, 0)
auth_layout.addWidget(pw_label, 1, 1)
auth_layout.addWidget(self.pw, 1, 2)
auth_layout.addWidget(self.kf_radio, 2, 0)
auth_layout.addWidget(kf_label, 2, 1)
auth_layout.addLayout(kf_layout, 2, 2)
auth_layout.addWidget(kfp_label, 3, 1)
auth_layout.addWidget(self.kfp, 3, 2)
auth_layout.addWidget(jupyter_runtime_location_cmd_label, 4, 1)
auth_layout.addWidget(self.jupyter_runtime_location_cmd_lineedit, 4, 2)
auth_layout.addWidget(self.kf_fetch_conn_files_btn, 5, 1)
auth_layout.addWidget(self.cb_remote_conn_files, 5, 2)
auth_group.setLayout(auth_layout)
# Remote kernel layout
rm_layout = QVBoxLayout()
rm_layout.addLayout(ssh_layout)
rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
rm_layout.addWidget(auth_group)
self.rm_group.setLayout(rm_layout)
self.rm_group.setCheckable(True)
self.rm_group.toggled.connect(self.pw_radio.setChecked)
# Ok and Cancel buttons
self.accept_btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.accept_btns.accepted.connect(self.save_connection_settings)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
# Save connection settings checkbox
self.save_layout = QCheckBox(self)
self.save_layout.setText(_("Save connection settings"))
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.save_layout)
btns_layout.addWidget(self.accept_btns)
# Dialog layout
layout = QVBoxLayout(self)
layout.addWidget(main_label)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
layout.addLayout(cf_layout)
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12)))
layout.addWidget(self.rm_group)
layout.addLayout(btns_layout)
# List with connection file paths found on the remote host
self.remote_conn_file_paths = []
self.load_connection_settings()
def load_connection_settings(self):
"""Load the user's previously-saved kernel connection settings."""
existing_kernel = CONF.get("existing-kernel", "settings", {})
connection_file_path = existing_kernel.get("json_file_path", "")
is_remote = existing_kernel.get("is_remote", False)
username = existing_kernel.get("username", "")
hostname = existing_kernel.get("hostname", "")
port = str(existing_kernel.get("port", 22))
is_ssh_kf = existing_kernel.get("is_ssh_keyfile", False)
ssh_kf = existing_kernel.get("ssh_key_file_path", "")
cmd_jupyter_runtime = existing_kernel.get("cmd_jupyter_runtime")
if connection_file_path != "":
self.cf.setText(connection_file_path)
if username != "":
self.un.setText(username)
if hostname != "":
self.hn.setText(hostname)
if ssh_kf != "":
self.kf.setText(ssh_kf)
if cmd_jupyter_runtime != "":
self.jupyter_runtime_location_cmd_lineedit.setText(
cmd_jupyter_runtime)
self.rm_group.setChecked(is_remote)
self.pn.setText(port)
self.kf_radio.setChecked(is_ssh_kf)
self.pw_radio.setChecked(not is_ssh_kf)
try:
import keyring
ssh_passphrase = keyring.get_password("spyder_remote_kernel",
"ssh_key_passphrase")
ssh_password = keyring.get_password("spyder_remote_kernel",
"ssh_password")
if ssh_passphrase:
self.kfp.setText(ssh_passphrase)
if ssh_password:
self.pw.setText(ssh_password)
except Exception:
pass
def save_connection_settings(self):
"""Save user's kernel connection settings."""
if not self.save_layout.isChecked():
return
is_ssh_key = bool(self.kf_radio.isChecked())
connection_settings = {
"json_file_path":
self.cf.text(),
"is_remote":
self.rm_group.isChecked(),
"username":
self.un.text(),
"hostname":
self.hn.text(),
"port":
self.pn.text(),
"is_ssh_keyfile":
is_ssh_key,
"ssh_key_file_path":
self.kf.text(),
"cmd_jupyter_runtime":
self.jupyter_runtime_location_cmd_lineedit.text()
}
CONF.set("existing-kernel", "settings", connection_settings)
try:
import keyring
if is_ssh_key:
keyring.set_password("spyder_remote_kernel",
"ssh_key_passphrase", self.kfp.text())
else:
keyring.set_password("spyder_remote_kernel", "ssh_password",
self.pw.text())
except Exception:
pass
def select_connection_file(self):
cf = getopenfilename(self, _('Select kernel connection file'),
jupyter_runtime_dir(), '*.json;;*.*')[0]
self.cf.setText(cf)
def select_ssh_key(self):
kf = getopenfilename(self, _('Select SSH keyfile'), get_home_dir(),
'*.pem;;*')[0]
self.kf.setText(kf)
def _take_over_selected_remote_configuration_file(
self, chosen_idx_of_combobox_with_remote_conn_files):
remote_path_filename = self.remote_conn_file_paths[
chosen_idx_of_combobox_with_remote_conn_files]
self.cf.setText(remote_path_filename)
def fill_combobox_with_fetched_remote_connection_files(self):
"""
Fill the combobox with found remote connection json files.
:return: None
"""
_, username, _, only_host, port, keyfile, password = KernelConnectionDialog._get_remote_config(
self)
cmd_to_get_location_of_jupyter_runtime_files = self.jupyter_runtime_location_cmd_lineedit.text(
)
self.remote_conn_file_paths = self._fetch_connection_files_list(
host=only_host,
keyfile=keyfile,
password=password,
username=username,
port=port,
cmd_to_get_location_of_jupyter_runtime_files=
cmd_to_get_location_of_jupyter_runtime_files)
conn_files_short = [
c.rsplit('/', 1)[1] if '/' in c else c
for c in self.remote_conn_file_paths
]
self.cb_remote_conn_files.addItems(conn_files_short)
def _fetch_connection_files_list(
self, host: str, keyfile: Optional[str], password: Optional[str],
username: Optional[str], port: str,
cmd_to_get_location_of_jupyter_runtime_files: Optional[str]):
"""
:param host: URL or IP of the host.
:param keyfile: SSH key path or None if no key was provided.
:param password: Password for SSH connection or None if no password is used.
:rtype: List[str]
:return:
"""
import paramiko
client = paramiko.SSHClient()
self.kf_fetch_conn_files_btn.setDisabled(True)
list_of_copied_connection_files = []
try:
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(hostname=host,
port=int(port),
key_filename=keyfile,
passphrase=password,
username=username,
timeout=10,
auth_timeout=10)
if cmd_to_get_location_of_jupyter_runtime_files is None:
cmd_to_get_location_of_jupyter_runtime_files = self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME
self.kf_fetch_conn_files_btn.setText(
'Getting location of jupyter runtime...')
stdin, stdout, stderr = client.exec_command(
cmd_to_get_location_of_jupyter_runtime_files)
location_of_jupyter_runtime = stdout.readlines()
if len(location_of_jupyter_runtime) > 0:
location_of_jupyter_runtime = location_of_jupyter_runtime[
0].strip()
# get absolute paths
stdin, stdout, stderr = client.exec_command(
f'ls -d {location_of_jupyter_runtime}/*')
list_of_connection_files = stdout.readlines()
if len(list_of_connection_files) > 0:
list_of_connection_files = [
l.strip() for l in list_of_connection_files
]
import tempfile
import os
temp_dir = tempfile.gettempdir()
only_filenames = [
f.rsplit('/', 1)[1] for f in list_of_connection_files
]
list_of_copied_connection_files = [
os.path.join(temp_dir, f) for f in only_filenames
]
self.kf_fetch_conn_files_btn.setText(
f'Downloading {len(list_of_connection_files)} connection files...'
)
for remote_path, filename_only in zip(
list_of_connection_files, only_filenames):
sftp = client.open_sftp()
sftp.get(remote_path,
os.path.join(temp_dir, filename_only))
sftp.close()
else:
show_info_dialog(
"Warning",
f"Could not find any jupyter configuration files in {location_of_jupyter_runtime}."
)
else:
show_info_dialog(
"Warning",
f"Could not extract jupyter runtime location. Error from command line: {stderr.readlines()}"
)
finally:
client.close()
self.kf_fetch_conn_files_btn.setText(
self.TEXT_FETCH_REMOTE_CONN_FILES_BTN)
self.kf_fetch_conn_files_btn.setEnabled(True)
return list_of_copied_connection_files
@staticmethod
def _get_remote_config(dialog):
only_host = None
username = None
port = '22'
if dialog.hn.text() and dialog.un.text():
port = dialog.pn.text() if dialog.pn.text() else '22'
only_host = dialog.hn.text()
username = dialog.un.text()
hostname = "{0}@{1}:{2}".format(username, only_host, port)
else:
hostname = None
if dialog.pw_radio.isChecked():
password = _falsy_to_none(dialog.pw.text())
keyfile = None
elif dialog.kf_radio.isChecked():
keyfile = _falsy_to_none(dialog.kf.text())
password = _falsy_to_none(dialog.kfp.text())
else: # imposible?
keyfile = None
password = None
return dialog.cf.text(
), username, hostname, only_host, port, keyfile, password
@staticmethod
def get_connection_parameters(parent=None, dialog=None):
if not dialog:
dialog = KernelConnectionDialog(parent)
result = dialog.exec_()
is_remote = bool(dialog.rm_group.isChecked())
accepted = result == QDialog.Accepted
if is_remote:
cf_text, _, hostname, _, _, keyfile, password = KernelConnectionDialog._get_remote_config(
dialog)
return cf_text, hostname, keyfile, password, accepted
else:
path = dialog.cf.text()
_dir, filename = osp.dirname(path), osp.basename(path)
if _dir == '' and not filename.endswith('.json'):
path = osp.join(jupyter_runtime_dir(),
'kernel-' + path + '.json')
return path, None, None, None, accepted
class RemoteKernelSetupDialog(QDialog):
"""Dialog to connect to existing kernels (either local or remote)."""
def __init__(self, parent=None):
super(RemoteKernelSetupDialog, self).__init__(parent)
self.setWindowTitle(_('Setup remote kernel'))
self.TEXT_FETCH_REMOTE_CONN_FILES_BTN = 'Fetch remote connection files'
self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME = 'jupyter --runtime-dir'
# Name of the connection
cfg_name_label = QLabel(_('Configuration name:'))
self.cfg_name_line_edit = QLineEdit()
# SSH connection
hostname_label = QLabel(_('Hostname:'))
self.hostname_lineedit = QLineEdit()
port_label = QLabel(_('Port:'))
self.port_lineeidt = QLineEdit()
self.port_lineeidt.setMaximumWidth(75)
username_label = QLabel(_('Username:'******'Password:'******'SSH keyfile:'))
self.pw = QLineEdit()
self.pw.setEchoMode(QLineEdit.Password)
self.pw_radio.toggled.connect(self.pw.setEnabled)
self.keyfile_radio.toggled.connect(self.pw.setDisabled)
self.keyfile_path_lineedit = QLineEdit()
keyfile_browse_btn = QPushButton(_('Browse'))
keyfile_browse_btn.clicked.connect(self.select_ssh_key)
keyfile_layout = QHBoxLayout()
keyfile_layout.addWidget(self.keyfile_path_lineedit)
keyfile_layout.addWidget(keyfile_browse_btn)
passphrase_label = QLabel(_('Passphrase:'))
self.passphrase_lineedit = QLineEdit()
self.passphrase_lineedit.setPlaceholderText(_('Optional'))
self.passphrase_lineedit.setEchoMode(QLineEdit.Password)
self.keyfile_radio.toggled.connect(self.keyfile_path_lineedit.setEnabled)
self.keyfile_radio.toggled.connect(self.passphrase_lineedit.setEnabled)
self.keyfile_radio.toggled.connect(keyfile_browse_btn.setEnabled)
self.keyfile_radio.toggled.connect(passphrase_label.setEnabled)
self.pw_radio.toggled.connect(self.keyfile_path_lineedit.setDisabled)
self.pw_radio.toggled.connect(self.passphrase_lineedit.setDisabled)
self.pw_radio.toggled.connect(keyfile_browse_btn.setDisabled)
self.pw_radio.toggled.connect(passphrase_label.setDisabled)
# Button to fetch JSON files listing
# self.kf_fetch_conn_files_btn = QPushButton(_(self.TEXT_FETCH_REMOTE_CONN_FILES_BTN))
# self.kf_fetch_conn_files_btn.clicked.connect(self.fill_combobox_with_fetched_remote_connection_files)
# self.cb_remote_conn_files = QComboBox()
# self.cb_remote_conn_files.currentIndexChanged.connect(self._take_over_selected_remote_configuration_file)
# Remote kernel groupbox
self.start_remote_kernel_group = QGroupBox(_("Start remote kernel"))
# Advanced settings to get remote connection files
jupyter_runtime_location_cmd_label = QLabel(_('Command to get Jupyter runtime:'))
self.jupyter_runtime_location_cmd_lineedit = QLineEdit()
self.jupyter_runtime_location_cmd_lineedit.setPlaceholderText(_(self.DEFAULT_CMD_FOR_JUPYTER_RUNTIME))
# SSH layout
ssh_layout = QGridLayout()
ssh_layout.addWidget(cfg_name_label, 0, 0)
ssh_layout.addWidget(self.cfg_name_line_edit, 0, 2)
ssh_layout.addWidget(hostname_label, 1, 0, 1, 2)
ssh_layout.addWidget(self.hostname_lineedit, 1, 2)
ssh_layout.addWidget(port_label, 1, 3)
ssh_layout.addWidget(self.port_lineeidt, 1, 4)
ssh_layout.addWidget(username_label, 2, 0, 1, 2)
ssh_layout.addWidget(self.username_lineedit, 2, 2, 1, 3)
# SSH authentication layout
auth_layout = QGridLayout()
auth_layout.addWidget(self.pw_radio, 1, 0)
auth_layout.addWidget(pw_label, 1, 1)
auth_layout.addWidget(self.pw, 1, 2)
auth_layout.addWidget(self.keyfile_radio, 2, 0)
auth_layout.addWidget(keyfile_label, 2, 1)
auth_layout.addLayout(keyfile_layout, 2, 2)
auth_layout.addWidget(passphrase_label, 3, 1)
auth_layout.addWidget(self.passphrase_lineedit, 3, 2)
auth_layout.addWidget(jupyter_runtime_location_cmd_label, 4, 1)
auth_layout.addWidget(self.jupyter_runtime_location_cmd_lineedit, 4, 2)
# auth_layout.addWidget(self.kf_fetch_conn_files_btn, 5, 1)
# auth_layout.addWidget(self.cb_remote_conn_files, 5, 2)
auth_group.setLayout(auth_layout)
# Remote kernel layout
self.rm_group = QGroupBox(_("Setup up of a remote connection"))
self.rm_group.setEnabled(False)
rm_layout = QVBoxLayout()
rm_layout.addLayout(ssh_layout)
rm_layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
rm_layout.addWidget(auth_group)
self.rm_group.setLayout(rm_layout)
self.rm_group.setCheckable(False)
# Ok and Cancel buttons
self.accept_btns = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
self.accept_btns.accepted.connect(self.accept)
self.accept_btns.rejected.connect(self.reject)
btns_layout = QHBoxLayout()
btns_layout.addWidget(self.accept_btns)
# Dialog layout
layout = QVBoxLayout()
layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 8)))
# layout.addSpacerItem(QSpacerItem(QSpacerItem(0, 12)))
layout.addWidget(self.rm_group)
layout.addLayout(btns_layout)
# Main layout
hbox_layout = QHBoxLayout(self)
# Left side with the list of all remote connection configurations
items_label = QLabel(text="Configured remote locations")
self.items_list = QListWidget()
self.items_list.clicked.connect(self._on_items_list_click)
items_layout = QVBoxLayout()
items_layout.addWidget(items_label)
items_layout.addWidget(self.items_list)
edit_delete_new_buttons_layout = QHBoxLayout()
edit_btn = QPushButton(text="Edit")
add_btn = QPushButton(text="Add")
delete_btn = QPushButton(text="Delete")
add_btn.clicked.connect(self._on_add_btn_click)
edit_btn.clicked.connect(self._on_edit_btn_click)
delete_btn.clicked.connect(self._on_delete_btn_click)
edit_delete_new_buttons_layout.addWidget(add_btn)
edit_delete_new_buttons_layout.addWidget(edit_btn)
edit_delete_new_buttons_layout.addWidget(delete_btn)
items_layout.addLayout(edit_delete_new_buttons_layout)
hbox_layout.addSpacerItem(QSpacerItem(10, 0))
hbox_layout.addLayout(items_layout)
hbox_layout.addLayout(layout)
self.lst_with_connecion_configs = []
def _on_items_list_click(self):
from .kernelconnectmaindialog import LocalConnectionSettings, RemoteConnectionSettings
idx_of_config = self.items_list.selectedIndexes()[0].row()
cfg = self.lst_with_connecion_configs[idx_of_config]
if isinstance(cfg, RemoteConnectionSettings):
self._update_remote_connection_input_fields(cfg)
else:
show_info_dialog("Information", "This functionality is still not available")
def _clear_remote_connection_input_fields(self):
self.keyfile_path_lineedit.setText("")
self.passphrase_lineedit.setText("")
self.hostname_lineedit.setText("")
self.username_lineedit.setText("")
self.port_lineeidt.setText("")
self.cfg_name_line_edit.setText("")
self.jupyter_runtime_location_cmd_lineedit.setText("")
self.keyfile_radio.setChecked(False)
self.pw_radio.setChecked(False)
def _update_remote_connection_input_fields(self, remote_conn_settings):
self.keyfile_path_lineedit.setText(remote_conn_settings.keyfile_path)
self.passphrase_lineedit.setText(remote_conn_settings.password)
self.hostname_lineedit.setText(remote_conn_settings.hostname)
self.username_lineedit.setText(remote_conn_settings.username)
self.port_lineeidt.setText(str(remote_conn_settings.port))
self.cfg_name_line_edit.setText(remote_conn_settings.connection_name)
self.jupyter_runtime_location_cmd_lineedit.setText(remote_conn_settings.cmd_for_jupyter_runtime_location)
self.keyfile_radio.setChecked(remote_conn_settings.keyfile_path is not None)
self.pw_radio.setChecked(remote_conn_settings.password is not None)
def _on_add_btn_click(self):
from .kernelconnectmaindialog import LocalConnectionSettings, RemoteConnectionSettings
username = self.username_lineedit.text()
passphrase = self.passphrase_lineedit.text()
hostname = self.hostname_lineedit.text()
keyfile_path = self.keyfile_path_lineedit.text()
port = int(self.port_lineeidt.text()) if self.port_lineeidt.text() != "" else 22
jup_runtime_cmd = self.jupyter_runtime_location_cmd_lineedit.text()
cfg_name = self.cfg_name_line_edit.text()
cfg = RemoteConnectionSettings(
username=username,
hostname=hostname,
keyfile_path=keyfile_path,
port=port,
connection_name=cfg_name,
cmd_for_jupyter_runtime_location=jup_runtime_cmd,
password=passphrase
)
self.lst_with_connecion_configs.append(cfg)
self._update_list_with_configs()
self.rm_group.setEnabled(False)
def _on_edit_btn_click(self):
from .kernelconnectmaindialog import LocalConnectionSettings, RemoteConnectionSettings
self.rm_group.setEnabled(True)
idx_of_config = self.items_list.selectedIndexes()[0].row()
cfg = self.lst_with_connecion_configs[idx_of_config]
if isinstance(cfg, RemoteConnectionSettings):
self._update_remote_connection_input_fields(cfg)
else:
show_info_dialog("Information", "This functionality is still not available")
def _on_delete_btn_click(self):
idx_of_config = self.items_list.selectedIndexes()[0].row()
self.lst_with_connecion_configs.pop(idx_of_config)
self._update_list_with_configs()
def select_ssh_key(self):
kf = getopenfilename(self, _('Select SSH keyfile'),
get_home_dir(), '*.pem;;*')[0]
self.keyfile_path_lineedit.setText(kf)
def _take_over_selected_remote_configuration_file(self, chosen_idx_of_combobox_with_remote_conn_files):
remote_path_filename = self.remote_conn_file_paths[chosen_idx_of_combobox_with_remote_conn_files]
self.cf.setText(remote_path_filename)
def set_connection_configs(self, lst_with_connecion_configs):
self.lst_with_connecion_configs = lst_with_connecion_configs
self._update_list_with_configs()
def _update_list_with_configs(self):
from .kernelconnectmaindialog import LocalConnectionSettings, RemoteConnectionSettings
# now, fill the list
self.items_list.clear()
for cfg in self.lst_with_connecion_configs:
if isinstance(cfg, LocalConnectionSettings):
self.items_list.addItem(f"Local: {cfg.connection_name}")
elif isinstance(cfg, RemoteConnectionSettings):
self.items_list.addItem(f"Remote: {cfg.connection_name}")
def get_connection_settings(self):
return self.lst_with_connecion_configs
