Log message:
py-structlog: fix build by using wheel.mk

Add a missing test dependency, add test status

Log message:
py-structlog: updated to 21.5.0

21.5.0 (2021-12-16)
-------------------
Changes:
- Added the ``structlog.processors.LogfmtRenderer`` processor to render log \ 
lines using the `logfmt <https://brandur.org/logfmt>`_ format.
- Added the ``structlog.stdlib.ExtraAdder`` processor that adds extra attributes \ 
of ``logging.LogRecord`` objects to the event dictionary.
  This processor can be used for adding data passed in the ``extra`` parameter \ 
of the ``logging`` module's log methods to the event dictionary.
- Added the ``structlog.processor.CallsiteParameterAdder`` processor that adds \ 
parameters of the callsite that an event dictionary orginated from to the event \ 
dictionary.
  This processor can be used to enrich events dictionaries with information such \ 
as the function name, line number and filename that an event dictionary \ 
orignated from.

21.4.0 (2021-11-25)
-------------------
Changes:
- Fixed import when running in optimized mode (``PYTHONOPTIMIZE=2`` or ``python \ 
-OO``).
- Added the ``structlog.threadlocal.bound_threadlocal`` and \ 
``structlog.contextvars.bound_contextvars`` decorator/context managers to \ 
temporarily bind key/value pairs to a thread-local and context-local context.

21.3.0 (2021-11-20)
-------------------
Backward-incompatible changes:
- ``structlog`` switched its packaging to `flit \ 
<https://flit.readthedocs.io/>`_.
  Users shouldn't notice a difference, but (re-)packagers might.

Changes:
- ``structlog.dev.ConsoleRenderer`` now has ``sort_keys`` boolean parameter that \ 
allows to disable the sorting of keys on output.
- ``structlog.processors.TimeStamper`` now works well with FreezeGun even when \ 
it gets applied before the loggers are configured.
- ``structlog.stdlib.AsyncBoundLogger`` now determines the running loop when \ 
logging, not on instantiation.
  That has a minor performance impact, but makes it more robust when loops \ 
change (e.g. ``aiohttp.web.run_app()``), or you want to use ``sync_bl`` *before* \ 
a loop has started.
- ``structlog.stdlib.ProcessorFormatter`` now has a *processors* argument that \ 
allows to define a processor chain to run over *all* log entries.

  Before running the chain, two additional keys are added to the event \ 
dictionary: ``_record`` and ``_from_structlog``.
  With them it's possible to extract information from ``logging.LogRecord``\s \ 
and differentiate between ``structlog`` and ``logging`` log entries while \ 
processing them.

  The old *processor* (singular) parameter is now deprecated, but no plans exist \ 
to remove it.

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

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

Log message:
py-structlog: updated to 21.2.0

21.2.0 (2021-10-12)
-------------------

Backward-incompatible changes:

- To implement pretty exceptions (see Changes below), \ 
``structlog.dev.ConsoleRenderer`` now formats exceptions itself.

  Make sure to remove ``format_exc_info`` from your processor chain if you \ 
configure ``structlog`` manually.
  This change is not really breaking, because the old use-case will keep working \ 
as before.
  However if you pass ``pretty_exceptions=True`` (which is the default if either \ 
``rich`` or ``better-exceptions`` is installed), a warning will be raised and \ 
the exception will be renderered without prettyfication.

Changes:

- ``structlog`` is now importable if ``sys.stdout`` is ``None`` (e.g. when \ 
running using ``pythonw``).
- ``structlog.threadlocal.get_threadlocal()`` and \ 
``structlog.contextvars.get_contextvars()`` can now be used to get a copy of the \ 
current thread-local/context-local context that has been bound using \ 
``structlog.threadlocal.bind_threadlocal()`` and \ 
``structlog.contextvars.bind_contextvars()``.
- ``structlog.threadlocal.get_merged_threadlocal(bl)`` and \ 
``structlog.contextvars.get_merged_contextvars(bl)`` do the same, but also merge \ 
the context from a bound logger *bl*.
  Same pull requests as previous change.
- ``structlog.contextvars.bind_contextvars()`` now returns a mapping of keys to \ 
``contextvars.Token``\s, allowing you to reset values using the new \ 
``structlog.contextvars.reset_contextvars()``.
- Exception rendering in ``structlog.dev.ConsoleLogger`` is now configurable \ 
using the ``exception_formatter`` setting.
  If either the `rich <https://github.com/willmcgugan/rich>`_ or the \ 
`better-exceptions <https://github.com/qix-/better-exceptions>`_ package \ 
is present, ``structlog`` will use them for pretty-printing tracebacks.
  ``rich`` takes precedence over ``better-exceptions`` if both are present.

  This only works if ``format_exc_info`` is **absent** in the processor chain.
- All use of ``colorama`` on non-Windows systems has been excised.
  Thus, colors are now enabled by default in ``structlog.dev.ConsoleRenderer`` \ 
on non-Windows systems.
  You can keep using ``colorama`` to customize colors, of course.
- The final processor can now return a ``bytearray`` (additionally to ``str`` \ 
and ``bytes``).

Log message:
sysutils: Replace RMD160 checksums with BLAKE2s checksums

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

Log message:
sysutils: Remove SHA1 hashes for distfiles

Log message:
py-structlog: updated to 21.1.0

21.1.0 (2021-02-18)
Changes:
- ``structlog.threadlocal.wrap_dict()`` now has a correct type annotation.
- Fix isolation in ``structlog.contextvars``.
- The default configuration and loggers are pickleable again.
- ``structlog.dev.ConsoleRenderer`` will now look for a ``logger_name`` key if no
  ``logger`` key is set.

Log message:
py-structlog: updated to 20.2.0

20.2.0

Backward-incompatible changes:

- Python 2.7 and 3.5 aren't supported anymore.
  The package meta data should ensure that you keep getting 20.1.0 on those versions.

- ``structlog`` is now fully type-annotated.
  This won't break your applications, but if you use Mypy, it will most likely \ 
break your CI.

  Check out the new chapter on typing for details.

Deprecations:

- Accessing the ``_context`` attribute of a bound logger is now deprecated.
  Please use the new ``structlog.get_context()``.

Changes:

- ``structlog`` has now type hints for all of its APIs!
  Since ``structlog`` is highly dynamic and configurable, this led to a few \ 
concessions like a specialized ``structlog.stdlib.get_logger()`` whose only \ 
difference to ``structlog.get_logger()`` is that it has the correct type hints.

  We consider them provisional for the time being – i.e. the backward \ 
compatibility does not apply to them in its full strength until we feel we got \ 
it right.
  Please feel free to provide feedback!
- Added ``structlog.make_filtering_logger`` that can be used like \ 
``configure(wrapper_class=make_filtering_bound_logger(logging.INFO))``.
  It creates a highly optimized bound logger whose inactive methods only consist \ 
of a ``return None``.
  This is now also the default logger.
- As a complement, ``structlog.stdlib.add_log_level()`` can now additionally be \ 
imported as ``structlog.processors.add_log_level`` since it just adds the method \ 
name to the event dict.
- ``structlog.processors.add_log_level()`` is now part of the default configuration.
- ``structlog.stdlib.ProcessorFormatter`` no longer uses exceptions for control \ 
flow, allowing ``foreign_pre_chain`` processors to use ``sys.exc_info()`` to \ 
access the real exception.
- Added ``structlog.BytesLogger`` to avoid unnecessary encoding round trips.
  Concretely this is useful with *orjson* which returns bytes.
- The final processor now also may return bytes that are passed untouched to the \ 
wrapped logger.
- ``structlog.get_context()`` allows you to retrieve the original context of a \ 
bound logger.
- ``structlog.PrintLogger`` now supports ``copy.deepcopy()``.
- Added ``structlog.testing.CapturingLogger`` for more unit testing goodness.
- Added ``structlog.stdlib.AsyncBoundLogger`` that executes logging calls in a \ 
thread executor and therefore doesn't block.

Log message:
py-structlog: updated to 20.1.0

20.1.0

Deprecations:
- This is the last version to support Python 2.7 (including PyPy) and 3.5.
  All following versions will only support Python 3.6 or later.

Changes:
- Added a new module ``structlog.contextvars`` that allows to have a global but \ 
context-local ``structlog`` context the same way as with \ 
``structlog.threadlocal`` since 19.2.0.
- Added a new module ``structlog.testing`` for first class testing support.
  The first entry is the context manager ``capture_logs()`` that allows to make \ 
assertions about structured log calls.
- Added ``structlog.threadlocal.unbind_threadlocal()``.
- The logger created by ``structlog.get_logger()`` is not detected as an \ 
abstract method anymore, when attached to an abstract base class.
- ``colorama`` isn't initialized lazily on Windows anymore because it breaks \ 
rendering.

Log message:
py-structlog: updated to 19.2.0

19.2.0:

Backward-incompatible changes:
- Python 3.4 is not supported anymore.
  It has been unsupported by the Python core team for a while now and its PyPI \ 
downloads are negligible.
  It's very unlikely that ``structlog`` will break under 3.4 anytime soon, but \ 
we don't test it anymore.

Changes:
- Full Python 3.8 support for ``structlog.stdlib``.
- Added more pass-through properties to ``structlog.stdlib.BoundLogger``.
  To makes it easier to use it as a drop-in replacement for ``logging.Logger``.
- ``structlog.stdlib.ProcessorFormatter`` now takes a logger object as an \ 
optional keyword argument.
  This makes ``ProcessorFormatter`` work properly with \ 
``stuctlog.stdlib.filter_by_level()``.
- ``structlog.dev.ConsoleRenderer`` now uses no colors by default, if \ 
``colorama`` is not available.
- ``structlog.dev.ConsoleRenderer`` now initializes ``colorama`` lazily, to \ 
prevent accidental side-effects just by importing ``structlog``.
- Added new processor ``structlog.dev.set_exc_info()`` that will set \ 
``exc_info=True`` if the method's name is `exception` and ``exc_info`` isn't set \ 
at all.
  *This is only necessary when the standard library integration is not used*.
  It fixes the problem that in the default configuration, \ 
``structlog.get_logger().exception("hi")`` in an ``except`` block \ 
would not print the exception without passing ``exc_info=True`` to it \ 
explicitly.
- A best effort has been made to make as much of ``structlog`` pickleable as \ 
possible to make it friendlier with ``multiprocessing`` and similar libraries.
  Some classes can only be pickled on Python 3 or using the `dill \ 
<https://pypi.org/project/dill/>`_ library though and that is very \ 
unlikely to change.
  So far, the configuration proxy, ``structlog.processor.TimeStamper``, \ 
``structlog.BoundLogger``, ``structlog.PrintLogger`` and \ 
``structlog.dev.ConsoleRenderer`` have been made pickelable.
- Added a new thread-local API that allows binding values to a thread-local \ 
context explicitly without affecting the default behavior of ``bind()``.
- Added ``pass_foreign_args`` argument to ``structlog.stdlib.ProcessorFormatter``.
  It allows to pass a foreign log record's ``args`` attribute to the event \ 
dictionary under the ``positional_args`` key.
- ``structlog.dev.ConsoleRenderer`` now calls ``str()`` on the event value.