aboutsummaryrefslogtreecommitdiff
path: root/.venv/lib/python3.12/site-packages/wrapt/wrappers.py
diff options
context:
space:
mode:
Diffstat (limited to '.venv/lib/python3.12/site-packages/wrapt/wrappers.py')
-rw-r--r--.venv/lib/python3.12/site-packages/wrapt/wrappers.py821
1 files changed, 821 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/wrapt/wrappers.py b/.venv/lib/python3.12/site-packages/wrapt/wrappers.py
new file mode 100644
index 00000000..62da8a30
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/wrapt/wrappers.py
@@ -0,0 +1,821 @@
+import sys
+import operator
+import inspect
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+ string_types = basestring,
+else:
+ string_types = str,
+
+def with_metaclass(meta, *bases):
+ """Create a base class with a metaclass."""
+ return meta("NewBase", bases, {})
+
+class _ObjectProxyMethods(object):
+
+ # We use properties to override the values of __module__ and
+ # __doc__. If we add these in ObjectProxy, the derived class
+ # __dict__ will still be setup to have string variants of these
+ # attributes and the rules of descriptors means that they appear to
+ # take precedence over the properties in the base class. To avoid
+ # that, we copy the properties into the derived class type itself
+ # via a meta class. In that way the properties will always take
+ # precedence.
+
+ @property
+ def __module__(self):
+ return self.__wrapped__.__module__
+
+ @__module__.setter
+ def __module__(self, value):
+ self.__wrapped__.__module__ = value
+
+ @property
+ def __doc__(self):
+ return self.__wrapped__.__doc__
+
+ @__doc__.setter
+ def __doc__(self, value):
+ self.__wrapped__.__doc__ = value
+
+ # We similar use a property for __dict__. We need __dict__ to be
+ # explicit to ensure that vars() works as expected.
+
+ @property
+ def __dict__(self):
+ return self.__wrapped__.__dict__
+
+ # Need to also propagate the special __weakref__ attribute for case
+ # where decorating classes which will define this. If do not define
+ # it and use a function like inspect.getmembers() on a decorator
+ # class it will fail. This can't be in the derived classes.
+
+ @property
+ def __weakref__(self):
+ return self.__wrapped__.__weakref__
+
+class _ObjectProxyMetaType(type):
+ def __new__(cls, name, bases, dictionary):
+ # Copy our special properties into the class so that they
+ # always take precedence over attributes of the same name added
+ # during construction of a derived class. This is to save
+ # duplicating the implementation for them in all derived classes.
+
+ dictionary.update(vars(_ObjectProxyMethods))
+
+ return type.__new__(cls, name, bases, dictionary)
+
+class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
+
+ __slots__ = '__wrapped__'
+
+ def __init__(self, wrapped):
+ object.__setattr__(self, '__wrapped__', wrapped)
+
+ # Python 3.2+ has the __qualname__ attribute, but it does not
+ # allow it to be overridden using a property and it must instead
+ # be an actual string object instead.
+
+ try:
+ object.__setattr__(self, '__qualname__', wrapped.__qualname__)
+ except AttributeError:
+ pass
+
+ # Python 3.10 onwards also does not allow itself to be overridden
+ # using a property and it must instead be set explicitly.
+
+ try:
+ object.__setattr__(self, '__annotations__', wrapped.__annotations__)
+ except AttributeError:
+ pass
+
+ def __self_setattr__(self, name, value):
+ object.__setattr__(self, name, value)
+
+ @property
+ def __name__(self):
+ return self.__wrapped__.__name__
+
+ @__name__.setter
+ def __name__(self, value):
+ self.__wrapped__.__name__ = value
+
+ @property
+ def __class__(self):
+ return self.__wrapped__.__class__
+
+ @__class__.setter
+ def __class__(self, value):
+ self.__wrapped__.__class__ = value
+
+ def __dir__(self):
+ return dir(self.__wrapped__)
+
+ def __str__(self):
+ return str(self.__wrapped__)
+
+ if not PY2:
+ def __bytes__(self):
+ return bytes(self.__wrapped__)
+
+ def __repr__(self):
+ return '<{} at 0x{:x} for {} at 0x{:x}>'.format(
+ type(self).__name__, id(self),
+ 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, ndigits=None):
+ return round(self.__wrapped__, ndigits)
+
+ if sys.hexversion >= 0x03070000:
+ def __mro_entries__(self, bases):
+ return (self.__wrapped__,)
+
+ def __lt__(self, other):
+ return self.__wrapped__ < other
+
+ def __le__(self, other):
+ return self.__wrapped__ <= other
+
+ def __eq__(self, other):
+ return self.__wrapped__ == other
+
+ def __ne__(self, other):
+ return self.__wrapped__ != other
+
+ def __gt__(self, other):
+ return self.__wrapped__ > other
+
+ def __ge__(self, other):
+ return self.__wrapped__ >= other
+
+ def __hash__(self):
+ return hash(self.__wrapped__)
+
+ def __nonzero__(self):
+ return bool(self.__wrapped__)
+
+ def __bool__(self):
+ return bool(self.__wrapped__)
+
+ def __setattr__(self, name, value):
+ if name.startswith('_self_'):
+ object.__setattr__(self, name, value)
+
+ elif name == '__wrapped__':
+ object.__setattr__(self, name, value)
+ try:
+ object.__delattr__(self, '__qualname__')
+ except AttributeError:
+ pass
+ try:
+ object.__setattr__(self, '__qualname__', value.__qualname__)
+ except AttributeError:
+ pass
+ try:
+ object.__delattr__(self, '__annotations__')
+ except AttributeError:
+ pass
+ try:
+ object.__setattr__(self, '__annotations__', value.__annotations__)
+ except AttributeError:
+ pass
+
+ elif name == '__qualname__':
+ setattr(self.__wrapped__, name, value)
+ object.__setattr__(self, name, value)
+
+ elif name == '__annotations__':
+ setattr(self.__wrapped__, name, value)
+ object.__setattr__(self, name, value)
+
+ elif hasattr(type(self), name):
+ object.__setattr__(self, name, value)
+
+ else:
+ setattr(self.__wrapped__, name, value)
+
+ def __getattr__(self, name):
+ # If we are being to lookup '__wrapped__' then the
+ # '__init__()' method cannot have been called.
+
+ if name == '__wrapped__':
+ raise ValueError('wrapper has not been initialised')
+
+ return getattr(self.__wrapped__, name)
+
+ def __delattr__(self, name):
+ if name.startswith('_self_'):
+ object.__delattr__(self, name)
+
+ elif name == '__wrapped__':
+ raise TypeError('__wrapped__ must be an object')
+
+ elif name == '__qualname__':
+ object.__delattr__(self, name)
+ delattr(self.__wrapped__, name)
+
+ elif hasattr(type(self), name):
+ object.__delattr__(self, name)
+
+ else:
+ delattr(self.__wrapped__, name)
+
+ def __add__(self, other):
+ return self.__wrapped__ + other
+
+ def __sub__(self, other):
+ return self.__wrapped__ - other
+
+ def __mul__(self, other):
+ return self.__wrapped__ * other
+
+ def __div__(self, other):
+ return operator.div(self.__wrapped__, other)
+
+ def __truediv__(self, other):
+ return operator.truediv(self.__wrapped__, other)
+
+ def __floordiv__(self, other):
+ return self.__wrapped__ // other
+
+ def __mod__(self, other):
+ return self.__wrapped__ % other
+
+ def __divmod__(self, other):
+ return divmod(self.__wrapped__, other)
+
+ def __pow__(self, other, *args):
+ return pow(self.__wrapped__, other, *args)
+
+ def __lshift__(self, other):
+ return self.__wrapped__ << other
+
+ def __rshift__(self, other):
+ return self.__wrapped__ >> other
+
+ def __and__(self, other):
+ return self.__wrapped__ & other
+
+ def __xor__(self, other):
+ return self.__wrapped__ ^ other
+
+ def __or__(self, other):
+ return self.__wrapped__ | other
+
+ def __radd__(self, other):
+ return other + self.__wrapped__
+
+ def __rsub__(self, other):
+ return other - self.__wrapped__
+
+ def __rmul__(self, other):
+ return other * self.__wrapped__
+
+ def __rdiv__(self, other):
+ return operator.div(other, self.__wrapped__)
+
+ def __rtruediv__(self, other):
+ return operator.truediv(other, self.__wrapped__)
+
+ def __rfloordiv__(self, other):
+ return other // self.__wrapped__
+
+ def __rmod__(self, other):
+ return other % self.__wrapped__
+
+ def __rdivmod__(self, other):
+ return divmod(other, self.__wrapped__)
+
+ def __rpow__(self, other, *args):
+ return pow(other, self.__wrapped__, *args)
+
+ def __rlshift__(self, other):
+ return other << self.__wrapped__
+
+ def __rrshift__(self, other):
+ return other >> self.__wrapped__
+
+ def __rand__(self, other):
+ return other & self.__wrapped__
+
+ def __rxor__(self, other):
+ return other ^ self.__wrapped__
+
+ def __ror__(self, other):
+ return other | self.__wrapped__
+
+ def __iadd__(self, other):
+ self.__wrapped__ += other
+ return self
+
+ def __isub__(self, other):
+ self.__wrapped__ -= other
+ return self
+
+ def __imul__(self, other):
+ self.__wrapped__ *= other
+ return self
+
+ def __idiv__(self, other):
+ self.__wrapped__ = operator.idiv(self.__wrapped__, other)
+ return self
+
+ def __itruediv__(self, other):
+ self.__wrapped__ = operator.itruediv(self.__wrapped__, other)
+ return self
+
+ def __ifloordiv__(self, other):
+ self.__wrapped__ //= other
+ return self
+
+ def __imod__(self, other):
+ self.__wrapped__ %= other
+ return self
+
+ def __ipow__(self, other):
+ self.__wrapped__ **= other
+ return self
+
+ def __ilshift__(self, other):
+ self.__wrapped__ <<= other
+ return self
+
+ def __irshift__(self, other):
+ self.__wrapped__ >>= other
+ return self
+
+ def __iand__(self, other):
+ self.__wrapped__ &= other
+ return self
+
+ def __ixor__(self, other):
+ self.__wrapped__ ^= other
+ return self
+
+ def __ior__(self, other):
+ self.__wrapped__ |= other
+ return self
+
+ def __neg__(self):
+ return -self.__wrapped__
+
+ def __pos__(self):
+ return +self.__wrapped__
+
+ def __abs__(self):
+ return abs(self.__wrapped__)
+
+ def __invert__(self):
+ return ~self.__wrapped__
+
+ def __int__(self):
+ return int(self.__wrapped__)
+
+ def __long__(self):
+ return long(self.__wrapped__)
+
+ def __float__(self):
+ return float(self.__wrapped__)
+
+ def __complex__(self):
+ return complex(self.__wrapped__)
+
+ def __oct__(self):
+ return oct(self.__wrapped__)
+
+ def __hex__(self):
+ return hex(self.__wrapped__)
+
+ def __index__(self):
+ return operator.index(self.__wrapped__)
+
+ def __len__(self):
+ return len(self.__wrapped__)
+
+ def __contains__(self, value):
+ return value in self.__wrapped__
+
+ def __getitem__(self, key):
+ return self.__wrapped__[key]
+
+ def __setitem__(self, key, value):
+ self.__wrapped__[key] = value
+
+ def __delitem__(self, key):
+ del self.__wrapped__[key]
+
+ def __getslice__(self, i, j):
+ return self.__wrapped__[i:j]
+
+ def __setslice__(self, i, j, value):
+ self.__wrapped__[i:j] = value
+
+ def __delslice__(self, i, j):
+ del self.__wrapped__[i:j]
+
+ def __enter__(self):
+ return self.__wrapped__.__enter__()
+
+ def __exit__(self, *args, **kwargs):
+ return self.__wrapped__.__exit__(*args, **kwargs)
+
+ def __iter__(self):
+ return iter(self.__wrapped__)
+
+ def __copy__(self):
+ raise NotImplementedError('object proxy must define __copy__()')
+
+ def __deepcopy__(self, memo):
+ raise NotImplementedError('object proxy must define __deepcopy__()')
+
+ def __reduce__(self):
+ raise NotImplementedError(
+ 'object proxy must define __reduce__()')
+
+ def __reduce_ex__(self, protocol):
+ raise NotImplementedError(
+ 'object proxy must define __reduce_ex__()')
+
+class CallableObjectProxy(ObjectProxy):
+
+ def __call__(*args, **kwargs):
+ def _unpack_self(self, *args):
+ return self, args
+
+ self, args = _unpack_self(*args)
+
+ return self.__wrapped__(*args, **kwargs)
+
+class PartialCallableObjectProxy(ObjectProxy):
+
+ def __init__(*args, **kwargs):
+ def _unpack_self(self, *args):
+ return self, args
+
+ self, args = _unpack_self(*args)
+
+ if len(args) < 1:
+ raise TypeError('partial type takes at least one argument')
+
+ wrapped, args = args[0], args[1:]
+
+ if not callable(wrapped):
+ raise TypeError('the first argument must be callable')
+
+ super(PartialCallableObjectProxy, self).__init__(wrapped)
+
+ self._self_args = args
+ self._self_kwargs = kwargs
+
+ def __call__(*args, **kwargs):
+ def _unpack_self(self, *args):
+ return self, args
+
+ self, args = _unpack_self(*args)
+
+ _args = self._self_args + args
+
+ _kwargs = dict(self._self_kwargs)
+ _kwargs.update(kwargs)
+
+ return self.__wrapped__(*_args, **_kwargs)
+
+class _FunctionWrapperBase(ObjectProxy):
+
+ __slots__ = ('_self_instance', '_self_wrapper', '_self_enabled',
+ '_self_binding', '_self_parent', '_self_owner')
+
+ def __init__(self, wrapped, instance, wrapper, enabled=None,
+ binding='callable', parent=None, owner=None):
+
+ super(_FunctionWrapperBase, self).__init__(wrapped)
+
+ object.__setattr__(self, '_self_instance', instance)
+ object.__setattr__(self, '_self_wrapper', wrapper)
+ 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.
+ #
+ # 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.
+ #
+ # 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.
+
+ if self._self_parent is None:
+ # 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
+
+ if self._self_binding == "class":
+ return self
+
+ binder = getattr(self.__wrapped__, '__get__', None)
+
+ 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.
+
+ 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, owner)
+
+ return self
+
+ def __call__(*args, **kwargs):
+ def _unpack_self(self, *args):
+ return self, args
+
+ 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 self._self_enabled is not None:
+ if callable(self._self_enabled):
+ if not self._self_enabled():
+ return self.__wrapped__(*args, **kwargs)
+ elif not self._self_enabled:
+ return self.__wrapped__(*args, **kwargs)
+
+ # This can occur where initial function wrapper was applied to
+ # 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', 'instancemethod', 'classmethod', 'callable'):
+ if self._self_instance is None:
+ instance = getattr(self.__wrapped__, '__self__', None)
+ if instance is not None:
+ return self._self_wrapper(self.__wrapped__, instance,
+ args, kwargs)
+
+ # This is generally invoked when the wrapped function is being
+ # called as a normal function and is not bound to a class as an
+ # instance method. This is also invoked in the case where the
+ # wrapped function was a method, but this wrapper was in turn
+ # wrapped using the staticmethod decorator.
+
+ return self._self_wrapper(self.__wrapped__, self._self_instance,
+ args, kwargs)
+
+ def __set_name__(self, owner, name):
+ # This is a special method use to supply information to
+ # descriptors about what the name of variable in a class
+ # definition is. Not wanting to add this to ObjectProxy as not
+ # sure of broader implications of doing that. Thus restrict to
+ # FunctionWrapper used by decorators.
+
+ if hasattr(self.__wrapped__, "__set_name__"):
+ self.__wrapped__.__set_name__(owner, name)
+
+ def __instancecheck__(self, instance):
+ # This is a special method used by isinstance() to make checks
+ # instance of the `__wrapped__`.
+ return isinstance(instance, self.__wrapped__)
+
+ def __subclasscheck__(self, subclass):
+ # This is a special method used by issubclass() to make checks
+ # about inheritance of classes. We need to upwrap any object
+ # proxy. Not wanting to add this to ObjectProxy as not sure of
+ # broader implications of doing that. Thus restrict to
+ # FunctionWrapper used by decorators.
+
+ if hasattr(subclass, "__wrapped__"):
+ return issubclass(subclass.__wrapped__, self.__wrapped__)
+ else:
+ return issubclass(subclass, self.__wrapped__)
+
+class BoundFunctionWrapper(_FunctionWrapperBase):
+
+ def __call__(*args, **kwargs):
+ def _unpack_self(self, *args):
+ return self, args
+
+ 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 self._self_enabled is not None:
+ if callable(self._self_enabled):
+ if not self._self_enabled():
+ return self.__wrapped__(*args, **kwargs)
+ 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.
+
+ 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.
+
+ if not args:
+ raise TypeError('missing 1 required positional argument')
+
+ instance, args = args[0], args[1:]
+ wrapped = PartialCallableObjectProxy(self.__wrapped__, instance)
+ return self._self_wrapper(wrapped, instance, args, kwargs)
+
+ return self._self_wrapper(self.__wrapped__, self._self_instance,
+ args, kwargs)
+
+ else:
+ # As in this case we would be dealing with a classmethod or
+ # staticmethod, then _self_instance will only tell us whether
+ # when calling the classmethod or staticmethod they did it via an
+ # instance of the class it is bound to and not the case where
+ # done by the class type itself. We thus ignore _self_instance
+ # and use the __self__ attribute of the bound function instead.
+ # For a classmethod, this means instance will be the class type
+ # and for a staticmethod it will be None. This is probably the
+ # more useful thing we can pass through even though we loose
+ # knowledge of whether they were called on the instance vs the
+ # class type, as it reflects what they have available in the
+ # decoratored function.
+
+ instance = getattr(self.__wrapped__, '__self__', None)
+
+ return self._self_wrapper(self.__wrapped__, instance, args,
+ kwargs)
+
+class FunctionWrapper(_FunctionWrapperBase):
+
+ __bound_function_wrapper__ = BoundFunctionWrapper
+
+ def __init__(self, wrapped, wrapper, enabled=None):
+ # What it is we are wrapping here could be anything. We need to
+ # try and detect specific cases though. In particular, we need
+ # to detect when we are given something that is a method of a
+ # class. Further, we need to know when it is likely an instance
+ # method, as opposed to a class or static method. This can
+ # become problematic though as there isn't strictly a fool proof
+ # method of knowing.
+ #
+ # The situations we could encounter when wrapping a method are:
+ #
+ # 1. The wrapper is being applied as part of a decorator which
+ # is a part of the class definition. In this case what we are
+ # given is the raw unbound function, classmethod or staticmethod
+ # wrapper objects.
+ #
+ # The problem here is that we will not know we are being applied
+ # in the context of the class being set up. This becomes
+ # important later for the case of an instance method, because in
+ # that case we just see it as a raw function and can't
+ # distinguish it from wrapping a normal function outside of
+ # a class context.
+ #
+ # 2. The wrapper is being applied when performing monkey
+ # patching of the class type afterwards and the method to be
+ # wrapped was retrieved direct from the __dict__ of the class
+ # type. This is effectively the same as (1) above.
+ #
+ # 3. The wrapper is being applied when performing monkey
+ # patching of the class type afterwards and the method to be
+ # wrapped was retrieved from the class type. In this case
+ # binding will have been performed where the instance against
+ # which the method is bound will be None at that point.
+ #
+ # This case is a problem because we can no longer tell if the
+ # method was a static method, plus if using Python3, we cannot
+ # tell if it was an instance method as the concept of an
+ # unnbound method no longer exists.
+ #
+ # 4. The wrapper is being applied when performing monkey
+ # patching of an instance of a class. In this case binding will
+ # have been perfomed where the instance was not None.
+ #
+ # This case is a problem because we can no longer tell if the
+ # method was a static method.
+ #
+ # Overall, the best we can do is look at the original type of the
+ # object which was wrapped prior to any binding being done and
+ # see if it is an instance of classmethod or staticmethod. In
+ # the case where other decorators are between us and them, if
+ # they do not propagate the __class__ attribute so that the
+ # isinstance() checks works, then likely this will do the wrong
+ # thing where classmethod and staticmethod are used.
+ #
+ # Since it is likely to be very rare that anyone even puts
+ # decorators around classmethod and staticmethod, likelihood of
+ # that being an issue is very small, so we accept it and suggest
+ # that those other decorators be fixed. It is also only an issue
+ # if a decorator wants to actually do things with the arguments.
+ #
+ # As to not being able to identify static methods properly, we
+ # just hope that that isn't something people are going to want
+ # to wrap, or if they do suggest they do it the correct way by
+ # ensuring that it is decorated in the class definition itself,
+ # 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 'callable'. If it was already bound and
+ # that is rebound later, we assume that it will be an instance
+ # 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.
+
+ binding = None
+
+ if isinstance(wrapped, _FunctionWrapperBase):
+ binding = wrapped._self_binding
+
+ if not binding:
+ if inspect.isbuiltin(wrapped):
+ binding = 'builtin'
+
+ elif inspect.isfunction(wrapped):
+ binding = 'function'
+
+ elif inspect.isclass(wrapped):
+ binding = 'class'
+
+ elif isinstance(wrapped, classmethod):
+ binding = 'classmethod'
+
+ elif isinstance(wrapped, staticmethod):
+ binding = 'staticmethod'
+
+ elif hasattr(wrapped, '__self__'):
+ if inspect.isclass(wrapped.__self__):
+ binding = 'classmethod'
+ elif inspect.ismethod(wrapped):
+ binding = 'instancemethod'
+ else:
+ binding = 'callable'
+
+ else:
+ binding = 'callable'
+
+ super(FunctionWrapper, self).__init__(wrapped, None, wrapper,
+ enabled, binding)
generated by cgit v1.2.3 (git 2.47.1) at 2025-07-28 16:41:25 +0000