Source

py-patches / six

# HG changeset patch
# Parent 2c042feb5b3b1acebc7ceb565cac0a3b72d2a732

diff --git a/py/__init__.py b/py/__init__.py
--- a/py/__init__.py
+++ b/py/__init__.py
@@ -80,30 +80,30 @@ sys.modules['py.error'] = _apipkg.AliasM
     # backports and additions of builtins
     'builtin' : {
         '__doc__'        : '._builtin:__doc__',
-        'enumerate'      : '._builtin:enumerate',
-        'reversed'       : '._builtin:reversed',
-        'sorted'         : '._builtin:sorted',
-        'any'            : '._builtin:any',
-        'all'            : '._builtin:all',
-        'set'            : '._builtin:set',
-        'frozenset'      : '._builtin:frozenset',
+        'enumerate'      : 'six.moves:builtins.enumerate',
+        'reversed'       : 'six.moves:builtins.reversed',
+        'sorted'         : 'six.moves:builtins.sorted',
+        'any'            : 'six.moves:builtins.any',
+        'all'            : 'six.moves:builtins.all',
+        'set'            : 'six.moves:builtins.set',
+        'frozenset'      : 'six.moves:builtins.frozenset',
         'BaseException'  : '._builtin:BaseException',
         'GeneratorExit'  : '._builtin:GeneratorExit',
         '_sysex'         : '._builtin:_sysex',
-        'print_'         : '._builtin:print_',
-        '_reraise'       : '._builtin:_reraise',
+        'print_'         : 'six:print_',
+        '_reraise'       : 'six:reraise',
         '_tryimport'     : '._builtin:_tryimport',
-        'exec_'          : '._builtin:exec_',
-        '_basestring'    : '._builtin:_basestring',
+        'exec_'          : 'six:exec_',
+        '_basestring'    : 'six:string_types',
         '_totext'        : '._builtin:_totext',
         '_isbytes'       : '._builtin:_isbytes',
         '_istext'        : '._builtin:_istext',
         '_getimself'     : '._builtin:_getimself',
         '_getfuncdict'   : '._builtin:_getfuncdict',
         '_getcode'       : '._builtin:_getcode',
-        'builtins'       : '._builtin:builtins',
+        'builtins'       : 'six.moves:builtins',
         'execfile'       : '._builtin:execfile',
-        'callable'       : '._builtin:callable',
+        'callable'       : 'six:callable',
     },
 
     # input-output helping
diff --git a/py/_builtin.py b/py/_builtin.py
--- a/py/_builtin.py
+++ b/py/_builtin.py
@@ -1,96 +1,6 @@
 import sys
 
 try:
-    reversed = reversed
-except NameError:
-    def reversed(sequence):
-        """reversed(sequence) -> reverse iterator over values of the sequence
-
-        Return a reverse iterator
-        """
-        if hasattr(sequence, '__reversed__'):
-            return sequence.__reversed__()
-        if not hasattr(sequence, '__getitem__'):
-            raise TypeError("argument to reversed() must be a sequence")
-        return reversed_iterator(sequence)
-
-    class reversed_iterator(object):
-
-        def __init__(self, seq):
-            self.seq = seq
-            self.remaining = len(seq)
-
-        def __iter__(self):
-            return self
-
-        def next(self):
-            i = self.remaining
-            if i > 0:
-                i -= 1
-                item = self.seq[i]
-                self.remaining = i
-                return item
-            raise StopIteration
-
-        def __length_hint__(self):
-            return self.remaining
-
-try:
-    any = any
-except NameError:
-    def any(iterable):
-        for x in iterable:
-            if x:
-                return True
-        return False
-
-try:
-    all = all
-except NameError:
-    def all(iterable):
-        for x in iterable:
-            if not x:
-                return False
-        return True
-
-try:
-    sorted = sorted
-except NameError:
-    builtin_cmp = cmp # need to use cmp as keyword arg
-
-    def sorted(iterable, cmp=None, key=None, reverse=0):
-        use_cmp = None
-        if key is not None:
-            if cmp is None:
-                def use_cmp(x, y):
-                    return builtin_cmp(x[0], y[0])
-            else:
-                def use_cmp(x, y):
-                    return cmp(x[0], y[0])
-            l = [(key(element), element) for element in iterable]
-        else:
-            if cmp is not None:
-                use_cmp = cmp
-            l = list(iterable)
-        if use_cmp is not None:
-            l.sort(use_cmp)
-        else:
-            l.sort()
-        if reverse:
-            l.reverse()
-        if key is not None:
-            return [element for (_, element) in l]
-        return l
-
-try:
-    set, frozenset = set, frozenset
-except NameError:
-    from sets import set, frozenset
-
-# pass through
-enumerate = enumerate
-
-try:
     BaseException = BaseException
 except NameError:
     BaseException = Exception
@@ -107,12 +17,26 @@ except NameError:
 
 _sysex = (KeyboardInterrupt, SystemExit, MemoryError, GeneratorExit)
 
+import six
+
+def _getfuncdict(function):
+    return getattr(function, "__dict__", None)
+
+def _getcode(function):
+    return getattr(function, six._func_code, None)
+
+def _getimself(function):
+    return getattr(function, six._meth_self, None)
+
+def _isbytes(x):
+    return isinstance(x, six.binary_type)
+def _istext(x):
+    return isinstance(x, six.text_type)
+
 if sys.version_info >= (3, 0):
-    exec ("print_ = print ; exec_=exec")
     import builtins
 
     # some backward compatibility helpers
-    _basestring = str
     def _totext(obj, encoding=None):
         if isinstance(obj, bytes):
             obj = obj.decode(encoding)
@@ -120,20 +44,6 @@ if sys.version_info >= (3, 0):
             obj = str(obj)
         return obj
 
-    def _isbytes(x):
-        return isinstance(x, bytes)
-    def _istext(x):
-        return isinstance(x, str)
-
-    def _getimself(function):
-        return getattr(function, '__self__', None)
-
-    def _getfuncdict(function):
-        return getattr(function, "__dict__", None)
-
-    def _getcode(function):
-        return getattr(function, "__code__", None)
-
     def execfile(fn, globs=None, locs=None):
         if globs is None:
             back = sys._getframe(1)
@@ -150,78 +60,13 @@ if sys.version_info >= (3, 0):
         co = compile(source, fn, "exec", dont_inherit=True)
         exec_(co, globs, locs)
 
-    def callable(obj):
-        return hasattr(obj, "__call__")
-
 else:
     import __builtin__ as builtins
     _totext = unicode
-    _basestring = basestring
     execfile = execfile
-    callable = callable
-    def _isbytes(x):
-        return isinstance(x, str)
-    def _istext(x):
-        return isinstance(x, unicode)
 
-    def _getimself(function):
-        return getattr(function, 'im_self', None)
 
-    def _getfuncdict(function):
-        return getattr(function, "__dict__", None)
 
-    def _getcode(function):
-        try:
-            return getattr(function, "__code__")
-        except AttributeError:
-            return getattr(function, "func_code", None)
-
-    def print_(*args, **kwargs):
-        """ minimal backport of py3k print statement. """
-        sep = ' '
-        if 'sep' in kwargs:
-            sep = kwargs.pop('sep')
-        end = '\n'
-        if 'end' in kwargs:
-            end = kwargs.pop('end')
-        file = 'file' in kwargs and kwargs.pop('file') or sys.stdout
-        if kwargs:
-            args = ", ".join([str(x) for x in kwargs])
-            raise TypeError("invalid keyword arguments: %s" % args)
-        at_start = True
-        for x in args:
-            if not at_start:
-                file.write(sep)
-            file.write(str(x))
-            at_start = False
-        file.write(end)
-
-    def exec_(obj, globals=None, locals=None):
-        """ minimal backport of py3k exec statement. """
-        __tracebackhide__ = True
-        if globals is None:
-            frame = sys._getframe(1)
-            globals = frame.f_globals
-            if locals is None:
-                locals = frame.f_locals
-        elif locals is None:
-            locals = globals
-        exec2(obj, globals, locals)
-
-if sys.version_info >= (3,0):
-    def _reraise(cls, val, tb):
-        __tracebackhide__ = True
-        assert hasattr(val, '__traceback__')
-        raise val
-else:
-    exec ("""
-def _reraise(cls, val, tb):
-    __tracebackhide__ = True
-    raise cls, val, tb
-def exec2(obj, globals, locals):
-    __tracebackhide__ = True
-    exec obj in globals, locals
-""")
 
 def _tryimport(*names):
     """ return the first successfully imported module. """
@@ -231,4 +76,4 @@ def _tryimport(*names):
             return __import__(name, None, None, '__doc__')
         except ImportError:
             excinfo = sys.exc_info()
-    _reraise(*excinfo)
+    six.reraise(*excinfo)
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -36,8 +36,9 @@ def main():
                   'py._path',
                   'py._process',
         ],
+        install_requires=['six'],
         zip_safe=False,
     )
 
 if __name__ == '__main__':
-    main()
\ No newline at end of file
+    main()