Log message:
*: bump PKGREVISION for egg.mk users

They now have a tool dependency on py-setuptools instead of a DEPENDS

Log message:
py-wrapt: updated to 1.13.3

Version 1.13.3

New Features

Adds wheels for Python 3.10 on PyPi and where possible also now generating \ 
binary wheels for musllinux.

Log message:
archivers: Replace RMD160 checksums with BLAKE2s checksums

All checksums have been double-checked against existing RMD160 and
SHA512 hashes

Could not be committed due to merge conflict:
devel/py-traitlets/distinfo

The following distfiles were unfetchable (note: some may be only fetched
conditionally):

./devel/pvs/distinfo pvs-3.2-solaris.tgz
./devel/eclipse/distinfo eclipse-sourceBuild-srcIncluded-3.0.1.zip

Log message:
py-wrapt: updated to 1.13.2

Version 1.13.2

Features Changed

On the Windows platform when using Python 2.7, by default the C extension will \ 
not be installed and the pure Python implementation will be used. This is \ 
because too often on Windows when using Python 2.7, there is no working compiler \ 
available. Prior to version 1.13.0, when installing the package it would \ 
fallback to using the pure Python implementation automatically but that relied \ 
on a workaround to do it when there was no working compiler. With the changes in \ 
1.13.0 to use the builtin mechanism of Python to not fail when a C extension \ 
cannot be compiled, this fallback doesn't work when the compiler doesn't exist, \ 
as the builtin mechanism in Python regards lack of a compiler as fatal and not a \ 
condition for which it is okay to ignore the fact that the extension could not \ 
be compiled.

If you are using Python 2.7 on Windows, have a working compiler, and still want \ 
to attempt to install the C extension, you can do so by setting the \ 
WRAPT_INSTALL_EXTENSIONS environment variable to true when installing the wrapt \ 
package.

Note that the next signficant release of wrapt will drop support for Python 2.7 \ 
and Python 3.5. The change described here is to ensure that wrapt can be used \ 
with Python 2.7 on Windows for just a little bit longer. If using Python 2.7 on \ 
non Windows platforms, it will still attempt to install the C extension.

Log message:
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.

Log message:
devel: Remove SHA1 hashes for distfiles

Log message:
py-wrapt: updated to 1.12.1

Version 1.12.1

Bugs Fixed

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.

Version 1.12.0

Features Changed

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.
Bugs Fixed

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.

Log message:
py-wrapt: updated to 1.11.2

Version 1.11.2
Bugs Fixed
Fix possible crash when garbage collection kicks in when invoking a destructor \ 
of wrapped object.

Log message:
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.

Log message:
Version 1.10.11

Bugs Fixed
* When wrapping a @classmethod in a class used as a base class, when the method \ 
was called via the derived class type, the base class type was being passed for \ 
the cls argument instead of the derived class type through which the call was \ 
made.

New Features
* The C extension can be disabled at runtime by setting the environment variable \ 
WRAPT_DISABLE_EXTENSIONS. This may be necessary where there is currently a \ 
difference in behaviour between pure Python implementation and C extension and \ 
the C extension isn't having the desired result.