def check_pandoc_version():
"""Returns True if minimal pandoc version is met.
Raises
------
PandocMissing
If pandoc is unavailable.
"""
v = get_pandoc_version()
if v is None:
warnings.warn(
"Sorry, we cannot determine the version of pandoc.\n"
"Please consider reporting this issue and include the"
"output of pandoc --version.\nContinuing...",
RuntimeWarning,
stacklevel=2)
return False
ok = check_version(v, _minimal_version)
if not ok:
warnings.warn(
"You are using an old version of pandoc (%s)\n" % v +
"Recommended version is %s.\nTry updating." % _minimal_version +
"http://johnmacfarlane.net/pandoc/installing.html.\nContinuing with doubts...",
RuntimeWarning,
stacklevel=2)
return ok
def import_pyqt4(version=2):
"""
Import PyQt4
Parameters
----------
version : 1, 2, or None
Which QString/QVariant API to use. Set to None to use the system
default
ImportErrors rasied within this function are non-recoverable
"""
# The new-style string API (version=2) automatically
# converts QStrings to Unicode Python strings. Also, automatically unpacks
# QVariants to their underlying objects.
import sip
if version is not None:
sip.setapi('QString', version)
sip.setapi('QVariant', version)
from PyQt4 import QtGui, QtCore, QtSvg
if not check_version(QtCore.PYQT_VERSION_STR, '4.7'):
raise ImportError("IPython requires PyQt4 >= 4.7, found %s" %
QtCore.PYQT_VERSION_STR)
# Alias PyQt-specific functions for PySide compatibility.
QtCore.Signal = QtCore.pyqtSignal
QtCore.Slot = QtCore.pyqtSlot
# query for the API version (in case version == None)
version = sip.getapi('QString')
api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
return QtCore, QtGui, QtSvg, api
def get_options():
"""Return a list of acceptable QT APIs, in decreasing order of
preference
"""
#already imported Qt somewhere. Use that
loaded = loaded_api()
if loaded is not None:
return [loaded]
mpl = sys.modules.get('matplotlib', None)
if mpl is not None and not check_version(mpl.__version__, '1.0.2'):
#1.0.1 only supports PyQt4 v1
return [QT_API_PYQT_DEFAULT]
qt_api = os.environ.get('QT_API', None)
if qt_api is None:
#no ETS variable. Ask mpl, then use default fallback path
return matplotlib_options(mpl) or [
QT_API_PYQT_DEFAULT, QT_API_PYSIDE, QT_API_PYQT5
]
elif qt_api not in _qt_apis:
raise RuntimeError("Invalid Qt API %r, valid values are: %r" %
(qt_api, ', '.join(_qt_apis)))
else:
return [qt_api]
def import_pyqt4(version=2):
"""
Import PyQt4
Parameters
----------
version : 1, 2, or None
Which QString/QVariant API to use. Set to None to use the system
default
ImportErrors rasied within this function are non-recoverable
"""
# The new-style string API (version=2) automatically
# converts QStrings to Unicode Python strings. Also, automatically unpacks
# QVariants to their underlying objects.
import sip
if version is not None:
sip.setapi('QString', version)
sip.setapi('QVariant', version)
from PyQt4 import QtGui, QtCore, QtSvg
if not check_version(QtCore.PYQT_VERSION_STR, '4.7'):
raise ImportError("IPython requires PyQt4 >= 4.7, found %s" %
QtCore.PYQT_VERSION_STR)
# Alias PyQt-specific functions for PySide compatibility.
QtCore.Signal = QtCore.pyqtSignal
QtCore.Slot = QtCore.pyqtSlot
# query for the API version (in case version == None)
version = sip.getapi('QString')
api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
return QtCore, QtGui, QtSvg, api
def load_ipython_extension(ip):
"""Load the extension in IPython."""
print("""The Cython magic has been move to the Cython package, hence """)
print("""`%load_ext cythonmagic` is deprecated; Please use `%load_ext Cython` instead.""")
if Cython is None or not version.check_version(Cython.__version__, "0.21"):
print("You need Cython version >=0.21 to use the Cython magic")
return
print("""\nThough, because I am nice, I'll still try to load it for you this time.""")
Cython.load_ipython_extension(ip)
def load_ipython_extension(ip):
"""Load the extension in IPython."""
print("""The Cython magic has been moved to the Cython package, hence """)
print("""`%load_ext cythonmagic` is deprecated; please use `%load_ext Cython` instead.""")
if Cython is None or not version.check_version(Cython.__version__, "0.21"):
print("You need Cython version >=0.21 to use the Cython magic")
return
print("""\nThough, because I am nice, I'll still try to load it for you this time.""")
Cython.load_ipython_extension(ip)
def check_for_zmq(minimum_version, required_by='Someone'):
try:
import zmq
except ImportError:
raise ImportError("%s requires pyzmq >= %s"%(required_by, minimum_version))
pyzmq_version = zmq.__version__
if not check_version(pyzmq_version, minimum_version):
raise ImportError("%s requires pyzmq >= %s, but you have %s"%(
required_by, minimum_version, pyzmq_version))
def check_for_zmq(minimum_version, module='IPython.kernel.zmq'):
try:
import zmq
except ImportError:
raise ImportError("%s requires pyzmq >= %s"%(module, minimum_version))
pyzmq_version = zmq.__version__
if not check_version(pyzmq_version, minimum_version):
raise ImportError("%s requires pyzmq >= %s, but you have %s"%(
module, minimum_version, pyzmq_version))
def check_for_zmq(minimum_version, module='IPython.kernel.zmq'):
try:
import zmq
except ImportError:
raise ImportError("%s requires pyzmq >= %s" %
(module, minimum_version))
pyzmq_version = zmq.__version__
if not check_version(pyzmq_version, minimum_version):
raise ImportError("%s requires pyzmq >= %s, but you have %s" %
(module, minimum_version, pyzmq_version))
def check_for_zmq(minimum_version, required_by='Someone'):
try:
import zmq
except ImportError:
raise ImportError("%s requires pyzmq >= %s" %
(required_by, minimum_version))
pyzmq_version = zmq.__version__
if not check_version(pyzmq_version, minimum_version):
raise ImportError("%s requires pyzmq >= %s, but you have %s" %
(required_by, minimum_version, pyzmq_version))
def has_binding(api):
"""Safely check for PyQt4/5 or PySide, without importing
submodules
Parameters
----------
api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyqtdefault']
Which module to check for
Returns
-------
True if the relevant module appears to be importable
"""
# we can't import an incomplete pyside and pyqt4
# this will cause a crash in sip (#1431)
# check for complete presence before importing
module_name = {
QT_API_PYSIDE: 'PySide',
QT_API_PYQT: 'PyQt4',
QT_API_PYQTv1: 'PyQt4',
QT_API_PYQT5: 'PyQt5',
QT_API_PYQT_DEFAULT: 'PyQt4'
}
module_name = module_name[api]
import imp
def find_module(module):
return "%s.%s" % (module_name, module) in sys.modules.keys()
try:
# importing top level PyQt4/PySide module is ok...
# FIXME: Once imported a top module this method will always deliver true.
# mod = __import__(module_name)
# ...importing submodules is not
# imp.find_module('QtCore', mod.__path__)
if (find_module("QtGui") or find_module("QtSvg")
or find_module("QtCore")):
return True
# imp.find_module('QtGui', mod.__path__)
# imp.find_module('QtSvg', mod.__path__)
if api == QT_API_PYQT5 and find_module("QtWidgets"):
# QT5 requires QtWidgets too
# imp.find_module('QtWidgets', mod.__path__)
return True
#we can also safely check PySide version
if api == QT_API_PYSIDE:
return check_version(mod.__version__, '1.0.3')
else:
return True
except ImportError:
return False
def check_pandoc_version():
"""Returns True if minimal pandoc version is met.
Exceptions
----------
PandocMissing will be raised if pandoc is unavailable.
"""
v = get_pandoc_version()
ok = check_version(v , _minimal_version )
if not ok:
warnings.warn( "You are using an old version of pandoc (%s)\n" % v +
"Recommended version is %s.\nTry updating." % _minimal_version +
"http://johnmacfarlane.net/pandoc/installing.html.\nContinuing with doubts...",
RuntimeWarning, stacklevel=2)
return ok
def _verify_node(cmd):
"""Verify that the node command exists and is at least the minimum supported
version of node.
Parameters
----------
cmd : string
Node command to verify (i.e 'node')."""
try:
out, err, return_code = get_output_error_code([cmd, '--version'])
except OSError:
# Command not found
return False
if return_code:
# Command error
return False
return check_version(out.lstrip('v'), '0.9.12')
def get_options():
"""Return a list of acceptable QT APIs, in decreasing order of
preference
"""
#already imported Qt somewhere. Use that
loaded = loaded_api()
if loaded is not None:
return [loaded]
mpl = sys.modules.get('matplotlib', None)
if mpl is not None and not check_version(mpl.__version__, '1.0.2'):
#1.0.1 only supports PyQt4 v1
return [QT_API_PYQT_DEFAULT]
qt_api = os.environ.get('QT_API', None)
if qt_api is None:
def _verify_node(cmd):
"""Verify that the node command exists and is at least the minimum supported
version of node.
Parameters
----------
cmd : string
Node command to verify (i.e 'node')."""
try:
out, err, return_code = get_output_error_code([cmd, '--version'])
except OSError:
# Command not found
return False
if return_code:
# Command error
return False
return check_version(out.lstrip('v'), '0.9.12')
def check_pandoc_version():
"""Returns True if minimal pandoc version is met.
Raises
------
PandocMissing
If pandoc is unavailable.
"""
v = get_pandoc_version()
ok = check_version(v, _minimal_version)
if not ok:
warnings.warn(
"You are using an old version of pandoc (%s)\n" % v +
"Recommended version is %s.\nTry updating." % _minimal_version +
"http://johnmacfarlane.net/pandoc/installing.html.\nContinuing with doubts...",
RuntimeWarning,
stacklevel=2)
return ok
def has_binding(api):
"""Safely check for PyQt4/5 or PySide, without importing
submodules
Parameters
----------
api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyqtdefault']
Which module to check for
Returns
-------
True if the relevant module appears to be importable
"""
# we can't import an incomplete pyside and pyqt4
# this will cause a crash in sip (#1431)
# check for complete presence before importing
module_name = {
QT_API_PYSIDE: 'PySide',
QT_API_PYQT: 'PyQt4',
QT_API_PYQTv1: 'PyQt4',
QT_API_PYQT5: 'PyQt5',
QT_API_PYQT_DEFAULT: 'PyQt4'
}
module_name = module_name[api]
import imp
try:
#importing top level PyQt4/PySide module is ok...
mod = import_module(module_name)
#...importing submodules is not
imp.find_module('QtCore', mod.__path__)
imp.find_module('QtGui', mod.__path__)
imp.find_module('QtSvg', mod.__path__)
if api == QT_API_PYQT5:
# QT5 requires QtWidgets too
imp.find_module('QtWidgets', mod.__path__)
#we can also safely check PySide version
if api == QT_API_PYSIDE:
return check_version(mod.__version__, '1.0.3')
else:
return True
except ImportError:
return False
def _verify_node(cmd):
"""Verify that the node command exists and is at least the minimum supported
version of node.
Parameters
----------
cmd : string
Node command to verify (i.e 'node')."""
try:
p = subprocess.Popen([cmd, "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, _ = p.communicate()
out = out.decode("utf8", "replace")
except OSError:
# Command not found
return False
if p.returncode:
# Command error
return False
return check_version(out.lstrip("v"), "0.9.12")
def has_binding(api):
"""Safely check for PyQt4/5 or PySide, without importing
submodules
Parameters
----------
api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyqtdefault']
Which module to check for
Returns
-------
True if the relevant module appears to be importable
"""
# we can't import an incomplete pyside and pyqt4
# this will cause a crash in sip (#1431)
# check for complete presence before importing
module_name = {QT_API_PYSIDE: 'PySide',
QT_API_PYQT: 'PyQt4',
QT_API_PYQTv1: 'PyQt4',
QT_API_PYQT5: 'PyQt5',
QT_API_PYQT_DEFAULT: 'PyQt4'}
module_name = module_name[api]
import imp
try:
#importing top level PyQt4/PySide module is ok...
mod = import_module(module_name)
#...importing submodules is not
imp.find_module('QtCore', mod.__path__)
imp.find_module('QtGui', mod.__path__)
imp.find_module('QtSvg', mod.__path__)
if api == QT_API_PYQT5:
# QT5 requires QtWidgets too
imp.find_module('QtWidgets', mod.__path__)
#we can also safely check PySide version
if api == QT_API_PYSIDE:
return check_version(mod.__version__, '1.0.3')
else:
return True
except ImportError:
return False
def _verify_node(cmd):
"""Verify that the node command exists and is at least the minimum supported
version of node.
Parameters
----------
cmd : string
Node command to verify (i.e 'node')."""
try:
p = subprocess.Popen([cmd, '--version'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, _ = p.communicate()
out = out.decode('utf8', 'replace')
except OSError:
# Command not found
return False
if p.returncode:
# Command error
return False
return check_version(out.lstrip('v'), '0.9.12')
def get_options():
"""Return a list of acceptable QT APIs, in decreasing order of
preference
"""
#already imported Qt somewhere. Use that
loaded = loaded_api()
if loaded is not None:
return [loaded]
mpl = sys.modules.get('matplotlib', None)
if mpl is not None and not check_version(mpl.__version__, '1.0.2'):
#1.0.1 only supports PyQt4 v1
return [QT_API_PYQT_DEFAULT]
if os.environ.get('QT_API', None) is None:
#no ETS variable. Ask mpl, then use either
return matplotlib_options(mpl) or [QT_API_PYQT_DEFAULT, QT_API_PYSIDE]
#ETS variable present. Will fallback to external.qt
return None
def get_options():
"""Return a list of acceptable QT APIs, in decreasing order of
preference
"""
#already imported Qt somewhere. Use that
loaded = loaded_api()
if loaded is not None:
return [loaded]
mpl = sys.modules.get('matplotlib', None)
if mpl is not None and not check_version(mpl.__version__, '1.0.2'):
#1.0.1 only supports PyQt4 v1
return [QT_API_PYQT_DEFAULT]
if os.environ.get('QT_API', None) is None:
#no ETS variable. Ask mpl, then use either
return matplotlib_options(mpl) or [QT_API_PYQT_DEFAULT, QT_API_PYSIDE]
#ETS variable present. Will fallback to external.qt
return None
def has_binding_new(api):
"""Safely check for PyQt4/5, PySide or PySide2, without importing submodules
Supports Python >= 3.4
Parameters
----------
api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyside2' | 'pyqtdefault']
Which module to check for
Returns
-------
True if the relevant module appears to be importable
"""
module_name = api_to_module[api]
from importlib.util import find_spec
required = ['QtCore', 'QtGui', 'QtSvg']
if api in (QT_API_PYQT5, QT_API_PYSIDE2):
# QT5 requires QtWidgets too
required.append('QtWidgets')
for submod in required:
try:
spec = find_spec('%s.%s' % (module_name, submod))
except ImportError:
# Package (e.g. PyQt5) not found
return False
else:
if spec is None:
# Submodule (e.g. PyQt5.QtCore) not found
return False
if api == QT_API_PYSIDE:
# We can also safely check PySide version
import PySide
return check_version(PySide.__version__, '1.0.3')
return True
def has_binding_new(api):
"""Safely check for PyQt4/5, PySide or PySide2, without importing submodules
Supports Python >= 3.4
Parameters
----------
api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyside2' | 'pyqtdefault']
Which module to check for
Returns
-------
True if the relevant module appears to be importable
"""
module_name = api_to_module[api]
from importlib.util import find_spec
required = ['QtCore', 'QtGui', 'QtSvg']
if api in (QT_API_PYQT5, QT_API_PYSIDE2):
# QT5 requires QtWidgets too
required.append('QtWidgets')
for submod in required:
try:
spec = find_spec('%s.%s' % (module_name, submod))
except ImportError:
# Package (e.g. PyQt5) not found
return False
else:
if spec is None:
# Submodule (e.g. PyQt5.QtCore) not found
return False
if api == QT_API_PYSIDE:
# We can also safely check PySide version
import PySide
return check_version(PySide.__version__, '1.0.3')
return True
def check_pandoc_version():
"""Returns True if minimal pandoc version is met.
Raises
------
PandocMissing
If pandoc is unavailable.
"""
v = get_pandoc_version()
if v is None:
warnings.warn("Sorry, we cannot determine the version of pandoc.\n"
"Please consider reporting this issue and include the"
"output of pandoc --version.\nContinuing...",
RuntimeWarning, stacklevel=2)
return False
ok = check_version(v, _minimal_version)
if not ok:
warnings.warn("You are using an old version of pandoc (%s)\n" % v +
"Recommended version is %s.\nTry updating." % _minimal_version +
"http://johnmacfarlane.net/pandoc/installing.html.\nContinuing with doubts...",
RuntimeWarning, stacklevel=2)
return ok
def get_options():
"""Return a list of acceptable QT APIs, in decreasing order of
preference
"""
#already imported Qt somewhere. Use that
loaded = loaded_api()
if loaded is not None:
return [loaded]
mpl = sys.modules.get('matplotlib', None)
if mpl is not None and not check_version(mpl.__version__, '1.0.2'):
#1.0.1 only supports PyQt4 v1
return [QT_API_PYQT_DEFAULT]
qt_api = os.environ.get('QT_API', None)
if qt_api is None:
#no ETS variable. Ask mpl, then use either
return matplotlib_options(mpl) or [QT_API_PYQT_DEFAULT, QT_API_PYSIDE]
elif qt_api not in _qt_apis:
raise RuntimeError("Invalid Qt API %r, valid values are: %r" %
(qt_api, ', '.join(_qt_apis)))
else:
return [qt_api]
def prepare_pyqt4():
# For PySide compatibility, use the new-style string API that automatically
# converts QStrings to Unicode Python strings. Also, automatically unpack
# QVariants to their underlying objects.
import sip
sip.setapi('QString', 2)
sip.setapi('QVariant', 2)
# Select Qt binding, using the QT_API environment variable if available.
QT_API = os.environ.get('QT_API')
if QT_API is None:
pyside_found = False
try:
import PySide
if not check_version(PySide.__version__, '1.0.3'):
# old PySide, fallback on PyQt
raise ImportError
# we can't import an incomplete pyside and pyqt4
# this will cause a crash in sip (#1431)
# check for complete presence before importing
import imp
imp.find_module("QtCore", PySide.__path__)
imp.find_module("QtGui", PySide.__path__)
imp.find_module("QtSvg", PySide.__path__)
pyside_found = True
from PySide import QtCore, QtGui, QtSvg
QT_API = QT_API_PYSIDE
except ImportError:
try:
prepare_pyqt4()
def prepare_pyqt4():
# For PySide compatibility, use the new-style string API that automatically
# converts QStrings to Unicode Python strings. Also, automatically unpack
# QVariants to their underlying objects.
import sip
sip.setapi('QString', 2)
sip.setapi('QVariant', 2)
# Select Qt binding, using the QT_API environment variable if available.
QT_API = os.environ.get('QT_API')
if QT_API is None:
pyside_found = False
try:
import PySide
if not check_version(PySide.__version__, '1.0.3'):
# old PySide, fallback on PyQt
raise ImportError
# we can't import an incomplete pyside and pyqt4
# this will cause a crash in sip (#1431)
# check for complete presence before importing
import imp
imp.find_module("QtCore", PySide.__path__)
imp.find_module("QtGui", PySide.__path__)
imp.find_module("QtSvg", PySide.__path__)
pyside_found = True
from PySide import QtCore, QtGui, QtSvg
QT_API = QT_API_PYSIDE
except ImportError:
try:
prepare_pyqt4()
from IPython.utils.version import check_version
try:
import argparse
# don't use system argparse if older than 1.1:
if not check_version(argparse.__version__, '1.1'):
raise ImportError
else:
from argparse import *
from argparse import SUPPRESS
except (ImportError, AttributeError):
from ._argparse import *
from ._argparse import SUPPRESS
import os
import terminado
from IPython.utils.version import check_version
if not check_version(terminado.__version__, '0.3.3'):
raise ImportError("terminado >= 0.3.3 required, found %s" % terminado.__version__)
from terminado import NamedTermManager
from tornado.log import app_log
from IPython.html.utils import url_path_join as ujoin
from .handlers import TerminalHandler, TermSocket
from . import api_handlers
def initialize(webapp):
shell = os.environ.get('SHELL', 'sh')
terminal_manager = webapp.settings['terminal_manager'] = NamedTermManager(shell_command=[shell])
terminal_manager.log = app_log
base_url = webapp.settings['base_url']
handlers = [
(ujoin(base_url, r"/terminals/(\w+)"), TerminalHandler),
(ujoin(base_url, r"/terminals/websocket/(\w+)"), TermSocket,
{'term_manager': terminal_manager}),
(ujoin(base_url, r"/api/terminals"), api_handlers.TerminalRootHandler),
(ujoin(base_url, r"/api/terminals/(\w+)"), api_handlers.TerminalHandler),
]
webapp.add_handlers(".*$", handlers)
except:
fallback on PySide
else:
use PyQt @v2 or PySide, depending on QT_API
because ETS doesn't work with PyQt @v1.
"""
import os
import sys
from IPython.utils.warn import warn
from IPython.utils.version import check_version
matplotlib = sys.modules.get('matplotlib')
if matplotlib and not check_version(matplotlib.__version__, '1.0.2'):
# 1.0.1 doesn't support pyside or v2, so stick with PyQt @v1,
# and ignore everything else
from PyQt4 import QtCore, QtGui
else:
# ask QT_API ETS variable *first*
QT_API = os.environ.get('QT_API', None)
if QT_API is None:
# QT_API not set, ask matplotlib if it was imported (e.g. `pylab=qt`)
if matplotlib:
mpqt = matplotlib.rcParams.get('backend.qt4', None)
else:
mpqt = None
if mpqt is None:
# matplotlib not imported or had nothing to say.
try: