def ipython(self):
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
except ImportError:
sys.exit('You must install ipython to run this shell.')
shell = TerminalInteractiveShell()
shell.mainloop()
def remote(args, context=None):
"""Starts a shell with the datastore as remote_api_stub.
Args:
args: arguments from the user
context: locals that should be added to the shell
"""
if not context:
context = {}
app_id = args[0]
host = args[1] if len(args) > 1 else None
setupRemote(app_id, host)
context['deepFetch'] = deepFetch
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell(user_ns=context)
shell.mainloop()
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=context)
shell.mainloop()
except ImportError:
# IPython not found, use the vanilla interpreter shell
code.interact('App Engine interactive console for %s' % (app_id, ),
None, context)
def call_actuation_console(self):
"""
Start an interactive python console with the local variables and names preloaded
into the environment
"""
local_vars = {}
for k in self.vars.iterkeys():
local_vars[k[1:]] = self.vars[k]
local_vars['api'] = lambda x: get_methods(x)
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
from IPython.frontend.terminal.ipapp import load_default_config
config = load_default_config()
console = TerminalInteractiveShell(config=config, user_ns=local_vars)
console.mainloop()
except ImportError:
console = code.InteractiveConsole(local_vars)
console.interact()
def handle_noargs(self, **options):
# XXX: (Temporary) workaround for ticket #1796: force early loading of all
# models from installed apps.
from google.appengine._internal.django.db.models.loading import get_models
loaded_models = get_models()
use_plain = options.get('plain', False)
try:
if use_plain:
# Don't bother loading IPython, because the user wants plain Python.
raise ImportError
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell()
shell.mainloop()
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
except ImportError:
import code
# 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.
imported_objects = {}
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 not use_plain:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
try:
exec(
compile(
open(pythonrc, "rb").read(), pythonrc, 'exec'))
except NameError:
pass
# This will import .pythonrc.py as a side-effect
import user
code.interact(local=imported_objects)
def remote(args, context=None):
"""Starts a shell with the datastore as remote_api_stub.
Args:
args: arguments from the user
context: locals that should be added to the shell
"""
if not context:
context = {}
app_id = args[0]
host = args[1] if len(args) > 1 else None
setupRemote(app_id, host)
context['deepFetch'] = deepFetch
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell(user_ns=context)
shell.mainloop()
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=context)
shell.mainloop()
except ImportError:
# IPython not found, use the vanilla interpreter shell
code.interact('App Engine interactive console for %s' % (app_id,), None, context)
def run_ipython(local):
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell(user_ns=local)
shell.mainloop()
except ImportError:
# IPython < 0.11
# Explicitly pass an empty list as arguments, because otherwise
# IPython would use sys.argv from this script.
from IPython.Shell import IPShell
shell = IPShell(argv=[], user_ns=local)
shell.mainloop()
def shell(use_plain=False, namespace=None):
if namespace is None:
namespace = {}
try:
if use_plain:
# Don't bother loading IPython, because the user wants plain Python.
raise ImportError
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell()
shell.mainloop()
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=namespace)
shell.mainloop()
except ImportError:
# IPython not found at all, raise ImportError
raise
except ImportError:
import code
# 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.
imported_objects = {}
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 not use_plain:
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=namespace)
def handle_noargs(self, **options):
# XXX: (Temporary) workaround for ticket #1796: force early loading of all
# models from installed apps.
from google.appengine._internal.django.db.models.loading import get_models
loaded_models = get_models()
use_plain = options.get('plain', False)
try:
if use_plain:
# Don't bother loading IPython, because the user wants plain Python.
raise ImportError
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell()
shell.mainloop()
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
except ImportError:
import code
# 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.
imported_objects = {}
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 not use_plain:
pythonrc = os.environ.get("PYTHONSTARTUP")
if pythonrc and os.path.isfile(pythonrc):
try:
exec(compile(open(pythonrc).read(), pythonrc, 'exec'))
except NameError:
pass
# This will import .pythonrc.py as a side-effect
import user
code.interact(local=imported_objects)
def ipython(self):
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell()
shell.mainloop()
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 handle_noargs(self, **options):
# XXX: (Temporary) workaround for ticket #1796: force early loading of all
# models from installed apps.
from django.db.models.loading import get_models, get_apps
loaded_models = get_models()
use_plain = options.get('plain', False)
from django.conf import settings
imported_objects = {'settings': settings}
import_messages = []
for app_mod in get_apps():
app_models = get_models(app_mod)
if not app_models:
continue
model_labels = []
for model in app_models:
name = model.__name__
while name in imported_objects:
name += '_'
imported_objects[name] = model
if model.__name__ == name:
model_labels.append(name)
else:
model_labels.append("{} as {}".format(
model.__name__, name))
import_messages.append(
"Models from '%s': %s"
"" %
(app_mod.__name__.split('.')[-2], ", ".join(model_labels)))
try:
if use_plain:
# Don't bother loading IPython, because the user wants plain
# Python.
raise ImportError
try:
from tempfile import mkstemp
_, tmp_name = mkstemp(suffix='.py')
tmp = open(tmp_name, 'w')
try:
tmp.write("\n".join(
(('raise Warning, "%s"' if line.startswith("Failed")
else 'print "%s"') % line
for line in import_messages)))
finally:
tmp.close()
try:
from bpython import cli
cli.main(args=['--interactive', tmp_name],
locals_=imported_objects)
finally:
os.unlink(tmp_name)
except ImportError:
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell()
shell.mainloop()
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
except ImportError:
import code
# 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.
for msg in import_messages:
print msg
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 not use_plain:
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):
# XXX: (Temporary) workaround for ticket #1796: force early loading of all
# models from installed apps.
from django.db.models.loading import get_models, get_apps
loaded_models = get_models()
use_plain = options.get('plain', False)
from django.conf import settings
imported_objects = {'settings': settings}
import_messages = []
for app_mod in get_apps():
app_models = get_models(app_mod)
if not app_models:
continue
model_labels = []
for model in app_models:
name = model.__name__
while name in imported_objects:
name += '_'
imported_objects[name] = model
if model.__name__ == name:
model_labels.append(name)
else:
model_labels.append("{} as {}".format(model.__name__, name))
import_messages.append("Models from '%s': %s"
"" % (app_mod.__name__.split('.')[-2], ", ".join(model_labels)))
try:
if use_plain:
# Don't bother loading IPython, because the user wants plain
# Python.
raise ImportError
try:
from tempfile import mkstemp
_, tmp_name = mkstemp(suffix='.py')
tmp = open(tmp_name, 'w')
try:
tmp.write("\n".join((('raise Warning, "%s"' if
line.startswith("Failed") else 'print "%s"') % line for
line in import_messages)))
finally:
tmp.close()
try:
from bpython import cli
cli.main(args=['--interactive', tmp_name],
locals_=imported_objects)
finally:
os.unlink(tmp_name)
except ImportError:
try:
from IPython.frontend.terminal.embed import TerminalInteractiveShell
shell = TerminalInteractiveShell()
shell.mainloop()
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
except ImportError:
import code
# 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.
for msg in import_messages:
print msg
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 not use_plain:
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)
