- update to 1.16.0:
  * Note that version 1.16.0 drops support for Python 2.7 and
    3.5. Python version 3.6 or later is required.
  * The ``patch_function_wrapper()`` decorator now accepts an
    ``enabled`` argument, which can be a literal boolean value,
    object that evaluates as boolean, or a callable object which
    returns a boolean. In the case of a callable, determination
    of whether the wrapper is invoked will be left until
    the point of the call. In the other cases, the wrapper will
    not be applied if the value evaluates false at the point of
    applying the wrapper.
  * The import hook loader and finder objects are now implemented
    as transparent object proxies so they properly proxy pass
    access to attributes/functions of the wrapped loader or finder.
  * Code files in the implementation have been reorganized such
    that the pure Python version of the ``ObjectProxy`` class
    is directly available even if the C extension variant is
    being used. This is to allow the pure Python variant to
    be used in exceptional cases where the C extension variant is
    not fully compatible with the pure Python implementation and the
    behaviour of the pure Python variant is what is required.
  * It was not possible to update the ``__class__`` attribute
    through the transparent object proxy when relying on the C
    implementation.

   generating binary wheels for ``musllinux``.
  * When using an adapter function to change the signature of the decorated
  * Code for inspect.getargspec() when using Python 2.6 was missing

• Files Changed
• Browse Source

- update to 1.15.0:
  * When the C extension for wrapt was being used, and a property
    was used on an object proxy wrapping another object to intercept
    access to an attribute of the same name on the wrapped object,
    if the function implementing the property
    raised an exception, then the exception was ignored and not
    propagated back to the caller.
  * Address issue where the post import hook mechanism of wrapt
    wasn't transparent and left the __loader__ and __spec__.loader
    attributes of a module as the wrapt import hook loader and
    not the original loader.
  * Address issues where a thread deadlock could occur within the
    wrapt module import handler, when code executed from a post
    import hook created a new thread and code executed in the
    context of the new thread itself tried to register a post
    import hook, or imported a new module.
  * When using ``CallableObjectProxy`` as a wrapper for a type or
    function and calling the wrapped object, it was not possible
    to pass a keyword argument named ``self``.

• Files Changed
• Browse Source

• Files Changed
• Browse Source

- update to 1.14.1:
  * When the post import hooks mechanism was being used, and a Python package with
    its own custom module importer was used, importing modules could fail if the
    custom module importer didn't use the latest Python import hook finder/loader
    APIs and instead used the deprecated API. This was actually occurring with the
    `zipimporter` in Python itself, which was not updated to use the newer Python
    APIs until Python 3.10.
  **Bugs Fixed**
  * Python 3.11 dropped ``inspect.formatargspec()`` which was used in creating
    signature changing decorators. Now bundling a version of this function
    which uses ``Parameter`` and ``Signature`` from ``inspect`` module when
    available. The replacement function is exposed as ``wrapt.formatargspec()``
    if need it for your own code.
  * When using a decorator on a class, ``isinstance()`` checks wouldn't previously
    work as expected and you had to manually use ``Type.__wrapped__`` to access
    the real type when doing instance checks. The ``__instancecheck__`` hook is
    now implemented such that you don't have to use ``Type.__wrapped__`` instead
    of ``Type`` as last argument to ``isinstance()``.
  * Eliminated deprecation warnings related to Python module import system, which
    would have turned into broken code in Python 3.12. This was used by the post
    import hook mechanism.

• Files Changed
• Browse Source

- update to 1.13.3:
  * Adds wheels for Python 3.10 on PyPi and where possible also now
   generating binary wheels for ``musllinux``.

• Files Changed
• Browse Source

- update to 1.13.2:
  * Note that the next signficant release of `wrapt` will drop support for
    Python 2.7 and Python 3.5.
  * Fix Python version constraint so PyPi classifier for ``pip`` requires
    Python 2.7 or Python 3.5+.
  * When a reference to a class method was taken out of a class, and then
    wrapped in a function wrapper, and called, the class type was not being
    passed as the instance argument, but as the first argument in args,
    with the instance being ``None``. The class type should have been passed
    as the instance argument.
  * If supplying an adapter function for a signature changing decorator
    using input in the form of a function argument specification, name lookup
    exceptions would occur where the adaptor function had annotations which
    referenced non builtin Python types. Although the issues have been
    addressed where using input data in the format usually returned by
    ``inspect.getfullargspec()`` to pass the function argument specification,
    you can still have problems when supplying a function signature as
    string. In the latter case only Python builtin types can be referenced
    in annotations.
  * When a decorator was applied on top of a data/non-data descriptor in a
    class definition, the call to the special method ``__set_name__()`` to
    notify the descriptor of the variable name was not being propogated. Note
    that this issue has been addressed in the ``FunctionWrapper`` used by
    ``@wrapt.decorator`` but has not been applied to the generic
    ``ObjectProxy`` class. If using ``ObjectProxy`` directly to construct a
    custom wrapper which is applied to a descriptor, you will need to
    propogate the ``__set_name__()`` call yourself if required.
  * The ``issubclass()`` builtin method would give incorrect results when used
    with a class which had a decorator applied to it. Note that this has only
    been able to be fixed for Python 3.7+. Also, due to what is arguably a

• Files Changed
• Browse Source

• Files Changed
• Browse Source

• Files Changed
• Browse Source

- update to 1.12.1:
  * Applying a function wrapper to a static method of a class using the
  ``wrap_function_wrapper()`` function, or wrapper for the same, wasn't
  being done correctly when the static method was the immediate child of
  the target object. It was working when the name path had multiple name
  components. A failure would subsequently occur when the static method
  was called via an instance of the class, rather than the class.

• Files Changed
• Browse Source

- update to 1.12.0:
  * Provided that you only want to support Python 3.7, when deriving from
    a base class which has a decorator applied to it, you no longer need
    to access the true type of the base class using ``__wrapped__`` in
    the inherited class list of the derived class.
  * When using the ``synchronized`` decorator on instance methods of a
    class, if the class declared special methods to override the result for
    when the class instance was tested as a boolean so that it returned
    ``False`` all the time, the synchronized method would fail when called.
  * When using an adapter function to change the signature of the decorated                    
    function, ``inspect.signature()`` was returning the wrong signature
    when an instance method was inspected by accessing the method via the
    class type.

• Files Changed
• Browse Source

- Update to 1.11.2:
  * Fix possible crash when garbage collection kicks in when invoking a destructor of wrapped object.

• Files Changed
• Browse Source

- Update to 1.11.1:
  * Many bugfixes all around
  * see changes.rst for detailed list
- Switch to github to include tests

• Files Changed
• Browse Source

- update to version 1.10.10:
  * Added back missing description and categorisations when releasing
  to PyPi.
  * Code for inspect.getargspec() when using Python 2.6 was missing 
  import of sys module.

• Files Changed
• Browse Source

1

• Files Changed
• Browse Source

- update for singlespec (forwarded request 479711 from matejcik)

• Files Changed
• Browse Source

1

• Files Changed
• Browse Source

1

• Files Changed
• Browse Source

• Browse Source