Python code 模块，interact() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用code.interact()。
def interactive(self):
utils.set_prompt(ps1="(rudra) ", ps2="... ")
import os
import readline
import rlcompleter
import atexit
histfile = os.path.join(os.environ["HOME"], ".rudrahistory")
if os.path.isfile(histfile):
readline.read_history_file(histfile)
atexit.register(readline.write_history_file, histfile)
r = self
print "Use the \"r\" object to analyze files"
vars = globals()
vars.update(locals())
readline.set_completer(rlcompleter.Completer(vars).complete)
readline.parse_and_bind("tab: complete")
del os, histfile, readline, rlcompleter, atexit
code.interact(banner="", local=vars)
def do_python(self,arg):
""" start the local python interpreter (for debugging purposes) """
orig_exit=builtins.exit
orig_quit=builtins.quit
def disabled_exit(*args, **kwargs):
self.display_warning("exit() disabled ! use ctrl+D to exit the python shell")
builtins.exit=disabled_exit
builtins.quit=disabled_exit
oldcompleter=readline.get_completer()
try:
local_ns={"pupsrv":self.pupsrv}
readline.set_completer(pythoncompleter(local_ns=local_ns).complete)
readline.parse_and_bind('tab: complete')
code.interact(local=local_ns)
except Exception as e:
self.display_error(str(e))
finally:
readline.set_completer(oldcompleter)
readline.parse_and_bind('tab: complete')
builtins.exit=orig_exit
builtins.quit=orig_quit
def handle(self, **options):
print('... starting jawaf shell ...')
waf = Jawaf(settings.PROJECT_NAME)
# Use IPython if it exists
try:
import IPython
IPython.embed()
return
except ImportError:
pass
# Use bypython if it exists
try:
import bpython
bpython.embed()
return
except ImportError:
pass
# Ok,just do the pumpkin spice python shell.
import code
code.interact(local=locals())
def do_python(self, **kwargs):
self.display_warning("exit() disabled ! use ctrl+D to exit the python shell")
builtins.exit=disabled_exit
builtins.quit=disabled_exit
oldcompleter=readline.get_completer()
try:
local_ns={"pupsrv":self.pupsrv}
readline.set_completer(pythoncompleter(local_ns=local_ns).complete)
readline.parse_and_bind('tab: complete')
code.interact(local=local_ns)
except Exception as e:
self.display_error(str(e))
finally:
readline.set_completer(oldcompleter)
readline.parse_and_bind('tab: complete')
builtins.exit=orig_exit
builtins.quit=orig_quit
def shell(env):
"""Runs a dummy generator."""
import code
banner = 'Python %s on %s\nEnvironment: %s' % (
sys.version,
sys.platform,
env,
)
ctx = {}
# Support the regular Python interpreter startup script if someone
# is using it.
startup = os.environ.get('PYTHONSTARTUP')
if startup and os.path.isfile(startup):
with open(startup, 'r') as f:
eval(compile(f.read(), startup, 'exec'), ctx)
ctx['env'] = env
code.interact(banner=banner, local=ctx)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--package', action='append')
parser.add_argument('--dir', action='append')
parser.add_argument('-m', action='store', Metavar='MODULE')
args, rest = parser.parse_kNown_args()
if args.package:
PACKAGES.extend(args.package)
if args.dir:
Dirs.extend(os.path.abspath(d) for d in args.dir)
if not PACKAGES and not Dirs:
Dirs.append(os.getcwd())
if args.m:
sys.argv[1:] = rest
runpy.run_module(args.m, run_name='__main__', alter_sys=True)
elif rest:
sys.argv = rest
converted = maybe_2to3(rest[0])
with open(converted) as f:
new_globals = dict(__name__='__main__',
__file__=rest[0])
exec(f.read(), new_globals)
else:
import code
code.interact()
def interact(pid=0, server=None, trace=None):
"""
Just a cute and dirty way to get a tracer attached to a pid
and get a python interpreter instance out of it.
"""
global remote
remote = server
if trace is None:
trace = getTrace()
if pid:
trace.attach(pid)
mylocals = {"trace": trace}
code.interact(local=mylocals)
def do_python(self, line):
"""
Start an interactive python interpreter. The namespace of the
interpreter is updated with expression niceties. You may also
specify a line of python code as an argument to be exec'd without
beginning an interactive python interpreter on the controlling
terminal.
Usage: python [pycode]
"""
locals = self.getExpressionLocals()
if len(line) != 0:
cobj = compile(line, 'cli_input', 'exec')
exec(cobj, locals)
else:
code.interact(local=locals)
def start_console(self):
# Set up initial console environment
console_env = {
'ad': self._ad,
'pprint': pprint.pprint,
}
# Start the services
self._start_services(console_env)
# Start the console
console_banner = self._get_banner(self._ad.serial)
code.interact(banner=console_banner, local=console_env)
# Tear everything down
self._ad.stop_services()
def _spawn_python_shell(self, arg):
import winappdbg
banner = ('Python %s on %s\nType "help","copyright",'
'"credits" or "license" for more information.\n')
platform = winappdbg.version.lower()
platform = 'WinAppDbg %s' % platform
banner = banner % (sys.version, platform)
local = {}
local.update(__builtins__)
local.update({
'__name__' : '__console__',
'__doc__' : None,
'exit' : self._python_exit,
'self' : self,
'arg' : arg,
'winappdbg' : winappdbg,
})
try:
code.interact(banner=banner, local=local)
except SystemExit:
# We need to catch it so it doesn't kill our program.
pass
def fit(self, X, y, alpha=1):
'''??,?????P(xi|y=k),p(y=k)
Args:
X: ????,m * n
y: ??,n * 1
lambda: ????
'''
y = np.array(y)
feature_nums = len(X[0])
sample_nums = len(X)
classes_nums = len(self.classes)
self.prob_matrix = {}
self.prob_classes = {}
for k in self.classes:
# code.interact(local=locals())
sample_nums_k = len(y[y == k])
# ??p(y)
self.prob_classes[k] = (sample_nums_k + alpha) / (sample_nums + classes_nums * alpha)
# ??p(x|y)
self.prob_matrix[k] = (np.sum(X[y == k, :], axis=0) + alpha) / (sample_nums_k * feature_nums + feature_nums * alpha)
return self
def _spawn_python_shell(self, local=local)
except SystemExit:
# We need to catch it so it doesn't kill our program.
pass
def str_to_float( r ):
try:
r = r.strip().replace(',', '').replace('%','').strip()
except:
r = 'None'
try:
#try directly converting
f = float(r)
return f
except ValueError:
try:
#try brackets eg: (4500)==> -4500
f = -float(str(r).translate(None,"(),"))
# code.interact( local=locals() )
return f
except:
return 0.0
# Million returns 1; Thousand returns 0.001; Billion returns 1000;
def load_preprocess(self, filename):
print("Loading preprocessed data...")
if filename.endswith("gz"):
handle = gzip.open
else:
handle = open
with handle(filename, "rb") as f:
stored = pickle.load(f)
stored_preprocesser, self._train, self._dev, self._verified_dev = stored
if stored_preprocesser.get_config() != self.preprocesser.get_config():
# print("WARNING")
import code
code.interact(local=locals())
raise ValueError()
print("done")
def run_console():
locals = {'self': c, 'do': do}
try:
from IPython.terminal import embed
except ImportError:
import code
interact = lambda: code.interact(local=locals)
else:
from IPython.core import magic
@magic.magics_class
class AsyncMagics(magic.Magics):
@magic.line_magic
def await(self, line):
return do(eval(line, self.shell.user_global_ns,
self.shell.user_ns))
shell = embed.InteractiveShellEmbed(user_ns=locals)
shell.register_magics(AsyncMagics)
interact = shell
def check_forever(checkers):
global reload_conf_pending, interrupted, open_backdoor
schedule_checks(checkers)
logger.info("Starting infinite loop")
while not reload_conf_pending:
if interrupted:
break
if open_backdoor:
open_backdoor = False
code.interact(
banner="Kibitzr debug shell",
local=locals(),
)
schedule.run_pending()
if interrupted:
break
time.sleep(1)
def _run():
global _run
_run = lambda: None
msg = """
===================================================
Welcome to Face++ Interactive Shell!
Here,you can explore and play with Face++ APIs :)
---------------------------------------------------
Getting Started:
0. Register a user and API key on https://cloud.megvii.com/
1. Write your API key/secret in apikey.cfg
2. Start this interactive shell and try varIoUs APIs
For example,to find all faces in a local image file,just type:
api.detect(image_file = File(r'<path to the image file>'))
Enjoy!
"""
try:
from IPython import embed
embed(banner2 = msg)
except ImportError:
import code
code.interact(msg, local = globals())
def main():
kb = Keyboard()
if appex.is_widget():
appex.set_widget_view(kb.root)
else:
kb.root.present("sheet")
def read(self, size=-1):
return kb.read(size)
def readline(self):
return kb.read()
sys.stdin.__class__.read = read
sys.stdin.__class__.readline = readline
code.interact()
def encode(en_sentences, cn_sentences, en_dict, cn_dict, sort_by_len=True):
'''
Encode the sequences.
'''
length = len(en_sentences)
out_en_sentences = []
out_cn_sentences = []
for i in range(length):
# code.interact(local=locals())
en_seq = [en_dict[w] if w in en_dict else 0 for w in en_sentences[i]]
cn_seq = [cn_dict[w] if w in cn_dict else 0 for w in cn_sentences[i]]
out_en_sentences.append(en_seq)
out_cn_sentences.append(cn_seq)
# sort sentences by english lengths
def len_argsort(seq):
return sorted(range(len(seq)), key=lambda x: len(seq[x]))
if sort_by_len:
sorted_index = len_argsort(out_en_sentences)
out_en_sentences = [out_en_sentences[i] for i in sorted_index]
out_cn_sentences = [out_cn_sentences[i] for i in sorted_index]
return out_en_sentences, out_cn_sentences
def NativePythonSupport(user_session):
"""Launch the rekall session using the native python interpreter.
Returns:
False if we Failed to use IPython. True if the session was run and exited.
"""
# If the ipython shell is not available,we can use the native python shell.
import code
# Try to enable tab completion
try:
import rlcompleter, readline # pylint: disable=unused-variable
readline.parse_and_bind("tab: complete")
except ImportError:
pass
# Prepare the session for running within the native python interpreter.
user_session.PrepareLocalNamespace()
code.interact(banner=constants.BANNER, local=user_session.locals)
def run(self, no_ipython, no_bpython):
"""
Runs the shell. If no_bpython is False or use_bpython is True,then
a BPython shell is run (if installed). Else,if no_ipython is False or
use_python is True then a IPython shell is run (if installed).
"""
context = self.get_context()
if not no_bpython:
# Try BPython
try:
from bpython import embed
embed(banner=self.banner, locals_=context)
return
except ImportError:
pass
if not no_ipython:
# Try IPython
try:
try:
# 0.10.x
from IPython.Shell import IPShellEmbed
ipshell = IPShellEmbed(banner=self.banner)
ipshell(global_ns=dict(), local_ns=context)
except ImportError:
# 0.12+
from IPython import embed
embed(banner1=self.banner, user_ns=context)
return
except ImportError:
pass
# Use basic python shell
code.interact(self.banner, local=context)
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version,
app.import_name,
app.debug and ' [debug]' or '',
app.instance_path, ctx)
ctx.update(app.make_shell_context())
code.interact(banner=banner, local=ctx)
def main():
opts = command_line()
print('Connecting...')
client = create_client_from_config(opts)
print('Connected.')
banner = '\nIMAPClient instance is "c"'
def ipython_011(c):
from IPython.frontend.terminal.embed import InteractiveShellEmbed
ipshell = InteractiveShellEmbed(banner1=banner)
ipshell('')
def ipython_010(c):
from IPython.Shell import IPShellEmbed
IPShellEmbed('', banner=banner)()
def builtin(c):
import code
code.interact(banner, local=dict(c=c))
for shell_attempt in (ipython_011, ipython_010, builtin):
try:
shell_attempt(client)
break
except ImportError:
pass
def run_plain(imported_objects):
import code
code.interact(local=imported_objects)
def handle(self, **options):
try:
if options['plain']:
# Don't bother loading IPython,because the user wants plain Python.
raise ImportError
self.run_shell(shell=options['interface'])
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 .pythonrc.py.
if not options['no_startup']:
for pythonrc in (os.environ.get("PYTHONSTARTUP"), '~/.pythonrc.py'):
if not pythonrc:
continue
pythonrc = os.path.expanduser(pythonrc)
if not os.path.isfile(pythonrc):
continue
try:
with open(pythonrc) as handle:
exec(compile(handle.read(), pythonrc, imported_objects)
except NameError:
pass
code.interact(local=imported_objects)
def python(self, options):
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.
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)
# Enable tab completion on systems using libedit (e.g. Mac OSX).
# These lines are copied from Lib/site.py on Python 3.4.
readline_doc = getattr(readline, '__doc__', '')
if readline_doc is not None and 'libedit' in readline_doc:
readline.parse_and_bind("bind ^I rl_complete")
else:
readline.parse_and_bind("tab:complete")
# We want to honor both $PYTHONSTARTUP and .pythonrc.py,so follow system
# conventions and get $PYTHONSTARTUP first then .pythonrc.py.
if not options['no_startup']:
for pythonrc in (os.environ.get("PYTHONSTARTUP"), '~/.pythonrc.py'):
if not pythonrc:
continue
pythonrc = os.path.expanduser(pythonrc)
if not os.path.isfile(pythonrc):
continue
try:
with open(pythonrc) as handle:
exec(compile(handle.read(), imported_objects)
except NameError:
pass
code.interact(local=imported_objects)
def run(self, shell=None):
"""Runs a Python interactive interpreter."""
if not shell:
shell = 'bpython'
if shell == 'bpython':
try:
import bpython
bpython.embed()
except ImportError:
shell = 'ipython'
if shell == 'ipython':
try:
from IPython import embed
embed()
except ImportError:
# Ipython < 0.11
try:
import IPython
# Explicitly pass an empty list as arguments,because
# otherwise IPython would use sys.argv from this script.
shell = IPython.Shell.IPShell(argv=[])
shell.mainloop()
except ImportError:
# no IPython module
shell = 'python'
if shell == 'python':
import code
try:
# Try activating rlcompleter,
# because we already kNow 'readline' was imported successfully.
import rlcompleter # noqa
readline.parse_and_bind("tab:complete")
code.interact()
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
def run_command(args):
from drift.appmodule import app
import code
code.interact(local=locals())
def do_python(self, line):
"""Open a full python shell if "python" was typed in the command line. From here,you can
look at and manipulate any variables in the application. This can be used to look at this
instance's "self.app" variable which contains the game object.
Usage:
python
"""
print("Available variables:")
print("self.pp.pprint(self.__dict__)")
self.pp.pprint(self.__dict__)
code.interact(local=locals())
def python(self,because
# we already kNow 'readline' was imported successfully.
import rlcompleter
readline.set_completer(rlcompleter.Completer(imported_objects).complete)
# Enable tab completion on systems using libedit (e.g. macOS).
# These lines are copied from Lib/site.py on Python 3.4.
readline_doc = getattr(readline,so follow system
# conventions and get $PYTHONSTARTUP first then .pythonrc.py.
if not options['no_startup']:
for pythonrc in OrderedSet([os.environ.get("PYTHONSTARTUP"), os.path.expanduser('~/.pythonrc.py')]):
if not pythonrc:
continue
if not os.path.isfile(pythonrc):
continue
try:
with open(pythonrc) as handle:
exec(compile(handle.read(), imported_objects)
except NameError:
pass
code.interact(local=imported_objects)
def interact(conn):
"""remote interactive interpreter
:param conn: the RPyC connection
:param namespace: the namespace to use (a ``dict``)
"""
with redirected_stdio(conn):
conn.execute("""def _rinteract():
def new_exit():
print "use ctrl+D to exit the interactive python interpreter."
import code
code.interact(local = dict({"exit":new_exit,"quit":new_exit}))""")
conn.namespace["_rinteract"]()
def python(self, imported_objects)
except NameError:
pass
code.interact(local=imported_objects)
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
def __call__(self, twitter, options):
upload = Twitter(
auth=twitter.auth,
domain="upload.twitter.com")
printNicely(
"\nUse the 'twitter' object to interact with"
" the Twitter REST API.\n"
"Use twitter_upload to interact with "
"upload.twitter.com\n\n")
code.interact(local={
"twitter": twitter,
"t": twitter,
"twitter_upload": upload,
"u": upload
})
def iter_raw_results(self):
"""
Iterate over the contents of the results file and return strings containing one result entry
each.
:return: A generator for iterating over the contents of the results file and returning strings containing
one result entry each
"""
with open(self.file_path, "r") as f:
current_entry = ""
for line in f:
line = line.strip()
if not line:
continue
current_entry = current_entry + line
try:
int(current_entry[-1])
yield current_entry
current_entry = ""
except ValueError:
pass
except Exception:
import code
code.interact(local=locals())
# Protected Methods
# Private Methods
# Properties
def interact(conn):
"""remote interactive interpreter
:param conn: the RPyC connection
:param namespace: the namespace to use (a ``dict``)
"""
with redirected_stdio(conn):
conn.execute("""def _rinteract():
def new_exit():
print "use ctrl+D to exit the interactive python interpreter."
import code
code.interact(local = dict({"exit":new_exit,"quit":new_exit}))""")
conn.namespace["_rinteract"]()
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
def handle(self, *args, **options):
use_plain = options.get('plain', False)
show_imports = options.get('show_imports', True)
imported_objects = self.import_objects(show_imports)
try:
if use_plain:
# Don't bother loading IPython,because the user wants plain Python.
raise ImportError
from IPython import start_ipython
except ImportError:
# Plain
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.
try: # Try activating rlcompleter,because
# we already kNow 'readline' was imported successfully.
import rlcompleter
readline.set_completer(rlcompleter.Completer(imported_objects).complete)
readline.parse_and_bind("tab:complete")
code.interact(banner='', local=imported_objects)
else:
# IPython
start_ipython(argv=['--no-banner', '--no-confirm-exit'], user_ns=imported_objects)
def shell_command():
"""Runs an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configuring the application.
"""
import code
from flask.globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
sys.version, local=ctx)
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
