Gevent

Latest version: v24.2.1

Safety actively analyzes 630130 Python packages for vulnerabilities to keep your Python projects secure.

Scan your dependencies

Page 3 of 4

1.1b3

Not secure
- Fix an `AttributeError` from `gevent.monkey.patch_builtins` on
Python 2 when the `future`_ library is also installed. Reported by
Carlos Sanchez.
- PyPy: Fix a `DistutilsModuleError` or `ImportError` if the CFFI
module backing `gevent.core` needs to be compiled when the hub is
initialized (due to a missing or invalid `__pycache__` directory).
Now, the module will be automtically compiled when gevent is
imported (this may produce compiler output on stdout). Reported in
:issue:`619` by Thinh Nguyen and :issue:`631` by Andy Freeland, with
contributions by Jay Oster and Matt Dupre.
- PyPy: Improve the performance of `gevent.socket.socket:sendall`
with large inputs. `bench_sendall.py`_ now performs about as well on
PyPy as it does on CPython, an improvement of 10x (from ~60MB/s to
~630MB/s). See this `pypy bug`_ for details.
- Fix a possible `TypeError` when calling `gevent.socket.wait`.
Reported in 635 by lanstin.
- `gevent.socket.socket:sendto` properly respects the socket's
blocking status (meaning it can raise EWOULDBLOCK now in cases it
wouldn't have before). Reported in :pr:`634` by Mike Kaplinskiy.
- Common lookup errors using the :mod:`threaded resolver
<gevent.resolver_thread>` are no longer always printed to stderr
since they are usually out of the programmer's control and caught
explicitly. (Programming errors like `TypeError` are still
printed.) Reported in :issue:`617` by Jay Oster and Carlos Sanchez.
- PyPy: Fix a `TypeError` from `gevent.idle()`. Reported in
:issue:`639` by chilun2008.
- The `imap_unordered` methods of a pool support a `maxsize`
parameter to limit the number of results buffered waiting for the
consumer. Reported in :issue:`638` by Sylvain Zimmer.
- The class `gevent.queue.Queue` now consistently orders multiple
blocked waiting `put` and `get` callers in the order they
arrived. Previously, due to an implementation quirk this was often
roughly the case under CPython, but not under PyPy. Now they both
behave the same.
- The class `gevent.queue.Queue` now supports the `len()` function.

1.1b2

Not secure
- Enable the c-ares resolver extension for PyPy.
- On some versions of PyPy on some platforms (notably 2.6.0 on 64-bit
Linux), enabling `gevent.monkey.patch_builtins` could cause PyPy
to crash. Reported in 618 by Jay Oster.
- `gevent.kill` raises the correct exception in the target greenlet.
Reported in 623 by Jonathan Kamens.
- Various fixes on Windows. Reported in 625, 627,
and 628 by jacekt and Yuanteng (Jeff) Pei. Fixed in 624.
- Add `readable` and `writable` methods to `FileObjectPosix`;
this fixes e.g., help() on Python 3 when monkey-patched.

1.1b1

Not secure
- `setup.py` can be run from a directory containing spaces. Reported
in :issue:`319` by Ivan Smirnov.
- `setup.py` can build with newer versions of clang on OS X. They
enforce the distinction between CFLAGS and CPPFLAGS.
- `gevent.lock.Semaphore` is atomic on PyPy, just like it is on
CPython. This comes at a small performance cost.
- Fixed regression that failed to set the `successful` value to
False when killing a greenlet before it ran with a non-default
exception. Fixed in :pr:`608` by Heungsub Lee.
- libev's child watchers caused `os.waitpid` to become unreliable
due to the use of signals on POSIX platforms. This was especially
noticeable when using `gevent.subprocess` in combination with
`multiprocessing`. Now, the monkey-patched `os` module provides
a `waitpid` function that seeks to ameliorate this. Reported in
:issue:`600` by champax and :issue:`452` by Łukasz Kawczyński.
- On platforms that implement `select.poll`, provide a
gevent-friendly `gevent.select.poll` and corresponding
monkey-patch. Implemented in :pr:`604` by Eddi Linder.
- Allow passing of events to the io callback under PyPy. Reported in
:issue:`531` by M. Nunberg and implemented in :pr:`604`.
- `gevent.thread.allocate_lock` (and so a monkey-patched standard
library `allocate_lock`) more closely matches the behaviour of the
builtin: an unlocked lock cannot be released, and attempting to do
so throws the correct exception (`thread.error` on Python 2,
`RuntimeError` on Python 3). Previously, over-releasing a lock was
silently ignored. Reported in :issue:`308` by Jędrzej Nowak.
- `gevent.fileobject.FileObjectThread` uses the threadpool to close
the underling file-like object. Reported in :issue:`201` by
vitaly-krugl.
- Malicious or malformed HTTP chunked transfer encoding data sent to
the `gevent.pywsgi` handler is handled more robustly, resulting in
"HTTP 400 bad request" responses instead of a 500 error or, in the
worst case, a server-side hang. Reported in :issue:`229` by Björn
Lindqvist.
- Importing the standard library `threading` module _before_ using
`gevent.monkey.patch_all()` no longer causes Python 3.4 to fail to
get the `repr` of the main thread, and other CPython platforms to
return an unjoinable DummyThread. (Note that this is not
recommended.) Reported in :issue:`153`.
- Under Python 2, use the `io` package to implement
`FileObjectPosix`. This unifies the code with the Python 3
implementation, and fixes problems with using `seek()`. See
:issue:`151`.
- Under Python 2, importing a module that uses gevent blocking
functions at its top level from multiple greenlets no longer
produces import errors (Python 3 handles this case natively).
Reported in :issue:`108` by shaun and initial fix based on code by
Sylvain Zimmer.
- `gevent.spawn`, `spawn_raw` and `spawn_later`, as well as the
`Greenlet` constructor, immediately produce useful `TypeError`s
if asked to run something that cannot be run. Previously, the
spawned greenlet would die with an uncaught `TypeError` the first
time it was switched to. Reported in :issue:`119` by stephan.
- Recursive use of `gevent.threadpool.ThreadPool.apply` no longer
raises a `LoopExit` error (using `ThreadPool.spawn` and then
`get` on the result still could; you must be careful to use the
correct hub). Reported in :issue:`131` by 8mayday.
- When the `threading` module is monkey-patched, the module-level
lock in the `logging` module is made greenlet-aware, as are the
instance locks of any configured handlers. This makes it safer to
import modules that use the standard pattern of creating a
module-level `Logger` instance before monkey-patching. Configuring
`logging` with a basic configuration and then monkey-patching is
also safer (but not configurations that involve such things as the
`SocketHandler`).
- Fix monkey-patching of `threading.RLock` under Python 3.
- Under Python 3, monkey-patching at the top-level of a module that
was imported by another module could result in a `RuntimeError`
from `importlib`. Reported in :issue:`615` by Daniel Mizyrycki.
(The same thing could happen under Python 2 if a `threading.RLock`
was held around the monkey-patching call; this is less likely but
not impossible with import hooks.)
- Fix configuring c-ares for a 32-bit Python when running on a 64-bit
platform. Reported in :issue:`381` and fixed in :pr:`616` by Chris
Lane.
- (Experimental) Let the `pywsgi.WSGIServer` accept a
`logging.Logger` instance for its `log` and (new) `error_log`
parameters. Take care that the system is fully monkey-patched very
early in the process's lifetime if attempting this, and note that
non-file handlers have not been tested. Fixes :issue:`106`.

1.1a2

Not secure
- `gevent.threadpool.ThreadPool.imap` and `imap_unordered` now
accept multiple iterables.
- (Experimental) Exceptions raised from iterating using the
`ThreadPool` or `Group` mapping/application functions should now
have the original traceback.
- `gevent.threadpool.ThreadPool.apply` now raises any exception
raised by the called function, the same as
`gevent.pool.Group`/`Pool` and the builtin `apply` function.
This obsoletes the undocumented `apply_e` function. Original PR
556 by Robert Estelle.
- Monkey-patch the `selectors` module from `patch_all` and
`patch_select` on Python 3.4. See 591 .
- Additional query functions for the :mod:`gevent.monkey` module
allow knowing what was patched. Discussed in :issue:`135` and
implemented in :pr:`325` by Nathan Hoad.
- In non-monkey-patched environments under Python 2.7.9 or above or
Python 3, using a gevent SSL socket could cause the greenlet to
block. See :issue:`597` by David Ford.
- `gevent.socket.socket.sendall` supports arbitrary objects that
implement the buffer protocol (such as ctypes structures), just like
native sockets. Reported in :issue:`466` by tzickel.
- Added support for the `onerror` attribute present in CFFI 1.2.0
for better signal handling under PyPy. Thanks to Armin Rigo and Omer
Katz. (See https://bitbucket.org/cffi/cffi/issue/152/handling-errors-from-signal-handlers-in)
- The `gevent.subprocess` module is closer in behaviour to the
standard library under Python 3, at least on POSIX. The
`pass_fds`, `restore_signals`, and `start_new_session`
arguments are now unimplemented, as are the `timeout` parameters
to various functions. Under Python 2, the previously undocumented `timeout`
parameter to `Popen.communicate` raises an exception like its
Python 3 counterpart.
- An exception starting a child process with the `gevent.subprocess`
module no longer leaks file descriptors. Reported in :pr:`374` by 陈小玉.
- The example `echoserver.py` no longer binds to the standard X11
TCP port. Reported in :issue:`485` by minusf.
- `gevent.iwait` no longer throws `LoopExit` if the caller
switches greenlets between return values. Reported and initial patch
in :pr:`467` by Alexey Borzenkov.
- The default threadpool and default threaded resolver work in a
forked child process, such as with `multiprocessing.Process`.
Previously the child process would hang indefinitely. Reported in
:issue:`230` by Lx Yu.
- Fork watchers are more likely to (eventually) get called in a
multi-threaded program.
- `gevent.killall` accepts an arbitrary iterable for the greenlets
to kill. Reported in :issue:`404` by Martin Bachwerk; seen in
combination with older versions of simple-requests.
- `gevent.local.local` objects are now eligible for garbage
collection as soon as the greenlet finishes running, matching the
behaviour of the built-in `threading.local` (when implemented
natively). Reported in :issue:`387` by AusIV.
- Killing a greenlet (with `gevent.kill` or
`gevent.greenlet.Greenlet.kill`) before it is actually started and
switched to now prevents the greenlet from ever running, instead of
raising an exception when it is later switched to. See :issue:`330`
reported by Jonathan Kamens.

1.1a1

Not secure
See [the changelog](https://github.com/gevent/gevent/blob/master/changelog.rst#11a1-jun-29-2015) for a detailed list of changes.

1.0.2

Not secure
See https://github.com/gevent/gevent/blob/1.0.2/changelog.rst#release-102-may-23-2015 for a list of changes.

Page 3 of 4

© 2024 Safety CLI Cybersecurity Inc. All Rights Reserved.