Merge pull request #8960 from sieben/simplify_comparison

Simplify comparison

IPython/lib/deepreload.py

@@ -1,360 +1,360
 # -*- coding: utf-8 -*-
 """
 Provides a reload() function that acts recursively.
 
 Python's normal :func:`python:reload` function only reloads the module that it's
 passed. The :func:`reload` function in this module also reloads everything
 imported from that module, which is useful when you're changing files deep
 inside a package.
 
 To use this as your default reload function, type this for Python 2::
 
     import __builtin__
     from IPython.lib import deepreload
     __builtin__.reload = deepreload.reload
 
 Or this for Python 3::
 
     import builtins
     from IPython.lib import deepreload
     builtins.reload = deepreload.reload
 
 A reference to the original :func:`python:reload` is stored in this module as
 :data:`original_reload`, so you can restore it later.
 
 This code is almost entirely based on knee.py, which is a Python
 re-implementation of hierarchical module import.
 """
 from __future__ import print_function
 #*****************************************************************************
 #       Copyright (C) 2001 Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 from contextlib import contextmanager
 import imp
 import sys
 
 from types import ModuleType
 from warnings import warn
 
 from IPython.utils.py3compat import builtin_mod, builtin_mod_name
 
 original_import = builtin_mod.__import__
 
 @contextmanager
 def replace_import_hook(new_import):
     saved_import = builtin_mod.__import__
     builtin_mod.__import__ = new_import
     try:
         yield
     finally:
         builtin_mod.__import__ = saved_import
 
 def get_parent(globals, level):
     """
     parent, name = get_parent(globals, level)
 
     Return the package that an import is being performed in.  If globals comes
     from the module foo.bar.bat (not itself a package), this returns the
     sys.modules entry for foo.bar.  If globals is from a package's __init__.py,
     the package's entry in sys.modules is returned.
 
     If globals doesn't come from a package or a module in a package, or a
     corresponding entry is not found in sys.modules, None is returned.
     """
     orig_level = level
 
     if not level or not isinstance(globals, dict):
         return None, ''
 
     pkgname = globals.get('__package__', None)
 
     if pkgname is not None:
         # __package__ is set, so use it
         if not hasattr(pkgname, 'rindex'):
             raise ValueError('__package__ set to non-string')
         if len(pkgname) == 0:
             if level > 0:
                 raise ValueError('Attempted relative import in non-package')
             return None, ''
         name = pkgname
     else:
         # __package__ not set, so figure it out and set it
         if '__name__' not in globals:
             return None, ''
         modname = globals['__name__']
 
         if '__path__' in globals:
             # __path__ is set, so modname is already the package name
             globals['__package__'] = name = modname
         else:
             # Normal module, so work out the package name if any
             lastdot = modname.rfind('.')
-            if lastdot < 0 and level > 0:
+            if lastdot < 0 < level:
                 raise ValueError("Attempted relative import in non-package")
             if lastdot < 0:
                 globals['__package__'] = None
                 return None, ''
             globals['__package__'] = name = modname[:lastdot]
 
     dot = len(name)
     for x in range(level, 1, -1):
         try:
             dot = name.rindex('.', 0, dot)
         except ValueError:
             raise ValueError("attempted relative import beyond top-level "
                              "package")
     name = name[:dot]
 
     try:
         parent = sys.modules[name]
     except:
         if orig_level < 1:
             warn("Parent module '%.200s' not found while handling absolute "
                  "import" % name)
             parent = None
         else:
             raise SystemError("Parent module '%.200s' not loaded, cannot "
                               "perform relative import" % name)
 
     # We expect, but can't guarantee, if parent != None, that:
     # - parent.__name__ == name
     # - parent.__dict__ is globals
     # If this is violated...  Who cares?
     return parent, name
 
 def load_next(mod, altmod, name, buf):
     """
     mod, name, buf = load_next(mod, altmod, name, buf)
 
     altmod is either None or same as mod
     """
 
     if len(name) == 0:
         # completely empty module name should only happen in
         # 'from . import' (or '__import__("")')
         return mod, None, buf
 
     dot = name.find('.')
     if dot == 0:
         raise ValueError('Empty module name')
 
     if dot < 0:
         subname = name
         next = None
     else:
         subname = name[:dot]
         next = name[dot+1:]
 
     if buf != '':
         buf += '.'
     buf += subname
 
     result = import_submodule(mod, subname, buf)
     if result is None and mod != altmod:
         result = import_submodule(altmod, subname, subname)
         if result is not None:
             buf = subname
 
     if result is None:
         raise ImportError("No module named %.200s" % name)
 
     return result, next, buf
 
 # Need to keep track of what we've already reloaded to prevent cyclic evil
 found_now = {}
 
 def import_submodule(mod, subname, fullname):
     """m = import_submodule(mod, subname, fullname)"""
     # Require:
     # if mod == None: subname == fullname
     # else: mod.__name__ + "." + subname == fullname
 
     global found_now
     if fullname in found_now and fullname in sys.modules:
         m = sys.modules[fullname]
     else:
         print('Reloading', fullname)
         found_now[fullname] = 1
         oldm = sys.modules.get(fullname, None)
 
         if mod is None:
             path = None
         elif hasattr(mod, '__path__'):
             path = mod.__path__
         else:
             return None
 
         try:
             # This appears to be necessary on Python 3, because imp.find_module()
             # tries to import standard libraries (like io) itself, and we don't
             # want them to be processed by our deep_import_hook.
             with replace_import_hook(original_import):
                 fp, filename, stuff = imp.find_module(subname, path)
         except ImportError:
             return None
 
         try:
             m = imp.load_module(fullname, fp, filename, stuff)
         except:
             # load_module probably removed name from modules because of
             # the error.  Put back the original module object.
             if oldm:
                 sys.modules[fullname] = oldm
             raise
         finally:
             if fp: fp.close()
 
         add_submodule(mod, m, fullname, subname)
 
     return m
 
 def add_submodule(mod, submod, fullname, subname):
     """mod.{subname} = submod"""
     if mod is None:
         return #Nothing to do here.
 
     if submod is None:
         submod = sys.modules[fullname]
 
     setattr(mod, subname, submod)
 
     return
 
 def ensure_fromlist(mod, fromlist, buf, recursive):
     """Handle 'from module import a, b, c' imports."""
     if not hasattr(mod, '__path__'):
         return
     for item in fromlist:
         if not hasattr(item, 'rindex'):
             raise TypeError("Item in ``from list'' not a string")
         if item == '*':
             if recursive:
                 continue # avoid endless recursion
             try:
                 all = mod.__all__
             except AttributeError:
                 pass
             else:
                 ret = ensure_fromlist(mod, all, buf, 1)
                 if not ret:
                     return 0
         elif not hasattr(mod, item):
             import_submodule(mod, item, buf + '.' + item)
 
 def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
     """Replacement for __import__()"""
     parent, buf = get_parent(globals, level)
 
     head, name, buf = load_next(parent, None if level < 0 else parent, name, buf)
 
     tail = head
     while name:
         tail, name, buf = load_next(tail, tail, name, buf)
 
     # If tail is None, both get_parent and load_next found
     # an empty module name: someone called __import__("") or
     # doctored faulty bytecode
     if tail is None:
         raise ValueError('Empty module name')
 
     if not fromlist:
         return head
 
     ensure_fromlist(tail, fromlist, buf, 0)
     return tail
 
 modules_reloading = {}
 
 def deep_reload_hook(m):
     """Replacement for reload()."""
     if not isinstance(m, ModuleType):
         raise TypeError("reload() argument must be module")
 
     name = m.__name__
 
     if name not in sys.modules:
         raise ImportError("reload(): module %.200s not in sys.modules" % name)
 
     global modules_reloading
     try:
         return modules_reloading[name]
     except:
         modules_reloading[name] = m
 
     dot = name.rfind('.')
     if dot < 0:
         subname = name
         path = None
     else:
         try:
             parent = sys.modules[name[:dot]]
         except KeyError:
             modules_reloading.clear()
             raise ImportError("reload(): parent %.200s not in sys.modules" % name[:dot])
         subname = name[dot+1:]
         path = getattr(parent, "__path__", None)
 
     try:
         # This appears to be necessary on Python 3, because imp.find_module()
         # tries to import standard libraries (like io) itself, and we don't
         # want them to be processed by our deep_import_hook.
         with replace_import_hook(original_import):
             fp, filename, stuff  = imp.find_module(subname, path)
     finally:
         modules_reloading.clear()
 
     try:
         newm = imp.load_module(name, fp, filename, stuff)
     except:
          # load_module probably removed name from modules because of
          # the error.  Put back the original module object.
         sys.modules[name] = m
         raise
     finally:
         if fp: fp.close()
 
     modules_reloading.clear()
     return newm
 
 # Save the original hooks
 try:
     original_reload = builtin_mod.reload
 except AttributeError:
     original_reload = imp.reload    # Python 3
 
 # Replacement for reload()
 def reload(module, exclude=('sys', 'os.path', builtin_mod_name, '__main__')):
     """Recursively reload all modules used in the given module.  Optionally
     takes a list of modules to exclude from reloading.  The default exclude
     list contains sys, __main__, and __builtin__, to prevent, e.g., resetting
     display, exception, and io hooks.
     """
     global found_now
     for i in exclude:
         found_now[i] = 1
     try:
         with replace_import_hook(deep_import_hook):
             return deep_reload_hook(module)
     finally:
         found_now = {}
 
 
 def _dreload(module, **kwargs):
     """
     **deprecated**
 
     import reload explicitly from `IPython.lib.deepreload` to use it
 
     """
     warn("""
 injecting `dreload` in interactive namespace is deprecated, please import `reload` explicitly from `IPython.lib.deepreload`
 """, DeprecationWarning, stacklevel=2)
     reload(module, **kwargs)
 
 # Uncomment the following to automatically activate deep reloading whenever
 # this module is imported
 #builtin_mod.reload = reload

IPython/utils/PyColorize.py

@@ -1,315 +1,315
 # -*- coding: utf-8 -*-
 """
 Class and program to colorize python source code for ANSI terminals.
 
 Based on an HTML code highlighter by Jurgen Hermann found at:
 http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
 
 Modifications by Fernando Perez ([e-mail]).
 
 Information on the original HTML highlighter follows:
 
 MoinMoin - Python Source Parser
 
 Title: Colorize Python source using the built-in tokenizer
 
 Submitter: Jurgen Hermann
 Last Updated:2001/04/06
 
 Version no:1.2
 
 Description:
 
 This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
 Python source code to HTML markup, rendering comments, keywords,
 operators, numeric and string literals in different colors.
 
 It shows how to use the built-in keyword, token and tokenize modules to
 scan Python source code and re-emit it with no changes to its original
 formatting (which is the hard part).
 """
 from __future__ import print_function
 from __future__ import absolute_import
 from __future__ import unicode_literals
 
 __all__ = ['ANSICodeColors','Parser']
 
 _scheme_default = 'Linux'
 
 
 # Imports
 import keyword
 import os
 import sys
 import token
 import tokenize
 
 try:
     generate_tokens = tokenize.generate_tokens
 except AttributeError:
     # Python 3. Note that we use the undocumented _tokenize because it expects
     # strings, not bytes. See also Python issue #9969.
     generate_tokens = tokenize._tokenize
 
 from IPython.utils.coloransi import *
 from IPython.utils.py3compat import PY3
 
 if PY3:
     from io import StringIO
 else:
     from StringIO import StringIO
 
 #############################################################################
 ### Python Source Parser (does Hilighting)
 #############################################################################
 
 _KEYWORD = token.NT_OFFSET + 1
 _TEXT    = token.NT_OFFSET + 2
 
 #****************************************************************************
 # Builtin color schemes
 
 Colors = TermColors  # just a shorthand
 
 # Build a few color schemes
 NoColor = ColorScheme(
     'NoColor',{
     token.NUMBER     : Colors.NoColor,
     token.OP         : Colors.NoColor,
     token.STRING     : Colors.NoColor,
     tokenize.COMMENT : Colors.NoColor,
     token.NAME       : Colors.NoColor,
     token.ERRORTOKEN : Colors.NoColor,
 
     _KEYWORD         : Colors.NoColor,
     _TEXT            : Colors.NoColor,
 
     'normal'         : Colors.NoColor  # color off (usu. Colors.Normal)
     }  )
 
 LinuxColors = ColorScheme(
     'Linux',{
     token.NUMBER     : Colors.LightCyan,
     token.OP         : Colors.Yellow,
     token.STRING     : Colors.LightBlue,
     tokenize.COMMENT : Colors.LightRed,
     token.NAME       : Colors.Normal,
     token.ERRORTOKEN : Colors.Red,
 
     _KEYWORD         : Colors.LightGreen,
     _TEXT            : Colors.Yellow,
 
     'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
     } )
 
 LightBGColors = ColorScheme(
     'LightBG',{
     token.NUMBER     : Colors.Cyan,
     token.OP         : Colors.Blue,
     token.STRING     : Colors.Blue,
     tokenize.COMMENT : Colors.Red,
     token.NAME       : Colors.Normal,
     token.ERRORTOKEN : Colors.Red,
 
     _KEYWORD         : Colors.Green,
     _TEXT            : Colors.Blue,
 
     'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
     }  )
 
 # Build table of color schemes (needed by the parser)
 ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
                                   _scheme_default)
 
 class Parser:
     """ Format colored Python source.
     """
 
     def __init__(self, color_table=None,out = sys.stdout):
         """ Create a parser with a specified color table and output channel.
 
         Call format() to process code.
         """
         self.color_table = color_table and color_table or ANSICodeColors
         self.out = out
 
     def format(self, raw, out = None, scheme = ''):
         return self.format2(raw, out, scheme)[0]
 
     def format2(self, raw, out = None, scheme = ''):
         """ Parse and send the colored source.
 
         If out and scheme are not specified, the defaults (given to
         constructor) are used.
 
         out should be a file-type object. Optionally, out can be given as the
         string 'str' and the parser will automatically return the output in a
         string."""
 
         string_output = 0
         if out == 'str' or self.out == 'str' or \
            isinstance(self.out,StringIO):
             # XXX - I don't really like this state handling logic, but at this
             # point I don't want to make major changes, so adding the
             # isinstance() check is the simplest I can do to ensure correct
             # behavior.
             out_old = self.out
             self.out = StringIO()
             string_output = 1
         elif out is not None:
             self.out = out
 
         # Fast return of the unmodified input for NoColor scheme
         if scheme == 'NoColor':
             error = False
             self.out.write(raw)
             if string_output:
                 return raw,error
             else:
                 return None,error
 
         # local shorthands
         colors = self.color_table[scheme].colors
         self.colors = colors # put in object so __call__ sees it
 
         # Remove trailing whitespace and normalize tabs
         self.raw = raw.expandtabs().rstrip()
 
         # store line offsets in self.lines
         self.lines = [0, 0]
         pos = 0
         raw_find = self.raw.find
         lines_append = self.lines.append
         while 1:
             pos = raw_find('\n', pos) + 1
             if not pos: break
             lines_append(pos)
         lines_append(len(self.raw))
 
         # parse the source and write it
         self.pos = 0
         text = StringIO(self.raw)
 
         error = False
         try:
             for atoken in generate_tokens(text.readline):
                 self(*atoken)
         except tokenize.TokenError as ex:
             msg = ex.args[0]
             line = ex.args[1][0]
             self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
                            (colors[token.ERRORTOKEN],
                             msg, self.raw[self.lines[line]:],
                             colors.normal)
                            )
             error = True
         self.out.write(colors.normal+'\n')
         if string_output:
             output = self.out.getvalue()
             self.out = out_old
             return (output, error)
         return (None, error)
 
     def __call__(self, toktype, toktext, start_pos, end_pos, line):
         """ Token handler, with syntax highlighting."""
         (srow,scol) = start_pos
         (erow,ecol) = end_pos
         colors = self.colors
         owrite = self.out.write
 
         # line separator, so this works across platforms
         linesep = os.linesep
 
         # calculate new positions
         oldpos = self.pos
         newpos = self.lines[srow] + scol
         self.pos = newpos + len(toktext)
 
         # send the original whitespace, if needed
         if newpos > oldpos:
             owrite(self.raw[oldpos:newpos])
 
         # skip indenting tokens
         if toktype in [token.INDENT, token.DEDENT]:
             self.pos = newpos
             return
 
         # map token type to a color group
-        if token.LPAR <= toktype and toktype <= token.OP:
+        if token.LPAR <= toktype <= token.OP:
             toktype = token.OP
         elif toktype == token.NAME and keyword.iskeyword(toktext):
             toktype = _KEYWORD
         color = colors.get(toktype, colors[_TEXT])
 
         #print '<%s>' % toktext,    # dbg
 
         # Triple quoted strings must be handled carefully so that backtracking
         # in pagers works correctly. We need color terminators on _each_ line.
         if linesep in toktext:
             toktext = toktext.replace(linesep, '%s%s%s' %
                                       (colors.normal,linesep,color))
 
         # send text
         owrite('%s%s%s' % (color,toktext,colors.normal))
 
 def main(argv=None):
     """Run as a command-line script: colorize a python file or stdin using ANSI
     color escapes and print to stdout.
 
     Inputs:
 
       - argv(None): a list of strings like sys.argv[1:] giving the command-line
         arguments. If None, use sys.argv[1:].
     """
 
     usage_msg = """%prog [options] [filename]
 
 Colorize a python file or stdin using ANSI color escapes and print to stdout.
 If no filename is given, or if filename is -, read standard input."""
 
     import optparse
     parser = optparse.OptionParser(usage=usage_msg)
     newopt = parser.add_option
     newopt('-s','--scheme',metavar='NAME',dest='scheme_name',action='store',
            choices=['Linux','LightBG','NoColor'],default=_scheme_default,
            help="give the color scheme to use. Currently only 'Linux'\
  (default) and 'LightBG' and 'NoColor' are implemented (give without\
  quotes)")
 
     opts,args = parser.parse_args(argv)
 
     if len(args) > 1:
         parser.error("you must give at most one filename.")
 
     if len(args) == 0:
         fname = '-' # no filename given; setup to read from stdin
     else:
         fname = args[0]
 
     if fname == '-':
         stream = sys.stdin
     else:
         try:
             stream = open(fname)
         except IOError as msg:
             print(msg, file=sys.stderr)
             sys.exit(1)
 
     parser = Parser()
 
     # we need nested try blocks because pre-2.5 python doesn't support unified
     # try-except-finally
     try:
         try:
             # write colorized version to stdout
             parser.format(stream.read(),scheme=opts.scheme_name)
         except IOError as msg:
             # if user reads through a pager and quits, don't print traceback
             if msg.args != (32,'Broken pipe'):
                 raise
     finally:
         if stream is not sys.stdin:
             stream.close() # in case a non-handled exception happened above
 
 if __name__ == "__main__":
     main()