Mailman 3 February 2020 - Python-checkins

fixes typos in http.client documentation (#18300)
by James Corbett Feb. 1, 2020

Feb. 1, 2020

https://github.com/python/cpython/commit/b94737a4af96b29bd4c025724f671e7bc0… commit: b94737a4af96b29bd4c025724f671e7bc0f6b6f1 branch: master author: James Corbett <james.h.corbett(a)gmail.com> committer: GitHub <noreply(a)github.com> date: 2020-02-01T04:31:00-08:00 summary: fixes typos in http.client documentation (#18300) files: M Doc/library/http.client.rst diff --git a/Doc/library/http.client.rst b/Doc/library/http.client.rst index 807dd8bd379a0..35997db2a9d27 100644 --- a/Doc/library/http.client.rst +++ b/Doc/library/http.client.rst @@ -586,8 +586,8 @@ Here is an example session that shows how to ``POST`` requests:: Client side ``HTTP PUT`` requests are very similar to ``POST`` requests. The difference lies only the server side where HTTP server will allow resources to be created via ``PUT`` request. It should be noted that custom HTTP methods -+are also handled in :class:`urllib.request.Request` by sending the appropriate -+method attribute.Here is an example session that shows how to do ``PUT`` +are also handled in :class:`urllib.request.Request` by setting the appropriate +method attribute. Here is an example session that shows how to send a ``PUT`` request using http.client:: >>> # This creates an HTTP message

1 0

bpo-34793: Drop old-style context managers in asyncio.locks (GH-17533)
by Andrew Svetlov Feb. 1, 2020

Feb. 1, 2020

https://github.com/python/cpython/commit/90d9ba6ef10af32e8dfe0649789c3a8ccf… commit: 90d9ba6ef10af32e8dfe0649789c3a8ccf419e95 branch: master author: Andrew Svetlov <andrew.svetlov(a)gmail.com> committer: GitHub <noreply(a)github.com> date: 2020-02-01T13:12:52+02:00 summary: bpo-34793: Drop old-style context managers in asyncio.locks (GH-17533) files: A Misc/NEWS.d/next/Library/2019-12-09-17-24-29.bpo-34793.D82Dyu.rst M Doc/library/asyncio-sync.rst M Doc/whatsnew/3.9.rst M Lib/asyncio/locks.py M Lib/test/test_asyncio/test_locks.py M Lib/test/test_asyncio/test_pep492.py diff --git a/Doc/library/asyncio-sync.rst b/Doc/library/asyncio-sync.rst index f080b03bc7c51..84a52cb2d5757 100644 --- a/Doc/library/asyncio-sync.rst +++ b/Doc/library/asyncio-sync.rst @@ -347,8 +347,8 @@ BoundedSemaphore --------- -.. deprecated:: 3.7 +.. versionchanged:: 3.9 Acquiring a lock using ``await lock`` or ``yield from lock`` and/or :keyword:`with` statement (``with await lock``, ``with (yield from - lock)``) is deprecated. Use ``async with lock`` instead. + lock)``) was removed. Use ``async with lock`` instead. diff --git a/Doc/whatsnew/3.9.rst b/Doc/whatsnew/3.9.rst index c8f407751ec5e..ee37b5a5b7265 100644 --- a/Doc/whatsnew/3.9.rst +++ b/Doc/whatsnew/3.9.rst @@ -470,6 +470,11 @@ Removed :exc:`DeprecationWarning` since Python 3.8. (Contributed by Inada Naoki in :issue:`39377`) +* ``with (await asyncio.lock):`` and ``with (yield from asyncio.lock):`` statements are + not longer supported, use ``async with lock`` instead. The same is correct for + ``asyncio.Condition`` and ``asyncio.Semaphore``. + (Contributed by Andrew Svetlov in :issue:`34793`.) + Porting to Python 3.9 ===================== diff --git a/Lib/asyncio/locks.py b/Lib/asyncio/locks.py index d94daeb5a173f..f1ce7324785ba 100644 --- a/Lib/asyncio/locks.py +++ b/Lib/asyncio/locks.py @@ -3,96 +3,13 @@ __all__ = ('Lock', 'Event', 'Condition', 'Semaphore', 'BoundedSemaphore') import collections -import types import warnings from . import events -from . import futures from . import exceptions -from .import coroutines - - -class _ContextManager: - """Context manager. - - This enables the following idiom for acquiring and releasing a - lock around a block: - - with (yield from lock): - <block> - - while failing loudly when accidentally using: - - with lock: - <block> - - Deprecated, use 'async with' statement: - async with lock: - <block> - """ - - def __init__(self, lock): - self._lock = lock - - def __enter__(self): - # We have no use for the "as ..." clause in the with - # statement for locks. - return None - - def __exit__(self, *args): - try: - self._lock.release() - finally: - self._lock = None # Crudely prevent reuse. class _ContextManagerMixin: - def __enter__(self): - raise RuntimeError( - '"yield from" should be used as context manager expression') - - def __exit__(self, *args): - # This must exist because __enter__ exists, even though that - # always raises; that's how the with-statement works. - pass - - @types.coroutine - def __iter__(self): - # This is not a coroutine. It is meant to enable the idiom: - # - # with (yield from lock): - # <block> - # - # as an alternative to: - # - # yield from lock.acquire() - # try: - # <block> - # finally: - # lock.release() - # Deprecated, use 'async with' statement: - # async with lock: - # <block> - warnings.warn("'with (yield from lock)' is deprecated " - "use 'async with lock' instead", - DeprecationWarning, stacklevel=2) - yield from self.acquire() - return _ContextManager(self) - - # The flag is needed for legacy asyncio.iscoroutine() - __iter__._is_coroutine = coroutines._is_coroutine - - async def __acquire_ctx(self): - await self.acquire() - return _ContextManager(self) - - def __await__(self): - warnings.warn("'with await lock' is deprecated " - "use 'async with lock' instead", - DeprecationWarning, stacklevel=2) - # To make "with await lock" work. - return self.__acquire_ctx().__await__() - async def __aenter__(self): await self.acquire() # We have no use for the "as ..." clause in the with diff --git a/Lib/test/test_asyncio/test_locks.py b/Lib/test/test_asyncio/test_locks.py index 9468e740b3c1d..8c93fae2b51c6 100644 --- a/Lib/test/test_asyncio/test_locks.py +++ b/Lib/test/test_asyncio/test_locks.py @@ -47,13 +47,7 @@ def test_repr(self): self.assertTrue(repr(lock).endswith('[unlocked]>')) self.assertTrue(RGX_REPR.match(repr(lock))) - with self.assertWarns(DeprecationWarning): - @asyncio.coroutine - def acquire_lock(): - with self.assertWarns(DeprecationWarning): - yield from lock - - self.loop.run_until_complete(acquire_lock()) + self.loop.run_until_complete(lock.acquire()) self.assertTrue(repr(lock).endswith('[locked]>')) self.assertTrue(RGX_REPR.match(repr(lock))) @@ -61,18 +55,16 @@ def test_lock(self): with self.assertWarns(DeprecationWarning): lock = asyncio.Lock(loop=self.loop) - @asyncio.coroutine def acquire_lock(): - with self.assertWarns(DeprecationWarning): - return (yield from lock) - - res = self.loop.run_until_complete(acquire_lock()) + return (yield from lock) - self.assertTrue(res) - self.assertTrue(lock.locked()) + with self.assertRaisesRegex( + TypeError, + "object is not iterable" + ): + self.loop.run_until_complete(acquire_lock()) - lock.release() self.assertFalse(lock.locked()) def test_lock_by_with_statement(self): @@ -90,13 +82,13 @@ def test_lock_by_with_statement(self): def test(lock): yield from asyncio.sleep(0.01) self.assertFalse(lock.locked()) - with self.assertWarns(DeprecationWarning): - with (yield from lock) as _lock: - self.assertIs(_lock, None) - self.assertTrue(lock.locked()) - yield from asyncio.sleep(0.01) - self.assertTrue(lock.locked()) - self.assertFalse(lock.locked()) + with self.assertRaisesRegex( + TypeError, + "object is not iterable" + ): + with (yield from lock): + pass + self.assertFalse(lock.locked()) for primitive in primitives: loop.run_until_complete(test(primitive)) @@ -302,52 +294,16 @@ def test_release_no_waiters(self): self.assertFalse(lock.locked()) def test_context_manager(self): - with self.assertWarns(DeprecationWarning): - lock = asyncio.Lock(loop=self.loop) + async def f(): + lock = asyncio.Lock() + self.assertFalse(lock.locked()) - @asyncio.coroutine - def acquire_lock(): - with self.assertWarns(DeprecationWarning): - return (yield from lock) + async with lock: + self.assertTrue(lock.locked()) - with self.loop.run_until_complete(acquire_lock()): - self.assertTrue(lock.locked()) + self.assertFalse(lock.locked()) - self.assertFalse(lock.locked()) - - def test_context_manager_cant_reuse(self): - with self.assertWarns(DeprecationWarning): - lock = asyncio.Lock(loop=self.loop) - - @asyncio.coroutine - def acquire_lock(): - with self.assertWarns(DeprecationWarning): - return (yield from lock) - - # This spells "yield from lock" outside a generator. - cm = self.loop.run_until_complete(acquire_lock()) - with cm: - self.assertTrue(lock.locked()) - - self.assertFalse(lock.locked()) - - with self.assertRaises(AttributeError): - with cm: - pass - - def test_context_manager_no_yield(self): - with self.assertWarns(DeprecationWarning): - lock = asyncio.Lock(loop=self.loop) - - try: - with lock: - self.fail('RuntimeError is not raised in with expression') - except RuntimeError as err: - self.assertEqual( - str(err), - '"yield from" should be used as context manager expression') - - self.assertFalse(lock.locked()) + self.loop.run_until_complete(f()) class EventTests(test_utils.TestCase): @@ -809,33 +765,14 @@ def test_repr(self): self.assertTrue(RGX_REPR.match(repr(cond))) def test_context_manager(self): - with self.assertWarns(DeprecationWarning): - cond = asyncio.Condition(loop=self.loop) - - with self.assertWarns(DeprecationWarning): - @asyncio.coroutine - def acquire_cond(): - with self.assertWarns(DeprecationWarning): - return (yield from cond) - - with self.loop.run_until_complete(acquire_cond()): - self.assertTrue(cond.locked()) - - self.assertFalse(cond.locked()) - - def test_context_manager_no_yield(self): - with self.assertWarns(DeprecationWarning): - cond = asyncio.Condition(loop=self.loop) - - try: - with cond: - self.fail('RuntimeError is not raised in with expression') - except RuntimeError as err: - self.assertEqual( - str(err), - '"yield from" should be used as context manager expression') + async def f(): + cond = asyncio.Condition() + self.assertFalse(cond.locked()) + async with cond: + self.assertTrue(cond.locked()) + self.assertFalse(cond.locked()) - self.assertFalse(cond.locked()) + self.loop.run_until_complete(f()) def test_explicit_lock(self): with self.assertWarns(DeprecationWarning): @@ -920,16 +857,14 @@ def test_semaphore(self): with self.assertWarns(DeprecationWarning): @asyncio.coroutine def acquire_lock(): - with self.assertWarns(DeprecationWarning): - return (yield from sem) + return (yield from sem) - res = self.loop.run_until_complete(acquire_lock()) - - self.assertTrue(res) - self.assertTrue(sem.locked()) - self.assertEqual(0, sem._value) + with self.assertRaisesRegex( + TypeError, + "'Semaphore' object is not iterable", + ): + self.loop.run_until_complete(acquire_lock()) - sem.release() self.assertFalse(sem.locked()) self.assertEqual(1, sem._value) @@ -1064,38 +999,6 @@ def test_release_no_waiters(self): sem.release() self.assertFalse(sem.locked()) - def test_context_manager(self): - with self.assertWarns(DeprecationWarning): - sem = asyncio.Semaphore(2, loop=self.loop) - - @asyncio.coroutine - def acquire_lock(): - with self.assertWarns(DeprecationWarning): - return (yield from sem) - - with self.loop.run_until_complete(acquire_lock()): - self.assertFalse(sem.locked()) - self.assertEqual(1, sem._value) - - with self.loop.run_until_complete(acquire_lock()): - self.assertTrue(sem.locked()) - - self.assertEqual(2, sem._value) - - def test_context_manager_no_yield(self): - with self.assertWarns(DeprecationWarning): - sem = asyncio.Semaphore(2, loop=self.loop) - - try: - with sem: - self.fail('RuntimeError is not raised in with expression') - except RuntimeError as err: - self.assertEqual( - str(err), - '"yield from" should be used as context manager expression') - - self.assertEqual(2, sem._value) - if __name__ == '__main__': unittest.main() diff --git a/Lib/test/test_asyncio/test_pep492.py b/Lib/test/test_asyncio/test_pep492.py index a1f27dd5721c8..c5e3a5c148357 100644 --- a/Lib/test/test_asyncio/test_pep492.py +++ b/Lib/test/test_asyncio/test_pep492.py @@ -77,13 +77,12 @@ def test_context_manager_with_await(self): async def test(lock): await asyncio.sleep(0.01) self.assertFalse(lock.locked()) - with self.assertWarns(DeprecationWarning): - with await lock as _lock: - self.assertIs(_lock, None) - self.assertTrue(lock.locked()) - await asyncio.sleep(0.01) - self.assertTrue(lock.locked()) - self.assertFalse(lock.locked()) + with self.assertRaisesRegex( + TypeError, + "can't be used in 'await' expression" + ): + with await lock: + pass for primitive in primitives: self.loop.run_until_complete(test(primitive)) diff --git a/Misc/NEWS.d/next/Library/2019-12-09-17-24-29.bpo-34793.D82Dyu.rst b/Misc/NEWS.d/next/Library/2019-12-09-17-24-29.bpo-34793.D82Dyu.rst new file mode 100644 index 0000000000000..2089285ecdb7f --- /dev/null +++ b/Misc/NEWS.d/next/Library/2019-12-09-17-24-29.bpo-34793.D82Dyu.rst @@ -0,0 +1,3 @@ +Remove support for ``with (await asyncio.lock):`` and ``with (yield from +asyncio.lock):``. The same is correct for ``asyncio.Condition`` and +``asyncio.Semaphore``.

1 0

Update sum comment. (#18240)
by Brandt Bucher Feb. 1, 2020

Feb. 1, 2020

https://github.com/python/cpython/commit/abb9a448dee3e18c69080231fbeba980bf… commit: abb9a448dee3e18c69080231fbeba980bf048211 branch: master author: Brandt Bucher <brandtbucher(a)gmail.com> committer: GitHub <noreply(a)github.com> date: 2020-02-01T11:08:34Z summary: Update sum comment. (#18240) files: M Python/bltinmodule.c diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c index 4f833c1f46253..5818eb9e38f6a 100644 --- a/Python/bltinmodule.c +++ b/Python/bltinmodule.c @@ -2440,7 +2440,11 @@ builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start) empty = [] sum([[x] for x in range(10)], empty) - would change the value of empty. */ + would change the value of empty. In fact, using + in-place addition rather that binary addition for + any of the steps introduces subtle behavior changes: + + https://bugs.python.org/issue18305 */ temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item);

1 0

bpo-39511: PyThreadState_Clear() calls on_delete (GH-18296)
by Victor Stinner Jan. 31, 2020

Jan. 31, 2020

https://github.com/python/cpython/commit/4d96b4635aeff1b8ad41d41422ce808ce0… commit: 4d96b4635aeff1b8ad41d41422ce808ce0b971c8 branch: master author: Victor Stinner <vstinner(a)python.org> committer: GitHub <noreply(a)github.com> date: 2020-02-01T02:30:25+01:00 summary: bpo-39511: PyThreadState_Clear() calls on_delete (GH-18296) PyThreadState.on_delete is a callback used to notify Python when a thread completes. _thread._set_sentinel() function creates a lock which is released when the thread completes. It sets on_delete callback to the internal release_sentinel() function. This lock is known as Threading._tstate_lock in the threading module. The release_sentinel() function uses the Python C API. The problem is that on_delete is called late in the Python finalization, when the C API is no longer fully working. The PyThreadState_Clear() function now calls the PyThreadState.on_delete callback. Previously, that happened in PyThreadState_Delete(). The release_sentinel() function is now called when the C API is still fully working. files: A Misc/NEWS.d/next/C API/2020-01-31-16-35-21.bpo-39511.nv9yEn.rst M Doc/c-api/init.rst M Python/pystate.c diff --git a/Doc/c-api/init.rst b/Doc/c-api/init.rst index 7ea48aec009c9..14049ee64205f 100644 --- a/Doc/c-api/init.rst +++ b/Doc/c-api/init.rst @@ -1048,6 +1048,10 @@ All of the following functions must be called after :c:func:`Py_Initialize`. Reset all information in a thread state object. The global interpreter lock must be held. + .. versionchanged:: 3.9 + This function now calls the :c:member:`PyThreadState.on_delete` callback. + Previously, that happened in :c:func:`PyThreadState_Delete`. + .. c:function:: void PyThreadState_Delete(PyThreadState *tstate) diff --git a/Misc/NEWS.d/next/C API/2020-01-31-16-35-21.bpo-39511.nv9yEn.rst b/Misc/NEWS.d/next/C API/2020-01-31-16-35-21.bpo-39511.nv9yEn.rst new file mode 100644 index 0000000000000..14a04875a8894 --- /dev/null +++ b/Misc/NEWS.d/next/C API/2020-01-31-16-35-21.bpo-39511.nv9yEn.rst @@ -0,0 +1,3 @@ +The :c:func:`PyThreadState_Clear` function now calls the +:c:member:`PyThreadState.on_delete` callback. Previously, that happened in +:c:func:`PyThreadState_Delete`. diff --git a/Python/pystate.c b/Python/pystate.c index d792380de4649..ebc17ea5a7219 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -806,6 +806,10 @@ PyThreadState_Clear(PyThreadState *tstate) Py_CLEAR(tstate->async_gen_finalizer); Py_CLEAR(tstate->context); + + if (tstate->on_delete != NULL) { + tstate->on_delete(tstate->on_delete_data); + } } @@ -830,9 +834,7 @@ tstate_delete_common(PyThreadState *tstate, if (tstate->next) tstate->next->prev = tstate->prev; HEAD_UNLOCK(runtime); - if (tstate->on_delete != NULL) { - tstate->on_delete(tstate->on_delete_data); - } + PyMem_RawFree(tstate); if (gilstate->autoInterpreterState &&

1 0

bpo-39511: Fix multiprocessing semlock_acquire() (GH-18298)
by Victor Stinner Jan. 31, 2020

Jan. 31, 2020

https://github.com/python/cpython/commit/7dc140126e918cc7c6e65aea321b7255f0… commit: 7dc140126e918cc7c6e65aea321b7255f0020798 branch: master author: Victor Stinner <vstinner(a)python.org> committer: GitHub <noreply(a)github.com> date: 2020-02-01T01:25:59+01:00 summary: bpo-39511: Fix multiprocessing semlock_acquire() (GH-18298) The Python C API must not be used when the GIL is released: only access Py_None when the GIL is hold. files: M Modules/_multiprocessing/semaphore.c diff --git a/Modules/_multiprocessing/semaphore.c b/Modules/_multiprocessing/semaphore.c index 4be2deae37750..ee490256d2a27 100644 --- a/Modules/_multiprocessing/semaphore.c +++ b/Modules/_multiprocessing/semaphore.c @@ -268,11 +268,8 @@ static PyObject * semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds) { int blocking = 1, res, err = 0; - double timeout; PyObject *timeout_obj = Py_None; struct timespec deadline = {0}; - struct timeval now; - long sec, nsec; static char *kwlist[] = {"block", "timeout", NULL}; @@ -285,19 +282,23 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds) Py_RETURN_TRUE; } - if (timeout_obj != Py_None) { - timeout = PyFloat_AsDouble(timeout_obj); - if (PyErr_Occurred()) + int use_deadline = (timeout_obj != Py_None); + if (use_deadline) { + double timeout = PyFloat_AsDouble(timeout_obj); + if (PyErr_Occurred()) { return NULL; - if (timeout < 0.0) + } + if (timeout < 0.0) { timeout = 0.0; + } + struct timeval now; if (gettimeofday(&now, NULL) < 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } - sec = (long) timeout; - nsec = (long) (1e9 * (timeout - sec) + 0.5); + long sec = (long) timeout; + long nsec = (long) (1e9 * (timeout - sec) + 0.5); deadline.tv_sec = now.tv_sec + sec; deadline.tv_nsec = now.tv_usec * 1000 + nsec; deadline.tv_sec += (deadline.tv_nsec / 1000000000); @@ -315,7 +316,7 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds) /* Couldn't acquire immediately, need to block */ do { Py_BEGIN_ALLOW_THREADS - if (timeout_obj == Py_None) { + if (!use_deadline) { res = sem_wait(self->handle); } else {

1 0