Revert "Revert "pylint: upgrade to 1.3.1""

third_party/logilab/common/decorators.py

-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of logilab-common.
 #
 # logilab-common is free software: you can redistribute it and/or modify it under
 # the terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 2.1 of the License, or (at your option) any
 # later version.
 #
 # logilab-common is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
 """ A few useful function/method decorators. """
+
+from __future__ import print_function
+
 __docformat__ = "restructuredtext en"
 
 import sys
+import types
 from time import clock, time
+from inspect import isgeneratorfunction, getargspec
 
-from logilab.common.compat import callable, method_type
+from logilab.common.compat import method_type
 
 # XXX rewrite so we can use the decorator syntax when keyarg has to be specified
 
-def _is_generator_function(callableobj):
-    return callableobj.func_code.co_flags & 0x20
-
 class cached_decorator(object):
     def __init__(self, cacheattr=None, keyarg=None):
         self.cacheattr = cacheattr
         self.keyarg = keyarg
     def __call__(self, callableobj=None):
-        assert not _is_generator_function(callableobj), \
+        assert not isgeneratorfunction(callableobj), \
                'cannot cache generator function: %s' % callableobj
-        if callableobj.func_code.co_argcount == 1 or self.keyarg == 0:
+        if len(getargspec(callableobj).args) == 1 or self.keyarg == 0:
             cache = _SingleValueCache(callableobj, self.cacheattr)
         elif self.keyarg:
             cache = _MultiValuesKeyArgCache(callableobj, self.keyarg, self.cacheattr)
         else:
             cache = _MultiValuesCache(callableobj, self.cacheattr)
         return cache.closure()
 
 class _SingleValueCache(object):
     def __init__(self, callableobj, cacheattr=None):
         self.callable = callableobj
@@ skipping 11 matching lines @@
             setattr(self, __me.cacheattr, value)
             return value
 
     def closure(self):
         def wrapped(*args, **kwargs):
             return self.__call__(*args, **kwargs)
         wrapped.cache_obj = self
         try:
             wrapped.__doc__ = self.callable.__doc__
             wrapped.__name__ = self.callable.__name__
-            wrapped.func_name = self.callable.func_name
         except:
             pass
         return wrapped
 
     def clear(self, holder):
         holder.__dict__.pop(self.cacheattr, None)
 
 
 class _MultiValuesCache(_SingleValueCache):
     def _get_cache(self, holder):
@@ skipping 138 matching lines @@
         return method_type(self.func, instance, objtype)
     def __set__(self, instance, value):
         raise AttributeError("can't set attribute")
 
 
 def timed(f):
     def wrap(*args, **kwargs):
         t = time()
         c = clock()
         res = f(*args, **kwargs)
-        print '%s clock: %.9f / time: %.9f' % (f.__name__,
-                                               clock() - c, time() - t)
+        print('%s clock: %.9f / time: %.9f' % (f.__name__,
+                                               clock() - c, time() - t))
         return res
     return wrap
 
 
 def locked(acquire, release):
     """Decorator taking two methods to acquire/release a lock as argument,
     returning a decorator function which will call the inner method after
     having called acquire(self) et will call release(self) afterwards.
     """
     def decorator(f):
         def wrapper(self, *args, **kwargs):
             acquire(self)
             try:
                 return f(self, *args, **kwargs)
             finally:
                 release(self)
         return wrapper
     return decorator
 
 
 def monkeypatch(klass, methodname=None):
-    """Decorator extending class with the decorated callable
+    """Decorator extending class with the decorated callable. This is basically
+    a syntactic sugar vs class assignment.
+
     >>> class A:
     ...     pass
     >>> @monkeypatch(A)
     ... def meth(self):
     ...     return 12
     ...
     >>> a = A()
     >>> a.meth()
     12
     >>> @monkeypatch(A, 'foo')
     ... def meth(self):
     ...     return 12
     ...
     >>> a.foo()
     12
     """
     def decorator(func):
         try:
             name = methodname or func.__name__
         except AttributeError:
             raise AttributeError('%s has no __name__ attribute: '
                                  'you should provide an explicit `methodname`'
                                  % func)
-        if callable(func) and sys.version_info < (3, 0):
-            setattr(klass, name, method_type(func, None, klass))
-        else:
-            # likely a property
-            # this is quite borderline but usage already in the wild ...
-            setattr(klass, name, func)
+        setattr(klass, name, func)
         return func
     return decorator