Preparing release 20.5.1

CHANGES.rst

@@ -6,6 +6,102 @@
 
 .. towncrier release notes start
 
+20.5.1 (2020-05-26)
+===================
+
+
+Features
+--------
+
+- Waiters on Event and Semaphore objects that call ``wait()`` or
+  ``acquire()``, respectively, that find the Event already set, or the
+  Semaphore available, no longer "cut in line" and run before any
+  previously scheduled greenlets. They now run in the order in which
+  they arrived, just as waiters that had to block in those methods do.
+  See :issue:`1520`.
+- Update tested PyPy version from 7.3.0 to 7.3.1 on Linux.
+  See :issue:`1569`.
+- Make ``zope.interface``, ``zope.event`` and (by extension)
+  ``setuptools`` required dependencies. The ``events`` install extra now
+  does nothing and will be removed in 2021.
+  See :issue:`1619`.
+- Update bundled libuv from 1.36.0 to 1.38.0.
+  See :issue:`1621`.
+- Update bundled c-ares from 1.16.0 to 1.16.1.
+
+  On macOS, stop trying to adjust c-ares headers to make them
+  universal.
+  See :issue:`1624`.
+
+
+Bugfixes
+--------
+
+- Make gevent locks that are monkey-patched usually work across native
+  threads as well as across greenlets within a single thread. Locks that
+  are only used in a single thread do not take a performance hit. While
+  cross-thread locking is relatively expensive, and not a recommended
+  programming pattern, it can happen unwittingly, for example when
+  using the threadpool and ``logging``.
+
+  Before, cross-thread lock uses might succeed, or, if the lock was
+  contended, raise ``greenlet.error``. Now, in the contended case, if
+  the lock has been acquired by the main thread at least once, it should
+  correctly block in any thread, cooperating with the event loop of both
+  threads. In certain (hopefully rare) cases, it might be possible for
+  contended case to raise ``LoopExit`` when previously it would have
+  raised ``greenlet.error``; if these cases are a practical concern,
+  please open an issue.
+
+  Also, the underlying Semaphore always behaves in an atomic fashion (as
+  if the GIL was not released) when PURE_PYTHON is set. Previously, it
+  only correctly did so on PyPy.
+  See :issue:`issue1437`.
+- Rename gevent's C accelerator extension modules using a prefix to
+  avoid clashing with other C extensions.
+  See :issue:`1480`.
+- Using ``gevent.wait`` on an ``Event`` more than once, when that Event
+  is already set, could previously raise an AssertionError.
+
+  As part of this, exceptions raised in the main greenlet will now
+  include a more complete traceback from the failing greenlet.
+  See :issue:`1540`.
+- Avoid closing the same Python libuv watcher IO object twice. Under
+  some circumstances (only seen on Windows), that could lead to program
+  crashes.
+  See :issue:`1587`.
+- gevent can now be built using Cython 3.0a5 and newer. The PyPI
+  distribution uses this version.
+
+  The libev extension was incompatible with this. As part of this,
+  certain internal, undocumented names have been changed.
+
+  (Technically, gevent can be built with Cython 3.0a2 and above.
+  However, up through 3.0a4 compiling with Cython 3 results in
+  gevent's test for memory leaks failing. See `this Cython issue
+  <https://github.com/cython/cython/issues/3578>`_.)
+  See :issue:`1599`.
+- Destroying a hub after joining it didn't necessarily clean up all
+  resources associated with the hub, especially if the hub had been
+  created in a secondary thread that was exiting. The hub and its parent
+  greenlet could be kept alive.
+
+  Now, destroying a hub drops the reference to the hub and ensures it
+  cannot be switched to again. (Though using a new blocking API call may
+  still create a new hub.)
+
+  Joining a hub also cleans up some (small) memory resources that might
+  have stuck around for longer before as well.
+  See :issue:`1601`.
+- Fix some potential crashes under libuv when using
+  ``gevent.signal_handler``. The crashes were seen running the test
+  suite and were non-deterministic.
+  See :issue:`1606`.
+
+
+----
+
+
 20.5.0 (2020-05-01)
 ===================
 

docs/changes/1480.bugfix

-Rename gevent's C accelerator extension modules using a prefix to
-avoid clashing with other C extensions.

docs/changes/1520.feature

-Waiters on Event and Semaphore objects that call ``wait()`` or
-``acquire()``, respectively, that find the Event already set, or the
-Semaphore available, no longer "cut in line" and run before any
-previously scheduled greenlets. They now run in the order in which
-they arrived, just as waiters that had to block in those methods do.

docs/changes/1540.bugfix

-Using ``gevent.wait`` on an ``Event`` more than once, when that Event
-is already set, could previously raise an AssertionError.
-
-As part of this, exceptions raised in the main greenlet will now
-include a more complete traceback from the failing greenlet.

docs/changes/1569.feature

-Update tested PyPy version from 7.3.0 to 7.3.1 on Linux.

docs/changes/1587.bugfix

-Avoid closing the same Python libuv watcher IO object twice. Under
-some circumstances (only seen on Windows), that could lead to program
-crashes.

docs/changes/1599.bugfix

-gevent can now be built using Cython 3.0a5 and newer. The PyPI
-distribution uses this version.
-
-The libev extension was incompatible with this. As part of this,
-certain internal, undocumented names have been changed.
-
-(Technically, gevent can be built with Cython 3.0a2 and above.
-However, up through 3.0a4 compiling with Cython 3 results in
-gevent's test for memory leaks failing. See `this Cython issue
-<https://github.com/cython/cython/issues/3578>`_.)

docs/changes/1601.bugfix

-Destroying a hub after joining it didn't necessarily clean up all
-resources associated with the hub, especially if the hub had been
-created in a secondary thread that was exiting. The hub and its parent
-greenlet could be kept alive.
-
-Now, destroying a hub drops the reference to the hub and ensures it
-cannot be switched to again. (Though using a new blocking API call may
-still create a new hub.)
-
-Joining a hub also cleans up some (small) memory resources that might
-have stuck around for longer before as well.

docs/changes/1606.bugfix

-Fix some potential crashes under libuv when using
-``gevent.signal_handler``. The crashes were seen running the test
-suite and were non-deterministic.

docs/changes/1619.feature

-Make ``zope.interface``, ``zope.event`` and (by extension)
-``setuptools`` required dependencies. The ``events`` install extra now
-does nothing and will be removed in 2021.

docs/changes/1621.feature

-Update bundled libuv from 1.36.0 to 1.38.0.

docs/changes/1624.feature

-Update bundled c-ares from 1.16.0 to 1.16.1.
-
-On macOS, stop trying to adjust c-ares headers to make them
-universal.

docs/changes/issue1437.bugfix

-Make gevent locks that are monkey-patched usually work across native
-threads as well as across greenlets within a single thread. Locks that
-are only used in a single thread do not take a performance hit. While
-cross-thread locking is relatively expensive, and not a recommended
-programming pattern, it can happen unwittingly, for example when
-using the threadpool and ``logging``.
-
-Before, cross-thread lock uses might succeed, or, if the lock was
-contended, raise ``greenlet.error``. Now, in the contended case, if
-the lock has been acquired by the main thread at least once, it should
-correctly block in any thread, cooperating with the event loop of both
-threads. In certain (hopefully rare) cases, it might be possible for
-contended case to raise ``LoopExit`` when previously it would have
-raised ``greenlet.error``; if these cases are a practical concern,
-please open an issue.
-
-Also, the underlying Semaphore always behaves in an atomic fashion (as
-if the GIL was not released) when PURE_PYTHON is set. Previously, it
-only correctly did so on PyPy.

src/gevent/__init__.py

@@ -27,7 +27,7 @@ version_info = _version_info(20, 0, 0, 'dev', 0) # XXX: Remove me
 #: Use ``pkg_resources.parse_version(__version__)`` or
 #: ``packaging.version.Version(__version__)`` to get a machine-usable
 #: value.
-__version__ = '20.5.1.dev0'
+__version__ = '20.5.1'
 
 
 __all__ = [

src/gevent/event.py

@@ -66,7 +66,7 @@ class Event(AbstractLinkable): # pylint:disable=undefined-variable
         The low-level ``rawlink`` method (most users won't use this) now
         automatically unlinks waiters before calling them.
 
-    .. versionchanged:: NEXT
+    .. versionchanged:: 20.5.1
 
         Callers to ``wait`` that find the event already set will now run
         after any other waiters that had to block. See :issue:`1520`.

src/gevent/hub.py

@@ -237,7 +237,7 @@ class signal(object):
         The ``handler`` argument is required to
         be callable at construction time.
 
-    .. versionchanged:: NEXT
+    .. versionchanged:: 20.5.1
        The ``cancel`` method now properly cleans up all native resources,
        and drops references to all the arguments of this function.
     """
@@ -541,7 +541,7 @@ class Hub(WaitOperationsGreenlet):
         System errors cause the exception to be raised in the main
         greenlet (the parent of this hub).
 
-        .. versionchanged:: NEXT
+        .. versionchanged:: 20.5.1
            Allow passing the traceback to associate with the
            exception if it is rethrown into the main greenlet.
         """
@@ -761,7 +761,7 @@ class Hub(WaitOperationsGreenlet):
         hub. Attempts to use the blocking gevent API with pre-existing
         objects from this native thread and bound to this hub will fail.
 
-        .. versionchanged:: NEXT
+        .. versionchanged:: 20.5.1
             Ensure that Python stack frames and greenlets referenced by this
             hub are cleaned up. This guarantees that switching to the hub again
             is not safe after this. (It was never safe, but it's even less safe.)

src/gevent/lock.py

@@ -273,7 +273,7 @@ class RLock(object):
 
     def __init__(self, hub=None):
         """
-        .. versionchanged:: NEXT
+        .. versionchanged:: 20.5.1
            Add the ``hub`` argument.
         """
         self._block = Semaphore(1, hub)