upstream/ipython Commit - r1376:52b165ea

Fixes to testing....

Fernando Perez -

r1376:52b165ea

parent child

IPython/Extensions/astyle.py

0 +4 -2

                     ``bg`` as the background color and ``attrs`` as the attributes.
                     Examples:
+                    >>> Style(COLOR_RED, COLOR_BLACK)
+                    <Style fg=red bg=black attrs=0>
-                        >>> Style(COLOR_RED, COLOR_BLACK)
+                    >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE)
-                        >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE)
+                    <Style fg=yellow bg=blue attrs=bold|underline>
                     """
                     self.fg = fg
                     self.bg = bg

IPython/Extensions/ipipe.py

0 +32 -33

             ``ipipe`` supports "pipeline expressions", which is something resembling Unix
             pipes. An example is::
-                >>> ienv | isort("key.lower()")
+                py> ienv | isort("key.lower()")
             This gives a listing of all environment variables sorted by name.
               makes it possible to use dictionaries and modules in pipeline expressions,
               for example::
-                  >>> import sys
+                  py> import sys
-                  >>> sys | ifilter("isinstance(value, int)") | idump
+                  py> sys | ifilter("isinstance(value, int)") | idump
                   key        |value
                   api_version|      1012
                   dllhandle  | 503316480
                   hexversion |  33817328
                   maxint     |2147483647
                   maxunicode |     65535
-                  >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
+                  py> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
                   ...
               Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
               refer to the object to be filtered or sorted via the variable ``_`` and to any
               of the attributes of the object, i.e.::
-                  >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
+                  py> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
               does the same as::
-                  >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
+                  py> sys.modules | ifilter("value is not None") | isort("key.lower()")
               In addition to expression strings, it's possible to pass callables (taking
               the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``::
-                  >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
+                  py> sys | ifilter(lambda _:isinstance(_.value, int)) \
                   ...     | ieval(lambda _: (_.key, hex(_.value))) | idump
 |1
                   api_version|0x3f4
                 grp = None
             from IPython.external import simplegeneric
+            from IPython.external import path
-            import path
             try:
                 from IPython import genutils, generics
                 Examples::
-                    >>> ils
+                    py> ils
-                    >>> ils("/usr/local/lib/python2.4")
+                    py> ils("/usr/local/lib/python2.4")
-                    >>> ils("~")
+                    py> ils("~")
                 """
                 def __init__(self, base=os.curdir, dirs=True, files=True):
                     self.base = os.path.expanduser(base)
                 Examples::
-                    >>> iglob("*.py")
+                    py> iglob("*.py")
                 """
                 def __init__(self, glob):
                     self.glob = glob
                 """
                 List all files and directories in a directory and it's subdirectory::
-                    >>> iwalk
+                    py> iwalk
-                    >>> iwalk("/usr/local/lib/python2.4")
+                    py> iwalk("/usr/local/lib/python2.4")
-                    >>> iwalk("~")
+                    py> iwalk("~")
                 """
                 def __init__(self, base=os.curdir, dirs=True, files=True):
                     self.base = os.path.expanduser(base)
                 Example::
-                    >>> ipwd | isort("uid")
+                    py> ipwd | isort("uid")
                 """
                 def __iter__(self):
                     for entry in pwd.getpwall():
                 Example::
-                    >>> ienv
+                    py> ienv
                 """
                 def __iter__(self):
                 Example::
-                    >>> ihist
+                    py> ihist
-                    >>> ihist(True) (raw mode)
+                    py> ihist(True) (raw mode)
                 """
                 def __init__(self, raw=True):
                     self.raw = raw
                 Example::
-                    >>> ialias
+                    py> ialias
                 """
                 def __iter__(self):
                     api = ipapi.get()
                 Examples::
-                    >>> ix("ps x")
+                    py> ix("ps x")
-                    >>> ix("find .") | ifile
+                    py> ix("find .") | ifile
                 """
                 def __init__(self, cmd):
                     self.cmd = cmd
                 Examples::
-                    >>> ils | ifilter("_.isfile() and size>1000")
+                    py> ils | ifilter("_.isfile() and size>1000")
-                    >>> igrp | ifilter("len(mem)")
+                    py> igrp | ifilter("len(mem)")
-                    >>> sys.modules | ifilter(lambda _:_.value is not None)
+                    py> sys.modules | ifilter(lambda _:_.value is not None)
                 """
                 def __init__(self, expr, globals=None, errors="raiseifallfail"):
                 Examples::
-                    >>> ils | ieval("_.abspath()")
+                    py> ils | ieval("_.abspath()")
-                    >>> sys.path | ieval(ifile)
+                    py> sys.path | ieval(ifile)
                 """
                 def __init__(self, expr, globals=None, errors="raiseifallfail"):
                 Examples::
-                    >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
+                    py> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
                 """
                 def __iter__(self):
                     fields = ("index", "object")
                 Examples::
-                    >>> ils | isort("size")
+                    py> ils | isort("size")
-                    >>> ils | isort("_.isdir(), _.lower()", reverse=True)
+                    py> ils | isort("_.isdir(), _.lower()", reverse=True)
                 """
                 def __init__(self, key=None, globals=None, reverse=False):
                 Examples::
-                    >>> import time
+                    py> import time
-                    >>> icap("for i in range(10): print i, time.sleep(0.1)")
+                    py> icap("for i in range(10): print i, time.sleep(0.1)")
                 """
                 def __init__(self, expr, globals=None):

IPython/deep_reload.py

0 +1 0

             To enable it type:
                 >>> import __builtin__, deep_reload
                 >>> __builtin__.reload = deep_reload.reload
             You can then disable it with:
                 >>> __builtin__.reload = deep_reload.original_reload

IPython/genutils.py

0 +126 -112

                 def close(self):
                     pass
             class IOTerm:
                 """ Term holds the file or file-like objects for handling I/O operations.
                     self.cin  = IOStream(cin,sys.stdin)
                     self.cout = IOStream(cout,sys.stdout)
                     self.cerr = IOStream(cerr,sys.stderr)
             # Global variable to be used for all I/O
             Term = IOTerm()
             import IPython.rlineimpl as readline
             # Remake Term to use the readline i/o facilities
             if sys.platform == 'win32' and readline.have_readline:
                 Term = IOTerm(cout=readline._outputfile,cerr=readline._outputfile)
             #****************************************************************************
             # Generic warning/error printer, used by everything else
                 """Standard warning printer. Gives formatting consistency.
                 Output is sent to Term.cerr (sys.stderr by default).
                 Options:
                 -level(2): allows finer control:
 -> Do nothing, dummy function.
 -> Print message.
                 -exit_val (1): exit value returned by sys.exit() for a level 4
                 warning. Ignored for all other levels."""
                 if level>0:
                     header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
                     print >> Term.cerr, '%s%s' % (header[level],msg)
             #---------------------------------------------------------------------------
             # Debugging routines
+            #
             def debugx(expr,pre_msg=''):
                 """Print the value of an expression from the caller's frame.
                 Takes an expression, evaluates it in the caller's frame and prints both
                 the given expression and the resulting value (as well as a debug mark
                 indicating the name of the calling function.  The input must be of a form
                 An optional message can be passed, which will be prepended to the printed
                 expr->value pair."""
                 cf = sys._getframe(1)
                 print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
                                                eval(expr,cf.f_globals,cf.f_locals))
                     Return the *USER* CPU time in seconds since the start of the process.
                     This is done via a call to resource.getrusage, so it avoids the
                     wraparound problems in time.clock()."""
                     return resource.getrusage(resource.RUSAGE_SELF)[0]
                 def clocks():
                     """clocks() -> floating point number
                     Return the *SYSTEM* CPU time in seconds since the start of the process.
                     This is done via a call to resource.getrusage, so it avoids the
                     wraparound problems in time.clock()."""
                     return resource.getrusage(resource.RUSAGE_SELF)[1]
                 def clock():
                     """clock() -> floating point number
                     the process.  This is done via a call to resource.getrusage, so it
                     avoids the wraparound problems in time.clock()."""
                     u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
                     return u+s
                 def clock2():
                     """clock2() -> (t_user,t_system)
                 Under Unix, the return value is the sum of user+system time consumed by
                 the process, computed via the resource module.  This prevents problems
                 related to the wraparound effect which the time.clock() function has.
                 Under Windows the return value is in wall clock seconds. See the
                 documentation for the time module for more details."""
                 Options:
                 - verbose (0): print the command to be executed.
                 - debug (0): only print, do not actually execute.
                 - header (''): Header to print on screen prior to the executed command (it
                     if len(cwd) < 4:
                         return cwd
                     drivepart,tail = os.path.splitdrive(cwd)
-                parts = tail.split('/')
+                parts = tail.split('/')
                 if len(parts) > 2:
                     tail = '/'.join(parts[-2:])
                 return (drivepart + (
                     cwd == '/' and '/' or tail))
             # This function is used by ipython in a lot of places to make system calls.
             # We need it to be slightly different under win32, due to the vagaries of
                 Options:
                 - verbose (0): print the command to be executed.
                 - debug (0): only print, do not actually execute.
                 - header (''): Header to print on screen prior to the executed command (it
                 if verbose or debug: print header+cmd
                 # flush stdout so we don't mangle python's buffering
                 sys.stdout.flush()
                 if not debug:
                     platutils.set_term_title("IPy " + cmd)
                     os.system(cmd)
                 Note: a stateful version of this function is available through the
                 SystemExec class.
                 This is pretty much deprecated and rarely used,
                 genutils.getoutputerror may be what you need.
                 """
                 if verbose or debug: print header+cmd
                 Note: here we refer to the system and getoutput functions from this
                 library, not the ones from the standard python library.
                 This class offers the system and getoutput functions as methods, but the
                 verbose, debug and header parameters can be set for the instance (at
                 creation time or later) so that they don't need to be specified on each
                 An instance can then be created as:
                 >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
-                And used as:
-                >>> sysexec.xsys('echo "Hello Python"')
-                Calling: echo "Hello Python"
-                Hello Python
                 """
                 def __init__(self,verbose=0,debug=0,header='',split=0):
                     """Specify the instance's values for verbose, debug and header."""
                     setattr_list(self,'verbose debug header split')
                 Arguments:
                 - argv: list of arguments, typically sys.argv.
                 - names: list of option names. See DPyGetOpt docs for details on options
                 syntax.
                 defaults.update(getopt.optionValues)
                 args = getopt.freeValues
                 return defaults,args
             #----------------------------------------------------------------------------
             #----------------------------------------------------------------------------
             def read_dict(filename,type_conv=None,**opt):
-                """Read a dictionary of key=value pairs from an input file, optionally
+                r"""Read a dictionary of key=value pairs from an input file, optionally
                 performing conversions on the resulting values.
                 read_dict(filename,type_conv,**opt) -> dict
                     to make a list of all appearances.
                 Example:
-                If the input file test.ini has:
-                  i 3
-                  x 4.5
-                  y 5.5
-                  s hi ho
-                Then:
+                If the input file test.ini contains (we put it in a string to keep the test
+                self-contained):
+                >>> test_ini = '''\
+                ... i 3
+                ... x 4.5
+                ... y 5.5
+                ... s hi ho'''
+                Then we can use it as follows:
                 >>> type_conv={int:'i',float:'x',None:'s'}
-                >>> read_dict('test.ini')
-                {'i': '3', 's': 'hi ho', 'x': '4.5', 'y': '5.5'}
+                >>> d = read_dict(test_ini)
-                >>> read_dict('test.ini',type_conv)
-                {'i': 3, 's': 'hi ho', 'x': 4.5, 'y': '5.5'}
+                >>> sorted(d.items())
-                >>> read_dict('test.ini',type_conv,purge=1)
+                [('i', '3'), ('s', 'hi ho'), ('x', '4.5'), ('y', '5.5')]
-                {'i': 3, 's': 'hi ho', 'x': 4.5}
+                >>> d = read_dict(test_ini,type_conv)
+                >>> sorted(d.items())
+                [('i', 3), ('s', 'hi ho'), ('x', 4.5), ('y', '5.5')]
+                >>> d = read_dict(test_ini,type_conv,purge=True)
+                >>> sorted(d.items())
+                [('i', 3), ('s', 'hi ho'), ('x', 4.5)]
                 """
                 # starting config
                     raise ValueError, 'Unique keys must be given as a string, List or Tuple'
                 dict = {}
                 # first read in table of values as strings
-                file = open(filename,'r')
+                if '\n' in filename:
-                for line in file.readlines():
+                    lines = filename.splitlines()
+                    file = None
+                else:
+                    file = open(filename,'r')
+                    lines = file.readlines()
+                for line in lines:
                     line = line.strip()
                     if len(line) and line[0]=='#': continue
                     if len(line)>0:
                 Testing for truth in wrapper.called allows you to determine if a call to
                 func() was attempted and succeeded."""
                 def wrapper(*args,**kw):
                     wrapper.called = False
                     out = func(*args,**kw)
                 """
                 def f(*a,**k):
                     dhook_s = sys.displayhook
                     sys.displayhook = sys.__displayhook__
                     try:
                 This routine:
                   - reloads doctest
                   - resets its global 'master' attribute to None, so that multiple uses of
                   the module interactively don't produce cumulative reports.
                   - Monkeypatches its core test runner method to protect it from IPython's
                   modified displayhook.  Doctest expects the default displayhook behavior
                   deep down, so our modification breaks it completely.  For this reason, a
                 isdir = os.path.isdir
                 env = os.environ
                 # first, check py2exe distribution root directory for _ipython.
                 # This overrides all. Normally does not exist.
                 if '\\library.zip\\' in IPython.__file__.lower():
                     root, rest = IPython.__file__.lower().split('library.zip')
                     if isdir(root + '_ipython'):
                         os.environ["IPYKITROOT"] = root.rstrip('\\')
                         return root
                 try:
                     homedir = env['HOME']
                     if not isdir(homedir):
                     .n (or .nlstr): original value (the string itself).
                     .s (or .spstr): value as whitespace-separated string.
                     .p (or .paths): list of path objects
                 Any values which require transformations are computed only once and
                 cached.
                     except AttributeError:
                         self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
                         return self.__paths
                 p = paths = property(get_paths)
             def print_lsstring(arg):
                 """ Prettier (non-repr-like) and more informative printer for LSString """
                 print "LSString (.p, .n, .l, .s available). Value:"
                 print arg
             print_lsstring = result_display.when_type(LSString)(print_lsstring)
             #----------------------------------------------------------------------------
                     .n (or .nlstr): value as a string, joined on newlines.
                     .s (or .spstr): value as a string, joined on spaces.
                     .p (or .paths): list of path objects
                 Any values which require transformations are computed only once and
                 cached."""
                         return self.__nlstr
                 n = nlstr = property(get_nlstr)
                 def get_paths(self):
                     try:
                         return self.__paths
                     except AttributeError:
                         self.__paths = [path(p) for p in self if os.path.exists(p)]
                         return self.__paths
                 p = paths = property(get_paths)
                 def grep(self, pattern, prune = False, field = None):
                     """ Return all strings matching 'pattern' (a regex or callable)
                     This is case-insensitive. If prune is true, return all items
                     NOT matching the pattern.
                     If field is specified, the match must occur in the specified
                     whitespace-separated field.
                     Examples::
                         a.grep( lambda x: x.startswith('C') )
                         a.grep('Cha.*log', prune=1)
                         a.grep('chm', field=-1)
                     """
                     def match_target(s):
                         if field is None:
                             return s
                             return tgt
                         except IndexError:
                             return ""
                     if isinstance(pattern, basestring):
                         pred = lambda x : re.search(pattern, x, re.IGNORECASE)
                     else:
                         return SList([el for el in self if not pred(match_target(el))])
                 def fields(self, *fields):
                     """ Collect whitespace-separated fields from string list
                     Allows quick awk-like usage of string lists.
                     Example data (in var a, created by 'a = !ls -l')::
                         -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
                         drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython
                     a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
                     a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
                     (note the joining by space).
                     a.fields(-1) is ['ChangeLog', 'IPython']
                     IndexErrors are ignored.
                     Without args, fields() just split()'s the strings.
                     """
                     if len(fields) == 0:
                         return [el.split() for el in self]
                     res = SList()
                     for el in [f.split() for f in self]:
                         lineparts = []
                                 pass
                         if lineparts:
                             res.append(" ".join(lineparts))
                     return res
                 def sort(self,field= None,  nums = False):
                     """ sort by specified fields (see fields())
                     Example::
                         a.sort(1, nums = True)
                     Sorts a by second field, in numerical order (so that 21 > 3)
                     """
                     #decorate, sort, undecorate
                     if field is not None:
                         dsu = [[SList([line]).fields(field),  line] for line in self]
                             except ValueError:
                                 n = 0;
                             dsu[i][0] = n
                     dsu.sort()
                     return SList([t[1] for t in dsu])
                 if hasattr(arg,  'hideonce') and arg.hideonce:
                     arg.hideonce = False
                     return
                 nlprint(arg)
             print_slist = result_display.when_type(SList)(print_slist)
             #----------------------------------------------------------------------------
             def make_quoted_expr(s):
                 """Return string s in appropriate quotes, using raw string if possible.
                 Effectively this turns string: cd \ao\ao\
                 to: r"cd \ao\ao\_"[:-1]
                 Note the use of raw string and padding at the end to allow trailing backslash.
                 """
                 tail = ''
                 tailpadding = ''
                 raw  = ''
                         while new_line.endswith('\\'):
                             new_line = new_line[:-1] + raw_input(ps2)
                         lines.append(new_line)
                     return lines[:-1]  # don't return the termination command
                 except EOFError:
                     print
                             print
                         else:
                             raise
                 return answers[ans]
             #----------------------------------------------------------------------------
                 >>> qw(['a b','1 2',['m n','p q']],flat=1)
                 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
                 """
                 if type(words) in StringTypes:
                     return [word.strip() for word in words.split(sep,maxsplit)
                             if word and not word.isspace() ]
             #----------------------------------------------------------------------------
             def indent(str,nspaces=4,ntabs=0):
                 """Indent a string a given number of spaces or tabstops.
                 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
                 """
                 if str is None:
                     return outstr[:-len(ind)]
                 else:
                     return outstr
             #-----------------------------------------------------------------------------
             def native_line_ends(filename,backup=1):
                 """Convert (in-place) a file to line-ends native to the current OS.
                         os.remove(bak_filename)
                     except:
                         pass
             #----------------------------------------------------------------------------
             def get_pager_cmd(pager_cmd = None):
                 """Return a pager command.
                 Makes some attempts at finding an OS-correct one."""
                 if os.name == 'posix':
                     default_pager_cmd = 'less -r'  # -r for color control sequences
                 elif os.name in ['nt','dos']:
                         return
                     except IPython.ipapi.TryNext:
                         pass
                 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
                 TERM = os.environ.get('TERM','dumb')
                 if TERM in ['dumb','emacs'] and os.name != 'nt':
                 str_toprint = os.linesep.join(str_lines)
                 num_newlines = len(str_lines)
                 len_str = len(str_toprint)
                 # Dumb heuristics to guesstimate number of on-screen lines the string
                 # takes.  Very basic, but good enough for docstrings in reasonable
                 # terminals. If someone later feels like refining it, it's not hard.
                 Note: All elements in the input must be valid dictionary keys for this
                 routine to work, as it internally uses a dictionary for efficiency
                 reasons."""
                 unique = []
                 unique_dict = {}
                 for nn in elems:
                 An instance of this class called nlprint is available and callable as a
                 function.
                 nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
                 and using 'sep' to separate the index from the value. """
                 def __init__(self):
                     self.depth = 0
                 def __call__(self,lst,pos='',**kw):
                     """Prints the nested list numbering levels."""
                     kw.setdefault('indent',' ')
                     stop = kw['stop']; del kw['stop']
                     if self.depth == 0 and 'header' in kw.keys():
                         print kw['header']
                     for idx in range(start,stop):
                         elem = lst[idx]
                         if type(elem)==type([]):
                         raise ValueError,'getattr_list() takes only one optional argument'
                 else:
                     return map(lambda attr: getattr(obj,attr),alist)
             #----------------------------------------------------------------------------
             def map_method(method,object_list,*argseq,**kw):
                 """map_method(method,object_list,*args,**kw) -> list
                 are later not really valid for attribute access (many extension libraries
                 have such bugs).
                 """
                 # Start building the attribute list via dir(), and then complete it
                 # with a few extra special-purpose calls.
                 words = dir(obj)
             def wrap_deprecated(func, suggest = '<nothing>'):
                 def newFunc(*args, **kwargs):
                     warnings.warn("Call to deprecated function %s, use %s instead" %
                                   ( func.__name__, suggest),
                                   category=DeprecationWarning,
                                   stacklevel = 2)
                If it can't find a sensible answer, it returns 1 (though an error *may* make
                it return a large positive number that's actually incorrect).
                """
                # Many thanks to the Parallel Python project (http://www.parallelpython.com)
                # for the names of the keys we needed to look up for this function.  This
                # code was inspired by their equivalent function.

IPython/iplib.py

0 +17 -5

                     Simple usage example:
-                    In [1]: x = 'hello'
+                    In [7]: x = 'hello'
-                    In [2]: __IP.complete('x.l')
+                    In [8]: x
-                    Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
+                    Out[8]: 'hello'
+                    In [9]: print x
+                    hello
+                    In [10]: _ip.IP.complete('x.l')
+                    Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
+                    """
                     complete = self.Completer.complete
                     state = 0
                         state += 1
                     outcomps = comps.keys()
                     outcomps.sort()
+                    print "T:",text,"OC:",outcomps  # dbg
+                    #print "vars:",self.user_ns.keys()
                     return outcomps
                 def set_completer_frame(self, frame=None):
                     # previous call (which most likely existed in a separate scope).
                     local_varnames = local_ns.keys()
                     self.user_ns.update(local_ns)
+                    #self.user_ns['local_ns'] = local_ns  # dbg
                     # Patch for global embedding to make sure that things don't overwrite
                     # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
                 def handle_auto(self, line_info):
                     """Hande lines which can be auto-executed, quoting if requested."""
-                    #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
                     line    = line_info.line
                     iFun    = line_info.iFun
                     theRest = line_info.theRest
                     pre     = line_info.pre
                     continue_prompt = line_info.continue_prompt
                     obj = line_info.ofind(self)['obj']
+                    #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
                     # This should only be active for single-line input!
                     if continue_prompt:
+                        print 'getting out!'  # dbg
                         self.log(line,line,continue_prompt)
                         return line

IPython/ipstruct.py

0 +1 -1

                 accessed using the dictionary syntax. Again, an example:
                 This doesn't work:
-                >> s=Struct(4='hi')  #doctest: +IGNORE_EXCEPTION_DETAIL
+                py> s=Struct(4='hi')  #doctest: +IGNORE_EXCEPTION_DETAIL
                 Traceback (most recent call last):
                     ...
                 SyntaxError: keyword can't be an expression

IPython/kernel/contexts.py

0 +7 -1

                     # A comment
                     remote()  # this means the code below only runs remotely
                     print 'Hello remote world'
-                    x = 3.14
+                    x = range(10)
                     # Comments are OK
                     # Even misindented.
                     y = x+1
+                with pfor('i',sequence) as pr:
+                    print x[i]
+                print pr.x + pr.y

IPython/testing/parametric.py ~~IPython/testing/attic/parametric.py~~

0 renamed 0 0

NO CONTENT: file renamed from IPython/testing/attic/parametric.py to IPython/testing/parametric.py

IPython/testing/plugin/Makefile

0 +4 0

             	nosetests -vs --with-ipdoctest --doctest-tests --doctest-extension=txt \
                     test_combo.txt
+            iptest: plugin
+            	nosetests -vs --with-ipdoctest --doctest-tests --doctest-extension=txt \
+                    IPython
             IPython_doctest_plugin.egg-info: ipdoctest.py setup.py
             	python setup.py install --prefix=$(PREFIX)
             	touch $@

IPython/testing/plugin/ipdoctest.py

0 +16 -2

                     """Convert input IPython source into valid Python."""
                     out = []
                     newline = out.append
-                    for line in source.splitlines():
+                    for lnum,line in enumerate(source.splitlines()):
                         #newline(_ip.IPipython.prefilter(line,True))
-                        newline(_ip.IP.prefilter(line,True))
+                        newline(_ip.IP.prefilter(line,lnum>0))
                     newline('')  # ensure a closing newline, needed by doctest
                     return '\n'.join(out)
                     """
                     #print 'Filename:',filename  # dbg
+                    # temporarily hardcoded list, will move to driver later
+                    exclude = ['IPython/external/',
+                               'IPython/Extensions/ipy_',
+                               'IPython/platutils_win32',
+                               'IPython/frontend/cocoa',
+                               'IPython_doctest_plugin',
+                               'IPython/Gnuplot',
+                               'IPython/Extensions/PhysicalQIn']
+                    for fex in exclude:
+                        if fex in filename:  # substring
+                            #print '###>>> SKIP:',filename  # dbg
+                            return False
                     if is_extension_module(filename):
                         return True
                     else:

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages