def interactive(idx=0, DongleClass=RfCat, intro=''):
global d
import rflib.chipcon_nic as rfnic
import atexit
d = DongleClass(idx=idx)
d.setModeRX() # this puts the dongle into receive mode
atexit.register(cleanupInteractiveAtExit)
gbls = globals()
lcls = locals()
try:
import IPython.Shell
ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls)
print intro
ipsh.mainloop(intro)
except ImportError, e:
try:
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
ipsh = TerminalInteractiveShell()
ipsh.user_global_ns.update(gbls)
ipsh.user_global_ns.update(lcls)
ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart!
ipsh.mainloop(intro)
except ImportError, e:
print e
shell = code.InteractiveConsole(gbls)
shell.interact(intro)
def interactive(idx=0, DongleClass=RfCat, intro=''):
global d
import rflib.chipcon_nic as rfnic
import atexit
d = DongleClass(idx=idx)
d.setModeRX() # this puts the dongle into receive mode
atexit.register(cleanupInteractiveAtExit)
gbls = globals()
lcls = locals()
try:
import IPython.Shell
ipsh = IPython.Shell.IPShell(argv=[''],
user_ns=lcls,
user_global_ns=gbls)
print intro
ipsh.mainloop(intro)
except ImportError, e:
try:
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
ipsh = TerminalInteractiveShell()
ipsh.user_global_ns.update(gbls)
ipsh.user_global_ns.update(lcls)
ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart!
ipsh.mainloop(intro)
except ImportError, e:
print e
shell = code.InteractiveConsole(gbls)
shell.interact(intro)
def handle(self, *args, **kwargs):
imported_objects = {
'config' : self.config,
}
try:
# Try IPython imports
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
from IPython.config.loader import Config
cfg = Config()
shell = TerminalInteractiveShell(config=cfg, user_ns=imported_objects)
shell.mainloop(display_banner='\n Samovar \n')
except:
import code
code.InteractiveConsole(locals=imported_objects).interact()
def handle(self, *args, **kwargs):
imported_objects = {
'config': self.config,
}
try:
# Try IPython imports
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
from IPython.config.loader import Config
cfg = Config()
shell = TerminalInteractiveShell(config=cfg,
user_ns=imported_objects)
shell.mainloop(display_banner='\n Samovar \n')
except:
import code
code.InteractiveConsole(locals=imported_objects).interact()
def run_ipython_shell_v11(locals, globals, first_time):
'''IPython shell from IPython version 0.11'''
if first_time:
banner = "Hit Ctrl-D to return to PuDB."
else:
banner = ""
from IPython.frontend.terminal.interactiveshell import \
TerminalInteractiveShell
from IPython.frontend.terminal.ipapp import load_default_config
# XXX: in the future it could be useful to load a 'pudb' config for the
# user (if it exists) that could contain the user's macros and other
# niceities.
config = load_default_config()
shell = TerminalInteractiveShell.instance(config=config, banner2=banner)
# XXX This avoids a warning about not having unique session/line numbers.
# See the HistoryManager.writeout_cache method in IPython.core.history.
shell.history_manager.new_session()
# Save the originating namespace
old_locals = shell.user_ns
old_globals = shell.user_global_ns
# Update shell with current namespace
_update_ns(shell, locals, globals)
shell.mainloop(banner)
# Restore originating namespace
_update_ns(shell, old_locals, old_globals)
def start_ipython():
"""Start a global IPython shell, which we need for IPython-specific syntax.
"""
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()
# Create and initialize our test-friendly IPython instance.
shell = TerminalInteractiveShell.instance(config=config,
user_ns=ipnsdict(),
user_global_ns={})
# 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 = py3compat.MethodType(xsys, shell)
shell._showtraceback = py3compat.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.get_ipython = get_ipython
# To avoid extra IPython messages during testing, suppress io.stdout/stderr
io.stdout = StreamProxy('stdout')
io.stderr = StreamProxy('stderr')
return _ip
def start_ipython():
"""Start a global IPython shell, which we need for IPython-specific syntax.
"""
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()
# Create and initialize our test-friendly IPython instance.
shell = TerminalInteractiveShell.instance(config=config,
user_ns=ipnsdict(),
user_global_ns={}
)
# A few more tweaks needed for playing nicely with doctests...
# 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 = MethodType(xsys, shell, TerminalInteractiveShell)
shell._showtraceback = MethodType(_showtraceback, shell,
TerminalInteractiveShell)
# 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__._ip = _ip
__builtin__.get_ipython = get_ipython
# To avoid extra IPython messages during testing, suppress io.stdout/stderr
io.stdout = StreamProxy('stdout')
io.stderr = StreamProxy('stderr')
return _ip
def construct(self):
# I am a little hesitant to put these into InteractiveShell itself.
# But that might be the place for them
sys.path.insert(0, '')
# Create an InteractiveShell instance.
self.shell = TerminalInteractiveShell.instance(config=self.master_config)
def run_ipython_shell_v11(locals, globals, first_time):
'''IPython shell from IPython version 0.11'''
if first_time:
banner = "Hit Ctrl-D to return to PuDB."
else:
banner = ""
from IPython.frontend.terminal.interactiveshell import \
TerminalInteractiveShell
from IPython.frontend.terminal.ipapp import load_default_config
# XXX: in the future it could be useful to load a 'pudb' config for the
# user (if it exists) that could contain the user's macros and other
# niceities.
config = load_default_config()
shell = TerminalInteractiveShell.instance(config=config,
banner2=banner)
# XXX This avoids a warning about not having unique session/line numbers.
# See the HistoryManager.writeout_cache method in IPython.core.history.
shell.history_manager.new_session()
# Save the originating namespace
old_locals = shell.user_ns
old_globals = shell.user_global_ns
# Update shell with current namespace
_update_ns(shell, locals, globals)
shell.mainloop(banner)
# Restore originating namespace
_update_ns(shell, old_locals, old_globals)
def construct(self):
# I am a little hesitant to put these into InteractiveShell itself.
# But that might be the place for them
sys.path.insert(0, '')
# Create an InteractiveShell instance.
self.shell = TerminalInteractiveShell.instance(config=self.master_config)
def init_shell(self):
"""initialize the InteractiveShell instance"""
# Create an InteractiveShell instance.
# shell.display_banner should always be False for the terminal
# based app, because we call shell.show_banner() by hand below
# so the banner shows *before* all extension loading stuff.
self.shell = TerminalInteractiveShell.instance(
config=self.config, display_banner=False, profile_dir=self.profile_dir, ipython_dir=self.ipython_dir
)
self.shell.configurables.append(self)
def init_shell(self):
"""initialize the InteractiveShell instance"""
# Create an InteractiveShell instance.
# shell.display_banner should always be False for the terminal
# based app, because we call shell.show_banner() by hand below
# so the banner shows *before* all extension loading stuff.
self.shell = TerminalInteractiveShell.instance(config=self.config,
display_banner=False, profile_dir=self.profile_dir,
ipython_dir=self.ipython_dir)
self.shell.configurables.append(self)
def init_shell(self):
"""initialize the InteractiveShell instance"""
# I am a little hesitant to put these into InteractiveShell itself.
# But that might be the place for them
sys.path.insert(0, '')
# Create an InteractiveShell instance.
# shell.display_banner should always be False for the terminal
# based app, because we call shell.show_banner() by hand below
# so the banner shows *before* all extension loading stuff.
self.shell = TerminalInteractiveShell.instance(config=self.config,
display_banner=False, profile_dir=self.profile_dir,
ipython_dir=self.ipython_dir)
def init_shell(self):
"""initialize the InteractiveShell instance"""
# I am a little hesitant to put these into InteractiveShell itself.
# But that might be the place for them
sys.path.insert(0, '')
# Create an InteractiveShell instance.
# shell.display_banner should always be False for the terminal
# based app, because we call shell.show_banner() by hand below
# so the banner shows *before* all extension loading stuff.
self.shell = TerminalInteractiveShell.instance(config=self.config,
display_banner=False, profile_dir=self.profile_dir,
ipython_dir=self.ipython_dir)
def execute(file_, verbose = 0, stop_on_error = 1, store_history = 0):
""" Read and execute lines of code in given open file.
Supports pure python or ipython-bash style syntax,
multi-line code, and the IPython feature set
"""
shell = TerminalInteractiveShell()
c = shell.get_ipython()
c.instance() # initialize ipython config
raw_cells = file_.readlines()
exception = None
while raw_cells:
# Extract smallest possible executable block of code from raw source
is_completed = c.input_splitter.push(raw_cells.pop(0))
while not is_completed:
is_completed = c.input_splitter.push(raw_cells.pop(0))
cell, raw_cell = c.input_splitter.source_raw_reset()
# Transform cell into syntactically correct python
cell = c.prefilter_manager.prefilter_lines(cell) + '\n'
# If we are storing script in/out history
if store_history:
c.history_manager.store_inputs(c.execution_count,
cell, raw_cell)
# Compile to byte code
code = compile(cell, 'cellname', 'exec')
if verbose:
print '========'
print 'executing:', cell
print '========'
outflag = c.run_code(code)
if stop_on_error and outflag:
c.exit()
break
def __init__(self, *args, **kwargs):
# Initialization based on: from IPython.testing.globalipapp import start_ipython
self._curr_exec_line = 0
# Store certain global objects that IPython modifies
_displayhook = sys.displayhook
_excepthook = sys.excepthook
# Create and initialize our IPython instance.
shell = TerminalInteractiveShell.instance()
# Create an intput splitter to handle input separation
self.input_splitter = IPythonInputSplitter()
shell.showtraceback = _showtraceback
# 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.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.
get_ipython = shell.get_ipython
try:
import __builtin__
except:
import builtins as __builtin__
__builtin__._ip = shell
__builtin__.get_ipython = get_ipython
# We want to print to stdout/err as usual.
io.stdout = original_stdout
io.stderr = original_stderr
self.ipython = shell
def __init__(self, *args, **kwargs):
# Initialization based on: from IPython.testing.globalipapp import start_ipython
self._curr_exec_line = 0
# Store certain global objects that IPython modifies
_displayhook = sys.displayhook
_excepthook = sys.excepthook
# Create and initialize our IPython instance.
shell = TerminalInteractiveShell.instance()
# Create an intput splitter to handle input separation
self.input_splitter = IPythonInputSplitter()
shell.showtraceback = _showtraceback
# 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.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.
get_ipython = shell.get_ipython
try:
import __builtin__
except:
import builtins as __builtin__
__builtin__._ip = shell
__builtin__.get_ipython = get_ipython
# We want to print to stdout/err as usual.
io.stdout = original_stdout
io.stderr = original_stderr
self.ipython = shell
import os
try:
from IPython import ipapi
except ImportError:
from IPython.frontend.terminal.interactiveshell import \
TerminalInteractiveShell
ip = TerminalInteractiveShell.instance()
_ipython_version = (0, 11)
else:
ip = ipapi.get()
_ipython_version = (0, 10)
def pudb_f_v10(self, arg):
""" Debug a script (like %run -d) in IPython process, using PuDB.
This conforms to IPython version 0.10
Usage:
%pudb test.py [args]
Run script test.py under PuDB.
"""
if not arg.strip():
print __doc__
return
from IPython.genutils import arg_split
args = arg_split(arg)
def autoipython(funcs):
# Use IPython in combination with AUTO
# First import the shell class
ipython11 = False
try:
import IPython.Shell
except ImportError:
try: # Check for ipython >= 0.11
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
ipython11 = True
except ImportError:
print("Sorry, ipython is not available on this system.")
return
if ipython11:
from IPython.config.loader import Config
cfg = Config()
cfg.PromptManager.in_template = "AUTO In [\\#]: "
cfg.PromptManager.in2_template = "AUTO .\\D.: "
cfg.PromptManager.out_template = "Out[\#]: "
cfg.InteractiveShell.confirm_exit = False
cfg.InteractiveShell.autocall = 2
cfg.InteractiveShell.banner2 = """
Welcome to the AUTO IPython CLUI
man -> List of AUTO CLUI commands"""
ipshell = TerminalInteractiveShell(config=cfg, user_ns=funcs)
ipshell.show_banner()
ipshell.mainloop()
return
import IPython
from IPython.iplib import InteractiveShell
# Now create an instance of the embeddable shell. The first argument is a
# string with options exactly as you would type them if you were starting
# IPython at the system command line. Any parameters you want to define for
# configuration can thus be specified here.
args = [
'-pi1', 'AUTO In [\\#]: ', '-pi2', 'AUTO .\\D.: ', '-po',
'Out[\#]: ', '-noconfirm_exit', '-autocall', '2'
]
banner = [
'Python %s\n'
'Type "copyright", "credits" or "license" '
'for more information.\n' % (sys.version.split('\n')[0], ),
"IPython %s -- An enhanced Interactive Python." %
(IPython.Release.version, ),
"""? -> Introduction to IPython's features.
%magic -> Information about IPython's 'magic' % functions.
help -> Python's own help system.
object? -> Details about 'object'. ?object also works, ?? prints more.
Welcome to the AUTO IPython CLUI
man -> List of AUTO CLUI commands"""
]
class AUTOInteractiveShell(AUTOInteractive, InteractiveShell):
def __init__(self, name, **kw):
self.parentclass = InteractiveShell
AUTOInteractive.__init__(self, kw["user_ns"], None)
InteractiveShell.__init__(self, name, **kw)
def prefilter(self, line, continue_prompt):
if not continue_prompt:
line = self.processShorthand(line)
line = InteractiveShell.prefilter(self, line, continue_prompt)
return line
ipshell = IPython.Shell.IPShell(args,
user_ns=funcs,
user_global_ns=funcs,
shell_class=AUTOInteractiveShell)
ipshell.IP.user_ns['help'] = ipshell.IP.help
ipshell.mainloop(banner='\n'.join(banner))
try:
from IPython import ipapi
ip = ipapi.get()
_ipython_version = (0, 10)
except ImportError:
try:
from IPython.core.magic import register_line_magic
from IPython import get_ipython
_ipython_version = (1, 0)
except ImportError:
# Note, keep this run last, or else it will raise a deprecation
# warning.
from IPython.frontend.terminal.interactiveshell import \
TerminalInteractiveShell
ip = TerminalInteractiveShell.instance()
_ipython_version = (0, 11)
# This conforms to IPython version 0.10
def pudb_f_v10(self, arg):
""" Debug a script (like %run -d) in the IPython process, using PuDB.
Usage:
%pudb test.py [args]
Run script test.py under PuDB.
"""
if not arg.strip():
print(__doc__)
def debug():
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
shell = TerminalInteractiveShell(user_ns=vars())
shell.mainloop()
def debug():
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
shell = TerminalInteractiveShell(user_ns=vars())
shell.mainloop()
