![[BACK]](/icons/back.gif){kind=icon}
Up to [cvs.NetBSD.org] / pkgsrc / devel / py-wrapt
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
py-wrapt: convert to wheel.mk Bump PKGREVISION.
py-wrapt: updated to 1.16.0 wrapt-1.16.0 Unknown changes
py-wrapt: updated to 1.14.0 Version 1.14.0 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. New Features Binary wheels provided on PyPi for aarch64 Linux systems and macOS native silicon where supported by Python when using pypa/cibuildwheel.
py-wrapt: updated to 1.13.1 Version 1.13.1 Bugs Fixed Fix Python version constraint so PyPi classifier for pip requires Python 2.7 or Python 3.5+. Version 1.13.0 Bugs Fixed 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 bug (https://bugs.python.org/issue44847) in the Python standard library, you will still have problems when the class heirarchy uses a base class which has the abc.ABCMeta metaclass. In this later case an exception will be raised of TypeError: issubclass() arg 1 must be a class.
py-wrapt: updated to 1.11.1 Version 1.11.1 Bugs Fixed Fixed memory leak in C extension variant of PartialCallableObjectProxy class introduced in 1.11.0, when it was being used to perform binding, when a call of an instance method was made through the class type, and the self object passed explicitly as first argument. The C extension variant of the PartialCallableObjectProxy class introduced in 1.11.0, which is a version of functools.partial which correctly handles binding when applied to methods of classes, couldn't be used when no positional arguments were supplied. When the C extension variant of PartialCallableObjectProxy was used and multiple positional arguments were supplied, the first argument would be replicated and used to all arguments, instead of correct values, when the partial was called. When the C extension variant of PartialCallableObjectProxy was used and keyword arguments were supplied, it would fail as was incorrectly using the positional arguments where the keyword arguments should have been used. Version 1.11.0 Bugs Fixed When using arithmetic operations through a proxy object, checks about the types of arguments were not being performed correctly, which could result in an exception being raised to indicate that a proxy object had not been initialised when in fact the argument wasn't even an instance of a proxy object. Because an incorrect cast in C level code was being performed and an attribute in memory checked on the basis of it being a type different to what it actually was, technically it may have resulted in a process crash if the size of the object was smaller than the type being casted to. The __complex__() special method wasn't implemented and using complex() on a proxy object would give wrong results or fail. When using the C extension, if an exception was raised when using inplace or, ie., |=, the error condition wasn't being correctly propagated back which would result in an exception showing up as wrong location in subsequent code. Type of long was used instead of Py_hash_t for Python 3.3+. This caused compiler warnings on Windows, which depending on what locale was set to, would cause pip to fail when installing the package. If calling Class.instancemethod and passing self explicitly, the ability to access __name__ and __module__ on the final bound method were not preserved. This was due to a partial being used for this special case, and it doesn't preserve introspection. Fixed typo in the getter property of ObjectProxy for accessing __annotations__. Appeared that it was still working as would fall back to using generic __getattr__() to access attribute on wrapped object.
add devel/py-wrapt (wrapt-1.10.8) A Python module for decorators, wrappers and monkey patching. The aim of the wrapt module is to provide a transparent object proxy for Python, which can be used as the basis for the construction of function wrappers and decorator functions. The wrapt module focuses very much on correctness. It therefore goes way beyond existing mechanisms such as functools.wraps() to ensure that decorators preserve introspectability, signatures, type checking abilities etc. The decorators that can be constructed using this module will work in far more scenarios than typical decorators and provide more predictable and consistent behaviour. To ensure that the overhead is as minimal as possible, a C extension module is used for performance critical components. An automatic fallback to a pure Python implementation is also provided where a target system does not have a compiler to allow the C extension to be compiled.