basic.py
663 lines
| 22.5 KiB
| text/x-python
|
PythonLexer
|
r18585 | """Implementation of basic magic functions.""" | ||
|
r6959 | |||
|
r24463 | from logging import error | ||
|
r6959 | import io | ||
|
r27282 | import os | ||
|
r6959 | from pprint import pformat | ||
|
r24463 | import sys | ||
from warnings import warn | ||||
|
r6959 | |||
|
r24463 | from traitlets.utils.importstring import import_item | ||
|
r11124 | from IPython.core import magic_arguments, page | ||
|
r6959 | from IPython.core.error import UsageError | ||
|
r7704 | from IPython.core.magic import Magics, magics_class, line_magic, magic_escapes | ||
|
r8005 | from IPython.utils.text import format_screen, dedent, indent | ||
|
r6959 | from IPython.testing.skipdoctest import skip_doctest | ||
from IPython.utils.ipstruct import Struct | ||||
|
r10688 | class MagicsDisplay(object): | ||
|
r23362 | def __init__(self, magics_manager, ignore=None): | ||
self.ignore = ignore if ignore else [] | ||||
|
r10688 | self.magics_manager = magics_manager | ||
def _lsmagic(self): | ||||
"""The main implementation of the %lsmagic""" | ||||
mesc = magic_escapes['line'] | ||||
cesc = magic_escapes['cell'] | ||||
mman = self.magics_manager | ||||
magics = mman.lsmagic() | ||||
out = ['Available line magics:', | ||||
|
r23362 | mesc + (' '+mesc).join(sorted([m for m,v in magics['line'].items() if (v not in self.ignore)])), | ||
|
r10688 | '', | ||
'Available cell magics:', | ||||
|
r23362 | cesc + (' '+cesc).join(sorted([m for m,v in magics['cell'].items() if (v not in self.ignore)])), | ||
|
r10688 | '', | ||
mman.auto_status()] | ||||
return '\n'.join(out) | ||||
def _repr_pretty_(self, p, cycle): | ||||
p.text(self._lsmagic()) | ||||
def __str__(self): | ||||
return self._lsmagic() | ||||
def _jsonable(self): | ||||
"""turn magics dict into jsonable dict of the same structure | ||||
|
r27294 | |||
|
r10688 | replaces object instances with their class names as strings | ||
""" | ||||
magic_dict = {} | ||||
mman = self.magics_manager | ||||
magics = mman.lsmagic() | ||||
for key, subdict in magics.items(): | ||||
d = {} | ||||
magic_dict[key] = d | ||||
for name, obj in subdict.items(): | ||||
try: | ||||
|
r13370 | classname = obj.__self__.__class__.__name__ | ||
|
r10688 | except AttributeError: | ||
classname = 'Other' | ||||
d[name] = classname | ||||
return magic_dict | ||||
def _repr_json_(self): | ||||
|
r19557 | return self._jsonable() | ||
|
r10688 | |||
|
r6973 | @magics_class | ||
|
r6959 | class BasicMagics(Magics): | ||
"""Magics that provide central IPython functionality. | ||||
These are various magics that don't fit into specific categories but that | ||||
are all part of the base 'IPython experience'.""" | ||||
|
r27102 | @skip_doctest | ||
|
r7705 | @magic_arguments.magic_arguments() | ||
@magic_arguments.argument( | ||||
'-l', '--line', action='store_true', | ||||
help="""Create a line magic alias.""" | ||||
) | ||||
@magic_arguments.argument( | ||||
'-c', '--cell', action='store_true', | ||||
help="""Create a cell magic alias.""" | ||||
) | ||||
@magic_arguments.argument( | ||||
'name', | ||||
help="""Name of the magic to be created.""" | ||||
) | ||||
@magic_arguments.argument( | ||||
'target', | ||||
help="""Name of the existing line or cell magic.""" | ||||
) | ||||
|
r23639 | @magic_arguments.argument( | ||
'-p', '--params', default=None, | ||||
help="""Parameters passed to the magic function.""" | ||||
) | ||||
|
r7705 | @line_magic | ||
def alias_magic(self, line=''): | ||||
|
r7722 | """Create an alias for an existing line or cell magic. | ||
Examples | ||||
-------- | ||||
:: | ||||
|
r13604 | |||
|
r7722 | In [1]: %alias_magic t timeit | ||
|
r7934 | Created `%t` as an alias for `%timeit`. | ||
Created `%%t` as an alias for `%%timeit`. | ||||
|
r7722 | |||
In [2]: %t -n1 pass | ||||
1 loops, best of 3: 954 ns per loop | ||||
In [3]: %%t -n1 | ||||
...: pass | ||||
...: | ||||
1 loops, best of 3: 954 ns per loop | ||||
In [4]: %alias_magic --cell whereami pwd | ||||
UsageError: Cell magic function `%%pwd` not found. | ||||
In [5]: %alias_magic --line whereami pwd | ||||
|
r7934 | Created `%whereami` as an alias for `%pwd`. | ||
|
r7722 | |||
In [6]: %whereami | ||||
Out[6]: u'/home/testuser' | ||||
|
r27294 | |||
|
r25189 | In [7]: %alias_magic h history "-p -l 30" --line | ||
|
r23639 | Created `%h` as an alias for `%history -l 30`. | ||
|
r7722 | """ | ||
|
r23639 | |||
|
r7705 | args = magic_arguments.parse_argstring(self.alias_magic, line) | ||
shell = self.shell | ||||
|
r7932 | mman = self.shell.magics_manager | ||
|
r7705 | escs = ''.join(magic_escapes.values()) | ||
target = args.target.lstrip(escs) | ||||
name = args.name.lstrip(escs) | ||||
|
r23639 | params = args.params | ||
if (params and | ||||
((params.startswith('"') and params.endswith('"')) | ||||
or (params.startswith("'") and params.endswith("'")))): | ||||
params = params[1:-1] | ||||
|
r7705 | # Find the requested magics. | ||
m_line = shell.find_magic(target, 'line') | ||||
m_cell = shell.find_magic(target, 'cell') | ||||
if args.line and m_line is None: | ||||
raise UsageError('Line magic function `%s%s` not found.' % | ||||
(magic_escapes['line'], target)) | ||||
if args.cell and m_cell is None: | ||||
raise UsageError('Cell magic function `%s%s` not found.' % | ||||
(magic_escapes['cell'], target)) | ||||
# If --line and --cell are not specified, default to the ones | ||||
# that are available. | ||||
if not args.line and not args.cell: | ||||
if not m_line and not m_cell: | ||||
raise UsageError( | ||||
'No line or cell magic with name `%s` found.' % target | ||||
) | ||||
args.line = bool(m_line) | ||||
args.cell = bool(m_cell) | ||||
|
r23639 | params_str = "" if params is None else " " + params | ||
|
r7705 | if args.line: | ||
|
r23639 | mman.register_alias(name, target, 'line', params) | ||
print('Created `%s%s` as an alias for `%s%s%s`.' % ( | ||||
|
r7934 | magic_escapes['line'], name, | ||
|
r23639 | magic_escapes['line'], target, params_str)) | ||
|
r7705 | |||
if args.cell: | ||||
|
r23639 | mman.register_alias(name, target, 'cell', params) | ||
print('Created `%s%s` as an alias for `%s%s%s`.' % ( | ||||
|
r7934 | magic_escapes['cell'], name, | ||
|
r23639 | magic_escapes['cell'], target, params_str)) | ||
|
r7705 | |||
|
r6959 | @line_magic | ||
def lsmagic(self, parameter_s=''): | ||||
"""List currently available magic functions.""" | ||||
|
r24887 | return MagicsDisplay(self.shell.magics_manager, ignore=[]) | ||
|
r6959 | |||
|
r7652 | def _magic_docs(self, brief=False, rest=False): | ||
"""Return docstrings from magic functions.""" | ||||
mman = self.shell.magics_manager | ||||
docs = mman.lsmagic_docs(brief, missing='No documentation') | ||||
if rest: | ||||
|
r8005 | format_string = '**%s%s**::\n\n%s\n\n' | ||
|
r7652 | else: | ||
|
r8005 | format_string = '%s%s:\n%s\n' | ||
|
r7652 | |||
return ''.join( | ||||
|
r8005 | [format_string % (magic_escapes['line'], fname, | ||
indent(dedent(fndoc))) | ||||
|
r7652 | for fname, fndoc in sorted(docs['line'].items())] | ||
+ | ||||
|
r8005 | [format_string % (magic_escapes['cell'], fname, | ||
indent(dedent(fndoc))) | ||||
|
r7652 | for fname, fndoc in sorted(docs['cell'].items())] | ||
) | ||||
|
r6959 | @line_magic | ||
def magic(self, parameter_s=''): | ||||
"""Print information about the magic function system. | ||||
Supported formats: -latex, -brief, -rest | ||||
""" | ||||
mode = '' | ||||
try: | ||||
mode = parameter_s.split()[0][1:] | ||||
|
r6986 | except IndexError: | ||
|
r6959 | pass | ||
|
r7652 | brief = (mode == 'brief') | ||
rest = (mode == 'rest') | ||||
magic_docs = self._magic_docs(brief, rest) | ||||
|
r6959 | |||
if mode == 'latex': | ||||
print(self.format_latex(magic_docs)) | ||||
return | ||||
else: | ||||
magic_docs = format_screen(magic_docs) | ||||
out = [""" | ||||
IPython's 'magic' functions | ||||
=========================== | ||||
The magic function system provides a series of functions which allow you to | ||||
control the behavior of IPython itself, plus a lot of system-type | ||||
|
r7005 | features. There are two kinds of magics, line-oriented and cell-oriented. | ||
Line magics are prefixed with the % character and work much like OS | ||||
command-line calls: they get as an argument the rest of the line, where | ||||
arguments are passed without parentheses or quotes. For example, this will | ||||
time the given statement:: | ||||
%timeit range(1000) | ||||
Cell magics are prefixed with a double %%, and they are functions that get as | ||||
an argument not only the rest of the line, but also the lines below it in a | ||||
separate argument. These magics are called with two arguments: the rest of the | ||||
call line and the body of the cell, consisting of the lines below the first. | ||||
For example:: | ||||
%%timeit x = numpy.random.randn((100, 100)) | ||||
numpy.linalg.svd(x) | ||||
will time the execution of the numpy svd routine, running the assignment of x | ||||
as part of the setup phase, which is not timed. | ||||
In a line-oriented client (the terminal or Qt console IPython), starting a new | ||||
input with %% will automatically enter cell mode, and IPython will continue | ||||
reading input until a blank line is given. In the notebook, simply type the | ||||
whole cell as one entity, but keep in mind that the %% escape can only be at | ||||
the very start of the cell. | ||||
|
r6959 | |||
NOTE: If you have 'automagic' enabled (via the command line option or with the | ||||
|
r7005 | %automagic function), you don't need to type in the % explicitly for line | ||
magics; cell magics always require an explicit '%%' escape. By default, | ||||
|
r6959 | IPython ships with automagic on, so you should only rarely need the % escape. | ||
|
r21677 | Example: typing '%cd mydir' (without the quotes) changes your working directory | ||
|
r6959 | to 'mydir', if it exists. | ||
For a list of the available magic functions, use %lsmagic. For a description | ||||
of any of them, type %magic_name?, e.g. '%cd?'. | ||||
Currently the magic system has the following functions:""", | ||||
magic_docs, | ||||
|
r8006 | "Summary of magic functions (from %slsmagic):" % magic_escapes['line'], | ||
|
r10994 | str(self.lsmagic()), | ||
|
r6959 | ] | ||
page.page('\n'.join(out)) | ||||
@line_magic | ||||
def page(self, parameter_s=''): | ||||
"""Pretty print the object and display it through a pager. | ||||
%page [options] OBJECT | ||||
If no object is given, use _ (last output). | ||||
Options: | ||||
-r: page str(object), don't pretty-print it.""" | ||||
# After a function contributed by Olivier Aubert, slightly modified. | ||||
# Process options/args | ||||
opts, args = self.parse_options(parameter_s, 'r') | ||||
raw = 'r' in opts | ||||
oname = args and args or '_' | ||||
|
r7638 | info = self.shell._ofind(oname) | ||
|
r28213 | if info.found: | ||
|
r27871 | if raw: | ||
|
r28213 | txt = str(info.obj) | ||
|
r27871 | else: | ||
|
r28213 | txt = pformat(info.obj) | ||
|
r6959 | page.page(txt) | ||
else: | ||||
print('Object `%s` not found' % oname) | ||||
@line_magic | ||||
def pprint(self, parameter_s=''): | ||||
"""Toggle pretty printing on/off.""" | ||||
ptformatter = self.shell.display_formatter.formatters['text/plain'] | ||||
ptformatter.pprint = bool(1 - ptformatter.pprint) | ||||
print('Pretty printing has been turned', | ||||
['OFF','ON'][ptformatter.pprint]) | ||||
@line_magic | ||||
def colors(self, parameter_s=''): | ||||
"""Switch color scheme for prompts, info system and exception handlers. | ||||
Currently implemented schemes: NoColor, Linux, LightBG. | ||||
Color scheme names are not case-sensitive. | ||||
Examples | ||||
-------- | ||||
To get a plain black and white terminal:: | ||||
%colors nocolor | ||||
""" | ||||
def color_switch_err(name): | ||||
warn('Error changing %s color schemes.\n%s' % | ||||
|
r22609 | (name, sys.exc_info()[1]), stacklevel=2) | ||
|
r6959 | |||
new_scheme = parameter_s.strip() | ||||
if not new_scheme: | ||||
raise UsageError( | ||||
"%colors: you must specify a color scheme. See '%colors?'") | ||||
# local shortcut | ||||
shell = self.shell | ||||
|
r22608 | # Set shell colour scheme | ||
try: | ||||
shell.colors = new_scheme | ||||
shell.refresh_style() | ||||
except: | ||||
color_switch_err('shell') | ||||
|
r6959 | |||
# Set exception colors | ||||
try: | ||||
shell.InteractiveTB.set_colors(scheme = new_scheme) | ||||
shell.SyntaxTB.set_colors(scheme = new_scheme) | ||||
except: | ||||
color_switch_err('exception') | ||||
# Set info (for 'object?') colors | ||||
if shell.color_info: | ||||
try: | ||||
shell.inspector.set_active_scheme(new_scheme) | ||||
except: | ||||
color_switch_err('object inspector') | ||||
else: | ||||
shell.inspector.set_active_scheme('NoColor') | ||||
@line_magic | ||||
def xmode(self, parameter_s=''): | ||||
"""Switch modes for the exception handlers. | ||||
|
r24849 | Valid modes: Plain, Context, Verbose, and Minimal. | ||
|
r6959 | |||
|
r25839 | If called without arguments, acts as a toggle. | ||
|
r27689 | When in verbose mode the value `--show` (and `--hide`) | ||
|
r25839 | will respectively show (or hide) frames with ``__tracebackhide__ = | ||
True`` value set. | ||||
""" | ||||
|
r6959 | |||
def xmode_switch_err(name): | ||||
warn('Error changing %s exception modes.\n%s' % | ||||
(name,sys.exc_info()[1])) | ||||
shell = self.shell | ||||
|
r25839 | if parameter_s.strip() == "--show": | ||
shell.InteractiveTB.skip_hidden = False | ||||
return | ||||
if parameter_s.strip() == "--hide": | ||||
shell.InteractiveTB.skip_hidden = True | ||||
return | ||||
|
r6959 | new_mode = parameter_s.strip().capitalize() | ||
try: | ||||
shell.InteractiveTB.set_mode(mode=new_mode) | ||||
print('Exception reporting mode:',shell.InteractiveTB.mode) | ||||
except: | ||||
xmode_switch_err('user') | ||||
|
r23362 | @line_magic | ||
def quickref(self, arg): | ||||
|
r6959 | """ Show a quick reference sheet """ | ||
from IPython.core.usage import quick_reference | ||||
|
r7653 | qr = quick_reference + self._magic_docs(brief=True) | ||
|
r6959 | page.page(qr) | ||
@line_magic | ||||
def doctest_mode(self, parameter_s=''): | ||||
"""Toggle doctest mode on and off. | ||||
This mode is intended to make IPython behave as much as possible like a | ||||
plain Python shell, from the perspective of how its prompts, exceptions | ||||
and output look. This makes it easy to copy and paste parts of a | ||||
session into doctests. It does so by: | ||||
- Changing the prompts to the classic ``>>>`` ones. | ||||
- Changing the exception reporting mode to 'Plain'. | ||||
- Disabling pretty-printing of output. | ||||
Note that IPython also supports the pasting of code snippets that have | ||||
leading '>>>' and '...' prompts in them. This means that you can paste | ||||
doctests from files or docstrings (even if they have leading | ||||
whitespace), and the code will execute correctly. You can then use | ||||
'%history -t' to see the translated history; this will give you the | ||||
input after removal of all the leading prompts and whitespace, which | ||||
can be pasted back into an editor. | ||||
With these features, you can switch into this mode easily whenever you | ||||
need to do testing and changes to doctests, without having to leave | ||||
your existing IPython session. | ||||
""" | ||||
# Shorthands | ||||
shell = self.shell | ||||
meta = shell.meta | ||||
disp_formatter = self.shell.display_formatter | ||||
ptformatter = disp_formatter.formatters['text/plain'] | ||||
# dstore is a data store kept in the instance metadata bag to track any | ||||
# changes we make, so we can undo them later. | ||||
dstore = meta.setdefault('doctest_mode',Struct()) | ||||
save_dstore = dstore.setdefault | ||||
# save a few values we'll need to recover later | ||||
mode = save_dstore('mode',False) | ||||
save_dstore('rc_pprint',ptformatter.pprint) | ||||
save_dstore('xmode',shell.InteractiveTB.mode) | ||||
save_dstore('rc_separate_out',shell.separate_out) | ||||
save_dstore('rc_separate_out2',shell.separate_out2) | ||||
save_dstore('rc_separate_in',shell.separate_in) | ||||
|
r9814 | save_dstore('rc_active_types',disp_formatter.active_types) | ||
|
r6959 | |||
|
r21779 | if not mode: | ||
|
r6959 | # turn on | ||
# Prompt separators like plain python | ||||
shell.separate_in = '' | ||||
shell.separate_out = '' | ||||
shell.separate_out2 = '' | ||||
ptformatter.pprint = False | ||||
|
r9814 | disp_formatter.active_types = ['text/plain'] | ||
|
r6959 | |||
shell.magic('xmode Plain') | ||||
else: | ||||
# turn off | ||||
shell.separate_in = dstore.rc_separate_in | ||||
shell.separate_out = dstore.rc_separate_out | ||||
shell.separate_out2 = dstore.rc_separate_out2 | ||||
ptformatter.pprint = dstore.rc_pprint | ||||
|
r9814 | disp_formatter.active_types = dstore.rc_active_types | ||
|
r6959 | |||
shell.magic('xmode ' + dstore.xmode) | ||||
|
r22429 | # mode here is the state before we switch; switch_doctest_mode takes | ||
# the mode we're switching to. | ||||
shell.switch_doctest_mode(not mode) | ||||
|
r6959 | # Store new mode and inform | ||
|
r22429 | dstore.mode = bool(not mode) | ||
|
r6959 | mode_label = ['OFF','ON'][dstore.mode] | ||
print('Doctest mode is:', mode_label) | ||||
@line_magic | ||||
def gui(self, parameter_s=''): | ||||
"""Enable or disable IPython GUI event loop integration. | ||||
%gui [GUINAME] | ||||
This magic replaces IPython's threaded shells that were activated | ||||
using the (pylab/wthread/etc.) command line flags. GUI toolkits | ||||
can now be enabled at runtime and keyboard | ||||
interrupts should work without any problems. The following toolkits | ||||
are supported: wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX):: | ||||
%gui wx # enable wxPython event loop integration | ||||
|
r28021 | %gui qt # enable PyQt/PySide event loop integration | ||
# with the latest version available. | ||||
%gui qt6 # enable PyQt6/PySide6 event loop integration | ||||
%gui qt5 # enable PyQt5/PySide2 event loop integration | ||||
|
r6959 | %gui gtk # enable PyGTK event loop integration | ||
%gui gtk3 # enable Gtk3 event loop integration | ||||
|
r26726 | %gui gtk4 # enable Gtk4 event loop integration | ||
|
r6959 | %gui tk # enable Tk event loop integration | ||
|
r7097 | %gui osx # enable Cocoa event loop integration | ||
|
r6959 | # (requires %matplotlib 1.1) | ||
%gui # disable all event loop integration | ||||
WARNING: after any of these has been called you can simply create | ||||
an application object, but DO NOT start the event loop yourself, as | ||||
we have already handled that. | ||||
""" | ||||
opts, arg = self.parse_options(parameter_s, '') | ||||
if arg=='': arg = None | ||||
try: | ||||
|
r7091 | return self.shell.enable_gui(arg) | ||
|
r6959 | except Exception as e: | ||
# print simple error message, rather than traceback if we can't | ||||
# hook up the GUI | ||||
error(str(e)) | ||||
@skip_doctest | ||||
@line_magic | ||||
def precision(self, s=''): | ||||
"""Set floating point precision for pretty printing. | ||||
Can set either integer precision or a format string. | ||||
If numpy has been imported and precision is an int, | ||||
numpy display precision will also be set, via ``numpy.set_printoptions``. | ||||
If no argument is given, defaults will be restored. | ||||
Examples | ||||
-------- | ||||
:: | ||||
In [1]: from math import pi | ||||
In [2]: %precision 3 | ||||
Out[2]: u'%.3f' | ||||
In [3]: pi | ||||
Out[3]: 3.142 | ||||
In [4]: %precision %i | ||||
Out[4]: u'%i' | ||||
In [5]: pi | ||||
Out[5]: 3 | ||||
In [6]: %precision %e | ||||
Out[6]: u'%e' | ||||
In [7]: pi**10 | ||||
Out[7]: 9.364805e+04 | ||||
In [8]: %precision | ||||
Out[8]: u'%r' | ||||
In [9]: pi**10 | ||||
Out[9]: 93648.047476082982 | ||||
""" | ||||
ptformatter = self.shell.display_formatter.formatters['text/plain'] | ||||
ptformatter.float_precision = s | ||||
return ptformatter.float_format | ||||
@magic_arguments.magic_arguments() | ||||
@magic_arguments.argument( | ||||
|
r23044 | 'filename', type=str, | ||
|
r6959 | help='Notebook name or filename' | ||
) | ||||
@line_magic | ||||
def notebook(self, s): | ||||
"""Export and convert IPython notebooks. | ||||
|
r18585 | This function can export the current IPython history to a notebook file. | ||
|
r22796 | For example, to export the history to "foo.ipynb" do "%notebook foo.ipynb". | ||
|
r6959 | """ | ||
args = magic_arguments.parse_argstring(self.notebook, s) | ||||
|
r27282 | outfname = os.path.expanduser(args.filename) | ||
|
r6959 | |||
|
r21345 | from nbformat import write, v4 | ||
|
r22796 | |||
cells = [] | ||||
hist = list(self.shell.history_manager.get_range()) | ||||
if(len(hist)<=1): | ||||
raise ValueError('History is empty, cannot export') | ||||
for session, execution_count, source in hist[:-1]: | ||||
cells.append(v4.new_code_cell( | ||||
execution_count=execution_count, | ||||
source=source | ||||
)) | ||||
nb = v4.new_notebook(cells=cells) | ||||
|
r27282 | with io.open(outfname, "w", encoding="utf-8") as f: | ||
|
r22796 | write(nb, f, version=4) | ||
|
r24467 | |||
@magics_class | ||||
class AsyncMagics(BasicMagics): | ||||
@line_magic | ||||
def autoawait(self, parameter_s): | ||||
""" | ||||
Allow to change the status of the autoawait option. | ||||
This allow you to set a specific asynchronous code runner. | ||||
If no value is passed, print the currently used asynchronous integration | ||||
and whether it is activated. | ||||
It can take a number of value evaluated in the following order: | ||||
- False/false/off deactivate autoawait integration | ||||
- True/true/on activate autoawait integration using configured default | ||||
loop | ||||
- asyncio/curio/trio activate autoawait integration and use integration | ||||
with said library. | ||||
|
r24481 | - `sync` turn on the pseudo-sync integration (mostly used for | ||
`IPython.embed()` which does not run IPython with a real eventloop and | ||||
deactivate running asynchronous code. Turning on Asynchronous code with | ||||
the pseudo sync loop is undefined behavior and may lead IPython to crash. | ||||
|
r24467 | If the passed parameter does not match any of the above and is a python | ||
identifier, get said object from user namespace and set it as the | ||||
|
r27294 | runner, and activate autoawait. | ||
|
r24467 | |||
If the object is a fully qualified object name, attempt to import it and | ||||
|
r24490 | set it as the runner, and activate autoawait. | ||
|
r27294 | |||
|
r24490 | The exact behavior of autoawait is experimental and subject to change | ||
across version of IPython and Python. | ||||
""" | ||||
|
r24467 | |||
param = parameter_s.strip() | ||||
d = {True: "on", False: "off"} | ||||
if not param: | ||||
print("IPython autoawait is `{}`, and set to use `{}`".format( | ||||
d[self.shell.autoawait], | ||||
self.shell.loop_runner | ||||
)) | ||||
return None | ||||
if param.lower() in ('false', 'off'): | ||||
self.shell.autoawait = False | ||||
return None | ||||
if param.lower() in ('true', 'on'): | ||||
self.shell.autoawait = True | ||||
return None | ||||
if param in self.shell.loop_runner_map: | ||||
|
r24481 | self.shell.loop_runner, self.shell.autoawait = self.shell.loop_runner_map[param] | ||
|
r24467 | return None | ||
if param in self.shell.user_ns : | ||||
self.shell.loop_runner = self.shell.user_ns[param] | ||||
self.shell.autoawait = True | ||||
return None | ||||
runner = import_item(param) | ||||
self.shell.loop_runner = runner | ||||
self.shell.autoawait = True | ||||