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 command(self, IPShell=_marker):
if IPShell is _marker:
try: #pragma no cover
from IPython.Shell import IPShell
except ImportError: #pragma no cover
IPShell = None
cprt =('Type "help" for more information. "root" is the Pyramid app '
'root object, "registry" is the Pyramid registry object.')
banner = "Python %s on %s\n%s" % (sys.version, sys.platform, cprt)
config_file, section_name = self.args
self.logging_file_config(config_file)
app = self.get_app(config_file, section_name, loadapp=self.loadapp[0])
root, closer = self.get_root(app)
shell_globals = {'root':root, 'registry':app.registry}
if IPShell is not None and not self.options.disable_ipython:
try:
shell = IPShell(argv=[], user_ns=shell_globals)
shell.IP.BANNER = shell.IP.BANNER + '\n\n' + banner
shell.mainloop()
finally:
closer()
else:
try:
self.interact[0](banner, local=shell_globals)
finally:
closer()
def command(self, IPShell=_marker):
# IPShell passed to command method is for testing purposes
if IPShell is _marker: # pragma: no cover
try:
from IPython.Shell import IPShell
except ImportError:
IPShell = None
cprt = ('Type "help" for more information. "root" is the Pyramid app '
'root object, "registry" is the Pyramid registry object.')
banner = "Python %s on %s\n%s" % (sys.version, sys.platform, cprt)
config_file, section_name = self.args
self.logging_file_config(config_file)
app = self.get_app(config_file, section_name, loadapp=self.loadapp[0])
root, closer = self.get_root(app)
shell_globals = {'root': root, 'registry': app.registry}
if (IPShell is None) or self.options.disable_ipython:
try:
self.interact[0](banner, local=shell_globals)
finally:
closer()
else:
try:
shell = IPShell(argv=[], user_ns=shell_globals)
shell.IP.BANNER = shell.IP.BANNER + '\n\n' + banner
shell.mainloop()
finally:
closer()
def ipython():
try:
from IPython import embed
embed()
except ImportError:
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
def _ipython_pre_011():
"""Start IPython pre-0.11"""
from IPython.Shell import IPShell # pylint: disable=import-error,no-name-in-module
user_ns = get_start_namespace()
if user_ns:
ipy_shell = IPShell(argv=[], user_ns=user_ns)
else:
ipy_shell = IPShell(argv=[])
ipy_shell.mainloop()
def _ipython_pre_011(self):
"""Start IPython pre-0.11"""
from IPython.Shell import IPShell
user_ns = self.get_start_namespace()
if user_ns:
shell = IPShell(argv=[], user_ns=user_ns)
else:
shell = IPShell(argv=[])
shell.mainloop()
def debug_shell(user_ns, user_global_ns): ipshell = None try: from IPython.Shell import IPShellEmbed,IPShell ipshell = IPShell(argv=[], user_ns=user_ns, user_global_ns=user_global_ns) except: pass if ipshell: #ipshell() ipshell.mainloop() else: simple_debug_shell(user_global_ns, user_ns)
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()
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()
def ipython(self):
try:
from IPython import embed
embed()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
try:
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
def ipython(self):
try:
from IPython import embed
embed()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
try:
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
def ipython(self):
try:
from IPython.frontend.terminal.ipapp import TerminalIPythonApp
app = TerminalIPythonApp.instance()
app.initialize(argv=[])
app.start()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
try:
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
def ipython(self):
try:
from IPython.frontend.terminal.ipapp import TerminalIPythonApp
app = TerminalIPythonApp.instance()
app.initialize(argv=[])
app.start()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
try:
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
def ipython(self):
try:
# from IPython import embed
# embed()
import sys
sys.argv=['ipython', 'console']
from IPython.frontend.terminal.ipapp import launch_new_instance
launch_new_instance()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
try:
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
def interactive_mode(localvars=None, globalvars=None, IPOFF=False, argv=None):
"""A very simple function to embed an interactive interpreter into movpy."""
# FIXME: could have the banner passed in as an optional argument
# plus maybe the IPython config file location
if localvars is not None and globalvars is None:
globalvars = localvars
#
try:
from IPython.Shell import IPShell
except ImportError:
IPShell = None
# NOTE: psyco and IPython are incompatible
if (IPShell is None) or (IPOFF or psycofullon()):
if localvars is None:
# extract locals from the calling frame - taken from IPython
localvars = sys._getframe(0).f_back.f_locals
from code import InteractiveConsole
con = InteractiveConsole(localvars)
con.interact()
else:
banner = ('Movable Python\nIPython Interactive Shell. See the manual '
'for a list of features and tips.\nCtrl-D to exit.')
# where to find the ipython config file
if libdir:
argv = ['-ipythondir', libdir] + (argv or [])
try:
ipshell = IPShell(argv, user_ns=localvars, user_global_ns=globalvars)
ipshell.mainloop(banner=banner)
except AttributeError, e:
print e
# if psyco is on, IPython will fail immediately with an AttributeError
if localvars is None:
# extract locals from the calling frame - taken from IPython
localvars = sys._getframe(0).f_back.f_locals
from code import InteractiveConsole
con = InteractiveConsole(localvars)
con.interact()
def command(self, IPShell=_marker):
# IPShell passed to command method is for testing purposes
if IPShell is _marker: # pragma: no cover
try:
from IPython.Shell import IPShell
except ImportError:
IPShell = None
config_uri = self.args[0]
config_file = config_uri.split('#', 1)[0]
self.logging_file_config(config_file)
self.pshell_file_config(config_file)
# bootstrap the environ
env = self.bootstrap[0](config_uri)
# remove the closer from the env
closer = env.pop('closer')
# setup help text for default environment
env_help = dict(env)
env_help['app'] = 'The WSGI application.'
env_help['root'] = 'Root of the default resource tree.'
env_help['registry'] = 'Active Pyramid registry.'
env_help['request'] = 'Active request object.'
env_help['root_factory'] = (
'Default root factory used to create `root`.')
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# generate help text
help = '\n'
if env_help:
help += 'Environment:'
for var in sorted(env_help.keys()):
help += '\n %-12s %s' % (var, env_help[var])
if self.object_help:
help += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
help += '\n %-12s %s' % (var, self.object_help[var])
help += '\n'
if (IPShell is None) or self.options.disable_ipython:
cprt = 'Type "help" for more information.'
banner = "Python %s on %s\n%s" % (sys.version, sys.platform, cprt)
banner += '\n' + help
try:
self.interact[0](banner, local=env)
finally:
closer()
else:
try:
shell = IPShell(argv=[], user_ns=env)
shell.IP.BANNER = shell.IP.BANNER + help
shell.mainloop()
finally:
closer()
import os
def debug_shell(user_ns, user_global_ns): from IPython.Shell import IPShellEmbed,IPShell ipshell = IPShell(argv=[], user_ns=user_ns, user_global_ns=user_global_ns) #ipshell() ipshell.mainloop()
def command(self, IPShell=_marker):
# IPShell passed to command method is for testing purposes
if IPShell is _marker: # pragma: no cover
try:
from IPython.Shell import IPShell
except ImportError:
IPShell = None
cprt = 'Type "help" for more information.'
banner = "Python %s on %s\n%s" % (sys.version, sys.platform, cprt)
app_spec = self.args[0]
config_file = app_spec.split('#', 1)[0]
self.logging_file_config(config_file)
app = self.get_app(app_spec, loadapp=self.loadapp[0])
# load default globals
shell_globals = {
'app': app,
}
default_variables = {'app': 'The WSGI Application'}
if hasattr(app, 'registry'):
root, closer = self.get_root(app)
shell_globals.update({'root':root, 'registry':app.registry,
'settings': app.registry.settings})
default_variables.update({
'root': 'The root of the default resource tree.',
'registry': 'The Pyramid registry object.',
'settings': 'The Pyramid settings object.',
})
warning = ''
else:
# warn the user that this isn't actually the Pyramid app
warning = """\n
WARNING: You have loaded a generic WSGI application, therefore the "root",
"registry", and "settings" global variables are not available. To correct
this, run "pshell" again and specify the INI section containing your Pyramid
application. For example, if your app is in the '[app:myapp]' config file
section, use 'development.ini#myapp' instead of 'development.ini' or
'development.ini#main'."""
closer = lambda: None
# load the pshell section of the ini file
self.pshell_file_config(config_file)
shell_globals.update(self.loaded_objects)
# eliminate duplicates from default_variables
for k in self.loaded_objects:
if k in default_variables:
del default_variables[k]
# append the loaded variables
if default_variables:
banner += '\n\nDefault Variables:'
for var, txt in default_variables.iteritems():
banner += '\n %-12s %s' % (var, txt)
if self.object_help:
banner += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
banner += '\n %-12s %s' % (var, self.object_help[var])
# append the warning
banner += warning
banner += '\n'
if (IPShell is None) or self.options.disable_ipython:
try:
self.interact[0](banner, local=shell_globals)
finally:
closer()
else:
try:
shell = IPShell(argv=[], user_ns=shell_globals)
shell.IP.BANNER = shell.IP.BANNER + '\n\n' + banner
shell.mainloop()
finally:
closer()
def launch_ipython():
imported_objects = get_launch_args(**options)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
def run_ipython():
imported_objects = import_objects(options, self.style)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
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 debug_shell(user_ns, user_global_ns):
from IPython.Shell import IPShellEmbed, IPShell
ipshell = IPShell(argv=[], user_ns=user_ns, user_global_ns=user_global_ns)
#ipshell()
ipshell.mainloop()
def _ipython_pre_011(self):
"""Start IPython pre-0.11"""
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
def _ipython_pre_011(self):
"""Start IPython pre-0.11"""
from IPython.Shell import IPShell
shell = IPShell(argv=[])
shell.mainloop()
def IPythonShell(namespace, banner):
from IPython.Shell import IPShell
ipshell = IPShell(user_ns=namespace)
ipshell.mainloop(banner=banner)
def handle(self, **options):
# XXX: (Temporary) workaround for ticket #1796: force early loading of all
# models from installed apps. (this is fixed by now, but leaving it here
# for people using 0.96 or older trunk (pre [5919]) versions.
from django.apps import apps
# loaded_models = apps.get_models()
use_ipython = options.get('ipython', False)
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' % execution_time
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.
from django.conf import settings
from django.utils.module_loading import import_module
imported_objects = {'settings': settings, 'import_module': import_module}
dont_load_cli = options.get('dont_load') # optparse will set this to [] if it doensnt exists
dont_load_conf = getattr(settings, 'SHELL_PLUS_DONT_LOAD', [])
dont_load = dont_load_cli + dont_load_conf
# model_aliases = getattr(settings, 'SHELL_PLUS_MODEL_ALIASES', {})
for app_mod in [import_module(appname) for appname in settings.INSTALLED_APPS]:
app_models = apps.get_models(app_mod)
if not app_models:
continue
app_name = app_mod.__name__
if app_name in dont_load:
continue
model_labels = []
for model in app_models:
alias = model.__name__
imported_objects[alias] = model
model_labels.append(model.__name__)
print self.style.SQL_COLTYPE("From '%s' autoload: %s" % (app_mod.__name__, ", ".join(model_labels)))
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
embed(imported_objects)
except ImportError:
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.
try:
from IPython.Shell import IPShell
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
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 embed():
shell = IPShell(argv=[])
shell.mainloop()
def run_ipython():
imported_objects = self.get_imported_objects(options)
shell = IPShell(argv=[], user_ns=imported_objects)
shell.mainloop()
def embed():
shell = IPShell(argv=[])
shell.mainloop()
