def run_ipython():
import IPython
from IPython.frontend.terminal.embed import InteractiveShellEmbed
from django.conf import settings
try:
imported_objects = import_objects(options, self.style)
cfgfile = "%s/.config/ipython/profile_default/ipython_config.py" % os.environ['HOME']
cfg = IPython.config.loader.PyFileConfigLoader(cfgfile).load_config()
appname = "Welcome to the %s Shell.\n" % getattr(settings, "APPLICATION_NAME", "")
ipshell = InteractiveShellEmbed(config=cfg, banner1=appname, user_ns=imported_objects)
# An example how to define magics
# the function _toggle_logging has to be provided by the PYTHONSTARTUP script,
# see django_extensions/management/shells.py
try:
ipshell.define_magic('toggle_logging', imported_objects['_toggle_logging'])
except:
pass
ipshell()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
# Notebook not supported for IPython < 0.11.
from IPython.Shell import IPShell
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
def run_ipython():
try:
from IPython import embed
imported_objects = import_objects(options, self.style)
embed(user_ns=imported_objects)
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
# Notebook not supported for IPython < 0.11.
from IPython.Shell import IPShell
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
def run_ipython():
try:
from IPython import embed
imported_objects = import_objects(options, self.style)
embed(user_ns=imported_objects)
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
# Notebook not supported for IPython < 0.11.
from IPython.Shell import IPShell
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
def run_kernel():
imported_objects = import_objects(options, self.style)
kwargs = dict(argv=[], user_ns=imported_objects)
connection_file = options.get("connection_file")
if connection_file:
kwargs["connection_file"] = connection_file
start_kernel(**kwargs)
def run_plain():
# Using normal Python shell
import code
imported_objects = import_objects(options, self.style)
try:
# Try activating rlcompleter, because it's handy.
import readline
except ImportError:
pass
else:
# We don't have to wrap the following import in a 'try', because
# we already know 'readline' was imported successfully.
import rlcompleter
readline.set_completer(
rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
# conventions and get $PYTHONSTARTUP first then import user.
if use_pythonrc:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
try:
execfile(pythonrc)
except NameError:
pass
# This will import .pythonrc.py as a side-effect
import user # NOQA
code.interact(local=imported_objects)
def run_plain():
# Using normal Python shell
import code
imported_objects = import_objects(options, self.style)
try:
# Try activating rlcompleter, because it's handy.
import readline
except ImportError:
pass
else:
# We don't have to wrap the following import in a 'try', because
# we already know 'readline' was imported successfully.
import rlcompleter
readline.set_completer(rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
# conventions and get $PYTHONSTARTUP first then import user.
if use_pythonrc:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
global_ns = {}
with open(pythonrc) as rcfile:
try:
six.exec_(compile(rcfile.read(), pythonrc, 'exec'), global_ns)
imported_objects.update(global_ns)
except NameError:
pass
# This will import .pythonrc.py as a side-effect
try:
import user # NOQA
except ImportError:
pass
code.interact(local=imported_objects)
def run_ptipython():
imported_objects = import_objects(options, self.style)
history_filename = os.path.expanduser('~/.ptpython_history')
embed(user_ns=imported_objects,
history_filename=history_filename,
vi_mode=options.get('vi_mode', False),
configure=run_config)
def start_django(reloader, main_func, *args, **kwargs):
ensure_echo_on()
main_func = check_errors(main_func)
django_main_thread = threading.Thread(target=main_func,
args=args,
kwargs=kwargs,
name='django-main-thread')
reloader_thread = ReloaderThread(reloader=reloader,
django_main_thread=django_main_thread)
try:
from django_extensions.management.shells import import_objects
except ImportError:
kernel_user_ns = {}
else:
kernel_user_ns = import_objects({'quiet_load': True}, style=None)
django_main_thread.setDaemon(True)
reloader_thread.setDaemon(True)
django_main_thread.start()
reloader_thread.start()
kernelapp.launch_new_instance(argv=[],
user_ns=kernel_user_ns,
quiet=False,
use_experimental_completions=False)
def run_kernel():
from IPython import release
if release.version_info[0] < 2:
print(self.style.ERROR("--kernel requires at least IPython version 2.0"))
return
from IPython import embed_kernel
imported_objects = import_objects(options, self.style)
embed_kernel(local_ns=imported_objects)
def load_ipython_extension(ipython):
from django.core.management.color import no_style
from django_extensions.management.shells import import_objects
imported_objects = import_objects(
options={'dont_load': []},
style=no_style(),
)
ipython.push(imported_objects)
def run_ptipython():
imported_objects = import_objects(options, self.style)
history_filename = os.path.expanduser("~/.ptpython_history")
embed(
user_ns=imported_objects,
history_filename=history_filename,
vi_mode=options.get("vi_mode", False),
configure=run_config,
)
def run_kernel():
from IPython import release
if release.version_info[0] < 2:
print(
self.style.ERROR(
"--kernel requires at least IPython version 2.0"))
return
from IPython import embed_kernel
imported_objects = import_objects(options, self.style)
embed_kernel(local_ns=imported_objects)
def run_kernel():
imported_objects = import_objects(options, self.style)
kwargs = dict(
argv=[],
user_ns=imported_objects,
)
connection_file = options.get('connection_file')
if connection_file:
kwargs['connection_file'] = connection_file
start_kernel(**kwargs)
def load_ipython_extension(ipython):
import sys
sys.path[0:0] = [
'/home/jsmits/Development/repos/delfland',
'/home/jsmits/.buildout/eggs/djangorecipe-1.3-py2.7.egg',
'/home/jsmits/.buildout/eggs/Django-1.4.3-py2.7.egg',
'/home/jsmits/.buildout/eggs/zc.recipe.egg-1.2.2-py2.7.egg',
'/home/jsmits/.buildout/eggs/zc.buildout-1.4.4-py2.7.egg',
'/usr/lib/python2.7/dist-packages',
'/home/jsmits/.buildout/eggs/simplejson-2.4.0-py2.7-linux-x86_64.egg',
'/home/jsmits/.buildout/eggs/Werkzeug-0.8.3-py2.7.egg',
'/home/jsmits/.buildout/eggs/python_memcached-1.48-py2.7.egg',
'/home/jsmits/.buildout/eggs/lizard_ui-4.16-py2.7.egg',
'/home/jsmits/.buildout/eggs/lizard_map-4.16-py2.7.egg',
'/home/jsmits/Development/repos/delfland/src/controlnext',
'/home/jsmits/.buildout/eggs/gunicorn-0.13.4-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_nose-1.1-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_extensions-1.0.1-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_celery-3.0.11-py2.7.egg',
'/home/jsmits/.buildout/eggs/South-0.7.6-py2.7.egg',
'/home/jsmits/.buildout/eggs/raven-2.0.3-py2.7.egg',
'/home/jsmits/.buildout/eggs/lizard_security-0.5-py2.7.egg',
'/home/jsmits/.buildout/eggs/docutils-0.8-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_compressor-1.2-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_staticfiles-1.2.1-py2.7.egg',
'/home/jsmits/.buildout/eggs/BeautifulSoup-3.2.1-py2.7.egg',
'/home/jsmits/.buildout/eggs/pkginfo-0.8-py2.7.egg',
'/home/jsmits/.buildout/eggs/mock-0.8.0-py2.7.egg',
'/home/jsmits/.buildout/eggs/lizard_help-0.4-py2.7.egg',
'/home/jsmits/.buildout/eggs/iso8601-0.1.4-py2.7.egg',
'/home/jsmits/.buildout/eggs/djangorestframework-2.1.12-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_piston-0.2.2-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_jsonfield-0.8.11-py2.7.egg',
'/home/jsmits/.buildout/eggs/Pillow-1.7.7-py2.7-linux-x86_64.egg',
'/home/jsmits/.buildout/eggs/factory_boy-1.2.0-py2.7.egg',
'/home/jsmits/.buildout/eggs/pandas-0.10.1-py2.7-linux-x86_64.egg',
'/home/jsmits/.buildout/eggs/lizard_fewsjdbc-2.14-py2.7.egg',
'/home/jsmits/.buildout/eggs/celery-3.0.11-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_tls-0.0.2-py2.7.egg',
'/home/jsmits/.buildout/eggs/django_appconf-0.5-py2.7.egg',
'/home/jsmits/.buildout/eggs/lizard_task-0.15-py2.7.egg',
'/home/jsmits/.buildout/eggs/kombu-2.4.7-py2.7.egg',
'/home/jsmits/.buildout/eggs/billiard-2.7.3.18-py2.7-linux-x86_64.egg',
'/home/jsmits/.buildout/eggs/amqplib-1.0.2-py2.7.egg',
'/home/jsmits/.buildout/eggs/anyjson-0.3.3-py2.7.egg',
'/home/jsmits/Development/repos/delfland',
]
from django.core.management.color import no_style
from django_extensions.management.shells import import_objects
imported_objects = import_objects(options={'dont_load': []},
style=no_style())
print imported_objects
ipython.push(imported_objects)
def run_plain():
# Using normal Python shell
import code
imported_objects = import_objects(options, self.style)
try:
# Try activating rlcompleter, because it's handy.
import readline
except ImportError:
pass
else:
# We don't have to wrap the following import in a 'try', because
# we already know 'readline' was imported successfully.
import rlcompleter
readline.set_completer(
rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
# conventions and get $PYTHONSTARTUP first then import user.
if use_pythonrc:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
global_ns = {}
with open(pythonrc) as rcfile:
try:
six.exec_(compile(rcfile.read(), pythonrc, 'exec'),
global_ns)
imported_objects.update(global_ns)
except NameError:
pass
# This will import .pythonrc.py as a side-effect
try:
import user # NOQA
except ImportError:
pass
shellplus_imports = {}
spfile = 'apps/rss_feeds/management/shellplus_imports.py'
with open(spfile) as rcfile:
six.exec_(compile(rcfile.read(), spfile, 'exec'),
shellplus_imports)
imported_objects.update(shellplus_imports)
code.interact(local=imported_objects)
def get_imported_objects(self, options):
imported_objects = import_objects(options, self.style)
if self.tests_mode:
# save imported objects so we can run tests against it later
self.tests_imported_objects = imported_objects
return imported_objects
def handle_noargs(self, **options):
use_notebook = options.get('notebook', False)
use_ipython = options.get('ipython', use_notebook)
use_plain = options.get('plain', False)
use_pythonrc = not options.get('no_pythonrc', True)
if options.get("print_sql", False):
# Code from http://gist.github.com/118990
from django.db.backends import util
try:
import sqlparse
except ImportError:
sqlparse = None
class PrintQueryWrapper(util.CursorDebugWrapper):
def execute(self, sql, params=()):
starttime = time.time()
try:
return self.cursor.execute(sql, params)
finally:
raw_sql = self.db.ops.last_executed_query(self.cursor, sql, params)
execution_time = time.time() - starttime
if sqlparse:
print sqlparse.format(raw_sql, reindent=True)
else:
print raw_sql
print
print 'Execution time: %.6fs [Database: %s]' % (execution_time, self.db.alias)
print
util.CursorDebugWrapper = PrintQueryWrapper
# Set up a dictionary to serve as the environment for the shell, so
# that tab completion works on objects that are imported at runtime.
# See ticket 5082.
try:
if use_plain:
# Don't bother loading B/IPython, because the user wants plain Python.
raise ImportError
try:
if use_ipython:
# User wants IPython
raise ImportError
from bpython import embed
imported_objects = import_objects(options, self.style)
embed(imported_objects)
except ImportError:
try:
if use_notebook:
from django.conf import settings
from IPython.frontend.html.notebook import notebookapp
app = notebookapp.NotebookApp.instance()
ipython_arguments = getattr(
settings,
'IPYTHON_ARGUMENTS',
['--ext',
'django_extensions.management.notebook_extension'])
app.initialize(ipython_arguments)
app.start()
else:
from IPython import embed
imported_objects = import_objects(options, self.style)
embed(user_ns=imported_objects)
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
# Notebook not supported for IPython < 0.11.
try:
from IPython.Shell import IPShell
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
except ImportError:
# Using normal Python shell
import code
imported_objects = import_objects(options, self.style)
try:
# Try activating rlcompleter, because it's handy.
import readline
except ImportError:
pass
else:
# We don't have to wrap the following import in a 'try', because
# we already know 'readline' was imported successfully.
import rlcompleter
readline.set_completer(rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
# conventions and get $PYTHONSTARTUP first then import user.
if use_pythonrc:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
try:
execfile(pythonrc)
except NameError:
pass
# This will import .pythonrc.py as a side-effect
import user
code.interact(local=imported_objects)
def handle_noargs(self, **options):
use_notebook = options.get('notebook', False)
use_ipython = options.get('ipython', False)
use_bpython = options.get('bpython', False)
use_plain = options.get('plain', False)
use_pythonrc = not options.get('no_pythonrc', True)
auto_reload = options.get('autoreload') or getattr(
settings, 'AUTO_RELOAD_SHELL', False)
if auto_reload:
# Transparently reload modules on filesystem changes via threading
if not _listener_enabled:
raise CommandError(
"Watchdog is required to use auto reload shell_plus. Install via pip. (pip install watchdog)"
)
autoreload_path = os.environ.get(
'VIRTUAL_ENV', getattr(settings, 'PROJECT_ROOT', False))
if not autoreload_path:
raise CommandError("""To reload shell_plus automatically,
you must either work in an activated
Python VIRTUALENV or specify a path in your filesystem
as 'PROJECT_ROOT' in your Django settings"""
)
def listen_for_changes(shell_globals, project_root, model_globals):
# Begin thread which listens for file system changes via Watchdog library
event_handler = ReloaderEventHandler(
project_root=project_root,
model_globals=model_globals,
shell_globals=shell_globals)
observer_thread.schedule(event_handler,
path=project_root,
recursive=True)
observer_thread.start()
if options.get("print_sql", False):
# Code from http://gist.github.com/118990
from django.db.backends import util
sqlparse = None
try:
import sqlparse
except ImportError:
pass
class PrintQueryWrapper(util.CursorDebugWrapper):
def execute(self, sql, params=()):
starttime = time.time()
try:
return self.cursor.execute(sql, params)
finally:
execution_time = time.time() - starttime
raw_sql = self.db.ops.last_executed_query(
self.cursor, sql, params)
if sqlparse:
print sqlparse.format(raw_sql, reindent=True)
else:
print raw_sql
print
print 'Execution time: %.6fs [Database: %s]' % (
execution_time, self.db.alias)
print
util.CursorDebugWrapper = PrintQueryWrapper
global_model_scope = defaultdict(list)
imported_objects = import_objects(
options, self.style, global_model_scope=global_model_scope)
def run_notebook():
from django.conf import settings
from IPython.frontend.html.notebook import notebookapp
app = notebookapp.NotebookApp.instance()
ipython_arguments = getattr(
settings, 'IPYTHON_ARGUMENTS',
['--ext', 'django_extensions.management.notebook_extension'])
app.initialize(ipython_arguments)
app.start()
def run_plain():
# Using normal Python shell
import code
try:
# Try activating rlcompleter, because it's handy.
import readline
except ImportError:
pass
else:
# We don't have to wrap the following import in a 'try', because
# we already know 'readline' was imported successfully.
import rlcompleter
readline.set_completer(
rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
# conventions and get $PYTHONSTARTUP first then import user.
if use_pythonrc:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
try:
execfile(pythonrc)
except NameError:
pass
# This will import .pythonrc.py as a side-effect
import user # NOQA
code.interact(local=imported_objects)
def run_bpython():
from bpython import embed
embed(imported_objects)
def run_ipython():
try:
from IPython import embed
embed(user_ns=imported_objects)
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
# Notebook not supported for IPython < 0.11.
from IPython.Shell import IPShell
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
if use_notebook:
run_notebook()
else:
if auto_reload:
listen_for_changes(imported_objects, autoreload_path,
global_model_scope)
if use_plain:
run_plain()
elif use_ipython:
run_ipython()
elif use_bpython:
run_bpython()
else:
for func in (run_ipython, run_bpython, run_plain):
try:
func()
except ImportError:
continue
else:
break
else:
import traceback
traceback.print_exc()
print self.style.ERROR(
"Could not load any interactive Python environment.")
def get_imported_objects(self, options):
imported_objects = import_objects(options, self.style)
if self.tests_mode:
# save imported objects so we can run tests against it later
self.tests_imported_objects = imported_objects
return imported_objects
def run_bpython():
from bpython import embed
imported_objects = import_objects(options, self.style)
embed(imported_objects)
def run_ipython():
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
def run_ipython():
imported_objects = import_objects(options, self.style)
embed(user_ns=imported_objects)
def handle_noargs(self, **options):
use_notebook = options.get('notebook', False)
use_ipython = options.get('ipython', False)
use_bpython = options.get('bpython', False)
use_plain = options.get('plain', False)
use_pythonrc = not options.get('no_pythonrc', True)
auto_reload = options.get('autoreload') or getattr(settings, 'AUTO_RELOAD_SHELL', False)
if auto_reload:
# Transparently reload modules on filesystem changes via threading
if not _listener_enabled:
raise CommandError("Watchdog is required to use auto reload shell_plus. Install via pip. (pip install watchdog)")
autoreload_path = os.environ.get('VIRTUAL_ENV', getattr(settings, 'PROJECT_ROOT', False))
if not autoreload_path:
raise CommandError("""To reload shell_plus automatically,
you must either work in an activated
Python VIRTUALENV or specify a path in your filesystem
as 'PROJECT_ROOT' in your Django settings""")
def listen_for_changes(shell_globals, project_root, model_globals):
# Begin thread which listens for file system changes via Watchdog library
event_handler = ReloaderEventHandler(project_root=project_root, model_globals=model_globals, shell_globals=shell_globals)
observer_thread.schedule(event_handler, path=project_root, recursive=True)
observer_thread.start()
if options.get("print_sql", False):
# Code from http://gist.github.com/118990
from django.db.backends import util
sqlparse = None
try:
import sqlparse
except ImportError:
pass
class PrintQueryWrapper(util.CursorDebugWrapper):
def execute(self, sql, params=()):
starttime = time.time()
try:
return self.cursor.execute(sql, params)
finally:
execution_time = time.time() - starttime
raw_sql = self.db.ops.last_executed_query(self.cursor, sql, params)
if sqlparse:
print sqlparse.format(raw_sql, reindent=True)
else:
print raw_sql
print
print 'Execution time: %.6fs [Database: %s]' % (execution_time, self.db.alias)
print
util.CursorDebugWrapper = PrintQueryWrapper
global_model_scope = defaultdict(list)
imported_objects = import_objects(options, self.style, global_model_scope=global_model_scope)
def run_notebook():
from django.conf import settings
from IPython.frontend.html.notebook import notebookapp
app = notebookapp.NotebookApp.instance()
ipython_arguments = getattr(settings, 'IPYTHON_ARGUMENTS', ['--ext', 'django_extensions.management.notebook_extension'])
app.initialize(ipython_arguments)
app.start()
def run_plain():
# Using normal Python shell
import code
try:
# Try activating rlcompleter, because it's handy.
import readline
except ImportError:
pass
else:
# We don't have to wrap the following import in a 'try', because
# we already know 'readline' was imported successfully.
import rlcompleter
readline.set_completer(rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
# conventions and get $PYTHONSTARTUP first then import user.
if use_pythonrc:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
try:
execfile(pythonrc)
except NameError:
pass
# This will import .pythonrc.py as a side-effect
import user # NOQA
code.interact(local=imported_objects)
def run_bpython():
from bpython import embed
embed(imported_objects)
def run_ipython():
try:
from IPython import embed
embed(user_ns=imported_objects)
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
# Notebook not supported for IPython < 0.11.
from IPython.Shell import IPShell
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
if use_notebook:
run_notebook()
else:
if auto_reload:
listen_for_changes(imported_objects, autoreload_path, global_model_scope)
if use_plain:
run_plain()
elif use_ipython:
run_ipython()
elif use_bpython:
run_bpython()
else:
for func in (run_ipython, run_bpython, run_plain):
try:
func()
except ImportError:
continue
else:
break
else:
import traceback
traceback.print_exc()
print self.style.ERROR("Could not load any interactive Python environment.")
def run_ptpython():
imported_objects = import_objects(options, self.style)
history_filename = os.path.expanduser('~/.ptpython_history')
embed(globals=imported_objects, history_filename=history_filename,
vi_mode=options.get('vi_mode', False))
def run_ipython():
imported_objects = import_objects(options, self.style)
ipython_arguments = getattr(settings, 'IPYTHON_ARGUMENTS', [])
start_ipython(argv=ipython_arguments, user_ns=imported_objects)
def run_ipython():
imported_objects = import_objects(options, self.style)
ipython_arguments = self.get_ipython_arguments(options)
start_ipython(argv=ipython_arguments, user_ns=imported_objects)
def run_ipython():
imported_objects = import_objects(options, self.style)
ipython_arguments = getattr(settings, 'IPYTHON_ARGUMENTS', [])
start_ipython(argv=ipython_arguments, user_ns=imported_objects)
def run_ipython():
imported_objects = import_objects(options, self.style)
ipython_arguments = self.get_ipython_arguments(options)
start_ipython(argv=ipython_arguments,
user_ns=imported_objects)
def run_bpython():
from bpython import embed
imported_objects = import_objects(options, self.style)
embed(imported_objects)
def run_kernel():
imported_objects = import_objects(options, self.style)
if options.get('connection_file'):
start_kernel(argv=[], user_ns=imported_objects, connection_file=options.get('connection_file'))
else:
start_kernel(argv=[], user_ns=imported_objects)
def get_imported_objects(self, options):
return import_objects(options, self.style)
def run_kernel():
imported_objects = import_objects(options, self.style)
embed_kernel(local_ns=imported_objects)
def run_ipython():
imported_objects = import_objects(options, self.style)
embed(user_ns=imported_objects)
def get_imported_objects(self, options):
return import_objects(options, self.style)
def run_kernel():
imported_objects = import_objects(options, self.style)
embed_kernel(local_ns=imported_objects)
def run_ipython():
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
