ansible-core 2.19.3rc1__py3-none-any.whl → 2.20.0b2__py3-none-any.whl

ansible/_internal/__init__.py

@@ -30,10 +30,7 @@ def import_controller_module(module_name: str, /) -> t.Any:
     return importlib.import_module(module_name)
 
 
-_T = t.TypeVar('_T')
-
-
-def experimental(obj: _T) -> _T:
+def experimental[T](obj: T) -> T:
     """
     Decorator for experimental types and methods outside the `_internal` package which accept or expose internal types.
     As with internal APIs, these are subject to change at any time without notice.

ansible/_internal/_ansiballz/_builder.py

@@ -9,8 +9,6 @@ from ansible.module_utils._internal._ansiballz import _extensions
 from ansible.module_utils._internal._ansiballz._extensions import _debugpy, _pydevd, _coverage
 from ansible.constants import config
 
-_T = t.TypeVar('_T')
-
 
 class ExtensionManager:
     """AnsiballZ extension manager."""
@@ -101,7 +99,7 @@ class ExtensionManager:
         )
 
     @classmethod
-    def _get_options(cls, name: str, config_type: type[_T], task_vars: dict[str, object]) -> _T | None:
+    def _get_options[T](cls, name: str, config_type: type[T], task_vars: dict[str, object]) -> T | None:
         """Parse configuration from the named environment variable as the specified type, or None if not configured."""
         if (value := config.get_config_value(name, variables=task_vars)) is None:
             return None

ansible/_internal/_collection_proxy.py

@@ -3,26 +3,24 @@ from __future__ import annotations as _annotations
 import collections.abc as _c
 import typing as _t
 
-_T_co = _t.TypeVar('_T_co', covariant=True)
 
-
-class SequenceProxy(_c.Sequence[_T_co]):
+class SequenceProxy[T](_c.Sequence[T]):
     """A read-only sequence proxy."""
 
     # DTFIX5: needs unit test coverage
 
     __slots__ = ('__value',)
 
-    def __init__(self, value: _c.Sequence[_T_co]) -> None:
+    def __init__(self, value: _c.Sequence[T]) -> None:
         self.__value = value
 
     @_t.overload
-    def __getitem__(self, index: int) -> _T_co: ...
+    def __getitem__(self, index: int) -> T: ...
 
     @_t.overload
-    def __getitem__(self, index: slice) -> _c.Sequence[_T_co]: ...
+    def __getitem__(self, index: slice) -> _c.Sequence[T]: ...
 
-    def __getitem__(self, index: int | slice) -> _T_co | _c.Sequence[_T_co]:
+    def __getitem__(self, index: int | slice) -> T | _c.Sequence[T]:
         if isinstance(index, slice):
             return self.__class__(self.__value[index])
 
@@ -34,10 +32,10 @@ class SequenceProxy(_c.Sequence[_T_co]):
     def __contains__(self, item: object) -> bool:
         return item in self.__value
 
-    def __iter__(self) -> _t.Iterator[_T_co]:
+    def __iter__(self) -> _t.Iterator[T]:
         yield from self.__value
 
-    def __reversed__(self) -> _c.Iterator[_T_co]:
+    def __reversed__(self) -> _c.Iterator[T]:
         return reversed(self.__value)
 
     def index(self, *args) -> int:

ansible/_internal/_json/__init__.py

@@ -24,7 +24,6 @@ from ansible._internal._templating import _transform
 from ansible.module_utils import _internal
 from ansible.module_utils._internal import _datatag
 
-_T = t.TypeVar('_T')
 _sentinel = object()
 
 
@@ -115,7 +114,7 @@ class AnsibleVariableVisitor:
         if func := getattr(super(), '__exit__', None):
             func(*args, **kwargs)
 
-    def visit(self, value: _T) -> _T:
+    def visit[T](self, value: T) -> T:
         """
         Enforces Ansible's variable type system restrictions before a var is accepted in inventory. Also, conditionally implements template trust
         compatibility, depending on the plugin's declared understanding (or lack thereof). This always recursively copies inputs to fully isolate
@@ -143,7 +142,7 @@ class AnsibleVariableVisitor:
 
         return self._visit(None, key)  # key=None prevents state tracking from seeing the key as value
 
-    def _visit(self, key: t.Any, value: _T) -> _T:
+    def _visit[T](self, key: t.Any, value: T) -> T:
         """Internal implementation to recursively visit a data structure's contents."""
         self._current = key  # supports StateTrackingMixIn
 
@@ -168,7 +167,7 @@ class AnsibleVariableVisitor:
             value = value._native_copy()
             value_type = type(value)
 
-        result: _T
+        result: T
 
         # DTFIX-FUTURE: Visitor generally ignores dict/mapping keys by default except for debugging and schema-aware checking.
         #               It could be checking keys destined for variable storage to apply more strict rules about key shape and type.

ansible/_internal/_templating/_engine.py

@@ -193,7 +193,7 @@ class TemplateEngine:
         return self._variables
 
     @available_variables.setter
-    def available_variables(self, variables: dict[str, t.Any]) -> None:
+    def available_variables(self, variables: dict[str, t.Any] | ChainMap[str, t.Any]) -> None:
         self._variables = variables
 
     def resolve_variable_expression(

ansible/_internal/_templating/_jinja_plugins.py

@@ -29,7 +29,6 @@ from ._utils import LazyOptions, TemplateContext
 
 _display = Display()
 
-_TCallable = t.TypeVar("_TCallable", bound=t.Callable)
 _ITERATOR_TYPES: t.Final = (c.Iterator, c.ItemsView, c.KeysView, c.ValuesView, range)
 
 
@@ -174,7 +173,7 @@ class _DirectCall:
     _marker_attr: t.Final[str] = "_directcall"
 
     @classmethod
-    def mark(cls, src: _TCallable) -> _TCallable:
+    def mark[T: t.Callable](cls, src: T) -> T:
         setattr(src, cls._marker_attr, True)
         return src
 

ansible/_internal/_wrapt.py

@@ -23,7 +23,7 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-# copied from https://github.com/GrahamDumpleton/wrapt/blob/1.15.0/src/wrapt/wrappers.py
+# copied from https://github.com/GrahamDumpleton/wrapt/blob/1.17.2/src/wrapt/wrappers.py
 
 # LOCAL PATCHES:
 # - disabled optional relative import of the _wrappers C extension; we shouldn't need it
@@ -31,13 +31,10 @@
 from __future__ import annotations
 
 # The following makes it easier for us to script updates of the bundled code
-_BUNDLED_METADATA = {"pypi_name": "wrapt", "version": "1.15.0"}
+_BUNDLED_METADATA = {"pypi_name": "wrapt", "version": "1.17.2"}
 
-import os
 import sys
-import functools
 import operator
-import weakref
 import inspect
 
 PY2 = sys.version_info[0] == 2
@@ -129,6 +126,9 @@ class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
         except AttributeError:
             pass
 
+    def __self_setattr__(self, name, value):
+        object.__setattr__(self, name, value)
+
     @property
     def __name__(self):
         return self.__wrapped__.__name__
@@ -161,12 +161,15 @@ class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
                 type(self.__wrapped__).__name__,
                 id(self.__wrapped__))
 
+    def __format__(self, format_spec):
+        return format(self.__wrapped__, format_spec)
+
     def __reversed__(self):
         return reversed(self.__wrapped__)
 
     if not PY2:
-        def __round__(self):
-            return round(self.__wrapped__)
+        def __round__(self, ndigits=None):
+            return round(self.__wrapped__, ndigits)
 
     if sys.hexversion >= 0x03070000:
         def __mro_entries__(self, bases):
@@ -472,7 +475,7 @@ class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
 
     def __reduce__(self):
         raise NotImplementedError(
-                'object proxy must define __reduce_ex__()')
+                'object proxy must define __reduce__()')
 
     def __reduce_ex__(self, protocol):
         raise NotImplementedError(
@@ -525,10 +528,10 @@ class PartialCallableObjectProxy(ObjectProxy):
 class _FunctionWrapperBase(ObjectProxy):
 
     __slots__ = ('_self_instance', '_self_wrapper', '_self_enabled',
-            '_self_binding', '_self_parent')
+            '_self_binding', '_self_parent', '_self_owner')
 
     def __init__(self, wrapped, instance, wrapper, enabled=None,
-            binding='function', parent=None):
+            binding='callable', parent=None, owner=None):
 
         super(_FunctionWrapperBase, self).__init__(wrapped)
 
@@ -537,60 +540,68 @@ class _FunctionWrapperBase(ObjectProxy):
         object.__setattr__(self, '_self_enabled', enabled)
         object.__setattr__(self, '_self_binding', binding)
         object.__setattr__(self, '_self_parent', parent)
+        object.__setattr__(self, '_self_owner', owner)
 
     def __get__(self, instance, owner):
-        # This method is actually doing double duty for both unbound and
-        # bound derived wrapper classes. It should possibly be broken up
-        # and the distinct functionality moved into the derived classes.
-        # Can't do that straight away due to some legacy code which is
-        # relying on it being here in this base class.
+        # This method is actually doing double duty for both unbound and bound
+        # derived wrapper classes. It should possibly be broken up and the
+        # distinct functionality moved into the derived classes. Can't do that
+        # straight away due to some legacy code which is relying on it being
+        # here in this base class.
         #
-        # The distinguishing attribute which determines whether we are
-        # being called in an unbound or bound wrapper is the parent
-        # attribute. If binding has never occurred, then the parent will
-        # be None.
+        # The distinguishing attribute which determines whether we are being
+        # called in an unbound or bound wrapper is the parent attribute. If
+        # binding has never occurred, then the parent will be None.
         #
-        # First therefore, is if we are called in an unbound wrapper. In
-        # this case we perform the binding.
+        # First therefore, is if we are called in an unbound wrapper. In this
+        # case we perform the binding.
         #
-        # We have one special case to worry about here. This is where we
-        # are decorating a nested class. In this case the wrapped class
-        # would not have a __get__() method to call. In that case we
-        # simply return self.
+        # We have two special cases to worry about here. These are where we are
+        # decorating a class or builtin function as neither provide a __get__()
+        # method to call. In this case we simply return self.
         #
-        # Note that we otherwise still do binding even if instance is
-        # None and accessing an unbound instance method from a class.
-        # This is because we need to be able to later detect that
-        # specific case as we will need to extract the instance from the
-        # first argument of those passed in.
+        # Note that we otherwise still do binding even if instance is None and
+        # accessing an unbound instance method from a class. This is because we
+        # need to be able to later detect that specific case as we will need to
+        # extract the instance from the first argument of those passed in.
 
         if self._self_parent is None:
-            if not inspect.isclass(self.__wrapped__):
-                descriptor = self.__wrapped__.__get__(instance, owner)
+            # Technically can probably just check for existence of __get__ on
+            # the wrapped object, but this is more explicit.
+
+            if self._self_binding == 'builtin':
+                return self
 
-                return self.__bound_function_wrapper__(descriptor, instance,
-                        self._self_wrapper, self._self_enabled,
-                        self._self_binding, self)
+            if self._self_binding == "class":
+                return self
 
-            return self
+            binder = getattr(self.__wrapped__, '__get__', None)
 
-        # Now we have the case of binding occurring a second time on what
-        # was already a bound function. In this case we would usually
-        # return ourselves again. This mirrors what Python does.
+            if binder is None:
+                return self
+
+            descriptor =  binder(instance, owner)
+
+            return self.__bound_function_wrapper__(descriptor, instance,
+                    self._self_wrapper, self._self_enabled,
+                    self._self_binding, self, owner)
+
+        # Now we have the case of binding occurring a second time on what was
+        # already a bound function. In this case we would usually return
+        # ourselves again. This mirrors what Python does.
         #
-        # The special case this time is where we were originally bound
-        # with an instance of None and we were likely an instance
-        # method. In that case we rebind against the original wrapped
-        # function from the parent again.
+        # The special case this time is where we were originally bound with an
+        # instance of None and we were likely an instance method. In that case
+        # we rebind against the original wrapped function from the parent again.
 
-        if self._self_instance is None and self._self_binding == 'function':
+        if self._self_instance is None and self._self_binding in ('function', 'instancemethod', 'callable'):
             descriptor = self._self_parent.__wrapped__.__get__(
                     instance, owner)
 
             return self._self_parent.__bound_function_wrapper__(
                     descriptor, instance, self._self_wrapper,
                     self._self_enabled, self._self_binding,
-                    self._self_parent)
+                    self._self_parent, owner)
 
         return self
 
@@ -617,7 +628,7 @@ class _FunctionWrapperBase(ObjectProxy):
         # a function that was already bound to an instance. In that case
         # we want to extract the instance from the function and use it.
 
-        if self._self_binding in ('function', 'classmethod'):
+        if self._self_binding in ('function', 'instancemethod', 'classmethod', 'callable'):
             if self._self_instance is None:
                 instance = getattr(self.__wrapped__, '__self__', None)
                 if instance is not None:
@@ -668,11 +679,11 @@ class BoundFunctionWrapper(_FunctionWrapperBase):
 
         self, args = _unpack_self(*args)
 
-        # If enabled has been specified, then evaluate it at this point
-        # and if the wrapper is not to be executed, then simply return
-        # the bound function rather than a bound wrapper for the bound
-        # function. When evaluating enabled, if it is callable we call
-        # it, otherwise we evaluate it as a boolean.
+        # If enabled has been specified, then evaluate it at this point and if
+        # the wrapper is not to be executed, then simply return the bound
+        # function rather than a bound wrapper for the bound function. When
+        # evaluating enabled, if it is callable we call it, otherwise we
+        # evaluate it as a boolean.
 
         if self._self_enabled is not None:
             if callable(self._self_enabled):
@@ -681,18 +692,27 @@ class BoundFunctionWrapper(_FunctionWrapperBase):
             elif not self._self_enabled:
                 return self.__wrapped__(*args, **kwargs)
 
-        # We need to do things different depending on whether we are
-        # likely wrapping an instance method vs a static method or class
-        # method.
+        # We need to do things different depending on whether we are likely
+        # wrapping an instance method vs a static method or class method.
 
         if self._self_binding == 'function':
+            if self._self_instance is None and args:
+                instance, newargs = args[0], args[1:]
+                if isinstance(instance, self._self_owner):
+                    wrapped = PartialCallableObjectProxy(self.__wrapped__, instance)
+                    return self._self_wrapper(wrapped, instance, newargs, kwargs)
+
+            return self._self_wrapper(self.__wrapped__, self._self_instance,
+                    args, kwargs)
+
+        elif self._self_binding == 'callable':
             if self._self_instance is None:
                 # This situation can occur where someone is calling the
-                # instancemethod via the class type and passing the instance
-                # as the first argument. We need to shift the args before
-                # making the call to the wrapper and effectively bind the
-                # instance to the wrapped function using a partial so the
-                # wrapper doesn't see anything as being different.
+                # instancemethod via the class type and passing the instance as
+                # the first argument. We need to shift the args before making
+                # the call to the wrapper and effectively bind the instance to
+                # the wrapped function using a partial so the wrapper doesn't
+                # see anything as being different.
 
                 if not args:
                     raise TypeError('missing 1 required positional argument')
@@ -794,259 +814,43 @@ class FunctionWrapper(_FunctionWrapperBase):
         # or patch it in the __dict__ of the class type.
         #
         # So to get the best outcome we can, whenever we aren't sure what
-        # it is, we label it as a 'function'. If it was already bound and
+        # it is, we label it as a 'callable'. If it was already bound and
         # that is rebound later, we assume that it will be an instance
-        # method and try an cope with the possibility that the 'self'
+        # method and try and cope with the possibility that the 'self'
         # argument it being passed as an explicit argument and shuffle
         # the arguments around to extract 'self' for use as the instance.
 
-        if isinstance(wrapped, classmethod):
-            binding = 'classmethod'
-
-        elif isinstance(wrapped, staticmethod):
-            binding = 'staticmethod'
-
-        elif hasattr(wrapped, '__self__'):
-            if inspect.isclass(wrapped.__self__):
-                binding = 'classmethod'
-            else:
-                binding = 'function'
-
-        else:
-            binding = 'function'
-
-        super(FunctionWrapper, self).__init__(wrapped, None, wrapper,
-                enabled, binding)
-
-# disabled support for native extension; we likely don't need it
-# try:
-#     if not os.environ.get('WRAPT_DISABLE_EXTENSIONS'):
-#         from ._wrappers import (ObjectProxy, CallableObjectProxy,
-#             PartialCallableObjectProxy, FunctionWrapper,
-#             BoundFunctionWrapper, _FunctionWrapperBase)
-# except ImportError:
-#     pass
-
-# Helper functions for applying wrappers to existing functions.
-
-def resolve_path(module, name):
-    if isinstance(module, string_types):
-        __import__(module)
-        module = sys.modules[module]
-
-    parent = module
-
-    path = name.split('.')
-    attribute = path[0]
-
-    # We can't just always use getattr() because in doing
-    # that on a class it will cause binding to occur which
-    # will complicate things later and cause some things not
-    # to work. For the case of a class we therefore access
-    # the __dict__ directly. To cope though with the wrong
-    # class being given to us, or a method being moved into
-    # a base class, we need to walk the class hierarchy to
-    # work out exactly which __dict__ the method was defined
-    # in, as accessing it from __dict__ will fail if it was
-    # not actually on the class given. Fallback to using
-    # getattr() if we can't find it. If it truly doesn't
-    # exist, then that will fail.
-
-    def lookup_attribute(parent, attribute):
-        if inspect.isclass(parent):
-            for cls in inspect.getmro(parent):
-                if attribute in vars(cls):
-                    return vars(cls)[attribute]
-            else:
-                return getattr(parent, attribute)
-        else:
-            return getattr(parent, attribute)
-
-    original = lookup_attribute(parent, attribute)
-
-    for attribute in path[1:]:
-        parent = original
-        original = lookup_attribute(parent, attribute)
-
-    return (parent, attribute, original)
-
-def apply_patch(parent, attribute, replacement):
-    setattr(parent, attribute, replacement)
-
-def wrap_object(module, name, factory, args=(), kwargs={}):
-    (parent, attribute, original) = resolve_path(module, name)
-    wrapper = factory(original, *args, **kwargs)
-    apply_patch(parent, attribute, wrapper)
-    return wrapper
-
-# Function for applying a proxy object to an attribute of a class
-# instance. The wrapper works by defining an attribute of the same name
-# on the class which is a descriptor and which intercepts access to the
-# instance attribute. Note that this cannot be used on attributes which
-# are themselves defined by a property object.
-
-class AttributeWrapper(object):
-
-    def __init__(self, attribute, factory, args, kwargs):
-        self.attribute = attribute
-        self.factory = factory
-        self.args = args
-        self.kwargs = kwargs
-
-    def __get__(self, instance, owner):
-        value = instance.__dict__[self.attribute]
-        return self.factory(value, *self.args, **self.kwargs)
-
-    def __set__(self, instance, value):
-        instance.__dict__[self.attribute] = value
-
-    def __delete__(self, instance):
-        del instance.__dict__[self.attribute]
-
-def wrap_object_attribute(module, name, factory, args=(), kwargs={}):
-    path, attribute = name.rsplit('.', 1)
-    parent = resolve_path(module, path)[2]
-    wrapper = AttributeWrapper(attribute, factory, args, kwargs)
-    apply_patch(parent, attribute, wrapper)
-    return wrapper
-
-# Functions for creating a simple decorator using a FunctionWrapper,
-# plus short cut functions for applying wrappers to functions. These are
-# for use when doing monkey patching. For a more featured way of
-# creating decorators see the decorator decorator instead.
-
-def function_wrapper(wrapper):
-    def _wrapper(wrapped, instance, args, kwargs):
-        target_wrapped = args[0]
-        if instance is None:
-            target_wrapper = wrapper
-        elif inspect.isclass(instance):
-            target_wrapper = wrapper.__get__(None, instance)
-        else:
-            target_wrapper = wrapper.__get__(instance, type(instance))
-        return FunctionWrapper(target_wrapped, target_wrapper)
-    return FunctionWrapper(wrapper, _wrapper)
-
-def wrap_function_wrapper(module, name, wrapper):
-    return wrap_object(module, name, FunctionWrapper, (wrapper,))
-
-def patch_function_wrapper(module, name):
-    def _wrapper(wrapper):
-        return wrap_object(module, name, FunctionWrapper, (wrapper,))
-    return _wrapper
-
-def transient_function_wrapper(module, name):
-    def _decorator(wrapper):
-        def _wrapper(wrapped, instance, args, kwargs):
-            target_wrapped = args[0]
-            if instance is None:
-                target_wrapper = wrapper
-            elif inspect.isclass(instance):
-                target_wrapper = wrapper.__get__(None, instance)
-            else:
-                target_wrapper = wrapper.__get__(instance, type(instance))
-            def _execute(wrapped, instance, args, kwargs):
-                (parent, attribute, original) = resolve_path(module, name)
-                replacement = FunctionWrapper(original, target_wrapper)
-                setattr(parent, attribute, replacement)
-                try:
-                    return wrapped(*args, **kwargs)
-                finally:
-                    setattr(parent, attribute, original)
-            return FunctionWrapper(target_wrapped, _execute)
-        return FunctionWrapper(wrapper, _wrapper)
-    return _decorator
-
-# A weak function proxy. This will work on instance methods, class
-# methods, static methods and regular functions. Special treatment is
-# needed for the method types because the bound method is effectively a
-# transient object and applying a weak reference to one will immediately
-# result in it being destroyed and the weakref callback called. The weak
-# reference is therefore applied to the instance the method is bound to
-# and the original function. The function is then rebound at the point
-# of a call via the weak function proxy.
-
-def _weak_function_proxy_callback(ref, proxy, callback):
-    if proxy._self_expired:
-        return
-
-    proxy._self_expired = True
-
-    # This could raise an exception. We let it propagate back and let
-    # the weakref.proxy() deal with it, at which point it generally
-    # prints out a short error message direct to stderr and keeps going.
-
-    if callback is not None:
-        callback(proxy)
-
-class WeakFunctionProxy(ObjectProxy):
-
-    __slots__ = ('_self_expired', '_self_instance')
-
-    def __init__(self, wrapped, callback=None):
-        # We need to determine if the wrapped function is actually a
-        # bound method. In the case of a bound method, we need to keep a
-        # reference to the original unbound function and the instance.
-        # This is necessary because if we hold a reference to the bound
-        # function, it will be the only reference and given it is a
-        # temporary object, it will almost immediately expire and
-        # the weakref callback triggered. So what is done is that we
-        # hold a reference to the instance and unbound function and
-        # when called bind the function to the instance once again and
-        # then call it. Note that we avoid using a nested function for
-        # the callback here so as not to cause any odd reference cycles.
-
-        _callback = callback and functools.partial(
-                _weak_function_proxy_callback, proxy=self,
-                callback=callback)
-
-        self._self_expired = False
+        binding = None
 
         if isinstance(wrapped, _FunctionWrapperBase):
-            self._self_instance = weakref.ref(wrapped._self_instance,
-                    _callback)
+            binding = wrapped._self_binding
 
-            if wrapped._self_parent is not None:
-                super(WeakFunctionProxy, self).__init__(
-                        weakref.proxy(wrapped._self_parent, _callback))
+        if not binding:
+            if inspect.isbuiltin(wrapped):
+                binding = 'builtin'
 
-            else:
-                super(WeakFunctionProxy, self).__init__(
-                        weakref.proxy(wrapped, _callback))
-
-            return
-
-        try:
-            self._self_instance = weakref.ref(wrapped.__self__, _callback)
-
-            super(WeakFunctionProxy, self).__init__(
-                    weakref.proxy(wrapped.__func__, _callback))
-
-        except AttributeError:
-            self._self_instance = None
-
-            super(WeakFunctionProxy, self).__init__(
-                    weakref.proxy(wrapped, _callback))
-
-    def __call__(*args, **kwargs):
-        def _unpack_self(self, *args):
-            return self, args
+            elif inspect.isfunction(wrapped):
+                binding = 'function'
 
-        self, args = _unpack_self(*args)
+            elif inspect.isclass(wrapped):
+                binding = 'class'
 
-        # We perform a boolean check here on the instance and wrapped
-        # function as that will trigger the reference error prior to
-        # calling if the reference had expired.
+            elif isinstance(wrapped, classmethod):
+                binding = 'classmethod'
 
-        instance = self._self_instance and self._self_instance()
-        function = self.__wrapped__ and self.__wrapped__
+            elif isinstance(wrapped, staticmethod):
+                binding = 'staticmethod'
 
-        # If the wrapped function was originally a bound function, for
-        # which we retained a reference to the instance and the unbound
-        # function we need to rebind the function and then call it. If
-        # not just called the wrapped function.
+            elif hasattr(wrapped, '__self__'):
+                if inspect.isclass(wrapped.__self__):
+                    binding = 'classmethod'
+                elif inspect.ismethod(wrapped):
+                    binding = 'instancemethod'
+                else:
+                    binding = 'callable'
 
-        if instance is None:
-            return self.__wrapped__(*args, **kwargs)
+            else:
+                binding = 'callable'
 
-        return function.__get__(instance, type(instance))(*args, **kwargs)
+        super(FunctionWrapper, self).__init__(wrapped, None, wrapper,
+                enabled, binding)