Gecko [ goons4good.org ]

Name	Size	Permission	Date
ext	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
plugins	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
sphinx	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
tools	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
__init__.py	404 B	-rw-r--r--	2015-06-02 04:43
__init__.pyc	689 B	-rw-r--r--	2017-08-01 23:26
__init__.pyo	689 B	-rw-r--r--	2017-08-01 23:26
__main__.py	144 B	-rw-r--r--	2014-03-29 06:20
__main__.pyc	347 B	-rw-r--r--	2017-08-01 23:26
__main__.pyo	347 B	-rw-r--r--	2017-08-01 23:26
case.py	12.86 KB	-rw-r--r--	2014-08-13 05:44
case.pyc	14.23 KB	-rw-r--r--	2017-08-01 23:26
case.pyo	14.23 KB	-rw-r--r--	2017-08-01 23:26
commands.py	6.16 KB	-rw-r--r--	2015-04-04 04:52
commands.pyc	5.89 KB	-rw-r--r--	2017-08-01 23:26
commands.pyo	5.89 KB	-rw-r--r--	2017-08-01 23:26
config.py	24.65 KB	-rw-r--r--	2015-04-04 04:52
config.pyc	23.01 KB	-rw-r--r--	2017-08-01 23:26
config.pyo	23.01 KB	-rw-r--r--	2017-08-01 23:26
core.py	12.79 KB	-rw-r--r--	2015-04-04 04:52
core.pyc	12.84 KB	-rw-r--r--	2017-08-01 23:26
core.pyo	12.84 KB	-rw-r--r--	2017-08-01 23:26
exc.py	376 B	-rw-r--r--	2012-09-29 04:18
exc.pyc	576 B	-rw-r--r--	2017-08-01 23:26
exc.pyo	576 B	-rw-r--r--	2017-08-01 23:26
failure.py	1.22 KB	-rw-r--r--	2015-04-04 04:52
failure.pyc	1.87 KB	-rw-r--r--	2017-08-01 23:26
failure.pyo	1.87 KB	-rw-r--r--	2017-08-01 23:26
importer.py	5.84 KB	-rw-r--r--	2015-04-04 04:52
importer.pyc	5.45 KB	-rw-r--r--	2017-08-01 23:26
importer.pyo	5.45 KB	-rw-r--r--	2017-08-01 23:26
inspector.py	6.82 KB	-rw-r--r--	2012-09-29 04:18
inspector.pyc	5.8 KB	-rw-r--r--	2017-08-01 23:26
inspector.pyo	5.8 KB	-rw-r--r--	2017-08-01 23:26
loader.py	24.93 KB	-rw-r--r--	2015-06-01 06:53
loader.pyc	17.98 KB	-rw-r--r--	2017-08-01 23:26
loader.pyo	17.93 KB	-rw-r--r--	2017-08-01 23:26
proxy.py	6.72 KB	-rw-r--r--	2015-03-18 19:44
proxy.pyc	7.89 KB	-rw-r--r--	2017-08-01 23:26
proxy.pyo	7.69 KB	-rw-r--r--	2017-08-01 23:26
pyversion.py	7.3 KB	-rw-r--r--	2015-04-04 04:52
pyversion.pyc	8.86 KB	-rw-r--r--	2017-08-01 23:26
pyversion.pyo	8.86 KB	-rw-r--r--	2017-08-01 23:26
result.py	6.55 KB	-rw-r--r--	2015-04-04 04:52
result.pyc	6.65 KB	-rw-r--r--	2017-08-01 23:26
result.pyo	6.65 KB	-rw-r--r--	2017-08-01 23:26
selector.py	8.89 KB	-rw-r--r--	2015-04-04 04:52
selector.pyc	8.72 KB	-rw-r--r--	2017-08-01 23:26
selector.pyo	8.72 KB	-rw-r--r--	2017-08-01 23:26
suite.py	21.82 KB	-rw-r--r--	2015-04-04 04:52
suite.pyc	21.09 KB	-rw-r--r--	2017-08-01 23:26
suite.pyo	21.09 KB	-rw-r--r--	2017-08-01 23:26
twistedtools.py	5.4 KB	-rw-r--r--	2013-04-05 18:25
twistedtools.pyc	6.01 KB	-rw-r--r--	2017-08-01 23:26
twistedtools.pyo	6.01 KB	-rw-r--r--	2017-08-01 23:26
usage.txt	4.32 KB	-rw-r--r--	2015-04-04 04:52
util.py	19.83 KB	-rw-r--r--	2015-04-04 04:52
util.pyc	20.61 KB	-rw-r--r--	2017-08-01 23:26
util.pyo	20.61 KB	-rw-r--r--	2017-08-01 23:26

Rename

"""
This module contains fixups for using nose under different versions of Python.
"""
import sys
import os
import traceback
import types
import inspect
import nose.util

__all__ = ['make_instancemethod', 'cmp_to_key', 'sort_list', 'ClassType',
           'TypeType', 'UNICODE_STRINGS', 'unbound_method', 'ismethod',
           'bytes_', 'is_base_exception', 'force_unicode', 'exc_to_unicode',
           'format_exception']

# In Python 3.x, all strings are unicode (the call to 'unicode()' in the 2.x
# source will be replaced with 'str()' when running 2to3, so this test will
# then become true)
UNICODE_STRINGS = (type(unicode()) == type(str()))

if sys.version_info[:2] < (3, 0):
    def force_unicode(s, encoding='UTF-8'):
        try:
            s = unicode(s)
        except UnicodeDecodeError:
            s = str(s).decode(encoding, 'replace')

return s
else:
    def force_unicode(s, encoding='UTF-8'):
        return str(s)

# new.instancemethod() is obsolete for new-style classes (Python 3.x)
# We need to use descriptor methods instead.
try:
    import new
    def make_instancemethod(function, instance):
        return new.instancemethod(function.im_func, instance,
                                  instance.__class__)
except ImportError:
    def make_instancemethod(function, instance):
        return function.__get__(instance, instance.__class__)

# To be forward-compatible, we do all list sorts using keys instead of cmp
# functions.  However, part of the unittest.TestLoader API involves a
# user-provideable cmp function, so we need some way to convert that.
def cmp_to_key(mycmp):
    'Convert a cmp= function into a key= function'
    class Key(object):
        def __init__(self, obj):
            self.obj = obj
        def __lt__(self, other):
            return mycmp(self.obj, other.obj) < 0
        def __gt__(self, other):
            return mycmp(self.obj, other.obj) > 0
        def __eq__(self, other):
            return mycmp(self.obj, other.obj) == 0
    return Key

# Python 2.3 also does not support list-sorting by key, so we need to convert
# keys to cmp functions if we're running on old Python..
if sys.version_info < (2, 4):
    def sort_list(l, key, reverse=False):
        if reverse:
            return l.sort(lambda a, b: cmp(key(b), key(a)))
        else:
            return l.sort(lambda a, b: cmp(key(a), key(b)))
else:
    def sort_list(l, key, reverse=False):
        return l.sort(key=key, reverse=reverse)

# In Python 3.x, all objects are "new style" objects descended from 'type', and
# thus types.ClassType and types.TypeType don't exist anymore.  For
# compatibility, we make sure they still work.
if hasattr(types, 'ClassType'):
    ClassType = types.ClassType
    TypeType = types.TypeType
else:
    ClassType = type
    TypeType = type

# The following emulates the behavior (we need) of an 'unbound method' under
# Python 3.x (namely, the ability to have a class associated with a function
# definition so that things can do stuff based on its associated class)
class UnboundMethod:
    def __init__(self, cls, func):
        # Make sure we have all the same attributes as the original function,
        # so that the AttributeSelector plugin will work correctly...
        self.__dict__ = func.__dict__.copy()
        self._func = func
        self.__self__ = UnboundSelf(cls)
        if sys.version_info < (3, 0):
            self.im_class = cls
        self.__doc__ = getattr(func, '__doc__', None)

def address(self):
        cls = self.__self__.cls
        modname = cls.__module__
        module = sys.modules[modname]
        filename = getattr(module, '__file__', None)
        if filename is not None:
            filename = os.path.abspath(filename)
        return (nose.util.src(filename), modname, "%s.%s" % (cls.__name__,
                                                        self._func.__name__))

def __call__(self, *args, **kwargs):
        return self._func(*args, **kwargs)

def __getattr__(self, attr):
        return getattr(self._func, attr)

def __repr__(self):
        return '<unbound method %s.%s>' % (self.__self__.cls.__name__,
                                           self._func.__name__)

class UnboundSelf:
    def __init__(self, cls):
        self.cls = cls

# We have to do this hackery because Python won't let us override the
    # __class__ attribute...
    def __getattribute__(self, attr):
        if attr == '__class__':
            return self.cls
        else:
            return object.__getattribute__(self, attr)

def unbound_method(cls, func):
    if inspect.ismethod(func):
        return func
    if not inspect.isfunction(func):
        raise TypeError('%s is not a function' % (repr(func),))
    return UnboundMethod(cls, func)

def ismethod(obj):
    return inspect.ismethod(obj) or isinstance(obj, UnboundMethod)

# Make a pseudo-bytes function that can be called without the encoding arg:
if sys.version_info >= (3, 0):
    def bytes_(s, encoding='utf8'):
        if isinstance(s, bytes):
            return s
        return bytes(s, encoding)
else:
    def bytes_(s, encoding=None):
        return str(s)

if sys.version_info[:2] >= (2, 6):
    def isgenerator(o):
        if isinstance(o, UnboundMethod):
            o = o._func
        return inspect.isgeneratorfunction(o) or inspect.isgenerator(o)
else:
    try:
        from compiler.consts import CO_GENERATOR
    except ImportError:
        # IronPython doesn't have a complier module
        CO_GENERATOR=0x20

def isgenerator(func):
        try:
            return func.func_code.co_flags & CO_GENERATOR != 0
        except AttributeError:
            return False

# Make a function to help check if an exception is derived from BaseException.
# In Python 2.4, we just use Exception instead.
if sys.version_info[:2] < (2, 5):
    def is_base_exception(exc):
        return isinstance(exc, Exception)
else:
    def is_base_exception(exc):
        return isinstance(exc, BaseException)

if sys.version_info[:2] < (3, 0):
    def exc_to_unicode(ev, encoding='utf-8'):
        if is_base_exception(ev):
            if not hasattr(ev, '__unicode__'):
                # 2.5-
                if not hasattr(ev, 'message'):
                    # 2.4
                    msg = len(ev.args) and ev.args[0] or ''
                else:
                    msg = ev.message
                msg = force_unicode(msg, encoding=encoding)
                clsname = force_unicode(ev.__class__.__name__,
                        encoding=encoding)
                ev = u'%s: %s' % (clsname, msg)
        elif not isinstance(ev, unicode):
            ev = repr(ev)

return force_unicode(ev, encoding=encoding)
else:
    def exc_to_unicode(ev, encoding='utf-8'):
        return str(ev)

def format_exception(exc_info, encoding='UTF-8'):
    ec, ev, tb = exc_info

# Our exception object may have been turned into a string, and Python 3's
    # traceback.format_exception() doesn't take kindly to that (it expects an
    # actual exception object).  So we work around it, by doing the work
    # ourselves if ev is not an exception object.
    if not is_base_exception(ev):
        tb_data = force_unicode(
                ''.join(traceback.format_tb(tb)),
                encoding)
        ev = exc_to_unicode(ev)
        return tb_data + ev
    else:
        return force_unicode(
                ''.join(traceback.format_exception(*exc_info)),
                encoding)