inputsplitter.py
682 lines
| 24.2 KiB
| text/x-python
|
PythonLexer
|
r13890 | """Input handling and transformation machinery. | ||
|
r2628 | |||
|
r13890 | The first class in this module, :class:`InputSplitter`, is designed to tell when | ||
input from a line-oriented frontend is complete and should be executed, and when | ||||
the user should be prompted for another line of code instead. The name 'input | ||||
splitter' is largely for historical reasons. | ||||
|
r2628 | |||
|
r2782 | A companion, :class:`IPythonInputSplitter`, provides the same functionality but | ||
with full support for the extended IPython syntax (magics, system calls, etc). | ||||
|
r13890 | The code to actually do these transformations is in :mod:`IPython.core.inputtransformer`. | ||
:class:`IPythonInputSplitter` feeds the raw code to the transformers in order | ||||
and stores the results. | ||||
|
r2782 | |||
|
r13890 | For more details, see the class docstrings below. | ||
|
r2628 | """ | ||
|
r17813 | # Copyright (c) IPython Development Team. | ||
# Distributed under the terms of the Modified BSD License. | ||||
|
r3454 | import ast | ||
|
r2628 | import codeop | ||
import re | ||||
import sys | ||||
|
r18850 | import warnings | ||
|
r2628 | |||
|
r4745 | from IPython.utils.py3compat import cast_unicode | ||
|
r10093 | from IPython.core.inputtransformer import (leading_indent, | ||
classic_prompt, | ||||
ipy_prompt, | ||||
|
r11442 | strip_encoding_cookie, | ||
|
r10093 | cellmagic, | ||
|
r10105 | assemble_logical_lines, | ||
|
r10093 | help_end, | ||
|
r10107 | escaped_commands, | ||
|
r10093 | assign_from_magic, | ||
assign_from_system, | ||||
|
r10106 | assemble_python_lines, | ||
|
r10093 | ) | ||
|
r11124 | # These are available in this module for backwards compatibility. | ||
|
r10093 | from IPython.core.inputtransformer import (ESC_SHELL, ESC_SH_CAP, ESC_HELP, | ||
ESC_HELP2, ESC_MAGIC, ESC_MAGIC2, | ||||
ESC_QUOTE, ESC_QUOTE2, ESC_PAREN, ESC_SEQUENCES) | ||||
|
r7554 | |||
|
r2780 | #----------------------------------------------------------------------------- | ||
|
r2628 | # Utilities | ||
#----------------------------------------------------------------------------- | ||||
|
r2780 | # FIXME: These are general-purpose utilities that later can be moved to the | ||
# general ward. Kept here for now because we're being very strict about test | ||||
# coverage with this code, and this lets us ensure that we keep 100% coverage | ||||
# while developing. | ||||
|
r2633 | |||
|
r2628 | # compiled regexps for autoindent management | ||
|
r3704 | dedent_re = re.compile('|'.join([ | ||
r'^\s+raise(\s.*)?$', # raise statement (+ space + other stuff, maybe) | ||||
r'^\s+raise\([^\)]*\).*$', # wacky raise with immediate open paren | ||||
r'^\s+return(\s.*)?$', # normal return (+ space + other stuff, maybe) | ||||
r'^\s+return\([^\)]*\).*$', # wacky return with immediate open paren | ||||
|
r7824 | r'^\s+pass\s*$', # pass (optionally followed by trailing spaces) | ||
r'^\s+break\s*$', # break (optionally followed by trailing spaces) | ||||
r'^\s+continue\s*$', # continue (optionally followed by trailing spaces) | ||||
|
r3704 | ])) | ||
|
r2628 | ini_spaces_re = re.compile(r'^([ \t\r\f\v]+)') | ||
|
r2979 | # regexp to match pure comment lines so we don't accidentally insert 'if 1:' | ||
# before pure comments | ||||
comment_line_re = re.compile('^\s*\#') | ||||
|
r2628 | |||
def num_ini_spaces(s): | ||||
"""Return the number of initial spaces in a string. | ||||
Note that tabs are counted as a single space. For now, we do *not* support | ||||
mixing of tabs and spaces in the user's input. | ||||
Parameters | ||||
---------- | ||||
s : string | ||||
|
r2663 | |||
Returns | ||||
------- | ||||
n : int | ||||
|
r2628 | """ | ||
ini_spaces = ini_spaces_re.match(s) | ||||
if ini_spaces: | ||||
return ini_spaces.end() | ||||
else: | ||||
return 0 | ||||
|
r6978 | def last_blank(src): | ||
"""Determine if the input source ends in a blank. | ||||
A blank is either a newline or a line consisting of whitespace. | ||||
Parameters | ||||
---------- | ||||
src : string | ||||
A single or multiline string. | ||||
""" | ||||
|
r6981 | if not src: return False | ||
ll = src.splitlines()[-1] | ||||
return (ll == '') or ll.isspace() | ||||
|
r6979 | |||
|
r6981 | last_two_blanks_re = re.compile(r'\n\s*\n\s*$', re.MULTILINE) | ||
last_two_blanks_re2 = re.compile(r'.+\n\s*\n\s+$', re.MULTILINE) | ||||
|
r6979 | |||
def last_two_blanks(src): | ||||
"""Determine if the input source ends in two blanks. | ||||
A blank is either a newline or a line consisting of whitespace. | ||||
Parameters | ||||
---------- | ||||
src : string | ||||
A single or multiline string. | ||||
""" | ||||
|
r6981 | if not src: return False | ||
# The logic here is tricky: I couldn't get a regexp to work and pass all | ||||
# the tests, so I took a different approach: split the source by lines, | ||||
# grab the last two and prepend '###\n' as a stand-in for whatever was in | ||||
# the body before the last two lines. Then, with that structure, it's | ||||
# possible to analyze with two regexps. Not the most elegant solution, but | ||||
# it works. If anyone tries to change this logic, make sure to validate | ||||
# the whole test suite first! | ||||
new_src = '\n'.join(['###\n'] + src.splitlines()[-2:]) | ||||
return (bool(last_two_blanks_re.match(new_src)) or | ||||
bool(last_two_blanks_re2.match(new_src)) ) | ||||
|
r6978 | |||
|
r2628 | def remove_comments(src): | ||
"""Remove all comments from input source. | ||||
Note: comments are NOT recognized inside of strings! | ||||
Parameters | ||||
---------- | ||||
src : string | ||||
A single or multiline input string. | ||||
Returns | ||||
------- | ||||
String with all Python comments removed. | ||||
""" | ||||
return re.sub('#.*', '', src) | ||||
|
r7823 | |||
|
r2628 | |||
def get_input_encoding(): | ||||
|
r2718 | """Return the default standard input encoding. | ||
If sys.stdin has no encoding, 'ascii' is returned.""" | ||||
|
r2674 | # There are strange environments for which sys.stdin.encoding is None. We | ||
# ensure that a valid encoding is returned. | ||||
encoding = getattr(sys.stdin, 'encoding', None) | ||||
if encoding is None: | ||||
encoding = 'ascii' | ||||
return encoding | ||||
|
r2628 | |||
#----------------------------------------------------------------------------- | ||||
|
r2780 | # Classes and functions for normal Python syntax handling | ||
|
r2628 | #----------------------------------------------------------------------------- | ||
|
r2663 | class InputSplitter(object): | ||
|
r13597 | r"""An object that can accumulate lines of Python source before execution. | ||
|
r2663 | |||
|
r4077 | This object is designed to be fed python source line-by-line, using | ||
|
r13597 | :meth:`push`. It will return on each push whether the currently pushed | ||
code could be executed already. In addition, it provides a method called | ||||
:meth:`push_accepts_more` that can be used to query whether more input | ||||
can be pushed into a single interactive block. | ||||
|
r2663 | |||
This is a simple example of how an interactive terminal-based client can use | ||||
this tool:: | ||||
isp = InputSplitter() | ||||
while isp.push_accepts_more(): | ||||
indent = ' '*isp.indent_spaces | ||||
prompt = '>>> ' + indent | ||||
line = indent + raw_input(prompt) | ||||
isp.push(line) | ||||
print 'Input source was:\n', isp.source_reset(), | ||||
""" | ||||
# Number of spaces of indentation computed from input that has been pushed | ||||
# so far. This is the attributes callers should query to get the current | ||||
# indentation level, in order to provide auto-indent facilities. | ||||
|
r2628 | indent_spaces = 0 | ||
|
r2663 | # String, indicating the default input encoding. It is computed by default | ||
# at initialization time via get_input_encoding(), but it can be reset by a | ||||
# client with specific knowledge of the encoding. | ||||
|
r2628 | encoding = '' | ||
|
r2663 | # String where the current full source input is stored, properly encoded. | ||
# Reading this attribute is the normal way of querying the currently pushed | ||||
# source code, that has been properly encoded. | ||||
|
r2628 | source = '' | ||
|
r2663 | # Code object corresponding to the current source. It is automatically | ||
# synced to the source, so it can be queried at any time to obtain the code | ||||
# object; it will be None if the source doesn't compile to valid Python. | ||||
|
r2628 | code = None | ||
|
r7823 | |||
|
r2633 | # Private attributes | ||
|
r7823 | |||
|
r2663 | # List with lines of input accumulated so far | ||
|
r2633 | _buffer = None | ||
|
r2663 | # Command compiler | ||
_compile = None | ||||
# Mark when input has changed indentation all the way back to flush-left | ||||
_full_dedent = False | ||||
# Boolean indicating whether the current block is complete | ||||
_is_complete = None | ||||
|
r17804 | # Boolean indicating whether the current block has an unrecoverable syntax error | ||
_is_invalid = False | ||||
|
r7823 | |||
|
r10251 | def __init__(self): | ||
|
r2663 | """Create a new InputSplitter instance. | ||
|
r2634 | """ | ||
|
r2633 | self._buffer = [] | ||
|
r2663 | self._compile = codeop.CommandCompiler() | ||
|
r2628 | self.encoding = get_input_encoding() | ||
def reset(self): | ||||
"""Reset the input buffer and associated state.""" | ||||
self.indent_spaces = 0 | ||||
|
r2633 | self._buffer[:] = [] | ||
|
r2628 | self.source = '' | ||
|
r2633 | self.code = None | ||
|
r2663 | self._is_complete = False | ||
|
r17804 | self._is_invalid = False | ||
|
r2663 | self._full_dedent = False | ||
|
r2628 | |||
|
r2636 | def source_reset(self): | ||
"""Return the input source and perform a full reset. | ||||
|
r2628 | """ | ||
out = self.source | ||||
|
r2636 | self.reset() | ||
|
r2628 | return out | ||
|
r17804 | def check_complete(self, source): | ||
|
r17624 | """Return whether a block of code is ready to execute, or should be continued | ||
This is a non-stateful API, and will reset the state of this InputSplitter. | ||||
|
r17804 | |||
Parameters | ||||
---------- | ||||
source : string | ||||
Python input code, which can be multiline. | ||||
Returns | ||||
------- | ||||
status : str | ||||
One of 'complete', 'incomplete', or 'invalid' if source is not a | ||||
prefix of valid code. | ||||
indent_spaces : int or None | ||||
The number of spaces by which to indent the next line of code. If | ||||
status is not 'incomplete', this is None. | ||||
|
r17624 | """ | ||
self.reset() | ||||
try: | ||||
self.push(source) | ||||
except SyntaxError: | ||||
# Transformers in IPythonInputSplitter can raise SyntaxError, | ||||
# which push() will not catch. | ||||
|
r17804 | return 'invalid', None | ||
else: | ||||
if self._is_invalid: | ||||
return 'invalid', None | ||||
elif self.push_accepts_more(): | ||||
return 'incomplete', self.indent_spaces | ||||
else: | ||||
return 'complete', None | ||||
|
r17624 | finally: | ||
self.reset() | ||||
|
r2628 | def push(self, lines): | ||
|
r3293 | """Push one or more lines of input. | ||
|
r2628 | |||
This stores the given lines and returns a status code indicating | ||||
whether the code forms a complete Python block or not. | ||||
|
r2663 | Any exceptions generated in compilation are swallowed, but if an | ||
exception was produced, the method returns True. | ||||
|
r2628 | |||
Parameters | ||||
---------- | ||||
lines : string | ||||
One or more lines of Python input. | ||||
|
r7823 | |||
|
r2628 | Returns | ||
------- | ||||
is_complete : boolean | ||||
True if the current input source (the result of the current input | ||||
|
r7643 | plus prior inputs) forms a complete Python execution block. Note that | ||
this value is also stored as a private attribute (``_is_complete``), so it | ||||
can be queried at any time. | ||||
|
r2628 | """ | ||
|
r2633 | self._store(lines) | ||
|
r2628 | source = self.source | ||
|
r2663 | # Before calling _compile(), reset the code object to None so that if an | ||
|
r2628 | # exception is raised in compilation, we don't mislead by having | ||
# inconsistent code/source attributes. | ||||
|
r2663 | self.code, self._is_complete = None, None | ||
|
r17804 | self._is_invalid = False | ||
|
r2645 | |||
|
r3013 | # Honor termination lines properly | ||
|
r7823 | if source.endswith('\\\n'): | ||
|
r3013 | return False | ||
|
r2645 | self._update_indent(lines) | ||
|
r2635 | try: | ||
|
r18850 | with warnings.catch_warnings(): | ||
warnings.simplefilter('error', SyntaxWarning) | ||||
self.code = self._compile(source, symbol="exec") | ||||
|
r2635 | # Invalid syntax can produce any of a number of different errors from | ||
# inside the compiler, so we have to catch them all. Syntax errors | ||||
# immediately produce a 'ready' block, so the invalid Python can be | ||||
# sent to the kernel for evaluation with possible ipython | ||||
# special-syntax conversion. | ||||
|
r2645 | except (SyntaxError, OverflowError, ValueError, TypeError, | ||
|
r18850 | MemoryError, SyntaxWarning): | ||
|
r2663 | self._is_complete = True | ||
|
r17804 | self._is_invalid = True | ||
|
r2635 | else: | ||
# Compilation didn't produce any exceptions (though it may not have | ||||
# given a complete code object) | ||||
|
r2663 | self._is_complete = self.code is not None | ||
|
r2635 | |||
|
r2663 | return self._is_complete | ||
|
r2628 | |||
|
r2663 | def push_accepts_more(self): | ||
"""Return whether a block of interactive input can accept more input. | ||||
|
r2628 | |||
This method is meant to be used by line-oriented frontends, who need to | ||||
guess whether a block is complete or not based solely on prior and | ||||
|
r2663 | current input lines. The InputSplitter considers it has a complete | ||
|
r10255 | interactive block and will not accept more input when either: | ||
* A SyntaxError is raised | ||||
|
r7823 | |||
|
r10255 | * The code is complete and consists of a single line or a single | ||
non-compound statement | ||||
|
r2628 | |||
|
r10255 | * The code is complete and has a blank line at the end | ||
|
r2628 | |||
|
r2663 | If the current input produces a syntax error, this method immediately | ||
returns False but does *not* raise the syntax error exception, as | ||||
typically clients will want to send invalid syntax to an execution | ||||
backend which might convert the invalid syntax into valid Python via | ||||
one of the dynamic IPython mechanisms. | ||||
|
r2628 | """ | ||
|
r3004 | |||
# With incomplete input, unconditionally accept more | ||||
|
r10251 | # A syntax error also sets _is_complete to True - see push() | ||
|
r2663 | if not self._is_complete: | ||
|
r10251 | #print("Not complete") # debug | ||
|
r2628 | return True | ||
|
r10251 | |||
# The user can make any (complete) input execute by leaving a blank line | ||||
last_line = self.source.splitlines()[-1] | ||||
if (not last_line) or last_line.isspace(): | ||||
#print("Blank line") # debug | ||||
return False | ||||
|
r10255 | # If there's just a single line or AST node, and we're flush left, as is | ||
# the case after a simple statement such as 'a=1', we want to execute it | ||||
|
r10251 | # straight away. | ||
|
r2663 | if self.indent_spaces==0: | ||
|
r10255 | if len(self.source.splitlines()) <= 1: | ||
return False | ||||
|
r10251 | try: | ||
code_ast = ast.parse(u''.join(self._buffer)) | ||||
except Exception: | ||||
#print("Can't parse AST") # debug | ||||
return False | ||||
|
r3004 | else: | ||
|
r10251 | if len(code_ast.body) == 1 and \ | ||
not hasattr(code_ast.body[0], 'body'): | ||||
#print("Simple statement") # debug | ||||
|
r3004 | return False | ||
|
r10251 | # General fallback - accept more code | ||
return True | ||||
|
r2628 | |||
|
r2633 | #------------------------------------------------------------------------ | ||
# Private interface | ||||
#------------------------------------------------------------------------ | ||||
|
r2628 | |||
|
r2645 | def _find_indent(self, line): | ||
"""Compute the new indentation level for a single line. | ||||
Parameters | ||||
---------- | ||||
line : str | ||||
A single new line of non-whitespace, non-comment Python input. | ||||
|
r7823 | |||
|
r2645 | Returns | ||
------- | ||||
indent_spaces : int | ||||
New value for the indent level (it may be equal to self.indent_spaces | ||||
if indentation doesn't change. | ||||
full_dedent : boolean | ||||
Whether the new line causes a full flush-left dedent. | ||||
""" | ||||
indent_spaces = self.indent_spaces | ||||
|
r2663 | full_dedent = self._full_dedent | ||
|
r7823 | |||
|
r2645 | inisp = num_ini_spaces(line) | ||
if inisp < indent_spaces: | ||||
indent_spaces = inisp | ||||
if indent_spaces <= 0: | ||||
#print 'Full dedent in text',self.source # dbg | ||||
full_dedent = True | ||||
|
r4204 | if line.rstrip()[-1] == ':': | ||
|
r2645 | indent_spaces += 4 | ||
elif dedent_re.match(line): | ||||
indent_spaces -= 4 | ||||
if indent_spaces <= 0: | ||||
full_dedent = True | ||||
# Safety | ||||
if indent_spaces < 0: | ||||
indent_spaces = 0 | ||||
#print 'safety' # dbg | ||||
|
r7823 | |||
|
r2645 | return indent_spaces, full_dedent | ||
|
r7823 | |||
|
r2645 | def _update_indent(self, lines): | ||
for line in remove_comments(lines).splitlines(): | ||||
|
r2633 | if line and not line.isspace(): | ||
|
r2663 | self.indent_spaces, self._full_dedent = self._find_indent(line) | ||
|
r2628 | |||
|
r3080 | def _store(self, lines, buffer=None, store='source'): | ||
|
r2633 | """Store one or more lines of input. | ||
If input lines are not newline-terminated, a newline is automatically | ||||
appended.""" | ||||
|
r7823 | |||
|
r3080 | if buffer is None: | ||
buffer = self._buffer | ||||
|
r7823 | |||
|
r2633 | if lines.endswith('\n'): | ||
|
r3080 | buffer.append(lines) | ||
|
r2633 | else: | ||
|
r3080 | buffer.append(lines+'\n') | ||
setattr(self, store, self._set_source(buffer)) | ||||
|
r2645 | |||
|
r3080 | def _set_source(self, buffer): | ||
|
r3455 | return u''.join(buffer) | ||
|
r2719 | |||
class IPythonInputSplitter(InputSplitter): | ||||
"""An input splitter that recognizes all of IPython's special syntax.""" | ||||
|
r3080 | # String with raw, untransformed input. | ||
source_raw = '' | ||||
|
r10093 | |||
# Flag to track when a transformer has stored input that it hasn't given | ||||
# back yet. | ||||
transformer_accumulating = False | ||||
|
r10106 | |||
# Flag to track when assemble_python_lines has stored input that it hasn't | ||||
# given back yet. | ||||
within_python_line = False | ||||
|
r6976 | |||
|
r3080 | # Private attributes | ||
|
r6978 | |||
|
r3080 | # List with lines of raw input accumulated so far. | ||
_buffer_raw = None | ||||
|
r10493 | def __init__(self, line_input_checker=True, physical_line_transforms=None, | ||
|
r10106 | logical_line_transforms=None, python_line_transforms=None): | ||
|
r10251 | super(IPythonInputSplitter, self).__init__() | ||
|
r3080 | self._buffer_raw = [] | ||
|
r6978 | self._validate = True | ||
|
r10106 | |||
|
r10113 | if physical_line_transforms is not None: | ||
self.physical_line_transforms = physical_line_transforms | ||||
else: | ||||
|
r11460 | self.physical_line_transforms = [ | ||
leading_indent(), | ||||
|
r10113 | classic_prompt(), | ||
ipy_prompt(), | ||||
|
r11463 | cellmagic(end_on_blank_line=line_input_checker), | ||
|
r21824 | strip_encoding_cookie(), | ||
|
r10113 | ] | ||
|
r10106 | |||
self.assemble_logical_lines = assemble_logical_lines() | ||||
|
r10113 | if logical_line_transforms is not None: | ||
self.logical_line_transforms = logical_line_transforms | ||||
else: | ||||
|
r11460 | self.logical_line_transforms = [ | ||
|
r10113 | help_end(), | ||
escaped_commands(), | ||||
assign_from_magic(), | ||||
assign_from_system(), | ||||
] | ||||
|
r10106 | |||
self.assemble_python_lines = assemble_python_lines() | ||||
|
r10113 | if python_line_transforms is not None: | ||
self.python_line_transforms = python_line_transforms | ||||
else: | ||||
# We don't use any of these at present | ||||
self.python_line_transforms = [] | ||||
|
r10106 | |||
@property | ||||
def transforms(self): | ||||
"Quick access to all transformers." | ||||
return self.physical_line_transforms + \ | ||||
[self.assemble_logical_lines] + self.logical_line_transforms + \ | ||||
[self.assemble_python_lines] + self.python_line_transforms | ||||
@property | ||||
def transforms_in_use(self): | ||||
"""Transformers, excluding logical line transformers if we're in a | ||||
Python line.""" | ||||
|
r10112 | t = self.physical_line_transforms[:] | ||
|
r10106 | if not self.within_python_line: | ||
|
r10112 | t += [self.assemble_logical_lines] + self.logical_line_transforms | ||
|
r10106 | return t + [self.assemble_python_lines] + self.python_line_transforms | ||
|
r7823 | |||
|
r3080 | def reset(self): | ||
"""Reset the input buffer and associated state.""" | ||||
|
r6976 | super(IPythonInputSplitter, self).reset() | ||
|
r3080 | self._buffer_raw[:] = [] | ||
self.source_raw = '' | ||||
|
r10093 | self.transformer_accumulating = False | ||
|
r10112 | self.within_python_line = False | ||
|
r13529 | |||
|
r10096 | for t in self.transforms: | ||
|
r13529 | try: | ||
t.reset() | ||||
|
r13912 | except SyntaxError: | ||
# Nothing that calls reset() expects to handle transformer | ||||
# errors | ||||
pass | ||||
|
r10096 | |||
def flush_transformers(self): | ||||
|
r17814 | def _flush(transform, outs): | ||
|
r17813 | """yield transformed lines | ||
always strings, never None | ||||
transform: the current transform | ||||
|
r17814 | outs: an iterable of previously transformed inputs. | ||
|
r17813 | Each may be multiline, which will be passed | ||
one line at a time to transform. | ||||
""" | ||||
|
r17814 | for out in outs: | ||
|
r17813 | for line in out.splitlines(): | ||
# push one line at a time | ||||
tmp = transform.push(line) | ||||
if tmp is not None: | ||||
yield tmp | ||||
|
r17814 | |||
# reset the transform | ||||
tmp = transform.reset() | ||||
if tmp is not None: | ||||
yield tmp | ||||
|
r10106 | |||
|
r17813 | out = [] | ||
|
r10106 | for t in self.transforms_in_use: | ||
out = _flush(t, out) | ||||
|
r17813 | out = list(out) | ||
if out: | ||||
self._store('\n'.join(out)) | ||||
|
r3080 | |||
|
r13912 | def raw_reset(self): | ||
"""Return raw input only and perform a full reset. | ||||
|
r3080 | """ | ||
|
r13912 | out = self.source_raw | ||
|
r3080 | self.reset() | ||
|
r13912 | return out | ||
|
r10096 | |||
def source_reset(self): | ||||
|
r13912 | try: | ||
self.flush_transformers() | ||||
return self.source | ||||
finally: | ||||
self.reset() | ||||
|
r3080 | |||
|
r6978 | def push_accepts_more(self): | ||
|
r10093 | if self.transformer_accumulating: | ||
return True | ||||
|
r6978 | else: | ||
return super(IPythonInputSplitter, self).push_accepts_more() | ||||
|
r7487 | def transform_cell(self, cell): | ||
"""Process and translate a cell of input. | ||||
""" | ||||
self.reset() | ||||
|
r13912 | try: | ||
self.push(cell) | ||||
self.flush_transformers() | ||||
return self.source | ||||
finally: | ||||
self.reset() | ||||
|
r7487 | |||
|
r2719 | def push(self, lines): | ||
"""Push one or more lines of IPython input. | ||||
|
r6976 | |||
This stores the given lines and returns a status code indicating | ||||
whether the code forms a complete Python block or not, after processing | ||||
all input lines for special IPython syntax. | ||||
Any exceptions generated in compilation are swallowed, but if an | ||||
exception was produced, the method returns True. | ||||
Parameters | ||||
---------- | ||||
lines : string | ||||
One or more lines of Python input. | ||||
Returns | ||||
------- | ||||
is_complete : boolean | ||||
True if the current input source (the result of the current input | ||||
|
r13890 | plus prior inputs) forms a complete Python execution block. Note that | ||
this value is also stored as a private attribute (_is_complete), so it | ||||
can be queried at any time. | ||||
|
r2719 | """ | ||
|
r2782 | |||
|
r3126 | # We must ensure all input is pure unicode | ||
|
r4745 | lines = cast_unicode(lines, self.encoding) | ||
|
r10094 | |||
# ''.splitlines() --> [], but we need to push the empty line to transformers | ||||
|
r2782 | lines_list = lines.splitlines() | ||
|
r10094 | if not lines_list: | ||
lines_list = [''] | ||||
|
r2782 | |||
|
r3080 | # Store raw source before applying any transformations to it. Note | ||
# that this must be done *after* the reset() call that would otherwise | ||||
# flush the buffer. | ||||
self._store(lines, self._buffer_raw, 'source_raw') | ||||
|
r7823 | |||
|
r10251 | for line in lines_list: | ||
out = self.push_line(line) | ||||
|
r2782 | return out | ||
|
r10093 | |||
def push_line(self, line): | ||||
buf = self._buffer | ||||
|
r10106 | |||
def _accumulating(dbg): | ||||
#print(dbg) | ||||
self.transformer_accumulating = True | ||||
return False | ||||
for transformer in self.physical_line_transforms: | ||||
line = transformer.push(line) | ||||
if line is None: | ||||
return _accumulating(transformer) | ||||
if not self.within_python_line: | ||||
|
r10112 | line = self.assemble_logical_lines.push(line) | ||
if line is None: | ||||
return _accumulating('acc logical line') | ||||
|
r10106 | for transformer in self.logical_line_transforms: | ||
line = transformer.push(line) | ||||
if line is None: | ||||
return _accumulating(transformer) | ||||
line = self.assemble_python_lines.push(line) | ||||
if line is None: | ||||
self.within_python_line = True | ||||
return _accumulating('acc python line') | ||||
else: | ||||
self.within_python_line = False | ||||
for transformer in self.python_line_transforms: | ||||
|
r10105 | line = transformer.push(line) | ||
if line is None: | ||||
|
r10106 | return _accumulating(transformer) | ||
|
r10093 | |||
|
r10106 | #print("transformers clear") #debug | ||
|
r10093 | self.transformer_accumulating = False | ||
return super(IPythonInputSplitter, self).push(line) | ||||