|
|
"""Analysis of text input into executable blocks.
|
|
|
|
|
|
The main class in this module, :class:`InputSplitter`, is designed to break
|
|
|
input from either interactive, line-by-line environments or block-based ones,
|
|
|
into standalone blocks that can be executed by Python as 'single' statements
|
|
|
(thus triggering sys.displayhook).
|
|
|
|
|
|
A companion, :class:`IPythonInputSplitter`, provides the same functionality but
|
|
|
with full support for the extended IPython syntax (magics, system calls, etc).
|
|
|
|
|
|
For more details, see the class docstring below.
|
|
|
|
|
|
Syntax Transformations
|
|
|
----------------------
|
|
|
|
|
|
One of the main jobs of the code in this file is to apply all syntax
|
|
|
transformations that make up 'the IPython language', i.e. magics, shell
|
|
|
escapes, etc. All transformations should be implemented as *fully stateless*
|
|
|
entities, that simply take one line as their input and return a line.
|
|
|
Internally for implementation purposes they may be a normal function or a
|
|
|
callable object, but the only input they receive will be a single line and they
|
|
|
should only return a line, without holding any data-dependent state between
|
|
|
calls.
|
|
|
|
|
|
As an example, the EscapedTransformer is a class so we can more clearly group
|
|
|
together the functionality of dispatching to individual functions based on the
|
|
|
starting escape character, but the only method for public use is its call
|
|
|
method.
|
|
|
|
|
|
|
|
|
ToDo
|
|
|
----
|
|
|
|
|
|
- Should we make push() actually raise an exception once push_accepts_more()
|
|
|
returns False?
|
|
|
|
|
|
- Naming cleanups. The tr_* names aren't the most elegant, though now they are
|
|
|
at least just attributes of a class so not really very exposed.
|
|
|
|
|
|
- Think about the best way to support dynamic things: automagic, autocall,
|
|
|
macros, etc.
|
|
|
|
|
|
- Think of a better heuristic for the application of the transforms in
|
|
|
IPythonInputSplitter.push() than looking at the buffer ending in ':'. Idea:
|
|
|
track indentation change events (indent, dedent, nothing) and apply them only
|
|
|
if the indentation went up, but not otherwise.
|
|
|
|
|
|
- Think of the cleanest way for supporting user-specified transformations (the
|
|
|
user prefilters we had before).
|
|
|
|
|
|
Authors
|
|
|
-------
|
|
|
|
|
|
* Fernando Perez
|
|
|
* Brian Granger
|
|
|
"""
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Copyright (C) 2010 The IPython Development Team
|
|
|
#
|
|
|
# Distributed under the terms of the BSD License. The full license is in
|
|
|
# the file COPYING, distributed as part of this software.
|
|
|
#-----------------------------------------------------------------------------
|
|
|
from __future__ import print_function
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Imports
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# stdlib
|
|
|
import codeop
|
|
|
import re
|
|
|
import sys
|
|
|
|
|
|
# IPython modules
|
|
|
from IPython.utils.text import make_quoted_expr
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Globals
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
# The escape sequences that define the syntax transformations IPython will
|
|
|
# apply to user input. These can NOT be just changed here: many regular
|
|
|
# expressions and other parts of the code may use their hardcoded values, and
|
|
|
# for all intents and purposes they constitute the 'IPython syntax', so they
|
|
|
# should be considered fixed.
|
|
|
|
|
|
ESC_SHELL = '!' # Send line to underlying system shell
|
|
|
ESC_SH_CAP = '!!' # Send line to system shell and capture output
|
|
|
ESC_HELP = '?' # Find information about object
|
|
|
ESC_HELP2 = '??' # Find extra-detailed information about object
|
|
|
ESC_MAGIC = '%' # Call magic function
|
|
|
ESC_QUOTE = ',' # Split args on whitespace, quote each as string and call
|
|
|
ESC_QUOTE2 = ';' # Quote all args as a single string, call
|
|
|
ESC_PAREN = '/' # Call first argument with rest of line as arguments
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Utilities
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
# 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.
|
|
|
|
|
|
# compiled regexps for autoindent management
|
|
|
dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
|
|
|
ini_spaces_re = re.compile(r'^([ \t\r\f\v]+)')
|
|
|
|
|
|
# regexp to match pure comment lines so we don't accidentally insert 'if 1:'
|
|
|
# before pure comments
|
|
|
comment_line_re = re.compile('^\s*\#')
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
Returns
|
|
|
-------
|
|
|
n : int
|
|
|
"""
|
|
|
|
|
|
ini_spaces = ini_spaces_re.match(s)
|
|
|
if ini_spaces:
|
|
|
return ini_spaces.end()
|
|
|
else:
|
|
|
return 0
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
|
|
|
|
def get_input_encoding():
|
|
|
"""Return the default standard input encoding.
|
|
|
|
|
|
If sys.stdin has no encoding, 'ascii' is returned."""
|
|
|
# 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
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Classes and functions for normal Python syntax handling
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
# HACK! This implementation, written by Robert K a while ago using the
|
|
|
# compiler module, is more robust than the other one below, but it expects its
|
|
|
# input to be pure python (no ipython syntax). For now we're using it as a
|
|
|
# second-pass splitter after the first pass transforms the input to pure
|
|
|
# python.
|
|
|
|
|
|
def split_blocks(python):
|
|
|
""" Split multiple lines of code into discrete commands that can be
|
|
|
executed singly.
|
|
|
|
|
|
Parameters
|
|
|
----------
|
|
|
python : str
|
|
|
Pure, exec'able Python code.
|
|
|
|
|
|
Returns
|
|
|
-------
|
|
|
commands : list of str
|
|
|
Separate commands that can be exec'ed independently.
|
|
|
"""
|
|
|
|
|
|
import compiler
|
|
|
|
|
|
# compiler.parse treats trailing spaces after a newline as a
|
|
|
# SyntaxError. This is different than codeop.CommandCompiler, which
|
|
|
# will compile the trailng spaces just fine. We simply strip any
|
|
|
# trailing whitespace off. Passing a string with trailing whitespace
|
|
|
# to exec will fail however. There seems to be some inconsistency in
|
|
|
# how trailing whitespace is handled, but this seems to work.
|
|
|
python_ori = python # save original in case we bail on error
|
|
|
python = python.strip()
|
|
|
|
|
|
# The compiler module does not like unicode. We need to convert
|
|
|
# it encode it:
|
|
|
if isinstance(python, unicode):
|
|
|
# Use the utf-8-sig BOM so the compiler detects this a UTF-8
|
|
|
# encode string.
|
|
|
python = '\xef\xbb\xbf' + python.encode('utf-8')
|
|
|
|
|
|
# The compiler module will parse the code into an abstract syntax tree.
|
|
|
# This has a bug with str("a\nb"), but not str("""a\nb""")!!!
|
|
|
try:
|
|
|
ast = compiler.parse(python)
|
|
|
except:
|
|
|
return [python_ori]
|
|
|
|
|
|
# Uncomment to help debug the ast tree
|
|
|
# for n in ast.node:
|
|
|
# print n.lineno,'->',n
|
|
|
|
|
|
# Each separate command is available by iterating over ast.node. The
|
|
|
# lineno attribute is the line number (1-indexed) beginning the commands
|
|
|
# suite.
|
|
|
# lines ending with ";" yield a Discard Node that doesn't have a lineno
|
|
|
# attribute. These nodes can and should be discarded. But there are
|
|
|
# other situations that cause Discard nodes that shouldn't be discarded.
|
|
|
# We might eventually discover other cases where lineno is None and have
|
|
|
# to put in a more sophisticated test.
|
|
|
linenos = [x.lineno-1 for x in ast.node if x.lineno is not None]
|
|
|
|
|
|
# When we finally get the slices, we will need to slice all the way to
|
|
|
# the end even though we don't have a line number for it. Fortunately,
|
|
|
# None does the job nicely.
|
|
|
linenos.append(None)
|
|
|
|
|
|
# Same problem at the other end: sometimes the ast tree has its
|
|
|
# first complete statement not starting on line 0. In this case
|
|
|
# we might miss part of it. This fixes ticket 266993. Thanks Gael!
|
|
|
linenos[0] = 0
|
|
|
|
|
|
lines = python.splitlines()
|
|
|
|
|
|
# Create a list of atomic commands.
|
|
|
cmds = []
|
|
|
for i, j in zip(linenos[:-1], linenos[1:]):
|
|
|
cmd = lines[i:j]
|
|
|
if cmd:
|
|
|
cmds.append('\n'.join(cmd)+'\n')
|
|
|
|
|
|
return cmds
|
|
|
|
|
|
|
|
|
class InputSplitter(object):
|
|
|
"""An object that can split Python source input in executable blocks.
|
|
|
|
|
|
This object is designed to be used in one of two basic modes:
|
|
|
|
|
|
1. By feeding it python source line-by-line, using :meth:`push`. In this
|
|
|
mode, 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.
|
|
|
|
|
|
2. By calling :meth:`split_blocks` with a single, multiline Python string,
|
|
|
that is then split into blocks each of which can be executed
|
|
|
interactively as a single statement.
|
|
|
|
|
|
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.
|
|
|
indent_spaces = 0
|
|
|
# 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.
|
|
|
encoding = ''
|
|
|
# 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.
|
|
|
source = ''
|
|
|
# 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.
|
|
|
code = None
|
|
|
# Input mode
|
|
|
input_mode = 'line'
|
|
|
|
|
|
# Private attributes
|
|
|
|
|
|
# List with lines of input accumulated so far
|
|
|
_buffer = None
|
|
|
# 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
|
|
|
|
|
|
def __init__(self, input_mode=None):
|
|
|
"""Create a new InputSplitter instance.
|
|
|
|
|
|
Parameters
|
|
|
----------
|
|
|
input_mode : str
|
|
|
|
|
|
One of ['line', 'cell']; default is 'line'.
|
|
|
|
|
|
The input_mode parameter controls how new inputs are used when fed via
|
|
|
the :meth:`push` method:
|
|
|
|
|
|
- 'line': meant for line-oriented clients, inputs are appended one at a
|
|
|
time to the internal buffer and the whole buffer is compiled.
|
|
|
|
|
|
- 'cell': meant for clients that can edit multi-line 'cells' of text at
|
|
|
a time. A cell can contain one or more blocks that can be compile in
|
|
|
'single' mode by Python. In this mode, each new input new input
|
|
|
completely replaces all prior inputs. Cell mode is thus equivalent
|
|
|
to prepending a full reset() to every push() call.
|
|
|
"""
|
|
|
self._buffer = []
|
|
|
self._compile = codeop.CommandCompiler()
|
|
|
self.encoding = get_input_encoding()
|
|
|
self.input_mode = InputSplitter.input_mode if input_mode is None \
|
|
|
else input_mode
|
|
|
|
|
|
def reset(self):
|
|
|
"""Reset the input buffer and associated state."""
|
|
|
self.indent_spaces = 0
|
|
|
self._buffer[:] = []
|
|
|
self.source = ''
|
|
|
self.code = None
|
|
|
self._is_complete = False
|
|
|
self._full_dedent = False
|
|
|
|
|
|
def source_reset(self):
|
|
|
"""Return the input source and perform a full reset.
|
|
|
"""
|
|
|
out = self.source
|
|
|
self.reset()
|
|
|
return out
|
|
|
|
|
|
def push(self, lines):
|
|
|
"""Push one ore more lines of input.
|
|
|
|
|
|
This stores the given lines and returns a status code indicating
|
|
|
whether the code forms a complete Python block or not.
|
|
|
|
|
|
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
|
|
|
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.
|
|
|
"""
|
|
|
if self.input_mode == 'cell':
|
|
|
self.reset()
|
|
|
|
|
|
# If the source code has leading blanks, add 'if 1:\n' to it
|
|
|
# this allows execution of indented pasted code. It is tempting
|
|
|
# to add '\n' at the end of source to run commands like ' a=1'
|
|
|
# directly, but this fails for more complicated scenarios
|
|
|
|
|
|
if not self._buffer and lines[:1] in [' ', '\t'] and \
|
|
|
not comment_line_re.match(lines):
|
|
|
lines = 'if 1:\n%s' % lines
|
|
|
|
|
|
self._store(lines)
|
|
|
source = self.source
|
|
|
|
|
|
# Before calling _compile(), reset the code object to None so that if an
|
|
|
# exception is raised in compilation, we don't mislead by having
|
|
|
# inconsistent code/source attributes.
|
|
|
self.code, self._is_complete = None, None
|
|
|
|
|
|
self._update_indent(lines)
|
|
|
try:
|
|
|
self.code = self._compile(source)
|
|
|
# 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.
|
|
|
except (SyntaxError, OverflowError, ValueError, TypeError,
|
|
|
MemoryError):
|
|
|
self._is_complete = True
|
|
|
else:
|
|
|
# Compilation didn't produce any exceptions (though it may not have
|
|
|
# given a complete code object)
|
|
|
self._is_complete = self.code is not None
|
|
|
|
|
|
return self._is_complete
|
|
|
|
|
|
def push_accepts_more(self):
|
|
|
"""Return whether a block of interactive input can accept more input.
|
|
|
|
|
|
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
|
|
|
current input lines. The InputSplitter considers it has a complete
|
|
|
interactive block and will not accept more input only when either a
|
|
|
SyntaxError is raised, or *all* of the following are true:
|
|
|
|
|
|
1. The input compiles to a complete statement.
|
|
|
|
|
|
2. The indentation level is flush-left (because if we are indented,
|
|
|
like inside a function definition or for loop, we need to keep
|
|
|
reading new input).
|
|
|
|
|
|
3. There is one extra line consisting only of whitespace.
|
|
|
|
|
|
Because of condition #3, this method should be used only by
|
|
|
*line-oriented* frontends, since it means that intermediate blank lines
|
|
|
are not allowed in function definitions (or any other indented block).
|
|
|
|
|
|
Block-oriented frontends that have a separate keyboard event to
|
|
|
indicate execution should use the :meth:`split_blocks` method instead.
|
|
|
|
|
|
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.
|
|
|
"""
|
|
|
|
|
|
# With incomplete input, unconditionally accept more
|
|
|
if not self._is_complete:
|
|
|
return True
|
|
|
|
|
|
# If we already have complete input and we're flush left, the answer
|
|
|
# depends. In line mode, we're done. But in cell mode, we need to
|
|
|
# check how many blocks the input so far compiles into, because if
|
|
|
# there's already more than one full independent block of input, then
|
|
|
# the client has entered full 'cell' mode and is feeding lines that
|
|
|
# each is complete. In this case we should then keep accepting.
|
|
|
# The Qt terminal-like console does precisely this, to provide the
|
|
|
# convenience of terminal-like input of single expressions, but
|
|
|
# allowing the user (with a separate keystroke) to switch to 'cell'
|
|
|
# mode and type multiple expressions in one shot.
|
|
|
if self.indent_spaces==0:
|
|
|
if self.input_mode=='line':
|
|
|
return False
|
|
|
else:
|
|
|
nblocks = len(split_blocks(''.join(self._buffer)))
|
|
|
if nblocks==1:
|
|
|
return False
|
|
|
|
|
|
# When input is complete, then termination is marked by an extra blank
|
|
|
# line at the end.
|
|
|
last_line = self.source.splitlines()[-1]
|
|
|
return bool(last_line and not last_line.isspace())
|
|
|
|
|
|
def split_blocks(self, lines):
|
|
|
"""Split a multiline string into multiple input blocks.
|
|
|
|
|
|
Note: this method starts by performing a full reset().
|
|
|
|
|
|
Parameters
|
|
|
----------
|
|
|
lines : str
|
|
|
A possibly multiline string.
|
|
|
|
|
|
Returns
|
|
|
-------
|
|
|
blocks : list
|
|
|
A list of strings, each possibly multiline. Each string corresponds
|
|
|
to a single block that can be compiled in 'single' mode (unless it
|
|
|
has a syntax error)."""
|
|
|
|
|
|
# This code is fairly delicate. If you make any changes here, make
|
|
|
# absolutely sure that you do run the full test suite and ALL tests
|
|
|
# pass.
|
|
|
|
|
|
self.reset()
|
|
|
blocks = []
|
|
|
|
|
|
# Reversed copy so we can use pop() efficiently and consume the input
|
|
|
# as a stack
|
|
|
lines = lines.splitlines()[::-1]
|
|
|
# Outer loop over all input
|
|
|
while lines:
|
|
|
#print 'Current lines:', lines # dbg
|
|
|
# Inner loop to build each block
|
|
|
while True:
|
|
|
# Safety exit from inner loop
|
|
|
if not lines:
|
|
|
break
|
|
|
# Grab next line but don't push it yet
|
|
|
next_line = lines.pop()
|
|
|
# Blank/empty lines are pushed as-is
|
|
|
if not next_line or next_line.isspace():
|
|
|
self.push(next_line)
|
|
|
continue
|
|
|
|
|
|
# Check indentation changes caused by the *next* line
|
|
|
indent_spaces, _full_dedent = self._find_indent(next_line)
|
|
|
|
|
|
# If the next line causes a dedent, it can be for two differnt
|
|
|
# reasons: either an explicit de-dent by the user or a
|
|
|
# return/raise/pass statement. These MUST be handled
|
|
|
# separately:
|
|
|
#
|
|
|
# 1. the first case is only detected when the actual explicit
|
|
|
# dedent happens, and that would be the *first* line of a *new*
|
|
|
# block. Thus, we must put the line back into the input buffer
|
|
|
# so that it starts a new block on the next pass.
|
|
|
#
|
|
|
# 2. the second case is detected in the line before the actual
|
|
|
# dedent happens, so , we consume the line and we can break out
|
|
|
# to start a new block.
|
|
|
|
|
|
# Case 1, explicit dedent causes a break.
|
|
|
# Note: check that we weren't on the very last line, else we'll
|
|
|
# enter an infinite loop adding/removing the last line.
|
|
|
if _full_dedent and lines and not next_line.startswith(' '):
|
|
|
lines.append(next_line)
|
|
|
break
|
|
|
|
|
|
# Otherwise any line is pushed
|
|
|
self.push(next_line)
|
|
|
|
|
|
# Case 2, full dedent with full block ready:
|
|
|
if _full_dedent or \
|
|
|
self.indent_spaces==0 and not self.push_accepts_more():
|
|
|
break
|
|
|
# Form the new block with the current source input
|
|
|
blocks.append(self.source_reset())
|
|
|
|
|
|
#return blocks
|
|
|
# HACK!!! Now that our input is in blocks but guaranteed to be pure
|
|
|
# python syntax, feed it back a second time through the AST-based
|
|
|
# splitter, which is more accurate than ours.
|
|
|
return split_blocks(''.join(blocks))
|
|
|
|
|
|
#------------------------------------------------------------------------
|
|
|
# Private interface
|
|
|
#------------------------------------------------------------------------
|
|
|
|
|
|
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.
|
|
|
|
|
|
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
|
|
|
full_dedent = self._full_dedent
|
|
|
|
|
|
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
|
|
|
|
|
|
if line[-1] == ':':
|
|
|
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
|
|
|
|
|
|
return indent_spaces, full_dedent
|
|
|
|
|
|
def _update_indent(self, lines):
|
|
|
for line in remove_comments(lines).splitlines():
|
|
|
if line and not line.isspace():
|
|
|
self.indent_spaces, self._full_dedent = self._find_indent(line)
|
|
|
|
|
|
def _store(self, lines):
|
|
|
"""Store one or more lines of input.
|
|
|
|
|
|
If input lines are not newline-terminated, a newline is automatically
|
|
|
appended."""
|
|
|
|
|
|
if lines.endswith('\n'):
|
|
|
self._buffer.append(lines)
|
|
|
else:
|
|
|
self._buffer.append(lines+'\n')
|
|
|
self._set_source()
|
|
|
|
|
|
def _set_source(self):
|
|
|
self.source = ''.join(self._buffer).encode(self.encoding)
|
|
|
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Functions and classes for IPython-specific syntactic support
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
# RegExp for splitting line contents into pre-char//first word-method//rest.
|
|
|
# For clarity, each group in on one line.
|
|
|
|
|
|
line_split = re.compile("""
|
|
|
^(\s*) # any leading space
|
|
|
([,;/%]|!!?|\?\??) # escape character or characters
|
|
|
\s*(%?[\w\.]*) # function/method, possibly with leading %
|
|
|
# to correctly treat things like '?%magic'
|
|
|
(\s+.*$|$) # rest of line
|
|
|
""", re.VERBOSE)
|
|
|
|
|
|
|
|
|
def split_user_input(line):
|
|
|
"""Split user input into early whitespace, esc-char, function part and rest.
|
|
|
|
|
|
This is currently handles lines with '=' in them in a very inconsistent
|
|
|
manner.
|
|
|
|
|
|
Examples
|
|
|
========
|
|
|
>>> split_user_input('x=1')
|
|
|
('', '', 'x=1', '')
|
|
|
>>> split_user_input('?')
|
|
|
('', '?', '', '')
|
|
|
>>> split_user_input('??')
|
|
|
('', '??', '', '')
|
|
|
>>> split_user_input(' ?')
|
|
|
(' ', '?', '', '')
|
|
|
>>> split_user_input(' ??')
|
|
|
(' ', '??', '', '')
|
|
|
>>> split_user_input('??x')
|
|
|
('', '??', 'x', '')
|
|
|
>>> split_user_input('?x=1')
|
|
|
('', '', '?x=1', '')
|
|
|
>>> split_user_input('!ls')
|
|
|
('', '!', 'ls', '')
|
|
|
>>> split_user_input(' !ls')
|
|
|
(' ', '!', 'ls', '')
|
|
|
>>> split_user_input('!!ls')
|
|
|
('', '!!', 'ls', '')
|
|
|
>>> split_user_input(' !!ls')
|
|
|
(' ', '!!', 'ls', '')
|
|
|
>>> split_user_input(',ls')
|
|
|
('', ',', 'ls', '')
|
|
|
>>> split_user_input(';ls')
|
|
|
('', ';', 'ls', '')
|
|
|
>>> split_user_input(' ;ls')
|
|
|
(' ', ';', 'ls', '')
|
|
|
>>> split_user_input('f.g(x)')
|
|
|
('', '', 'f.g(x)', '')
|
|
|
>>> split_user_input('f.g (x)')
|
|
|
('', '', 'f.g', '(x)')
|
|
|
>>> split_user_input('?%hist')
|
|
|
('', '?', '%hist', '')
|
|
|
"""
|
|
|
match = line_split.match(line)
|
|
|
if match:
|
|
|
lspace, esc, fpart, rest = match.groups()
|
|
|
else:
|
|
|
# print "match failed for line '%s'" % line
|
|
|
try:
|
|
|
fpart, rest = line.split(None, 1)
|
|
|
except ValueError:
|
|
|
# print "split failed for line '%s'" % line
|
|
|
fpart, rest = line,''
|
|
|
lspace = re.match('^(\s*)(.*)', line).groups()[0]
|
|
|
esc = ''
|
|
|
|
|
|
# fpart has to be a valid python identifier, so it better be only pure
|
|
|
# ascii, no unicode:
|
|
|
try:
|
|
|
fpart = fpart.encode('ascii')
|
|
|
except UnicodeEncodeError:
|
|
|
lspace = unicode(lspace)
|
|
|
rest = fpart + u' ' + rest
|
|
|
fpart = u''
|
|
|
|
|
|
#print 'line:<%s>' % line # dbg
|
|
|
#print 'esc <%s> fpart <%s> rest <%s>' % (esc,fpart.strip(),rest) # dbg
|
|
|
return lspace, esc, fpart.strip(), rest.lstrip()
|
|
|
|
|
|
|
|
|
# The escaped translators ALL receive a line where their own escape has been
|
|
|
# stripped. Only '?' is valid at the end of the line, all others can only be
|
|
|
# placed at the start.
|
|
|
|
|
|
class LineInfo(object):
|
|
|
"""A single line of input and associated info.
|
|
|
|
|
|
This is a utility class that mostly wraps the output of
|
|
|
:func:`split_user_input` into a convenient object to be passed around
|
|
|
during input transformations.
|
|
|
|
|
|
Includes the following as properties:
|
|
|
|
|
|
line
|
|
|
The original, raw line
|
|
|
|
|
|
lspace
|
|
|
Any early whitespace before actual text starts.
|
|
|
|
|
|
esc
|
|
|
The initial esc character (or characters, for double-char escapes like
|
|
|
'??' or '!!').
|
|
|
|
|
|
fpart
|
|
|
The 'function part', which is basically the maximal initial sequence
|
|
|
of valid python identifiers and the '.' character. This is what is
|
|
|
checked for alias and magic transformations, used for auto-calling,
|
|
|
etc.
|
|
|
|
|
|
rest
|
|
|
Everything else on the line.
|
|
|
"""
|
|
|
def __init__(self, line):
|
|
|
self.line = line
|
|
|
self.lspace, self.esc, self.fpart, self.rest = \
|
|
|
split_user_input(line)
|
|
|
|
|
|
def __str__(self):
|
|
|
return "LineInfo [%s|%s|%s|%s]" % (self.lspace, self.esc,
|
|
|
self.fpart, self.rest)
|
|
|
|
|
|
|
|
|
# Transformations of the special syntaxes that don't rely on an explicit escape
|
|
|
# character but instead on patterns on the input line
|
|
|
|
|
|
# The core transformations are implemented as standalone functions that can be
|
|
|
# tested and validated in isolation. Each of these uses a regexp, we
|
|
|
# pre-compile these and keep them close to each function definition for clarity
|
|
|
|
|
|
_assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
|
|
|
r'\s*=\s*!\s*(?P<cmd>.*)')
|
|
|
|
|
|
def transform_assign_system(line):
|
|
|
"""Handle the `files = !ls` syntax."""
|
|
|
m = _assign_system_re.match(line)
|
|
|
if m is not None:
|
|
|
cmd = m.group('cmd')
|
|
|
lhs = m.group('lhs')
|
|
|
expr = make_quoted_expr(cmd)
|
|
|
new_line = '%s = get_ipython().getoutput(%s)' % (lhs, expr)
|
|
|
return new_line
|
|
|
return line
|
|
|
|
|
|
|
|
|
_assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
|
|
|
r'\s*=\s*%\s*(?P<cmd>.*)')
|
|
|
|
|
|
def transform_assign_magic(line):
|
|
|
"""Handle the `a = %who` syntax."""
|
|
|
m = _assign_magic_re.match(line)
|
|
|
if m is not None:
|
|
|
cmd = m.group('cmd')
|
|
|
lhs = m.group('lhs')
|
|
|
expr = make_quoted_expr(cmd)
|
|
|
new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
|
|
|
return new_line
|
|
|
return line
|
|
|
|
|
|
|
|
|
_classic_prompt_re = re.compile(r'^([ \t]*>>> |^[ \t]*\.\.\. )')
|
|
|
|
|
|
def transform_classic_prompt(line):
|
|
|
"""Handle inputs that start with '>>> ' syntax."""
|
|
|
|
|
|
if not line or line.isspace():
|
|
|
return line
|
|
|
m = _classic_prompt_re.match(line)
|
|
|
if m:
|
|
|
return line[len(m.group(0)):]
|
|
|
else:
|
|
|
return line
|
|
|
|
|
|
|
|
|
_ipy_prompt_re = re.compile(r'^([ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
|
|
|
|
|
|
def transform_ipy_prompt(line):
|
|
|
"""Handle inputs that start classic IPython prompt syntax."""
|
|
|
|
|
|
if not line or line.isspace():
|
|
|
return line
|
|
|
#print 'LINE: %r' % line # dbg
|
|
|
m = _ipy_prompt_re.match(line)
|
|
|
if m:
|
|
|
#print 'MATCH! %r -> %r' % (line, line[len(m.group(0)):]) # dbg
|
|
|
return line[len(m.group(0)):]
|
|
|
else:
|
|
|
return line
|
|
|
|
|
|
|
|
|
class EscapedTransformer(object):
|
|
|
"""Class to transform lines that are explicitly escaped out."""
|
|
|
|
|
|
def __init__(self):
|
|
|
tr = { ESC_SHELL : self._tr_system,
|
|
|
ESC_SH_CAP : self._tr_system2,
|
|
|
ESC_HELP : self._tr_help,
|
|
|
ESC_HELP2 : self._tr_help,
|
|
|
ESC_MAGIC : self._tr_magic,
|
|
|
ESC_QUOTE : self._tr_quote,
|
|
|
ESC_QUOTE2 : self._tr_quote2,
|
|
|
ESC_PAREN : self._tr_paren }
|
|
|
self.tr = tr
|
|
|
|
|
|
# Support for syntax transformations that use explicit escapes typed by the
|
|
|
# user at the beginning of a line
|
|
|
@staticmethod
|
|
|
def _tr_system(line_info):
|
|
|
"Translate lines escaped with: !"
|
|
|
cmd = line_info.line.lstrip().lstrip(ESC_SHELL)
|
|
|
return '%sget_ipython().system(%s)' % (line_info.lspace,
|
|
|
make_quoted_expr(cmd))
|
|
|
|
|
|
@staticmethod
|
|
|
def _tr_system2(line_info):
|
|
|
"Translate lines escaped with: !!"
|
|
|
cmd = line_info.line.lstrip()[2:]
|
|
|
return '%sget_ipython().getoutput(%s)' % (line_info.lspace,
|
|
|
make_quoted_expr(cmd))
|
|
|
|
|
|
@staticmethod
|
|
|
def _tr_help(line_info):
|
|
|
"Translate lines escaped with: ?/??"
|
|
|
# A naked help line should just fire the intro help screen
|
|
|
if not line_info.line[1:]:
|
|
|
return 'get_ipython().show_usage()'
|
|
|
|
|
|
# There may be one or two '?' at the end, move them to the front so that
|
|
|
# the rest of the logic can assume escapes are at the start
|
|
|
line = line_info.line
|
|
|
if line.endswith('?'):
|
|
|
line = line[-1] + line[:-1]
|
|
|
if line.endswith('?'):
|
|
|
line = line[-1] + line[:-1]
|
|
|
line_info = LineInfo(line)
|
|
|
|
|
|
# From here on, simply choose which level of detail to get.
|
|
|
if line_info.esc == '?':
|
|
|
pinfo = 'pinfo'
|
|
|
elif line_info.esc == '??':
|
|
|
pinfo = 'pinfo2'
|
|
|
|
|
|
tpl = '%sget_ipython().magic("%s %s")'
|
|
|
return tpl % (line_info.lspace, pinfo,
|
|
|
' '.join([line_info.fpart, line_info.rest]).strip())
|
|
|
|
|
|
@staticmethod
|
|
|
def _tr_magic(line_info):
|
|
|
"Translate lines escaped with: %"
|
|
|
tpl = '%sget_ipython().magic(%s)'
|
|
|
cmd = make_quoted_expr(' '.join([line_info.fpart,
|
|
|
line_info.rest]).strip())
|
|
|
return tpl % (line_info.lspace, cmd)
|
|
|
|
|
|
@staticmethod
|
|
|
def _tr_quote(line_info):
|
|
|
"Translate lines escaped with: ,"
|
|
|
return '%s%s("%s")' % (line_info.lspace, line_info.fpart,
|
|
|
'", "'.join(line_info.rest.split()) )
|
|
|
|
|
|
@staticmethod
|
|
|
def _tr_quote2(line_info):
|
|
|
"Translate lines escaped with: ;"
|
|
|
return '%s%s("%s")' % (line_info.lspace, line_info.fpart,
|
|
|
line_info.rest)
|
|
|
|
|
|
@staticmethod
|
|
|
def _tr_paren(line_info):
|
|
|
"Translate lines escaped with: /"
|
|
|
return '%s%s(%s)' % (line_info.lspace, line_info.fpart,
|
|
|
", ".join(line_info.rest.split()))
|
|
|
|
|
|
def __call__(self, line):
|
|
|
"""Class to transform lines that are explicitly escaped out.
|
|
|
|
|
|
This calls the above _tr_* static methods for the actual line
|
|
|
translations."""
|
|
|
|
|
|
# Empty lines just get returned unmodified
|
|
|
if not line or line.isspace():
|
|
|
return line
|
|
|
|
|
|
# Get line endpoints, where the escapes can be
|
|
|
line_info = LineInfo(line)
|
|
|
|
|
|
# If the escape is not at the start, only '?' needs to be special-cased.
|
|
|
# All other escapes are only valid at the start
|
|
|
if not line_info.esc in self.tr:
|
|
|
if line.endswith(ESC_HELP):
|
|
|
return self._tr_help(line_info)
|
|
|
else:
|
|
|
# If we don't recognize the escape, don't modify the line
|
|
|
return line
|
|
|
|
|
|
return self.tr[line_info.esc](line_info)
|
|
|
|
|
|
|
|
|
# A function-looking object to be used by the rest of the code. The purpose of
|
|
|
# the class in this case is to organize related functionality, more than to
|
|
|
# manage state.
|
|
|
transform_escaped = EscapedTransformer()
|
|
|
|
|
|
|
|
|
class IPythonInputSplitter(InputSplitter):
|
|
|
"""An input splitter that recognizes all of IPython's special syntax."""
|
|
|
|
|
|
def push(self, lines):
|
|
|
"""Push one or more lines of IPython input.
|
|
|
"""
|
|
|
if not lines:
|
|
|
return super(IPythonInputSplitter, self).push(lines)
|
|
|
|
|
|
lines_list = lines.splitlines()
|
|
|
|
|
|
transforms = [transform_escaped, transform_assign_system,
|
|
|
transform_assign_magic, transform_ipy_prompt,
|
|
|
transform_classic_prompt]
|
|
|
|
|
|
# Transform logic
|
|
|
#
|
|
|
# We only apply the line transformers to the input if we have either no
|
|
|
# input yet, or complete input, or if the last line of the buffer ends
|
|
|
# with ':' (opening an indented block). This prevents the accidental
|
|
|
# transformation of escapes inside multiline expressions like
|
|
|
# triple-quoted strings or parenthesized expressions.
|
|
|
#
|
|
|
# The last heuristic, while ugly, ensures that the first line of an
|
|
|
# indented block is correctly transformed.
|
|
|
#
|
|
|
# FIXME: try to find a cleaner approach for this last bit.
|
|
|
|
|
|
# If we were in 'block' mode, since we're going to pump the parent
|
|
|
# class by hand line by line, we need to temporarily switch out to
|
|
|
# 'line' mode, do a single manual reset and then feed the lines one
|
|
|
# by one. Note that this only matters if the input has more than one
|
|
|
# line.
|
|
|
changed_input_mode = False
|
|
|
|
|
|
if len(lines_list)>1 and self.input_mode == 'cell':
|
|
|
self.reset()
|
|
|
changed_input_mode = True
|
|
|
saved_input_mode = 'cell'
|
|
|
self.input_mode = 'line'
|
|
|
|
|
|
try:
|
|
|
push = super(IPythonInputSplitter, self).push
|
|
|
for line in lines_list:
|
|
|
if self._is_complete or not self._buffer or \
|
|
|
(self._buffer and self._buffer[-1].rstrip().endswith(':')):
|
|
|
for f in transforms:
|
|
|
line = f(line)
|
|
|
|
|
|
out = push(line)
|
|
|
finally:
|
|
|
if changed_input_mode:
|
|
|
self.input_mode = saved_input_mode
|
|
|
|
|
|
return out
|
|
|
|
