def __init__(self, exec_lines=None): self.cout = StringIO() if exec_lines is None: exec_lines = [] # Create config object for IPython config = Config() config.HistoryManager.hist_file = ':memory:' config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) atexit.register(self.cleanup) sys.stdout = self.cout sys.stderr = self.cout # For debugging, so we can see normal output, use this: #from IPython.utils.io import Tee #sys.stdout = Tee(self.cout, channel='stdout') # dbg #sys.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.tmp_profile_dir = tmp_profile_dir self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. # this is assigned by the SetUp method of IPythonDirective # to point at itself. # # So, you can access handy things at self.directive.state self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def spark_magic(self, option=""): ip = InteractiveShell.instance() ip.register_magics(SparkexMagicsForTests) code = " from pyspark.sql import SparkSession" \ " \n SparkSession.builder.appName('abc')" result = ip.run_cell_magic("spark", option, code) return result
def __init__(self, exec_lines=None): self.cout = StringIO() if exec_lines is None: exec_lines = [] # Create config object for IPython config = Config() config.HistoryManager.hist_file = ":memory:" config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = "NoColor" # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix="profile_") profname = "auto_profile_sphinx_build" pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) atexit.register(self.cleanup) sys.stdout = self.cout sys.stderr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee # sys.stdout = Tee(self.cout, channel='stdout') # dbg # sys.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = "" self.output = "" self.tmp_profile_dir = tmp_profile_dir self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. # this is assigned by the SetUp method of IPythonDirective # to point at itself. # # So, you can access handy things at self.directive.state self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def __init__(self, exec_lines=None,state=None): self.cout = DecodingStringIO(u'') if exec_lines is None: exec_lines = [] self.state = state # Create config object for IPython config = Config() config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir,profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) # io.stdout redirect must be done after instantiating InteractiveShell io.stdout = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: #from IPython.utils.io import Tee #io.stdout = Tee(self.cout, channel='stdout') # dbg #io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def __init__(self, exec_lines=None, state=None): self.cout = DecodingStringIO("") if exec_lines is None: exec_lines = [] self.state = state # Create config object for IPython config = Config() config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = "NoColor" # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix="profile_") profname = "auto_profile_sphinx_build" pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) # io.stdout redirect must be done after instantiating InteractiveShell io.stdout = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee # io.stdout = Tee(self.cout, channel='stdout') # dbg # io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = "" self.output = "" self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def __init__(self): # self.cout = cStringIO.StringIO() self.cout = io.StringIO() # Create config object for IPython config = Config() config.Global.display_banner = False config.Global.exec_lines = [ 'import numpy as np', 'from pylab import *' ] config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize ipython, but don't start its mainloop IP = InteractiveShell.instance(config=config, profile_dir=profile) # io.stdout redirect must be done *after* instantiating InteractiveShell #io.stdout = self.cout sys.stdout = self.cout #io.stderr = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: #from IPython.utils.io import Tee #io.stdout = Tee(self.cout, channel='stdout') # dbg #io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.is_verbatim = False self.is_doctest = False self.is_suppress = False # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False
def __init__(self): self.cout = cStringIO.StringIO() # Create config object for IPython config = Config() config.Global.display_banner = False config.Global.exec_lines = ['import numpy as np', 'from pylab import *' ] config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' config.InteractiveShell.cache_size = 0 # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize ipython, but don't start its mainloop IP = InteractiveShell.instance(config=config, profile_dir=profile) # io.stdout redirect must be done *after* instantiating # InteractiveShell io.stdout = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee # io.stdout = Tee(self.cout, channel='stdout') # dbg # io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.is_verbatim = False self.is_doctest = False self.is_suppress = False # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False
def __install(): log = logging.getLogger('tpython') log.info('setting up twisted reactor in ipython loop') from twisted.internet import _threadedselect _threadedselect.install() from twisted.internet import reactor from collections import deque from IPython.lib import inputhook from IPython import InteractiveShell q = deque() def reactor_wake(twisted_loop_next, q=q): q.append(twisted_loop_next) def reactor_work(*_args): if q: while len(q): q.popleft()() return 0 def reactor_start(*_args): log.info('starting twisted reactor in ipython') reactor.interleave(reactor_wake) # @UndefinedVariable inputhook.set_inputhook(reactor_work) def reactor_stop(): if reactor.threadpool: # @UndefinedVariable log.info('stopping twisted threads') reactor.threadpool.stop() # @UndefinedVariable log.info('shutting down twisted reactor') reactor._mainLoopShutdown() # @UndefinedVariable ip = InteractiveShell.instance() ask_exit = ip.ask_exit def ipython_exit(): reactor_stop() return ask_exit() ip.ask_exit = ipython_exit reactor_start() return reactor
def __init__(self): self.cout = io.StringIO() Term.cout = self.cout Term.cerr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee #Term.cout = Tee(self.cout, channel='stdout') # dbg #Term.cerr = Tee(self.cout, channel='stderr') # dbg # Create config object for IPython config = Config() config.Global.display_banner = False config.Global.exec_lines = ['import numpy as np', 'from pylab import *' ] config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' # Create and initialize ipython, but don't start its mainloop IP = InteractiveShell.instance(config=config) # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.is_verbatim = False self.is_doctest = False self.is_suppress = False # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # we need bookmark the current dir first so we can save # relative to it self.process_input_line('bookmark ipy_basedir') self.cout.seek(0) self.cout.truncate(0)
def __init__(self): self.cout = cStringIO.StringIO() Term.cout = self.cout Term.cerr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee # Term.cout = Tee(self.cout, channel='stdout') # dbg # Term.cerr = Tee(self.cout, channel='stderr') # dbg # Create config object for IPython config = Config() config.Global.display_banner = False config.Global.exec_lines = [ "import numpy as np", "from pylab import *" ] config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = "NoColor" # Create and initialize ipython, but don't start its mainloop IP = InteractiveShell.instance(config=config) # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = "" self.output = "" self.is_verbatim = False self.is_doctest = False self.is_suppress = False # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # we need bookmark the current dir first so we can save # relative to it self.process_input_line("bookmark ipy_basedir") self.cout.seek(0) self.cout.truncate(0)
from altair.vega.v5 import Vega DATA_RECORDS = [ {"amount": 28, "category": "A"}, {"amount": 55, "category": "B"}, {"amount": 43, "category": "C"}, {"amount": 91, "category": "D"}, {"amount": 81, "category": "E"}, {"amount": 53, "category": "F"}, {"amount": 19, "category": "G"}, {"amount": 87, "category": "H"}, ] if IPYTHON_AVAILABLE: _ipshell = InteractiveShell.instance() _ipshell.run_cell("%load_ext altair") _ipshell.run_cell( """ import pandas as pd table = pd.DataFrame.from_records({}) the_data = table """.format( DATA_RECORDS ) ) VEGA_SPEC = { "$schema": "https://vega.github.io/schema/vega/v5.json", "axes": [
def _start_ipython(): """Start a global IPython shell, which we need for IPython-specific syntax. """ def xsys(self, cmd): """Replace the default system call with a capturing one for doctest. """ # We use getoutput, but we need to strip it because pexpect captures # the trailing newline differently from commands.getoutput print(self.getoutput(cmd, split=False, depth=1).rstrip(), end="", file=sys.stdout) sys.stdout.flush() def _showtraceback(self, etype, evalue, stb): """Print the traceback purely on stdout for doctest to capture it. """ print(self.InteractiveTB.stb2text(stb), file=sys.stdout) global get_ipython # This function should only ever run once! if hasattr(_start_ipython, "already_called"): return _start_ipython.already_called = True # Store certain global objects that IPython modifies _displayhook = sys.displayhook _excepthook = sys.excepthook _main = sys.modules.get("__main__") # Create custom argv and namespaces for our IPython to be test-friendly config = tools.default_config() config.TerminalInteractiveShell.simple_prompt = True # Create and initialize our test-friendly IPython instance. shell = InteractiveShell.instance(config=config) # A few more tweaks needed for playing nicely with doctests... # remove history file shell.tempfiles.append(config.HistoryManager.hist_file) # These traps are normally only active for interactive use, set them # permanently since we'll be mocking interactive sessions. shell.builtin_trap.activate() # Modify the IPython system call with one that uses getoutput, so that we # can capture subcommands and print them to Python's stdout, otherwise the # doctest machinery would miss them. shell.system = types.MethodType(xsys, shell) shell._showtraceback = types.MethodType(_showtraceback, shell) # IPython is ready, now clean up some global state... # Deactivate the various python system hooks added by ipython for # interactive convenience so we don't confuse the doctest system sys.modules["__main__"] = _main sys.displayhook = _displayhook sys.excepthook = _excepthook # So that ipython magics and aliases can be doctested (they work by making # a call into a global _ip object). Also make the top-level get_ipython # now return this without recursively calling here again. _ip = shell get_ipython = _ip.get_ipython builtin_mod._ip = _ip builtin_mod.ip = _ip builtin_mod.get_ipython = get_ipython # Override paging, so we don't require user interaction during the tests. def nopage(strng, start=0, screen_lines=0, pager_cmd=None): if isinstance(strng, dict): strng = strng.get("text/plain", "") print(strng) page.orig_page = page.pager_page page.pager_page = nopage return _ip
from mpl_toolkits.basemap import cm as bacm except: try: from matplotlib.toolkits.basemap import cm as bacm except: print "Cannot load basemap colormaps (bacm)" # Coping with the IPython API change from v0.10 to v0.11 try: import IPython.ipapi # IPython 0.10 and earlier ip = IPython.ipapi.get() def_Magic = ip.expose_magic IPY_LEGACY = True except: from IPython import InteractiveShell # IPython 0.11 and later ip = InteractiveShell.instance() def_Magic = ip.define_magic IPY_LEGACY = False def ip_Exec(self, cmd): if IPY_LEGACY: self.api.ex(cmd) else: ip.ex(cmd) def grads_(self, arg=' '): ip_Exec(self, "from grads import GrADS; ga=GrADS(%s)" % arg)
from IPython import get_ipython from IPython import InteractiveShell shell = InteractiveShell.instance() ip = get_ipython() ip.run_cell("%time None") # CPU times: user 2 µs, sys: 0 ns, total: 2 µs # Wall time: 3.58 µs