adjust strip_prompts logic a bit further

- initial-only prompt is only stripped from the first line (only change from master)
- any prompt is stripped from the second line
- if a prompt is found in the first two lines,
  strip from the rest of the block

IPython/core/inputtransformer.py

@@ -1,498 +1,502 b''
 import abc
 import functools
 import re
 from StringIO import StringIO
 
 from IPython.core.splitinput import LineInfo
 from IPython.utils import tokenize2
 from IPython.utils.openpy import cookie_comment_re
 from IPython.utils.tokenize2 import generate_tokens, untokenize, TokenError
 
 #-----------------------------------------------------------------------------
 # 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_MAGIC2 = '%%'    # Call cell-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
 
 ESC_SEQUENCES = [ESC_SHELL, ESC_SH_CAP, ESC_HELP ,\
                  ESC_HELP2, ESC_MAGIC, ESC_MAGIC2,\
                  ESC_QUOTE, ESC_QUOTE2, ESC_PAREN ]
 
 
 class InputTransformer(object):
     """Abstract base class for line-based input transformers."""
     __metaclass__ = abc.ABCMeta
     
     @abc.abstractmethod
     def push(self, line):
         """Send a line of input to the transformer, returning the transformed
         input or None if the transformer is waiting for more input.
         
         Must be overridden by subclasses.
         """
         pass
     
     @abc.abstractmethod
     def reset(self):
         """Return, transformed any lines that the transformer has accumulated,
         and reset its internal state.
         
         Must be overridden by subclasses.
         """
         pass
     
     @classmethod
     def wrap(cls, func):
         """Can be used by subclasses as a decorator, to return a factory that
         will allow instantiation with the decorated object.
         """
         @functools.wraps(func)
         def transformer_factory(**kwargs):
             return cls(func, **kwargs)
         
         return transformer_factory
 
 class StatelessInputTransformer(InputTransformer):
     """Wrapper for a stateless input transformer implemented as a function."""
     def __init__(self, func):
         self.func = func
     
     def __repr__(self):
         return "StatelessInputTransformer(func={0!r})".format(self.func)
     
     def push(self, line):
         """Send a line of input to the transformer, returning the
         transformed input."""
         return self.func(line)
     
     def reset(self):
         """No-op - exists for compatibility."""
         pass
 
 class CoroutineInputTransformer(InputTransformer):
     """Wrapper for an input transformer implemented as a coroutine."""
     def __init__(self, coro, **kwargs):
         # Prime it
         self.coro = coro(**kwargs)
         next(self.coro)
     
     def __repr__(self):
         return "CoroutineInputTransformer(coro={0!r})".format(self.coro)
     
     def push(self, line):
         """Send a line of input to the transformer, returning the
         transformed input or None if the transformer is waiting for more
         input.
         """
         return self.coro.send(line)
     
     def reset(self):
         """Return, transformed any lines that the transformer has
         accumulated, and reset its internal state.
         """
         return self.coro.send(None)
 
 class TokenInputTransformer(InputTransformer):
     """Wrapper for a token-based input transformer.
     
     func should accept a list of tokens (5-tuples, see tokenize docs), and
     return an iterable which can be passed to tokenize.untokenize().
     """
     def __init__(self, func):
         self.func = func
         self.current_line = ""
         self.line_used = False
         self.reset_tokenizer()
     
     def reset_tokenizer(self):
         self.tokenizer = generate_tokens(self.get_line)
     
     def get_line(self):
         if self.line_used:
             raise TokenError
         self.line_used = True
         return self.current_line
     
     def push(self, line):
         self.current_line += line + "\n"
         if self.current_line.isspace():
             return self.reset()
         
         self.line_used = False
         tokens = []
         stop_at_NL = False
         try:
             for intok in self.tokenizer:
                 tokens.append(intok)
                 t = intok[0]
                 if t == tokenize2.NEWLINE or (stop_at_NL and t == tokenize2.NL):
                     # Stop before we try to pull a line we don't have yet
                     break
                 elif t == tokenize2.ERRORTOKEN:
                     stop_at_NL = True
         except TokenError:
             # Multi-line statement - stop and try again with the next line
             self.reset_tokenizer()
             return None
         
         return self.output(tokens)
     
     def output(self, tokens):
         self.current_line = ""
         self.reset_tokenizer()
         return untokenize(self.func(tokens)).rstrip('\n')
     
     def reset(self):
         l = self.current_line
         self.current_line = ""
         self.reset_tokenizer()
         if l:
             return l.rstrip('\n')
 
 class assemble_python_lines(TokenInputTransformer):
     def __init__(self):
         super(assemble_python_lines, self).__init__(None)
     
     def output(self, tokens):
         return self.reset()
 
 @CoroutineInputTransformer.wrap
 def assemble_logical_lines():
     """Join lines following explicit line continuations (\)"""
     line = ''
     while True:
         line = (yield line)
         if not line or line.isspace():
             continue
         
         parts = []
         while line is not None:
             if line.endswith('\\') and (not has_comment(line)):
                 parts.append(line[:-1])
                 line = (yield None) # Get another line
             else:
                 parts.append(line)
                 break
         
         # Output
         line = ''.join(parts)
 
 # Utilities
 def _make_help_call(target, esc, lspace, next_input=None):
     """Prepares a pinfo(2)/psearch call from a target name and the escape
     (i.e. ? or ??)"""
     method  = 'pinfo2' if esc == '??' \
                 else 'psearch' if '*' in target \
                 else 'pinfo'
     arg = " ".join([method, target])
     if next_input is None:
         return '%sget_ipython().magic(%r)' % (lspace, arg)
     else:
         return '%sget_ipython().set_next_input(%r);get_ipython().magic(%r)' % \
            (lspace, next_input, arg)
     
 # These define the transformations for the different escape characters.
 def _tr_system(line_info):
     "Translate lines escaped with: !"
     cmd = line_info.line.lstrip().lstrip(ESC_SHELL)
     return '%sget_ipython().system(%r)' % (line_info.pre, cmd)
 
 def _tr_system2(line_info):
     "Translate lines escaped with: !!"
     cmd = line_info.line.lstrip()[2:]
     return '%sget_ipython().getoutput(%r)' % (line_info.pre, cmd)
 
 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()'
 
     return _make_help_call(line_info.ifun, line_info.esc, line_info.pre)
 
 def _tr_magic(line_info):
     "Translate lines escaped with: %"
     tpl = '%sget_ipython().magic(%r)'
     if line_info.line.startswith(ESC_MAGIC2):
         return line_info.line
     cmd = ' '.join([line_info.ifun, line_info.the_rest]).strip()
     return tpl % (line_info.pre, cmd)
 
 def _tr_quote(line_info):
     "Translate lines escaped with: ,"
     return '%s%s("%s")' % (line_info.pre, line_info.ifun,
                          '", "'.join(line_info.the_rest.split()) )
 
 def _tr_quote2(line_info):
     "Translate lines escaped with: ;"
     return '%s%s("%s")' % (line_info.pre, line_info.ifun,
                            line_info.the_rest)
 
 def _tr_paren(line_info):
     "Translate lines escaped with: /"
     return '%s%s(%s)' % (line_info.pre, line_info.ifun,
                          ", ".join(line_info.the_rest.split()))
 
 tr = { ESC_SHELL  : _tr_system,
        ESC_SH_CAP : _tr_system2,
        ESC_HELP   : _tr_help,
        ESC_HELP2  : _tr_help,
        ESC_MAGIC  : _tr_magic,
        ESC_QUOTE  : _tr_quote,
        ESC_QUOTE2 : _tr_quote2,
        ESC_PAREN  : _tr_paren }
 
 @StatelessInputTransformer.wrap
 def escaped_commands(line):
     """Transform escaped commands - %magic, !system, ?help + various autocalls.
     """
     if not line or line.isspace():
         return line
     lineinf = LineInfo(line)
     if lineinf.esc not in tr:
         return line
     
     return tr[lineinf.esc](lineinf)
 
 _initial_space_re = re.compile(r'\s*')
 
 _help_end_re = re.compile(r"""(%{0,2}
                               [a-zA-Z_*][\w*]*        # Variable name
                               (\.[a-zA-Z_*][\w*]*)*   # .etc.etc
                               )
                               (\?\??)$                # ? or ??
                               """,
                               re.VERBOSE)
 
 def has_comment(src):
     """Indicate whether an input line has (i.e. ends in, or is) a comment.
 
     This uses tokenize, so it can distinguish comments from # inside strings.
 
     Parameters
     ----------
     src : string
       A single line input string.
 
     Returns
     -------
     comment : bool
         True if source has a comment.
     """
     readline = StringIO(src).readline
     toktypes = set()
     try:
         for t in generate_tokens(readline):
             toktypes.add(t[0])
     except TokenError:
         pass
     return(tokenize2.COMMENT in toktypes)
 
 
 @StatelessInputTransformer.wrap
 def help_end(line):
     """Translate lines with ?/?? at the end"""
     m = _help_end_re.search(line)
     if m is None or has_comment(line):
         return line
     target = m.group(1)
     esc = m.group(3)
     lspace = _initial_space_re.match(line).group(0)
 
     # If we're mid-command, put it back on the next prompt for the user.
     next_input = line.rstrip('?') if line.strip() != m.group(0) else None
 
     return _make_help_call(target, esc, lspace, next_input)
 
 
 @CoroutineInputTransformer.wrap
 def cellmagic(end_on_blank_line=False):
     """Captures & transforms cell magics.
     
     After a cell magic is started, this stores up any lines it gets until it is
     reset (sent None).
     """
     tpl = 'get_ipython().run_cell_magic(%r, %r, %r)'
     cellmagic_help_re = re.compile('%%\w+\?')
     line = ''
     while True:
         line = (yield line)
         # consume leading empty lines
         while not line:
             line = (yield line)
         
         if not line.startswith(ESC_MAGIC2):
             # This isn't a cell magic, idle waiting for reset then start over
             while line is not None:
                 line = (yield line)
             continue
         
         if cellmagic_help_re.match(line):
             # This case will be handled by help_end
             continue
         
         first = line
         body = []
         line = (yield None)
         while (line is not None) and \
                                 ((line.strip() != '') or not end_on_blank_line):
             body.append(line)
             line = (yield None)
         
         # Output
         magic_name, _, first = first.partition(' ')
         magic_name = magic_name.lstrip(ESC_MAGIC2)
         line = tpl % (magic_name, first, u'\n'.join(body))
 
 
-def _strip_prompts(prompt_re, continuation_re=None):
+def _strip_prompts(prompt_re, initial_re=None):
     """Remove matching input prompts from a block of input.
     
-    prompt_re is stripped only once, on either the first or second line.
-    If prompt_re is found on one of the first two lines,
-    continuation_re is stripped from lines thereafter.
+    Parameters
+    ----------
+    prompt_re : regular expression
+        A regular expression matching any input prompt (including continuation)
+    initial_re : regular expression, optional
+        A regular expression matching only the initial prompt, but not continuation.
+        If no initial expression is given, prompt_re will be used everywhere.
+        Used mainly for plain Python prompts, where the continuation prompt
+        ``...`` is a valid Python expression in Python 3, so shouldn't be stripped.
     
-    If continuation_re is unspecified, prompt_re will be used for both.
+    If initial_re and prompt_re differ,
+    only initial_re will be tested against the first line.
+    If any prompt is found on the first two lines,
+    prompts will be stripped from the rest of the block.
     """
-    if continuation_re is None:
-        continuation_re = prompt_re
+    if initial_re is None:
+        initial_re = prompt_re
     line = ''
     while True:
         line = (yield line)
         
         # First line of cell
         if line is None:
             continue
-        out, n1 = prompt_re.subn('', line, count=1)
+        out, n1 = initial_re.subn('', line, count=1)
         line = (yield out)
         
-        # Second line of cell, because people often copy from just after the
-        # first prompt, so we might not see it in the first line.
         if line is None:
             continue
-        # check for first prompt if not found on first line, continuation otherwise
-        if n1:
-            pat = continuation_re
-        else:
-            pat = prompt_re
-        out, n2 = pat.subn('', line, count=1)
+        # check for any prompt on the second line of the cell,
+        # because people often copy from just after the first prompt,
+        # so we might not see it in the first line.
+        out, n2 = prompt_re.subn('', line, count=1)
         line = (yield out)
         
         if n1 or n2:
-            # Found the input prompt in the first two lines - check for it in
+            # Found a prompt in the first two lines - check for it in
             # the rest of the cell as well.
             while line is not None:
-                line = (yield continuation_re.sub('', line, count=1))
+                line = (yield prompt_re.sub('', line, count=1))
         
         else:
             # Prompts not in input - wait for reset
             while line is not None:
                 line = (yield line)
 
 @CoroutineInputTransformer.wrap
 def classic_prompt():
     """Strip the >>>/... prompts of the Python interactive shell."""
     # FIXME: non-capturing version (?:...) usable?
-    prompt_re = re.compile(r'^(>>> ?)')
-    continuation_re = re.compile(r'^(>>> ?|\.\.\. ?)')
-    return _strip_prompts(prompt_re, continuation_re)
+    prompt_re = re.compile(r'^(>>> ?|\.\.\. ?)')
+    initial_re = re.compile(r'^(>>> ?)')
+    return _strip_prompts(prompt_re, initial_re)
 
 @CoroutineInputTransformer.wrap
 def ipy_prompt():
     """Strip IPython's In [1]:/...: prompts."""
     # FIXME: non-capturing version (?:...) usable?
     # FIXME: r'^(In \[\d+\]: | {3}\.{3,}: )' clearer?
-    prompt_re = re.compile(r'^(In \[\d+\]: )')
-    continuation_re = re.compile(r'^(In \[\d+\]: |\ \ \ \.\.\.+: )')
-    return _strip_prompts(prompt_re, continuation_re)
+    prompt_re = re.compile(r'^(In \[\d+\]: |\ \ \ \.\.\.+: )')
+    return _strip_prompts(prompt_re)
 
 
 @CoroutineInputTransformer.wrap
 def leading_indent():
     """Remove leading indentation.
     
     If the first line starts with a spaces or tabs, the same whitespace will be
     removed from each following line until it is reset.
     """
     space_re = re.compile(r'^[ \t]+')
     line = ''
     while True:
         line = (yield line)
         
         if line is None:
             continue
         
         m = space_re.match(line)
         if m:
             space = m.group(0)
             while line is not None:
                 if line.startswith(space):
                     line = line[len(space):]
                 line = (yield line)
         else:
             # No leading spaces - wait for reset
             while line is not None:
                 line = (yield line)
 
 
 @CoroutineInputTransformer.wrap
 def strip_encoding_cookie():
     """Remove encoding comment if found in first two lines
     
     If the first or second line has the `# coding: utf-8` comment,
     it will be removed.
     """
     line = ''
     while True:
         line = (yield line)
         # check comment on first two lines
         for i in range(2):
             if line is None:
                 break
             if cookie_comment_re.match(line):
                 line = (yield "")
             else:
                 line = (yield line)
         
         # no-op on the rest of the cell
         while line is not None:
             line = (yield line)
 
 
 assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
                               r'\s*=\s*!\s*(?P<cmd>.*)')
 assign_system_template = '%s = get_ipython().getoutput(%r)'
 @StatelessInputTransformer.wrap
 def assign_from_system(line):
     """Transform assignment from system commands (e.g. files = !ls)"""
     m = assign_system_re.match(line)
     if m is None:
         return line
     
     return assign_system_template % m.group('lhs', 'cmd')
 
 assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
                              r'\s*=\s*%\s*(?P<cmd>.*)')
 assign_magic_template = '%s = get_ipython().magic(%r)'
 @StatelessInputTransformer.wrap
 def assign_from_magic(line):
     """Transform assignment from magic commands (e.g. a = %who_ls)"""
     m = assign_magic_re.match(line)
     if m is None:
         return line
     
     return assign_magic_template % m.group('lhs', 'cmd')

IPython/core/tests/test_inputtransformer.py

@@ -1,456 +1,464 b''
 import tokenize
 import nose.tools as nt
 
 from IPython.testing import tools as tt
 from IPython.utils import py3compat
 u_fmt = py3compat.u_format
 
 from IPython.core import inputtransformer as ipt
 
 def transform_and_reset(transformer):
     transformer = transformer()
     def transform(inp):
         try:
             return transformer.push(inp)
         finally:
             transformer.reset()
     
     return transform
 
 # Transformer tests
 def transform_checker(tests, transformer, **kwargs):
     """Utility to loop over test inputs"""
     transformer = transformer(**kwargs)
     try:
         for inp, tr in tests:
             if inp is None:
                 out = transformer.reset()
             else:
                 out = transformer.push(inp)
             nt.assert_equal(out, tr)
     finally:
         transformer.reset()
 
 # Data for all the syntax tests in the form of lists of pairs of
 # raw/transformed input.  We store it here as a global dict so that we can use
 # it both within single-function tests and also to validate the behavior of the
 # larger objects
 
 syntax = \
   dict(assign_system =
        [(i,py3compat.u_format(o)) for i,o in \
        [(u'a =! ls', "a = get_ipython().getoutput({u}'ls')"),
         (u'b = !ls', "b = get_ipython().getoutput({u}'ls')"),
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ','    '),  # blank lines are kept intact
         ]],
 
        assign_magic =
        [(i,py3compat.u_format(o)) for i,o in \
        [(u'a =% who', "a = get_ipython().magic({u}'who')"),
         (u'b = %who', "b = get_ipython().magic({u}'who')"),
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ','    '),  # blank lines are kept intact
         ]],
 
        classic_prompt =
        [('>>> x=1', 'x=1'),
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ', '    '),  # blank lines are kept intact
         ],
 
        ipy_prompt =
        [('In [1]: x=1', 'x=1'),
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ','    '),  # blank lines are kept intact
         ],
 
        strip_encoding_cookie =
        [
         ('# -*- encoding: utf-8 -*-', ''),
         ('# coding: latin-1', ''),
        ],
 
 
        # Tests for the escape transformer to leave normal code alone
        escaped_noesc =
        [ ('    ', '    '),
          ('x=1', 'x=1'),
          ],
 
        # System calls
        escaped_shell =
        [(i,py3compat.u_format(o)) for i,o in \
        [ (u'!ls', "get_ipython().system({u}'ls')"),
          # Double-escape shell, this means to capture the output of the
          # subprocess and return it
          (u'!!ls', "get_ipython().getoutput({u}'ls')"),
          ]],
 
        # Help/object info
        escaped_help =
        [(i,py3compat.u_format(o)) for i,o in \
        [ (u'?', 'get_ipython().show_usage()'),
          (u'?x1', "get_ipython().magic({u}'pinfo x1')"),
          (u'??x2', "get_ipython().magic({u}'pinfo2 x2')"),
          (u'?a.*s', "get_ipython().magic({u}'psearch a.*s')"),
          (u'?%hist1', "get_ipython().magic({u}'pinfo %hist1')"),
          (u'?%%hist2', "get_ipython().magic({u}'pinfo %%hist2')"),
          (u'?abc = qwe', "get_ipython().magic({u}'pinfo abc')"),
          ]],
 
       end_help =
       [(i,py3compat.u_format(o)) for i,o in \
       [ (u'x3?', "get_ipython().magic({u}'pinfo x3')"),
         (u'x4??', "get_ipython().magic({u}'pinfo2 x4')"),
         (u'%hist1?', "get_ipython().magic({u}'pinfo %hist1')"),
         (u'%hist2??', "get_ipython().magic({u}'pinfo2 %hist2')"),
         (u'%%hist3?', "get_ipython().magic({u}'pinfo %%hist3')"),
         (u'%%hist4??', "get_ipython().magic({u}'pinfo2 %%hist4')"),
         (u'f*?', "get_ipython().magic({u}'psearch f*')"),
         (u'ax.*aspe*?', "get_ipython().magic({u}'psearch ax.*aspe*')"),
         (u'a = abc?', "get_ipython().set_next_input({u}'a = abc');"
                       "get_ipython().magic({u}'pinfo abc')"),
         (u'a = abc.qe??', "get_ipython().set_next_input({u}'a = abc.qe');"
                           "get_ipython().magic({u}'pinfo2 abc.qe')"),
         (u'a = *.items?', "get_ipython().set_next_input({u}'a = *.items');"
                           "get_ipython().magic({u}'psearch *.items')"),
         (u'plot(a?', "get_ipython().set_next_input({u}'plot(a');"
                      "get_ipython().magic({u}'pinfo a')"),
         (u'a*2 #comment?', 'a*2 #comment?'),
         ]],
 
        # Explicit magic calls
        escaped_magic =
        [(i,py3compat.u_format(o)) for i,o in \
        [ (u'%cd', "get_ipython().magic({u}'cd')"),
          (u'%cd /home', "get_ipython().magic({u}'cd /home')"),
          # Backslashes need to be escaped.
          (u'%cd C:\\User', "get_ipython().magic({u}'cd C:\\\\User')"),
          (u'    %magic', "    get_ipython().magic({u}'magic')"),
          ]],
 
        # Quoting with separate arguments
        escaped_quote =
        [ (',f', 'f("")'),
          (',f x', 'f("x")'),
          ('  ,f y', '  f("y")'),
          (',f a b', 'f("a", "b")'),
          ],
 
        # Quoting with single argument
        escaped_quote2 =
        [ (';f', 'f("")'),
          (';f x', 'f("x")'),
          ('  ;f y', '  f("y")'),
          (';f a b', 'f("a b")'),
          ],
 
        # Simply apply parens
        escaped_paren =
        [ ('/f', 'f()'),
          ('/f x', 'f(x)'),
          ('  /f y', '  f(y)'),
          ('/f a b', 'f(a, b)'),
          ],
 
        # Check that we transform prompts before other transforms
        mixed =
        [(i,py3compat.u_format(o)) for i,o in \
        [ (u'In [1]: %lsmagic', "get_ipython().magic({u}'lsmagic')"),
          (u'>>> %lsmagic', "get_ipython().magic({u}'lsmagic')"),
          (u'In [2]: !ls', "get_ipython().system({u}'ls')"),
          (u'In [3]: abs?', "get_ipython().magic({u}'pinfo abs')"),
          (u'In [4]: b = %who', "b = get_ipython().magic({u}'who')"),
          ]],
        )
 
 # multiline syntax examples.  Each of these should be a list of lists, with
 # each entry itself having pairs of raw/transformed input.  The union (with
 # '\n'.join() of the transformed inputs is what the splitter should produce
 # when fed the raw lines one at a time via push.
 syntax_ml = \
   dict(classic_prompt =
        [ [('>>> for i in range(10):','for i in range(10):'),
           ('...     print i','    print i'),
           ('... ', ''),
           ],
          [('>>> a="""','a="""'),
           ('... 123"""','123"""'),
           ],
          [('a="""','a="""'),
-          ('... 123','... 123'),
-          ('... 456"""','... 456"""'),
+          ('... 123','123'),
+          ('... 456"""','456"""'),
+          ],
+         [('a="""','a="""'),
+          ('>>> 123','123'),
+          ('... 456"""','456"""'),
           ],
          [('a="""','a="""'),
           ('123','123'),
           ('... 456"""','... 456"""'),
           ],
          [('....__class__','....__class__'),
          ],
          [('a=5', 'a=5'),
-          ('...', '...'),
+          ('...', ''),
          ],
          [('>>> def f(x):', 'def f(x):'),
           ('...', ''),
           ('...     return x', '    return x'),
           ],
         ],
 
        ipy_prompt =
        [ [('In [24]: for i in range(10):','for i in range(10):'),
           ('   ....:     print i','    print i'),
           ('   ....: ', ''),
           ],
          [('In [2]: a="""','a="""'),
           ('   ...: 123"""','123"""'),
           ],
          [('a="""','a="""'),
-          ('   ...: 123','   ...: 123'),
-          ('   ...: 456"""','   ...: 456"""'),
+          ('   ...: 123','123'),
+          ('   ...: 456"""','456"""'),
+          ],
+         [('a="""','a="""'),
+          ('In [1]: 123','123'),
+          ('   ...: 456"""','456"""'),
           ],
          [('a="""','a="""'),
           ('123','123'),
           ('   ...: 456"""','   ...: 456"""'),
           ],
          ],
 
        strip_encoding_cookie =
        [
         [
             ('# -*- coding: utf-8 -*-', ''),
             ('foo', 'foo'),
         ],
         [
             ('#!/usr/bin/env python', '#!/usr/bin/env python'),
             ('# -*- coding: latin-1 -*-', ''),
             # only the first-two lines
             ('# -*- coding: latin-1 -*-', '# -*- coding: latin-1 -*-'),
         ],
        ],
 
        multiline_datastructure_prompt =
        [ [('>>> a = [1,','a = [1,'),
           ('... 2]','2]'),
          ],
        ],
         
        multiline_datastructure =
        [ [('b = ("%s"', None),
           ('# comment', None),
           ('%foo )', 'b = ("%s"\n# comment\n%foo )'),
          ],
        ],
        
        leading_indent =
        [ [('    print "hi"','print "hi"'),
           ],
          [('  for a in range(5):','for a in range(5):'),
           ('    a*2','  a*2'),
           ],
          [('    a="""','a="""'),
           ('    123"""','123"""'),
            ],
          [('a="""','a="""'),
           ('    123"""','    123"""'),
           ],
        ],
        
        cellmagic =
        [ [(u'%%foo a', None),
           (None, u_fmt("get_ipython().run_cell_magic({u}'foo', {u}'a', {u}'')")),
           ],
          [(u'%%bar 123', None),
           (u'hello', None),
           (None , u_fmt("get_ipython().run_cell_magic({u}'bar', {u}'123', {u}'hello')")),
           ],
          [(u'a=5', 'a=5'),
           (u'%%cellmagic', '%%cellmagic'),
           ],
        ],
        
        escaped =
        [ [('%abc def \\', None),
           ('ghi', u_fmt("get_ipython().magic({u}'abc def ghi')")),
           ],
          [('%abc def \\', None),
           ('ghi\\', None),
           (None, u_fmt("get_ipython().magic({u}'abc def ghi')")),
           ],
        ],
        
        assign_magic =
        [ [(u'a = %bc de \\', None),
           (u'fg', u_fmt("a = get_ipython().magic({u}'bc de fg')")),
           ],
          [(u'a = %bc de \\', None),
           (u'fg\\', None),
           (None, u_fmt("a = get_ipython().magic({u}'bc de fg')")),
           ],
        ],
        
        assign_system =
        [ [(u'a = !bc de \\', None),
           (u'fg', u_fmt("a = get_ipython().getoutput({u}'bc de fg')")),
           ],
          [(u'a = !bc de \\', None),
           (u'fg\\', None),
           (None, u_fmt("a = get_ipython().getoutput({u}'bc de fg')")),
           ],
        ],
        )
 
 
 def test_assign_system():
     tt.check_pairs(transform_and_reset(ipt.assign_from_system), syntax['assign_system'])
 
 def test_assign_magic():
     tt.check_pairs(transform_and_reset(ipt.assign_from_magic), syntax['assign_magic'])
 
 def test_classic_prompt():
     tt.check_pairs(transform_and_reset(ipt.classic_prompt), syntax['classic_prompt'])
     for example in syntax_ml['classic_prompt']:
         transform_checker(example, ipt.classic_prompt)
     for example in syntax_ml['multiline_datastructure_prompt']:
         transform_checker(example, ipt.classic_prompt)
 
 
 def test_ipy_prompt():
     tt.check_pairs(transform_and_reset(ipt.ipy_prompt), syntax['ipy_prompt'])
     for example in syntax_ml['ipy_prompt']:
         transform_checker(example, ipt.ipy_prompt)
 
 def test_coding_cookie():
     tt.check_pairs(transform_and_reset(ipt.strip_encoding_cookie), syntax['strip_encoding_cookie'])
     for example in syntax_ml['strip_encoding_cookie']:
         transform_checker(example, ipt.strip_encoding_cookie)
 
 def test_assemble_logical_lines():
     tests = \
     [ [(u"a = \\", None),
        (u"123", u"a = 123"),
       ],
       [(u"a = \\", None),  # Test resetting when within a multi-line string
        (u"12 *\\", None),
        (None, u"a = 12 *"),
       ],
       [(u"# foo\\", u"# foo\\"), # Comments can't be continued like this
       ],
     ]
     for example in tests:
         transform_checker(example, ipt.assemble_logical_lines)
 
 def test_assemble_python_lines():
     tests = \
     [ [(u"a = '''", None),
        (u"abc'''", u"a = '''\nabc'''"),
       ],
       [(u"a = '''", None),  # Test resetting when within a multi-line string
        (u"def", None),
        (None, u"a = '''\ndef"),
       ],
       [(u"a = [1,", None),
        (u"2]", u"a = [1,\n2]"),
       ],
       [(u"a = [1,", None),  # Test resetting when within a multi-line string
        (u"2,", None),
        (None, u"a = [1,\n2,"),
       ],
     ] + syntax_ml['multiline_datastructure']
     for example in tests:
         transform_checker(example, ipt.assemble_python_lines)
 
 
 def test_help_end():
     tt.check_pairs(transform_and_reset(ipt.help_end), syntax['end_help'])
 
 def test_escaped_noesc():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_noesc'])
 
 
 def test_escaped_shell():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_shell'])
 
 
 def test_escaped_help():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_help'])
 
 
 def test_escaped_magic():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_magic'])
 
 
 def test_escaped_quote():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_quote'])
 
 
 def test_escaped_quote2():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_quote2'])
 
 
 def test_escaped_paren():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_paren'])
 
 
 def test_cellmagic():
     for example in syntax_ml['cellmagic']:
         transform_checker(example, ipt.cellmagic)
     
     line_example = [(u'%%bar 123', None),
                     (u'hello', None),
                     (u'' , u_fmt("get_ipython().run_cell_magic({u}'bar', {u}'123', {u}'hello')")),
                    ]
     transform_checker(line_example, ipt.cellmagic, end_on_blank_line=True)
 
 def test_has_comment():
     tests = [('text', False),
              ('text #comment', True),
              ('text #comment\n', True),
              ('#comment', True),
              ('#comment\n', True),
              ('a = "#string"', False),
              ('a = "#string" # comment', True),
              ('a #comment not "string"', True),
              ]
     tt.check_pairs(ipt.has_comment, tests)
 
 @ipt.TokenInputTransformer.wrap
 def decistmt(tokens):
     """Substitute Decimals for floats in a string of statements.
 
     Based on an example from the tokenize module docs.
     """
     result = []
     for toknum, tokval, _, _, _  in tokens:
         if toknum == tokenize.NUMBER and '.' in tokval:  # replace NUMBER tokens
             for newtok in [
                 (tokenize.NAME, 'Decimal'),
                 (tokenize.OP, '('),
                 (tokenize.STRING, repr(tokval)),
                 (tokenize.OP, ')')
             ]:
                 yield newtok
         else:
             yield (toknum, tokval)
 
 
 
 def test_token_input_transformer():
     tests = [(u'1.2', u_fmt(u"Decimal ({u}'1.2')")),
              (u'"1.2"', u'"1.2"'),
              ]
     tt.check_pairs(transform_and_reset(decistmt), tests)
     ml_tests = \
     [ [(u"a = 1.2; b = '''x", None),
        (u"y'''", u_fmt(u"a =Decimal ({u}'1.2');b ='''x\ny'''")),
       ],
       [(u"a = [1.2,", None),
        (u"3]", u_fmt(u"a =[Decimal ({u}'1.2'),\n3 ]")),
       ],
       [(u"a = '''foo", None),  # Test resetting when within a multi-line string
        (u"bar", None),
        (None, u"a = '''foo\nbar"),
       ],
     ]
     for example in ml_tests:
         transform_checker(example, decistmt)