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)