Add files using upload-large-folder tool

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/AUTHORS

@@ -0,0 +1,62 @@
+Gevent is written and maintained by
+
+  Denis Bilenko
+  Matt Iversen
+  Steffen Prince
+  Jason Madden
+
+and the contributors (ordered by the date of first contribution):
+
+  Jason Toffaletti
+  Mike Barton
+  Ludvig Ericson
+  Marcus Cavanaugh
+  Matt Goodall
+  Ralf Schmitt
+  Daniele Varrazzo
+  Nicholas Piël
+  Örjan Persson
+  Uriel Katz
+  Ted Suzman
+  Randall Leeds
+  Erik Näslund
+  Alexey Borzenkov
+  David Hain
+  Dmitry Chechik
+  Ned Rockson
+  Tommie Gannert
+  Shaun Lindsay
+  Andreas Blixt
+  Nick Barkas
+  Galfy Pundee
+  Alexander Boudkar
+  Damien Churchill
+  Tom Lynn
+  Shaun Cutts
+  David LaBissoniere
+  Alexandre Kandalintsev
+  Geert Jansen
+  Vitaly Kruglikov
+  Saúl Ibarra Corretgé
+  Oliver Beattie
+  Bobby Powers
+  Anton Patrushev
+  Jan-Philip Gehrcke
+  Alex Gaynor
+  陈小玉
+  Philip Conrad
+  Heungsub Lee
+  Ron Rothman
+
+  See https://github.com/gevent/gevent/graphs/contributors for more info.
+
+Gevent is inspired by and uses some code from eventlet which was written by
+
+  Bob Ipollito
+  Donovan Preston
+
+The win32util module is taken from Twisted. The tblib module is taken from python-tblib by Ionel Cristian Mărieș.
+
+Some modules (local, ssl) contain code from the Python standard library.
+
+If your code is used in gevent and you are not mentioned above, please contact the maintainer.

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Except when otherwise stated (look at the beginning of each file) the software
+and the documentation in this project are copyrighted by:
+
+  Denis Bilenko and the contributors, http://www.gevent.org
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/METADATA

@@ -0,0 +1,349 @@
+Metadata-Version: 2.1
+Name: gevent
+Version: 24.11.1
+Summary: Coroutine-based network library
+Home-page: http://www.gevent.org/
+Author: Denis Bilenko
+Author-email: denis.bilenko@gmail.com
+Maintainer: Jason Madden
+Maintainer-email: jason@nextthought.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/gevent/gevent/issues
+Project-URL: Source Code, https://github.com/gevent/gevent/
+Project-URL: Documentation, http://www.gevent.org
+Project-URL: Changes, https://www.gevent.org/changelog.html
+Keywords: greenlet coroutine cooperative multitasking light threads monkey
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: NOTICE
+License-File: AUTHORS
+Requires-Dist: zope.event
+Requires-Dist: zope.interface
+Requires-Dist: greenlet>=3.1.1; platform_python_implementation == "CPython"
+Requires-Dist: cffi>=1.17.1; platform_python_implementation == "CPython" and sys_platform == "win32"
+Provides-Extra: dnspython
+Requires-Dist: dnspython<2.0,>=1.16.0; python_version < "3.10" and extra == "dnspython"
+Requires-Dist: idna; python_version < "3.10" and extra == "dnspython"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: repoze.sphinx.autointerface; extra == "docs"
+Requires-Dist: sphinxcontrib-programoutput; extra == "docs"
+Requires-Dist: zope.schema; extra == "docs"
+Provides-Extra: events
+Provides-Extra: monitor
+Requires-Dist: psutil>=5.7.0; (sys_platform != "win32" or platform_python_implementation == "CPython") and extra == "monitor"
+Provides-Extra: recommended
+Requires-Dist: cffi>=1.17.1; platform_python_implementation == "CPython" and extra == "recommended"
+Requires-Dist: dnspython<2.0,>=1.16.0; python_version < "3.10" and extra == "recommended"
+Requires-Dist: idna; python_version < "3.10" and extra == "recommended"
+Requires-Dist: psutil>=5.7.0; (sys_platform != "win32" or platform_python_implementation == "CPython") and extra == "recommended"
+Provides-Extra: test
+Requires-Dist: requests; extra == "test"
+Requires-Dist: objgraph; extra == "test"
+Requires-Dist: cffi>=1.17.1; platform_python_implementation == "CPython" and extra == "test"
+Requires-Dist: dnspython<2.0,>=1.16.0; python_version < "3.10" and extra == "test"
+Requires-Dist: idna; python_version < "3.10" and extra == "test"
+Requires-Dist: coverage>=5.0; sys_platform != "win32" and extra == "test"
+Requires-Dist: psutil>=5.7.0; (sys_platform != "win32" or platform_python_implementation == "CPython") and extra == "test"
+
+========
+ gevent
+========
+
+.. image:: https://github.com/gevent/gevent/workflows/gevent%20testing/badge.svg
+   :target: https://github.com/gevent/gevent/actions
+
+.. image:: https://ci.appveyor.com/api/projects/status/bqxl88yhpho223jg?svg=true
+   :target: https://ci.appveyor.com/project/denik/gevent
+
+.. image:: https://coveralls.io/repos/gevent/gevent/badge.svg?branch=master&service=github
+   :target: https://coveralls.io/github/gevent/gevent?branch=master
+
+..
+  This file is included in README.rst from the top-level
+  so it is limited to pure ReST markup, not Sphinx.
+
+
+
+gevent is a coroutine_ -based Python_ networking library that uses
+`greenlet <https://greenlet.readthedocs.io>`_ to provide a high-level synchronous API on top of the `libev`_
+or `libuv`_ event loop.
+
+Features include:
+
+
+* Fast event loop based on `libev`_ or `libuv`_.
+* Lightweight execution units based on greenlets.
+* API that re-uses concepts from the Python standard library (for
+  examples there are `events`_ and
+  `queues`_).
+* `Cooperative sockets with SSL support <http://www.gevent.org/api/index.html#networking>`_
+* `Cooperative DNS queries <http://www.gevent.org/dns.html>`_ performed through a threadpool,
+  dnspython, or c-ares.
+* `Monkey patching utility <http://www.gevent.org/intro.html#monkey-patching>`_ to get 3rd party modules to become cooperative
+* TCP/UDP/HTTP servers
+* Subprocess support (through `gevent.subprocess`_)
+* Thread pools
+
+gevent is `inspired by eventlet`_ but features a more consistent API,
+simpler implementation and better performance. Read why others `use
+gevent`_ and check out the list of the `open source projects based on
+gevent`_.
+
+gevent was written by `Denis Bilenko <http://denisbilenko.com/>`_.
+
+Since version 1.1, gevent is maintained by Jason Madden for
+`NextThought <https://nextthought.com>`_ (through gevent 21) and
+`Institutional Shareholder Services <https://www.issgovernance.com>`_
+with help from the `contributors
+<https://github.com/gevent/gevent/graphs/contributors>`_ and is
+licensed under the MIT license.
+
+See `what's new`_ in the latest major release.
+
+Check out the detailed changelog_ for this version.
+
+.. _events: http://www.gevent.org/api/gevent.event.html#gevent.event.Event
+.. _queues: http://www.gevent.org/api/gevent.queue.html#gevent.queue.Queue
+.. _gevent.subprocess: http://www.gevent.org/api/gevent.subprocess.html#module-gevent.subprocess
+
+.. _coroutine: https://en.wikipedia.org/wiki/Coroutine
+.. _Python: http://python.org
+.. _libev: http://software.schmorp.de/pkg/libev.html
+.. _libuv: http://libuv.org
+.. _inspired by eventlet: http://blog.gevent.org/2010/02/27/why-gevent/
+.. _use gevent: http://groups.google.com/group/gevent/browse_thread/thread/4de9703e5dca8271
+.. _open source projects based on gevent: https://github.com/gevent/gevent/wiki/Projects
+.. _what's new: http://www.gevent.org/whatsnew_1_5.html
+.. _changelog: http://www.gevent.org/changelog.html
+
+
+Read the documentation online at http://www.gevent.org.
+
+Post issues on the `bug tracker`_, discuss and ask open ended
+questions on the `mailing list`_, and find announcements and
+information on the blog_ and `twitter (@gevent)`_.
+
+===============================
+ Installation and Requirements
+===============================
+
+.. _installation:
+
+..
+  This file is included in README.rst so it is limited to plain
+  ReST markup, not Sphinx.
+
+.. note::
+
+   If you are reading this document on the `Python Package Index`_
+   (PyPI, https://pypi.org/), it is specific to the version of gevent that
+   you are viewing. If you are viewing this document on gevent.org, it
+   refers to the current state of gevent in source control (git
+   master).
+
+Supported Platforms
+===================
+
+This version of gevent runs on Python 3.8 and up, (for exact details
+of tested versions, see the classifiers on the PyPI page or in
+``setup.py``). gevent requires the `greenlet
+<https://greenlet.readthedocs.io>`_ library and will install the
+`cffi`_ library by default on Windows. The cffi library will become
+the default on all platforms in a future release of gevent.
+
+This version of gevent is also tested on on PyPy 3.10 (7.3.12); it
+should run on PyPy 3.9 and above. On PyPy, there are no external
+dependencies.
+
+gevent is tested on Windows, macOS, and Linux, and should run on most
+other Unix-like operating systems (e.g., FreeBSD, Solaris, etc.)
+
+.. note::
+
+   Windows is supported as a tier 2, "best effort," platform. It is
+   suitable for development, but not recommended for production. In
+   particular, PyPy3 on Windows may have issues, especially with
+   subprocesses.
+
+   On Windows using the deprecated libev backend, gevent is
+   limited to a maximum of 1024 open sockets due to
+   `limitations in libev`_. This limitation should not exist
+   with the default libuv backend.
+
+Older Versions of Python
+------------------------
+
+Users of older versions of Python 2 or Python 3 may install an older
+version of gevent. Note that these versions are generally not
+supported.
+
++-------+-------+
+|Python |Gevent |
+|Version|Version|
++=======+=======+
+|2.5    |1.0.x  |
+|       |       |
++-------+-------+
+|2.6    |1.1.x  |
++-------+-------+
+|<=     |1.2.x  |
+|2.7.8  |       |
++-------+-------+
+|3.3    |1.2.x  |
++-------+-------+
+|3.4.0 -| 1.3.x |
+|3.4.2  |       |
+|       |       |
++-------+-------+
+|3.4.3  | 1.4.x |
+|       |       |
+|       |       |
++-------+-------+
+|3.5.x  | 20.9.0|
+|       |       |
+|       |       |
++-------+-------+
+|2.7.9 -|       |
+|2.7.18,| 22.10 |
+|3.6,   |       |
+|3.7    |       |
+|       |       |
++-------+-------+
+
+Installation
+============
+
+.. note::
+
+   This section is about installing released versions of gevent as
+   distributed on the `Python Package Index`_. For building gevent
+   from source, including customizing the build and embedded
+   libraries, see `Installing From Source`_.
+
+.. _Python Package Index: http://pypi.org/project/gevent
+
+gevent and greenlet can both be installed with `pip`_, e.g., ``pip
+install gevent``. Installation using `buildout
+<http://docs.buildout.org/en/latest/>`_ is also supported.
+
+On Windows, macOS, and Linux, both gevent and greenlet are
+distributed as binary `wheels`_.
+
+.. tip::
+
+   You need Pip 8.0 or later, or buildout 2.10.0 to install the binary
+   wheels on Windows or macOS. On Linux, you'll need `pip 19
+   <https://github.com/pypa/pip/pull/5008>`_ to install the
+   manylinux2010 wheels.
+
+.. tip::
+
+   While the x86-64 binaries are considered production quality, they
+   are built with relatively low optimization levels and no hardware
+   specific optimizations. Serious production users are encouraged to
+   install from source with appropriate compiler flags.
+
+.. tip::
+
+   Beginning with gevent 20.12.0, 64-bit ARM binaries are distributed
+   on PyPI for aarch64 manylinux2014 compatible systems. Installing these
+   needs a very recent version of ``pip``. These wheels *do not*
+   contain the c-ares resolver, are not tested, and are built with
+   very low levels of optimizations. Serious production users of
+   gevent on 64-bit ARM systems are encouraged to build their own
+   binary wheels.
+
+   Beginning with gevent 22.10.0, ppc64le binaries are distributed on
+   PyPI. The same caveats apply as for 64-bit ARM binaries. Using them
+   for anything other than local development is discouraged.
+
+   Beginning with gevent 23, muslinux aarch64 and S390X binaries
+   are distributed on PyPI. The same caveats apply as for 64-bit ARM
+   binaries. Using them for anything other than local development is
+   discouraged.
+
+
+Installing From Source
+----------------------
+
+If you are unable to use the binary wheels (for platforms where no
+pre-built wheels are available or if wheel installation is disabled),
+you can build gevent from source. A normal ``pip install`` will
+fall back to doing this if no binary wheel is available. See
+`Installing From Source`_ for more, including common installation issues.
+
+Extra Dependencies
+==================
+
+There are a number
+of additional libraries that extend gevent's functionality and will be
+used if they are available. All of these may be installed using
+`setuptools extras
+<https://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-extras-optional-features-with-their-own-dependencies>`_,
+as named below, e.g., ``pip install gevent[events]``.
+
+events
+    In versions of gevent up to and including 20.5.0, this provided configurable
+    event support using `zope.event
+    <https://pypi.org/project/zope.event>`_ and was highly
+    recommended.
+
+    In versions after that, this extra is empty and does nothing. It
+    will be removed in gevent 21.0.
+
+dnspython
+    Enables a pure-Python resolver, backed by `dnspython
+    <https://pypi.org/project/dnspython>`_. On Python 2, this also
+    includes `idna <https://pypi.org/project/idna>`_. They can be
+    installed with the ``dnspython`` extra.
+
+    .. note:: This is not compatible with Python 3.10+ or dnspython 2.
+
+monitor
+    Enhancements to gevent's self-monitoring capabilities. This
+    includes the `psutil <https://pypi.org/project/psutil>`_ library
+    which is needed to monitor memory usage. (Note that this may not
+    build on all platforms.)
+
+recommended
+    A shortcut for installing suggested extras together. This includes
+    the non-test extras defined here, plus additions that improve
+    gevent's operation on certain platforms (for example, in the past,
+    it has included backports of newer APIs).
+
+test
+    Everything needed to run the complete gevent test suite.
+
+
+.. _`pip`: https://pip.pypa.io/en/stable/installing/
+.. _`wheels`: http://pythonwheels.com
+.. _`gevent 1.5`: whatsnew_1_5.html
+.. _`Installing From Source`: https://www.gevent.org/development/installing_from_source.html
+
+.. _`cffi`: https://cffi.readthedocs.io
+.. _`limitations in libev`: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#WIN32_PLATFORM_LIMITATIONS_AND_WORKA
+
+
+.. _bug tracker: https://github.com/gevent/gevent/issues
+.. _mailing list: http://groups.google.com/group/gevent
+.. _blog: https://dev.nextthought.com/blog/categories/gevent.html
+.. _twitter (@gevent): http://twitter.com/gevent

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/NOTICE

@@ -0,0 +1,94 @@
+gevent is licensed under the MIT license. See the LICENSE file for the
+complete license.
+
+Portions of this software may have other licenses.
+
+=============================================
+
+greentest/2.7
+greentest/2.7.8
+greentest/2.7pypy
+greentest/3.3
+greentest/3.4
+greentest/3.5
+-----------------
+
+Copyright (c) 2001-2016 Python Software Foundation; All Rights Reserved
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001-2016 Python Software Foundation; All Rights
+Reserved" are retained in Python alone or in any derivative version prepared
+by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+============================================
+
+gevent/libuv/_corecffi_source.c
+gevent/libuv/_corecffi_cdef.c
+
+Originally based on code from https://github.com/veegee/guv
+
+Copyright (c) 2014 V G
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+===========================================

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/RECORD

@@ -0,0 +1,558 @@
+gevent-24.11.1.dist-info/AUTHORS,sha256=IS4ttuioANx5ucZqOXHiezC9ys2nkpxl1M_8f77Rleo,1303
+gevent-24.11.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+gevent-24.11.1.dist-info/LICENSE,sha256=TUa8EdGeOFPVQyWXO44sUwkPVjinvyf6H18SMseJAfc,1235
+gevent-24.11.1.dist-info/METADATA,sha256=WaZtQb7KccFebD8a5N-GXq2gXBzY6CzkOSA33IqGveA,13477
+gevent-24.11.1.dist-info/NOTICE,sha256=ZJOCR8qaV_7kwRZWQEuTwxMCkYfhPaeHySe2xkpoBYM,4004
+gevent-24.11.1.dist-info/RECORD,,
+gevent-24.11.1.dist-info/WHEEL,sha256=-ffw4ErOrld3H5FyGb0-yfKd91A4S1balHz5KyTz-4c,151
+gevent-24.11.1.dist-info/entry_points.txt,sha256=g2MTL3KfdJVJ6CEp0d4f9x6HjLAp-MklXYlxlZQ9_u4,95
+gevent-24.11.1.dist-info/top_level.txt,sha256=fpElGiTe2fdw27vmNxdV5MQpyndjzWZMk5TB_NMYPSI,7
+gevent/__init__.py,sha256=CGttQxS3SceN70fIhe-oRee6AmT9RjtXKc02Aol6TNw,3407
+gevent/__pycache__/__init__.cpython-310.pyc,,
+gevent/__pycache__/_abstract_linkable.cpython-310.pyc,,
+gevent/__pycache__/_compat.cpython-310.pyc,,
+gevent/__pycache__/_config.cpython-310.pyc,,
+gevent/__pycache__/_fileobjectcommon.cpython-310.pyc,,
+gevent/__pycache__/_fileobjectposix.cpython-310.pyc,,
+gevent/__pycache__/_greenlet_primitives.cpython-310.pyc,,
+gevent/__pycache__/_hub_local.cpython-310.pyc,,
+gevent/__pycache__/_hub_primitives.cpython-310.pyc,,
+gevent/__pycache__/_ident.cpython-310.pyc,,
+gevent/__pycache__/_imap.cpython-310.pyc,,
+gevent/__pycache__/_interfaces.cpython-310.pyc,,
+gevent/__pycache__/_monitor.cpython-310.pyc,,
+gevent/__pycache__/_patcher.cpython-310.pyc,,
+gevent/__pycache__/_semaphore.cpython-310.pyc,,
+gevent/__pycache__/_socket3.cpython-310.pyc,,
+gevent/__pycache__/_socketcommon.cpython-310.pyc,,
+gevent/__pycache__/_tblib.cpython-310.pyc,,
+gevent/__pycache__/_threading.cpython-310.pyc,,
+gevent/__pycache__/_tracer.cpython-310.pyc,,
+gevent/__pycache__/_util.cpython-310.pyc,,
+gevent/__pycache__/_waiter.cpython-310.pyc,,
+gevent/__pycache__/ares.cpython-310.pyc,,
+gevent/__pycache__/backdoor.cpython-310.pyc,,
+gevent/__pycache__/baseserver.cpython-310.pyc,,
+gevent/__pycache__/builtins.cpython-310.pyc,,
+gevent/__pycache__/contextvars.cpython-310.pyc,,
+gevent/__pycache__/core.cpython-310.pyc,,
+gevent/__pycache__/event.cpython-310.pyc,,
+gevent/__pycache__/events.cpython-310.pyc,,
+gevent/__pycache__/exceptions.cpython-310.pyc,,
+gevent/__pycache__/fileobject.cpython-310.pyc,,
+gevent/__pycache__/greenlet.cpython-310.pyc,,
+gevent/__pycache__/hub.cpython-310.pyc,,
+gevent/__pycache__/local.cpython-310.pyc,,
+gevent/__pycache__/lock.cpython-310.pyc,,
+gevent/__pycache__/os.cpython-310.pyc,,
+gevent/__pycache__/pool.cpython-310.pyc,,
+gevent/__pycache__/pywsgi.cpython-310.pyc,,
+gevent/__pycache__/queue.cpython-310.pyc,,
+gevent/__pycache__/resolver_ares.cpython-310.pyc,,
+gevent/__pycache__/resolver_thread.cpython-310.pyc,,
+gevent/__pycache__/select.cpython-310.pyc,,
+gevent/__pycache__/selectors.cpython-310.pyc,,
+gevent/__pycache__/server.cpython-310.pyc,,
+gevent/__pycache__/signal.cpython-310.pyc,,
+gevent/__pycache__/socket.cpython-310.pyc,,
+gevent/__pycache__/ssl.cpython-310.pyc,,
+gevent/__pycache__/subprocess.cpython-310.pyc,,
+gevent/__pycache__/thread.cpython-310.pyc,,
+gevent/__pycache__/threading.cpython-310.pyc,,
+gevent/__pycache__/threadpool.cpython-310.pyc,,
+gevent/__pycache__/time.cpython-310.pyc,,
+gevent/__pycache__/timeout.cpython-310.pyc,,
+gevent/__pycache__/util.cpython-310.pyc,,
+gevent/__pycache__/win32util.cpython-310.pyc,,
+gevent/_abstract_linkable.py,sha256=vpHRKQF0qw4FMKYQMCCY70jzuWGUpL-VFeBshchG364,22722
+gevent/_compat.py,sha256=5J80cwYac8ns8sOWc719Lkw7O-pCSH7r3Y7Na4OsDYM,2806
+gevent/_config.py,sha256=Lx1isVwHjFutWHL2Oth1Y6lc9ynENucjhcZFOVFrxnc,21428
+gevent/_ffi/__init__.py,sha256=BTBgjjvO4ecQBPbReBhem-0zvy1Mq6jXf5dMrykGIhs,493
+gevent/_ffi/__pycache__/__init__.cpython-310.pyc,,
+gevent/_ffi/__pycache__/callback.cpython-310.pyc,,
+gevent/_ffi/__pycache__/loop.cpython-310.pyc,,
+gevent/_ffi/__pycache__/watcher.cpython-310.pyc,,
+gevent/_ffi/callback.py,sha256=JL2mvMVD7vVaatIdUxo9UfvUJvIwiHhZ7qLGgiBc8YA,1564
+gevent/_ffi/loop.py,sha256=gq5kGvEyhMknFEM58vXnN0QC5tbmN9sOOWOsHHR7NcY,31802
+gevent/_ffi/watcher.py,sha256=qUFXAHM56_GVyCrvv6VkA735ZvtvLB8Zv26I8iMKIgs,20954
+gevent/_fileobjectcommon.py,sha256=S-69DeitiPnvjbGfexTuD2yzPeI0-eDv_1DBIlV0sTg,24359
+gevent/_fileobjectposix.py,sha256=n4ziPoRoq3741XEHN-UTKdXihoq8TUyik6k9HD-UFI8,12840
+gevent/_gevent_c_abstract_linkable.cpython-310-x86_64-linux-gnu.so,sha256=biDM6csd8yxuD1ggOl_n69rZroxKaawS4qzExEPBLWo,1021000
+gevent/_gevent_c_greenlet_primitives.cpython-310-x86_64-linux-gnu.so,sha256=QkNhIn0oKA4PHk1XTCssDgz3CpjbTY3_y_EQwbupfd8,498944
+gevent/_gevent_c_hub_local.cpython-310-x86_64-linux-gnu.so,sha256=Gf2NVwg68xmwNzj04QQsXXCJlouk28J9_ilBC0BPZx0,398712
+gevent/_gevent_c_hub_primitives.cpython-310-x86_64-linux-gnu.so,sha256=8CR_u8d-3MO0YQKOZCT0xY7Zt-u4nkM6vJK2wVv0c-0,1086104
+gevent/_gevent_c_ident.cpython-310-x86_64-linux-gnu.so,sha256=3Lz-x4XoynIkpg8XwIvU3zk5dCMwjeHArldLReiUOwk,346704
+gevent/_gevent_c_imap.cpython-310-x86_64-linux-gnu.so,sha256=dyXcy00koo5ACsyQHdFNzF-dTeFHBOX2hV-R2BRheSY,623536
+gevent/_gevent_c_semaphore.cpython-310-x86_64-linux-gnu.so,sha256=Y3o7jHFE9r4bJwRmPSuXn-TH1lwgJO65Xl54Jl4IeD4,1062208
+gevent/_gevent_c_tracer.cpython-310-x86_64-linux-gnu.so,sha256=gnwW0AS7s4QFfWlCUAb7wFBMoQ5_Z3KUcoAaDgtXDeg,731368
+gevent/_gevent_c_waiter.cpython-310-x86_64-linux-gnu.so,sha256=8_ttuHOOOEcckQpbhtqUO9eECjHstd8K4wOh9T9bXAo,521608
+gevent/_gevent_cevent.cpython-310-x86_64-linux-gnu.so,sha256=spDqQyo89edL6qPh2TMk5YliCxnbMSiKhpsMhhloddA,776328
+gevent/_gevent_cgreenlet.cpython-310-x86_64-linux-gnu.so,sha256=ai4EL81Zy8Sq47-zwEjYSrvrT-wYd8qFD0vWtH6_pnE,2119856
+gevent/_gevent_clocal.cpython-310-x86_64-linux-gnu.so,sha256=9zjpFK2y2q99o-FyiY7mHkDfcPb18pi7crb4SmzkpSA,1009128
+gevent/_gevent_cqueue.cpython-310-x86_64-linux-gnu.so,sha256=hfPVeCsWlxgSv254bEWRmEFDUb8OhIEvc3CipIc3DuU,1923064
+gevent/_greenlet_primitives.py,sha256=i2b0bj5oYr5qzhRRQPhzbCMEg9zMRAx_zhiSOCHtTeY,4647
+gevent/_hub_local.py,sha256=OJPT7QZufzgEgV3SJvOVUWIqhYAKVgfn2mGx9ismIFo,4763
+gevent/_hub_primitives.py,sha256=aTCXhH1gJNdb1JONz7X0fBnNCu9Lv1U55sVF2dXpnUk,14026
+gevent/_ident.py,sha256=w7kjbyaNR4MVzRTjB0_3ZUZ-JYS6eukY55l-r_MdjM4,2249
+gevent/_imap.py,sha256=RtrIfyUPPMFxNX4gSVuJQLjn6oxIdI2t9ERVErIgtwg,7672
+gevent/_interfaces.py,sha256=D-ZJuGse_gtj8XOTRQyXgsj9FNLCr9Xtn_9U5Txk-Cc,9731
+gevent/_monitor.py,sha256=t-zK6iL6rxtGMuBcnNq0kpRIdNDmESWnTRf1y4j64vc,12006
+gevent/_patcher.py,sha256=e4dfPB9MhmnipVpwwEPcChMbiC2F0Rp_MdkwZ02ZF_c,9020
+gevent/_semaphore.py,sha256=BBjdqHfz8NFVD_XbKbiGxgMUvxYfGeBXA1qh26tgqb8,20887
+gevent/_socket3.py,sha256=w8mFOeD3gFyI2_zWOj1u0adxIKBeNc2Jumhy-CjmNUs,23013
+gevent/_socketcommon.py,sha256=tbdbfwoVh6lSBEYYKogVCRTH-uyUpKBvIbCc4TFkGwY,26066
+gevent/_tblib.py,sha256=szKF1dyK4ELE2_44vxyBPZatAtZe57w0Mseki4ld_IA,12219
+gevent/_threading.py,sha256=mYFPLhSlSWXTGDixNLm0JFfnh3jH1e51fyl5iSXaczM,8342
+gevent/_tracer.py,sha256=FX1B-6s7GWWKLvcdYKRZYCbHABy9i3c5p66cy95ijKM,6455
+gevent/_util.py,sha256=go3VuMYv1k9zpvNkGp0MbxZT4gn3xfutA9HjoY9G6nk,10964
+gevent/_waiter.py,sha256=fCVW5AxbqvIYROgHbC22kljXr6wHIr54fPePtTVMoW4,7387
+gevent/ares.py,sha256=2LLRXoWkyS5YwSpJ0b7R_e3M8ikwpsA53eUWizys8eM,383
+gevent/backdoor.py,sha256=Hn7dZXAzywWypJm2MENTWZLS4oUrSpriy_Apz2X-7f4,8642
+gevent/baseserver.py,sha256=x4zWdbE5JtOYCuvGQozCUgfpArhN0mPMXdLdPDRiYnI,16614
+gevent/builtins.py,sha256=0K7haEs0DhfIEhArBaxaRRx_i3Dws2ZqFWey6HOYjHo,4108
+gevent/contextvars.py,sha256=a0f8GxwQESkQM-zUNO-gdmDcW-2-kV321auE6KbSHGw,9838
+gevent/core.py,sha256=XgaVreHocvO9JCVby3JCo8ixbllJL08V9OrA7ETDaHs,479
+gevent/event.py,sha256=vOR3t77RyCzLH240f-DrypxLNgwsP4YkOaaeqZfYa64,15079
+gevent/events.py,sha256=olRj_SbHNW-I8Ifs6vNYWaRKV0bWtgEFnOYt6Uhihuk,17182
+gevent/exceptions.py,sha256=6JvoCgb4Recrl_kngtBe8Zx36uwc5qTakLJSJBQVr8I,3932
+gevent/fileobject.py,sha256=GNeYmbGSLWq8t311pVbgYsyDpzMmtQ8m2fHI15a0EpI,3020
+gevent/greenlet.py,sha256=gWxllLzY6SQanwBKO_nXxm7IEY7k02cv4Bq0V4gIm0Y,45203
+gevent/hub.py,sha256=_ZodHnESbnnj2qg8p-4aGhY4HH4u-7T7wJHI00JYJAM,34590
+gevent/libev/__init__.py,sha256=I6hpYFJCnbBBDrousKzZ7Ql--mnfAFwfM2q1BuxcMfI,169
+gevent/libev/__pycache__/__init__.cpython-310.pyc,,
+gevent/libev/__pycache__/_corecffi_build.cpython-310.pyc,,
+gevent/libev/__pycache__/corecffi.cpython-310.pyc,,
+gevent/libev/__pycache__/watcher.cpython-310.pyc,,
+gevent/libev/_corecffi.abi3.so,sha256=iivm2mzecVM_515ub_hbspW7nT1nRFlS4NC8TUWlumw,473480
+gevent/libev/_corecffi_build.py,sha256=ARUO9jiMqdfk80aSs4_CkBIIwcpUaF9enyj-AJVXVP8,4059
+gevent/libev/corecext.cpython-310-x86_64-linux-gnu.so,sha256=dVkXbVISohLQNrKUqHonyhh1BDzudif32NSryKk0aGU,2563472
+gevent/libev/corecffi.py,sha256=yxz0x6YzcQSFPSuba3JJpPJkkdU7KBwFPa299cGOGSw,13720
+gevent/libev/watcher.py,sha256=DGBi_JFksqLv4ifO5o-eIT8POn-om3EdiJhQDVx4pLs,7999
+gevent/libuv/__init__.py,sha256=I6hpYFJCnbBBDrousKzZ7Ql--mnfAFwfM2q1BuxcMfI,169
+gevent/libuv/__pycache__/__init__.cpython-310.pyc,,
+gevent/libuv/__pycache__/_corecffi_build.cpython-310.pyc,,
+gevent/libuv/__pycache__/loop.cpython-310.pyc,,
+gevent/libuv/__pycache__/watcher.cpython-310.pyc,,
+gevent/libuv/_corecffi.abi3.so,sha256=LsSrcAHjxBA-GEbOP7U-E3OuVX9T4yp4ZX_sncATvrQ,1307296
+gevent/libuv/_corecffi_build.py,sha256=uzAzrWhtl6yfjvBSR-1WkdPtsPSPo-oS_kqii1WAMnc,12349
+gevent/libuv/loop.py,sha256=q7es7RTne1wl2EEJ9AVHw5-mBvu92cmxQ5qh_QeKtlM,27626
+gevent/libuv/watcher.py,sha256=kuT3uqGc5XnAw1T_vgnseH2KpqAUqE5xjk65VXVoFxk,27664
+gevent/local.py,sha256=I12OWg8nWR5q7p3UZhJjSMfbyHuShVqYqQTkmPdF-8k,21457
+gevent/lock.py,sha256=Wsfkdv2By0C-7plcGmK5OWEX9EmVhvY1UpEdYkHUNYA,11398
+gevent/monkey/__init__.py,sha256=blTV4wtxZGjRAJLXA80cCSduobcUJE9KUdLvkibq2Xk,24869
+gevent/monkey/__main__.py,sha256=JPNIwI-Qb_VQERows-n4R2XzcY8rGCt5FR8kUiKD1J4,31
+gevent/monkey/__pycache__/__init__.cpython-310.pyc,,
+gevent/monkey/__pycache__/__main__.cpython-310.pyc,,
+gevent/monkey/__pycache__/_errors.cpython-310.pyc,,
+gevent/monkey/__pycache__/_main.cpython-310.pyc,,
+gevent/monkey/__pycache__/_patch_thread_common.cpython-310.pyc,,
+gevent/monkey/__pycache__/_patch_thread_gte313.cpython-310.pyc,,
+gevent/monkey/__pycache__/_patch_thread_lt313.cpython-310.pyc,,
+gevent/monkey/__pycache__/_state.cpython-310.pyc,,
+gevent/monkey/__pycache__/_util.cpython-310.pyc,,
+gevent/monkey/__pycache__/api.cpython-310.pyc,,
+gevent/monkey/_errors.py,sha256=cBctoXo4sAME97eaCdWGY1q1zEOtG8krDFyv-O5WOiQ,547
+gevent/monkey/_main.py,sha256=8zzhBLrRSBV0D_GbgwcY_iwsIR3ayrG9xX8TvyGAvH8,4411
+gevent/monkey/_patch_thread_common.py,sha256=n018JoqZ2zMZnKWzhDNOOkEOWJxskOOWjth-q_30b3A,13119
+gevent/monkey/_patch_thread_gte313.py,sha256=83Mix-vpJA2xGmmsxD4Glc4c-c8kyjrMMngxuB1zlPo,3490
+gevent/monkey/_patch_thread_lt313.py,sha256=3qLEpTt2L6CRJy2H1SFyVqtrfT8ItnHpUpOD45Mxdzc,3054
+gevent/monkey/_state.py,sha256=FGJFTDXFUwio1b-IwtlOmXCysVrqheM9j9JjRxOzrqI,1897
+gevent/monkey/_util.py,sha256=U-KBkLB9v5J7RedNHOfK7qaaonaKo5Z7oQ-5gwrYnAo,3689
+gevent/monkey/api.py,sha256=ZoRUk0e-wVXE6CnTI8BULQaDAIVqyEmTCwXhVzUrh5s,6760
+gevent/os.py,sha256=1sJXacYJZUDwgUii44K_D1AB6EwFTTHtYQEX7D6Vaho,20858
+gevent/pool.py,sha256=JSt0I106SQr3wYjc9z919ebcX3MUyM33gaAbohSXNCo,25634
+gevent/pywsgi.py,sha256=ZWZMKmn21k3K5NS6JLJ4UrPLTA3z2bn-jPjHRjm7fKc,69033
+gevent/queue.py,sha256=Vkq4L7xSTcYYOmw_EynWMas6OkWoXdSV47YOivlMnI0,25708
+gevent/resolver/__init__.py,sha256=lx0L8Up3DXkp61RQxceQbmj5AVFt9WGMhHi12-iy7GI,10760
+gevent/resolver/__pycache__/__init__.cpython-310.pyc,,
+gevent/resolver/__pycache__/_addresses.cpython-310.pyc,,
+gevent/resolver/__pycache__/_hostsfile.cpython-310.pyc,,
+gevent/resolver/__pycache__/ares.cpython-310.pyc,,
+gevent/resolver/__pycache__/blocking.cpython-310.pyc,,
+gevent/resolver/__pycache__/dnspython.cpython-310.pyc,,
+gevent/resolver/__pycache__/thread.cpython-310.pyc,,
+gevent/resolver/_addresses.py,sha256=BvLXxwN1QTQ4Pajgk5UwvHRP6J8TDQ8n-_75AfIaOVo,4795
+gevent/resolver/_hostsfile.py,sha256=KY6q-aY5F1f3MV4SZioAcstBRvxm4647-JKlCtY47E0,4629
+gevent/resolver/ares.py,sha256=6Oed67PUah45MwMQz3KFIWNAnm7XkoRJXx9vz7voJEc,12965
+gevent/resolver/blocking.py,sha256=5ubBMewB7X-JouMKIlf_s2JNw4KJ_EqmNVUg4PrrSaA,1216
+gevent/resolver/cares.cpython-310-x86_64-linux-gnu.so,sha256=MRiOjNPMCvdmF0vwePyW9kFRz0mDbURipVbx1vXWCsM,2882264
+gevent/resolver/dnspython.py,sha256=cZ0mQyWluVz_h2YsyS_sSg0n7NEpuFPsZhp63WMyFeg,20706
+gevent/resolver/thread.py,sha256=DTSwSwBRsSJKjPjyAHS0qT07oDxmFOhR4wYLfSSaJCU,2487
+gevent/resolver_ares.py,sha256=s5Jo9Z0b-zKxSWcIvW5onaFE2OrfqLuNnTPlOoxFxEQ,486
+gevent/resolver_thread.py,sha256=jcKcEVCXwyRqcsDUZmryQ9hc-83yztgaM4kuTKHOvaw,504
+gevent/select.py,sha256=7-LNetKIlhpB3YifQ5momSLQXnt5q92g8EDJaC4qGEE,13257
+gevent/selectors.py,sha256=ffV2jG6m2etjqNIppHNCBY7JSDr4q0_zbf-tkA06gVI,11725
+gevent/server.py,sha256=7rrN3Ieujlo0vKddDyYIqgocslsW-3VNG-faOfOk7vE,10852
+gevent/signal.py,sha256=-Rx0_Ta7Zel8UWXmrrtzDWVnjUQZuGWINWhrNwHB9ic,5217
+gevent/socket.py,sha256=CUC-jiNIjbXghj_muCXyn9Ij7GUDa44kKxBb3F1-PMM,6503
+gevent/ssl.py,sha256=Q_etOyl2s9PcZRvOaf1_7joEIeo8d8u4N7XWhRxnFTs,34772
+gevent/subprocess.py,sha256=Q1mRVgRyAVigzjlLd0aXvhTb5IKk3TOhbLNcK6mVJX0,83510
+gevent/testing/__init__.py,sha256=my2P6ikG7OUO9hGXN54zZawh4LYtu825K9epAGUnoDc,5583
+gevent/testing/__pycache__/__init__.cpython-310.pyc,,
+gevent/testing/__pycache__/errorhandler.cpython-310.pyc,,
+gevent/testing/__pycache__/exception.cpython-310.pyc,,
+gevent/testing/__pycache__/flaky.cpython-310.pyc,,
+gevent/testing/__pycache__/hub.cpython-310.pyc,,
+gevent/testing/__pycache__/leakcheck.cpython-310.pyc,,
+gevent/testing/__pycache__/modules.cpython-310.pyc,,
+gevent/testing/__pycache__/monkey_test.cpython-310.pyc,,
+gevent/testing/__pycache__/openfiles.cpython-310.pyc,,
+gevent/testing/__pycache__/params.cpython-310.pyc,,
+gevent/testing/__pycache__/patched_tests_setup.cpython-310.pyc,,
+gevent/testing/__pycache__/resources.cpython-310.pyc,,
+gevent/testing/__pycache__/six.cpython-310.pyc,,
+gevent/testing/__pycache__/skipping.cpython-310.pyc,,
+gevent/testing/__pycache__/sockets.cpython-310.pyc,,
+gevent/testing/__pycache__/support.cpython-310.pyc,,
+gevent/testing/__pycache__/switching.cpython-310.pyc,,
+gevent/testing/__pycache__/sysinfo.cpython-310.pyc,,
+gevent/testing/__pycache__/testcase.cpython-310.pyc,,
+gevent/testing/__pycache__/testrunner.cpython-310.pyc,,
+gevent/testing/__pycache__/timing.cpython-310.pyc,,
+gevent/testing/__pycache__/travis.cpython-310.pyc,,
+gevent/testing/__pycache__/util.cpython-310.pyc,,
+gevent/testing/coveragesite/__pycache__/sitecustomize.cpython-310.pyc,,
+gevent/testing/coveragesite/sitecustomize.py,sha256=GSOkHhxLE_pjOHuUn4InKmmuLyIGSIumySFVVSmc4Vo,558
+gevent/testing/errorhandler.py,sha256=NzoItIrdz8t0YOFEAa6fn9WyFnubs_egnpV8yD7AcDQ,2329
+gevent/testing/exception.py,sha256=yQHF9Ebom2JAKUq70mLsdFk9p4eorpK36O-3iH1LL1Q,1265
+gevent/testing/flaky.py,sha256=x-IujIZGK_m2FYRyi4RxKMZhLfxq25p47En4DAlYhCs,4104
+gevent/testing/hub.py,sha256=Qmo7bcZPLIEOF7mncgV3vR-KrbHLUT_pORNQejrltig,3115
+gevent/testing/leakcheck.py,sha256=mHU-MoeEtHV319aTbDeMx-F0OwDWmf3rJI-sYJl9lmI,8227
+gevent/testing/modules.py,sha256=qGfvohEps4mo6_hqcRZHlEuxBx1wDNqRY_DZmJDM61o,4987
+gevent/testing/monkey_test.py,sha256=Y2WYnBEb5FQIuOnFpv42ETuvdKRbBhAtqywDDDoPowE,5730
+gevent/testing/openfiles.py,sha256=daybcm27dkOGOiloGj0GocHzPRX2q6NvW861WylWxFA,8739
+gevent/testing/params.py,sha256=B-5PoctZfrtii3rcjA68kmI0wvwg7_sHJ4pWFzRAcbw,2674
+gevent/testing/patched_tests_setup.py,sha256=ztdpf2o4DlhjaLSIMy1Ie5VJY78l843b7QpAFA_pwZ8,66439
+gevent/testing/resources.py,sha256=C3cxaDi56orLzs50vTCnGElxk-ChJBjFV3JX2f610_A,7481
+gevent/testing/six.py,sha256=4Gi0PTjZ9rKHn-DGy9WdRSxuYFmeoTonD_LL_TvyrcU,1035
+gevent/testing/skipping.py,sha256=z9S_gzsCaDeuAbw3E80gysE7CoVGrvc6a1OYXyDtTkY,6719
+gevent/testing/sockets.py,sha256=CvtRiCVxCXcv_Vv3OFQiEYEH-Mok32sY18JiATEbeI4,2285
+gevent/testing/support.py,sha256=hn2IghJcKYUcS7hcii9RdWBLy0gGOu2nRTlEEvaq06U,4631
+gevent/testing/switching.py,sha256=6idIaCiHKFZF8aibeHjxIdZi38cxXCKuhQRHUT1YWoo,2708
+gevent/testing/sysinfo.py,sha256=LP97FlKGdJXc-S1ejAkO-k8VHGX2ybIpk_Ozy_WNNIw,8211
+gevent/testing/testcase.py,sha256=-Xo56A1ZIX_PW7RMqn_YkPKauzUI5yxJXAjpd_dKjXI,18602
+gevent/testing/testrunner.py,sha256=ld43CGn3CbDjzOGW4lOlyOnubr2mWyd2ve-J8Pt58F4,36487
+gevent/testing/timing.py,sha256=Yy9dQ3KvJ9uEV6BwpgM3ZEnVYP1ic6jgVGqZF1uWLLc,4982
+gevent/testing/travis.py,sha256=yYJlIY2L4vMzSxaODPVhANFaB_svNmwhrw4CRotQXlc,877
+gevent/testing/util.py,sha256=Kky0x628NVhr9g_-yYjkeuhSQViBSRZ9YWt02WfWbG4,19302
+gevent/tests/2_7_keycert.pem,sha256=PuSO2qCmga4an7pkSs7ep1Fo16yrQKd9i84DnrqSYcI,5081
+gevent/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gevent/tests/__main__.py,sha256=EMw-OppCjl-heu15mLg-cf400NS1Ikuy96OisvLoKLM,179
+gevent/tests/__pycache__/__init__.cpython-310.pyc,,
+gevent/tests/__pycache__/__main__.cpython-310.pyc,,
+gevent/tests/__pycache__/_blocks_at_top_level.cpython-310.pyc,,
+gevent/tests/__pycache__/_import_import_patch.cpython-310.pyc,,
+gevent/tests/__pycache__/_import_patch.cpython-310.pyc,,
+gevent/tests/__pycache__/_import_wait.cpython-310.pyc,,
+gevent/tests/__pycache__/_imports_at_top_level.cpython-310.pyc,,
+gevent/tests/__pycache__/_imports_imports_at_top_level.cpython-310.pyc,,
+gevent/tests/__pycache__/getaddrinfo_module.cpython-310.pyc,,
+gevent/tests/__pycache__/known_failures.cpython-310.pyc,,
+gevent/tests/__pycache__/lock_tests.cpython-310.pyc,,
+gevent/tests/__pycache__/test__GreenletExit.cpython-310.pyc,,
+gevent/tests/__pycache__/test___config.cpython-310.pyc,,
+gevent/tests/__pycache__/test___ident.cpython-310.pyc,,
+gevent/tests/__pycache__/test___monitor.cpython-310.pyc,,
+gevent/tests/__pycache__/test___monkey_patching.cpython-310.pyc,,
+gevent/tests/__pycache__/test__all__.cpython-310.pyc,,
+gevent/tests/__pycache__/test__api.cpython-310.pyc,,
+gevent/tests/__pycache__/test__api_timeout.cpython-310.pyc,,
+gevent/tests/__pycache__/test__ares_host_result.cpython-310.pyc,,
+gevent/tests/__pycache__/test__ares_timeout.cpython-310.pyc,,
+gevent/tests/__pycache__/test__backdoor.cpython-310.pyc,,
+gevent/tests/__pycache__/test__close_backend_fd.cpython-310.pyc,,
+gevent/tests/__pycache__/test__compat.cpython-310.pyc,,
+gevent/tests/__pycache__/test__contextvars.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_async.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_callback.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_fork.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_loop_run.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_stat.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_timer.cpython-310.pyc,,
+gevent/tests/__pycache__/test__core_watcher.cpython-310.pyc,,
+gevent/tests/__pycache__/test__destroy.cpython-310.pyc,,
+gevent/tests/__pycache__/test__destroy_default_loop.cpython-310.pyc,,
+gevent/tests/__pycache__/test__doctests.cpython-310.pyc,,
+gevent/tests/__pycache__/test__environ.cpython-310.pyc,,
+gevent/tests/__pycache__/test__event.cpython-310.pyc,,
+gevent/tests/__pycache__/test__events.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_echoserver.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_portforwarder.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_udp_client.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_udp_server.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_webproxy.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_wsgiserver.cpython-310.pyc,,
+gevent/tests/__pycache__/test__example_wsgiserver_ssl.cpython-310.pyc,,
+gevent/tests/__pycache__/test__examples.cpython-310.pyc,,
+gevent/tests/__pycache__/test__exc_info.cpython-310.pyc,,
+gevent/tests/__pycache__/test__execmodules.cpython-310.pyc,,
+gevent/tests/__pycache__/test__fileobject.cpython-310.pyc,,
+gevent/tests/__pycache__/test__getaddrinfo_import.cpython-310.pyc,,
+gevent/tests/__pycache__/test__greenio.cpython-310.pyc,,
+gevent/tests/__pycache__/test__greenlet.cpython-310.pyc,,
+gevent/tests/__pycache__/test__greenletset.cpython-310.pyc,,
+gevent/tests/__pycache__/test__greenness.cpython-310.pyc,,
+gevent/tests/__pycache__/test__hub.cpython-310.pyc,,
+gevent/tests/__pycache__/test__hub_join.cpython-310.pyc,,
+gevent/tests/__pycache__/test__hub_join_timeout.cpython-310.pyc,,
+gevent/tests/__pycache__/test__import_blocking_in_greenlet.cpython-310.pyc,,
+gevent/tests/__pycache__/test__import_wait.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue112.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue1686.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue1864.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue230.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue330.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue467.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue6.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue600.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue607.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue639.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issue_728.cpython-310.pyc,,
+gevent/tests/__pycache__/test__issues461_471.cpython-310.pyc,,
+gevent/tests/__pycache__/test__iwait.cpython-310.pyc,,
+gevent/tests/__pycache__/test__joinall.cpython-310.pyc,,
+gevent/tests/__pycache__/test__local.cpython-310.pyc,,
+gevent/tests/__pycache__/test__lock.cpython-310.pyc,,
+gevent/tests/__pycache__/test__loop_callback.cpython-310.pyc,,
+gevent/tests/__pycache__/test__makefile_ref.cpython-310.pyc,,
+gevent/tests/__pycache__/test__memleak.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_builtins_future.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_hub_in_thread.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_logging.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_module_run.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_multiple_imports.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_queue.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_select.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_selectors.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_sigchld.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_sigchld_2.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_sigchld_3.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_ssl_warning.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_ssl_warning2.cpython-310.pyc,,
+gevent/tests/__pycache__/test__monkey_ssl_warning3.cpython-310.pyc,,
+gevent/tests/__pycache__/test__nondefaultloop.cpython-310.pyc,,
+gevent/tests/__pycache__/test__order.cpython-310.pyc,,
+gevent/tests/__pycache__/test__os.cpython-310.pyc,,
+gevent/tests/__pycache__/test__pool.cpython-310.pyc,,
+gevent/tests/__pycache__/test__pywsgi.cpython-310.pyc,,
+gevent/tests/__pycache__/test__queue.cpython-310.pyc,,
+gevent/tests/__pycache__/test__real_greenlet.cpython-310.pyc,,
+gevent/tests/__pycache__/test__refcount.cpython-310.pyc,,
+gevent/tests/__pycache__/test__refcount_core.cpython-310.pyc,,
+gevent/tests/__pycache__/test__resolver_dnspython.cpython-310.pyc,,
+gevent/tests/__pycache__/test__select.cpython-310.pyc,,
+gevent/tests/__pycache__/test__selectors.cpython-310.pyc,,
+gevent/tests/__pycache__/test__semaphore.cpython-310.pyc,,
+gevent/tests/__pycache__/test__server.cpython-310.pyc,,
+gevent/tests/__pycache__/test__server_pywsgi.cpython-310.pyc,,
+gevent/tests/__pycache__/test__signal.cpython-310.pyc,,
+gevent/tests/__pycache__/test__sleep0.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_close.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_dns.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_dns6.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_errors.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_ex.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_send_memoryview.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_ssl.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socket_timeout.cpython-310.pyc,,
+gevent/tests/__pycache__/test__socketpair.cpython-310.pyc,,
+gevent/tests/__pycache__/test__ssl.cpython-310.pyc,,
+gevent/tests/__pycache__/test__subprocess.cpython-310.pyc,,
+gevent/tests/__pycache__/test__subprocess_interrupted.cpython-310.pyc,,
+gevent/tests/__pycache__/test__subprocess_poll.cpython-310.pyc,,
+gevent/tests/__pycache__/test__systemerror.cpython-310.pyc,,
+gevent/tests/__pycache__/test__thread.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_2.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_before_monkey.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_fork_from_dummy.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_holding_lock_while_monkey.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_monkey_in_thread.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_native_before_monkey.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_no_monkey.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_patched_local.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threading_vs_settrace.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threadpool.cpython-310.pyc,,
+gevent/tests/__pycache__/test__threadpool_executor_patched.cpython-310.pyc,,
+gevent/tests/__pycache__/test__timeout.cpython-310.pyc,,
+gevent/tests/__pycache__/test__util.cpython-310.pyc,,
+gevent/tests/_blocks_at_top_level.py,sha256=Hp36RFiC0djMSfvUHZsu8pVttpc7Hbmv_7VGq6xW630,48
+gevent/tests/_import_import_patch.py,sha256=IbgraY7KaPggcX1JNVkUQTTBSboegF_VWSDFJp38buI,28
+gevent/tests/_import_patch.py,sha256=_PWRiLjpsFyhT2CxTDIE9ZVS9gcCFqzQGFKel00zc2s,47
+gevent/tests/_import_wait.py,sha256=8353o30STWbRg53op9CWmTXfElU6VV4klLdqiq7Jmjg,570
+gevent/tests/_imports_at_top_level.py,sha256=9SCo81uRMT8xWbDFUBhbc_EwAoii9oygwOBSSNWfWWI,55
+gevent/tests/_imports_imports_at_top_level.py,sha256=VcIaDELcdgeEMqO_Cndy0XMjx05h5eG4_F_12giOSDs,345
+gevent/tests/badcert.pem,sha256=JioQeRZkHH8hGsWJjAF3U1zQvcWqhyzG6IOEJpTY9SE,1928
+gevent/tests/badkey.pem,sha256=gaBK9px_gG7DmrLKxfD6f6i-toAmARBTVfs-YGFRQF0,2162
+gevent/tests/getaddrinfo_module.py,sha256=oFyeNRywc3QO5HlpuV5DVcpUbml8hFn86pbWm_mGQX8,116
+gevent/tests/hosts_file.txt,sha256=07jEX3FicSKuiUJbQ_14H0MP8v7r35h_usGUmScPnSM,290909
+gevent/tests/https_svn_python_org_root.pem,sha256=wOB3Onnc62Iu9kEFd8GcHhd_suucYjpJNA3jyfHeJWA,2569
+gevent/tests/keycert.pem,sha256=r0KE1WH9eV6X4mUykpCY5Dm8_robBSi4zwMcGBPtMi4,1872
+gevent/tests/known_failures.py,sha256=y7BTq9dlR-At455-Q5YCJ5pnDaXOnmo5Ms317fcbbDo,17473
+gevent/tests/lock_tests.py,sha256=Oxi0uoEPVzA1NKP6t69fuezuHCZE0xQZbHBuMQtTwUs,21858
+gevent/tests/monkey_package/__init__.py,sha256=bvY5MXWih-w0IshrJmEKnPTI25R0eC_ma0Xa2bT3XCI,329
+gevent/tests/monkey_package/__main__.py,sha256=mJx6YRmYplQEY8Lb3hQOPrbIj2Z3mwrZY3wLL7p2zcM,363
+gevent/tests/monkey_package/__pycache__/__init__.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/__main__.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/issue1526_no_monkey.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/issue1526_with_monkey.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/issue302monkey.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/script.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/threadpool_monkey_patches.cpython-310.pyc,,
+gevent/tests/monkey_package/__pycache__/threadpool_no_monkey.cpython-310.pyc,,
+gevent/tests/monkey_package/issue1526_no_monkey.py,sha256=mDdY5_Y4IDBd8b-gjYNQKh8U4jb8Nn7eSEC_DM7lSxk,573
+gevent/tests/monkey_package/issue1526_with_monkey.py,sha256=5mbVockojXOZQZwQFaPrMVcg50T_vD1WRj07F6pOj_Y,666
+gevent/tests/monkey_package/issue302monkey.py,sha256=aitTDyrxJZI4EE_n6gg0o4AfHEQsFPfzQtVVmWMr6JQ,935
+gevent/tests/monkey_package/script.py,sha256=4q695hn_S3YA2aQh4TRyjVJ7QA9xlfqNTrezlUZkjVQ,427
+gevent/tests/monkey_package/threadpool_monkey_patches.py,sha256=0Glu2IugiK6rT6fYZbgqmGgciUjUX-6eannkqekzTi4,869
+gevent/tests/monkey_package/threadpool_no_monkey.py,sha256=c-bdOwTHjhBzlmcJMFyixL3Wjp-wXO4T1VZIGC3clGE,787
+gevent/tests/nullcert.pem,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gevent/tests/server.crt,sha256=LOyJ1muRGaDZapZQ9x3BRNGIrC4jKiiIyNZJvMM5eQI,1809
+gevent/tests/server.key,sha256=CXI8bo8kvTo3I_o0kVPabuQ0oHBsoNbgFVT1bWNTwOI,3272
+gevent/tests/sha256.pem,sha256=trYsA7FY0hyVoV1AoGNwZ_s6T89eiiOIFexoNRv029s,2065
+gevent/tests/test__GreenletExit.py,sha256=qHtC7KnjCG039F_VGDXnsrhyWaQXvfcmgnVB2Rfa_Vk,127
+gevent/tests/test___config.py,sha256=mCJfAOG9DEAU5RtUg_UgHwsB6f0x-KWTjHX9aTaS7d8,4889
+gevent/tests/test___ident.py,sha256=15ucVXe5y4hE9F--Y8fhxN9-WcGhXt2ehHMLTzDuDKs,2109
+gevent/tests/test___monitor.py,sha256=-hp7xNRmS3dnqgdfea9228hOUQ_IuG26WXTk2gsVZgE,12624
+gevent/tests/test___monkey_patching.py,sha256=2W6ZF3gTCSh9SgUjJUuX2OP1ZZCq9Vjsv20UPqgrXnY,3502
+gevent/tests/test__all__.py,sha256=j_TqCJ3_iILFT3tDlH0RBGjYv70dqzncJ536ove_ZOs,11547
+gevent/tests/test__api.py,sha256=zJF6cfQKnPscZio9ErpkY2Mn2NNPOzNnzX4J8ujx4ww,4550
+gevent/tests/test__api_timeout.py,sha256=is-HOBSQiMKPc67r41FqamL3KOF5BnfmtV8kW01JId4,6323
+gevent/tests/test__ares_host_result.py,sha256=f-ZJubI1wyzJExMifQnRFNpNcxkZ0Ykyp2W75jLjrqY,908
+gevent/tests/test__ares_timeout.py,sha256=65MC4NdPYJzbLO90FRjwtPuz3E_Y0JJm2Ld5aDcYLcU,1015
+gevent/tests/test__backdoor.py,sha256=y6xN2JGBlo4EziEWp5C4Xh550RMe60EHyrgGm73VE4I,5580
+gevent/tests/test__close_backend_fd.py,sha256=6yssqISBW-rhKZx25iCDbE6gaLYAEBCTzPlchwzsB7Y,3865
+gevent/tests/test__compat.py,sha256=YBE4IJwtRozcCRqeZXY9dkxqjZ6m2xS0Pk1ceApjvnE,1439
+gevent/tests/test__contextvars.py,sha256=JUPQ3TzpSLTQkdRNr7g2OgEzmFIK5vd8ml2bF7BNTYc,31717
+gevent/tests/test__core.py,sha256=VDxOazcjEyhp4o094xQcKSupm-Qf0aDNN0o3Ja_UF7s,5618
+gevent/tests/test__core_async.py,sha256=X4CNU4Kroea9fyjlfd_l8HmMLKfvec-eE4qzqTPZNow,761
+gevent/tests/test__core_callback.py,sha256=occ-buOrq8DrbJ0GUzHeMVF-Qcuu5e4qnUPnrmqvq80,618
+gevent/tests/test__core_fork.py,sha256=i4WdiNIL_LWINMg38rnNakfCfVZiMkFgVo9wUsiXxH4,2738
+gevent/tests/test__core_loop_run.py,sha256=N6ZHGuVfrclHoKrL1R8T7BeObT9P28Ey2wfvyo_jGJs,494
+gevent/tests/test__core_stat.py,sha256=YvqLSe-9j5tIFC6MoPQhD5_0MdBtxrbVagp4o0jzpw8,3754
+gevent/tests/test__core_timer.py,sha256=e6VG-IHLiQ3OkrTOYGiLMX4VdU6RLG3UoA69uao2xG8,4330
+gevent/tests/test__core_watcher.py,sha256=ULftUAJqrMLYgzItmSzEosgeagKbI72m0oheKn14vYo,3573
+gevent/tests/test__destroy.py,sha256=fy9Gh1WH6URkLCTjVv2RzxljX6DDRZXmaCuUEHVCYf8,1765
+gevent/tests/test__destroy_default_loop.py,sha256=9KsDb5i7Nn4uFrNrfT_vMYLOG7VV6-hp46HGlFg06nc,2199
+gevent/tests/test__doctests.py,sha256=aZqNLQDOpyvFYkhmqgXyDRhtV3CnN50H4OnZkp0vC0E,3613
+gevent/tests/test__environ.py,sha256=i7sqbSsRVyM5ypN9obyVIMWKyATOs5FC3BrMNf_i5Sk,608
+gevent/tests/test__event.py,sha256=UVT1jc5lgWoTJnWSEThOhrV3kaXCk7oA6ai8d-JiYYQ,14176
+gevent/tests/test__events.py,sha256=wa8mZSnMCsZ_qX2ak0Lwy3RE0MqXfdaSevLv0PEzXFM,1465
+gevent/tests/test__example_echoserver.py,sha256=oHLko-fDrrhS-3YrSr86B599W1ww1-MlTomarszLuZM,1198
+gevent/tests/test__example_portforwarder.py,sha256=hIVFPP8CBapzR918PBlrZM_Zibt8OyzDdKD9V1vfgbw,2025
+gevent/tests/test__example_udp_client.py,sha256=VGDHP_cYMlxnDkqW1E1fs-WteLH_6O7euW3SYvA1Mvk,884
+gevent/tests/test__example_udp_server.py,sha256=ApnWzkhqlHXmELMwgviFr8jf2QU4obHYefWCq1t2zlY,513
+gevent/tests/test__example_webproxy.py,sha256=Tg4dVbS725yOQVoslPz3FpA6SFAoYKIPAhddwUvEvEs,807
+gevent/tests/test__example_wsgiserver.py,sha256=bavlc9OfdFdkyibxxGhBuhEFXOYcfyc_Jqg0P8gfQEo,3202
+gevent/tests/test__example_wsgiserver_ssl.py,sha256=Ztn83XeMTLENcZduhdE2hiGYitSvi0hEQLJaD1tLpdA,649
+gevent/tests/test__examples.py,sha256=F2tAzDtGDYz3mo9Y5u0UfgnXGUTSz6TbtxK_LzEJyFQ,3336
+gevent/tests/test__exc_info.py,sha256=qp4J_TJrPk3JakATBvyOBO_7UbEhpoXmqVShNRK3yvY,1377
+gevent/tests/test__execmodules.py,sha256=oUgXwnV9wD3PZSJD6RVzWj9DxDpnmzPE5pm0z8YgG_4,1628
+gevent/tests/test__fileobject.py,sha256=38RddEZk-TdK0adkLpZmrKQUkJwXifAFrcT2fvkViAI,18345
+gevent/tests/test__getaddrinfo_import.py,sha256=eGmX5zaq-x9Or3UGtIZL8yqNN97yVBQx9zlehM3ogE4,463
+gevent/tests/test__greenio.py,sha256=vYzw_tSAAZxD0TjbKt_9wy_2KM3727YjUEdmcJ6GNvc,5523
+gevent/tests/test__greenlet.py,sha256=_bm2-nbngzCtR1mjC7LuugvWX-BhHANrnwUpeEOaYDw,32010
+gevent/tests/test__greenletset.py,sha256=NaIikUvwC7FcHjZQ24P3blp3iW4VaLImJfqH_E6mVuo,5032
+gevent/tests/test__greenness.py,sha256=YztEj8cMW3XkbTtoRJPv8K5yKugRwhlWy6szMKRwk2o,2790
+gevent/tests/test__hub.py,sha256=kT1T7tzDAZ1zmU3EsYGhGBqyYRv7acMVgTA3_BE1Ok0,13728
+gevent/tests/test__hub_join.py,sha256=-V1LjhFtZOAvCTWJsqxsLKFGicoDbp3NpojlS1EOZKc,3217
+gevent/tests/test__hub_join_timeout.py,sha256=E6Ul1xhZ1Ro7_IMx9QZBpf1zzWl1yrYWS11K25JyLho,2913
+gevent/tests/test__import_blocking_in_greenlet.py,sha256=BEEB6WrcXqFscxQxEIdMzlLVQ-KFvDlQ52yNlQWxIKs,1134
+gevent/tests/test__import_wait.py,sha256=-m2mg2urO-nNDTj3Ov0QNXuDmgr7rOCa7MKD-LT5cyA,252
+gevent/tests/test__issue112.py,sha256=OxamNgJF1QlKuirw_jJNYzpE84PgjYP2z1x27n61JQc,338
+gevent/tests/test__issue1686.py,sha256=5CIooK1MteQPtSWaWPpvyzMil_OLcvIYeHjIcZHlpxE,2878
+gevent/tests/test__issue1864.py,sha256=Xb3CcArxYDox-lCDpHOpwTkE5XXM3jK5zqUk3zyKGzk,1291
+gevent/tests/test__issue230.py,sha256=3zEzP5fLwLaHUeX0xNntV29AhhtHr_9t0cG1SPSa24c,500
+gevent/tests/test__issue330.py,sha256=qDbqSKfvZ4IdR_r7PwDAuCfTQuZEjLELSK1IvTowoaI,2333
+gevent/tests/test__issue467.py,sha256=PrqSlERQf8XttyiNB5NRZqEo8D0cmNTiO8qIdamRgPg,1205
+gevent/tests/test__issue6.py,sha256=OOBbWEwmA4zKxpF8jZ_5fm4E7uHKbqxP63FiE0ktU9w,1530
+gevent/tests/test__issue600.py,sha256=dKW-RzdzaJhVl8dClpBzLzgRjMn7BlqeTIiIB97R9cw,1386
+gevent/tests/test__issue607.py,sha256=-lQuJxVfIPDhrrf1G-2BpIbQqwDMygDeuRMh7vANGPM,1354
+gevent/tests/test__issue639.py,sha256=ExWDeXqUDqGTXF1rx6t1SQjac4GWKqZ2opusTpxgi1g,214
+gevent/tests/test__issue_728.py,sha256=1u6WSToRxMYe70aLU5vMhrWSZ_OHtwN9oP6L4UXXywg,212
+gevent/tests/test__issues461_471.py,sha256=_Xwj-ImGgYuTcWGxITACba3FGnRHmlXZxTDkkChriVg,3889
+gevent/tests/test__iwait.py,sha256=uzef1gKSo8dDbciyjZobklIXNDdc-B0ehEKb3iIn2Bg,1205
+gevent/tests/test__joinall.py,sha256=UAV56-NMPLhs8TBYJ-qcNAC8gT_ZoUAcOq22_qYEQZM,296
+gevent/tests/test__local.py,sha256=1iThKxhRmbTG5aH91kVNOEdU84CnsT3YMqjX3zY5WXU,11741
+gevent/tests/test__lock.py,sha256=9QBouc6_S4xVwbxraJNpTPN12S7R9c4yj_4mwF28KuA,1100
+gevent/tests/test__loop_callback.py,sha256=SUKmuaQh4sSC1fTyGv3zaTG1NkJN7T4EaJt-ezd_wT4,356
+gevent/tests/test__makefile_ref.py,sha256=OVdy8i-zQDzL_wnF9_M_WL_3cT1S_k-VAAKQQ8Rh-MA,19150
+gevent/tests/test__memleak.py,sha256=Yq3tfWmbpgI5hYopozWEHSbP8Xs4lDqBBQ76in2mFxc,1466
+gevent/tests/test__monkey.py,sha256=DNAhYP27e9l3t_wFATd99SHlPKhbSzzYPF6mKh3WGdM,6722
+gevent/tests/test__monkey_builtins_future.py,sha256=ZUJj7wWz9jEa9vDPSdEPrjqewiUwBspmtgh7RN8LymA,521
+gevent/tests/test__monkey_hub_in_thread.py,sha256=iMWv4a8Agy_llZypYxXo62kSB7LLTdNG5u9N_eHKIg8,520
+gevent/tests/test__monkey_logging.py,sha256=ZBbUvAqOam0Twekv_Mint1dWiWBt_ce9Y7L3JRCrqGU,1564
+gevent/tests/test__monkey_module_run.py,sha256=G-bHCowrKt4dDUgotEeB5rX8yVlDrfppIRGKYJIOdA8,4368
+gevent/tests/test__monkey_multiple_imports.py,sha256=QwmJJ4r3RXOQhti_5vj3Let0zllXzq4GwDY8NqzJUuQ,296
+gevent/tests/test__monkey_queue.py,sha256=d9m4mfBPMFa5bhuyNOOEMHEoBLc7bvlCz7Q3jbODULk,12337
+gevent/tests/test__monkey_select.py,sha256=U77pqLIX-2wCtdY7CxigfT0wgSTBqHs3e53eajJV45A,741
+gevent/tests/test__monkey_selectors.py,sha256=gootPuj6Hp_ZuT_ChQmjkR75TY9xNmTXNq0nTbRxEMU,2580
+gevent/tests/test__monkey_sigchld.py,sha256=U4L8AciJ-1-ivwMZlfIMkgpmoWFVxxlZri0bsJ_1vvo,2939
+gevent/tests/test__monkey_sigchld_2.py,sha256=zV1WsDX8dTQiW6XBOs0GQejZsq2obE2LA9Dil1eo_9Y,1774
+gevent/tests/test__monkey_sigchld_3.py,sha256=dlaDG9t4kPRfhT6anZRRCkltvQSKWNeKPOBd7doAgGo,1755
+gevent/tests/test__monkey_ssl_warning.py,sha256=vvfhrq-1zurv3ERAaeiIotk1LARVAGeUy4UDdrde7Zk,1250
+gevent/tests/test__monkey_ssl_warning2.py,sha256=NRlZ8-s-doOC6xNkQbaiVPIaqOtFBfEmQzyrKsUukww,1255
+gevent/tests/test__monkey_ssl_warning3.py,sha256=WZEOHQoewYAuYJu0f8UMjpmRzaR0B-sf0wBhvaRKTEQ,1330
+gevent/tests/test__nondefaultloop.py,sha256=Y3IrgT8SF3SmO3A1IlvC0nF4GCqxzvKES0KqvO72crE,204
+gevent/tests/test__order.py,sha256=iI8wh316sNia20IkHx7wSnE_LKdCsse6Q89xVkQev1U,1125
+gevent/tests/test__os.py,sha256=FywENBJyzocpTd2dK_3VfqVWFBK2lPNhPm-8qkMZDog,5963
+gevent/tests/test__pool.py,sha256=oOf38RQcEVd8AQQuynwebNWLnQ2CRoXHV9hJWskmhrc,18351
+gevent/tests/test__pywsgi.py,sha256=qOp0J-IbtKy9EXZBXBG-EBE6j2a6Zp8E8Av11j_wSTQ,73786
+gevent/tests/test__queue.py,sha256=GZTa2XcuseEqJKNOa04Clk4ipPGPCgsARGo09nDjwxk,13107
+gevent/tests/test__real_greenlet.py,sha256=SoZQ8cY1wQFJnVmTFxuYvXo08KVyb99ZUqGDBUbo1C4,693
+gevent/tests/test__refcount.py,sha256=rqdMK4QiCLWTIblXbxvGJ2AWQimV91KDFmawHV-X5ik,5866
+gevent/tests/test__refcount_core.py,sha256=XiTmU2kYH-JkVINch2jpA1vGVKOc6ufdPW28DMNpo9c,600
+gevent/tests/test__resolver_dnspython.py,sha256=aA7rtaB273IaTG9whMwvtGwG8c42xTPtb4iH9gTR4DE,1117
+gevent/tests/test__select.py,sha256=q7wFNosgYq2T6BBekZ-DKZifNQVnbzXr-nfv4eewpVM,4069
+gevent/tests/test__selectors.py,sha256=SB2A581GN0ZDl_qk5LdQIeGI2q6Kbiwv7NGas238M6c,3789
+gevent/tests/test__semaphore.py,sha256=m-CHrKE_S5yyKd6O78b6j8AvmTFpgTVJtGT-b91nDvA,13756
+gevent/tests/test__server.py,sha256=VmpoHCkPW6baDlfzhfg9Jg8LIKefsOkXaP0KEUYKtU4,19882
+gevent/tests/test__server_pywsgi.py,sha256=0Fquqy69Xylu3UXATvd__Y9wTBXnohP9fdvEoUhGysI,3074
+gevent/tests/test__signal.py,sha256=3vN7T6bNTQchXHs6THkRm9QNROisO_40lGk1jgiO41I,3813
+gevent/tests/test__sleep0.py,sha256=uoruOPjsaPk1m0thN_4UppH4kW4k9fHQXDuLXnc3u5k,139
+gevent/tests/test__socket.py,sha256=GbN3AZC6eup3G8w_bpnBf7jcAWL2oCTYG9Zzd-KC8FU,23490
+gevent/tests/test__socket_close.py,sha256=_lidh6C8SSup3avpXKUdv0Kkok1GiLbaC_5Dn6hkiRQ,1862
+gevent/tests/test__socket_dns.py,sha256=n_KUI-C2x15cfoj_3N7XlOevQAsMI721zdWm4ToyZJo,36681
+gevent/tests/test__socket_dns6.py,sha256=zCqRfupQLxCNNQFaHVat5pzO_UMWiBORnmxWeax_K9U,3716
+gevent/tests/test__socket_errors.py,sha256=L6ZZymYkkYGq6V_S7lzdC2D1J-0jQkKF9_xytAldQN8,1869
+gevent/tests/test__socket_ex.py,sha256=RYT56ubUxD-e13wL1rG5NS9afx0gaqYfKcqzL0uS0T0,1110
+gevent/tests/test__socket_send_memoryview.py,sha256=xhNyL7y_TriGrMbJvKmbwEReUBMR_M6LKL0l0IarBbE,960
+gevent/tests/test__socket_ssl.py,sha256=X7iDcOwBbtX7e0B_JBXoSFI_dRzpQzVMGYpMQTswtf4,865
+gevent/tests/test__socket_timeout.py,sha256=_TqCsWOPrKNMJ8OFvKGjLIbiToDm7X1Y1wJxR39rJME,1351
+gevent/tests/test__socketpair.py,sha256=VKi94yATBBTzKsN7S7D1rpx-GropJf0qXRpw9GT43c0,951
+gevent/tests/test__ssl.py,sha256=mTvZ6r9hJxh_9siwPgQDwaG7c4WTjDDIPr4JsfY7JpA,5597
+gevent/tests/test__subprocess.py,sha256=7hByz0Yh4_BG93BwDhnGyZPvMnPlW11RLSmp6Hy3daQ,20208
+gevent/tests/test__subprocess_interrupted.py,sha256=qNr4GCwg-xhLrZLGHnprQILnj0g08-GozvYClSR_uE0,1922
+gevent/tests/test__subprocess_poll.py,sha256=AFlQJZcNCfDKP5zwefoGmSFvPe_1cT5HpUu_VDbp4Lk,346
+gevent/tests/test__systemerror.py,sha256=lgUg-grJQ6VTNXjOTkQQGds6m7PmtoPgddG-tYURYsU,3295
+gevent/tests/test__thread.py,sha256=xhyh6Z_HQzh2kqSjdoPoEdUURzj8A2B2l1dbXpuv1yc,780
+gevent/tests/test__threading.py,sha256=R6eAMnNIMQE757HL6JdwKaCFQq21HD4uPCen5iRCghc,2586
+gevent/tests/test__threading_2.py,sha256=Z23N_WRNT6h2wDGuK-qQY6UWi7NKxB5Vy6dW8og-4EM,23535
+gevent/tests/test__threading_before_monkey.py,sha256=DhdEFVUY6LTb-74I3KgiFExW-aFvSn_B8jTvMS_NjWo,714
+gevent/tests/test__threading_fork_from_dummy.py,sha256=Ds0y3KgYqLzQnjUuAeu2WmpBtabpMF9qA4n6weoirwQ,2181
+gevent/tests/test__threading_holding_lock_while_monkey.py,sha256=5IWkIjTs1eRlphtDF0cCINz16M6tUi9hZMB-R_eVMIw,411
+gevent/tests/test__threading_monkey_in_thread.py,sha256=rnxzlmcUahqg4pWEIdh-5bmIMdGn5ed-V7hjt-WxXDo,2366
+gevent/tests/test__threading_native_before_monkey.py,sha256=KvQaAWQe78cGVYT-T2MAh6T4s7YUZdza8-vqxS4YJp0,2157
+gevent/tests/test__threading_no_monkey.py,sha256=FkY93eRfkpZjsbEzLbJLvtI9-POMbAGYd3IpJE8peHw,806
+gevent/tests/test__threading_patched_local.py,sha256=0EaAtlORHJjfxkUZzGKL1lOh-OY9hZa1R6MoUE0eSHo,675
+gevent/tests/test__threading_vs_settrace.py,sha256=vsRpAqYimfePGGqyTj-8M-SpGmwVN01JQ6yROkKBjl8,5023
+gevent/tests/test__threadpool.py,sha256=FhfeW0JZ5U_e84B8Q3JIb6KBxXKFkGSD6RsYVNHMMoM,24825
+gevent/tests/test__threadpool_executor_patched.py,sha256=KihwMAZ_hQfZBhnxv_CCx8HJnvdQaKxxaMuuJkV9IiM,386
+gevent/tests/test__timeout.py,sha256=uRjOchrp6NVrjkxrCW9UMd6r5iheRe8EjzpW5XDD7Bg,5243
+gevent/tests/test__util.py,sha256=8T3EPIPWlOQtAylapMTLjz32ZQyCudhRlchXx-EGSGQ,10705
+gevent/tests/test_server.crt,sha256=QIKfCQ-jpwWvzwJLO-eOSqT2TTSEVE-HLcC1wzs-YNw,1809
+gevent/tests/test_server.key,sha256=5yU4QY75gVWwTt4TE5EKkiOhENEwO0eP9oG3WTB0dtk,3268
+gevent/tests/tests_that_dont_do_leakchecks.txt,sha256=dzRXEFB_7uZlFI5ANA1VCfYCd9HTINqDTi1BcIkzxOY,223
+gevent/tests/tests_that_dont_monkeypatch.txt,sha256=PH8kQY8hpSlwzXJkJQpTsczkNZ13uUxkWM-Hl4Cz-wQ,647
+gevent/tests/tests_that_dont_use_resolver.txt,sha256=nhsAcj2CwFEsEtmfROY3NFiIe7Xqpb3AK1I-nQK6f2A,3184
+gevent/tests/wrongcert.pem,sha256=6n4u7wcalNKCtnMsq7J3Y7uOiez901ZLiH38oE0jGUM,1880
+gevent/thread.py,sha256=H6weO4bwie9U0DciiDjC1rDLMvkGgSKDO1xDT2pXaKE,10586
+gevent/threading.py,sha256=yIo2tlqfrlgutwKM9Bw1uIsbYQquMdGICBnXbsZHE6Q,16808
+gevent/threadpool.py,sha256=iQ90WLeFsm1XUM_cI_WehtKGLh9BJ-r-fgubPvsyTEo,30975
+gevent/time.py,sha256=C0eRlHq0rBxy9tC_SsIywkYaBNlwO1bc04qFi2OceB4,491
+gevent/timeout.py,sha256=TWuPBaYcXZMzX4vUEKtGVBCsLj3QClL6TWTCZq5Zcng,13678
+gevent/util.py,sha256=lZoYCZDZdkBQYd8wSCbbwdkVW0VTVx_cikkX1lxMDmg,22571
+gevent/win32util.py,sha256=WBk_YNf_kk3QF3PMUdScqgM_PreF4OBhfXq2W5264n0,3637

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gevent.plugins.monkey.will_patch_all]
+signal_os_incompat = gevent.monkey:_subscribe_signal_os

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent-24.11.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+gevent

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/_ffi/__init__.py

@@ -0,0 +1,27 @@
+"""
+Internal helpers for FFI implementations.
+"""
+from __future__ import print_function, absolute_import
+
+import os
+import sys
+
+def _dbg(*args, **kwargs):
+    # pylint:disable=unused-argument
+    pass
+
+#_dbg = print
+
+def _pid_dbg(*args, **kwargs):
+    kwargs['file'] = sys.stderr
+    print(os.getpid(), *args, **kwargs)
+
+CRITICAL = 1
+ERROR = 3
+DEBUG = 5
+TRACE = 9
+
+GEVENT_DEBUG_LEVEL = vars()[os.getenv("GEVENT_DEBUG", 'CRITICAL').upper()]
+
+if GEVENT_DEBUG_LEVEL >= TRACE:
+    _dbg = _pid_dbg

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/_ffi/callback.py

@@ -0,0 +1,57 @@
+from __future__ import absolute_import
+from __future__ import print_function
+
+from zope.interface import implementer
+
+from gevent._interfaces import ICallback
+
+__all__ = [
+    'callback',
+]
+
+
+@implementer(ICallback)
+class callback(object):
+
+    __slots__ = ('callback', 'args')
+
+    def __init__(self, cb, args):
+        self.callback = cb
+        self.args = args
+
+    def stop(self):
+        self.callback = None
+        self.args = None
+
+    close = stop
+
+    # Note that __nonzero__ and pending are different
+    # bool() is used in contexts where we need to know whether to schedule another callback,
+    # so it's true if it's pending or currently running
+    # 'pending' has the same meaning as libev watchers: it is cleared before actually
+    # running the callback
+
+    def __bool__(self):
+        # it's nonzero if it's pending or currently executing
+        # NOTE: This depends on loop._run_callbacks setting the args property
+        # to None.
+        return self.args is not None
+
+    @property
+    def pending(self):
+        return self.callback is not None
+
+    def _format(self):
+        return ''
+
+    def __repr__(self):
+        result = "<%s at 0x%x" % (self.__class__.__name__, id(self))
+        if self.pending:
+            result += " pending"
+        if self.callback is not None:
+            result += " callback=%r" % (self.callback, )
+        if self.args is not None:
+            result += " args=%r" % (self.args, )
+        if self.callback is None and self.args is None:
+            result += " stopped"
+        return result + ">"

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/_ffi/loop.py

@@ -0,0 +1,789 @@
+"""
+Basic loop implementation for ffi-based cores.
+"""
+# pylint: disable=too-many-lines, protected-access, redefined-outer-name, not-callable
+from __future__ import absolute_import, print_function
+
+from collections import deque
+import sys
+import os
+import traceback
+
+from gevent._ffi import _dbg
+from gevent._ffi import GEVENT_DEBUG_LEVEL
+from gevent._ffi import TRACE
+from gevent._ffi.callback import callback
+from gevent._compat import PYPY
+from gevent.exceptions import HubDestroyed
+
+from gevent import getswitchinterval
+
+__all__ = [
+    'AbstractLoop',
+    'assign_standard_callbacks',
+]
+
+
+class _EVENTSType(object):
+    def __repr__(self):
+        return 'gevent.core.EVENTS'
+
+EVENTS = GEVENT_CORE_EVENTS = _EVENTSType()
+
+
+class _DiscardedSet(frozenset):
+    __slots__ = ()
+
+    def discard(self, o):
+        "Does nothing."
+
+#####
+## Note on CFFI objects, callbacks and the lifecycle of watcher objects
+#
+# Each subclass of `watcher` allocates a C structure of the
+# appropriate type e.g., struct gevent_ev_io and holds this pointer in
+# its `_gwatcher` attribute. When that watcher instance is garbage
+# collected, then the C structure is also freed. The C structure is
+# passed to libev from the watcher's start() method and then to the
+# appropriate C callback function, e.g., _gevent_ev_io_callback, which
+# passes it back to python's _python_callback where we need the
+# watcher instance. Therefore, as long as that callback is active (the
+# watcher is started), the watcher instance must not be allowed to get
+# GC'd---any access at the C level or even the FFI level to the freed
+# memory could crash the process.
+#
+# However, the typical idiom calls for writing something like this:
+#  loop.io(fd, python_cb).start()
+# thus forgetting the newly created watcher subclass and allowing it to be immediately
+# GC'd. To combat this, when the watcher is started, it places itself into the loop's
+# `_keepaliveset`, and it only removes itself when the watcher's `stop()` method is called.
+# Often, this is the *only* reference keeping the watcher object, and hence its C structure,
+# alive.
+#
+# This is slightly complicated by the fact that the python-level
+# callback, called from the C callback, could choose to manually stop
+# the watcher. When we return to the C level callback, we now have an
+# invalid pointer, and attempting to pass it back to Python (e.g., to
+# handle an error) could crash. Hence, _python_callback,
+# _gevent_io_callback, and _python_handle_error cooperate to make sure
+# that the watcher instance stays in the loops `_keepaliveset` while
+# the C code could be running---and if it gets removed, to not call back
+# to Python again.
+# See also https://github.com/gevent/gevent/issues/676
+####
+class AbstractCallbacks(object):
+
+
+    def __init__(self, ffi):
+        self.ffi = ffi
+        self.callbacks = []
+        if GEVENT_DEBUG_LEVEL < TRACE:
+            self.from_handle = ffi.from_handle
+
+    def from_handle(self, handle): # pylint:disable=method-hidden
+        x = self.ffi.from_handle(handle)
+        return x
+
+    def python_callback(self, handle, revents):
+        """
+        Returns an integer having one of three values:
+
+        - -1
+          An exception occurred during the callback and you must call
+          :func:`_python_handle_error` to deal with it. The Python watcher
+          object will have the exception tuple saved in ``_exc_info``.
+        - 1
+          Everything went according to plan. You should check to see if the native
+          watcher is still active, and call :func:`python_stop` if it is not. This will
+          clean up the memory. Finding the watcher still active at the event loop level,
+          but not having stopped itself at the gevent level is a buggy scenario and
+          shouldn't happen.
+        - 2
+          Everything went according to plan, but the watcher has already
+          been stopped. Its memory may no longer be valid.
+
+        This function should never return 0, as that's the default value that
+        Python exceptions will produce.
+        """
+        #_dbg("Running callback", handle)
+        orig_ffi_watcher = None
+        orig_loop = None
+        try:
+            # Even dereferencing the handle needs to be inside the try/except;
+            # if we don't return normally (e.g., a signal) then we wind up going
+            # to the 'onerror' handler (unhandled_onerror), which
+            # is not what we want; that can permanently wedge the loop depending
+            # on which callback was executing.
+            # XXX: See comments in that function. We may be able to restart and do better?
+            if not handle:
+                # Hmm, a NULL handle. That's not supposed to happen.
+                # We can easily get into a loop if we deref it and allow that
+                # to raise.
+                _dbg("python_callback got null handle")
+                return 1
+            the_watcher = self.from_handle(handle)
+            orig_ffi_watcher = the_watcher._watcher
+            orig_loop = the_watcher.loop
+            args = the_watcher.args
+            if args is None:
+                # Legacy behaviour from corecext: convert None into ()
+                # See test__core_watcher.py
+                args = _NOARGS
+            if args and args[0] == GEVENT_CORE_EVENTS:
+                args = (revents, ) + args[1:]
+            the_watcher.callback(*args) # None here means we weren't started
+        except: # pylint:disable=bare-except
+            # It's possible for ``the_watcher`` to be undefined (UnboundLocalError)
+            # if we threw an exception (signal) on the line that created that variable.
+            # This is typically the case with a signal under libuv
+            try:
+                the_watcher
+            except UnboundLocalError:
+                the_watcher = self.from_handle(handle)
+
+            # It may not be safe to do anything with `handle` or `orig_ffi_watcher`
+            # anymore. If the watcher closed or stopped itself *before* throwing the exception,
+            # then the `handle` and `orig_ffi_watcher` may no longer be valid. Attempting to
+            # e.g., dereference the handle is likely to crash the process.
+            the_watcher._exc_info = sys.exc_info()
+
+
+            # If it hasn't been stopped, we need to make sure its
+            # memory stays valid so we can stop it at the native level if needed.
+            # If its loop is gone, it has already been stopped,
+            # see https://github.com/gevent/gevent/issues/1295 for a case where
+            # that happened, as well as issue #1482
+            if (
+                    # The last thing it does. Full successful close.
+                    the_watcher.loop is None
+                    # Only a partial close. We could leak memory and even crash later.
+                    or the_watcher._handle is None
+            ):
+                # Prevent unhandled_onerror from using the invalid handle
+                handle = None
+                exc_info = the_watcher._exc_info
+                del the_watcher._exc_info
+                try:
+                    if orig_loop is not None:
+                        orig_loop.handle_error(the_watcher, *exc_info)
+                    else:
+                        self.unhandled_onerror(*exc_info)
+                except:
+                    print("WARNING: gevent: Error when handling error",
+                          file=sys.stderr)
+                    traceback.print_exc()
+                # Signal that we're closed, no need to do more.
+                return 2
+
+            # Keep it around so we can close it later.
+            the_watcher.loop._keepaliveset.add(the_watcher)
+            return -1
+
+        if (the_watcher.loop is not None
+                and the_watcher in the_watcher.loop._keepaliveset
+                and the_watcher._watcher is orig_ffi_watcher):
+            # It didn't stop itself, *and* it didn't stop itself, reset
+            # its watcher, and start itself again. libuv's io watchers
+            # multiplex and may do this.
+
+            # The normal, expected scenario when we find the watcher still
+            # in the keepaliveset is that it is still active at the event loop
+            # level, so we don't expect that python_stop gets called.
+            #_dbg("The watcher has not stopped itself, possibly still active", the_watcher)
+            return 1
+        return 2 # it stopped itself
+
+    def python_handle_error(self, handle, _revents):
+        _dbg("Handling error for handle", handle)
+        if not handle:
+            return
+        try:
+            watcher = self.from_handle(handle)
+            exc_info = watcher._exc_info
+            del watcher._exc_info
+            # In the past, we passed the ``watcher`` itself as the context,
+            # which typically meant that the Hub would just print
+            # the exception. This is a problem because sometimes we can't
+            # detect signals until late in ``python_callback``; specifically,
+            # test_selectors.py:DefaultSelectorTest.test_select_interrupt_exc
+            # installs a SIGALRM handler that raises an exception. That exception can happen
+            # before we enter ``python_callback`` or at any point within it because of the way
+            # libuv swallows signals. By passing None, we get the exception prapagated into
+            # the main greenlet (which is probably *also* not what we always want, but
+            # I see no way to distinguish the cases).
+            watcher.loop.handle_error(None, *exc_info)
+        finally:
+            # XXX Since we're here on an error condition, and we
+            # made sure that the watcher object was put in loop._keepaliveset,
+            # what about not stopping the watcher? Looks like a possible
+            # memory leak?
+            # XXX: This used to do "if revents & (libev.EV_READ | libev.EV_WRITE)"
+            # before stopping. Why?
+            try:
+                watcher.stop()
+            except: # pylint:disable=bare-except
+                watcher.loop.handle_error(watcher, *sys.exc_info())
+            return # pylint:disable=lost-exception,return-in-finally
+
+    def unhandled_onerror(self, t, v, tb):
+        # This is supposed to be called for signals, etc.
+        # This is the onerror= value for CFFI.
+        # If we return None, C will get a value of 0/NULL;
+        # if we raise, CFFI will print the exception and then
+        # return 0/NULL; (unless error= was configured)
+        # If things go as planned, we return the value that asks
+        # C to call back and check on if the watcher needs to be closed or
+        # not.
+
+        # XXX: TODO: Could this cause events to be lost? Maybe we need to return
+        # a value that causes the C loop to try the callback again?
+        # at least for signals under libuv, which are delivered at very odd times.
+        # Hopefully the event still shows up when we poll the next time.
+        watcher = None
+        handle = tb.tb_frame.f_locals.get('handle') if tb is not None else None
+        if handle: # handle could be NULL
+            watcher = self.from_handle(handle)
+        if watcher is not None:
+            watcher.loop.handle_error(None, t, v, tb)
+            return 1
+
+        # Raising it causes a lot of noise from CFFI
+        print("WARNING: gevent: Unhandled error with no watcher",
+              file=sys.stderr)
+        traceback.print_exception(t, v, tb)
+
+    def python_stop(self, handle):
+        if not handle: # pragma: no cover
+            print(
+                "WARNING: gevent: Unable to dereference handle; not stopping watcher. "
+                "Native resources may leak. This is most likely a bug in gevent.",
+                file=sys.stderr)
+            # The alternative is to crash with no helpful information
+            # NOTE: Raising exceptions here does nothing, they're swallowed by CFFI.
+            # Since the C level passed in a null pointer, even dereferencing the handle
+            # will just produce some exceptions.
+            return
+        watcher = self.from_handle(handle)
+        watcher.stop()
+
+    if not PYPY:
+        def python_check_callback(self, watcher_ptr): # pylint:disable=unused-argument
+            # If we have the onerror callback, this is a no-op; all the real
+            # work to rethrow the exception is done by the onerror callback
+
+            # NOTE: Unlike the rest of the functions, this is called with a pointer
+            # to the C level structure, *not* a pointer to the void* that represents a
+            # <cdata> for the Python Watcher object.
+            pass
+    else: # PyPy
+        # On PyPy, we need the function to have some sort of body, otherwise
+        # the signal exceptions don't always get caught, *especially* with
+        # libuv (however, there's no reason to expect this to only be a libuv
+        # issue; it's just that we don't depend on the periodic signal timer
+        # under libev, so the issue is much more pronounced under libuv)
+        # test_socket's test_sendall_interrupted can hang.
+        # See https://github.com/gevent/gevent/issues/1112
+
+        def python_check_callback(self, watcher_ptr): # pylint:disable=unused-argument
+            # Things we've tried that *don't* work:
+            # greenlet.getcurrent()
+            # 1 + 1
+            try:
+                raise MemoryError()
+            except MemoryError:
+                pass
+
+    def python_prepare_callback(self, watcher_ptr):
+        loop = self._find_loop_from_c_watcher(watcher_ptr)
+        if loop is None: # pragma: no cover
+            print("WARNING: gevent: running prepare callbacks from a destroyed handle: ",
+                  watcher_ptr)
+            return
+        loop._run_callbacks()
+
+    def check_callback_onerror(self, t, v, tb):
+        loop = None
+        watcher_ptr = self._find_watcher_ptr_in_traceback(tb)
+        if watcher_ptr:
+            loop = self._find_loop_from_c_watcher(watcher_ptr)
+        if loop is not None:
+            # None as the context argument causes the exception to be raised
+            # in the main greenlet.
+            loop.handle_error(None, t, v, tb)
+            return None
+        raise v # Let CFFI print
+
+    def _find_loop_from_c_watcher(self, watcher_ptr):
+        raise NotImplementedError()
+
+    def _find_watcher_ptr_in_traceback(self, tb):
+        return tb.tb_frame.f_locals['watcher_ptr'] if tb is not None else None
+
+
+def assign_standard_callbacks(ffi, lib, callbacks_class, extras=()): # pylint:disable=unused-argument
+    """
+    Given the typical *ffi* and *lib* arguments, and a subclass of :class:`AbstractCallbacks`
+    in *callbacks_class*, set up the ``def_extern`` Python callbacks from C
+    into an instance of *callbacks_class*.
+
+    :param tuple extras: If given, this is a sequence of ``(name, error_function)``
+      additional callbacks to register. Each *name* is an attribute of
+      the *callbacks_class* instance. (Each element cas also be just a *name*.)
+    :return: The *callbacks_class* instance. This object must be kept alive,
+      typically at module scope.
+    """
+    # callbacks keeps these cdata objects alive at the python level
+    callbacks = callbacks_class(ffi)
+    extras = [extra if len(extra) == 2 else (extra, None) for extra in extras]
+    extras = tuple((getattr(callbacks, name), error) for name, error in extras)
+    for (func, error_func) in (
+            (callbacks.python_callback, None),
+            (callbacks.python_handle_error, None),
+            (callbacks.python_stop, None),
+            (callbacks.python_check_callback, callbacks.check_callback_onerror),
+            (callbacks.python_prepare_callback, callbacks.check_callback_onerror)
+    ) + extras:
+        # The name of the callback function matches the 'extern Python' declaration.
+        error_func = error_func or callbacks.unhandled_onerror
+        callback = ffi.def_extern(onerror=error_func)(func)
+        # keep alive the cdata
+        # (def_extern returns the original function, and it requests that
+        # the function be "global", so maybe it keeps a hard reference to it somewhere now
+        # unlike ffi.callback(), and we don't need to do this?)
+        callbacks.callbacks.append(callback)
+
+        # At this point, the library C variable (static function, actually)
+        # is filled in.
+
+    return callbacks
+
+
+
+basestring = (bytes, str)
+integer_types = (int,)
+
+
+_NOARGS = ()
+
+
+class AbstractLoop(object):
+    # pylint:disable=too-many-public-methods,too-many-instance-attributes
+
+    # How many callbacks we should run between checking against the
+    # switch interval.
+    CALLBACK_CHECK_COUNT = 50
+
+    error_handler = None
+
+    _CHECK_POINTER = None
+
+    _TIMER_POINTER = None
+    _TIMER_CALLBACK_SIG = None
+
+    _PREPARE_POINTER = None
+
+    starting_timer_may_update_loop_time = False
+
+    # Subclasses should set this in __init__ to reflect
+    # whether they were the default loop.
+    _default = None
+
+    _keepaliveset = _DiscardedSet()
+    _threadsafe_async = None
+
+    def __init__(self, ffi, lib, watchers, flags=None, default=None):
+        self._ffi = ffi
+        self._lib = lib
+        self._ptr = None
+        self._handle_to_self = self._ffi.new_handle(self) # XXX: Reference cycle?
+        self._watchers = watchers
+        self._in_callback = False
+        self._callbacks = deque()
+        # Stores python watcher objects while they are started
+        self._keepaliveset = set()
+        self._init_loop_and_aux_watchers(flags, default)
+
+    def _init_loop_and_aux_watchers(self, flags=None, default=None):
+        self._ptr = self._init_loop(flags, default)
+
+        # self._check is a watcher that runs in each iteration of the
+        # mainloop, just after the blocking call. It's point is to handle
+        # signals. It doesn't run watchers or callbacks, it just exists to give
+        # CFFI a chance to raise signal exceptions so we can handle them.
+        self._check = self._ffi.new(self._CHECK_POINTER)
+        self._check.data = self._handle_to_self
+        self._init_and_start_check()
+
+        # self._prepare is a watcher that runs in each iteration of the mainloop,
+        # just before the blocking call. It's where we run deferred callbacks
+        # from self.run_callback. This cooperates with _setup_for_run_callback()
+        # to schedule self._timer0 if needed.
+        self._prepare = self._ffi.new(self._PREPARE_POINTER)
+        self._prepare.data = self._handle_to_self
+        self._init_and_start_prepare()
+
+        # A timer we start and stop on demand. If we have callbacks,
+        # too many to run in one iteration of _run_callbacks, we turn this
+        # on so as to have the next iteration of the run loop return to us
+        # as quickly as possible.
+        # TODO: There may be a more efficient way to do this using ev_timer_again;
+        # see the "ev_timer" section of the ev manpage (http://linux.die.net/man/3/ev)
+        # Alternatively, setting the ev maximum block time may also work.
+        self._timer0 = self._ffi.new(self._TIMER_POINTER)
+        self._timer0.data = self._handle_to_self
+        self._init_callback_timer()
+
+        self._threadsafe_async = self.async_(ref=False)
+        # No need to do anything with this on ``fork()``, both libev and libuv
+        # take care of creating a new pipe in their respective ``loop_fork()`` methods.
+        self._threadsafe_async.start(lambda: None)
+        # TODO: We may be able to do something nicer and use the existing python_callback
+        # combined with onerror and the class check/timer/prepare to simplify things
+        # and unify our handling
+
+    def _init_loop(self, flags, default):
+        """
+        Called by __init__ to create or find the loop. The return value
+        is assigned to self._ptr.
+        """
+        raise NotImplementedError()
+
+    def _init_and_start_check(self):
+        raise NotImplementedError()
+
+    def _init_and_start_prepare(self):
+        raise NotImplementedError()
+
+    def _init_callback_timer(self):
+        raise NotImplementedError()
+
+    def _stop_callback_timer(self):
+        raise NotImplementedError()
+
+    def _start_callback_timer(self):
+        raise NotImplementedError()
+
+    def _check_callback_handle_error(self, t, v, tb):
+        self.handle_error(None, t, v, tb)
+
+    def _run_callbacks(self): # pylint:disable=too-many-branches
+        # When we're running callbacks, its safe for timers to
+        # update the notion of the current time (because if we're here,
+        # we're not running in a timer callback that may let other timers
+        # run; this is mostly an issue for libuv).
+
+        # That's actually a bit of a lie: on libev, self._timer0 really is
+        # a timer, and so sometimes this is running in a timer callback, not
+        # a prepare callback. But that's OK, libev doesn't suffer from cascading
+        # timer expiration and its safe to update the loop time at any
+        # moment there.
+        self.starting_timer_may_update_loop_time = True
+        try:
+            count = self.CALLBACK_CHECK_COUNT
+            now = self.now()
+            expiration = now + getswitchinterval()
+            self._stop_callback_timer()
+            while self._callbacks:
+                cb = self._callbacks.popleft() # pylint:disable=assignment-from-no-return
+                count -= 1
+                self.unref() # XXX: libuv doesn't have a global ref count!
+                callback = cb.callback
+                cb.callback = None
+                args = cb.args
+                if callback is None or args is None:
+                    # it's been stopped
+                    continue
+
+                try:
+                    callback(*args)
+                except: # pylint:disable=bare-except
+                    # If we allow an exception to escape this method (while we are running the ev callback),
+                    # then CFFI will print the error and libev will continue executing.
+                    # There are two problems with this. The first is that the code after
+                    # the loop won't run. The second is that any remaining callbacks scheduled
+                    # for this loop iteration will be silently dropped; they won't run, but they'll
+                    # also not be *stopped* (which is not a huge deal unless you're looking for
+                    # consistency or checking the boolean/pending status; the loop doesn't keep
+                    # a reference to them like it does to watchers...*UNLESS* the callback itself had
+                    # a reference to a watcher; then I don't know what would happen, it depends on
+                    # the state of the watcher---a leak or crash is not totally inconceivable).
+                    # The Cython implementation in core.ppyx uses gevent_call from callbacks.c
+                    # to run the callback, which uses gevent_handle_error to handle any errors the
+                    # Python callback raises...it unconditionally simply prints any error raised
+                    # by loop.handle_error and clears it, so callback handling continues.
+                    # We take a similar approach (but are extra careful about printing)
+                    try:
+                        self.handle_error(cb, *sys.exc_info())
+                    except: # pylint:disable=bare-except
+                        try:
+                            print("Exception while handling another error", file=sys.stderr)
+                            traceback.print_exc()
+                        except: # pylint:disable=bare-except
+                            pass # Nothing we can do here
+                finally:
+                    # NOTE: this must be reset here, because cb.args is used as a flag in
+                    # the callback class so that bool(cb) of a callback that has been run
+                    # becomes False
+                    cb.args = None
+
+                # We've finished running one group of callbacks
+                # but we may have more, so before looping check our
+                # switch interval.
+                if count == 0 and self._callbacks:
+                    count = self.CALLBACK_CHECK_COUNT
+                    self.update_now()
+                    if self.now() >= expiration:
+                        now = 0
+                        break
+
+            # Update the time before we start going again, if we didn't
+            # just do so.
+            if now != 0:
+                self.update_now()
+
+            if self._callbacks:
+                self._start_callback_timer()
+        finally:
+            self.starting_timer_may_update_loop_time = False
+
+    def _stop_aux_watchers(self):
+        if self._threadsafe_async is not None:
+            self._threadsafe_async.close()
+            self._threadsafe_async = None
+
+    def destroy(self):
+        ptr = self.ptr
+        if ptr:
+            try:
+                if not self._can_destroy_loop(ptr):
+                    return False
+                self._stop_aux_watchers()
+                self._destroy_loop(ptr)
+            finally:
+                # not ffi.NULL, we don't want something that can be
+                # passed to C and crash later. This will create nice friendly
+                # TypeError from CFFI.
+                self._ptr = None
+                del self._handle_to_self
+                del self._callbacks
+                del self._keepaliveset
+
+            return True
+
+    def _can_destroy_loop(self, ptr):
+        raise NotImplementedError()
+
+    def _destroy_loop(self, ptr):
+        raise NotImplementedError()
+
+    @property
+    def ptr(self):
+        # Use this when you need to be sure the pointer is valid.
+        return self._ptr
+
+    @property
+    def WatcherType(self):
+        return self._watchers.watcher
+
+    @property
+    def MAXPRI(self):
+        return 1
+
+    @property
+    def MINPRI(self):
+        return 1
+
+    def _handle_syserr(self, message, errno):
+        try:
+            errno = os.strerror(errno)
+        except: # pylint:disable=bare-except
+            traceback.print_exc()
+        try:
+            message = '%s: %s' % (message, errno)
+        except: # pylint:disable=bare-except
+            traceback.print_exc()
+        self.handle_error(None, SystemError, SystemError(message), None)
+
+    def handle_error(self, context, type, value, tb):
+        if type is HubDestroyed:
+            self._callbacks.clear()
+            self.break_()
+            return
+
+        handle_error = None
+        error_handler = self.error_handler
+        if error_handler is not None:
+            # we do want to do getattr every time so that setting Hub.handle_error property just works
+            handle_error = getattr(error_handler, 'handle_error', error_handler)
+            handle_error(context, type, value, tb)
+        else:
+            self._default_handle_error(context, type, value, tb)
+
+    def _default_handle_error(self, context, type, value, tb): # pylint:disable=unused-argument
+        # note: Hub sets its own error handler so this is not used by gevent
+        # this is here to make core.loop usable without the rest of gevent
+        # Should cause the loop to stop running.
+        traceback.print_exception(type, value, tb)
+
+
+    def run(self, nowait=False, once=False):
+        raise NotImplementedError()
+
+    def reinit(self):
+        raise NotImplementedError()
+
+    def ref(self):
+        # XXX: libuv doesn't do it this way
+        raise NotImplementedError()
+
+    def unref(self):
+        raise NotImplementedError()
+
+    def break_(self, how=None):
+        raise NotImplementedError()
+
+    def verify(self):
+        pass
+
+    def now(self):
+        raise NotImplementedError()
+
+    def update_now(self):
+        raise NotImplementedError()
+
+    def update(self):
+        import warnings
+        warnings.warn("'update' is deprecated; use 'update_now'",
+                      DeprecationWarning,
+                      stacklevel=2)
+        self.update_now()
+
+    def __repr__(self):
+        return '<%s.%s at 0x%x %s>' % (
+            self.__class__.__module__,
+            self.__class__.__name__,
+            id(self),
+            self._format()
+        )
+
+    @property
+    def default(self):
+        return self._default if self.ptr else False
+
+    @property
+    def iteration(self):
+        return -1
+
+    @property
+    def depth(self):
+        return -1
+
+    @property
+    def backend_int(self):
+        return 0
+
+    @property
+    def backend(self):
+        return "default"
+
+    @property
+    def pendingcnt(self):
+        return 0
+
+    def io(self, fd, events, ref=True, priority=None):
+        return self._watchers.io(self, fd, events, ref, priority)
+
+    def closing_fd(self, fd): # pylint:disable=unused-argument
+        return False
+
+    def timer(self, after, repeat=0.0, ref=True, priority=None):
+        return self._watchers.timer(self, after, repeat, ref, priority)
+
+    def signal(self, signum, ref=True, priority=None):
+        return self._watchers.signal(self, signum, ref, priority)
+
+    def idle(self, ref=True, priority=None):
+        return self._watchers.idle(self, ref, priority)
+
+    def prepare(self, ref=True, priority=None):
+        return self._watchers.prepare(self, ref, priority)
+
+    def check(self, ref=True, priority=None):
+        return self._watchers.check(self, ref, priority)
+
+    def fork(self, ref=True, priority=None):
+        return self._watchers.fork(self, ref, priority)
+
+    def async_(self, ref=True, priority=None):
+        return self._watchers.async_(self, ref, priority)
+
+    # Provide BWC for those that can use 'async' as is
+    locals()['async'] = async_
+
+    if sys.platform != "win32":
+
+        def child(self, pid, trace=0, ref=True):
+            return self._watchers.child(self, pid, trace, ref)
+
+        def install_sigchld(self):
+            pass
+
+    def stat(self, path, interval=0.0, ref=True, priority=None):
+        return self._watchers.stat(self, path, interval, ref, priority)
+
+    def callback(self, priority=None):
+        return callback(self, priority)
+
+    def _setup_for_run_callback(self):
+        raise NotImplementedError()
+
+    def run_callback(self, func, *args):
+        # If we happen to already be running callbacks (inside
+        # _run_callbacks), this could happen almost immediately,
+        # without the loop cycling.
+        cb = callback(func, args)
+        self._callbacks.append(cb) # Relying on the GIL for this to be threadsafe
+        self._setup_for_run_callback() # XXX: This may not be threadsafe.
+        return cb
+
+    def run_callback_threadsafe(self, func, *args):
+        cb = self.run_callback(func, *args)
+        self._threadsafe_async.send()
+        return cb
+
+    def _format(self):
+        ptr = self.ptr
+        if not ptr:
+            return 'destroyed'
+        msg = "backend=" + self.backend
+        msg += ' ptr=' + str(ptr)
+        if self.default:
+            msg += ' default'
+        msg += ' pending=%s' % self.pendingcnt
+        msg += self._format_details()
+        return msg
+
+    def _format_details(self):
+        msg = ''
+        fileno = self.fileno() # pylint:disable=assignment-from-none
+        try:
+            activecnt = self.activecnt
+        except AttributeError:
+            activecnt = None
+        if activecnt is not None:
+            msg += ' ref=' + repr(activecnt)
+        if fileno is not None:
+            msg += ' fileno=' + repr(fileno)
+        #if sigfd is not None and sigfd != -1:
+        #    msg += ' sigfd=' + repr(sigfd)
+        msg += ' callbacks=' + str(len(self._callbacks))
+        return msg
+
+    def fileno(self):
+        return None
+
+    @property
+    def activecnt(self):
+        if not self.ptr:
+            raise ValueError('operation on destroyed loop')
+        return 0

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/_ffi/watcher.py

@@ -0,0 +1,644 @@
+"""
+Useful base classes for watchers. The available
+watchers will depend on the specific event loop.
+"""
+# pylint:disable=not-callable
+from __future__ import absolute_import, print_function
+
+import signal as signalmodule
+import functools
+import warnings
+
+from gevent._config import config
+from gevent._util import LazyOnClass
+
+try:
+    from tracemalloc import get_object_traceback
+
+    def tracemalloc(init):
+        # PYTHONTRACEMALLOC env var controls this on Python 3.
+        return init
+except ImportError: # Python < 3.4
+
+    if config.trace_malloc:
+        # Use the same env var to turn this on for Python 2
+        import traceback
+
+        class _TB(object):
+            __slots__ = ('lines',)
+
+            def __init__(self, lines):
+                # These end in newlines, which we don't want for consistency
+                self.lines = [x.rstrip() for x in lines]
+
+            def format(self):
+                return self.lines
+
+        def tracemalloc(init):
+            @functools.wraps(init)
+            def traces(self, *args, **kwargs):
+                init(self, *args, **kwargs)
+                self._captured_malloc = _TB(traceback.format_stack())
+            return traces
+
+        def get_object_traceback(obj):
+            return obj._captured_malloc
+
+    else:
+        def get_object_traceback(_obj):
+            return None
+
+        def tracemalloc(init):
+            return init
+
+from gevent._compat import fsencode
+
+from gevent._ffi import _dbg # pylint:disable=unused-import
+from gevent._ffi import GEVENT_DEBUG_LEVEL
+from gevent._ffi import DEBUG
+from gevent._ffi.loop import GEVENT_CORE_EVENTS
+from gevent._ffi.loop import _NOARGS
+
+ALLOW_WATCHER_DEL = GEVENT_DEBUG_LEVEL >= DEBUG
+
+__all__ = [
+
+]
+
+try:
+    ResourceWarning # pylint:disable=used-before-assignment
+except NameError:
+    class ResourceWarning(Warning):
+        "Python 2 fallback"
+
+class _NoWatcherResult(int):
+
+    def __repr__(self):
+        return "<NoWatcher>"
+
+_NoWatcherResult = _NoWatcherResult(0)
+
+def events_to_str(event_field, all_events):
+    result = []
+    for (flag, string) in all_events:
+        c_flag = flag
+        if event_field & c_flag:
+            result.append(string)
+            event_field &=  (~c_flag)
+        if not event_field:
+            break
+    if event_field:
+        result.append(hex(event_field))
+    return '|'.join(result)
+
+
+def not_while_active(func):
+    @functools.wraps(func)
+    def nw(self, *args, **kwargs):
+        if self.active:
+            raise ValueError("not while active")
+        func(self, *args, **kwargs)
+    return nw
+
+def only_if_watcher(func):
+    @functools.wraps(func)
+    def if_w(self):
+        if self._watcher:
+            return func(self)
+        return _NoWatcherResult
+    return if_w
+
+
+class AbstractWatcherType(type):
+    """
+    Base metaclass for watchers.
+
+    To use, you will:
+
+    - subclass the watcher class defined from this type.
+    - optionally subclass this type
+    """
+    # pylint:disable=bad-mcs-classmethod-argument
+
+    _FFI = None
+    _LIB = None
+
+    def __new__(cls, name, bases, cls_dict):
+        if name != 'watcher' and not cls_dict.get('_watcher_skip_ffi'):
+            cls._fill_watcher(name, bases, cls_dict)
+        if '__del__' in cls_dict and not ALLOW_WATCHER_DEL: # pragma: no cover
+            raise TypeError("CFFI watchers are not allowed to have __del__")
+        return type.__new__(cls, name, bases, cls_dict)
+
+    @classmethod
+    def _fill_watcher(cls, name, bases, cls_dict):
+        # TODO: refactor smaller
+        # pylint:disable=too-many-locals
+        if name.endswith('_'):
+            # Strip trailing _ added to avoid keyword duplications
+            # e.g., async_
+            name = name[:-1]
+
+        def _mro_get(attr, bases, error=True):
+            for b in bases:
+                try:
+                    return getattr(b, attr)
+                except AttributeError:
+                    continue
+            if error: # pragma: no cover
+                raise AttributeError(attr)
+        _watcher_prefix = cls_dict.get('_watcher_prefix') or _mro_get('_watcher_prefix', bases)
+
+        if '_watcher_type' not in cls_dict:
+            watcher_type = _watcher_prefix + '_' + name
+            cls_dict['_watcher_type'] = watcher_type
+        elif not cls_dict['_watcher_type'].startswith(_watcher_prefix):
+            watcher_type = _watcher_prefix + '_' + cls_dict['_watcher_type']
+            cls_dict['_watcher_type'] = watcher_type
+
+        active_name = _watcher_prefix + '_is_active'
+
+        def _watcher_is_active(self):
+            return getattr(self._LIB, active_name)
+
+        LazyOnClass.lazy(cls_dict, _watcher_is_active)
+
+        watcher_struct_name = cls_dict.get('_watcher_struct_name')
+        if not watcher_struct_name:
+            watcher_struct_pattern = (cls_dict.get('_watcher_struct_pattern')
+                                      or _mro_get('_watcher_struct_pattern', bases, False)
+                                      or 'struct %s')
+            watcher_struct_name = watcher_struct_pattern % (watcher_type,)
+
+        def _watcher_struct_pointer_type(self):
+            return self._FFI.typeof(watcher_struct_name + ' *')
+
+        LazyOnClass.lazy(cls_dict, _watcher_struct_pointer_type)
+
+        callback_name = (cls_dict.get('_watcher_callback_name')
+                         or _mro_get('_watcher_callback_name', bases, False)
+                         or '_gevent_generic_callback')
+
+        def _watcher_callback(self):
+            return self._FFI.addressof(self._LIB, callback_name)
+
+        LazyOnClass.lazy(cls_dict, _watcher_callback)
+
+        def _make_meth(name, watcher_name):
+            def meth(self):
+                lib_name = self._watcher_type + '_' + name
+                return getattr(self._LIB, lib_name)
+            meth.__name__ = watcher_name
+            return meth
+
+        for meth_name in 'start', 'stop', 'init':
+            watcher_name = '_watcher' + '_' + meth_name
+            if watcher_name not in cls_dict:
+                LazyOnClass.lazy(cls_dict, _make_meth(meth_name, watcher_name))
+
+    def new_handle(cls, obj):
+        return cls._FFI.new_handle(obj)
+
+    def new(cls, kind):
+        return cls._FFI.new(kind)
+
+class watcher(object):
+
+    _callback = None
+    _args = None
+    _watcher = None
+    # self._handle has a reference to self, keeping it alive.
+    # We must keep self._handle alive for ffi.from_handle() to be
+    # able to work. We only fill this in when we are started,
+    # and when we are stopped we destroy it.
+    # NOTE: This is a GC cycle, so we keep it around for as short
+    # as possible.
+    _handle = None
+
+    @tracemalloc
+    def __init__(self, _loop, ref=True, priority=None, args=_NOARGS):
+        self.loop = _loop
+        self.__init_priority = priority
+        self.__init_args = args
+        self.__init_ref = ref
+        self._watcher_full_init()
+
+
+    def _watcher_full_init(self):
+        priority = self.__init_priority
+        ref = self.__init_ref
+        args = self.__init_args
+
+        self._watcher_create(ref)
+
+        if priority is not None:
+            self._watcher_ffi_set_priority(priority)
+
+        try:
+            self._watcher_ffi_init(args)
+        except:
+            # Let these be GC'd immediately.
+            # If we keep them around to when *we* are gc'd,
+            # they're probably invalid, meaning any native calls
+            # we do then to close() them are likely to fail
+            self._watcher = None
+            raise
+        self._watcher_ffi_set_init_ref(ref)
+
+    @classmethod
+    def _watcher_ffi_close(cls, ffi_watcher):
+        pass
+
+    def _watcher_create(self, ref): # pylint:disable=unused-argument
+        self._watcher = self._watcher_new()
+
+    def _watcher_new(self):
+        return type(self).new(self._watcher_struct_pointer_type) # pylint:disable=no-member
+
+    def _watcher_ffi_set_init_ref(self, ref):
+        pass
+
+    def _watcher_ffi_set_priority(self, priority):
+        pass
+
+    def _watcher_ffi_init(self, args):
+        raise NotImplementedError()
+
+    def _watcher_ffi_start(self):
+        raise NotImplementedError()
+
+    def _watcher_ffi_stop(self):
+        self._watcher_stop(self.loop.ptr, self._watcher)
+
+    def _watcher_ffi_ref(self):
+        raise NotImplementedError()
+
+    def _watcher_ffi_unref(self):
+        raise NotImplementedError()
+
+    def _watcher_ffi_start_unref(self):
+        # While a watcher is active, we don't keep it
+        # referenced. This allows a timer, for example, to be started,
+        # and still allow the loop to end if there is nothing
+        # else to do. see test__order.TestSleep0 for one example.
+        self._watcher_ffi_unref()
+
+    def _watcher_ffi_stop_ref(self):
+        self._watcher_ffi_ref()
+
+    # A string identifying the type of libev object we watch, e.g., 'ev_io'
+    # This should be a class attribute.
+    _watcher_type = None
+    # A class attribute that is the callback on the libev object that init's the C struct,
+    # e.g., libev.ev_io_init. If None, will be set by _init_subclasses.
+    _watcher_init = None
+    # A class attribute that is the callback on the libev object that starts the C watcher,
+    # e.g., libev.ev_io_start. If None, will be set by _init_subclasses.
+    _watcher_start = None
+    # A class attribute that is the callback on the libev object that stops the C watcher,
+    # e.g., libev.ev_io_stop. If None, will be set by _init_subclasses.
+    _watcher_stop = None
+    # A cffi ctype object identifying the struct pointer we create.
+    # This is a class attribute set based on the _watcher_type
+    _watcher_struct_pointer_type = None
+    # The attribute of the libev object identifying the custom
+    # callback function for this type of watcher. This is a class
+    # attribute set based on the _watcher_type in _init_subclasses.
+    _watcher_callback = None
+    _watcher_is_active = None
+
+    def close(self):
+        if self._watcher is None:
+            return
+
+        self.stop()
+        _watcher = self._watcher
+        self._watcher = None
+        self._watcher_set_data(_watcher, self._FFI.NULL) # pylint: disable=no-member
+        self._watcher_ffi_close(_watcher)
+        self.loop = None
+
+    def _watcher_set_data(self, the_watcher, data):
+        # This abstraction exists for the sole benefit of
+        # libuv.watcher.stat, which "subclasses" uv_handle_t.
+        # Can we do something to avoid this extra function call?
+        the_watcher.data = data
+        return data
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, t, v, tb):
+        self.close()
+
+    if ALLOW_WATCHER_DEL:
+        def __del__(self):
+            if self._watcher:
+                tb = get_object_traceback(self)
+                tb_msg = ''
+                if tb is not None:
+                    tb_msg = '\n'.join(tb.format())
+                    tb_msg = '\nTraceback:\n' + tb_msg
+                warnings.warn("Failed to close watcher %r%s" % (self, tb_msg),
+                              ResourceWarning)
+
+                # may fail if __init__ did; will be harmlessly printed
+                self.close()
+
+    __in_repr = False
+
+    def __repr__(self):
+        basic = "<%s at 0x%x" % (self.__class__.__name__, id(self))
+        if self.__in_repr:
+            return basic + '>'
+        # Running child watchers have been seen to have a
+        # recursive repr in ``self.args``, thanks to ``gevent.os.fork_and_watch``
+        # passing the watcher as an argument to its callback.
+        self.__in_repr = True
+        try:
+            result = '%s%s' % (basic, self._format())
+            if self.pending:
+                result += " pending"
+            if self.callback is not None:
+                fself = getattr(self.callback, '__self__', None)
+                if fself is self:
+                    result += " callback=<bound method %s of self>" % (self.callback.__name__)
+                else:
+                    result += " callback=%r" % (self.callback, )
+            if self.args is not None:
+                result += " args=%r" % (self.args, )
+            if self.callback is None and self.args is None:
+                result += " stopped"
+            result += " watcher=%s" % (self._watcher)
+            result += " handle=%s" % (self._watcher_handle)
+            result += " ref=%s" % (self.ref)
+            return result + ">"
+        finally:
+            self.__in_repr = False
+
+    @property
+    def _watcher_handle(self):
+        if self._watcher:
+            return self._watcher.data
+
+    def _format(self):
+        return ''
+
+    @property
+    def ref(self):
+        raise NotImplementedError()
+
+    def _get_callback(self):
+        return self._callback if '_callback' in self.__dict__ else None
+
+    def _set_callback(self, cb):
+        if not callable(cb) and cb is not None:
+            raise TypeError("Expected callable, not %r" % (cb, ))
+        if cb is None:
+            if '_callback' in self.__dict__:
+                del self._callback
+        else:
+            self._callback = cb
+    callback = property(_get_callback, _set_callback)
+
+    def _get_args(self):
+        return self._args
+
+    def _set_args(self, args):
+        if not isinstance(args, tuple) and args is not None:
+            raise TypeError("args must be a tuple or None")
+        if args is None:
+            if '_args' in self.__dict__:
+                del self._args
+        else:
+            self._args = args
+
+    args = property(_get_args, _set_args)
+
+    def start(self, callback, *args):
+        if callback is None:
+            raise TypeError('callback must be callable, not None')
+        self.callback = callback
+        self.args = args or _NOARGS
+        self.loop._keepaliveset.add(self)
+        self._handle = self._watcher_set_data(self._watcher, type(self).new_handle(self)) # pylint:disable=no-member
+        self._watcher_ffi_start()
+        self._watcher_ffi_start_unref()
+
+    def stop(self):
+        if self.callback is None:
+            assert self.loop is None or self not in self.loop._keepaliveset
+            return
+        self.callback = None
+        # Only after setting the signal to make this idempotent do
+        # we move ahead.
+        self._watcher_ffi_stop_ref()
+        self._watcher_ffi_stop()
+        self.loop._keepaliveset.discard(self)
+        self._handle = None
+        self._watcher_set_data(self._watcher, self._FFI.NULL) # pylint:disable=no-member
+
+        self.args = None
+
+    def _get_priority(self):
+        return None
+
+    @not_while_active
+    def _set_priority(self, priority):
+        pass
+
+    priority = property(_get_priority, _set_priority)
+
+
+    @property
+    def active(self):
+        if self._watcher is not None and self._watcher_is_active(self._watcher):
+            return True
+        return False
+
+    @property
+    def pending(self):
+        return False
+
+watcher = AbstractWatcherType('watcher', (object,), dict(watcher.__dict__))
+
+class IoMixin(object):
+
+    EVENT_MASK = 0
+
+    def __init__(self, loop, fd, events, ref=True, priority=None, _args=None):
+        # Win32 only works with sockets, and only when we use libuv, because
+        # we don't use _open_osfhandle. See libuv/watchers.py:io for a description.
+        if fd < 0:
+            raise ValueError('fd must be non-negative: %r' % fd)
+        if events & ~self.EVENT_MASK:
+            raise ValueError('illegal event mask: %r' % events)
+        self._fd = fd
+        super(IoMixin, self).__init__(loop, ref=ref, priority=priority,
+                                      args=_args or (fd, events))
+
+    def start(self, callback, *args, **kwargs):
+        args = args or _NOARGS
+        if kwargs.get('pass_events'):
+            args = (GEVENT_CORE_EVENTS, ) + args
+        super(IoMixin, self).start(callback, *args)
+
+    def _format(self):
+        return ' fd=%d' % self._fd
+
+class TimerMixin(object):
+    _watcher_type = 'timer'
+
+    def __init__(self, loop, after=0.0, repeat=0.0, ref=True, priority=None):
+        if repeat < 0.0:
+            raise ValueError("repeat must be positive or zero: %r" % repeat)
+        self._after = after
+        self._repeat = repeat
+        super(TimerMixin, self).__init__(loop, ref=ref, priority=priority, args=(after, repeat))
+
+    def start(self, callback, *args, **kw):
+        update = kw.get("update", self.loop.starting_timer_may_update_loop_time)
+        if update:
+            # Quoth the libev doc: "This is a costly operation and is
+            # usually done automatically within ev_run(). This
+            # function is rarely useful, but when some event callback
+            # runs for a very long time without entering the event
+            # loop, updating libev's idea of the current time is a
+            # good idea."
+
+            # 1.3 changed the default for this to False *unless* the loop is
+            # running a callback; see libuv for details. Note that
+            # starting Timeout objects still sets this to true.
+
+            self.loop.update_now()
+        super(TimerMixin, self).start(callback, *args)
+
+    def again(self, callback, *args, **kw):
+        raise NotImplementedError()
+
+
+class SignalMixin(object):
+    _watcher_type = 'signal'
+
+    def __init__(self, loop, signalnum, ref=True, priority=None):
+        if signalnum < 1 or signalnum >= signalmodule.NSIG:
+            raise ValueError('illegal signal number: %r' % signalnum)
+        # still possible to crash on one of libev's asserts:
+        # 1) "libev: ev_signal_start called with illegal signal number"
+        #    EV_NSIG might be different from signal.NSIG on some platforms
+        # 2) "libev: a signal must not be attached to two different loops"
+        #    we probably could check that in LIBEV_EMBED mode, but not in general
+        self._signalnum = signalnum
+        super(SignalMixin, self).__init__(loop, ref=ref, priority=priority, args=(signalnum, ))
+
+
+class IdleMixin(object):
+    _watcher_type = 'idle'
+
+
+class PrepareMixin(object):
+    _watcher_type = 'prepare'
+
+
+class CheckMixin(object):
+    _watcher_type = 'check'
+
+
+class ForkMixin(object):
+    _watcher_type = 'fork'
+
+
+class AsyncMixin(object):
+    _watcher_type = 'async'
+
+    def send(self):
+        raise NotImplementedError()
+
+    def send_ignoring_arg(self, _ignored):
+        """
+        Calling compatibility with ``greenlet.switch(arg)``
+        as used by waiters that have ``rawlink``.
+
+        This is an advanced method, not usually needed.
+        """
+        return self.send()
+
+    @property
+    def pending(self):
+        raise NotImplementedError()
+
+
+class ChildMixin(object):
+
+    # hack for libuv which doesn't extend watcher
+    _CALL_SUPER_INIT = True
+
+    def __init__(self, loop, pid, trace=0, ref=True):
+        if not loop.default:
+            raise TypeError('child watchers are only available on the default loop')
+        loop.install_sigchld()
+        self._pid = pid
+        if self._CALL_SUPER_INIT:
+            super(ChildMixin, self).__init__(loop, ref=ref, args=(pid, trace))
+
+    def _format(self):
+        return ' pid=%r rstatus=%r' % (self.pid, self.rstatus)
+
+    @property
+    def pid(self):
+        return self._pid
+
+    @property
+    def rpid(self):
+        # The received pid, the result of the waitpid() call.
+        return self._rpid
+
+    _rpid = None
+    _rstatus = 0
+
+    @property
+    def rstatus(self):
+        return self._rstatus
+
+class StatMixin(object):
+
+    @staticmethod
+    def _encode_path(path):
+        return fsencode(path)
+
+    def __init__(self, _loop, path, interval=0.0, ref=True, priority=None):
+        # Store the encoded path in the same attribute that corecext does
+        self._paths = self._encode_path(path)
+
+        # Keep the original path to avoid re-encoding, especially on Python 3
+        self._path = path
+
+        # Although CFFI would automatically convert a bytes object into a char* when
+        # calling ev_stat_init(..., char*, ...), on PyPy the char* pointer is not
+        # guaranteed to live past the function call. On CPython, only with a constant/interned
+        # bytes object is the pointer guaranteed to last path the function call. (And since
+        # Python 3 is pretty much guaranteed to produce a newly-encoded bytes object above, thats
+        # rarely the case). Therefore, we must keep a reference to the produced cdata object
+        # so that the struct ev_stat_watcher's `path` pointer doesn't become invalid/deallocated
+        self._cpath = self._FFI.new('char[]', self._paths)
+
+        self._interval = interval
+        super(StatMixin, self).__init__(_loop, ref=ref, priority=priority,
+                                        args=(self._cpath,
+                                              interval))
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def attr(self):
+        raise NotImplementedError
+
+    @property
+    def prev(self):
+        raise NotImplementedError
+
+    @property
+    def interval(self):
+        return self._interval

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/core.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2009-2015 Denis Bilenko and gevent contributors. See LICENSE for details.
+"""
+Deprecated; this does not reflect all the possible options
+and its interface varies.
+
+.. versionchanged:: 1.3a2
+    Deprecated.
+"""
+from __future__ import absolute_import
+
+import sys
+
+from gevent._config import config
+from gevent._util import copy_globals
+
+_core = sys.modules[config.loop.__module__]
+
+copy_globals(_core, globals())
+
+__all__ = _core.__all__ # pylint:disable=no-member

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/event.py

@@ -0,0 +1,427 @@
+# Copyright (c) 2009-2016 Denis Bilenko, gevent contributors. See LICENSE for details.
+# cython: auto_pickle=False,embedsignature=True,always_allow_keywords=False,infer_types=True
+
+"""Basic synchronization primitives: Event and AsyncResult"""
+from __future__ import print_function
+
+from gevent._util import _NONE
+from gevent._compat import reraise
+from gevent._tblib import dump_traceback, load_traceback
+
+from gevent.timeout import Timeout
+
+
+__all__ = [
+    'Event',
+    'AsyncResult',
+]
+
+def _get_linkable():
+    x = __import__('gevent._abstract_linkable')
+    return x._abstract_linkable.AbstractLinkable
+locals()['AbstractLinkable'] = _get_linkable()
+del _get_linkable
+
+
+class Event(AbstractLinkable): # pylint:disable=undefined-variable
+    """
+    A synchronization primitive that allows one greenlet to wake up
+    one or more others. It has the same interface as
+    :class:`threading.Event` but works across greenlets.
+
+    .. important::
+       This object is for communicating among greenlets within the
+       same thread *only*! Do not try to use it to communicate across threads.
+
+    An event object manages an internal flag that can be set to true
+    with the :meth:`set` method and reset to false with the
+    :meth:`clear` method. The :meth:`wait` method blocks until the
+    flag is true; as soon as the flag is set to true, all greenlets
+    that are currently blocked in a call to :meth:`wait` will be scheduled
+    to awaken.
+
+    Note that the flag may be cleared and set many times before
+    any individual greenlet runs; all the greenlet can know for sure is that the
+    flag was set *at least once* while it was waiting.
+    If the greenlet cares whether the flag is still
+    set, it must check with :meth:`ready` and possibly call back into
+    :meth:`wait` again.
+
+    .. note::
+
+        The exact order and timing in which waiting greenlets are awakened is not determined.
+
+        Once the event is set, other greenlets may run before any waiting greenlets
+        are awakened.
+
+        While the code here will awaken greenlets in the order in which they
+        waited, each such greenlet that runs may in turn cause other greenlets
+        to run.
+
+        These details may change in the future.
+
+    .. versionchanged:: 1.5a3
+
+        Waiting greenlets are now awakened in
+        the order in which they waited.
+
+    .. versionchanged:: 1.5a3
+
+        The low-level ``rawlink`` method (most users won't use this) now
+        automatically unlinks waiters before calling them.
+
+    .. 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`.
+    """
+
+    __slots__ = ('_flag',)
+
+    def __init__(self):
+        super(Event, self).__init__()
+        self._flag = False
+
+    def __str__(self):
+        return '<%s.%s %s _links[%s]>' % (
+            self.__class__.__module__,
+            self.__class__.__name__,
+            'set' if self._flag else 'clear',
+            self.linkcount()
+        )
+
+    def is_set(self):
+        """Return true if and only if the internal flag is true."""
+        return self._flag
+
+    def isSet(self):
+        # makes it a better drop-in replacement for threading.Event
+        return self._flag
+
+    def ready(self):
+        # makes it compatible with AsyncResult and Greenlet (for
+        # example in wait())
+        return self._flag
+
+    def set(self):
+        """
+        Set the internal flag to true.
+
+        All greenlets waiting for it to become true are awakened in
+        some order at some time in the future. Greenlets that call
+        :meth:`wait` once the flag is true will not block at all
+        (until :meth:`clear` is called).
+        """
+        self._flag = True
+        self._check_and_notify()
+
+    def clear(self):
+        """
+        Reset the internal flag to false.
+
+        Subsequently, threads calling :meth:`wait` will block until
+        :meth:`set` is called to set the internal flag to true again.
+        """
+        self._flag = False
+
+    def _wait_return_value(self, waited, wait_success):
+        # To avoid the race condition outlined in http://bugs.python.org/issue13502,
+        # if we had to wait, then we need to return whether or not
+        # the condition got changed. Otherwise we simply echo
+        # the current state of the flag (which should be true)
+        if not waited:
+            flag = self._flag
+            assert flag, "if we didn't wait we should already be set"
+            return flag
+
+        return wait_success
+
+    def wait(self, timeout=None):
+        """
+        Block until this object is :meth:`ready`.
+
+        If the internal flag is true on entry, return immediately. Otherwise,
+        block until another thread (greenlet) calls :meth:`set` to set the flag to true,
+        or until the optional *timeout* expires.
+
+        When the *timeout* argument is present and not ``None``, it should be a
+        floating point number specifying a timeout for the operation in seconds
+        (or fractions thereof).
+
+        :return: This method returns true if and only if the internal flag has been set to
+            true, either before the wait call or after the wait starts, so it will
+            always return ``True`` except if a timeout is given and the operation
+            times out.
+
+        .. versionchanged:: 1.1
+            The return value represents the flag during the elapsed wait, not
+            just after it elapses. This solves a race condition if one greenlet
+            sets and then clears the flag without switching, while other greenlets
+            are waiting. When the waiters wake up, this will return True; previously,
+            they would still wake up, but the return value would be False. This is most
+            noticeable when the *timeout* is present.
+        """
+        return self._wait(timeout)
+
+    def _reset_internal_locks(self): # pragma: no cover
+        # for compatibility with threading.Event
+        #  Exception AttributeError: AttributeError("'Event' object has no attribute '_reset_internal_locks'",)
+        # in <module 'threading' from '/usr/lib/python2.7/threading.pyc'> ignored
+        pass
+
+
+class AsyncResult(AbstractLinkable): # pylint:disable=undefined-variable
+    """
+    A one-time event that stores a value or an exception.
+
+    Like :class:`Event` it wakes up all the waiters when :meth:`set`
+    or :meth:`set_exception` is called. Waiters may receive the passed
+    value or exception by calling :meth:`get` instead of :meth:`wait`.
+    An :class:`AsyncResult` instance cannot be reset.
+
+    .. important::
+       This object is for communicating among greenlets within the
+       same thread *only*! Do not try to use it to communicate across threads.
+
+    To pass a value call :meth:`set`. Calls to :meth:`get` (those that
+    are currently blocking as well as those made in the future) will
+    return the value::
+
+        >>> from gevent.event import AsyncResult
+        >>> result = AsyncResult()
+        >>> result.set(100)
+        >>> result.get()
+        100
+
+    To pass an exception call :meth:`set_exception`. This will cause
+    :meth:`get` to raise that exception::
+
+        >>> result = AsyncResult()
+        >>> result.set_exception(RuntimeError('failure'))
+        >>> result.get()
+        Traceback (most recent call last):
+         ...
+        RuntimeError: failure
+
+    :class:`AsyncResult` implements :meth:`__call__` and thus can be
+    used as :meth:`link` target::
+
+        >>> import gevent
+        >>> result = AsyncResult()
+        >>> gevent.spawn(lambda : 1/0).link(result)
+        >>> try:
+        ...     result.get()
+        ... except ZeroDivisionError:
+        ...     print('ZeroDivisionError')
+        ZeroDivisionError
+
+    .. note::
+
+        The order and timing in which waiting greenlets are awakened is not determined.
+        As an implementation note, in gevent 1.1 and 1.0, waiting greenlets are awakened in a
+        undetermined order sometime *after* the current greenlet yields to the event loop. Other greenlets
+        (those not waiting to be awakened) may run between the current greenlet yielding and
+        the waiting greenlets being awakened. These details may change in the future.
+
+    .. versionchanged:: 1.1
+
+       The exact order in which waiting greenlets
+       are awakened is not the same as in 1.0.
+
+    .. versionchanged:: 1.1
+
+       Callbacks :meth:`linked <rawlink>` to this object are required to
+       be hashable, and duplicates are merged.
+
+    .. versionchanged:: 1.5a3
+
+       Waiting greenlets are now awakened in the order in which they
+       waited.
+
+    .. versionchanged:: 1.5a3
+
+       The low-level ``rawlink`` method
+       (most users won't use this) now automatically unlinks waiters
+       before calling them.
+    """
+
+    __slots__ = ('_value', '_exc_info', '_imap_task_index')
+
+    def __init__(self):
+        super(AsyncResult, self).__init__()
+        self._value = _NONE
+        self._exc_info = ()
+
+    @property
+    def _exception(self):
+        return self._exc_info[1] if self._exc_info else _NONE
+
+    @property
+    def value(self):
+        """
+        Holds the value passed to :meth:`set` if :meth:`set` was called. Otherwise,
+        ``None``
+        """
+        return self._value if self._value is not _NONE else None
+
+    @property
+    def exc_info(self):
+        """
+        The three-tuple of exception information if :meth:`set_exception` was called.
+        """
+        if self._exc_info:
+            return (self._exc_info[0], self._exc_info[1], load_traceback(self._exc_info[2]))
+        return ()
+
+    def __str__(self):
+        result = '<%s ' % (self.__class__.__name__, )
+        if self.value is not None or self._exception is not _NONE:
+            result += 'value=%r ' % self.value
+        if self._exception is not None and self._exception is not _NONE:
+            result += 'exception=%r ' % self._exception
+        if self._exception is _NONE:
+            result += 'unset '
+        return result + ' _links[%s]>' % self.linkcount()
+
+    def ready(self):
+        """Return true if and only if it holds a value or an exception"""
+        return self._exc_info or self._value is not _NONE
+
+    def successful(self):
+        """Return true if and only if it is ready and holds a value"""
+        return self._value is not _NONE
+
+    @property
+    def exception(self):
+        """Holds the exception instance passed to :meth:`set_exception` if :meth:`set_exception` was called.
+        Otherwise ``None``."""
+        if self._exc_info:
+            return self._exc_info[1]
+
+    def set(self, value=None):
+        """Store the value and wake up any waiters.
+
+        All greenlets blocking on :meth:`get` or :meth:`wait` are awakened.
+        Subsequent calls to :meth:`wait` and :meth:`get` will not block at all.
+        """
+        self._value = value
+        self._check_and_notify()
+
+    def set_exception(self, exception, exc_info=None):
+        """Store the exception and wake up any waiters.
+
+        All greenlets blocking on :meth:`get` or :meth:`wait` are awakened.
+        Subsequent calls to :meth:`wait` and :meth:`get` will not block at all.
+
+        :keyword tuple exc_info: If given, a standard three-tuple of type, value, :class:`traceback`
+            as returned by :func:`sys.exc_info`. This will be used when the exception
+            is re-raised to propagate the correct traceback.
+        """
+        if exc_info:
+            self._exc_info = (exc_info[0], exc_info[1], dump_traceback(exc_info[2]))
+        else:
+            self._exc_info = (type(exception), exception, dump_traceback(None))
+
+        self._check_and_notify()
+
+    def _raise_exception(self):
+        reraise(*self.exc_info)
+
+    def get(self, block=True, timeout=None):
+        """Return the stored value or raise the exception.
+
+        If this instance already holds a value or an exception, return  or raise it immediately.
+        Otherwise, block until another greenlet calls :meth:`set` or :meth:`set_exception` or
+        until the optional timeout occurs.
+
+        When the *timeout* argument is present and not ``None``, it should be a
+        floating point number specifying a timeout for the operation in seconds
+        (or fractions thereof). If the *timeout* elapses, the *Timeout* exception will
+        be raised.
+
+        :keyword bool block: If set to ``False`` and this instance is not ready,
+            immediately raise a :class:`Timeout` exception.
+        """
+        if self._value is not _NONE:
+            return self._value
+        if self._exc_info:
+            return self._raise_exception()
+
+        if not block:
+            # Not ready and not blocking, so immediately timeout
+            raise Timeout()
+
+        self._capture_hub(True)
+
+        # Wait, raising a timeout that elapses
+        self._wait_core(timeout, ())
+
+        # by definition we are now ready
+        return self.get(block=False)
+
+    def get_nowait(self):
+        """
+        Return the value or raise the exception without blocking.
+
+        If this object is not yet :meth:`ready <ready>`, raise
+        :class:`gevent.Timeout` immediately.
+        """
+        return self.get(block=False)
+
+    def _wait_return_value(self, waited, wait_success):
+        # pylint:disable=unused-argument
+        # Always return the value. Since this is a one-shot event,
+        # no race condition should reset it.
+        return self.value
+
+    def wait(self, timeout=None):
+        """Block until the instance is ready.
+
+        If this instance already holds a value, it is returned immediately. If this
+        instance already holds an exception, ``None`` is returned immediately.
+
+        Otherwise, block until another greenlet calls :meth:`set` or :meth:`set_exception`
+        (at which point either the value or ``None`` will be returned, respectively),
+        or until the optional timeout expires (at which point ``None`` will also be
+        returned).
+
+        When the *timeout* argument is present and not ``None``, it should be a
+        floating point number specifying a timeout for the operation in seconds
+        (or fractions thereof).
+
+        .. note:: If a timeout is given and expires, ``None`` will be returned
+            (no timeout exception will be raised).
+
+        """
+        return self._wait(timeout)
+
+    # link protocol
+    def __call__(self, source):
+        if source.successful():
+            self.set(source.value)
+        else:
+            self.set_exception(source.exception, getattr(source, 'exc_info', None))
+
+    # Methods to make us more like concurrent.futures.Future
+
+    def result(self, timeout=None):
+        return self.get(timeout=timeout)
+
+    set_result = set
+
+    def done(self):
+        return self.ready()
+
+    # we don't support cancelling
+
+    def cancel(self):
+        return False
+
+    def cancelled(self):
+        return False
+
+    # exception is a method, we use it as a property
+
+
+from gevent._util import import_c_accel
+import_c_accel(globals(), 'gevent._event')

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/events.py

@@ -0,0 +1,516 @@
+# -*- coding: utf-8 -*-
+# Copyright 2018 gevent. See LICENSE for details.
+"""
+Publish/subscribe event infrastructure.
+
+When certain "interesting" things happen during the lifetime of the
+process, gevent will "publish" an event (an object). That event is
+delivered to interested "subscribers" (functions that take one
+parameter, the event object).
+
+Higher level frameworks may take this foundation and build richer
+models on it.
+
+:mod:`zope.event` will be used to provide the functionality of
+`notify` and `subscribers`. See :mod:`zope.event.classhandler` for a
+simple class-based approach to subscribing to a filtered list of
+events, and see `zope.component
+<https://zopecomponent.readthedocs.io/en/latest/event.html>`_ for a
+much higher-level, flexible system. If you are using one of these
+systems, you generally will not want to directly modify `subscribers`.
+
+.. versionadded:: 1.3b1
+
+.. versionchanged:: 23.7.0
+   Now uses :mod:`importlib.metadata` instead of :mod:`pkg_resources`
+   to locate entry points.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+__all__ = [
+    'subscribers',
+
+    # monitor thread
+    'IEventLoopBlocked',
+    'EventLoopBlocked',
+    'IMemoryUsageThresholdExceeded',
+    'MemoryUsageThresholdExceeded',
+    'IMemoryUsageUnderThreshold',
+    'MemoryUsageUnderThreshold',
+
+    # Hub
+    'IPeriodicMonitorThread',
+    'IPeriodicMonitorThreadStartedEvent',
+    'PeriodicMonitorThreadStartedEvent',
+
+    # monkey
+    'IGeventPatchEvent',
+    'GeventPatchEvent',
+    'IGeventWillPatchEvent',
+    'DoNotPatch',
+    'GeventWillPatchEvent',
+    'IGeventDidPatchEvent',
+    'IGeventWillPatchModuleEvent',
+    'GeventWillPatchModuleEvent',
+    'IGeventDidPatchModuleEvent',
+    'GeventDidPatchModuleEvent',
+    'IGeventWillPatchAllEvent',
+    'GeventWillPatchAllEvent',
+    'IGeventDidPatchBuiltinModulesEvent',
+    'GeventDidPatchBuiltinModulesEvent',
+    'IGeventDidPatchAllEvent',
+    'GeventDidPatchAllEvent',
+]
+
+# pylint:disable=no-self-argument,inherit-non-class
+import platform
+
+from zope.interface import Interface
+from zope.interface import Attribute
+from zope.interface import implementer
+
+from zope.event import subscribers
+from zope.event import notify
+
+
+
+#: Applications may register for notification of events by appending a
+#: callable to the ``subscribers`` list.
+#:
+#: Each subscriber takes a single argument, which is the event object
+#: being published.
+#:
+#: Exceptions raised by subscribers will be propagated *without* running
+#: any remaining subscribers.
+#:
+#: This is an alias for `zope.event.subscribers`; prefer to use
+#: that attribute directly.
+subscribers = subscribers
+
+try:
+    # Cache the platform info. pkg_resources uses
+    # platform.machine() for environment markers, and
+    # platform.machine() wants to call os.popen('uname'), which is
+    # broken on Py2 when the gevent child signal handler is
+    # installed. (see test__monkey_sigchild_2.py)
+    platform.uname()
+except: # pylint:disable=bare-except
+    pass
+finally:
+    del platform
+
+def notify_and_call_entry_points(event):
+    notify(event)
+    from importlib import metadata
+    import sys
+    # This used to use the  old ``pkg_resources.iter_entry_points(group,name=None)``
+    # API, passing it just the first argument, ``group=event.ENTRY_POINT_NAME``.
+    # In other words, we don't care about the ``name``.
+    if sys.version_info[:2] >= (3, 10):
+        # pylint:disable-next=unexpected-keyword-arg
+        # The only thing you can do with this is iterate it to get
+        # EntryPoint objects. (e.g., accessing by index raises a warning)
+        entry_points = metadata.entry_points(group=event.ENTRY_POINT_NAME)
+    else:
+        # Prior to 3.10, we have to do this all manually (keyword selection
+        # was introduced in 3.10; in 3.9 and before, entry_points returns a plain
+        # ``dict``). Using it like this is deprecated in 3.10, so to avoid warnings
+        # we have to write it twice.
+        #
+        # Prior to 3.9, there is no ``.module`` attribute, so if we
+        # needed that we'd have to look at the complete ``.value``
+        # attribute.
+        ep_dict = metadata.entry_points()
+        __traceback_info__ = ep_dict
+        # On Python 3.8, we can get duplicate EntryPoint objects; it is unclear
+        # why. Drop them into a set to make sure we only get one.
+        #
+        # Running a more recent pylint flags the non-existence of ``get``
+        # pylint:disable=no-member
+        entry_points = set(
+            ep
+            for ep
+            in ep_dict.get(event.ENTRY_POINT_NAME, ())
+        )
+
+    for plugin in entry_points:
+        subscriber = plugin.load()
+        subscriber(event)
+
+
+class IPeriodicMonitorThread(Interface):
+    """
+    The contract for the periodic monitoring thread that is started
+    by the hub.
+    """
+
+    def add_monitoring_function(function, period):
+        """
+        Schedule the *function* to be called approximately every *period* fractional seconds.
+
+        The *function* receives one argument, the hub being monitored. It is called
+        in the monitoring thread, *not* the hub thread. It **must not** attempt to
+        use the gevent asynchronous API.
+
+        If the *function* is already a monitoring function, then its *period*
+        will be updated for future runs.
+
+        If the *period* is ``None``, then the function will be removed.
+
+        A *period* less than or equal to zero is not allowed.
+        """
+
+class IPeriodicMonitorThreadStartedEvent(Interface):
+    """
+    The event emitted when a hub starts a periodic monitoring thread.
+
+    You can use this event to add additional monitoring functions.
+    """
+
+    monitor = Attribute("The instance of `IPeriodicMonitorThread` that was started.")
+
+@implementer(IPeriodicMonitorThreadStartedEvent)
+class PeriodicMonitorThreadStartedEvent(object):
+    """
+    The implementation of :class:`IPeriodicMonitorThreadStartedEvent`.
+
+    .. versionchanged:: 24.11.1
+       Now actually implements the promised interface.
+    """
+
+    #: The name of the setuptools entry point that is called when this
+    #: event is emitted.
+    ENTRY_POINT_NAME = 'gevent.plugins.hub.periodic_monitor_thread_started'
+
+    def __init__(self, monitor):
+        self.monitor = monitor
+
+class IEventLoopBlocked(Interface):
+    """
+    The event emitted when the event loop is blocked.
+
+    This event is emitted in the monitor thread.
+
+    .. versionchanged:: 24.11.1
+       Add the *hub* attribute.
+    """
+
+    greenlet = Attribute("The greenlet that appeared to be blocking the loop.")
+    blocking_time = Attribute("The approximate time in seconds the loop has been blocked.")
+    info = Attribute("A list of string lines providing extra info. You may modify this list.")
+    hub = Attribute("""If not None, the hub being blocked.""")
+
+@implementer(IEventLoopBlocked)
+class EventLoopBlocked(object):
+    """
+    The event emitted when the event loop is blocked.
+
+    Implements `IEventLoopBlocked`.
+    """
+
+    def __init__(self, greenlet, blocking_time, info, *, hub=None):
+        self.greenlet = greenlet
+        self.blocking_time = blocking_time
+        self.info = info
+        self.hub = hub
+
+class IMemoryUsageThresholdExceeded(Interface):
+    """
+    The event emitted when the memory usage threshold is exceeded.
+
+    This event is emitted only while memory continues to grow
+    above the threshold. Only if the condition or stabilized is corrected (memory
+    usage drops) will the event be emitted in the future.
+
+    This event is emitted in the monitor thread.
+    """
+
+    mem_usage = Attribute("The current process memory usage, in bytes.")
+    max_allowed = Attribute("The maximum allowed memory usage, in bytes.")
+    memory_info = Attribute("The tuple of memory usage stats return by psutil.")
+
+class _AbstractMemoryEvent(object):
+
+    def __init__(self, mem_usage, max_allowed, memory_info):
+        self.mem_usage = mem_usage
+        self.max_allowed = max_allowed
+        self.memory_info = memory_info
+
+    def __repr__(self):
+        return "<%s used=%d max=%d details=%r>" % (
+            self.__class__.__name__,
+            self.mem_usage,
+            self.max_allowed,
+            self.memory_info,
+        )
+
+@implementer(IMemoryUsageThresholdExceeded)
+class MemoryUsageThresholdExceeded(_AbstractMemoryEvent):
+    """
+    Implementation of `IMemoryUsageThresholdExceeded`.
+    """
+
+
+class IMemoryUsageUnderThreshold(Interface):
+    """
+    The event emitted when the memory usage drops below the
+    threshold after having previously been above it.
+
+    This event is emitted only the first time memory usage is detected
+    to be below the threshold after having previously been above it.
+    If memory usage climbs again, a `IMemoryUsageThresholdExceeded`
+    event will be broadcast, and then this event could be broadcast again.
+
+    This event is emitted in the monitor thread.
+    """
+
+    mem_usage = Attribute("The current process memory usage, in bytes.")
+    max_allowed = Attribute("The maximum allowed memory usage, in bytes.")
+    max_memory_usage = Attribute("The memory usage that caused the previous "
+                                 "IMemoryUsageThresholdExceeded event.")
+    memory_info = Attribute("The tuple of memory usage stats return by psutil.")
+
+
+@implementer(IMemoryUsageUnderThreshold)
+class MemoryUsageUnderThreshold(_AbstractMemoryEvent):
+    """
+    Implementation of `IMemoryUsageUnderThreshold`.
+    """
+
+    def __init__(self, mem_usage, max_allowed, memory_info, max_usage):
+        super(MemoryUsageUnderThreshold, self).__init__(mem_usage, max_allowed, memory_info)
+        self.max_memory_usage = max_usage
+
+
+class IGeventPatchEvent(Interface):
+    """
+    The root for all monkey-patch events gevent emits.
+    """
+
+    source = Attribute("The source object containing the patches.")
+    target = Attribute("The destination object to be patched.")
+
+@implementer(IGeventPatchEvent)
+class GeventPatchEvent(object):
+    """
+    Implementation of `IGeventPatchEvent`.
+    """
+
+    def __init__(self, source, target):
+        self.source = source
+        self.target = target
+
+    def __repr__(self):
+        return '<%s source=%r target=%r at %x>' % (self.__class__.__name__,
+                                                   self.source,
+                                                   self.target,
+                                                   id(self))
+
+class IGeventWillPatchEvent(IGeventPatchEvent):
+    """
+    An event emitted *before* gevent monkey-patches something.
+
+    If a subscriber raises `DoNotPatch`, then patching this particular
+    item will not take place.
+    """
+
+
+class DoNotPatch(BaseException):
+    """
+    Subscribers to will-patch events can raise instances
+    of this class to tell gevent not to patch that particular item.
+    """
+
+
+@implementer(IGeventWillPatchEvent)
+class GeventWillPatchEvent(GeventPatchEvent):
+    """
+    Implementation of `IGeventWillPatchEvent`.
+    """
+
+class IGeventDidPatchEvent(IGeventPatchEvent):
+    """
+    An event emitted *after* gevent has patched something.
+    """
+
+@implementer(IGeventDidPatchEvent)
+class GeventDidPatchEvent(GeventPatchEvent):
+    """
+    Implementation of `IGeventDidPatchEvent`.
+    """
+
+class IGeventWillPatchModuleEvent(IGeventWillPatchEvent):
+    """
+    An event emitted *before* gevent begins patching a specific module.
+
+    Both *source* and *target* attributes are module objects.
+    """
+
+    module_name = Attribute("The name of the module being patched. "
+                            "This is the same as ``target.__name__``.")
+
+    target_item_names = Attribute("The list of item names to patch. "
+                                  "This can be modified in place with caution.")
+
+@implementer(IGeventWillPatchModuleEvent)
+class GeventWillPatchModuleEvent(GeventWillPatchEvent):
+    """
+    Implementation of `IGeventWillPatchModuleEvent`.
+    """
+
+    #: The name of the setuptools entry point that is called when this
+    #: event is emitted.
+    ENTRY_POINT_NAME = 'gevent.plugins.monkey.will_patch_module'
+
+    def __init__(self, module_name, source, target, items):
+        super(GeventWillPatchModuleEvent, self).__init__(source, target)
+        self.module_name = module_name
+        self.target_item_names = items
+
+
+class IGeventDidPatchModuleEvent(IGeventDidPatchEvent):
+    """
+    An event emitted *after* gevent has completed patching a specific
+    module.
+    """
+
+    module_name = Attribute("The name of the module being patched. "
+                            "This is the same as ``target.__name__``.")
+
+
+@implementer(IGeventDidPatchModuleEvent)
+class GeventDidPatchModuleEvent(GeventDidPatchEvent):
+    """
+    Implementation of `IGeventDidPatchModuleEvent`.
+    """
+
+    #: The name of the setuptools entry point that is called when this
+    #: event is emitted.
+    ENTRY_POINT_NAME = 'gevent.plugins.monkey.did_patch_module'
+
+    def __init__(self, module_name, source, target):
+        super(GeventDidPatchModuleEvent, self).__init__(source, target)
+        self.module_name = module_name
+
+# TODO: Maybe it would be useful for the the module patch events
+# to have an attribute telling if they're being done during patch_all?
+
+class IGeventWillPatchAllEvent(IGeventWillPatchEvent):
+    """
+    An event emitted *before* gevent begins patching the system.
+
+    Following this event will be a series of
+    `IGeventWillPatchModuleEvent` and `IGeventDidPatchModuleEvent` for
+    each patched module.
+
+    Once the gevent builtin modules have been processed,
+    `IGeventDidPatchBuiltinModulesEvent` will be emitted. Processing
+    this event is an ideal time for third-party modules to be imported
+    and patched (which may trigger its own will/did patch module
+    events).
+
+    Finally, a `IGeventDidPatchAllEvent` will be sent.
+
+    If a subscriber to this event raises `DoNotPatch`, no patching
+    will be done.
+
+    The *source* and *target* attributes have undefined values.
+    """
+
+    patch_all_arguments = Attribute(
+        "A dictionary of all the arguments to `gevent.monkey.patch_all`. "
+        "This dictionary should not be modified. "
+    )
+
+    patch_all_kwargs = Attribute(
+        "A dictionary of the extra arguments to `gevent.monkey.patch_all`. "
+        "This dictionary should not be modified. "
+    )
+
+    def will_patch_module(module_name):
+        """
+        Return whether the module named *module_name* will be patched.
+        """
+
+class _PatchAllMixin(object):
+    def __init__(self, patch_all_arguments, patch_all_kwargs):
+        super(_PatchAllMixin, self).__init__(None, None)
+        self._patch_all_arguments = patch_all_arguments
+        self._patch_all_kwargs = patch_all_kwargs
+
+    @property
+    def patch_all_arguments(self):
+        return self._patch_all_arguments.copy()
+
+    @property
+    def patch_all_kwargs(self):
+        return self._patch_all_kwargs.copy()
+
+    def __repr__(self):
+        return '<%s %r at %x>' % (self.__class__.__name__,
+                                  self._patch_all_arguments,
+                                  id(self))
+
+@implementer(IGeventWillPatchAllEvent)
+class GeventWillPatchAllEvent(_PatchAllMixin, GeventWillPatchEvent):
+    """
+    Implementation of `IGeventWillPatchAllEvent`.
+    """
+
+    #: The name of the setuptools entry point that is called when this
+    #: event is emitted.
+    ENTRY_POINT_NAME = 'gevent.plugins.monkey.will_patch_all'
+
+    def will_patch_module(self, module_name):
+        return self.patch_all_arguments.get(module_name)
+
+class IGeventDidPatchBuiltinModulesEvent(IGeventDidPatchEvent):
+    """
+    Event emitted *after* the builtin modules have been patched.
+
+    If you're going to monkey-patch a third-party library, this is
+    usually the event to listen for.
+
+    The values of the *source* and *target* attributes are undefined.
+    """
+
+    patch_all_arguments = Attribute(
+        "A dictionary of all the arguments to `gevent.monkey.patch_all`. "
+        "This dictionary should not be modified. "
+    )
+
+    patch_all_kwargs = Attribute(
+        "A dictionary of the extra arguments to `gevent.monkey.patch_all`. "
+        "This dictionary should not be modified. "
+    )
+
+@implementer(IGeventDidPatchBuiltinModulesEvent)
+class GeventDidPatchBuiltinModulesEvent(_PatchAllMixin, GeventDidPatchEvent):
+    """
+    Implementation of `IGeventDidPatchBuiltinModulesEvent`.
+    """
+
+    #: The name of the setuptools entry point that is called when this
+    #: event is emitted.
+    ENTRY_POINT_NAME = 'gevent.plugins.monkey.did_patch_builtins'
+
+class IGeventDidPatchAllEvent(IGeventDidPatchEvent):
+    """
+    Event emitted after gevent has patched all modules, both builtin
+    and those provided by plugins/subscribers.
+
+    The values of the *source* and *target* attributes are undefined.
+    """
+
+@implementer(IGeventDidPatchAllEvent)
+class GeventDidPatchAllEvent(_PatchAllMixin, GeventDidPatchEvent):
+    """
+    Implementation of `IGeventDidPatchAllEvent`.
+    """
+
+    #: The name of the setuptools entry point that is called when this
+    #: event is emitted.
+    ENTRY_POINT_NAME = 'gevent.plugins.monkey.did_patch_all'

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/exceptions.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+# copyright 2018 gevent
+"""
+Exceptions.
+
+.. versionadded:: 1.3b1
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from greenlet import GreenletExit
+
+__all__ = [
+    'LoopExit',
+]
+
+
+class LoopExit(Exception):
+    """
+    Exception thrown when the hub finishes running (`gevent.hub.Hub.run`
+    would return).
+
+    In a normal application, this is never thrown or caught
+    explicitly. The internal implementation of functions like
+    :meth:`gevent.hub.Hub.join` and :func:`gevent.joinall` may catch it, but user code
+    generally should not.
+
+    .. caution::
+       Errors in application programming can also lead to this exception being
+       raised. Some examples include (but are not limited too):
+
+       - greenlets deadlocking on a lock;
+       - using a socket or other gevent object with native thread
+         affinity from a different thread
+
+    """
+
+    @property
+    def hub(self):
+        """
+        The (optional) hub that raised the error.
+
+        .. versionadded:: 20.12.0
+        """
+        # XXX: Note that semaphore.py does this manually.
+        if len(self.args) == 3: # From the hub
+            return self.args[1]
+
+    def __repr__(self):
+        # pylint:disable=unsubscriptable-object
+        if len(self.args) == 3: # From the hub
+            import pprint
+            return (
+                "%s\n"
+                "\tHub: %s\n"
+                "\tHandles:\n%s"
+            ) % (
+                self.args[0],
+                self.args[1],
+                pprint.pformat(self.args[2])
+            )
+        return Exception.__repr__(self)
+
+    def __str__(self):
+        return repr(self)
+
+class BlockingSwitchOutError(AssertionError):
+    """
+    Raised when a gevent synchronous function is called from a
+    low-level event loop callback.
+
+    This is usually a programming error.
+    """
+
+
+class InvalidSwitchError(AssertionError):
+    """
+    Raised when the event loop returns control to a greenlet in an
+    unexpected way.
+
+    This is usually a bug in gevent, greenlet, or the event loop.
+    """
+
+class ConcurrentObjectUseError(AssertionError):
+    """
+    Raised when an object is used (waited on) by two greenlets
+    independently, meaning the object was entered into a blocking
+    state by one greenlet and then another while still blocking in the
+    first one.
+
+    This is usually a programming error.
+
+    .. seealso:: `gevent.socket.wait`
+    """
+
+class InvalidThreadUseError(RuntimeError):
+    """
+    Raised when an object is used from a different thread than
+    the one it is bound to.
+
+    Some objects, such as gevent sockets, semaphores, and threadpools,
+    are tightly bound to their hub and its loop. The hub and loop
+    are not thread safe, with a few exceptions. Attempting to use
+    such objects from a different thread is an error, and may cause
+    problems ranging from incorrect results to memory corruption
+    and a crashed process.
+
+    In some cases, gevent catches this "accidentally", and the result is
+    a `LoopExit`. In some cases, gevent doesn't catch this at all.
+
+    In other cases (typically when the consequences are suspected to
+    be more on the more severe end of the scale, and when the operation in
+    question is already relatively heavyweight), gevent explicitly checks
+    for this usage and will raise this exception when it is detected.
+
+    .. versionadded:: 1.5a3
+    """
+
+
+class HubDestroyed(GreenletExit):
+    """
+    Internal exception, raised when we're trying to destroy the
+    hub and we want the loop to stop running callbacks now.
+
+    This must not be subclassed; the type is tested by identity.
+
+    Clients outside of gevent must not raise this exception.
+
+    .. versionadded:: 20.12.0
+    """
+
+    def __init__(self, destroy_loop):
+        GreenletExit.__init__(self, destroy_loop)
+        self.destroy_loop = destroy_loop

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/fileobject.py

@@ -0,0 +1,85 @@
+"""
+Wrappers to make file-like objects cooperative.
+
+.. class:: FileObject(fobj, mode='r', buffering=-1, closefd=True, encoding=None, errors=None, newline=None)
+
+    The main entry point to the file-like gevent-compatible behaviour. It
+    will be defined to be the best available implementation.
+
+    All the parameters are as for :func:`io.open`.
+
+    :param fobj: Usually a file descriptor of a socket. Can also be
+        another object with a ``fileno()`` method, or an object that can
+        be passed to ``io.open()`` (e.g., a file system path). If the object
+        is not a socket, the results will vary based on the platform and the
+        type of object being opened.
+
+        All supported versions of Python allow :class:`os.PathLike` objects.
+
+    .. versionchanged:: 1.5
+       Accept str and ``PathLike`` objects for *fobj* on all versions of Python.
+    .. versionchanged:: 1.5
+       Add *encoding*, *errors* and *newline* arguments.
+    .. versionchanged:: 1.5
+       Accept *closefd* and *buffering* instead of *close* and *bufsize* arguments.
+       The latter remain for backwards compatibility.
+
+There are two main implementations of ``FileObject``. On all systems,
+there is :class:`FileObjectThread` which uses the built-in native
+threadpool to avoid blocking the entire interpreter. On UNIX systems
+(those that support the :mod:`fcntl` module), there is also
+:class:`FileObjectPosix` which uses native non-blocking semantics.
+
+A third class, :class:`FileObjectBlock`, is simply a wrapper that
+executes everything synchronously (and so is not gevent-compatible).
+It is provided for testing and debugging purposes.
+
+All classes have the same signature; some may accept extra keyword arguments.
+
+Configuration
+=============
+
+You may change the default value for ``FileObject`` using the
+``GEVENT_FILE`` environment variable. Set it to ``posix``, ``thread``,
+or ``block`` to choose from :class:`FileObjectPosix`,
+:class:`FileObjectThread` and :class:`FileObjectBlock`, respectively.
+You may also set it to the fully qualified class name of another
+object that implements the file interface to use one of your own
+objects.
+
+.. note::
+
+    The environment variable must be set at the time this module
+    is first imported.
+
+Classes
+=======
+"""
+from __future__ import absolute_import
+
+from gevent._config import config
+
+__all__ = [
+    'FileObjectPosix',
+    'FileObjectThread',
+    'FileObjectBlock',
+    'FileObject',
+]
+
+try:
+    from fcntl import fcntl
+except ImportError:
+    __all__.remove("FileObjectPosix")
+else:
+    del fcntl
+    from gevent._fileobjectposix import FileObjectPosix
+
+from gevent._fileobjectcommon import FileObjectThread
+from gevent._fileobjectcommon import FileObjectBlock
+
+
+# None of the possible objects can live in this module because
+# we would get an import cycle and the config couldn't be set from code.
+# TODO: zope.hookable would be great for allowing this to be imported
+# without requiring configuration but still being very fast.
+FileObject = config.fileobject

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/greenlet.py

@@ -0,0 +1,1186 @@
+# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
+# cython: auto_pickle=False,embedsignature=True,always_allow_keywords=False
+# pylint:disable=too-many-lines
+from __future__ import absolute_import, print_function, division
+
+from sys import _getframe as sys_getframe
+from sys import exc_info as sys_exc_info
+from weakref import ref as wref
+
+# XXX: How to get cython to let us rename this as RawGreenlet
+# like we prefer?
+from greenlet import greenlet
+from greenlet import GreenletExit
+
+from gevent._compat import reraise
+from gevent._compat import PYPY as _PYPY
+from gevent._tblib import dump_traceback
+from gevent._tblib import load_traceback
+
+from gevent.exceptions import InvalidSwitchError
+
+from gevent._hub_primitives import iwait_on_objects as iwait
+from gevent._hub_primitives import wait_on_objects as wait
+
+from gevent.timeout import Timeout
+
+from gevent._config import config as GEVENT_CONFIG
+from gevent._util import readproperty
+from gevent._hub_local import get_hub_noargs as get_hub
+from gevent import _waiter
+
+
+__all__ = [
+    'Greenlet',
+    'joinall',
+    'killall',
+]
+
+
+# In Cython, we define these as 'cdef inline' functions. The
+# compilation unit cannot have a direct assignment to them (import
+# is assignment) without generating a 'lvalue is not valid target'
+# error.
+locals()['getcurrent'] = __import__('greenlet').getcurrent
+locals()['greenlet_init'] = lambda: None
+locals()['Waiter'] = _waiter.Waiter
+# With Cython, this raises a TypeError if the parent is *not*
+# the hub (SwitchOutGreenletWithLoop); in pure-Python, we will
+# very likely get an AttributeError immediately after when we access `loop`;
+# The TypeError message is more informative on Python 2.
+# This must ONLY be called when we know that `s` is not None and is in fact a greenlet
+# object (e.g., when called on `self`)
+locals()['get_my_hub'] = lambda s: s.parent
+# This must also ONLY be called when we know that S is not None and is in fact a greenlet
+# object (including the result of getcurrent())
+locals()['get_generic_parent'] = lambda s: s.parent
+
+# Frame access
+locals()['Gevent_PyFrame_GetCode'] = lambda frame: frame.f_code
+locals()['Gevent_PyFrame_GetLineNumber'] = lambda frame: frame.f_lineno
+locals()['Gevent_PyFrame_GetBack'] = lambda frame: frame.f_back
+
+
+if _PYPY:
+    import _continuation # pylint:disable=import-error
+    _continulet = _continuation.continulet
+
+
+class SpawnedLink(object):
+    """
+    A wrapper around link that calls it in another greenlet.
+
+    Can be called only from main loop.
+    """
+    __slots__ = ['callback']
+
+    def __init__(self, callback):
+        if not callable(callback):
+            raise TypeError("Expected callable: %r" % (callback, ))
+        self.callback = callback
+
+    def __call__(self, source):
+        g = greenlet(self.callback, get_hub())
+        g.switch(source)
+
+    def __hash__(self):
+        return hash(self.callback)
+
+    def __eq__(self, other):
+        return self.callback == getattr(other, 'callback', other)
+
+    def __str__(self):
+        return str(self.callback)
+
+    def __repr__(self):
+        return repr(self.callback)
+
+    def __getattr__(self, item):
+        assert item != 'callback'
+        return getattr(self.callback, item)
+
+
+class SuccessSpawnedLink(SpawnedLink):
+    """A wrapper around link that calls it in another greenlet only if source succeed.
+
+    Can be called only from main loop.
+    """
+    __slots__ = []
+
+    def __call__(self, source):
+        if source.successful():
+            return SpawnedLink.__call__(self, source)
+
+
+class FailureSpawnedLink(SpawnedLink):
+    """A wrapper around link that calls it in another greenlet only if source failed.
+
+    Can be called only from main loop.
+    """
+    __slots__ = []
+
+    def __call__(self, source):
+        if not source.successful():
+            return SpawnedLink.__call__(self, source)
+
+class _Frame(object):
+
+    __slots__ = ('f_code', 'f_lineno', 'f_back')
+
+    def __init__(self):
+        self.f_code = None
+        self.f_back = None
+        self.f_lineno = 0
+
+    @property
+    def f_globals(self):
+        return None
+
+
+def _extract_stack(limit):
+    try:
+        frame = sys_getframe()
+    except ValueError:
+        # In certain embedded cases that directly use the Python C api
+        # to call Greenlet.spawn (e.g., uwsgi) this can raise
+        # `ValueError: call stack is not deep enough`. This is because
+        # the Cython stack frames for Greenlet.spawn ->
+        # Greenlet.__init__ -> _extract_stack are all on the C level,
+        # not the Python level.
+        # See https://github.com/gevent/gevent/issues/1212
+        frame = None
+
+    newest_Frame = None
+    newer_Frame = None
+
+    while limit and frame is not None:
+        limit -= 1
+        older_Frame = _Frame()
+        # Arguments are always passed to the constructor as Python objects,
+        # meaning we wind up boxing the f_lineno just to unbox it if we pass it.
+        # It's faster to simply assign once the object is created.
+        older_Frame.f_code = Gevent_PyFrame_GetCode(frame)  # pylint:disable=undefined-variable
+        older_Frame.f_lineno = Gevent_PyFrame_GetLineNumber(frame) # pylint:disable=undefined-variable
+        if newer_Frame is not None:
+            newer_Frame.f_back = older_Frame
+        newer_Frame = older_Frame
+        if newest_Frame is None:
+            newest_Frame = newer_Frame
+
+        frame = Gevent_PyFrame_GetBack(frame) # pylint:disable=undefined-variable
+
+    return newest_Frame
+
+
+_greenlet__init__ = greenlet.__init__
+
+class Greenlet(greenlet):
+    """
+    A light-weight cooperatively-scheduled execution unit.
+    """
+    # pylint:disable=too-many-public-methods,too-many-instance-attributes
+
+    spawning_stack_limit = 10
+
+    # pylint:disable=keyword-arg-before-vararg,super-init-not-called
+    def __init__(self, run=None, *args, **kwargs):
+        """
+        :param args: The arguments passed to the ``run`` function.
+        :param kwargs: The keyword arguments passed to the ``run`` function.
+        :keyword callable run: The callable object to run. If not given, this object's
+            `_run` method will be invoked (typically defined by subclasses).
+
+        .. versionchanged:: 1.1b1
+            The ``run`` argument to the constructor is now verified to be a callable
+            object. Previously, passing a non-callable object would fail after the greenlet
+            was spawned.
+
+        .. versionchanged:: 1.3b1
+           The ``GEVENT_TRACK_GREENLET_TREE`` configuration value may be set to
+           a false value to disable ``spawn_tree_locals``, ``spawning_greenlet``,
+           and ``spawning_stack``. The first two will be None in that case, and the
+           latter will be empty.
+
+        .. versionchanged:: 1.5
+           Greenlet objects are now more careful to verify that their ``parent`` is really
+           a gevent hub, raising a ``TypeError`` earlier instead of an ``AttributeError`` later.
+
+        .. versionchanged:: 20.12.1
+           Greenlet objects now function as context managers. Exiting the ``with`` suite
+           ensures that the greenlet has completed by :meth:`joining <join>`
+           the greenlet (blocking, with
+           no timeout). If the body of the suite raises an exception, the greenlet is
+           :meth:`killed <kill>` with the default arguments and not joined in that case.
+        """
+        # The attributes are documented in the .rst file
+
+        # greenlet.greenlet(run=None, parent=None)
+        # Calling it with both positional arguments instead of a keyword
+        # argument (parent=get_hub()) speeds up creation of this object ~30%:
+        # python -m timeit -s 'import gevent' 'gevent.Greenlet()'
+        # Python 3.5: 2.70usec with keywords vs 1.94usec with positional
+        # Python 3.4: 2.32usec with keywords vs 1.74usec with positional
+        # Python 3.3: 2.55usec with keywords vs 1.92usec with positional
+        # Python 2.7: 1.73usec with keywords vs 1.40usec with positional
+
+        # Timings taken Feb 21 2018 prior to integration of #755
+        # python -m perf timeit -s 'import gevent' 'gevent.Greenlet()'
+        # 3.6.4       : Mean +- std dev: 1.08 us +- 0.05 us
+        # 2.7.14      : Mean +- std dev: 1.44 us +- 0.06 us
+        # PyPy2 5.10.0: Mean +- std dev: 2.14 ns +- 0.08 ns
+
+        # After the integration of spawning_stack, spawning_greenlet,
+        # and spawn_tree_locals on that same date:
+        # 3.6.4       : Mean +- std dev: 8.92 us +- 0.36 us ->  8.2x
+        # 2.7.14      : Mean +- std dev: 14.8 us +- 0.5 us  -> 10.2x
+        # PyPy2 5.10.0: Mean +- std dev: 3.24 us +- 0.17 us ->  1.5x
+
+        # Compiling with Cython gets us to these numbers:
+        # 3.6.4        : Mean +- std dev: 3.63 us +- 0.14 us
+        # 2.7.14       : Mean +- std dev: 3.37 us +- 0.20 us
+        # PyPy2 5.10.0 : Mean +- std dev: 4.44 us +- 0.28 us
+
+        # Switching to reified frames and some more tuning gets us here:
+        # 3.7.2        : Mean +- std dev: 2.53 us +- 0.15 us
+        # 2.7.16       : Mean +- std dev: 2.35 us +- 0.12 us
+        # PyPy2 7.1    : Mean +- std dev: 11.6 us +- 0.4 us
+
+        # Compared to the released 1.4 (tested at the same time):
+        # 3.7.2        : Mean +- std dev: 3.21 us +- 0.32 us
+        # 2.7.16       : Mean +- std dev: 3.11 us +- 0.19 us
+        # PyPy2 7.1    : Mean +- std dev: 12.3 us +- 0.8 us
+
+        _greenlet__init__(self, None, get_hub())
+
+        if run is not None:
+            self._run = run
+
+        # If they didn't pass a callable at all, then they must
+        # already have one. Note that subclassing to override the run() method
+        # itself has never been documented or supported.
+        if not callable(self._run):
+            raise TypeError("The run argument or self._run must be callable")
+
+        self.args = args
+        self.kwargs = kwargs
+        self.value = None
+
+        #: An event, such as a timer or a callback that fires. It is established in
+        #: start() and start_later() as those two objects, respectively.
+        #: Once this becomes non-None, the Greenlet cannot be started again. Conversely,
+        #: kill() and throw() check for non-None to determine if this object has ever been
+        #: scheduled for starting. A placeholder _cancelled_start_event is assigned by them to prevent
+        #: the greenlet from being started in the future, if necessary.
+        #: In the usual case, this transitions as follows: None -> event -> _start_completed_event.
+        #: A value of None means we've never been started.
+        self._start_event = None
+
+        self._notifier = None
+        self._formatted_info = None
+        self._links = []
+        self._ident = None
+
+        # Initial state: None.
+        # Completed successfully: (None, None, None)
+        # Failed with exception: (t, v, dump_traceback(tb)))
+        self._exc_info = None
+
+        if GEVENT_CONFIG.track_greenlet_tree:
+            spawner = getcurrent() # pylint:disable=undefined-variable
+            self.spawning_greenlet = wref(spawner)
+            try:
+                self.spawn_tree_locals = spawner.spawn_tree_locals
+            except AttributeError:
+                self.spawn_tree_locals = {}
+                if get_generic_parent(spawner) is not None: # pylint:disable=undefined-variable
+                    # The main greenlet has no parent.
+                    # Its children get separate locals.
+                    spawner.spawn_tree_locals = self.spawn_tree_locals
+
+            self.spawning_stack = _extract_stack(self.spawning_stack_limit)
+            # Don't copy the spawning greenlet's
+            # '_spawning_stack_frames' into ours. That's somewhat
+            # confusing, and, if we're not careful, a deep spawn tree
+            # can lead to excessive memory usage (an infinite spawning
+            # tree could lead to unbounded memory usage without care
+            # --- see https://github.com/gevent/gevent/issues/1371)
+            # The _spawning_stack_frames may be cleared out later if we access spawning_stack
+        else:
+            # None is the default for all of these in Cython, but we
+            # need to declare them for pure-Python mode.
+            self.spawning_greenlet = None
+            self.spawn_tree_locals = None
+            self.spawning_stack = None
+
+    def _get_minimal_ident(self):
+        # Helper function for cython, to allow typing `reg` and making a
+        # C call to get_ident.
+
+        # If we're being accessed from a hub different than the one running
+        # us, aka get_hub() is not self.parent, then calling hub.ident_registry.get_ident()
+        # may be quietly broken: it's not thread safe.
+        # If our parent is no longer the hub for whatever reason, this will raise a
+        # AttributeError or TypeError.
+        hub = get_my_hub(self) # pylint:disable=undefined-variable
+
+        reg = hub.ident_registry
+        return reg.get_ident(self)
+
+    @property
+    def minimal_ident(self):
+        """
+        A small, unique non-negative integer that identifies this object.
+
+        This is similar to :attr:`threading.Thread.ident` (and `id`)
+        in that as long as this object is alive, no other greenlet *in
+        this hub* will have the same id, but it makes a stronger
+        guarantee that the assigned values will be small and
+        sequential. Sometime after this object has died, the value
+        will be available for reuse.
+
+        To get ids that are unique across all hubs, combine this with
+        the hub's (``self.parent``) ``minimal_ident``.
+
+        Accessing this property from threads other than the thread running
+        this greenlet is not defined.
+
+        .. versionadded:: 1.3a2
+
+        """
+        # Not @Lazy, implemented manually because _ident is in the structure
+        # of the greenlet for fast access
+        if self._ident is None:
+            self._ident = self._get_minimal_ident()
+        return self._ident
+
+    @readproperty
+    def name(self):
+        """
+        The greenlet name. By default, a unique name is constructed using
+        the :attr:`minimal_ident`. You can assign a string to this
+        value to change it. It is shown in the `repr` of this object if it
+        has been assigned to or if the `minimal_ident` has already been generated.
+
+        .. versionadded:: 1.3a2
+        .. versionchanged:: 1.4
+           Stop showing generated names in the `repr` when the ``minimal_ident``
+           hasn't been requested. This reduces overhead and may be less confusing,
+           since ``minimal_ident`` can get reused.
+        """
+        return 'Greenlet-%d' % (self.minimal_ident,)
+
+    def _raise_exception(self):
+        reraise(*self.exc_info)
+
+    @property
+    def loop(self):
+        # needed by killall
+        hub = get_my_hub(self) # pylint:disable=undefined-variable
+        return hub.loop
+
+    def __bool__(self):
+        return self._start_event is not None and self._exc_info is None
+
+    ### Lifecycle
+
+    if _PYPY:
+        # oops - pypy's .dead relies on __nonzero__ which we overriden above
+        @property
+        def dead(self):
+            "Boolean indicating that the greenlet is dead and will not run again."
+            # pylint:disable=no-member
+            if self._greenlet__main:
+                return False
+            if self.__start_cancelled_by_kill() or self.__started_but_aborted():
+                return True
+
+            return self._greenlet__started and not _continulet.is_pending(self)
+    else:
+        @property
+        def dead(self):
+            """
+            Boolean indicating that the greenlet is dead and will not run again.
+
+            This is true if:
+
+            1. We were never started, but were :meth:`killed <kill>`
+               immediately after creation (not possible with :meth:`spawn`); OR
+            2. We were started, but were killed before running; OR
+            3. We have run and terminated (by raising an exception out of the
+               started function or by reaching the end of the started function).
+            """
+            return (
+                self.__start_cancelled_by_kill()
+                or self.__started_but_aborted()
+                or greenlet.dead.__get__(self)
+            )
+
+    def __never_started_or_killed(self):
+        return self._start_event is None
+
+    def __start_pending(self):
+        return (
+            self._start_event is not None
+            and (self._start_event.pending or getattr(self._start_event, 'active', False))
+        )
+
+    def __start_cancelled_by_kill(self):
+        return self._start_event is _cancelled_start_event
+
+    def __start_completed(self):
+        return self._start_event is _start_completed_event
+
+    def __started_but_aborted(self):
+        return (
+            not self.__never_started_or_killed() # we have been started or killed
+            and not self.__start_cancelled_by_kill() # we weren't killed, so we must have been started
+            and not self.__start_completed() # the start never completed
+            and not self.__start_pending() # and we're not pending, so we must have been aborted
+        )
+
+    def __cancel_start(self):
+        if self._start_event is None:
+            # prevent self from ever being started in the future
+            self._start_event = _cancelled_start_event
+        # cancel any pending start event
+        # NOTE: If this was a real pending start event, this will leave a
+        # "dangling" callback/timer object in the hub.loop.callbacks list;
+        # depending on where we are in the event loop, it may even be in a local
+        # variable copy of that list (in _run_callbacks). This isn't a problem,
+        # except for the leak-tests.
+        self._start_event.stop()
+        self._start_event.close()
+
+    def __handle_death_before_start(self, args):
+        # args is (t, v, tb) or simply t or v.
+        # The last two cases are transformed into (t, v, None);
+        # if the single argument is an exception type, a new instance
+        # is created; if the single argument is not an exception type and also
+        # not an exception, it is wrapped in a BaseException (this is not
+        # documented, but should result in better behaviour in the event of a
+        # user error---instead of silently printing something to stderr, we still
+        # kill the greenlet).
+        if self._exc_info is None and self.dead:
+            # the greenlet was never switched to before and it will
+            # never be; _report_error was not called, the result was
+            # not set, and the links weren't notified. Let's do it
+            # here.
+            #
+            # checking that self.dead is true is essential, because
+            # throw() does not necessarily kill the greenlet (if the
+            # exception raised by throw() is caught somewhere inside
+            # the greenlet).
+            if len(args) == 1:
+                arg = args[0]
+                if isinstance(arg, type) and issubclass(arg, BaseException):
+                    args = (arg, arg(), None)
+                else:
+                    args = (type(arg), arg, None)
+            elif not args:
+                args = (GreenletExit, GreenletExit(), None)
+            if not issubclass(args[0], BaseException):
+                # Random non-type, non-exception arguments.
+                args = (BaseException, BaseException(args), None)
+            assert issubclass(args[0], BaseException)
+            self.__report_error(args)
+
+    @property
+    def started(self):
+        # DEPRECATED
+        return bool(self)
+
+    def ready(self):
+        """
+        Return a true value if and only if the greenlet has finished
+        execution.
+
+        .. versionchanged:: 1.1
+            This function is only guaranteed to return true or false *values*, not
+            necessarily the literal constants ``True`` or ``False``.
+        """
+        return self.dead or self._exc_info is not None
+
+    def successful(self):
+        """
+        Return a true value if and only if the greenlet has finished execution
+        successfully, that is, without raising an error.
+
+        .. tip:: A greenlet that has been killed with the default
+            :class:`GreenletExit` exception is considered successful.
+            That is, ``GreenletExit`` is not considered an error.
+
+        .. note:: This function is only guaranteed to return true or false *values*,
+              not necessarily the literal constants ``True`` or ``False``.
+        """
+        return self._exc_info is not None and self._exc_info[1] is None
+
+    def __repr__(self):
+        classname = self.__class__.__name__
+        # If no name has been assigned, don't generate one, including a minimal_ident,
+        # if not necessary. This reduces the use of weak references and associated
+        # overhead.
+        if 'name' not in self.__dict__ and self._ident is None:
+            name = ' '
+        else:
+            name = ' "%s" ' % (self.name,)
+        result = '<%s%sat %s' % (classname, name, hex(id(self)))
+        formatted = self._formatinfo()
+        if formatted:
+            result += ': ' + formatted
+        return result + '>'
+
+
+    def _formatinfo(self):
+        info = self._formatted_info
+        if info is not None:
+            return info
+
+        # Are we running an arbitrary function provided to the constructor,
+        # or did a subclass override _run?
+        func = self._run
+        im_self = getattr(func, '__self__', None)
+        if im_self is self:
+            funcname = '_run'
+        elif im_self is not None:
+            funcname = repr(func)
+        else:
+            funcname = getattr(func, '__name__', '') or repr(func)
+
+        result = funcname
+        args = []
+        if self.args:
+            args = [repr(x)[:50] for x in self.args]
+        if self.kwargs:
+            args.extend(['%s=%s' % (key, repr(value)[:50]) for (key, value) in self.kwargs.items()])
+        if args:
+            result += '(' + ', '.join(args) + ')'
+        # it is important to save the result here, because once the greenlet exits '_run' attribute will be removed
+        self._formatted_info = result
+        return result
+
+    @property
+    def exception(self):
+        """
+        Holds the exception instance raised by the function if the
+        greenlet has finished with an error. Otherwise ``None``.
+        """
+        return self._exc_info[1] if self._exc_info is not None else None
+
+    @property
+    def exc_info(self):
+        """
+        Holds the exc_info three-tuple raised by the function if the
+        greenlet finished with an error. Otherwise a false value.
+
+        .. note:: This is a provisional API and may change.
+
+        .. versionadded:: 1.1
+        """
+        ei = self._exc_info
+        if ei is not None and ei[0] is not None:
+            return (
+                ei[0],
+                ei[1],
+                # The pickled traceback may be None if we couldn't pickle it.
+                load_traceback(ei[2]) if ei[2] else None
+            )
+
+    def throw(self, *args):
+        """Immediately switch into the greenlet and raise an exception in it.
+
+        Should only be called from the HUB, otherwise the current greenlet is left unscheduled forever.
+        To raise an exception in a safe manner from any greenlet, use :meth:`kill`.
+
+        If a greenlet was started but never switched to yet, then also
+        a) cancel the event that will start it
+        b) fire the notifications as if an exception was raised in a greenlet
+        """
+        self.__cancel_start()
+
+        try:
+            if not self.dead:
+                # Prevent switching into a greenlet *at all* if we had never
+                # started it. Usually this is the same thing that happens by throwing,
+                # but if this is done from the hub with nothing else running, prevents a
+                # LoopExit.
+                greenlet.throw(self, *args)
+        finally:
+            self.__handle_death_before_start(args)
+
+    def start(self):
+        """Schedule the greenlet to run in this loop iteration"""
+        if self._start_event is None:
+            _call_spawn_callbacks(self)
+            hub = get_my_hub(self) # pylint:disable=undefined-variable
+            self._start_event = hub.loop.run_callback(self.switch)
+
+    def start_later(self, seconds):
+        """
+        start_later(seconds) -> None
+
+        Schedule the greenlet to run in the future loop iteration
+        *seconds* later
+        """
+        if self._start_event is None:
+            _call_spawn_callbacks(self)
+            hub = get_my_hub(self) # pylint:disable=undefined-variable
+            self._start_event = hub.loop.timer(seconds)
+            self._start_event.start(self.switch)
+
+    @staticmethod
+    def add_spawn_callback(callback):
+        """
+        add_spawn_callback(callback) -> None
+
+        Set up a *callback* to be invoked when :class:`Greenlet` objects
+        are started.
+
+        The invocation order of spawn callbacks is unspecified.  Adding the
+        same callback more than one time will not cause it to be called more
+        than once.
+
+        .. versionadded:: 1.4.0
+        """
+        global _spawn_callbacks
+        if _spawn_callbacks is None:  # pylint:disable=used-before-assignment
+            _spawn_callbacks = set()
+        _spawn_callbacks.add(callback)
+
+    @staticmethod
+    def remove_spawn_callback(callback):
+        """
+        remove_spawn_callback(callback) -> None
+
+        Remove *callback* function added with :meth:`Greenlet.add_spawn_callback`.
+        This function will not fail if *callback* has been already removed or
+        if *callback* was never added.
+
+        .. versionadded:: 1.4.0
+        """
+        global _spawn_callbacks
+        if _spawn_callbacks is not None:
+            _spawn_callbacks.discard(callback)
+            if not _spawn_callbacks:
+                _spawn_callbacks = None
+
+    @classmethod
+    def spawn(cls, *args, **kwargs):
+        """
+        spawn(function, *args, **kwargs) -> Greenlet
+
+        Create a new :class:`Greenlet` object and schedule it to run ``function(*args, **kwargs)``.
+        This can be used as ``gevent.spawn`` or ``Greenlet.spawn``.
+
+        The arguments are passed to :meth:`Greenlet.__init__`.
+
+        .. versionchanged:: 1.1b1
+            If a *function* is given that is not callable, immediately raise a :exc:`TypeError`
+            instead of spawning a greenlet that will raise an uncaught TypeError.
+        """
+        g = cls(*args, **kwargs)
+        g.start()
+        return g
+
+    @classmethod
+    def spawn_later(cls, seconds, *args, **kwargs):
+        """
+        spawn_later(seconds, function, *args, **kwargs) -> Greenlet
+
+        Create and return a new `Greenlet` object scheduled to run ``function(*args, **kwargs)``
+        in a future loop iteration *seconds* later. This can be used as ``Greenlet.spawn_later``
+        or ``gevent.spawn_later``.
+
+        The arguments are passed to :meth:`Greenlet.__init__`.
+
+        .. versionchanged:: 1.1b1
+           If an argument that's meant to be a function (the first argument in *args*, or the ``run`` keyword )
+           is given to this classmethod (and not a classmethod of a subclass),
+           it is verified to be callable. Previously, the spawned greenlet would have failed
+           when it started running.
+        """
+        if cls is Greenlet and not args and 'run' not in kwargs:
+            raise TypeError("")
+        g = cls(*args, **kwargs)
+        g.start_later(seconds)
+        return g
+
+    def _maybe_kill_before_start(self, exception):
+        # Helper for Greenlet.kill(), and also for killall()
+        self.__cancel_start()
+        self.__free()
+        dead = self.dead
+        if dead:
+            if isinstance(exception, tuple) and len(exception) == 3:
+                args = exception
+            else:
+                args = (exception,)
+            self.__handle_death_before_start(args)
+        return dead
+
+    def kill(self, exception=GreenletExit, block=True, timeout=None):
+        """
+        Raise the ``exception`` in the greenlet.
+
+        If ``block`` is ``True`` (the default), wait until the greenlet
+        dies or the optional timeout expires; this may require switching
+        greenlets.
+        If block is ``False``, the current greenlet is not unscheduled.
+
+        This function always returns ``None`` and never raises an error. It
+        may be called multpile times on the same greenlet object, and may be
+        called on an unstarted or dead greenlet.
+
+        .. note::
+
+            Depending on what this greenlet is executing and the state
+            of the event loop, the exception may or may not be raised
+            immediately when this greenlet resumes execution. It may
+            be raised on a subsequent green call, or, if this greenlet
+            exits before making such a call, it may not be raised at
+            all. As of 1.1, an example where the exception is raised
+            later is if this greenlet had called :func:`sleep(0)
+            <gevent.sleep>`; an example where the exception is raised
+            immediately is if this greenlet had called
+            :func:`sleep(0.1) <gevent.sleep>`.
+
+        .. caution::
+
+            Use care when killing greenlets. If the code executing is not
+            exception safe (e.g., makes proper use of ``finally``) then an
+            unexpected exception could result in corrupted state. Using
+            a :meth:`link` or :meth:`rawlink` (cheaper) may be a safer way to
+            clean up resources.
+
+        See also :func:`gevent.kill` and :func:`gevent.killall`.
+
+        :keyword type exception: The type of exception to raise in the greenlet. The default
+            is :class:`GreenletExit`, which indicates a :meth:`successful` completion
+            of the greenlet.
+
+        .. versionchanged:: 0.13.0
+            *block* is now ``True`` by default.
+        .. versionchanged:: 1.1a2
+            If this greenlet had never been switched to, killing it will
+            prevent it from *ever* being switched to. Links (:meth:`rawlink`)
+            will still be executed, though.
+        .. versionchanged:: 20.12.1
+            If this greenlet is :meth:`ready`, immediately return instead of
+            requiring a trip around the event loop.
+        """
+        if not self._maybe_kill_before_start(exception):
+            if self.ready():
+                return
+
+            waiter = Waiter() if block else None # pylint:disable=undefined-variable
+            hub = get_my_hub(self) # pylint:disable=undefined-variable
+            hub.loop.run_callback(_kill, self, exception, waiter)
+            if waiter is not None:
+                waiter.get()
+                self.join(timeout)
+
+    def get(self, block=True, timeout=None):
+        """
+        get(block=True, timeout=None) -> object
+
+        Return the result the greenlet has returned or re-raise the
+        exception it has raised.
+
+        If block is ``False``, raise :class:`gevent.Timeout` if the
+        greenlet is still alive. If block is ``True``, unschedule the
+        current greenlet until the result is available or the timeout
+        expires. In the latter case, :class:`gevent.Timeout` is
+        raised.
+        """
+        if self.ready():
+            if self.successful():
+                return self.value
+            self._raise_exception()
+        if not block:
+            raise Timeout()
+
+        switch = getcurrent().switch # pylint:disable=undefined-variable
+        self.rawlink(switch)
+        try:
+            t = Timeout._start_new_or_dummy(timeout)
+            try:
+                result = get_my_hub(self).switch() # pylint:disable=undefined-variable
+                if result is not self:
+                    raise InvalidSwitchError('Invalid switch into Greenlet.get(): %r' % (result, ))
+            finally:
+                t.cancel()
+        except:
+            # unlinking in 'except' instead of finally is an optimization:
+            # if switch occurred normally then link was already removed in _notify_links
+            # and there's no need to touch the links set.
+            # Note, however, that if "Invalid switch" assert was removed and invalid switch
+            # did happen, the link would remain, causing another invalid switch later in this greenlet.
+            self.unlink(switch)
+            raise
+
+        if self.ready():
+            if self.successful():
+                return self.value
+            self._raise_exception()
+
+    def join(self, timeout=None):
+        """
+        join(timeout=None) -> None
+
+        Wait until the greenlet finishes or *timeout* expires. Return
+        ``None`` regardless.
+        """
+        if self.ready():
+            return
+
+        switch = getcurrent().switch # pylint:disable=undefined-variable
+        self.rawlink(switch)
+        try:
+            t = Timeout._start_new_or_dummy(timeout)
+            try:
+                result = get_my_hub(self).switch() # pylint:disable=undefined-variable
+                if result is not self:
+                    raise InvalidSwitchError('Invalid switch into Greenlet.join(): %r' % (result, ))
+            finally:
+                t.cancel()
+        except Timeout as ex:
+            self.unlink(switch)
+            if ex is not t:
+                raise
+        except:
+            self.unlink(switch)
+            raise
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, t, v, tb):
+        if t is None:
+            try:
+                self.join()
+            finally:
+                self.kill()
+        else:
+            self.kill((t, v, tb))
+
+    def __report_result(self, result):
+        self._exc_info = (None, None, None)
+        self.value = result
+        if self._links and not self._notifier:
+            hub = get_my_hub(self) # pylint:disable=undefined-variable
+            self._notifier = hub.loop.run_callback(self._notify_links)
+
+    def __report_error(self, exc_info):
+        if isinstance(exc_info[1], GreenletExit):
+            self.__report_result(exc_info[1])
+            return
+
+        # Depending on the error, we may not be able to pickle it.
+        # In particular, RecursionError can be a problem.
+        try:
+            tb = dump_traceback(exc_info[2])
+        except: # pylint:disable=bare-except
+            tb = None
+        self._exc_info = exc_info[0], exc_info[1], tb
+
+        hub = get_my_hub(self) # pylint:disable=undefined-variable
+        if self._links and not self._notifier:
+            self._notifier = hub.loop.run_callback(self._notify_links)
+
+        try:
+            hub.handle_error(self, *exc_info)
+        finally:
+            del exc_info
+
+    def run(self):
+        try:
+            self.__cancel_start()
+            self._start_event = _start_completed_event
+
+            try:
+                result = self._run(*self.args, **self.kwargs)
+            except: # pylint:disable=bare-except
+                self.__report_error(sys_exc_info())
+            else:
+                self.__report_result(result)
+        finally:
+            self.__free()
+
+    def __free(self):
+        try:
+            # It seems that Cython 0.29.13 sometimes miscompiles
+            # self.__dict__.pop('_run', None) ? When we moved this out of the
+            # inline finally: block in run(), we started getting strange
+            # exceptions from places that subclassed Greenlet.
+            del self._run
+        except AttributeError:
+            pass
+        self.args = ()
+        self.kwargs.clear()
+
+    def _run(self):
+        """
+        Subclasses may override this method to take any number of
+        arguments and keyword arguments.
+
+        .. versionadded:: 1.1a3
+            Previously, if no callable object was
+            passed to the constructor, the spawned greenlet would later
+            fail with an AttributeError.
+        """
+        # We usually override this in __init__
+        # pylint: disable=method-hidden
+        return
+
+    def has_links(self):
+        return len(self._links)
+
+    def rawlink(self, callback):
+        """
+        Register a callable to be executed when the greenlet finishes
+        execution.
+
+        The *callback* will be called with this instance as an
+        argument.
+
+        The *callback* will be called even if linked after the greenlet
+        is already ready().
+
+        .. caution::
+            The *callback* will be called in the hub and
+            **MUST NOT** raise an exception.
+        """
+        if not callable(callback):
+            raise TypeError('Expected callable: %r' % (callback, ))
+        self._links.append(callback) # pylint:disable=no-member
+        if self.ready() and self._links and not self._notifier:
+            hub = get_my_hub(self) # pylint:disable=undefined-variable
+            self._notifier = hub.loop.run_callback(self._notify_links)
+
+    def link(self, callback, SpawnedLink=SpawnedLink):
+        """
+        Link greenlet's completion to a callable.
+
+        The *callback* will be called with this instance as an
+        argument once this greenlet is dead. A callable is called in
+        its own :class:`greenlet.greenlet` (*not* a
+        :class:`Greenlet`).
+
+        The *callback* will be called even if linked after the greenlet
+        is already ready().
+        """
+        # XXX: Is the redefinition of SpawnedLink supposed to just be an
+        # optimization, or do people use it? It's not documented
+        # pylint:disable=redefined-outer-name
+        self.rawlink(SpawnedLink(callback))
+
+    def unlink(self, callback):
+        """Remove the callback set by :meth:`link` or :meth:`rawlink`"""
+        try:
+            self._links.remove(callback) # pylint:disable=no-member
+        except ValueError:
+            pass
+
+    def unlink_all(self):
+        """
+        Remove all the callbacks.
+
+        .. versionadded:: 1.3a2
+        """
+        del self._links[:]
+
+    def link_value(self, callback, SpawnedLink=SuccessSpawnedLink):
+        """
+        Like :meth:`link` but *callback* is only notified when the greenlet
+        has completed successfully.
+        """
+        # pylint:disable=redefined-outer-name
+        self.link(callback, SpawnedLink=SpawnedLink)
+
+    def link_exception(self, callback, SpawnedLink=FailureSpawnedLink):
+        """
+        Like :meth:`link` but *callback* is only notified when the
+        greenlet dies because of an unhandled exception.
+        """
+        # pylint:disable=redefined-outer-name
+        self.link(callback, SpawnedLink=SpawnedLink)
+
+    def _notify_links(self):
+        while self._links:
+            # Early links are allowed to remove later links
+            # before we get to them, and they're also allowed to
+            # add new links, so we have to be careful about iterating.
+
+            # We don't expect this list to be very large, so the time spent
+            # manipulating it should be small. a deque is probably not justified.
+            # Cython has optimizations to transform this into a memmove anyway.
+            link = self._links.pop(0)
+            try:
+                link(self)
+            except: # pylint:disable=bare-except, undefined-variable
+                get_my_hub(self).handle_error((link, self), *sys_exc_info())
+
+
+class _dummy_event(object):
+    __slots__ = ('pending', 'active')
+
+    def __init__(self):
+        self.pending = self.active = False
+
+    def stop(self):
+        pass
+
+    def start(self, cb): # pylint:disable=unused-argument
+        raise AssertionError("Cannot start the dummy event")
+
+    def close(self):
+        pass
+
+_cancelled_start_event = _dummy_event()
+_start_completed_event = _dummy_event()
+
+
+# This is *only* called as a callback from the hub via Greenlet.kill(),
+# and its first argument is the Greenlet. So we can be sure about the types.
+def _kill(glet, exception, waiter):
+    try:
+        if isinstance(exception, tuple) and len(exception) == 3:
+            glet.throw(*exception)
+        else:
+            glet.throw(exception)
+    except: # pylint:disable=bare-except, undefined-variable
+        # XXX do we need this here?
+        get_my_hub(glet).handle_error(glet, *sys_exc_info())
+    if waiter is not None:
+        waiter.switch(None)
+
+
+def joinall(greenlets, timeout=None, raise_error=False, count=None):
+    """
+    Wait for the ``greenlets`` to finish.
+
+    :param greenlets: A sequence (supporting :func:`len`) of greenlets to wait for.
+    :keyword float timeout: If given, the maximum number of seconds to wait.
+    :return: A sequence of the greenlets that finished before the timeout (if any)
+        expired.
+    """
+    if not raise_error:
+        return wait(greenlets, timeout=timeout, count=count)
+
+    done = []
+    for obj in iwait(greenlets, timeout=timeout, count=count):
+        if getattr(obj, 'exception', None) is not None:
+            if hasattr(obj, '_raise_exception'):
+                obj._raise_exception()
+            else:
+                raise obj.exception
+        done.append(obj)
+    return done
+
+
+def _killall3(greenlets, exception, waiter):
+    diehards = []
+    for g in greenlets:
+        if not g.dead:
+            try:
+                g.throw(exception)
+            except: # pylint:disable=bare-except, undefined-variable
+                get_my_hub(g).handle_error(g, *sys_exc_info())
+            if not g.dead:
+                diehards.append(g)
+    waiter.switch(diehards)
+
+
+def _killall(greenlets, exception):
+    for g in greenlets:
+        if not g.dead:
+            try:
+                g.throw(exception)
+            except: # pylint:disable=bare-except, undefined-variable
+                get_my_hub(g).handle_error(g, *sys_exc_info())
+
+
+def _call_spawn_callbacks(gr):
+    if _spawn_callbacks is not None:
+        for cb in _spawn_callbacks:
+            cb(gr)
+
+
+_spawn_callbacks = None
+
+
+def killall(greenlets, exception=GreenletExit, block=True, timeout=None):
+    """
+    Forceably terminate all the *greenlets* by causing them to raise *exception*.
+
+    .. caution:: Use care when killing greenlets. If they are not prepared for exceptions,
+       this could result in corrupted state.
+
+    :param greenlets: A **bounded** iterable of the non-None greenlets to terminate.
+       *All* the items in this iterable must be greenlets that belong to the same hub,
+       which should be the hub for this current thread. If this is a generator or iterator
+       that switches greenlets, the results are undefined.
+    :keyword exception: The type of exception to raise in the greenlets. By default this is
+        :class:`GreenletExit`.
+    :keyword bool block: If True (the default) then this function only returns when all the
+        greenlets are dead; the current greenlet is unscheduled during that process.
+        If greenlets ignore the initial exception raised in them,
+        then they will be joined (with :func:`gevent.joinall`) and allowed to die naturally.
+        If False, this function returns immediately and greenlets will raise
+        the exception asynchronously.
+    :keyword float timeout: A time in seconds to wait for greenlets to die. If given, it is
+        only honored when ``block`` is True.
+    :raise Timeout: If blocking and a timeout is given that elapses before
+        all the greenlets are dead.
+
+    .. versionchanged:: 1.1a2
+        *greenlets* can be any iterable of greenlets, like an iterator or a set.
+        Previously it had to be a list or tuple.
+    .. versionchanged:: 1.5a3
+        Any :class:`Greenlet` in the *greenlets* list that hadn't been switched to before
+        calling this method will never be switched to. This makes this function
+        behave like :meth:`Greenlet.kill`. This does not apply to raw greenlets.
+    .. versionchanged:: 1.5a3
+        Now accepts raw greenlets created by :func:`gevent.spawn_raw`.
+    """
+
+    need_killed = []
+    for glet in greenlets:
+        # Quick pass through to prevent any greenlet from
+        # actually being switched to if it hasn't already.
+        # (Previously we called ``list(greenlets)`` so we're still
+        # linear.)
+        #
+        # We don't use glet.kill() here because we don't want to schedule
+        # any callbacks in the loop; we're about to handle that more directly.
+        try:
+            cancel = glet._maybe_kill_before_start
+        except AttributeError:
+            need_killed.append(glet)
+        else:
+            if not cancel(exception):
+                need_killed.append(glet)
+
+    if not need_killed:
+        return
+
+    loop = glet.loop # pylint:disable=undefined-loop-variable
+    if block:
+        waiter = Waiter() # pylint:disable=undefined-variable
+        loop.run_callback(_killall3, need_killed, exception, waiter)
+        t = Timeout._start_new_or_dummy(timeout)
+        try:
+            alive = waiter.get()
+            if alive:
+                joinall(alive, raise_error=False)
+        finally:
+            t.cancel()
+    else:
+        loop.run_callback(_killall, need_killed, exception)
+
+def _init():
+    greenlet_init() # pylint:disable=undefined-variable
+
+_init()
+
+from gevent._util import import_c_accel
+import_c_accel(globals(), 'gevent._greenlet')

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/hub.py

@@ -0,0 +1,909 @@
+# Copyright (c) 2009-2015 Denis Bilenko. See LICENSE for details.
+"""
+Event-loop hub.
+"""
+from __future__ import absolute_import, print_function
+# XXX: FIXME: Refactor to make this smaller
+# pylint:disable=too-many-lines
+from functools import partial as _functools_partial
+
+import sys
+import traceback
+
+
+from greenlet import greenlet as RawGreenlet
+from greenlet import getcurrent
+from greenlet import GreenletExit
+from greenlet import error as GreenletError
+
+__all__ = [
+    'getcurrent',
+    'GreenletExit',
+    'spawn_raw',
+    'sleep',
+    'kill',
+    'signal',
+    'reinit',
+    'get_hub',
+    'Hub',
+    'Waiter',
+]
+
+from gevent._config import config as GEVENT_CONFIG
+from gevent._compat import thread_mod_name
+from gevent._compat import reraise
+from gevent._util import readproperty
+from gevent._util import Lazy
+from gevent._util import gmctime
+from gevent._ident import IdentRegistry
+
+from gevent._hub_local import get_hub
+from gevent._hub_local import get_loop
+from gevent._hub_local import set_hub
+from gevent._hub_local import set_loop
+from gevent._hub_local import get_hub_if_exists as _get_hub
+from gevent._hub_local import get_hub_noargs as _get_hub_noargs
+from gevent._hub_local import set_default_hub_class
+
+from gevent._greenlet_primitives import TrackedRawGreenlet
+from gevent._hub_primitives import WaitOperationsGreenlet
+
+# Export
+from gevent import _hub_primitives
+wait = _hub_primitives.wait_on_objects
+iwait = _hub_primitives.iwait_on_objects
+
+
+from gevent.exceptions import LoopExit
+from gevent.exceptions import HubDestroyed
+
+from gevent._waiter import Waiter
+
+
+# Need the real get_ident. We're imported early enough (by gevent/__init__.py)
+# that we can be sure nothing is monkey patched yet.
+get_thread_ident = __import__(thread_mod_name).get_ident
+MAIN_THREAD_IDENT = get_thread_ident() # XXX: Assuming import is done on the main thread.
+
+
+
+def spawn_raw(function, *args, **kwargs):
+    """
+    Create a new :class:`greenlet.greenlet` object and schedule it to
+    run ``function(*args, **kwargs)``.
+
+    This returns a raw :class:`~greenlet.greenlet` which does not have all the useful
+    methods that :class:`gevent.Greenlet` has. Typically, applications
+    should prefer :func:`~gevent.spawn`, but this method may
+    occasionally be useful as an optimization if there are many
+    greenlets involved.
+
+    .. versionchanged:: 1.1a3
+        Verify that ``function`` is callable, raising a TypeError if not. Previously,
+        the spawned greenlet would have failed the first time it was switched to.
+
+    .. versionchanged:: 1.1b1
+       If *function* is not callable, immediately raise a :exc:`TypeError`
+       instead of spawning a greenlet that will raise an uncaught TypeError.
+
+    .. versionchanged:: 1.1rc2
+        Accept keyword arguments for ``function`` as previously (incorrectly)
+        documented. Note that this may incur an additional expense.
+
+    .. versionchanged:: 1.3a2
+       Populate the ``spawning_greenlet`` and ``spawn_tree_locals``
+       attributes of the returned greenlet.
+
+    .. versionchanged:: 1.3b1
+       *Only* populate ``spawning_greenlet`` and ``spawn_tree_locals``
+       if ``GEVENT_TRACK_GREENLET_TREE`` is enabled (the default). If not enabled,
+       those attributes will not be set.
+
+    .. versionchanged:: 1.5a3
+       The returned greenlet always has a *loop* attribute matching the
+       current hub's loop. This helps it work better with more gevent APIs.
+    """
+    if not callable(function):
+        raise TypeError("function must be callable")
+
+    # The hub is always the parent.
+    hub = _get_hub_noargs()
+    loop = hub.loop
+
+    factory = TrackedRawGreenlet if GEVENT_CONFIG.track_greenlet_tree else RawGreenlet
+
+    # The callback class object that we use to run this doesn't
+    # accept kwargs (and those objects are heavily used, as well as being
+    # implemented twice in core.ppyx and corecffi.py) so do it with a partial
+    if kwargs:
+        function = _functools_partial(function, *args, **kwargs)
+        g = factory(function, hub)
+        loop.run_callback(g.switch)
+    else:
+        g = factory(function, hub)
+        loop.run_callback(g.switch, *args)
+    g.loop = hub.loop
+    return g
+
+
+def sleep(seconds=0, ref=True):
+    """
+    Put the current greenlet to sleep for at least *seconds*.
+
+    *seconds* may be specified as an integer, or a float if fractional
+    seconds are desired.
+
+    .. tip:: In the current implementation, a value of 0 (the default)
+       means to yield execution to any other runnable greenlets, but
+       this greenlet may be scheduled again before the event loop
+       cycles (in an extreme case, a greenlet that repeatedly sleeps
+       with 0 can prevent greenlets that are ready to do I/O from
+       being scheduled for some (small) period of time); a value greater than
+       0, on the other hand, will delay running this greenlet until
+       the next iteration of the loop.
+
+    If *ref* is False, the greenlet running ``sleep()`` will not prevent :func:`gevent.wait`
+    from exiting.
+
+    .. versionchanged:: 1.3a1
+       Sleeping with a value of 0 will now be bounded to approximately block the
+       loop for no longer than :func:`gevent.getswitchinterval`.
+
+    .. seealso:: :func:`idle`
+    """
+    hub = _get_hub_noargs()
+    loop = hub.loop
+    if seconds <= 0:
+        waiter = Waiter(hub)
+        loop.run_callback(waiter.switch, None)
+        waiter.get()
+    else:
+        with loop.timer(seconds, ref=ref) as t:
+            # Sleeping is expected to be an "absolute" measure with
+            # respect to time.time(), not a relative measure, so it's
+            # important to update the loop's notion of now before we start
+            loop.update_now()
+            hub.wait(t)
+
+
+def idle(priority=0):
+    """
+    Cause the calling greenlet to wait until the event loop is idle.
+
+    Idle is defined as having no other events of the same or higher
+    *priority* pending. That is, as long as sockets, timeouts or even
+    signals of the same or higher priority are being processed, the loop
+    is not idle.
+
+    .. seealso:: :func:`sleep`
+    """
+    hub = _get_hub_noargs()
+    with hub.loop.idle() as watcher:
+        if priority:
+            watcher.priority = priority
+        hub.wait(watcher)
+
+
+def kill(greenlet, exception=GreenletExit):
+    """
+    Kill greenlet asynchronously. The current greenlet is not unscheduled.
+
+    .. note::
+
+        The method :meth:`Greenlet.kill` method does the same and
+        more (and the same caveats listed there apply here). However, the MAIN
+        greenlet - the one that exists initially - does not have a
+        ``kill()`` method, and neither do any created with :func:`spawn_raw`,
+        so you have to use this function.
+
+    .. caution:: Use care when killing greenlets. If they are not prepared for
+       exceptions, this could result in corrupted state.
+
+    .. versionchanged:: 1.1a2
+        If the ``greenlet`` has a :meth:`kill <Greenlet.kill>` method, calls it. This prevents a
+        greenlet from being switched to for the first time after it's been
+        killed but not yet executed.
+    """
+    if not greenlet.dead:
+        if hasattr(greenlet, 'kill'):
+            # dealing with gevent.greenlet.Greenlet. Use it, especially
+            # to avoid allowing one to be switched to for the first time
+            # after it's been killed
+            greenlet.kill(exception=exception, block=False)
+        else:
+            _get_hub_noargs().loop.run_callback(greenlet.throw, exception)
+
+
+class signal(object):
+    """
+    signal_handler(signalnum, handler, *args, **kwargs) -> object
+
+    Call the *handler* with the *args* and *kwargs* when the process
+    receives the signal *signalnum*.
+
+    The *handler* will be run in a new greenlet when the signal is
+    delivered.
+
+    This returns an object with the useful method ``cancel``, which,
+    when called, will prevent future deliveries of *signalnum* from
+    calling *handler*. It's best to keep the returned object alive
+    until you call ``cancel``.
+
+    .. note::
+
+        This may not operate correctly with ``SIGCHLD`` if libev child
+        watchers are used (as they are by default with
+        `gevent.os.fork`). See :mod:`gevent.signal` for a more
+        general purpose solution.
+
+    .. versionchanged:: 1.2a1
+
+        The ``handler`` argument is required to
+        be callable at construction time.
+
+    .. versionchanged:: 20.5.1
+       The ``cancel`` method now properly cleans up all native resources,
+       and drops references to all the arguments of this function.
+    """
+    # This is documented as a function, not a class,
+    # so we're free to change implementation details.
+
+    greenlet_class = None
+
+    def __init__(self, signalnum, handler, *args, **kwargs):
+        if not callable(handler):
+            raise TypeError("signal handler must be callable.")
+
+        self.hub = _get_hub_noargs()
+        self.watcher = self.hub.loop.signal(signalnum, ref=False)
+        self.handler = handler
+        self.args = args
+        self.kwargs = kwargs
+        if self.greenlet_class is None:
+            from gevent import Greenlet
+            type(self).greenlet_class = Greenlet
+            self.greenlet_class = Greenlet
+
+        self.watcher.start(self._start)
+
+    ref = property(
+        lambda self: self.watcher.ref,
+        lambda self, nv: setattr(self.watcher, 'ref', nv)
+    )
+
+    def cancel(self):
+        if self.watcher is not None:
+            self.watcher.stop()
+            # Must close the watcher at a deterministic time, otherwise
+            # when CFFI reclaims the memory, the native loop might still
+            # have some reference to it; if anything tries to touch it
+            # we can wind up writing to memory that is no longer valid,
+            # leading to a wide variety of crashes.
+            self.watcher.close()
+        self.watcher = None
+        self.handler = None
+        self.args = None
+        self.kwargs = None
+        self.hub = None
+        self.greenlet_class = None
+
+    def _start(self):
+        # TODO: Maybe this should just be Greenlet.spawn()?
+        try:
+            greenlet = self.greenlet_class(self.handle)
+            greenlet.switch()
+        except: # pylint:disable=bare-except
+            self.hub.handle_error(None, *sys._exc_info()) # pylint:disable=no-member
+
+    def handle(self):
+        try:
+            self.handler(*self.args, **self.kwargs)
+        except: # pylint:disable=bare-except
+            self.hub.handle_error(None, *sys.exc_info())
+
+
+def reinit(hub=None):
+    """
+    reinit() -> None
+
+    Prepare the gevent hub to run in a new (forked) process.
+
+    This should be called *immediately* after :func:`os.fork` in the
+    child process. This is done automatically by
+    :func:`gevent.os.fork` or if the :mod:`os` module has been
+    monkey-patched. If this function is not called in a forked
+    process, symptoms may include hanging of functions like
+    :func:`socket.getaddrinfo`, and the hub's threadpool is unlikely
+    to work.
+
+    .. note:: Registered fork watchers may or may not run before
+       this function (and thus ``gevent.os.fork``) return. If they have
+       not run, they will run "soon", after an iteration of the event loop.
+       You can force this by inserting a few small (but non-zero) calls to :func:`sleep`
+       after fork returns. (As of gevent 1.1 and before, fork watchers will
+       not have run, but this may change in the future.)
+
+    .. note:: This function may be removed in a future major release
+       if the fork process can be more smoothly managed.
+
+    .. warning:: See remarks in :func:`gevent.os.fork` about greenlets
+       and event loop watchers in the child process.
+    """
+    # Note the signature line in the docstring: hub is not a public param.
+
+    # The loop reinit function in turn calls libev's ev_loop_fork
+    # function.
+    hub = _get_hub() if hub is None else hub
+    if hub is None:
+        return
+
+    # Note that we reinit the existing loop, not destroy it.
+    # See https://github.com/gevent/gevent/issues/200.
+    hub.loop.reinit()
+    # libev's fork watchers are slow to fire because the only fire
+    # at the beginning of a loop; due to our use of callbacks that
+    # run at the end of the loop, that may be too late. The
+    # threadpool and resolvers depend on the fork handlers being
+    # run (specifically, the threadpool will fail in the forked
+    # child if there were any threads in it, which there will be
+    # if the resolver_thread was in use (the default) before the
+    # fork.)
+    #
+    # If the forked process wants to use the threadpool or
+    # resolver immediately (in a queued callback), it would hang.
+    #
+    # The below is a workaround. Fortunately, all of these
+    # methods are idempotent and can be called multiple times
+    # following a fork if the suddenly started working, or were
+    # already working on some platforms. Other threadpools and fork handlers
+    # will be called at an arbitrary time later ('soon')
+    for obj in (hub._threadpool, hub._resolver, hub.periodic_monitoring_thread):
+        getattr(obj, '_on_fork', lambda: None)()
+
+    # TODO: We'd like to sleep for a non-zero amount of time to force the loop to make a
+    # pass around before returning to this greenlet. That will allow any
+    # user-provided fork watchers to run. (Two calls are necessary.) HOWEVER, if
+    # we do this, certain tests that heavily mix threads and forking,
+    # like 2.7/test_threading:test_reinit_tls_after_fork, fail. It's not immediately clear
+    # why.
+    #sleep(0.00001)
+    #sleep(0.00001)
+
+
+class Hub(WaitOperationsGreenlet):
+    """
+    A greenlet that runs the event loop.
+
+    It is created automatically by :func:`get_hub`.
+
+    .. rubric:: Switching
+
+    Every time this greenlet (i.e., the event loop) is switched *to*,
+    if the current greenlet has a ``switch_out`` method, it will be
+    called. This allows a greenlet to take some cleanup actions before
+    yielding control. This method should not call any gevent blocking
+    functions.
+    """
+
+    #: If instances of these classes are raised into the event loop,
+    #: they will be propagated out to the main greenlet (where they will
+    #: usually be caught by Python itself)
+    SYSTEM_ERROR = (KeyboardInterrupt, SystemExit, SystemError)
+
+    #: Instances of these classes are not considered to be errors and
+    #: do not get logged/printed when raised by the event loop.
+    NOT_ERROR = (GreenletExit, SystemExit)
+
+    #: The size we use for our threadpool. Either use a subclass
+    #: for this, or change it immediately after creating the hub.
+    threadpool_size = 10
+
+    # An instance of PeriodicMonitoringThread, if started.
+    periodic_monitoring_thread = None
+
+    # The ident of the thread we were created in, which should be the
+    # thread that we run in.
+    thread_ident = None
+
+    #: A string giving the name of this hub. Useful for associating hubs
+    #: with particular threads. Printed as part of the default repr.
+    #:
+    #: .. versionadded:: 1.3b1
+    name = ''
+
+    # NOTE: We cannot define a class-level 'loop' attribute
+    # because that conflicts with the slot we inherit from the
+    # Cythonized-bases.
+
+    # This is the source for our 'minimal_ident' property. We don't use a
+    # IdentRegistry because we've seen some crashes having to do with
+    # clearing weak references on shutdown in Windows (see known_failures.py).
+    # This gives us slightly different semantics than a greenlet's minimal_ident
+    # (notably, there can be holes) but we never documented this object's minimal_ident,
+    # and there should be few enough hub's over the lifetime of a process so as not
+    # to matter much.
+    _hub_counter = 0
+
+    def __init__(self, loop=None, default=None):
+        WaitOperationsGreenlet.__init__(self, None, None)
+        self.thread_ident = get_thread_ident()
+        if hasattr(loop, 'run'):
+            if default is not None:
+                raise TypeError("Unexpected argument: default")
+            self.loop = loop
+        elif get_loop() is not None:
+            # Reuse a loop instance previously set by
+            # destroying a hub without destroying the associated
+            # loop. See #237 and #238.
+            self.loop = get_loop()
+        else:
+            if default is None and self.thread_ident != MAIN_THREAD_IDENT:
+                default = False
+
+            if loop is None:
+                loop = self.backend
+            self.loop = self.loop_class(flags=loop, default=default) # pylint:disable=not-callable
+        self._resolver = None
+        self._threadpool = None
+        self.format_context = GEVENT_CONFIG.format_context
+
+        Hub._hub_counter += 1
+        self.minimal_ident = Hub._hub_counter
+
+    @Lazy
+    def ident_registry(self):
+        return IdentRegistry()
+
+    @property
+    def loop_class(self):
+        return GEVENT_CONFIG.loop
+
+    @property
+    def backend(self):
+        return GEVENT_CONFIG.libev_backend
+
+    @property
+    def main_hub(self):
+        """
+        Is this the hub for the main thread?
+
+        .. versionadded:: 1.3b1
+        """
+        return self.thread_ident == MAIN_THREAD_IDENT
+
+    def __repr__(self):
+        if self.loop is None:
+            info = 'destroyed'
+        else:
+            try:
+                info = self.loop._format()
+            except Exception as ex: # pylint:disable=broad-except
+                info = str(ex) or repr(ex) or 'error'
+        result = '<%s %r at 0x%x %s' % (
+            self.__class__.__name__,
+            self.name,
+            id(self),
+            info)
+        if self._resolver is not None:
+            result += ' resolver=%r' % self._resolver
+        if self._threadpool is not None:
+            result += ' threadpool=%r' % self._threadpool
+        result += ' thread_ident=%s' % (hex(self.thread_ident), )
+        return result + '>'
+
+    def _normalize_exception(self, t, v, tb):
+        # Allow passing in all None if the caller doesn't have
+        # easy access to sys.exc_info()
+        if (t, v, tb) == (None, None, None):
+            t, v, tb = sys.exc_info()
+
+        if isinstance(v, str):
+            # Cython can raise errors where the value is a plain string
+            # e.g., AttributeError, "_semaphore.Semaphore has no attr", <traceback>
+            v = t(v)
+
+        return t, v, tb
+
+    def handle_error(self, context, type, value, tb):
+        """
+        Called by the event loop when an error occurs. The default
+        action is to print the exception to the :attr:`exception
+        stream <exception_stream>`.
+
+        The arguments ``type``, ``value``, and ``tb`` are the standard
+        tuple as returned by :func:`sys.exc_info`. (Note that when
+        this is called, it may not be safe to call
+        :func:`sys.exc_info`.)
+
+        Errors that are :attr:`not errors <NOT_ERROR>` are not
+        printed.
+
+        Errors that are :attr:`system errors <SYSTEM_ERROR>` are
+        passed to :meth:`handle_system_error` after being printed.
+
+        Applications can set a property on the hub instance with this
+        same signature to override the error handling provided by this
+        class. This is an advanced usage and requires great care. This
+        function *must not* raise any exceptions.
+
+        :param context: If this is ``None``, indicates a system error
+            that should generally result in exiting the loop and being
+            thrown to the parent greenlet.
+        """
+        type, value, tb = self._normalize_exception(type, value, tb)
+
+        if type is HubDestroyed:
+            # We must continue propagating this for it to properly
+            # exit.
+            reraise(type, value, tb)
+
+        if not issubclass(type, self.NOT_ERROR):
+            self.print_exception(context, type, value, tb)
+        if context is None or issubclass(type, self.SYSTEM_ERROR):
+            self.handle_system_error(type, value, tb)
+
+    def handle_system_error(self, type, value, tb=None):
+        """
+        Called from `handle_error` when the exception type is determined
+        to be a :attr:`system error <SYSTEM_ERROR>`.
+
+        System errors cause the exception to be raised in the main
+        greenlet (the parent of this hub).
+
+        .. versionchanged:: 20.5.1
+           Allow passing the traceback to associate with the
+           exception if it is rethrown into the main greenlet.
+        """
+        current = getcurrent()
+        if current is self or current is self.parent or self.loop is None:
+            self.parent.throw(type, value, tb)
+        else:
+            # in case system error was handled and life goes on
+            # switch back to this greenlet as well
+            cb = None
+            try:
+                cb = self.loop.run_callback(current.switch)
+            except: # pylint:disable=bare-except
+                traceback.print_exc(file=self.exception_stream)
+            try:
+                self.parent.throw(type, value, tb)
+            finally:
+                if cb is not None:
+                    cb.stop()
+
+    @readproperty
+    def exception_stream(self):
+        """
+        The stream to which exceptions will be written.
+        Defaults to ``sys.stderr`` unless assigned. Assigning a
+        false (None) value disables printing exceptions.
+
+        .. versionadded:: 1.2a1
+        """
+        # Unwrap any FileObjectThread we have thrown around sys.stderr
+        # (because it can't be used in the hub). Tricky because we are
+        # called in error situations when it's not safe to import.
+        # Be careful not to access sys if we're in the process of interpreter
+        # shutdown.
+        stderr = sys.stderr if sys else None # pylint:disable=using-constant-test
+        if type(stderr).__name__ == 'FileObjectThread':
+            stderr = stderr.io # pylint:disable=no-member
+        return stderr
+
+    def print_exception(self, context, t, v, tb):
+        # Python 3 does not gracefully handle None value or tb in
+        # traceback.print_exception() as previous versions did.
+        # pylint:disable=no-member
+        errstream = self.exception_stream
+        if not errstream: # pragma: no cover
+            # If the error stream is gone, such as when the sys dict
+            # gets cleared during interpreter shutdown,
+            # don't cause follow-on errors.
+            # See https://github.com/gevent/gevent/issues/1295
+            return
+
+        t, v, tb = self._normalize_exception(t, v, tb)
+
+        if v is None:
+            errstream.write('%s\n' % t.__name__)
+        else:
+            traceback.print_exception(t, v, tb, file=errstream)
+        del tb
+
+        try:
+            errstream.write(gmctime())
+            errstream.write(' ' if context is not None else '\n')
+        except: # pylint:disable=bare-except
+            # Possible not safe to import under certain
+            # error conditions in Python 2
+            pass
+
+        if context is not None:
+            if not isinstance(context, str):
+                try:
+                    context = self.format_context(context)
+                except: # pylint:disable=bare-except
+                    traceback.print_exc(file=self.exception_stream)
+                    context = repr(context)
+            errstream.write('%s failed with %s\n\n' % (context, getattr(t, '__name__', 'exception'), ))
+
+
+    def run(self):
+        """
+        Entry-point to running the loop. This method is called automatically
+        when the hub greenlet is scheduled; do not call it directly.
+
+        :raises gevent.exceptions.LoopExit: If the loop finishes running. This means
+           that there are no other scheduled greenlets, and no active
+           watchers or servers. In some situations, this indicates a
+           programming error.
+        """
+        assert self is getcurrent(), 'Do not call Hub.run() directly'
+        self.start_periodic_monitoring_thread()
+        while 1:
+            loop = self.loop
+            loop.error_handler = self
+            try:
+                loop.run()
+            finally:
+                loop.error_handler = None  # break the refcount cycle
+
+            # This function must never return, as it will cause
+            # switch() in the parent greenlet to return an unexpected
+            # value. This can show up as unexpected failures e.g.,
+            # from Waiters raising AssertionError or MulitpleWaiter
+            # raising invalid IndexError.
+            #
+            # It is still possible to kill this greenlet with throw.
+            # However, in that case switching to it is no longer safe,
+            # as switch will return immediately.
+            #
+            # Note that there's a problem with simply doing
+            # ``self.parent.throw()`` and never actually exiting this
+            # greenlet: The greenlet tends to stay alive. This is
+            # because throwing the exception captures stack frames
+            # (regardless of what we do with the argument) and those
+            # get saved. In addition to this object having
+            # ``gr_frame`` pointing to this method, which contains
+            # ``self``, which points to the parent, and both of which point to
+            # an internal thread state dict that points back to the current greenlet for the thread,
+            # which is likely to be the parent: a cycle.
+            #
+            # We can't have ``join()`` tell us to finish, because we
+            # need to be able to resume after this throw. The only way
+            # to dispose of the greenlet is to use ``self.destroy()``.
+
+            debug = []
+            if hasattr(loop, 'debug'):
+                debug = loop.debug()
+            loop = None
+
+            self.parent.throw(LoopExit('This operation would block forever',
+                                       self,
+                                       debug))
+            # Execution could resume here if another blocking API call is made
+            # in the same thread and the hub hasn't been destroyed, so clean
+            # up anything left.
+            debug = None
+
+    def start_periodic_monitoring_thread(self):
+        if self.periodic_monitoring_thread is None and GEVENT_CONFIG.monitor_thread:
+            # Note that it is possible for one real thread to
+            # (temporarily) wind up with multiple monitoring threads,
+            # if hubs are started and stopped within the thread. This shows up
+            # in the threadpool tests. The monitoring threads will eventually notice their
+            # hub object is gone.
+            from gevent._monitor import PeriodicMonitoringThread
+            from gevent.events import PeriodicMonitorThreadStartedEvent
+            from gevent.events import notify_and_call_entry_points
+            self.periodic_monitoring_thread = PeriodicMonitoringThread(self)
+
+            if self.main_hub:
+                self.periodic_monitoring_thread.install_monitor_memory_usage()
+
+            notify_and_call_entry_points(PeriodicMonitorThreadStartedEvent(
+                self.periodic_monitoring_thread))
+
+        return self.periodic_monitoring_thread
+
+    def join(self, timeout=None):
+        """
+        Wait for the event loop to finish. Exits only when there
+        are no more spawned greenlets, started servers, active
+        timeouts or watchers.
+
+        .. caution:: This doesn't clean up all resources associated
+           with the hub. For that, see :meth:`destroy`.
+
+        :param float timeout: If *timeout* is provided, wait no longer
+            than the specified number of seconds.
+
+        :return: `True` if this method returns because the loop
+                 finished execution. Or `False` if the timeout
+                 expired.
+        """
+        assert getcurrent() is self.parent, "only possible from the MAIN greenlet"
+        if self.dead:
+            return True
+
+        waiter = Waiter(self)
+
+        if timeout is not None:
+            timeout = self.loop.timer(timeout, ref=False)
+            timeout.start(waiter.switch, None)
+
+        try:
+            try:
+                # Switch to the hub greenlet and let it continue.
+                # Since we're the parent greenlet of the hub, when it exits
+                # by `parent.throw(LoopExit)`, control will resume here.
+                # If the timer elapses, however, ``waiter.switch()`` is called and
+                # again control resumes here, but without an exception.
+                waiter.get()
+            except LoopExit:
+                # Control will immediately be returned to this greenlet.
+                return True
+        finally:
+            # Clean up as much junk as we can. There is a small cycle in the frames,
+            # and it won't be GC'd.
+            # this greenlet -> this frame
+            # this greenlet -> the exception that was thrown
+            # the exception that was thrown -> a bunch of other frames, including this frame.
+            # some frame calling self.run() -> self
+            del waiter # this frame -> waiter -> self
+            del self # this frame -> self
+            if timeout is not None:
+                timeout.stop()
+                timeout.close()
+            del timeout
+        return False
+
+    def destroy(self, destroy_loop=None):
+        """
+        Destroy this hub and clean up its resources.
+
+        If you manually create hubs, or you use a hub or the gevent
+        blocking API from multiple native threads, you *should* call this
+        method before disposing of the hub object reference. Ideally,
+        this should be called from the same thread running the hub, but
+        it can be called from other threads after that thread has exited.
+
+        Once this is done, it is impossible to continue running the
+        hub. Attempts to use the blocking gevent API with pre-existing
+        objects from this native thread and bound to this hub will fail.
+
+        .. versionchanged:: 20.5.1
+            Attempt to 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.)
+
+            Note that this only works if the hub is destroyed in the same thread it
+            is running in. If the hub is destroyed by a different thread
+            after a ``fork()``, for example, expect some garbage to leak.
+        """
+        if destroy_loop is None:
+            destroy_loop = not self.loop.default
+
+        if self.periodic_monitoring_thread is not None:
+            self.periodic_monitoring_thread.kill()
+            self.periodic_monitoring_thread = None
+        if self._resolver is not None:
+            self._resolver.close()
+            del self._resolver
+        if self._threadpool is not None:
+            self._threadpool.kill()
+            del self._threadpool
+
+        # Let the frame be cleaned up by causing the run() function to
+        # exit. This is the only way to guarantee that the hub itself
+        # and the main greenlet, if this was a secondary thread, get
+        # cleaned up. Otherwise there are likely to be reference
+        # cycles still around. We MUST do this before we destroy the
+        # loop; if we destroy the loop and then switch into the hub,
+        # things will go VERY, VERY wrong (because we will have destroyed
+        # the C datastructures in the middle of the C function that's
+        # using them; the best we can hope for is a segfault).
+        try:
+            self.throw(HubDestroyed(destroy_loop))
+        except LoopExit:
+            # Expected.
+            pass
+        except GreenletError:
+            # Must be coming from a different thread.
+            # Note that python stack frames are likely to leak
+            # in this case.
+            pass
+
+        if destroy_loop:
+            if get_loop() is self.loop:
+                # Don't let anyone try to reuse this
+                set_loop(None)
+            self.loop.destroy()
+        else:
+            # Store in case another hub is created for this
+            # thread.
+            set_loop(self.loop)
+
+        self.loop = None
+        if _get_hub() is self:
+            set_hub(None)
+
+
+
+    # XXX: We can probably simplify the resolver and threadpool properties.
+
+    @property
+    def resolver_class(self):
+        return GEVENT_CONFIG.resolver
+
+    def _get_resolver(self):
+        if self._resolver is None:
+            self._resolver = self.resolver_class(hub=self) # pylint:disable=not-callable
+        return self._resolver
+
+    def _set_resolver(self, value):
+        self._resolver = value
+
+    def _del_resolver(self):
+        self._resolver = None
+
+    resolver = property(_get_resolver, _set_resolver, _del_resolver,
+                        """
+                        The DNS resolver that the socket functions will use.
+
+                        .. seealso:: :doc:`/dns`
+                        """)
+
+
+    @property
+    def threadpool_class(self):
+        return GEVENT_CONFIG.threadpool
+
+    def _get_threadpool(self):
+        if self._threadpool is None:
+            # pylint:disable=not-callable
+            self._threadpool = self.threadpool_class(
+                self.threadpool_size,
+                hub=self,
+                idle_task_timeout=GEVENT_CONFIG.threadpool_idle_task_timeout
+            )
+        return self._threadpool
+
+    def _set_threadpool(self, value):
+        self._threadpool = value
+
+    def _del_threadpool(self):
+        self._threadpool = None
+
+    threadpool = property(_get_threadpool, _set_threadpool, _del_threadpool,
+                          """
+                          The threadpool associated with this hub.
+
+                          Usually this is a
+                          :class:`gevent.threadpool.ThreadPool`, but
+                          you :attr:`can customize that
+                          <gevent._config.Config.threadpool>`.
+
+                          Use this object to schedule blocking
+                          (non-cooperative) operations in a different
+                          thread to prevent them from halting the event loop.
+                          """)
+
+
+set_default_hub_class(Hub)
+
+
+
+class linkproxy(object):
+    __slots__ = ['callback', 'obj']
+
+    def __init__(self, callback, obj):
+        self.callback = callback
+        self.obj = obj
+
+    def __call__(self, *args):
+        callback = self.callback
+        obj = self.obj
+        self.callback = None
+        self.obj = None
+        callback(obj)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libev/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# Nothing public here
+__all__ = []

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libev/_corecffi_build.py

@@ -0,0 +1,126 @@
+# pylint: disable=no-member
+
+# This module is only used to create and compile the gevent._corecffi module;
+# nothing should be directly imported from it except `ffi`, which should only be
+# used for `ffi.compile()`; programs should import gevent._corecfffi.
+# However, because we are using "out-of-line" mode, it is necessary to examine
+# this file to know what functions are created and available on the generated
+# module.
+from __future__ import absolute_import, print_function
+import sys
+import os
+import os.path # pylint:disable=no-name-in-module
+from cffi import FFI
+
+sys.path.append(".")
+try:
+    import _setuplibev
+    import _setuputils
+except ImportError:
+    print("This file must be imported with setup.py in the current working dir.")
+    raise
+
+thisdir = os.path.dirname(os.path.abspath(__file__))
+parentdir = os.path.abspath(os.path.join(thisdir, '..'))
+setup_dir = os.path.abspath(os.path.join(thisdir, '..', '..', '..'))
+
+
+__all__ = []
+
+
+ffi = FFI()
+distutils_ext = _setuplibev.build_extension()
+
+def read_source(name):
+    # pylint:disable=unspecified-encoding
+    with open(os.path.join(thisdir, name), 'r') as f:
+        return f.read()
+
+# cdef goes to the cffi library and determines what can be used in
+# Python.
+_cdef = read_source('_corecffi_cdef.c')
+
+# These defines and uses help keep the C file readable and lintable by
+# C tools.
+_cdef = _cdef.replace('#define GEVENT_STRUCT_DONE int', '')
+_cdef = _cdef.replace("GEVENT_STRUCT_DONE _;", '...;')
+
+_cdef = _cdef.replace('#define GEVENT_ST_NLINK_T int',
+                      'typedef int... nlink_t;')
+_cdef = _cdef.replace('GEVENT_ST_NLINK_T', 'nlink_t')
+
+if _setuplibev.LIBEV_EMBED:
+    # Arrange access to the loop internals
+    _cdef += """
+struct ev_loop {
+    int backend_fd;
+    int activecnt;
+    ...;
+};
+    """
+
+# arrange to be configured.
+_setuputils.ConfiguringBuildExt.gevent_add_pre_run_action(distutils_ext.configure)
+
+
+if sys.platform.startswith('win'):
+    # We must have the vfd_open, etc, functions on
+    # Windows. But on other platforms, going through
+    # CFFI to just return the file-descriptor is slower
+    # than just doing it in Python, so we check for and
+    # workaround their absence in corecffi.py
+    _cdef += """
+typedef int... vfd_socket_t;
+int vfd_open(vfd_socket_t);
+vfd_socket_t vfd_get(int);
+void vfd_free(int);
+"""
+
+# source goes to the C compiler
+_source = read_source('_corecffi_source.c')
+
+macros = list(distutils_ext.define_macros)
+try:
+    # We need the data pointer.
+    macros.remove(('EV_COMMON', ''))
+except ValueError:
+    pass
+
+ffi.cdef(_cdef)
+ffi.set_source(
+    'gevent.libev._corecffi',
+    _source,
+    include_dirs=distutils_ext.include_dirs + [
+        thisdir, # "libev.h"
+        parentdir, # _ffi/alloc.c
+    ],
+    define_macros=macros,
+    undef_macros=distutils_ext.undef_macros,
+    libraries=distutils_ext.libraries,
+)
+
+if __name__ == '__main__':
+    # XXX: Note, on Windows, we would need to specify the external libraries
+    # that should be linked in, such as ws2_32 and (because libev_vfd.h makes
+    # Python.h calls) the proper Python library---at least for PyPy. I never got
+    # that to work though, and calling python functions is strongly discouraged
+    # from CFFI code.
+
+    # On macOS to make the non-embedded case work correctly, against
+    # our local copy of libev:
+    #
+    # 1) configure and make libev
+    # 2) CPPFLAGS=-Ideps/libev/ LDFLAGS=-Ldeps/libev/.libs GEVENTSETUP_EMBED_LIBEV=0 \
+    #     python setup.py build_ext -i
+    # 3) export DYLD_LIBRARY_PATH=`pwd`/deps/libev/.libs
+    #
+    # The DYLD_LIBRARY_PATH is because the linker hard-codes
+    # /usr/local/lib/libev.4.dylib in the corecffi.so dylib, because
+    # that's the "install name" of the libev dylib that was built.
+    # Adding a -rpath to the LDFLAGS doesn't change things.
+    # This can be fixed with `install_name_tool`:
+    #
+    # 3) install_name_tool -change /usr/local/lib/libev.4.dylib \
+    #    `pwd`/deps/libev/.libs/libev.4.dylib \
+    #     src/gevent/libev/_corecffi.abi3.so
+    ffi.compile(verbose=True)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libev/corecffi.py

@@ -0,0 +1,470 @@
+# pylint: disable=too-many-lines, protected-access, redefined-outer-name, not-callable
+# pylint: disable=no-member
+from __future__ import absolute_import, print_function
+import sys
+
+# pylint: disable=undefined-all-variable
+__all__ = [
+    'get_version',
+    'get_header_version',
+    'supported_backends',
+    'recommended_backends',
+    'embeddable_backends',
+    'time',
+    'loop',
+]
+
+from zope.interface import implementer
+
+from gevent._interfaces import ILoop
+
+from gevent.libev import _corecffi # pylint:disable=no-name-in-module,import-error
+
+ffi = _corecffi.ffi # pylint:disable=no-member
+libev = _corecffi.lib # pylint:disable=no-member
+
+if hasattr(libev, 'vfd_open'):
+    # Must be on windows
+    # pylint:disable=c-extension-no-member
+    assert sys.platform.startswith("win"), "vfd functions only needed on windows"
+    vfd_open = libev.vfd_open
+    vfd_free = libev.vfd_free
+    vfd_get = libev.vfd_get
+else:
+    vfd_open = vfd_free = vfd_get = lambda fd: fd
+
+libev.gevent_set_ev_alloc()
+
+#####
+## NOTE on Windows:
+# The C implementation does several things specially for Windows;
+# a possibly incomplete list is:
+#
+# - the loop runs a periodic signal checker;
+# - the io watcher constructor is different and it has a destructor;
+# - the child watcher is not defined
+#
+# The CFFI implementation does none of these things, and so
+# is possibly NOT FUNCTIONALLY CORRECT on Win32
+#####
+
+
+from gevent._ffi.loop import AbstractCallbacks
+from gevent._ffi.loop import assign_standard_callbacks
+
+class _Callbacks(AbstractCallbacks):
+    # pylint:disable=arguments-differ,arguments-renamed
+
+    def python_check_callback(self, *args):
+        # There's a pylint bug (pylint 2.9.3, astroid 2.6.2) that causes pylint to crash
+        # with an AttributeError on certain types of arguments-differ errors
+        # But code in _ffi/loop depends on being able to find the watcher_ptr
+        # argument is the local frame. BUT it gets invoked before the function body runs.
+        # Hence the override of _find_watcher_ptr_in_traceback.
+        # pylint:disable=unused-variable
+        _loop, watcher_ptr, _events = args
+        AbstractCallbacks.python_check_callback(self, watcher_ptr)
+
+    def _find_watcher_ptr_in_traceback(self, tb):
+        if tb is not None:
+            l = tb.tb_frame.f_locals
+            if 'watcher_ptr' in l:
+                return l['watcher_ptr']
+            if 'args' in l and len(l['args']) == 3:
+                return l['args'][1]
+        return AbstractCallbacks._find_watcher_ptr_in_traceback(self, tb)
+
+    def python_prepare_callback(self, _loop_ptr, watcher_ptr, _events):
+        AbstractCallbacks.python_prepare_callback(self, watcher_ptr)
+
+    def _find_loop_from_c_watcher(self, watcher_ptr):
+        loop_handle = ffi.cast('struct ev_watcher*', watcher_ptr).data
+        return self.from_handle(loop_handle)
+
+_callbacks = assign_standard_callbacks(ffi, libev, _Callbacks)
+
+
+UNDEF = libev.EV_UNDEF
+NONE = libev.EV_NONE
+READ = libev.EV_READ
+WRITE = libev.EV_WRITE
+TIMER = libev.EV_TIMER
+PERIODIC = libev.EV_PERIODIC
+SIGNAL = libev.EV_SIGNAL
+CHILD = libev.EV_CHILD
+STAT = libev.EV_STAT
+IDLE = libev.EV_IDLE
+PREPARE = libev.EV_PREPARE
+CHECK = libev.EV_CHECK
+EMBED = libev.EV_EMBED
+FORK = libev.EV_FORK
+CLEANUP = libev.EV_CLEANUP
+ASYNC = libev.EV_ASYNC
+CUSTOM = libev.EV_CUSTOM
+ERROR = libev.EV_ERROR
+
+READWRITE = libev.EV_READ | libev.EV_WRITE
+
+MINPRI = libev.EV_MINPRI
+MAXPRI = libev.EV_MAXPRI
+
+BACKEND_PORT = libev.EVBACKEND_PORT
+BACKEND_KQUEUE = libev.EVBACKEND_KQUEUE
+BACKEND_EPOLL = libev.EVBACKEND_EPOLL
+BACKEND_POLL = libev.EVBACKEND_POLL
+BACKEND_SELECT = libev.EVBACKEND_SELECT
+FORKCHECK = libev.EVFLAG_FORKCHECK
+NOINOTIFY = libev.EVFLAG_NOINOTIFY
+SIGNALFD = libev.EVFLAG_SIGNALFD
+NOSIGMASK = libev.EVFLAG_NOSIGMASK
+
+
+from gevent._ffi.loop import EVENTS
+GEVENT_CORE_EVENTS = EVENTS
+
+
+def get_version():
+    return 'libev-%d.%02d' % (libev.ev_version_major(), libev.ev_version_minor())
+
+
+def get_header_version():
+    return 'libev-%d.%02d' % (libev.EV_VERSION_MAJOR, libev.EV_VERSION_MINOR)
+
+# This list backends in the order they are actually tried by libev,
+# as defined in loop_init. The names must be lower case.
+_flags = [
+    # IOCP --- not supported/used.
+    (libev.EVBACKEND_PORT, 'port'),
+    (libev.EVBACKEND_KQUEUE, 'kqueue'),
+    (libev.EVBACKEND_IOURING, 'linux_iouring'),
+    (libev.EVBACKEND_LINUXAIO, "linux_aio"),
+    (libev.EVBACKEND_EPOLL, 'epoll'),
+    (libev.EVBACKEND_POLL, 'poll'),
+    (libev.EVBACKEND_SELECT, 'select'),
+
+    (libev.EVFLAG_NOENV, 'noenv'),
+    (libev.EVFLAG_FORKCHECK, 'forkcheck'),
+    (libev.EVFLAG_SIGNALFD, 'signalfd'),
+    (libev.EVFLAG_NOSIGMASK, 'nosigmask')
+]
+
+_flags_str2int = dict((string, flag) for (flag, string) in _flags)
+
+
+
+def _flags_to_list(flags):
+    result = []
+    for code, value in _flags:
+        if flags & code:
+            result.append(value)
+        flags &= ~code
+        if not flags:
+            break
+    if flags:
+        result.append(flags)
+    return result
+
+if sys.version_info[0] >= 3:
+    basestring = (bytes, str)
+    integer_types = (int,)
+else:
+    import __builtin__ # pylint:disable=import-error
+    basestring = (__builtin__.basestring,)
+    integer_types = (int, __builtin__.long)
+
+
+def _flags_to_int(flags):
+    # Note, that order does not matter, libev has its own predefined order
+    if not flags:
+        return 0
+    if isinstance(flags, integer_types):
+        return flags
+    result = 0
+    try:
+        if isinstance(flags, basestring):
+            flags = flags.split(',')
+        for value in flags:
+            value = value.strip().lower()
+            if value:
+                result |= _flags_str2int[value]
+    except KeyError as ex:
+        raise ValueError('Invalid backend or flag: %s\nPossible values: %s' % (ex, ', '.join(sorted(_flags_str2int.keys()))))
+    return result
+
+
+def _str_hex(flag):
+    if isinstance(flag, integer_types):
+        return hex(flag)
+    return str(flag)
+
+
+def _check_flags(flags):
+    as_list = []
+    flags &= libev.EVBACKEND_MASK
+    if not flags:
+        return
+    if not flags & libev.EVBACKEND_ALL:
+        raise ValueError('Invalid value for backend: 0x%x' % flags)
+    if not flags & libev.ev_supported_backends():
+        as_list = [_str_hex(x) for x in _flags_to_list(flags)]
+        raise ValueError('Unsupported backend: %s' % '|'.join(as_list))
+
+
+def supported_backends():
+    return _flags_to_list(libev.ev_supported_backends())
+
+
+def recommended_backends():
+    return _flags_to_list(libev.ev_recommended_backends())
+
+
+def embeddable_backends():
+    return _flags_to_list(libev.ev_embeddable_backends())
+
+
+def time():
+    return libev.ev_time()
+
+from gevent._ffi.loop import AbstractLoop
+
+
+from gevent.libev import watcher as _watchers
+_events_to_str = _watchers._events_to_str # exported
+
+
+@implementer(ILoop)
+class loop(AbstractLoop):
+    # pylint:disable=too-many-public-methods
+
+    # libuv parameters simply won't accept anything lower than 1ms
+    # (0.001s), but libev takes fractional seconds. In practice, on
+    # one machine, libev can sleep for very small periods of time:
+    #
+    # sleep(0.00001) -> 0.000024
+    # sleep(0.0001)  -> 0.000156
+    # sleep(0.001)   -> 0.00136 (which is comparable to libuv)
+
+    approx_timer_resolution = 0.00001
+
+    error_handler = None
+
+    _CHECK_POINTER = 'struct ev_check *'
+
+    _PREPARE_POINTER = 'struct ev_prepare *'
+
+    _TIMER_POINTER = 'struct ev_timer *'
+
+    def __init__(self, flags=None, default=None):
+        AbstractLoop.__init__(self, ffi, libev, _watchers, flags, default)
+        self._default = bool(libev.ev_is_default_loop(self._ptr))
+
+    def _init_loop(self, flags, default):
+        c_flags = _flags_to_int(flags)
+        _check_flags(c_flags)
+        c_flags |= libev.EVFLAG_NOENV
+        c_flags |= libev.EVFLAG_FORKCHECK
+        if default is None:
+            default = True
+        if default:
+            ptr = libev.gevent_ev_default_loop(c_flags)
+            if not ptr:
+                raise SystemError("ev_default_loop(%s) failed" % (c_flags, ))
+        else:
+            ptr = libev.ev_loop_new(c_flags)
+            if not ptr:
+                raise SystemError("ev_loop_new(%s) failed" % (c_flags, ))
+        if default or SYSERR_CALLBACK is None:
+            set_syserr_cb(self._handle_syserr)
+
+        # Mark this loop as being used.
+        libev.ev_set_userdata(ptr, ptr)
+        return ptr
+
+    def _init_and_start_check(self):
+        libev.ev_check_init(self._check, libev.python_check_callback)
+        self._check.data = self._handle_to_self
+        libev.ev_check_start(self._ptr, self._check)
+        self.unref()
+
+    def _init_and_start_prepare(self):
+        libev.ev_prepare_init(self._prepare, libev.python_prepare_callback)
+        libev.ev_prepare_start(self._ptr, self._prepare)
+        self.unref()
+
+    def _init_callback_timer(self):
+        libev.ev_timer_init(self._timer0, libev.gevent_noop, 0.0, 0.0)
+
+    def _stop_callback_timer(self):
+        libev.ev_timer_stop(self._ptr, self._timer0)
+
+    def _start_callback_timer(self):
+        libev.ev_timer_start(self._ptr, self._timer0)
+
+    def _stop_aux_watchers(self):
+        super(loop, self)._stop_aux_watchers()
+        if libev.ev_is_active(self._prepare):
+            self.ref()
+            libev.ev_prepare_stop(self._ptr, self._prepare)
+        if libev.ev_is_active(self._check):
+            self.ref()
+            libev.ev_check_stop(self._ptr, self._check)
+        if libev.ev_is_active(self._timer0):
+            libev.ev_timer_stop(self._timer0)
+
+    def _setup_for_run_callback(self):
+        # XXX: libuv needs to start the callback timer to be sure
+        # that the loop wakes up and calls this. Our C version doesn't
+        # do this.
+        # self._start_callback_timer()
+        self.ref() # we should go through the loop now
+
+    def destroy(self):
+        if self._ptr:
+            super(loop, self).destroy()
+            # pylint:disable=comparison-with-callable
+            if globals()["SYSERR_CALLBACK"] == self._handle_syserr:
+                set_syserr_cb(None)
+
+
+    def _can_destroy_loop(self, ptr):
+        # Is it marked as destroyed?
+        return libev.ev_userdata(ptr)
+
+    def _destroy_loop(self, ptr):
+        # Mark as destroyed.
+        libev.ev_set_userdata(ptr, ffi.NULL)
+        libev.ev_loop_destroy(ptr)
+
+        libev.gevent_zero_prepare(self._prepare)
+        libev.gevent_zero_check(self._check)
+        libev.gevent_zero_timer(self._timer0)
+
+        del self._prepare
+        del self._check
+        del self._timer0
+
+
+    @property
+    def MAXPRI(self):
+        return libev.EV_MAXPRI
+
+    @property
+    def MINPRI(self):
+        return libev.EV_MINPRI
+
+    def _default_handle_error(self, context, type, value, tb): # pylint:disable=unused-argument
+        super(loop, self)._default_handle_error(context, type, value, tb)
+        libev.ev_break(self._ptr, libev.EVBREAK_ONE)
+
+    def run(self, nowait=False, once=False):
+        flags = 0
+        if nowait:
+            flags |= libev.EVRUN_NOWAIT
+        if once:
+            flags |= libev.EVRUN_ONCE
+
+        libev.ev_run(self._ptr, flags)
+
+    def reinit(self):
+        libev.ev_loop_fork(self._ptr)
+
+    def ref(self):
+        libev.ev_ref(self._ptr)
+
+    def unref(self):
+        libev.ev_unref(self._ptr)
+
+    def break_(self, how=libev.EVBREAK_ONE):
+        libev.ev_break(self._ptr, how)
+
+    def verify(self):
+        libev.ev_verify(self._ptr)
+
+    def now(self):
+        return libev.ev_now(self._ptr)
+
+    def update_now(self):
+        libev.ev_now_update(self._ptr)
+
+    def __repr__(self):
+        return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format())
+
+    @property
+    def iteration(self):
+        return libev.ev_iteration(self._ptr)
+
+    @property
+    def depth(self):
+        return libev.ev_depth(self._ptr)
+
+    @property
+    def backend_int(self):
+        return libev.ev_backend(self._ptr)
+
+    @property
+    def backend(self):
+        backend = libev.ev_backend(self._ptr)
+        for key, value in _flags:
+            if key == backend:
+                return value
+        return backend
+
+    @property
+    def pendingcnt(self):
+        return libev.ev_pending_count(self._ptr)
+
+    def closing_fd(self, fd):
+        pending_before = libev.ev_pending_count(self._ptr)
+        libev.ev_feed_fd_event(self._ptr, fd, 0xFFFF)
+        pending_after = libev.ev_pending_count(self._ptr)
+        return pending_after > pending_before
+
+    if sys.platform != "win32":
+
+        def install_sigchld(self):
+            libev.gevent_install_sigchld_handler()
+
+        def reset_sigchld(self):
+            libev.gevent_reset_sigchld_handler()
+
+    def fileno(self):
+        if self._ptr and LIBEV_EMBED:
+            # If we don't embed, we can't access these fields,
+            # the type is opaque
+            fd = self._ptr.backend_fd
+            if fd >= 0:
+                return fd
+
+    @property
+    def activecnt(self):
+        if not self._ptr:
+            raise ValueError('operation on destroyed loop')
+        if LIBEV_EMBED:
+            return self._ptr.activecnt
+        return -1
+
+
+@ffi.def_extern()
+def _syserr_cb(msg):
+    try:
+        msg = ffi.string(msg)
+        SYSERR_CALLBACK(msg, ffi.errno)
+    except:
+        set_syserr_cb(None)
+        raise  # let cffi print the traceback
+
+
+def set_syserr_cb(callback):
+    global SYSERR_CALLBACK
+    if callback is None:
+        libev.ev_set_syserr_cb(ffi.NULL)
+        SYSERR_CALLBACK = None
+    elif callable(callback):
+        libev.ev_set_syserr_cb(libev._syserr_cb)
+        SYSERR_CALLBACK = callback
+    else:
+        raise TypeError('Expected callable or None, got %r' % (callback, ))
+
+SYSERR_CALLBACK = None
+
+LIBEV_EMBED = libev.LIBEV_EMBED

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libev/watcher.py

@@ -0,0 +1,287 @@
+# pylint: disable=too-many-lines, protected-access, redefined-outer-name, not-callable
+# pylint: disable=no-member
+from __future__ import absolute_import, print_function
+import sys
+
+from gevent.libev import _corecffi # pylint:disable=no-name-in-module,import-error
+
+# Nothing public here
+__all__ = []
+
+
+ffi = _corecffi.ffi # pylint:disable=no-member
+libev = _corecffi.lib # pylint:disable=no-member
+
+if hasattr(libev, 'vfd_open'):
+    # Must be on windows
+    # pylint:disable=c-extension-no-member
+    assert sys.platform.startswith("win"), "vfd functions only needed on windows"
+    vfd_open = libev.vfd_open
+    vfd_free = libev.vfd_free
+    vfd_get = libev.vfd_get
+else:
+    vfd_open = vfd_free = vfd_get = lambda fd: fd
+
+#####
+## NOTE on Windows:
+# The C implementation does several things specially for Windows;
+# a possibly incomplete list is:
+#
+# - the loop runs a periodic signal checker;
+# - the io watcher constructor is different and it has a destructor;
+# - the child watcher is not defined
+#
+# The CFFI implementation does none of these things, and so
+# is possibly NOT FUNCTIONALLY CORRECT on Win32
+#####
+_NOARGS = ()
+_events = [(libev.EV_READ, 'READ'),
+           (libev.EV_WRITE, 'WRITE'),
+           (libev.EV__IOFDSET, '_IOFDSET'),
+           (libev.EV_PERIODIC, 'PERIODIC'),
+           (libev.EV_SIGNAL, 'SIGNAL'),
+           (libev.EV_CHILD, 'CHILD'),
+           (libev.EV_STAT, 'STAT'),
+           (libev.EV_IDLE, 'IDLE'),
+           (libev.EV_PREPARE, 'PREPARE'),
+           (libev.EV_CHECK, 'CHECK'),
+           (libev.EV_EMBED, 'EMBED'),
+           (libev.EV_FORK, 'FORK'),
+           (libev.EV_CLEANUP, 'CLEANUP'),
+           (libev.EV_ASYNC, 'ASYNC'),
+           (libev.EV_CUSTOM, 'CUSTOM'),
+           (libev.EV_ERROR, 'ERROR')]
+
+from gevent._ffi import watcher as _base
+
+def _events_to_str(events):
+    return _base.events_to_str(events, _events)
+
+
+
+class watcher(_base.watcher):
+    _FFI = ffi
+    _LIB = libev
+    _watcher_prefix = 'ev'
+
+    # Flags is a bitfield with the following meaning:
+    # 0000 -> default, referenced (when active)
+    # 0010 -> ev_unref has been called
+    # 0100 -> not referenced; independent of 0010
+    _flags = 0
+
+    def __init__(self, _loop, ref=True, priority=None, args=_base._NOARGS):
+        if ref:
+            self._flags = 0
+        else:
+            self._flags = 4
+
+        super(watcher, self).__init__(_loop, ref=ref, priority=priority, args=args)
+
+    def _watcher_ffi_set_priority(self, priority):
+        libev.ev_set_priority(self._watcher, priority)
+
+    def _watcher_ffi_init(self, args):
+        self._watcher_init(self._watcher,
+                           self._watcher_callback,
+                           *args)
+
+    def _watcher_ffi_start(self):
+        self._watcher_start(self.loop._ptr, self._watcher)
+
+    def _watcher_ffi_ref(self):
+        if self._flags & 2: # we've told libev we're not referenced
+            self.loop.ref()
+            self._flags &= ~2
+
+    def _watcher_ffi_unref(self):
+        if self._flags & 6 == 4:
+            # We're not referenced, but we haven't told libev that
+            self.loop.unref()
+            self._flags |= 2 # now we've told libev
+
+    def _get_ref(self):
+        return not self._flags & 4
+
+    def _set_ref(self, value):
+        if value:
+            if not self._flags & 4:
+                return  # ref is already True
+            if self._flags & 2:  # ev_unref was called, undo
+                self.loop.ref()
+            self._flags &= ~6  # do not want unref, no outstanding unref
+        else:
+            if self._flags & 4:
+                return  # ref is already False
+            self._flags |= 4 # we're not referenced
+            if not self._flags & 2 and libev.ev_is_active(self._watcher):
+                # we haven't told libev we're not referenced, but it thinks we're
+                # active so we need to undo that
+                self.loop.unref()
+                self._flags |= 2 # libev knows we're not referenced
+
+    ref = property(_get_ref, _set_ref)
+
+
+    def _get_priority(self):
+        return libev.ev_priority(self._watcher)
+
+    @_base.not_while_active
+    def _set_priority(self, priority):
+        libev.ev_set_priority(self._watcher, priority)
+
+    priority = property(_get_priority, _set_priority)
+
+    def feed(self, revents, callback, *args):
+        self.callback = callback
+        self.args = args or _NOARGS
+        if self._flags & 6 == 4:
+            self.loop.unref()
+            self._flags |= 2
+        libev.ev_feed_event(self.loop._ptr, self._watcher, revents)
+        if not self._flags & 1:
+            # Py_INCREF(<PyObjectPtr>self)
+            self._flags |= 1
+
+    @property
+    def pending(self):
+        return bool(self._watcher and libev.ev_is_pending(self._watcher))
+
+
+class io(_base.IoMixin, watcher):
+
+    EVENT_MASK = libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE
+
+    def _get_fd(self):
+        return vfd_get(self._watcher.fd)
+
+    @_base.not_while_active
+    def _set_fd(self, fd):
+        vfd = vfd_open(fd)
+        vfd_free(self._watcher.fd)
+        self._watcher_init(self._watcher, self._watcher_callback, vfd, self._watcher.events)
+
+    fd = property(_get_fd, _set_fd)
+
+    def _get_events(self):
+        return self._watcher.events
+
+    @_base.not_while_active
+    def _set_events(self, events):
+        self._watcher_init(self._watcher, self._watcher_callback, self._watcher.fd, events)
+
+    events = property(_get_events, _set_events)
+
+    @property
+    def events_str(self):
+        return _events_to_str(self._watcher.events)
+
+    def _format(self):
+        return ' fd=%s events=%s' % (self.fd, self.events_str)
+
+
+class timer(_base.TimerMixin, watcher):
+
+    @property
+    def at(self):
+        return self._watcher.at
+
+    def again(self, callback, *args, **kw):
+        # Exactly the same as start(), just with a different initializer
+        # function
+        self._watcher_start = libev.ev_timer_again
+        try:
+            self.start(callback, *args, **kw)
+        finally:
+            del self._watcher_start
+
+
+class signal(_base.SignalMixin, watcher):
+    pass
+
+class idle(_base.IdleMixin, watcher):
+    pass
+
+class prepare(_base.PrepareMixin, watcher):
+    pass
+
+class check(_base.CheckMixin, watcher):
+    pass
+
+class fork(_base.ForkMixin, watcher):
+    pass
+
+
+class async_(_base.AsyncMixin, watcher):
+
+    def send(self):
+        libev.ev_async_send(self.loop._ptr, self._watcher)
+
+    @property
+    def pending(self):
+        return self._watcher is not None and bool(libev.ev_async_pending(self._watcher))
+
+# Provide BWC for those that have async
+locals()['async'] = async_
+
+class _ClosedWatcher(object):
+    __slots__ = ('pid', 'rpid', 'rstatus')
+
+    def __init__(self, other):
+        self.pid = other.pid
+        self.rpid = other.rpid
+        self.rstatus = other.rstatus
+
+    def __bool__(self):
+        return False
+    __nonzero__ = __bool__
+
+class child(_base.ChildMixin, watcher):
+    _watcher_type = 'child'
+
+    def close(self):
+        # Capture the properties we defer to our _watcher, because
+        # we're about to discard it.
+        closed_watcher = _ClosedWatcher(self._watcher)
+        super(child, self).close()
+        self._watcher = closed_watcher
+
+    @property
+    def pid(self):
+        return self._watcher.pid
+
+    @property
+    def rpid(self):
+        return self._watcher.rpid
+
+    @rpid.setter
+    def rpid(self, value):
+        self._watcher.rpid = value
+
+    @property
+    def rstatus(self):
+        return self._watcher.rstatus
+
+    @rstatus.setter
+    def rstatus(self, value):
+        self._watcher.rstatus = value
+
+
+class stat(_base.StatMixin, watcher):
+    _watcher_type = 'stat'
+
+    @property
+    def attr(self):
+        if not self._watcher.attr.st_nlink:
+            return
+        return self._watcher.attr
+
+    @property
+    def prev(self):
+        if not self._watcher.prev.st_nlink:
+            return
+        return self._watcher.prev
+
+    @property
+    def interval(self):
+        return self._watcher.interval

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libuv/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# Nothing public here
+__all__ = []

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libuv/_corecffi_build.py

@@ -0,0 +1,345 @@
+# pylint: disable=no-member
+
+# This module is only used to create and compile the gevent.libuv._corecffi module;
+# nothing should be directly imported from it except `ffi`, which should only be
+# used for `ffi.compile()`; programs should import gevent._corecfffi.
+# However, because we are using "out-of-line" mode, it is necessary to examine
+# this file to know what functions are created and available on the generated
+# module.
+from __future__ import absolute_import, print_function
+import os
+import os.path # pylint:disable=no-name-in-module
+import platform
+import sys
+
+from cffi import FFI
+
+sys.path.append(".")
+
+try:
+    import _setuputils
+except ImportError:
+    print("This file must be imported with setup.py in the current working dir.")
+    raise
+
+
+__all__ = []
+
+WIN = sys.platform.startswith('win32')
+LIBUV_EMBED = _setuputils.should_embed('libuv')
+PY2 = sys.version_info[0] == 2
+
+
+ffi = FFI()
+
+thisdir = os.path.dirname(os.path.abspath(__file__))
+parentdir = os.path.abspath(os.path.join(thisdir, '..'))
+setup_py_dir = os.path.abspath(os.path.join(thisdir, '..', '..', '..'))
+libuv_dir = os.path.abspath(os.path.join(setup_py_dir, 'deps', 'libuv'))
+
+def read_source(name):
+    # pylint:disable=unspecified-encoding
+    with open(os.path.join(thisdir, name), 'r') as f:
+        return f.read()
+
+_cdef = read_source('_corecffi_cdef.c')
+_source = read_source('_corecffi_source.c')
+
+# These defines and uses help keep the C file readable and lintable by
+# C tools.
+_cdef = _cdef.replace('#define GEVENT_STRUCT_DONE int', '')
+_cdef = _cdef.replace("GEVENT_STRUCT_DONE _;", '...;')
+
+# nlink_t is not used in libuv.
+_cdef = _cdef.replace('#define GEVENT_ST_NLINK_T int',
+                      '')
+_cdef = _cdef.replace('GEVENT_ST_NLINK_T', 'nlink_t')
+
+
+_cdef = _cdef.replace('#define GEVENT_UV_OS_SOCK_T int', '')
+# uv_os_sock_t is int on POSIX and SOCKET on Win32, but socket is
+# just another name for handle, which is just another name for 'void*'
+# which we will treat as an 'unsigned long' or 'unsigned long long'
+# since it comes through 'fileno()' where it has been cast as an int.
+# See class watcher.io
+_void_pointer_as_integer = 'intptr_t'
+_cdef = _cdef.replace("GEVENT_UV_OS_SOCK_T", 'int' if not WIN else _void_pointer_as_integer)
+
+
+
+
+LIBUV_INCLUDE_DIRS = [
+    os.path.join(libuv_dir, 'include'),
+    os.path.join(libuv_dir, 'src'),
+]
+
+# Initially based on https://github.com/saghul/pyuv/blob/v1.x/setup_libuv.py
+
+def _libuv_source(rel_path):
+    # Certain versions of setuptools, notably on windows, are *very*
+    # picky about what we feed to sources= "setup() arguments must
+    # *always* be /-separated paths relative to the setup.py
+    # directory, *never* absolute paths." POSIX doesn't have that issue.
+    path = os.path.join('deps', 'libuv', 'src', rel_path)
+    return path
+
+LIBUV_SOURCES = [
+    _libuv_source('fs-poll.c'),
+    _libuv_source('inet.c'),
+    _libuv_source('threadpool.c'),
+    _libuv_source('uv-common.c'),
+    _libuv_source('version.c'),
+    _libuv_source('uv-data-getter-setters.c'),
+    _libuv_source('timer.c'),
+    _libuv_source('idna.c'),
+    _libuv_source('strscpy.c'),
+    # Added between 1.42.0 and 1.44.2; only used
+    # on unix in that release, but generic
+    _libuv_source('strtok.c'),
+]
+
+if WIN:
+    LIBUV_SOURCES += [
+        _libuv_source('win/async.c'),
+        _libuv_source('win/core.c'),
+        _libuv_source('win/detect-wakeup.c'),
+        _libuv_source('win/dl.c'),
+        _libuv_source('win/error.c'),
+        _libuv_source('win/fs-event.c'),
+        _libuv_source('win/fs.c'),
+        # getaddrinfo.c refers to ConvertInterfaceIndexToLuid
+        # and ConvertInterfaceLuidToNameA, which are supposedly in iphlpapi.h
+        # and iphlpapi.lib/dll. But on Windows 10 with Python 3.5 and VC 14 (Visual Studio 2015),
+        # I get an undefined warning from the compiler for those functions and
+        # a link error from the linker, so this file can't be included.
+        # This is possibly because the functions are defined for Windows Vista, and
+        # Python 3.5 builds with at earlier SDK?
+        # Fortunately we don't use those functions.
+        #_libuv_source('win/getaddrinfo.c'),
+        # getnameinfo.c refers to uv__getaddrinfo_translate_error from
+        # getaddrinfo.c, which we don't have.
+        #_libuv_source('win/getnameinfo.c'),
+        _libuv_source('win/handle.c'),
+        _libuv_source('win/loop-watcher.c'),
+        _libuv_source('win/pipe.c'),
+        _libuv_source('win/poll.c'),
+        _libuv_source('win/process-stdio.c'),
+        _libuv_source('win/process.c'),
+        _libuv_source('win/signal.c'),
+        _libuv_source('win/snprintf.c'),
+        _libuv_source('win/stream.c'),
+        _libuv_source('win/tcp.c'),
+        _libuv_source('win/thread.c'),
+        _libuv_source('win/tty.c'),
+        _libuv_source('win/udp.c'),
+        _libuv_source('win/util.c'),
+        _libuv_source('win/winapi.c'),
+        _libuv_source('win/winsock.c'),
+    ]
+else:
+    LIBUV_SOURCES += [
+        _libuv_source('unix/async.c'),
+        _libuv_source('unix/core.c'),
+        _libuv_source('unix/dl.c'),
+        _libuv_source('unix/fs.c'),
+        _libuv_source('unix/getaddrinfo.c'),
+        _libuv_source('unix/getnameinfo.c'),
+        _libuv_source('unix/loop-watcher.c'),
+        _libuv_source('unix/loop.c'),
+        _libuv_source('unix/pipe.c'),
+        _libuv_source('unix/poll.c'),
+        _libuv_source('unix/process.c'),
+        _libuv_source('unix/signal.c'),
+        _libuv_source('unix/stream.c'),
+        _libuv_source('unix/tcp.c'),
+        _libuv_source('unix/thread.c'),
+        _libuv_source('unix/tty.c'),
+        _libuv_source('unix/udp.c'),
+    ]
+
+
+if sys.platform.startswith('linux'):
+    LIBUV_SOURCES += [
+        _libuv_source('unix/linux-core.c'),
+        _libuv_source('unix/linux-inotify.c'),
+        _libuv_source('unix/linux-syscalls.c'),
+        _libuv_source('unix/procfs-exepath.c'),
+        _libuv_source('unix/proctitle.c'),
+        _libuv_source('unix/random-sysctl-linux.c'),
+        _libuv_source('unix/epoll.c'),
+    ]
+elif sys.platform == 'darwin':
+    LIBUV_SOURCES += [
+        _libuv_source('unix/bsd-ifaddrs.c'),
+        _libuv_source('unix/darwin.c'),
+        _libuv_source('unix/darwin-proctitle.c'),
+        _libuv_source('unix/fsevents.c'),
+        _libuv_source('unix/kqueue.c'),
+        _libuv_source('unix/proctitle.c'),
+    ]
+elif sys.platform.startswith(('freebsd', 'dragonfly')): # pragma: no cover
+    # Not tested
+    LIBUV_SOURCES += [
+        _libuv_source('unix/bsd-ifaddrs.c'),
+        _libuv_source('unix/freebsd.c'),
+        _libuv_source('unix/kqueue.c'),
+        _libuv_source('unix/posix-hrtime.c'),
+        _libuv_source('unix/bsd-proctitle.c'),
+    ]
+elif sys.platform.startswith('openbsd'): # pragma: no cover
+    # Not tested
+    LIBUV_SOURCES += [
+        _libuv_source('unix/bsd-ifaddrs.c'),
+        _libuv_source('unix/kqueue.c'),
+        _libuv_source('unix/openbsd.c'),
+        _libuv_source('unix/posix-hrtime.c'),
+        _libuv_source('unix/bsd-proctitle.c'),
+    ]
+elif sys.platform.startswith('netbsd'): # pragma: no cover
+    # Not tested
+    LIBUV_SOURCES += [
+        _libuv_source('unix/bsd-ifaddrs.c'),
+        _libuv_source('unix/kqueue.c'),
+        _libuv_source('unix/netbsd.c'),
+        _libuv_source('unix/posix-hrtime.c'),
+        _libuv_source('unix/bsd-proctitle.c'),
+    ]
+elif sys.platform.startswith('sunos'): # pragma: no cover
+    # Not tested.
+    LIBUV_SOURCES += [
+        _libuv_source('unix/no-proctitle.c'),
+        _libuv_source('unix/sunos.c'),
+    ]
+elif sys.platform.startswith('aix'): # pragma: no cover
+    # Not tested.
+    LIBUV_SOURCES += [
+        _libuv_source('unix/aix.c'),
+        _libuv_source('unix/aix-common.c'),
+    ]
+elif sys.platform.startswith('haiku'): # pragma: no cover
+    # Not tested
+    LIBUV_SOURCES += [
+        _libuv_source('unix/haiku.c')
+    ]
+elif sys.platform.startswith('cygwin'): # pragma: no cover
+    # Not tested.
+
+    # Based on Cygwin package sources /usr/src/libuv-1.32.0-1.src/libuv-1.32.0/Makefile.am
+    # Apparently the same upstream at https://github.com/libuv/libuv/blob/v1.x/Makefile.am
+    LIBUV_SOURCES += [
+        _libuv_source('unix/cygwin.c'),
+        _libuv_source('unix/bsd-ifaddrs.c'),
+        _libuv_source('unix/no-fsevents.c'),
+        _libuv_source('unix/no-proctitle.c'),
+        _libuv_source('unix/posix-hrtime.c'),
+        _libuv_source('unix/posix-poll.c'),
+        _libuv_source('unix/procfs-exepath.c'),
+        _libuv_source('unix/sysinfo-loadavg.c'),
+        _libuv_source('unix/sysinfo-memory.c'),
+    ]
+
+
+LIBUV_MACROS = [
+    ('LIBUV_EMBED', int(LIBUV_EMBED)),
+]
+
+def _define_macro(name, value):
+    LIBUV_MACROS.append((name, value))
+
+LIBUV_LIBRARIES = []
+
+def _add_library(name):
+    LIBUV_LIBRARIES.append(name)
+
+if sys.platform != 'win32':
+    _define_macro('_LARGEFILE_SOURCE', 1)
+    _define_macro('_FILE_OFFSET_BITS', 64)
+
+if sys.platform.startswith('linux'):
+    _add_library('dl')
+    _add_library('rt')
+    _define_macro('_GNU_SOURCE', 1)
+    _define_macro('_POSIX_C_SOURCE', '200112')
+elif sys.platform == 'darwin':
+    _define_macro('_DARWIN_USE_64_BIT_INODE', 1)
+    _define_macro('_DARWIN_UNLIMITED_SELECT', 1)
+elif sys.platform.startswith('netbsd'): # pragma: no cover
+    _add_library('kvm')
+elif sys.platform.startswith('sunos'): # pragma: no cover
+    _define_macro('__EXTENSIONS__', 1)
+    _define_macro('_XOPEN_SOURCE', 500)
+    _define_macro('_REENTRANT', 1)
+    _add_library('kstat')
+    _add_library('nsl')
+    _add_library('sendfile')
+    _add_library('socket')
+    if platform.release() == '5.10':
+        # https://github.com/libuv/libuv/issues/1458
+        # https://github.com/giampaolo/psutil/blob/4d6a086411c77b7909cce8f4f141bbdecfc0d354/setup.py#L298-L300
+        _define_macro('SUNOS_NO_IFADDRS', '')
+elif sys.platform.startswith('aix'): # pragma: no cover
+    _define_macro('_LINUX_SOURCE_COMPAT', 1)
+    if os.uname().sysname != 'OS400':
+        _add_library('perfstat')
+elif WIN:
+    # All other gevent .pyd files link to the specific minor-version Python
+    # DLL, so we should do the same here. In virtual environments that don't
+    # contain the major-version python?.dll stub, _corecffi.pyd would otherwise
+    # cause the Windows DLL loader to search the entire PATH for a DLL with
+    # that name. This might end up bringing a second, ABI-incompatible Python
+    # version into the process, which can easily lead to crashes.
+    # See https://github.com/gevent/gevent/pull/1814/files
+    _define_macro('_CFFI_NO_LIMITED_API', 1)
+
+    _define_macro('_GNU_SOURCE', 1)
+    _define_macro('WIN32', 1)
+    _define_macro('_CRT_SECURE_NO_DEPRECATE', 1)
+    _define_macro('_CRT_NONSTDC_NO_DEPRECATE', 1)
+    _define_macro('_CRT_SECURE_NO_WARNINGS', 1)
+    _define_macro('_WIN32_WINNT', '0x0602')
+    _define_macro('WIN32_LEAN_AND_MEAN', 1)
+    # This value isn't available on the platform that we build and
+    # test Python 2.7 on. It's used for getting power management
+    # suspend/resume notifications, maybe for keeping timers accurate?
+    #
+    # TODO: This should be a more targeted check based on the platform
+    # version, but that's complicated because it depends on having a
+    # particular patch installed to the OS, and I don't know how to
+    # check for that...but we're dropping Python 2 support soon, so
+    # I suspect it really doesn't matter.
+    if PY2:
+        _define_macro('LOAD_LIBRARY_SEARCH_SYSTEM32', 0)
+    _add_library('advapi32')
+    _add_library('iphlpapi')
+    _add_library('psapi')
+    _add_library('shell32')
+    _add_library('user32')
+    _add_library('userenv')
+    _add_library('ws2_32')
+
+if not LIBUV_EMBED:
+    del LIBUV_SOURCES[:]
+    del LIBUV_INCLUDE_DIRS[:]
+    _add_library('uv')
+
+LIBUV_INCLUDE_DIRS.append(parentdir)
+
+ffi.cdef(_cdef)
+ffi.set_source(
+    'gevent.libuv._corecffi',
+    _source,
+    sources=LIBUV_SOURCES,
+    depends=LIBUV_SOURCES,
+    include_dirs=LIBUV_INCLUDE_DIRS,
+    libraries=list(LIBUV_LIBRARIES),
+    define_macros=list(LIBUV_MACROS),
+    extra_compile_args=list(_setuputils.IGNORE_THIRD_PARTY_WARNINGS),
+)
+
+if __name__ == '__main__':
+    # See notes in libev/_corecffi_build.py for how to test this.
+    #
+    # Other than the obvious directory changes, the changes are:
+    #
+    # CPPFLAGS=-Ideps/libuv/include/ -Isrc/gevent/
+    ffi.compile(verbose=True)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libuv/loop.py

@@ -0,0 +1,690 @@
+"""
+libuv loop implementation
+"""
+# pylint: disable=no-member
+from __future__ import absolute_import, print_function
+
+import os
+from collections import defaultdict
+from collections import namedtuple
+from operator import delitem
+import signal
+
+from zope.interface import implementer
+
+from gevent import getcurrent
+from gevent.exceptions import LoopExit
+
+from gevent._ffi import _dbg # pylint: disable=unused-import
+from gevent._ffi.loop import AbstractLoop
+from gevent._ffi.loop import assign_standard_callbacks
+from gevent._ffi.loop import AbstractCallbacks
+from gevent._interfaces import ILoop
+from gevent.libuv import _corecffi # pylint:disable=no-name-in-module,import-error
+
+ffi = _corecffi.ffi
+libuv = _corecffi.lib
+
+__all__ = [
+]
+
+
+class _Callbacks(AbstractCallbacks):
+
+    def _find_loop_from_c_watcher(self, watcher_ptr):
+        loop_handle = ffi.cast('uv_handle_t*', watcher_ptr).data
+        return self.from_handle(loop_handle) if loop_handle else None
+
+    def python_sigchld_callback(self, watcher_ptr, _signum):
+        self.from_handle(ffi.cast('uv_handle_t*', watcher_ptr).data)._sigchld_callback()
+
+    def python_timer0_callback(self, watcher_ptr):
+        return self.python_prepare_callback(watcher_ptr)
+
+    def python_queue_callback(self, watcher_ptr, revents):
+        watcher_handle = watcher_ptr.data
+        the_watcher = self.from_handle(watcher_handle)
+
+        the_watcher.loop._queue_callback(watcher_ptr, revents)
+
+
+_callbacks = assign_standard_callbacks(
+    ffi, libuv, _Callbacks,
+    [
+        'python_sigchld_callback',
+        'python_timer0_callback',
+        'python_queue_callback',
+    ]
+)
+
+from gevent._ffi.loop import EVENTS
+GEVENT_CORE_EVENTS = EVENTS # export
+
+from gevent.libuv import watcher as _watchers # pylint:disable=no-name-in-module
+
+_events_to_str = _watchers._events_to_str # export
+
+READ = libuv.UV_READABLE
+WRITE = libuv.UV_WRITABLE
+
+def get_version():
+    uv_bytes = ffi.string(libuv.uv_version_string())
+    if not isinstance(uv_bytes, str):
+        # Py3
+        uv_str = uv_bytes.decode("ascii")
+    else:
+        uv_str = uv_bytes
+
+    return 'libuv-' + uv_str
+
+def get_header_version():
+    return 'libuv-%d.%d.%d' % (libuv.UV_VERSION_MAJOR, libuv.UV_VERSION_MINOR, libuv.UV_VERSION_PATCH)
+
+def supported_backends():
+    return ['default']
+
+libuv.gevent_set_uv_alloc()
+
+@implementer(ILoop)
+class loop(AbstractLoop):
+
+    # libuv parameters simply won't accept anything lower than 1ms. In
+    # practice, looping on gevent.sleep(0.001) takes about 0.00138 s
+    # (+- 0.000036s)
+    approx_timer_resolution = 0.001 # 1ms
+
+    # It's relatively more expensive to break from the callback loop
+    # because we don't do it "inline" from C, we're looping in Python
+    CALLBACK_CHECK_COUNT = max(AbstractLoop.CALLBACK_CHECK_COUNT, 100)
+
+    # Defines the maximum amount of time the loop will sleep waiting for IO,
+    # which is also the interval at which signals are checked and handled.
+    SIGNAL_CHECK_INTERVAL_MS = 300
+
+    error_handler = None
+
+    _CHECK_POINTER = 'uv_check_t *'
+
+    _PREPARE_POINTER = 'uv_prepare_t *'
+    _PREPARE_CALLBACK_SIG = "void(*)(void*)"
+
+    _TIMER_POINTER = _CHECK_POINTER # This is poorly named. It's for the callback "timer"
+
+    def __init__(self, flags=None, default=None):
+        AbstractLoop.__init__(self, ffi, libuv, _watchers, flags, default)
+        self._child_watchers = defaultdict(list)
+        self._io_watchers = {}
+        self._fork_watchers = set()
+        self._pid = os.getpid()
+        # pylint:disable-next=superfluous-parens
+        self._default = (self._ptr == libuv.uv_default_loop())
+        self._queued_callbacks = []
+
+    def _queue_callback(self, watcher_ptr, revents):
+        self._queued_callbacks.append((watcher_ptr, revents))
+
+    def _init_loop(self, flags, default):
+        if default is None:
+            default = True
+            # Unlike libev, libuv creates a new default
+            # loop automatically if the old default loop was
+            # closed.
+
+        if default:
+            # XXX: If the default loop had been destroyed, this
+            # will create a new one, but we won't destroy it
+            ptr = libuv.uv_default_loop()
+        else:
+            ptr = libuv.uv_loop_new()
+
+
+        if not ptr:
+            raise SystemError("Failed to get loop")
+
+        # Track whether or not any object has destroyed
+        # this loop. See _can_destroy_default_loop
+        ptr.data = self._handle_to_self
+        return ptr
+
+    _signal_idle = None
+
+    @property
+    def ptr(self):
+        if not self._ptr:
+            return None
+        if self._ptr and not self._ptr.data:
+            # Another instance of the Python loop destroyed
+            # the C loop. It was probably the default.
+            self._ptr = None
+        return self._ptr
+
+    def _init_and_start_check(self):
+        libuv.uv_check_init(self.ptr, self._check)
+        libuv.uv_check_start(self._check, libuv.python_check_callback)
+        libuv.uv_unref(self._check)
+
+        # We also have to have an idle watcher to be able to handle
+        # signals in a timely manner. Without them, libuv won't loop again
+        # and call into its check and prepare handlers.
+        # Note that this basically forces us into a busy-loop
+        # XXX: As predicted, using an idle watcher causes our process
+        # to eat 100% CPU time. We instead use a timer with a max of a .3 second
+        # delay to notice signals. Note that this timeout also implements fork
+        # watchers, effectively.
+
+        # XXX: Perhaps we could optimize this to notice when there are other
+        # timers in the loop and start/stop it then. When we have a callback
+        # scheduled, this should also be the same and unnecessary?
+        # libev does takes this basic approach on Windows.
+        self._signal_idle = ffi.new("uv_timer_t*")
+        libuv.uv_timer_init(self.ptr, self._signal_idle)
+        self._signal_idle.data = self._handle_to_self
+        sig_cb = ffi.cast('void(*)(uv_timer_t*)', libuv.python_check_callback)
+        libuv.uv_timer_start(self._signal_idle,
+                             sig_cb,
+                             self.SIGNAL_CHECK_INTERVAL_MS,
+                             self.SIGNAL_CHECK_INTERVAL_MS)
+        libuv.uv_unref(self._signal_idle)
+
+    def __check_and_die(self):
+        if not self.ptr:
+            # We've been destroyed during the middle of self.run().
+            # This method is being called into from C, and it's not
+            # safe to go back to C (Windows in particular can abort
+            # the process with "GetQueuedCompletionStatusEx: (6) The
+            # handle is invalid.") So switch to the parent greenlet.
+            getcurrent().parent.throw(LoopExit('Destroyed during run'))
+
+    def _run_callbacks(self):
+        self.__check_and_die()
+        # Manually handle fork watchers.
+        curpid = os.getpid()
+        if curpid != self._pid:
+            self._pid = curpid
+            for watcher in self._fork_watchers:
+                watcher._on_fork()
+
+
+        # The contents of queued_callbacks at this point should be timers
+        # that expired when the loop began along with any idle watchers.
+        # We need to run them so that any manual callbacks they want to schedule
+        # get added to the list and ran next before we go on to poll for IO.
+        # This is critical for libuv on linux: closing a socket schedules some manual
+        # callbacks to actually stop the watcher; if those don't run before
+        # we poll for IO, then libuv can abort the process for the closed file descriptor.
+
+        # XXX: There's still a race condition here because we may not run *all* the manual
+        # callbacks. We need a way to prioritize those.
+
+        # Running these before the manual callbacks lead to some
+        # random test failures. In test__event.TestEvent_SetThenClear
+        # we would get a LoopExit sometimes. The problem occurred when
+        # a timer expired on entering the first loop; we would process
+        # it there, and then process the callback that it created
+        # below, leaving nothing for the loop to do. Having the
+        # self.run() manually process manual callbacks before
+        # continuing solves the problem. (But we must still run callbacks
+        # here again.)
+        self._prepare_ran_callbacks = self.__run_queued_callbacks()
+
+        super(loop, self)._run_callbacks()
+
+    def _init_and_start_prepare(self):
+        libuv.uv_prepare_init(self.ptr, self._prepare)
+        libuv.uv_prepare_start(self._prepare, libuv.python_prepare_callback)
+        libuv.uv_unref(self._prepare)
+
+    def _init_callback_timer(self):
+        libuv.uv_check_init(self.ptr, self._timer0)
+
+    def _stop_callback_timer(self):
+        libuv.uv_check_stop(self._timer0)
+
+    def _start_callback_timer(self):
+        # The purpose of the callback timer is to ensure that we run
+        # callbacks as soon as possible on the next iteration of the event loop.
+
+        # In libev, we set a 0 duration timer with a no-op callback.
+        # This executes immediately *after* the IO poll is done (it
+        # actually determines the time that the IO poll will block
+        # for), so having the timer present simply spins the loop, and
+        # our normal prepare watcher kicks in to run the callbacks.
+
+        # In libuv, however, timers are run *first*, before prepare
+        # callbacks and before polling for IO. So a no-op 0 duration
+        # timer actually does *nothing*. (Also note that libev queues all
+        # watchers found during IO poll to run at the end (I think), while libuv
+        # runs them in uv__io_poll itself.)
+
+        # From the loop inside uv_run:
+        # while True:
+        #   uv__update_time(loop);
+        #   uv__run_timers(loop);
+        #   # we don't use pending watchers. They are how libuv
+        #   # implements the pipe/udp/tcp streams.
+        #   ran_pending = uv__run_pending(loop);
+        #   uv__run_idle(loop);
+        #   uv__run_prepare(loop);
+        #   ...
+        #   uv__io_poll(loop, timeout); # <--- IO watchers run here!
+        #   uv__run_check(loop);
+
+        # libev looks something like this (pseudo code because the real code is
+        # hard to read):
+        #
+        # do {
+        #    run_fork_callbacks();
+        #    run_prepare_callbacks();
+        #    timeout = min(time of all timers or normal block time)
+        #    io_poll() # <--- Only queues IO callbacks
+        #    update_now(); calculate_expired_timers();
+        #    run callbacks in this order: (although specificying priorities changes it)
+        #        check
+        #        stat
+        #        child
+        #        signal
+        #        timer
+        #        io
+        # }
+
+        # So instead of running a no-op and letting the side-effect of spinning
+        # the loop run the callbacks, we must explicitly run them here.
+
+        # If we don't, test__systemerror:TestCallback will be flaky, failing
+        # one time out of ~20, depending on timing.
+
+        # To get them to run immediately after this current loop,
+        # we use a check watcher, instead of a 0 duration timer entirely.
+        # If we use a 0 duration timer, we can get stuck in a timer loop.
+        # Python 3.6 fails in test_ftplib.py
+
+        # As a final note, if we have not yet entered the loop *at
+        # all*, and a timer was created with a duration shorter than
+        # the amount of time it took for us to enter the loop in the
+        # first place, it may expire and get called before our callback
+        # does. This could also lead to test__systemerror:TestCallback
+        # appearing to be flaky.
+
+        # As yet another final note, if we are currently running a
+        # timer callback, meaning we're inside uv__run_timers() in C,
+        # and the Python starts a new timer, if the Python code then
+        # update's the loop's time, it's possible that timer will
+        # expire *and be run in the same iteration of the loop*. This
+        # is trivial to do: In sequential code, anything after
+        # `gevent.sleep(0.1)` is running in a timer callback. Starting
+        # a new timer---e.g., another gevent.sleep() call---will
+        # update the time, *before* uv__run_timers exits, meaning
+        # other timers get a chance to run before our check or prepare
+        # watcher callbacks do. Therefore, we do indeed have to have a 0
+        # timer to run callbacks---it gets inserted before any other user
+        # timers---ideally, this should be especially careful about how much time
+        # it runs for.
+
+        # AND YET: We can't actually do that. We get timeouts that I haven't fully
+        # investigated if we do. Probably stuck in a timer loop.
+
+        # As a partial remedy to this, unlike libev, our timer watcher
+        # class doesn't update the loop time by default.
+
+        libuv.uv_check_start(self._timer0, libuv.python_timer0_callback)
+
+
+    def _stop_aux_watchers(self):
+        super(loop, self)._stop_aux_watchers()
+        assert self._prepare
+        assert self._check
+        assert self._signal_idle
+        libuv.uv_prepare_stop(self._prepare)
+        libuv.uv_ref(self._prepare) # Why are we doing this?
+
+        libuv.uv_check_stop(self._check)
+        libuv.uv_ref(self._check)
+
+        libuv.uv_timer_stop(self._signal_idle)
+        libuv.uv_ref(self._signal_idle)
+
+        libuv.uv_check_stop(self._timer0)
+
+    def _setup_for_run_callback(self):
+        self._start_callback_timer()
+        libuv.uv_ref(self._timer0)
+
+    def _can_destroy_loop(self, ptr):
+        return ptr
+
+    def __close_loop(self, ptr):
+        closed_failed = 1
+
+        while closed_failed:
+            closed_failed = libuv.uv_loop_close(ptr)
+            if not closed_failed:
+                break
+
+            if closed_failed != libuv.UV_EBUSY:
+                raise SystemError("Unknown close failure reason", closed_failed)
+            # We already closed all the handles. Run the loop
+            # once to let them be cut off from the loop.
+            ran_has_more_callbacks = libuv.uv_run(ptr, libuv.UV_RUN_ONCE)
+            if ran_has_more_callbacks:
+                libuv.uv_run(ptr, libuv.UV_RUN_NOWAIT)
+
+
+    def _destroy_loop(self, ptr):
+        # We're being asked to destroy a loop that's, potentially, at
+        # the time it was constructed, was the default loop. If loop
+        # objects were constructed more than once, it may have already
+        # been destroyed, though. We track this in the data member.
+        data = ptr.data
+        ptr.data = ffi.NULL
+        try:
+            if data:
+                libuv.uv_stop(ptr)
+                libuv.gevent_close_all_handles(ptr)
+        finally:
+            ptr.data = ffi.NULL
+
+        try:
+            if data:
+                self.__close_loop(ptr)
+        finally:
+            # Destroy the native resources *after* we have closed
+            # the loop. If we do it before, walking the handles
+            # attached to the loop is likely to segfault.
+            # Note that these may have been closed already if the default loop was shared.
+            if data:
+                libuv.gevent_zero_check(self._check)
+                libuv.gevent_zero_check(self._timer0)
+                libuv.gevent_zero_prepare(self._prepare)
+                libuv.gevent_zero_timer(self._signal_idle)
+                libuv.gevent_zero_loop(ptr)
+
+            del self._check
+            del self._prepare
+            del self._signal_idle
+            del self._timer0
+
+            # Destroy any watchers we're still holding on to.
+            del self._io_watchers
+            del self._fork_watchers
+            del self._child_watchers
+
+    _HandleState = namedtuple("HandleState",
+                              ['handle',
+                               'type',
+                               'watcher',
+                               'ref',
+                               'active',
+                               'closing'])
+    def debug(self):
+        """
+        Return all the handles that are open and their ref status.
+        """
+        if not self.ptr:
+            return ["Loop has been destroyed"]
+
+        handle_state = self._HandleState
+        handles = []
+
+        # XXX: Convert this to a modern callback.
+        def walk(handle, _arg):
+            data = handle.data
+            if data:
+                watcher = ffi.from_handle(data)
+            else:
+                watcher = None
+            handles.append(handle_state(handle,
+                                        ffi.string(libuv.uv_handle_type_name(handle.type)),
+                                        watcher,
+                                        libuv.uv_has_ref(handle),
+                                        libuv.uv_is_active(handle),
+                                        libuv.uv_is_closing(handle)))
+
+        libuv.uv_walk(self.ptr,
+                      ffi.callback("void(*)(uv_handle_t*,void*)",
+                                   walk),
+                      ffi.NULL)
+        return handles
+
+    def ref(self):
+        pass
+
+    def unref(self):
+        # XXX: Called by _run_callbacks.
+        pass
+
+    def break_(self, how=None):
+        if self.ptr:
+            libuv.uv_stop(self.ptr)
+
+    def reinit(self):
+        # TODO: How to implement? We probably have to simply
+        # re-__init__ this whole class? Does it matter?
+        # OR maybe we need to uv_walk() and close all the handles?
+
+        # XXX: libuv < 1.12 simply CANNOT handle a fork unless you immediately
+        # exec() in the child. There are multiple calls to abort() that
+        # will kill the child process:
+        # - The OS X poll implementation (kqueue) aborts on an error return
+        # value; since kqueue FDs can't be inherited, then the next call
+        # to kqueue in the child will fail and get aborted; fork() is likely
+        # to be called during the gevent loop, meaning we're deep inside the
+        # runloop already, so we can't even close the loop that we're in:
+        # it's too late, the next call to kqueue is already scheduled.
+        # - The threadpool, should it be in use, also aborts
+        # (https://github.com/joyent/libuv/pull/1136)
+        # - There global shared state that breaks signal handling
+        # and leads to an abort() in the child, EVEN IF the loop in the parent
+        # had already been closed
+        # (https://github.com/joyent/libuv/issues/1405)
+
+        # In 1.12, the uv_loop_fork function was added (by gevent!)
+        libuv.uv_loop_fork(self.ptr)
+
+    _prepare_ran_callbacks = False
+
+    def __run_queued_callbacks(self):
+        if not self._queued_callbacks:
+            return False
+
+        cbs = self._queued_callbacks[:]
+        del self._queued_callbacks[:]
+
+        for watcher_ptr, arg in cbs:
+            handle = watcher_ptr.data
+            if not handle:
+                # It's been stopped and possibly closed
+                assert not libuv.uv_is_active(watcher_ptr)
+                continue
+            val = _callbacks.python_callback(handle, arg)
+            if val == -1: # Failure.
+                _callbacks.python_handle_error(handle, arg)
+            elif val == 1: # Success, and we may need to close the Python watcher.
+                if not libuv.uv_is_active(watcher_ptr):
+                    # The callback closed the native watcher resources. Good.
+                    # It's *supposed* to also reset the .data handle to NULL at
+                    # that same time. If it resets it to something else, we're
+                    # re-using the same watcher object, and that's not correct either.
+                    # On Windows in particular, if the .data handle is changed because
+                    # the IO multiplexer is being restarted, trying to dereference the
+                    # *old* handle can crash with an FFI error.
+                    handle_after_callback = watcher_ptr.data
+                    try:
+                        if handle_after_callback and handle_after_callback == handle:
+                            _callbacks.python_stop(handle_after_callback)
+                    finally:
+                        watcher_ptr.data = ffi.NULL
+        return True
+
+
+    def run(self, nowait=False, once=False):
+        # we can only respect one flag or the other.
+        # nowait takes precedence because it can't block
+        mode = libuv.UV_RUN_DEFAULT
+        if once:
+            mode = libuv.UV_RUN_ONCE
+        if nowait:
+            mode = libuv.UV_RUN_NOWAIT
+
+        if mode == libuv.UV_RUN_DEFAULT:
+            while self._ptr and self._ptr.data:
+                # This is here to better preserve order guarantees.
+                # See _run_callbacks for details.
+
+                # It may get run again from the prepare watcher, so
+                # potentially we could take twice as long as the
+                # switch interval.
+                # If we have *lots* of callbacks to run, we may not actually
+                # get through them all before we're requested to poll for IO;
+                # so in that case, just spin the loop once (UV_RUN_NOWAIT) and
+                # go again.
+                self._run_callbacks()
+                self._prepare_ran_callbacks = False
+
+                # UV_RUN_ONCE will poll for IO, blocking for up to the time needed
+                # for the next timer to expire. Worst case, that's our _signal_idle
+                # timer, about 1/3 second. UV_RUN_ONCE guarantees that some forward progress
+                # is made, either by an IO watcher or a timer.
+                #
+                # In contrast, UV_RUN_NOWAIT makes no such guarantee, it only polls for IO once and
+                # immediately returns; it does not update the loop time or timers after
+                # polling for IO.
+                run_mode = (
+                    libuv.UV_RUN_ONCE
+                    if not self._callbacks and not self._queued_callbacks
+                    else libuv.UV_RUN_NOWAIT
+                )
+
+                ran_status = libuv.uv_run(self._ptr, run_mode)
+                # Note that we run queued callbacks when the prepare watcher runs,
+                # thus accounting for timers that expired before polling for IO,
+                # and idle watchers. This next call should get IO callbacks and
+                # callbacks from timers that expired *after* polling for IO.
+                ran_callbacks = self.__run_queued_callbacks()
+
+                if not ran_status and not ran_callbacks and not self._prepare_ran_callbacks:
+                    # A return of 0 means there are no referenced and
+                    # active handles. The loop is over.
+                    # If we didn't run any callbacks, then we couldn't schedule
+                    # anything to switch in the future, so there's no point
+                    # running again.
+                    return ran_status
+            return 0 # Somebody closed the loop
+
+        result = libuv.uv_run(self._ptr, mode)
+        self.__run_queued_callbacks()
+        return result
+
+    def now(self):
+        self.__check_and_die()
+        # libuv's now is expressed as an integer number of
+        # milliseconds, so to get it compatible with time.time units
+        # that this method is supposed to return, we have to divide by 1000.0
+        now = libuv.uv_now(self.ptr)
+        return now / 1000.0
+
+    def update_now(self):
+        self.__check_and_die()
+        libuv.uv_update_time(self.ptr)
+
+    def fileno(self):
+        if self.ptr:
+            fd = libuv.uv_backend_fd(self._ptr)
+            if fd >= 0:
+                return fd
+
+    _sigchld_watcher = None
+    _sigchld_callback_ffi = None
+
+    def install_sigchld(self):
+        if not self.default:
+            return
+
+        if self._sigchld_watcher:
+            return
+
+        self._sigchld_watcher = ffi.new('uv_signal_t*')
+        libuv.uv_signal_init(self.ptr, self._sigchld_watcher)
+        self._sigchld_watcher.data = self._handle_to_self
+        # Don't let this keep the loop alive
+        libuv.uv_unref(self._sigchld_watcher)
+
+        libuv.uv_signal_start(self._sigchld_watcher,
+                              libuv.python_sigchld_callback,
+                              signal.SIGCHLD)
+
+    def reset_sigchld(self):
+        if not self.default or not self._sigchld_watcher:
+            return
+
+        libuv.uv_signal_stop(self._sigchld_watcher)
+        # Must go through this to manage the memory lifetime
+        # correctly. Alternately, we could just stop it and restart
+        # it in install_sigchld?
+        _watchers.watcher._watcher_ffi_close(self._sigchld_watcher)
+        del self._sigchld_watcher
+
+
+    def _sigchld_callback(self):
+        # Signals can arrive at (relatively) any time. To eliminate
+        # race conditions, and behave more like libev, we "queue"
+        # sigchld to run when we run callbacks.
+        while True:
+            try:
+                pid, status, _usage = os.wait3(os.WNOHANG)
+            except OSError:
+                # Python 3 raises ChildProcessError
+                break
+
+            if pid == 0:
+                break
+            children_watchers = self._child_watchers.get(pid, []) + self._child_watchers.get(0, [])
+            for watcher in children_watchers:
+                self.run_callback(watcher._set_waitpid_status, pid, status)
+
+            # Don't invoke child watchers for 0 more than once
+            self._child_watchers[0] = []
+
+    def _register_child_watcher(self, watcher):
+        self._child_watchers[watcher._pid].append(watcher)
+
+    def _unregister_child_watcher(self, watcher):
+        try:
+            # stop() should be idempotent
+            self._child_watchers[watcher._pid].remove(watcher)
+        except ValueError:
+            pass
+
+        # Now's a good time to clean up any dead watchers we don't need
+        # anymore
+        for pid in list(self._child_watchers):
+            if not self._child_watchers[pid]:
+                del self._child_watchers[pid]
+
+    def io(self, fd, events, ref=True, priority=None):
+        # We rely on hard references here and explicit calls to
+        # close() on the returned object to correctly manage
+        # the watcher lifetimes.
+
+        io_watchers = self._io_watchers
+        try:
+            io_watcher = io_watchers[fd]
+            assert io_watcher._multiplex_watchers, ("IO Watcher %s unclosed but should be dead" % io_watcher)
+        except KeyError:
+            # Start the watcher with just the events that we're interested in.
+            # as multiplexers are added, the real event mask will be updated to keep in sync.
+            # If we watch for too much, we get spurious wakeups and busy loops.
+            io_watcher = self._watchers.io(self, fd, 0)
+            io_watchers[fd] = io_watcher
+            io_watcher._no_more_watchers = lambda: delitem(io_watchers, fd)
+
+        return io_watcher.multiplex(events)
+
+    def prepare(self, ref=True, priority=None):
+        # We run arbitrary code in python_prepare_callback. That could switch
+        # greenlets. If it does that while also manipulating the active prepare
+        # watchers, we could corrupt the process state, since the prepare watcher
+        # queue is iterated on the stack (on unix). We could workaround this by implementing
+        # prepare watchers in pure Python.
+        # See https://github.com/gevent/gevent/issues/1126
+        raise TypeError("prepare watchers are not currently supported in libuv. "
+                        "If you need them, please contact the maintainers.")

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/libuv/watcher.py

@@ -0,0 +1,762 @@
+# pylint: disable=too-many-lines, protected-access, redefined-outer-name, not-callable
+# pylint: disable=no-member
+from __future__ import absolute_import, print_function
+
+import functools
+import sys
+
+from gevent.libuv import _corecffi # pylint:disable=no-name-in-module,import-error
+
+# Nothing public here
+__all__ = []
+
+ffi = _corecffi.ffi
+libuv = _corecffi.lib
+
+from gevent._ffi import watcher as _base
+from gevent._ffi import _dbg
+
+# A set of uv_handle_t* CFFI objects. Kept around
+# to keep the memory alive until libuv is done with them.
+class _ClosingWatchers(dict):
+    __slots__ = ()
+
+    def remove(self, obj):
+        try:
+            del self[obj]
+        except KeyError: # pragma: no cover
+            # This has been seen to happen if the module is executed twice
+            # and so the callback doesn't match the storage seen by watcher objects.
+            print(
+                'gevent error: Unable to remove closing watcher from keepaliveset. '
+                'Has the module state been corrupted or executed more than once?',
+                file=sys.stderr
+            )
+
+_closing_watchers = _ClosingWatchers()
+
+
+# In debug mode, it would be nice to be able to clear the memory of
+# the watcher (its size determined by
+# libuv.uv_handle_size(ffi_watcher.type)) using memset so that if we
+# are using it after it's supposedly been closed and deleted, we'd
+# catch it sooner. BUT doing so breaks test__threadpool. We get errors
+# about `pthread_mutex_lock[3]: Invalid argument` (and sometimes we
+# crash) suggesting either that we're writing on memory that doesn't
+# belong to us, somehow, or that we haven't actually lost all
+# references...
+_uv_close_callback = ffi.def_extern(name='_uv_close_callback')(
+    _closing_watchers.remove
+)
+
+
+_events = [(libuv.UV_READABLE, "READ"),
+           (libuv.UV_WRITABLE, "WRITE")]
+
+def _events_to_str(events): # export
+    return _base.events_to_str(events, _events)
+
+class UVFuncallError(ValueError):
+    pass
+
+class libuv_error_wrapper(object):
+    # Makes sure that everything stored as a function
+    # on the wrapper instances (classes, actually,
+    # because this is used by the metaclass)
+    # checks its return value and raises an error.
+    # This expects that everything we call has an int
+    # or void return value and follows the conventions
+    # of error handling (that negative values are errors)
+    def __init__(self, uv):
+        self._libuv = uv
+
+    def __getattr__(self, name):
+        libuv_func = getattr(self._libuv, name)
+
+        @functools.wraps(libuv_func)
+        def wrap(*args, **kwargs):
+            if args and isinstance(args[0], watcher):
+                args = args[1:]
+            res = libuv_func(*args, **kwargs)
+            if res is not None and res < 0:
+                raise UVFuncallError(
+                    str(ffi.string(libuv.uv_err_name(res)).decode('ascii')
+                        + ' '
+                        + ffi.string(libuv.uv_strerror(res)).decode('ascii'))
+                    + " Args: " + repr(args) + " KWARGS: " + repr(kwargs)
+                )
+            return res
+
+        setattr(self, name, wrap)
+
+        return wrap
+
+
+class ffi_unwrapper(object):
+    # undoes the wrapping of libuv_error_wrapper for
+    # the methods used by the metaclass that care
+
+    def __init__(self, ff):
+        self._ffi = ff
+
+    def __getattr__(self, name):
+        return getattr(self._ffi, name)
+
+    def addressof(self, lib, name):
+        assert isinstance(lib, libuv_error_wrapper)
+        return self._ffi.addressof(libuv, name)
+
+
+class watcher(_base.watcher):
+    _FFI = ffi_unwrapper(ffi)
+    _LIB = libuv_error_wrapper(libuv)
+
+    _watcher_prefix = 'uv'
+    _watcher_struct_pattern = '%s_t'
+
+    @classmethod
+    def _watcher_ffi_close(cls, ffi_watcher):
+        # Managing the lifetime of _watcher is tricky.
+        # They have to be uv_close()'d, but that only
+        # queues them to be closed in the *next* loop iteration.
+        # The memory must stay valid for at least that long,
+        # or assert errors are triggered. We can't use a ffi.gc()
+        # pointer to queue the uv_close, because by the time the
+        # destructor is called, there's no way to keep the memory alive
+        # and it could be re-used.
+        # So here we resort to resurrecting the pointer object out
+        # of our scope, keeping it alive past this object's lifetime.
+        # We then use the uv_close callback to handle removing that
+        # reference. There's no context passed to the close callback,
+        # so we have to do this globally.
+
+        # Sadly, doing this causes crashes if there were multiple
+        # watchers for a given FD, so we have to take special care
+        # about that. See https://github.com/gevent/gevent/issues/790#issuecomment-208076604
+
+        # Note that this cannot be a __del__ method, because we store
+        # the CFFI handle to self on self, which is a cycle, and
+        # objects with a __del__ method cannot be collected on CPython < 3.4
+
+        # Instead, this is arranged as a callback to GC when the
+        # watcher class dies. Obviously it's important to keep the ffi
+        # watcher alive.
+        # We can pass in "subclasses" of uv_handle_t that line up at the C level,
+        # but that don't in CFFI without a cast. But be careful what we use the cast
+        # for, don't pass it back to C.
+        ffi_handle_watcher = cls._FFI.cast('uv_handle_t*', ffi_watcher)
+        ffi_handle_watcher.data = ffi.NULL
+
+        if ffi_handle_watcher.type and not libuv.uv_is_closing(ffi_watcher):
+            # If the type isn't set, we were never properly initialized,
+            # and trying to close it results in libuv terminating the process.
+            # Sigh. Same thing if it's already in the process of being
+            # closed.
+            _closing_watchers[ffi_handle_watcher] = ffi_watcher
+            libuv.uv_close(ffi_watcher, libuv._uv_close_callback)
+
+    def _watcher_ffi_set_init_ref(self, ref):
+        self.ref = ref
+
+    def _watcher_ffi_init(self, args):
+        # TODO: we could do a better job chokepointing this
+        return self._watcher_init(self.loop.ptr,
+                                  self._watcher,
+                                  *args)
+
+    def _watcher_ffi_start(self):
+        self._watcher_start(self._watcher, self._watcher_callback)
+
+    def _watcher_ffi_stop(self):
+        if self._watcher:
+            # The multiplexed io watcher deletes self._watcher
+            # when it closes down. If that's in the process of
+            # an error handler, AbstractCallbacks.unhandled_onerror
+            # will try to close us again.
+            self._watcher_stop(self._watcher)
+
+    @_base.only_if_watcher
+    def _watcher_ffi_ref(self):
+        libuv.uv_ref(self._watcher)
+
+    @_base.only_if_watcher
+    def _watcher_ffi_unref(self):
+        libuv.uv_unref(self._watcher)
+
+    def _watcher_ffi_start_unref(self):
+        pass
+
+    def _watcher_ffi_stop_ref(self):
+        pass
+
+    def _get_ref(self):
+        # Convert 1/0 to True/False
+        if self._watcher is None:
+            return None
+        return bool(libuv.uv_has_ref(self._watcher))
+
+    def _set_ref(self, value):
+        if value:
+            self._watcher_ffi_ref()
+        else:
+            self._watcher_ffi_unref()
+
+    ref = property(_get_ref, _set_ref)
+
+    def feed(self, _revents, _callback, *_args):
+        # pylint:disable-next=broad-exception-raised
+        raise Exception("Not implemented")
+
+class io(_base.IoMixin, watcher):
+    _watcher_type = 'poll'
+    _watcher_callback_name = '_gevent_poll_callback2'
+
+    # On Windows is critical to be able to garbage collect these
+    # objects in a timely fashion so that they don't get reused
+    # for multiplexing completely different sockets. This is because
+    # uv_poll_init_socket does a lot of setup for the socket to make
+    # polling work. If get reused for another socket that has the same
+    # fileno, things break badly. (In theory this could be a problem
+    # on posix too, but in practice it isn't).
+
+    # TODO: We should probably generalize this to all
+    # ffi watchers. Avoiding GC cycles as much as possible
+    # is a good thing, and potentially allocating new handles
+    # as needed gets us better memory locality.
+
+    # Especially on Windows, we must also account for the case that a
+    # reference to this object has leaked (e.g., the socket object is
+    # still around), but the fileno has been closed and a new one
+    # opened. We must still get a new native watcher at that point. We
+    # handle this case by simply making sure that we don't even have
+    # a native watcher until the object is started, and we shut it down
+    # when the object is stopped.
+
+    # XXX: I was able to solve at least Windows test_ftplib.py issues
+    # with more of a careful use of io objects in socket.py, so
+    # delaying this entirely is at least temporarily on hold. Instead
+    # sticking with the _watcher_create function override for the
+    # moment.
+
+    # XXX: Note 2: Moving to a deterministic close model, which was necessary
+    # for PyPy, also seems to solve the Windows issues. So we're completely taking
+    # this object out of the loop's registration; we don't want GC callbacks and
+    # uv_close anywhere *near* this object.
+
+    _watcher_registers_with_loop_on_create = False
+
+    EVENT_MASK = libuv.UV_READABLE | libuv.UV_WRITABLE | libuv.UV_DISCONNECT
+
+    _multiplex_watchers = ()
+
+    def __init__(self, loop, fd, events, ref=True, priority=None):
+        super(io, self).__init__(loop, fd, events, ref=ref, priority=priority, _args=(fd,))
+        self._fd = fd
+        self._events = events
+        self._multiplex_watchers = []
+
+    def _get_fd(self):
+        return self._fd
+
+    @_base.not_while_active
+    def _set_fd(self, fd):
+        self._fd = fd
+        self._watcher_ffi_init((fd,))
+
+    def _get_events(self):
+        return self._events
+
+    def _set_events(self, events):
+        if events == self._events:
+            return
+        self._events = events
+        if self.active:
+            # We're running but libuv specifically says we can
+            # call start again to change our event mask.
+            assert self._handle is not None
+            self._watcher_start(self._watcher, self._events, self._watcher_callback)
+
+    events = property(_get_events, _set_events)
+
+    def _watcher_ffi_start(self):
+        self._watcher_start(self._watcher, self._events, self._watcher_callback)
+
+    if sys.platform.startswith('win32'):
+        # uv_poll can only handle sockets on Windows, but the plain
+        # uv_poll_init we call on POSIX assumes that the fileno
+        # argument is already a C fileno, as created by
+        # _get_osfhandle. C filenos are limited resources, must be
+        # closed with _close. So there are lifetime issues with that:
+        # calling the C function _close to dispose of the fileno
+        # *also* closes the underlying win32 handle, possibly
+        # prematurely. (XXX: Maybe could do something with weak
+        # references? But to what?)
+
+        # All libuv wants to do with the fileno in uv_poll_init is
+        # turn it back into a Win32 SOCKET handle.
+
+        # Now, libuv provides uv_poll_init_socket, which instead of
+        # taking a C fileno takes the SOCKET, avoiding the need to dance with
+        # the C runtime.
+
+        # It turns out that SOCKET (win32 handles in general) can be
+        # represented with `intptr_t`. It further turns out that
+        # CPython *directly* exposes the SOCKET handle as the value of
+        # fileno (32-bit PyPy does some munging on it, which should
+        # rarely matter). So we can pass socket.fileno() through
+        # to uv_poll_init_socket.
+
+        # See _corecffi_build.
+        _watcher_init = watcher._LIB.uv_poll_init_socket
+
+
+    class _multiplexwatcher(object):
+
+        callback = None
+        args = ()
+        pass_events = False
+        ref = True
+
+        def __init__(self, events, watcher):
+            self._events = events
+
+            # References:
+            # These objects must keep the original IO object alive;
+            # the IO object SHOULD NOT keep these alive to avoid cycles
+            # We MUST NOT rely on GC to clean up the IO objects, but the explicit
+            # calls to close(); see _multiplex_closed.
+            self._watcher_ref = watcher
+
+        events = property(
+            lambda self: self._events,
+            _base.not_while_active(lambda self, nv: setattr(self, '_events', nv)))
+
+        def start(self, callback, *args, **kwargs):
+            self.pass_events = kwargs.get("pass_events")
+            self.callback = callback
+            self.args = args
+
+            watcher = self._watcher_ref
+            if watcher is not None:
+                if not watcher.active:
+                    watcher._io_start()
+                else:
+                    # Make sure we're in the event mask
+                    watcher._calc_and_update_events()
+
+        def stop(self):
+            self.callback = None
+            self.pass_events = None
+            self.args = None
+            watcher = self._watcher_ref
+            if watcher is not None:
+                watcher._io_maybe_stop()
+
+        def close(self):
+            if self._watcher_ref is not None:
+                self._watcher_ref._multiplex_closed(self)
+            self._watcher_ref = None
+
+        @property
+        def active(self):
+            return self.callback is not None
+
+        @property
+        def _watcher(self):
+            # For testing.
+            return self._watcher_ref._watcher
+
+        # ares.pyx depends on this property,
+        # and test__core uses it too
+        fd = property(lambda self: getattr(self._watcher_ref, '_fd', -1),
+                      lambda self, nv: self._watcher_ref._set_fd(nv))
+
+    def _io_maybe_stop(self):
+        self._calc_and_update_events()
+        for w in self._multiplex_watchers:
+            if w.callback is not None:
+                # There's still a reference to it, and it's started,
+                # so we can't stop.
+                return
+        # If we get here, nothing was started
+        # so we can take ourself out of the polling set
+        self.stop()
+
+    def _io_start(self):
+        self._calc_and_update_events()
+        self.start(self._io_callback, pass_events=True)
+
+    def _calc_and_update_events(self):
+        events = 0
+        for watcher in self._multiplex_watchers:
+            if watcher.callback is not None:
+                # Only ask for events that are active.
+                events |= watcher.events
+        self._set_events(events)
+
+
+    def multiplex(self, events):
+        watcher = self._multiplexwatcher(events, self)
+        self._multiplex_watchers.append(watcher)
+        self._calc_and_update_events()
+        return watcher
+
+    def close(self):
+        super(io, self).close()
+        del self._multiplex_watchers
+
+    def _multiplex_closed(self, watcher):
+        self._multiplex_watchers.remove(watcher)
+        if not self._multiplex_watchers:
+            self.stop() # should already be stopped
+            self._no_more_watchers()
+            # It is absolutely critical that we control when the call
+            # to uv_close() gets made. uv_close() of a uv_poll_t
+            # handle winds up calling uv__platform_invalidate_fd,
+            # which, as the name implies, destroys any outstanding
+            # events for the *fd* that haven't been delivered yet, and also removes
+            # the *fd* from the poll set. So if this happens later, at some
+            # non-deterministic time when (cyclic or otherwise) GC runs,
+            # *and* we've opened a new watcher for the fd, that watcher will
+            # suddenly and mysteriously stop seeing events. So we do this now;
+            # this method is smart enough not to close the handle twice.
+            self.close()
+        else:
+            self._calc_and_update_events()
+
+    def _no_more_watchers(self):
+        # The loop sets this on an individual watcher to delete it from
+        # the active list where it keeps hard references.
+        pass
+
+    def _io_callback(self, events):
+        if events < 0:
+            # actually a status error code
+            _dbg("Callback error on", self._fd,
+                 ffi.string(libuv.uv_err_name(events)),
+                 ffi.string(libuv.uv_strerror(events)))
+            # XXX: We've seen one half of a FileObjectPosix pair
+            # (the read side of a pipe) report errno 11 'bad file descriptor'
+            # after the write side was closed and its watcher removed. But
+            # we still need to attempt to read from it to clear out what's in
+            # its buffers--if we return with the watcher inactive before proceeding to wake up
+            # the reader, we get a LoopExit. So we can't return here and arguably shouldn't print it
+            # either. The negative events mask will match the watcher's mask.
+            # See test__fileobject.py:Test.test_newlines for an example.
+
+            # On Windows (at least with PyPy), we can get ENOTSOCK (socket operation on non-socket)
+            # if a socket gets closed. If we don't pass the events on, we hang.
+            # See test__makefile_ref.TestSSL for examples.
+            # return
+
+        for watcher in self._multiplex_watchers:
+            if not watcher.callback:
+                # Stopped
+                continue
+            assert watcher._watcher_ref is self, (self, watcher._watcher_ref)
+
+            send_event = (events & watcher.events) or events < 0
+            if send_event:
+                if not watcher.pass_events:
+                    watcher.callback(*watcher.args)
+                else:
+                    watcher.callback(events, *watcher.args)
+
+class _SimulatedWithAsyncMixin(object):
+    _watcher_skip_ffi = True
+
+    def __init__(self, loop, *args, **kwargs):
+        self._async = loop.async_()
+        try:
+            super(_SimulatedWithAsyncMixin, self).__init__(loop, *args, **kwargs)
+        except:
+            self._async.close()
+            raise
+
+    def _watcher_create(self, _args):
+        return
+
+    @property
+    def _watcher_handle(self):
+        return None
+
+    def _watcher_ffi_init(self, _args):
+        return
+
+    def _watcher_ffi_set_init_ref(self, ref):
+        self._async.ref = ref
+
+    @property
+    def active(self):
+        return self._async.active
+
+    def start(self, cb, *args):
+        assert self._async is not None
+        self._register_loop_callback()
+        self.callback = cb
+        self.args = args
+        self._async.start(cb, *args)
+
+    def stop(self):
+        self._unregister_loop_callback()
+        self.callback = None
+        self.args = None
+        if self._async is not None:
+            # If we're stop() after close().
+            # That should be allowed.
+            self._async.stop()
+
+    def close(self):
+        if self._async is not None:
+            a = self._async
+            self._async = None
+            a.close()
+
+    def _register_loop_callback(self):
+        # called from start()
+        raise NotImplementedError()
+
+    def _unregister_loop_callback(self):
+        # called from stop
+        raise NotImplementedError()
+
+class fork(_SimulatedWithAsyncMixin,
+           _base.ForkMixin,
+           watcher):
+    # We'll have to implement this one completely manually.
+    _watcher_skip_ffi = False
+
+    def _register_loop_callback(self):
+        self.loop._fork_watchers.add(self)
+
+    def _unregister_loop_callback(self):
+        try:
+            # stop() should be idempotent
+            self.loop._fork_watchers.remove(self)
+        except KeyError:
+            pass
+
+    def _on_fork(self):
+        self._async.send()
+
+
+class child(_SimulatedWithAsyncMixin,
+            _base.ChildMixin,
+            watcher):
+    _watcher_skip_ffi = True
+    # We'll have to implement this one completely manually.
+    # Our approach is to use a SIGCHLD handler and the original
+    # os.waitpid call.
+
+    # On Unix, libuv's uv_process_t and uv_spawn use SIGCHLD,
+    # just like libev does for its child watchers. So
+    # we're not adding any new SIGCHLD related issues not already
+    # present in libev.
+
+
+    def _register_loop_callback(self):
+        self.loop._register_child_watcher(self)
+
+    def _unregister_loop_callback(self):
+        self.loop._unregister_child_watcher(self)
+
+    def _set_waitpid_status(self, pid, status):
+        self._rpid = pid
+        self._rstatus = status
+        self._async.send()
+
+
+class async_(_base.AsyncMixin, watcher):
+    _watcher_callback_name = '_gevent_async_callback0'
+
+    # libuv async watchers are different than all other watchers:
+    # They don't have a separate start/stop method (presumably
+    # because of race conditions). Simply initing them places them
+    # into the active queue.
+    #
+    # In the past, we sent a NULL C callback to the watcher, trusting
+    # that no one would call send() without actually starting us (or after
+    # closing us); doing so would crash. But we don't want to delay
+    # initing the struct because it will crash in uv_close() when we get GC'd,
+    # and send() will also crash. Plus that complicates our lifecycle (managing
+    # the memory).
+    #
+    # Now, we always init the correct C callback, and use a dummy
+    # Python callback that gets replaced when we are started and
+    # stopped. This prevents mistakes from being crashes.
+    _callback = lambda: None
+
+    def _watcher_ffi_init(self, args):
+        # NOTE: uv_async_init is NOT idempotent. Calling it more than
+        # once adds the uv_async_t to the internal queue multiple times,
+        # and uv_close only cleans up one of them, meaning that we tend to
+        # crash. Thus we have to be very careful not to allow that.
+        return self._watcher_init(self.loop.ptr, self._watcher,
+                                  self._watcher_callback)
+
+    def _watcher_ffi_start(self):
+        pass
+
+    def _watcher_ffi_stop(self):
+        pass
+
+    def send(self):
+        assert self._callback is not async_._callback, "Sending to a closed watcher"
+        if libuv.uv_is_closing(self._watcher):
+            # pylint:disable-next=broad-exception-raised
+            raise Exception("Closing handle")
+        libuv.uv_async_send(self._watcher)
+
+    @property
+    def pending(self):
+        return None
+
+locals()['async'] = async_
+
+class timer(_base.TimerMixin, watcher):
+
+    _watcher_callback_name = '_gevent_timer_callback0'
+
+    # In libuv, timer callbacks continue running while any timer is
+    # expired, including newly added timers. Newly added non-zero
+    # timers (especially of small duration) can be seen to be expired
+    # if the loop time is updated while we are in a timer callback.
+    # This can lead to us being stuck running timers for a terribly
+    # long time, which is not good. So default to not updating the
+    # time.
+
+    # Also, newly-added timers of 0 duration can *also* stall the
+    # loop, because they'll be seen to be expired immediately.
+    # Updating the time can prevent that, *if* there was already a
+    # timer for a longer duration scheduled.
+
+    # To mitigate the above problems, our loop implementation turns
+    # zero duration timers into check watchers instead using OneShotCheck.
+    # This ensures the loop cycles. Of course, the 'again' method does
+    # nothing on them and doesn't exist. In practice that's not an issue.
+
+    _again = False
+
+    def _watcher_ffi_init(self, args):
+        self._watcher_init(self.loop.ptr, self._watcher)
+        self._after, self._repeat = args
+        if self._after and self._after < 0.001:
+            import warnings
+            # XXX: The stack level is hard to determine, could be getting here
+            # through a number of different ways.
+            warnings.warn("libuv only supports millisecond timer resolution; "
+                          "all times less will be set to 1 ms",
+                          stacklevel=6)
+            # The alternative is to effectively pass in int(0.1) == 0, which
+            # means no sleep at all, which leads to excessive wakeups
+            self._after = 0.001
+        if self._repeat and self._repeat < 0.001:
+            import warnings
+            warnings.warn("libuv only supports millisecond timer resolution; "
+                          "all times less will be set to 1 ms",
+                          stacklevel=6)
+            self._repeat = 0.001
+
+    def _watcher_ffi_start(self):
+        if self._again:
+            libuv.uv_timer_again(self._watcher)
+        else:
+            try:
+                self._watcher_start(self._watcher, self._watcher_callback,
+                                    int(self._after * 1000),
+                                    int(self._repeat * 1000))
+            except ValueError:
+                # in case of non-ints in _after/_repeat
+                raise TypeError()
+
+    def again(self, callback, *args, **kw):
+        if not self.active:
+            # If we've never been started, this is the same as starting us.
+            # libuv makes the distinction, libev doesn't.
+            self.start(callback, *args, **kw)
+            return
+
+        self._again = True
+        try:
+            self.start(callback, *args, **kw)
+        finally:
+            del self._again
+
+
+class stat(_base.StatMixin, watcher):
+    _watcher_type = 'fs_poll'
+    _watcher_struct_name = 'gevent_fs_poll_t'
+    _watcher_callback_name = '_gevent_fs_poll_callback3'
+
+    def _watcher_set_data(self, the_watcher, data):
+        the_watcher.handle.data = data
+        return data
+
+    def _watcher_ffi_init(self, args):
+        return self._watcher_init(self.loop.ptr, self._watcher)
+
+    MIN_STAT_INTERVAL = 0.1074891 # match libev; 0.0 is default
+
+    def _watcher_ffi_start(self):
+        # libev changes this when the watcher is started
+        self._interval = max(self._interval, self.MIN_STAT_INTERVAL)
+        self._watcher_start(self._watcher, self._watcher_callback,
+                            self._cpath,
+                            int(self._interval * 1000))
+
+    @property
+    def _watcher_handle(self):
+        return self._watcher.handle.data
+
+    @property
+    def attr(self):
+        if not self._watcher.curr.st_nlink:
+            return
+        return self._watcher.curr
+
+    @property
+    def prev(self):
+        if not self._watcher.prev.st_nlink:
+            return
+        return self._watcher.prev
+
+
+class signal(_base.SignalMixin, watcher):
+    _watcher_callback_name = '_gevent_signal_callback1'
+
+    def _watcher_ffi_init(self, args):
+        self._watcher_init(self.loop.ptr, self._watcher)
+        self.ref = False # libev doesn't ref these by default
+
+
+    def _watcher_ffi_start(self):
+        self._watcher_start(self._watcher, self._watcher_callback,
+                            self._signalnum)
+
+
+class idle(_base.IdleMixin, watcher):
+    # Because libuv doesn't support priorities, idle watchers are
+    # potentially quite a bit different than under libev
+    _watcher_callback_name = '_gevent_idle_callback0'
+
+
+class check(_base.CheckMixin, watcher):
+    _watcher_callback_name = '_gevent_check_callback0'
+
+class OneShotCheck(check):
+
+    _watcher_skip_ffi = True
+
+    def __make_cb(self, func):
+        stop = self.stop
+        @functools.wraps(func)
+        def cb(*args):
+            stop()
+            return func(*args)
+        return cb
+
+    def start(self, callback, *args):
+        return check.start(self, self.__make_cb(callback), *args)
+
+class prepare(_base.PrepareMixin, watcher):
+    _watcher_callback_name = '_gevent_prepare_callback0'

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/local.py

@@ -0,0 +1,610 @@
+# cython: auto_pickle=False,embedsignature=True,always_allow_keywords=False
+"""
+Greenlet-local objects.
+
+This module is based on `_threading_local.py`__ from the standard
+library of Python 3.4.
+
+__ https://github.com/python/cpython/blob/3.4/Lib/_threading_local.py
+
+Greenlet-local objects support the management of greenlet-local data.
+If you have data that you want to be local to a greenlet, simply create
+a greenlet-local object and use its attributes:
+
+  >>> import gevent
+  >>> from gevent.local import local
+  >>> mydata = local()
+  >>> mydata.number = 42
+  >>> mydata.number
+  42
+
+You can also access the local-object's dictionary:
+
+  >>> mydata.__dict__
+  {'number': 42}
+  >>> mydata.__dict__.setdefault('widgets', [])
+  []
+  >>> mydata.widgets
+  []
+
+What's important about greenlet-local objects is that their data are
+local to a greenlet. If we access the data in a different greenlet:
+
+  >>> log = []
+  >>> def f():
+  ...     items = list(mydata.__dict__.items())
+  ...     items.sort()
+  ...     log.append(items)
+  ...     mydata.number = 11
+  ...     log.append(mydata.number)
+  >>> greenlet = gevent.spawn(f)
+  >>> greenlet.join()
+  >>> log
+  [[], 11]
+
+we get different data.  Furthermore, changes made in the other greenlet
+don't affect data seen in this greenlet:
+
+  >>> mydata.number
+  42
+
+Of course, values you get from a local object, including a __dict__
+attribute, are for whatever greenlet was current at the time the
+attribute was read.  For that reason, you generally don't want to save
+these values across greenlets, as they apply only to the greenlet they
+came from.
+
+You can create custom local objects by subclassing the local class:
+
+  >>> class MyLocal(local):
+  ...     number = 2
+  ...     initialized = False
+  ...     def __init__(self, **kw):
+  ...         if self.initialized:
+  ...             raise SystemError('__init__ called too many times')
+  ...         self.initialized = True
+  ...         self.__dict__.update(kw)
+  ...     def squared(self):
+  ...         return self.number ** 2
+
+This can be useful to support default values, methods and
+initialization.  Note that if you define an __init__ method, it will be
+called each time the local object is used in a separate greenlet.  This
+is necessary to initialize each greenlet's dictionary.
+
+Now if we create a local object:
+
+  >>> mydata = MyLocal(color='red')
+
+Now we have a default number:
+
+  >>> mydata.number
+  2
+
+an initial color:
+
+  >>> mydata.color
+  'red'
+  >>> del mydata.color
+
+And a method that operates on the data:
+
+  >>> mydata.squared()
+  4
+
+As before, we can access the data in a separate greenlet:
+
+  >>> log = []
+  >>> greenlet = gevent.spawn(f)
+  >>> greenlet.join()
+  >>> log
+  [[('color', 'red'), ('initialized', True)], 11]
+
+without affecting this greenlet's data:
+
+  >>> mydata.number
+  2
+  >>> mydata.color
+  Traceback (most recent call last):
+  ...
+  AttributeError: 'MyLocal' object has no attribute 'color'
+
+Note that subclasses can define slots, but they are not greenlet
+local. They are shared across greenlets::
+
+  >>> class MyLocal(local):
+  ...     __slots__ = 'number'
+
+  >>> mydata = MyLocal()
+  >>> mydata.number = 42
+  >>> mydata.color = 'red'
+
+So, the separate greenlet:
+
+  >>> greenlet = gevent.spawn(f)
+  >>> greenlet.join()
+
+affects what we see:
+
+  >>> mydata.number
+  11
+
+>>> del mydata
+
+.. versionchanged:: 1.1a2
+   Update the implementation to match Python 3.4 instead of Python 2.5.
+   This results in locals being eligible for garbage collection as soon
+   as their greenlet exits.
+
+.. versionchanged:: 1.2.3
+   Use a weak-reference to clear the greenlet link we establish in case
+   the local object dies before the greenlet does.
+
+.. versionchanged:: 1.3a1
+   Implement the methods for attribute access directly, handling
+   descriptors directly here. This allows removing the use of a lock
+   and facilitates greatly improved performance.
+
+.. versionchanged:: 1.3a1
+   The ``__init__`` method of subclasses of ``local`` is no longer
+   called with a lock held. CPython does not use such a lock in its
+   native implementation. This could potentially show as a difference
+   if code that uses multiple dependent attributes in ``__slots__``
+   (which are shared across all greenlets) switches during ``__init__``.
+
+"""
+from __future__ import print_function
+
+from copy import copy
+from weakref import ref
+
+
+locals()['getcurrent'] = __import__('greenlet').getcurrent
+locals()['greenlet_init'] = lambda: None
+
+__all__ = [
+    "local",
+]
+
+# The key used in the Thread objects' attribute dicts.
+# We keep it a string for speed but make it unlikely to clash with
+# a "real" attribute.
+key_prefix = '_gevent_local_localimpl_'
+
+# The overall structure is as follows:
+# For each local() object:
+# greenlet.__dict__[key_prefix + str(id(local))]
+#    => _localimpl.dicts[id(greenlet)] => (ref(greenlet), {})
+
+# That final tuple is actually a localimpl_dict_entry object.
+
+def all_local_dicts_for_greenlet(greenlet):
+    """
+    Internal debug helper for getting the local values associated
+    with a greenlet. This is subject to change or removal at any time.
+
+    :return: A list of ((type, id), {}) pairs, where the first element
+      is the type and id of the local object and the second object is its
+      instance dictionary, as seen from this greenlet.
+
+    .. versionadded:: 1.3a2
+    """
+
+    result = []
+    id_greenlet = id(greenlet)
+    greenlet_dict = greenlet.__dict__
+    for k, v in greenlet_dict.items():
+        if not k.startswith(key_prefix):
+            continue
+        local_impl = v()
+        if local_impl is None:
+            continue
+        entry = local_impl.dicts.get(id_greenlet)
+        if entry is None:
+            # Not yet used in this greenlet.
+            continue
+        assert entry.wrgreenlet() is greenlet
+        result.append((local_impl.localtypeid, entry.localdict))
+
+    return result
+
+
+class _wrefdict(dict):
+    """A dict that can be weak referenced"""
+
+class _greenlet_deleted(object):
+    """
+    A weakref callback for when the greenlet
+    is deleted.
+
+    If the greenlet is a `gevent.greenlet.Greenlet` and
+    supplies ``rawlink``, that will be used instead of a
+    weakref.
+    """
+    __slots__ = ('idt', 'wrdicts')
+
+    def __init__(self, idt, wrdicts):
+        self.idt = idt
+        self.wrdicts = wrdicts
+
+    def __call__(self, _unused):
+        dicts = self.wrdicts()
+        if dicts:
+            dicts.pop(self.idt, None)
+
+class _local_deleted(object):
+    __slots__ = ('key', 'wrthread', 'greenlet_deleted')
+
+    def __init__(self, key, wrthread, greenlet_deleted):
+        self.key = key
+        self.wrthread = wrthread
+        self.greenlet_deleted = greenlet_deleted
+
+    def __call__(self, _unused):
+        thread = self.wrthread()
+        if thread is not None:
+            try:
+                unlink = thread.unlink
+            except AttributeError:
+                pass
+            else:
+                unlink(self.greenlet_deleted)
+            del thread.__dict__[self.key]
+
+class _localimpl(object):
+    """A class managing thread-local dicts"""
+    __slots__ = ('key', 'dicts',
+                 'localargs', 'localkwargs',
+                 'localtypeid',
+                 '__weakref__',)
+
+    def __init__(self, args, kwargs, local_type, id_local):
+        self.key = key_prefix + str(id(self))
+        # { id(greenlet) -> _localimpl_dict_entry(ref(greenlet), greenlet-local dict) }
+        self.dicts = _wrefdict()
+        self.localargs = args
+        self.localkwargs = kwargs
+        self.localtypeid = local_type, id_local
+
+        # We need to create the thread dict in anticipation of
+        # __init__ being called, to make sure we don't call it
+        # again ourselves. MUST do this before setting any attributes.
+        greenlet = getcurrent() # pylint:disable=undefined-variable
+        _localimpl_create_dict(self, greenlet, id(greenlet))
+
+class _localimpl_dict_entry(object):
+    """
+    The object that goes in the ``dicts`` of ``_localimpl``
+    object for each thread.
+    """
+    # This is a class, not just a tuple, so that cython can optimize
+    # attribute access
+    __slots__ = ('wrgreenlet', 'localdict')
+
+    def __init__(self, wrgreenlet, localdict):
+        self.wrgreenlet = wrgreenlet
+        self.localdict = localdict
+
+# We use functions instead of methods so that they can be cdef'd in
+# local.pxd; if they were cdef'd as methods, they would cause
+# the creation of a pointer and a vtable. This happens
+# even if we declare the class @cython.final. functions thus save memory overhead
+# (but not pointer chasing overhead; the vtable isn't used when we declare
+# the class final).
+
+
+def _localimpl_create_dict(self, greenlet, id_greenlet):
+    """Create a new dict for the current thread, and return it."""
+    localdict = {}
+    key = self.key
+
+    wrdicts = ref(self.dicts)
+
+    # When the greenlet is deleted, remove the local dict.
+    # Note that this is suboptimal if the greenlet object gets
+    # caught in a reference loop. We would like to be called
+    # as soon as the OS-level greenlet ends instead.
+
+    # If we are working with a gevent.greenlet.Greenlet, we
+    # can pro-actively clear out with a link, avoiding the
+    # issue described above. Use rawlink to avoid spawning any
+    # more greenlets.
+    greenlet_deleted = _greenlet_deleted(id_greenlet, wrdicts)
+
+    rawlink = getattr(greenlet, 'rawlink', None)
+    if rawlink is not None:
+        rawlink(greenlet_deleted)
+        wrthread = ref(greenlet)
+    else:
+        wrthread = ref(greenlet, greenlet_deleted)
+
+
+    # When the localimpl is deleted, remove the thread attribute.
+    local_deleted = _local_deleted(key, wrthread, greenlet_deleted)
+
+
+    wrlocal = ref(self, local_deleted)
+    greenlet.__dict__[key] = wrlocal
+
+    self.dicts[id_greenlet] = _localimpl_dict_entry(wrthread, localdict)
+    return localdict
+
+
+_marker = object()
+
+def _local_get_dict(self):
+    impl = self._local__impl
+    # Cython can optimize dict[], but not dict.get()
+    greenlet = getcurrent() # pylint:disable=undefined-variable
+    idg = id(greenlet)
+    try:
+        entry = impl.dicts[idg]
+        dct = entry.localdict
+    except KeyError:
+        dct = _localimpl_create_dict(impl, greenlet, idg)
+        self.__init__(*impl.localargs, **impl.localkwargs)
+    return dct
+
+def _init():
+    greenlet_init() # pylint:disable=undefined-variable
+
+_local_attrs = {
+    '_local__impl',
+    '_local_type_get_descriptors',
+    '_local_type_set_or_del_descriptors',
+    '_local_type_del_descriptors',
+    '_local_type_set_descriptors',
+    '_local_type',
+    '_local_type_vars',
+    '__class__',
+    '__cinit__',
+}
+
+class local(object):
+    """
+    An object whose attributes are greenlet-local.
+    """
+    __slots__ = tuple(_local_attrs - {'__class__', '__cinit__'})
+
+    def __cinit__(self, *args, **kw): # pylint:disable=bad-dunder-name
+        if args or kw:
+            if type(self).__init__ == object.__init__: # pylint:disable=comparison-with-callable
+                raise TypeError("Initialization arguments are not supported", args, kw)
+        impl = _localimpl(args, kw, type(self), id(self))
+        # pylint:disable=attribute-defined-outside-init
+        self._local__impl = impl
+        get, dels, sets_or_dels, sets = _local_find_descriptors(self)
+        self._local_type_get_descriptors = get
+        self._local_type_set_or_del_descriptors = sets_or_dels
+        self._local_type_del_descriptors = dels
+        self._local_type_set_descriptors = sets
+        self._local_type = type(self)
+        self._local_type_vars = set(dir(self._local_type))
+
+    def __getattribute__(self, name): # pylint:disable=too-many-return-statements
+        if name in _local_attrs:
+            # The _local__impl,  __cinit__, etc, won't be hit by the
+            # Cython version, if we've done things right. If we haven't,
+            # they will be, and this will produce an error.
+            return object.__getattribute__(self, name)
+
+        dct = _local_get_dict(self)
+
+        if name == '__dict__':
+            return dct
+        # If there's no possible way we can switch, because this
+        # attribute is *not* found in the class where it might be a
+        # data descriptor (property), and it *is* in the dict
+        # then we don't need to swizzle the dict and take the lock.
+
+        # We don't have to worry about people overriding __getattribute__
+        # because if they did, the dict-swizzling would only last as
+        # long as we were in here anyway.
+        # Similarly, a __getattr__ will still be called by _oga() if needed
+        # if it's not in the dict.
+
+        # Optimization: If we're not subclassed, then
+        # there can be no descriptors except for methods, which will
+        # never need to use __dict__.
+        if self._local_type is local:
+            return dct[name] if name in dct else object.__getattribute__(self, name)
+
+        # NOTE: If this is a descriptor, this will invoke its __get__.
+        # A broken descriptor that doesn't return itself when called with
+        # a None for the instance argument could mess us up here.
+        # But this is faster than a loop over mro() checking each class __dict__
+        # manually.
+        if name in dct:
+            if name not in self._local_type_vars:
+                # If there is a dict value, and nothing in the type,
+                # it can't possibly be a descriptor, so it is just returned.
+                return dct[name]
+
+            # It's in the type *and* in the dict. If the type value is
+            # a data descriptor (defines __get__ *and* either __set__ or
+            # __delete__), then the type wins. If it's a non-data descriptor
+            # (defines just __get__), then the instance wins. If it's not a
+            # descriptor at all (doesn't have __get__), the instance wins.
+            # NOTE that the docs for descriptors say that these methods must be
+            # defined on the *class* of the object in the type.
+            if name not in self._local_type_get_descriptors:
+                # Entirely not a descriptor. Instance wins.
+                return dct[name]
+            if name in self._local_type_set_or_del_descriptors:
+                # A data descriptor.
+                # arbitrary code execution while these run. If they touch self again,
+                # they'll call back into us and we'll repeat the dance.
+                type_attr = getattr(self._local_type, name)
+                return type(type_attr).__get__(type_attr, self, self._local_type)
+            # Last case is a non-data descriptor. Instance wins.
+            return dct[name]
+
+        if name in self._local_type_vars:
+            # Not in the dictionary, but is found in the type. It could be
+            # a non-data descriptor still. Some descriptors, like @staticmethod,
+            # return objects (functions, in this case), that are *themselves*
+            # descriptors, which when invoked, again, would do the wrong thing.
+            # So we can't rely on getattr() on the type for them, we have to
+            # look through the MRO dicts ourself.
+            if name not in self._local_type_get_descriptors:
+                # Not a descriptor, can't execute code. So all we need is
+                # the return value of getattr() on our type.
+                return getattr(self._local_type, name)
+
+            for base in self._local_type.mro():
+                bd = base.__dict__
+                if name in bd:
+                    attr_on_type = bd[name]
+                    result = type(attr_on_type).__get__(attr_on_type, self, self._local_type)
+                    return result
+
+        # It wasn't in the dict and it wasn't in the type.
+        # So the next step is to invoke type(self)__getattr__, if it
+        # exists, otherwise raise an AttributeError.
+        # we will invoke type(self).__getattr__ or raise an attribute error.
+        if hasattr(self._local_type, '__getattr__'):
+            return self._local_type.__getattr__(self, name)
+        raise AttributeError("%r object has no attribute '%s'"
+                             % (self._local_type.__name__, name))
+
+    def __setattr__(self, name, value):
+        if name == '__dict__':
+            raise AttributeError(
+                "%r object attribute '__dict__' is read-only"
+                % type(self))
+
+        if name in _local_attrs:
+            object.__setattr__(self, name, value)
+            return
+
+        dct = _local_get_dict(self)
+
+        if self._local_type is local:
+            # Optimization: If we're not subclassed, we can't
+            # have data descriptors, so this goes right in the dict.
+            dct[name] = value
+            return
+
+        if name in self._local_type_vars:
+            if name in self._local_type_set_descriptors:
+                type_attr = getattr(self._local_type, name, _marker)
+                # A data descriptor, like a property or a slot.
+                type(type_attr).__set__(type_attr, self, value)
+                return
+        # Otherwise it goes directly in the dict
+        dct[name] = value
+
+    def __delattr__(self, name):
+        if name == '__dict__':
+            raise AttributeError(
+                "%r object attribute '__dict__' is read-only"
+                % self.__class__.__name__)
+
+        if name in self._local_type_vars:
+            if name in self._local_type_del_descriptors:
+                # A data descriptor, like a property or a slot.
+                type_attr = getattr(self._local_type, name, _marker)
+                type(type_attr).__delete__(type_attr, self)
+                return
+        # Otherwise it goes directly in the dict
+
+        # Begin inlined function _get_dict()
+        dct = _local_get_dict(self)
+
+        try:
+            del dct[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __copy__(self):
+        impl = self._local__impl
+        entry = impl.dicts[id(getcurrent())]  # pylint:disable=undefined-variable
+
+        dct = entry.localdict
+        duplicate = copy(dct)
+
+        cls = type(self)
+        instance = cls(*impl.localargs, **impl.localkwargs)
+        _local__copy_dict_from(instance, impl, duplicate)
+        return instance
+
+def _local__copy_dict_from(self, impl, duplicate):
+    current = getcurrent() # pylint:disable=undefined-variable
+    currentId = id(current)
+    new_impl = self._local__impl
+    assert new_impl is not impl
+    entry = new_impl.dicts[currentId]
+    new_impl.dicts[currentId] = _localimpl_dict_entry(entry.wrgreenlet, duplicate)
+
+def _local_find_descriptors(self):
+    type_self = type(self)
+    gets = set()
+    dels = set()
+    set_or_del = set()
+    sets = set()
+    mro = list(type_self.mro())
+
+    for attr_name in dir(type_self):
+        # Conventionally, descriptors when called on a class
+        # return themself, but not all do. Notable exceptions are
+        # in the zope.interface package, where things like __provides__
+        # return other class attributes. So we can't use getattr, and instead
+        # walk up the dicts
+        for base in mro:
+            bd = base.__dict__
+            if attr_name in bd:
+                attr = bd[attr_name]
+                break
+        else:
+            raise AttributeError(attr_name)
+
+        type_attr = type(attr)
+        if hasattr(type_attr, '__get__'):
+            gets.add(attr_name)
+        if hasattr(type_attr, '__delete__'):
+            dels.add(attr_name)
+            set_or_del.add(attr_name)
+        if hasattr(type_attr, '__set__'):
+            sets.add(attr_name)
+
+    return (gets, dels, set_or_del, sets)
+
+# Cython doesn't let us use __new__, it requires
+# __cinit__. But we need __new__ if we're not compiled
+# (e.g., on PyPy). So we set it at runtime. Cython
+# will raise an error if we're compiled.
+def __new__(cls, *args, **kw):
+    self = super(local, cls).__new__(cls) # pylint:disable=no-value-for-parameter
+    # We get the cls in *args for some reason
+    # too when we do it this way....except on PyPy3, which does
+    # not *unless* it's wrapped in a classmethod (which it is)
+    self.__cinit__(*args[1:], **kw)
+    return self
+
+if local.__module__ == 'gevent.local':
+    # PyPy2/3 and CPython handle adding a __new__ to the class
+    # in different ways. In CPython and PyPy3, it must be wrapped with classmethod;
+    # in PyPy2 < 7.3.3, it must not. In either case, the args that get passed to
+    # it are stil wrong.
+    #
+    # Prior to Python 3.10, Cython-compiled classes were immutable and
+    # raised a TypeError on assignment to __new__, and we relied on that
+    # to detect the compiled version; but that breaks in
+    # 3.10 as classes are now mutable. (See
+    # https://github.com/cython/cython/issues/4326).
+    #
+    # That's OK; post https://github.com/gevent/gevent/issues/1480, the Cython-compiled
+    # module has a different name than the pure-Python version and we can check for that.
+    # It's not as direct, but it works.
+    # So here we're not compiled
+    local.__new__ = classmethod(__new__)
+else: # pragma: no cover
+    # Make sure we revisit in case of changes to the (accelerator) module names.
+    if local.__module__ != 'gevent._gevent_clocal': # pylint:disable=else-if-used
+        raise AssertionError("Module names changed (local: %r; __name__: %r); revisit this code" % (
+            local.__module__, __name__) )
+
+_init()
+
+from gevent._util import import_c_accel
+import_c_accel(globals(), 'gevent._local')

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/lock.py

@@ -0,0 +1,372 @@
+# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
+"""
+Locking primitives.
+
+These include semaphores with arbitrary bounds (:class:`Semaphore` and
+its safer subclass :class:`BoundedSemaphore`) and a semaphore with
+infinite bounds (:class:`DummySemaphore`), along with a reentrant lock
+(:class:`RLock`) with the same API as :class:`threading.RLock`.
+"""
+from __future__ import absolute_import
+from __future__ import print_function
+
+from gevent.hub import getcurrent
+from gevent._compat import PURE_PYTHON
+
+# This is the one exception to the rule of where to
+# import Semaphore, obviously
+from gevent import monkey
+from gevent._semaphore import Semaphore
+from gevent._semaphore import BoundedSemaphore
+
+
+__all__ = [
+    'Semaphore',
+    'BoundedSemaphore',
+    'DummySemaphore',
+    'RLock',
+]
+
+# On PyPy, we don't compile the Semaphore class with Cython. Under
+# Cython, each individual method holds the GIL for its entire
+# duration, ensuring that no other thread can interrupt us in an
+# unsafe state (only when we _wait do we call back into Python and
+# allow switching threads; this is broken down into the
+# _drop_lock_for_switch_out and _acquire_lock_for_switch_in methods).
+# Simulate that here through the use of a manual lock. (We use a
+# separate lock for each semaphore to allow sys.settrace functions to
+# use locks *other* than the one being traced.) This, of course, must
+# also hold for PURE_PYTHON mode when no optional C extensions are
+# used.
+
+_allocate_lock, _get_ident = monkey.get_original(
+    ('_thread', 'thread'),
+    ('allocate_lock', 'get_ident')
+)
+
+def atomic(meth):
+    def m(self, *args):
+        with self._atomic:
+            return meth(self, *args)
+    return m
+
+
+class _GILLock(object):
+    __slots__ = (
+        '_owned_thread_id',
+        '_gil',
+        '_atomic',
+        '_recursion_depth',
+    )
+    # Don't allow re-entry to these functions in a single thread, as
+    # can happen if a sys.settrace is used. (XXX: What does that even
+    # mean? Our original implementation that did that has been
+    # replaced by something more robust)
+    #
+    # This is essentially a variant of the (pure-Python) RLock from the
+    # standard library.
+    def __init__(self):
+        self._owned_thread_id = None
+        self._gil = _allocate_lock()
+        self._atomic = _allocate_lock()
+        self._recursion_depth = 0
+
+    @atomic
+    def acquire(self):
+        current_tid = _get_ident()
+        if self._owned_thread_id == current_tid:
+            self._recursion_depth += 1
+            return True
+
+        # Not owned by this thread. Only one thread will make it through this point.
+        while 1:
+            self._atomic.release()
+            try:
+                self._gil.acquire()
+            finally:
+                self._atomic.acquire()
+            if self._owned_thread_id is None:
+                break
+
+        self._owned_thread_id = current_tid
+        self._recursion_depth = 1
+        return True
+
+    @atomic
+    def release(self):
+        current_tid = _get_ident()
+        if current_tid != self._owned_thread_id:
+            raise RuntimeError("%s: Releasing lock not owned by you. You: 0x%x; Owner: 0x%x" % (
+                self,
+                current_tid, self._owned_thread_id or 0,
+            ))
+
+        self._recursion_depth -= 1
+
+        if not self._recursion_depth:
+            self._owned_thread_id = None
+            self._gil.release()
+
+    def __enter__(self):
+        self.acquire()
+
+    def __exit__(self, t, v, tb):
+        self.release()
+
+    def locked(self):
+        return self._gil.locked()
+
+class _AtomicSemaphoreMixin(object):
+    # Behaves as though the GIL was held for the duration of acquire, wait,
+    # and release, just as if we were in Cython.
+    #
+    # acquire, wait, and release all acquire the lock on entry and release it
+    # on exit. acquire and wait can call _wait, which must release it on entry
+    # and re-acquire it for them on exit.
+    #
+    # Note that this does *NOT*, in-and-of itself, make semaphores safe to use from multiple threads
+    __slots__ = ()
+    def __init__(self, *args, **kwargs):
+        self._lock_lock = _GILLock() # pylint:disable=assigning-non-slot
+        super(_AtomicSemaphoreMixin, self).__init__(*args, **kwargs)
+
+    def _acquire_lock_for_switch_in(self):
+        self._lock_lock.acquire()
+
+    def _drop_lock_for_switch_out(self):
+        self._lock_lock.release()
+
+    def _notify_links(self, arrived_while_waiting):
+        with self._lock_lock:
+            return super(_AtomicSemaphoreMixin, self)._notify_links(arrived_while_waiting)
+
+    def release(self):
+        with self._lock_lock:
+            return super(_AtomicSemaphoreMixin, self).release()
+
+    def acquire(self, blocking=True, timeout=None):
+        with self._lock_lock:
+            return super(_AtomicSemaphoreMixin, self).acquire(blocking, timeout)
+
+    _py3k_acquire = acquire
+
+    def wait(self, timeout=None):
+        with self._lock_lock:
+            return super(_AtomicSemaphoreMixin, self).wait(timeout)
+
+class _AtomicSemaphore(_AtomicSemaphoreMixin, Semaphore):
+    __doc__ = Semaphore.__doc__
+    __slots__ = (
+        '_lock_lock',
+    )
+
+
+class _AtomicBoundedSemaphore(_AtomicSemaphoreMixin, BoundedSemaphore):
+    __doc__ = BoundedSemaphore.__doc__
+    __slots__ = (
+        '_lock_lock',
+    )
+
+    def release(self): # pylint:disable=useless-super-delegation
+        # This method is duplicated here so that it can get
+        # properly documented.
+        return super(_AtomicBoundedSemaphore, self).release()
+
+
+def _fixup_docstrings():
+    for c in _AtomicSemaphore, _AtomicBoundedSemaphore:
+        b = c.__mro__[2]
+        assert b.__name__.endswith('Semaphore') and 'Atomic' not in b.__name__
+        assert c.__doc__ == b.__doc__
+        for m in 'acquire', 'release', 'wait':
+            c_meth = getattr(c, m)
+            b_meth = getattr(b, m)
+            c_meth.__doc__ = b_meth.__doc__
+
+_fixup_docstrings()
+del _fixup_docstrings
+
+
+if PURE_PYTHON:
+    Semaphore = _AtomicSemaphore
+    Semaphore.__name__ = 'Semaphore'
+    BoundedSemaphore = _AtomicBoundedSemaphore
+    BoundedSemaphore.__name__ = 'BoundedSemaphore'
+
+
+class DummySemaphore(object):
+    """
+    DummySemaphore(value=None) -> DummySemaphore
+
+    An object with the same API as :class:`Semaphore`,
+    initialized with "infinite" initial value. None of its
+    methods ever block.
+
+    This can be used to parameterize on whether or not to actually
+    guard access to a potentially limited resource. If the resource is
+    actually limited, such as a fixed-size thread pool, use a real
+    :class:`Semaphore`, but if the resource is unbounded, use an
+    instance of this class. In that way none of the supporting code
+    needs to change.
+
+    Similarly, it can be used to parameterize on whether or not to
+    enforce mutual exclusion to some underlying object. If the
+    underlying object is known to be thread-safe itself mutual
+    exclusion is not needed and a ``DummySemaphore`` can be used, but
+    if that's not true, use a real ``Semaphore``.
+    """
+
+    # Internally this is used for exactly the purpose described in the
+    # documentation. gevent.pool.Pool uses it instead of a Semaphore
+    # when the pool size is unlimited, and
+    # gevent.fileobject.FileObjectThread takes a parameter that
+    # determines whether it should lock around IO to the underlying
+    # file object.
+
+    def __init__(self, value=None):
+        """
+        .. versionchanged:: 1.1rc3
+            Accept and ignore a *value* argument for compatibility with Semaphore.
+        """
+
+    def __str__(self):
+        return '<%s>' % self.__class__.__name__
+
+    def locked(self):
+        """A DummySemaphore is never locked so this always returns False."""
+        return False
+
+    def ready(self):
+        """A DummySemaphore is never locked so this always returns True."""
+        return True
+
+    def release(self):
+        """Releasing a dummy semaphore does nothing."""
+
+    def rawlink(self, callback):
+        # XXX should still work and notify?
+        pass
+
+    def unlink(self, callback):
+        pass
+
+    def wait(self, timeout=None): # pylint:disable=unused-argument
+        """Waiting for a DummySemaphore returns immediately."""
+        return 1
+
+    def acquire(self, blocking=True, timeout=None):
+        """
+        A DummySemaphore can always be acquired immediately so this always
+        returns True and ignores its arguments.
+
+        .. versionchanged:: 1.1a1
+           Always return *true*.
+        """
+        # pylint:disable=unused-argument
+        return True
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, typ, val, tb):
+        pass
+
+
+class RLock(object):
+    """
+    A mutex that can be acquired more than once by the same greenlet.
+
+    A mutex can only be locked by one greenlet at a time. A single greenlet
+    can `acquire` the mutex as many times as desired, though. Each call to
+    `acquire` must be paired with a matching call to `release`.
+
+    It is an error for a greenlet that has not acquired the mutex
+    to release it.
+
+    Instances are context managers.
+    """
+
+    __slots__ = (
+        '_block',
+        '_owner',
+        '_count',
+        '__weakref__',
+    )
+
+    def __init__(self, hub=None):
+        """
+        .. versionchanged:: 20.5.1
+           Add the ``hub`` argument.
+        """
+        self._block = Semaphore(1, hub)
+        self._owner = None
+        self._count = 0
+
+    def __repr__(self):
+        return "<%s at 0x%x _block=%s _count=%r _owner=%r)>" % (
+            self.__class__.__name__,
+            id(self),
+            self._block,
+            self._count,
+            self._owner)
+
+    def acquire(self, blocking=True, timeout=None):
+        """
+        Acquire the mutex, blocking if *blocking* is true, for up to
+        *timeout* seconds.
+
+        .. versionchanged:: 1.5a4
+           Added the *timeout* parameter.
+
+        :return: A boolean indicating whether the mutex was acquired.
+        """
+        me = getcurrent()
+        if self._owner is me:
+            self._count += 1
+            return 1
+        rc = self._block.acquire(blocking, timeout)
+        if rc:
+            self._owner = me
+            self._count = 1
+        return rc
+
+    def __enter__(self):
+        return self.acquire()
+
+    def release(self):
+        """
+        Release the mutex.
+
+        Only the greenlet that originally acquired the mutex can
+        release it.
+        """
+        if self._owner is not getcurrent():
+            raise RuntimeError("cannot release un-acquired lock. Owner: %r Current: %r" % (
+                self._owner, getcurrent()
+            ))
+        self._count = count = self._count - 1 # pylint:disable=consider-using-augmented-assign
+        if not count:
+            self._owner = None
+            self._block.release()
+
+    def __exit__(self, typ, value, tb):
+        self.release()
+
+    # Internal methods used by condition variables
+
+    def _acquire_restore(self, count_owner):
+        count, owner = count_owner
+        self._block.acquire()
+        self._count = count
+        self._owner = owner
+
+    def _release_save(self):
+        count = self._count
+        self._count = 0
+        owner = self._owner
+        self._owner = None
+        self._block.release()
+        return (count, owner)
+
+    def _is_owned(self):
+        return self._owner is getcurrent()

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/__init__.py

@@ -0,0 +1,704 @@
+# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
+# pylint: disable=redefined-outer-name,too-many-lines
+"""
+Make the standard library cooperative.
+
+The primary purpose of this module is to carefully patch, in place,
+portions of the standard library with gevent-friendly functions that
+behave in the same way as the original (at least as closely as possible).
+
+The primary interface to this is the :func:`patch_all` function, which
+performs all the available patches. It accepts arguments to limit the
+patching to certain modules, but most programs **should** use the
+default values as they receive the most wide-spread testing, and some monkey
+patches have dependencies on others.
+
+Patching **should be done as early as possible** in the lifecycle of the
+program. For example, the main module (the one that tests against
+``__main__`` or is otherwise the first imported) should begin with
+this code, ideally before any other imports::
+
+    from gevent import monkey
+    monkey.patch_all()
+
+A corollary of the above is that patching **should be done on the main
+thread** and **should be done while the program is single-threaded**.
+
+.. tip::
+
+    Some frameworks, such as gunicorn, handle monkey-patching for you.
+    Check their documentation to be sure.
+
+.. warning::
+
+    Patching too late can lead to unreliable behaviour (for example, some
+    modules may still use blocking sockets) or even errors.
+
+.. tip::
+
+    Be sure to read the documentation for each patch function to check for
+    known incompatibilities.
+
+Querying
+========
+
+Sometimes it is helpful to know if objects have been monkey-patched, and in
+advanced cases even to have access to the original standard library functions. This
+module provides functions for that purpose.
+
+- :func:`is_module_patched`
+- :func:`is_object_patched`
+- :func:`get_original`
+
+.. _plugins:
+
+Plugins and Events
+==================
+
+Beginning in gevent 1.3, events are emitted during the monkey patching process.
+These events are delivered first to :mod:`gevent.events` subscribers, and then
+to `setuptools entry points`_.
+
+The following events are defined. They are listed in (roughly) the order
+that a call to :func:`patch_all` will emit them.
+
+- :class:`gevent.events.GeventWillPatchAllEvent`
+- :class:`gevent.events.GeventWillPatchModuleEvent`
+- :class:`gevent.events.GeventDidPatchModuleEvent`
+- :class:`gevent.events.GeventDidPatchBuiltinModulesEvent`
+- :class:`gevent.events.GeventDidPatchAllEvent`
+
+Each event class documents the corresponding setuptools entry point name. The
+entry points will be called with a single argument, the same instance of
+the class that was sent to the subscribers.
+
+You can subscribe to the events to monitor the monkey-patching process and
+to manipulate it, for example by raising :exc:`gevent.events.DoNotPatch`.
+
+You can also subscribe to the events to provide additional patching beyond what
+gevent distributes, either for additional standard library modules, or
+for third-party packages. The suggested time to do this patching is in
+the subscriber for :class:`gevent.events.GeventDidPatchBuiltinModulesEvent`.
+For example, to automatically patch `psycopg2`_ using `psycogreen`_
+when the call to :func:`patch_all` is made, you could write code like this::
+
+    # mypackage.py
+    def patch_psycopg(event):
+        from psycogreen.gevent import patch_psycopg
+        patch_psycopg()
+
+In your ``setup.py`` you would register it like this::
+
+    from setuptools import setup
+    setup(
+        ...
+        entry_points={
+            'gevent.plugins.monkey.did_patch_builtins': [
+                'psycopg2 = mypackage:patch_psycopg',
+            ],
+        },
+        ...
+    )
+
+For more complex patching, gevent provides a helper method
+that you can call to replace attributes of modules with attributes of your
+own modules. This function also takes care of emitting the appropriate events.
+
+- :func:`patch_module`
+
+.. _setuptools entry points: http://setuptools.readthedocs.io/en/latest/setuptools.html#dynamic-discovery-of-services-and-plugins
+.. _psycopg2: https://pypi.python.org/pypi/psycopg2
+.. _psycogreen: https://pypi.python.org/pypi/psycogreen
+
+Use as a module
+===============
+
+Sometimes it is useful to run existing python scripts or modules that
+were not built to be gevent aware under gevent. To do so, this module
+can be run as the main module, passing the script and its arguments.
+For details, see the :func:`main` function.
+
+.. versionchanged:: 1.3b1
+   Added support for plugins and began emitting will/did patch events.
+"""
+
+import sys
+
+####
+# gevent developers: IMPORTANT: Keep imports
+# as limited and localized as possible to avoid
+# interfering with the monkey-patch process.
+# This is why many imports are nested inside functions.
+#
+# This applies for this entire package.
+###
+
+__all__ = [
+    'patch_all',
+    'patch_builtins',
+    'patch_dns',
+    'patch_os',
+    'patch_queue',
+    'patch_select',
+    'patch_signal',
+    'patch_socket',
+    'patch_ssl',
+    'patch_subprocess',
+    'patch_sys',
+    'patch_thread',
+    'patch_time',
+    # query functions
+    'get_original',
+    'is_module_patched',
+    'is_object_patched',
+
+    # 'is_anything_patched', <- see docstring
+
+    # plugin API
+    'patch_module',
+    # module functions
+    'main',
+    # Errors and warnings
+    'MonkeyPatchWarning',
+]
+
+WIN = sys.platform.startswith("win")
+
+# Unused imports may be removed in a major release after 2024-10.
+# Used private imports may be renamed or removed or changed
+# in an incompatible way at that time.
+
+
+
+from ._errors import MonkeyPatchWarning
+
+from ._util import _notify_patch
+from ._util import _ignores_DoNotPatch
+
+from ._state import saved
+from ._state import is_module_patched
+from ._state import is_object_patched
+
+# Never documented as a public API, but
+# potentially in use by third parties
+# given the naming convention.
+from ._state import is_anything_patched # pylint:disable=unused-import
+from ._errors import _BadImplements # pylint:disable=unused-import
+
+
+
+from .api import get_original
+from .api import patch_module
+
+
+
+# These are not part of the documented public API,
+# but they could be used by plugins. TODO: Do we
+# want to make them public with __all__?
+from .api import patch_item
+from .api import remove_item
+
+
+
+
+
+
+
+
+from ._util import _check_availability
+from ._util import _patch_module
+from ._util import _queue_warning
+from ._util import _process_warnings
+
+
+
+def _patch_sys_std(name):
+    from gevent.fileobject import FileObjectThread
+    orig = getattr(sys, name)
+    if not isinstance(orig, FileObjectThread):
+        patch_item(sys, name, FileObjectThread(orig))
+
+@_ignores_DoNotPatch
+def patch_sys(stdin=True, stdout=True, stderr=True): # pylint:disable=unused-argument
+    """
+    Patch sys.std[in,out,err] to use a cooperative IO via a
+    threadpool.
+
+    This is relatively dangerous and can have unintended consequences
+    such as hanging the process or `misinterpreting control keys`_
+    when :func:`input` and :func:`raw_input` are used. :func:`patch_all`
+    does *not* call this function by default.
+
+    This method does nothing on Python 3. The Python 3 interpreter
+    wants to flush the TextIOWrapper objects that make up
+    stderr/stdout at shutdown time, but using a threadpool at that
+    time leads to a hang.
+
+    .. _`misinterpreting control keys`: https://github.com/gevent/gevent/issues/274
+
+    .. deprecated:: 23.7.0
+       Does nothing on any supported version.
+    """
+    return
+
+@_ignores_DoNotPatch
+def patch_os():
+    """
+    Replace :func:`os.fork` with :func:`gevent.fork`, and, on POSIX,
+    :func:`os.waitpid` with :func:`gevent.os.waitpid` (if the
+    environment variable ``GEVENT_NOWAITPID`` is not defined). Does
+    nothing if fork is not available.
+
+    .. caution:: This method must be used with :func:`patch_signal` to have proper `SIGCHLD`
+         handling and thus correct results from ``waitpid``.
+         :func:`patch_all` calls both by default.
+
+    .. caution:: For `SIGCHLD` handling to work correctly, the event loop must run.
+         The easiest way to help ensure this is to use :func:`patch_all`.
+    """
+    _patch_module('os')
+
+
+@_ignores_DoNotPatch
+def patch_queue():
+    """
+    Patch objects in :mod:`queue`.
+
+
+    Currently, this just replaces :class:`queue.SimpleQueue` (implemented
+    in C) with its Python counterpart, but the details may change at any time.
+
+    .. versionadded:: 1.3.5
+    """
+    _patch_module('queue', items=[
+        'SimpleQueue',
+    ])
+
+
+@_ignores_DoNotPatch
+def patch_time():
+    """
+    Replace :func:`time.sleep` with :func:`gevent.sleep`.
+    """
+    _patch_module('time')
+
+@_ignores_DoNotPatch
+def patch_contextvars():
+    """
+    Replaces the implementations of :mod:`contextvars` with
+    :mod:`gevent.contextvars`.
+
+    On Python 3.7 and above, this is a standard library module. On
+    earlier versions, a backport that uses the same distribution name
+    and import name is available on PyPI (though this is not
+    recommended). If that is installed, it will be patched.
+
+    .. versionchanged:: 20.04.0
+       Clarify that the backport is also patched.
+
+    .. versionchanged:: 20.9.0
+       This now does nothing on Python 3.7 and above.
+       gevent now depends on greenlet 0.4.17, which
+       natively handles switching context vars when greenlets are switched.
+       Older versions of Python that have the backport installed will
+       still be patched.
+
+    .. deprecated:: 23.7.0
+       Does nothing on any supported version.
+    """
+    return
+
+
+
+@_ignores_DoNotPatch
+def patch_thread(threading=True, _threading_local=True, Event=True, logging=True,
+                 existing_locks=True,
+                 _warnings=None):
+    """
+    patch_thread(threading=True, _threading_local=True, Event=True, logging=True, existing_locks=True) -> None
+
+    Replace the standard :mod:`thread` module to make it greenlet-based.
+
+    :keyword bool threading: When True (the default),
+        also patch :mod:`threading`.
+    :keyword bool _threading_local: When True (the default),
+        also patch :class:`_threading_local.local`.
+    :keyword bool logging: When True (the default), also patch locks
+        taken if the logging module has been configured.
+
+    :keyword bool existing_locks: When True (the default), and the
+        process is still single threaded, make sure that any
+        :class:`threading.RLock` (and, under Python 3, :class:`importlib._bootstrap._ModuleLock`)
+        instances that are currently locked can be properly unlocked. **Important**: This is a
+        best-effort attempt and, on certain implementations, may not detect all
+        locks. It is important to monkey-patch extremely early in the startup process.
+        Setting this to False is not recommended, especially on Python 2.
+
+    .. caution::
+        Monkey-patching :mod:`thread` and using
+        :class:`multiprocessing.Queue` or
+        :class:`concurrent.futures.ProcessPoolExecutor` (which uses a
+        ``Queue``) will hang the process.
+
+        Monkey-patching with this function and using
+        sub-interpreters (and advanced C-level API) and threads may be
+        unstable on certain platforms.
+
+    .. versionchanged:: 1.1b1
+        Add *logging* and *existing_locks* params.
+    .. versionchanged:: 1.3a2
+        ``Event`` defaults to True.
+    """
+    if sys.version_info[:2] < (3, 13):
+        from ._patch_thread_lt313 import Patcher
+    else:
+        from ._patch_thread_gte313 import Patcher
+    patch = Patcher(threading=threading, _threading_local=_threading_local, Event=Event,
+                    logging=logging, existing_locks=existing_locks, _warnings=_warnings)
+    patch()
+
+
+@_ignores_DoNotPatch
+def patch_socket(dns=True, aggressive=True):
+    """
+    Replace the standard socket object with gevent's cooperative
+    sockets.
+
+    :keyword bool dns: When true (the default), also patch address
+        resolution functions in :mod:`socket`. See :doc:`/dns` for details.
+    """
+    from gevent import socket
+    # Note: although it seems like it's not strictly necessary to monkey patch 'create_connection',
+    # it's better to do it. If 'create_connection' was not monkey patched, but the rest of socket module
+    # was, create_connection would still use "green" getaddrinfo and "green" socket.
+    # However, because gevent.socket.socket.connect is a Python function, the exception raised by it causes
+    # _socket object to be referenced by the frame, thus causing the next invocation of bind(source_address) to fail.
+    if dns:
+        items = socket.__implements__ # pylint:disable=no-member
+    else:
+        items = set(socket.__implements__) - set(socket.__dns__) # pylint:disable=no-member
+    _patch_module('socket', items=items)
+    if aggressive:
+        if 'ssl' not in socket.__implements__: # pylint:disable=no-member
+            remove_item(socket, 'ssl')
+
+@_ignores_DoNotPatch
+def patch_dns():
+    """
+    Replace :doc:`DNS functions </dns>` in :mod:`socket` with
+    cooperative versions.
+
+    This is only useful if :func:`patch_socket` has been called and is
+    done automatically by that method if requested.
+    """
+    from gevent import socket
+    _patch_module('socket', items=socket.__dns__) # pylint:disable=no-member
+
+
+def _find_module_refs(to, excluding_names=()):
+    # Looks specifically for module-level references,
+    # i.e., 'from foo import Bar'. We define a module reference
+    # as a dict (subclass) that also has a __name__ attribute.
+    # This does not handle subclasses, but it does find them.
+    # Returns two sets. The first is modules (name, file) that were
+    # found. The second is subclasses that were found.
+    gc = __import__('gc')
+    direct_ref_modules = set()
+    subclass_modules = set()
+
+    def report(mod):
+        return mod['__name__'], mod.get('__file__', '<unknown>')
+
+    for r in gc.get_referrers(to):
+        if isinstance(r, dict) and '__name__' in r:
+            if r['__name__'] in excluding_names:
+                continue
+
+            for v in r.values():
+                if v is to:
+                    direct_ref_modules.add(report(r))
+        elif isinstance(r, type) and to in r.__bases__ and 'gevent.' not in r.__module__:
+            subclass_modules.add(r)
+
+    return direct_ref_modules, subclass_modules
+
+@_ignores_DoNotPatch
+def patch_ssl(_warnings=None, _first_time=True):
+    """
+    patch_ssl() -> None
+
+    Replace :class:`ssl.SSLSocket` object and socket wrapping functions in
+    :mod:`ssl` with cooperative versions.
+
+    This is only useful if :func:`patch_socket` has been called.
+    """
+    may_need_warning = (
+        _first_time
+        and 'ssl' in sys.modules
+        and hasattr(sys.modules['ssl'], 'SSLContext'))
+    # Previously, we didn't warn on Python 2 if pkg_resources has been imported
+    # because that imports ssl and it's commonly used for namespace packages,
+    # which typically means we're still in some early part of the import cycle.
+    # However, with our new more discriminating check, that no longer seems to be a problem.
+    # Prior to 3.6, we don't have the RecursionError problem, and prior to 3.7 we don't have the
+    # SSLContext.sslsocket_class/SSLContext.sslobject_class problem.
+
+    gevent_mod, _ = _patch_module('ssl', _warnings=_warnings)
+    if may_need_warning:
+        direct_ref_modules, subclass_modules = _find_module_refs(
+            gevent_mod.orig_SSLContext,
+            excluding_names=('ssl', 'gevent.ssl', 'gevent._ssl3', 'gevent._sslgte279'))
+        if direct_ref_modules or subclass_modules:
+            # Normally you don't want to have dynamic warning strings, because
+            # the cache in the warning module is based on the string. But we
+            # specifically only do this the first time we patch ourself, so it's
+            # ok.
+            direct_ref_mod_str = subclass_str = ''
+            if direct_ref_modules:
+                direct_ref_mod_str = 'Modules that had direct imports (NOT patched): %s. ' % ([
+                    "%s (%s)" % (name, fname)
+                    for name, fname in direct_ref_modules
+                ])
+            if subclass_modules:
+                subclass_str = 'Subclasses (NOT patched): %s. ' % ([
+                    str(t) for t in subclass_modules
+                ])
+            _queue_warning(
+                'Monkey-patching ssl after ssl has already been imported '
+                'may lead to errors, including RecursionError on Python 3.6. '
+                'It may also silently lead to incorrect behaviour on Python 3.7. '
+                'Please monkey-patch earlier. '
+                'See https://github.com/gevent/gevent/issues/1016. '
+                + direct_ref_mod_str + subclass_str,
+                _warnings)
+
+
+@_ignores_DoNotPatch
+def patch_select(aggressive=True):
+    """
+    Replace :func:`select.select` with :func:`gevent.select.select`
+    and :func:`select.poll` with :class:`gevent.select.poll` (where available).
+
+    If ``aggressive`` is true (the default), also remove other
+    blocking functions from :mod:`select` .
+
+    - :func:`select.epoll`
+    - :func:`select.kqueue`
+    - :func:`select.kevent`
+    - :func:`select.devpoll` (Python 3.5+)
+    """
+    _patch_module('select',
+                  _patch_kwargs={'aggressive': aggressive})
+
+@_ignores_DoNotPatch
+def patch_selectors(aggressive=True):
+    """
+    Replace :class:`selectors.DefaultSelector` with
+    :class:`gevent.selectors.GeventSelector`.
+
+    If ``aggressive`` is true (the default), also remove other
+    blocking classes :mod:`selectors`:
+
+    - :class:`selectors.EpollSelector`
+    - :class:`selectors.KqueueSelector`
+    - :class:`selectors.DevpollSelector` (Python 3.5+)
+
+    On Python 2, the :mod:`selectors2` module is used instead
+    of :mod:`selectors` if it is available. If this module cannot
+    be imported, no patching is done and :mod:`gevent.selectors` is
+    not available.
+
+    In :func:`patch_all`, the *select* argument controls both this function
+    and :func:`patch_select`.
+
+    .. versionadded:: 20.6.0
+    """
+    try:
+        _check_availability('selectors')
+    except ImportError: # pragma: no cover
+        return
+
+    _patch_module('selectors',
+                  _patch_kwargs={'aggressive': aggressive})
+
+
+@_ignores_DoNotPatch
+def patch_subprocess():
+    """
+    Replace :func:`subprocess.call`, :func:`subprocess.check_call`,
+    :func:`subprocess.check_output` and :class:`subprocess.Popen` with
+    :mod:`cooperative versions <gevent.subprocess>`.
+
+    .. note::
+       On Windows under Python 3, the API support may not completely match
+       the standard library.
+
+    """
+    _patch_module('subprocess')
+
+@_ignores_DoNotPatch
+def patch_builtins():
+    """
+    Make the builtin :func:`__import__` function `greenlet safe`_ under Python 2.
+
+    .. note::
+       This does nothing under Python 3 as it is not necessary. Python 3 features
+       improved import locks that are per-module, not global.
+
+    .. _greenlet safe: https://github.com/gevent/gevent/issues/108
+
+    .. deprecated:: 23.7.0
+       Does nothing on any supported platform.
+    """
+
+
+@_ignores_DoNotPatch
+def patch_signal():
+    """
+    Make the :func:`signal.signal` function work with a :func:`monkey-patched os <patch_os>`.
+
+    .. caution:: This method must be used with :func:`patch_os` to have proper ``SIGCHLD``
+         handling. :func:`patch_all` calls both by default.
+
+    .. caution:: For proper ``SIGCHLD`` handling, you must yield to the event loop.
+         Using :func:`patch_all` is the easiest way to ensure this.
+
+    .. seealso:: :mod:`gevent.signal`
+    """
+    _patch_module("signal")
+
+
+def _check_repatching(**module_settings):
+    _warnings = []
+    key = '_gevent_saved_patch_all_module_settings'
+
+    del module_settings['kwargs']
+    currently_patched = saved.setdefault(key, {})
+    first_time = not currently_patched
+    if not first_time and currently_patched != module_settings:
+        _queue_warning("Patching more than once will result in the union of all True"
+                       " parameters being patched",
+                       _warnings)
+
+    to_patch = {}
+    for k, v in module_settings.items():
+        # If we haven't seen the setting at all, record it and echo it.
+        # If we have seen the setting, but it became true, record it and echo it.
+        if k not in currently_patched:
+            to_patch[k] = currently_patched[k] = v
+        elif v and not currently_patched[k]:
+            to_patch[k] = currently_patched[k] = True
+
+    return _warnings, first_time, to_patch
+
+
+def _subscribe_signal_os(will_patch_all):
+    if will_patch_all.will_patch_module('signal') and not will_patch_all.will_patch_module('os'):
+        warnings = will_patch_all._warnings # Internal
+        _queue_warning('Patching signal but not os will result in SIGCHLD handlers'
+                       ' installed after this not being called and os.waitpid may not'
+                       ' function correctly if gevent.subprocess is used. This may raise an'
+                       ' error in the future.',
+                       warnings)
+
+def patch_all(socket=True, dns=True, time=True, select=True, thread=True, os=True, ssl=True,
+              subprocess=True, sys=False, aggressive=True, Event=True,
+              builtins=True, signal=True,
+              queue=True, contextvars=True,
+              **kwargs):
+    """
+    Do all of the default monkey patching (calls every other applicable
+    function in this module).
+
+    :return: A true value if patching all modules wasn't cancelled, a false
+      value if it was.
+
+    .. versionchanged:: 1.1
+       Issue a :mod:`warning <warnings>` if this function is called multiple times
+       with different arguments. The second and subsequent calls will only add more
+       patches, they can never remove existing patches by setting an argument to ``False``.
+    .. versionchanged:: 1.1
+       Issue a :mod:`warning <warnings>` if this function is called with ``os=False``
+       and ``signal=True``. This will cause SIGCHLD handlers to not be called. This may
+       be an error in the future.
+    .. versionchanged:: 1.3a2
+       ``Event`` defaults to True.
+    .. versionchanged:: 1.3b1
+       Defined the return values.
+    .. versionchanged:: 1.3b1
+       Add ``**kwargs`` for the benefit of event subscribers. CAUTION: gevent may add
+       and interpret additional arguments in the future, so it is suggested to use prefixes
+       for kwarg values to be interpreted by plugins, for example, `patch_all(mylib_futures=True)`.
+    .. versionchanged:: 1.3.5
+       Add *queue*, defaulting to True, for Python 3.7.
+    .. versionchanged:: 1.5
+       Remove the ``httplib`` argument. Previously, setting it raised a ``ValueError``.
+    .. versionchanged:: 1.5a3
+       Add the ``contextvars`` argument.
+    .. versionchanged:: 1.5
+       Better handling of patching more than once.
+    """
+    # pylint:disable=too-many-locals,too-many-branches
+
+    # Check to see if they're changing the patched list
+    _warnings, first_time, modules_to_patch = _check_repatching(**locals())
+
+    if not modules_to_patch:
+        # Nothing to do. Either the arguments were identical to what
+        # we previously did, or they specified false values
+        # for things we had previously patched.
+        _process_warnings(_warnings)
+        return
+
+    for k, v in modules_to_patch.items():
+        locals()[k] = v
+
+    from gevent import events
+    try:
+        _notify_patch(events.GeventWillPatchAllEvent(modules_to_patch, kwargs), _warnings)
+    except events.DoNotPatch:
+        return False
+
+    # order is important
+    if os:
+        patch_os()
+    if thread:
+        patch_thread(Event=Event, _warnings=_warnings)
+    if time:
+        # time must be patched after thread, some modules used by thread
+        # need access to the real time.sleep function.
+        patch_time()
+
+    # sys must be patched after thread. in other cases threading._shutdown will be
+    # initiated to _MainThread with real thread ident
+    if sys:
+        patch_sys()
+    if socket:
+        patch_socket(dns=dns, aggressive=aggressive)
+    if select:
+        patch_select(aggressive=aggressive)
+        patch_selectors(aggressive=aggressive)
+    if ssl:
+        patch_ssl(_warnings=_warnings, _first_time=first_time)
+    if subprocess:
+        patch_subprocess()
+    if builtins:
+        patch_builtins()
+    if signal:
+        patch_signal()
+    if queue:
+        patch_queue()
+    if contextvars:
+        patch_contextvars()
+
+    _notify_patch(events.GeventDidPatchBuiltinModulesEvent(modules_to_patch, kwargs), _warnings)
+    _notify_patch(events.GeventDidPatchAllEvent(modules_to_patch, kwargs), _warnings)
+
+    _process_warnings(_warnings)
+    return True
+
+def __getattr__(name):
+    if name == 'main':
+        from ._main import main
+        return main
+    raise AttributeError(name)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/__main__.py

@@ -0,0 +1,2 @@
+from ._main import main
+main()

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_errors.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+"""
+Exception classes and errors that this package may raise.
+
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+class _BadImplements(AttributeError):
+    """
+    Raised when ``__implements__`` is incorrect.
+    """
+
+    def __init__(self, module):
+        AttributeError.__init__(
+            self,
+            "Module %r has a bad or missing value for __implements__" % (module,)
+        )
+
+class MonkeyPatchWarning(RuntimeWarning):
+    """
+    The type of warnings we issue.
+
+    .. versionadded:: 1.3a2
+    """

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_main.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+The real functionality to run this package as a main module.
+
+"""
+
+
+def main():
+    # TODO: Now that this is its own module, see if
+    # we can refactor.
+    # pylint:disable=too-many-locals
+    import sys
+    from . import patch_all
+
+    args = {}
+    argv = sys.argv[1:]
+    verbose = False
+    run_fn = "run_path"
+    script_help, patch_all_args, modules = _get_script_help()
+    while argv and argv[0].startswith('--'):
+        option = argv[0][2:]
+        if option == 'verbose':
+            verbose += 1
+        elif option == 'module':
+            run_fn = "run_module"
+        elif option.startswith('no-') and option.replace('no-', '') in patch_all_args:
+            args[option[3:]] = False
+        elif option in patch_all_args:
+            args[option] = True
+            if option in modules:
+                for module in modules:
+                    args.setdefault(module, False)
+        else:
+            sys.exit(script_help + '\n\n' + 'Cannot patch %r' % option)
+        del argv[0]
+        # TODO: break on --
+    if verbose:
+        import pprint
+        import os
+        print('gevent.monkey.patch_all(%s)' % ', '.join('%s=%s' % item for item in args.items()))
+        print('sys.version=%s' % (sys.version.strip().replace('\n', ' '), ))
+        print('sys.path=%s' % pprint.pformat(sys.path))
+        print('sys.modules=%s' % pprint.pformat(sorted(sys.modules.keys())))
+        print('cwd=%s' % os.getcwd())
+
+    if not argv:
+        print(script_help)
+        return
+
+    sys.argv[:] = argv
+    # Make sure that we don't get imported again under a different
+    # name (usually it's ``__main__`` here) because that could lead to
+    # double-patching, and making monkey.get_original() not work.
+    try:
+        mod_name = __spec__.name
+    except NameError:
+        # Py2: __spec__ is not defined as standard
+        mod_name = 'gevent.monkey'
+    sys.modules[mod_name] = sys.modules[__name__]
+    # On Python 2, we have to set the gevent.monkey attribute
+    # manually; putting gevent.monkey into sys.modules stops the
+    # import machinery from making that connection, and ``from gevent
+    # import monkey`` is broken. On Python 3 (.8 at least) that's not
+    # necessary.
+    assert 'gevent.monkey' in sys.modules
+
+    # Running ``patch_all()`` will load pkg_resources entry point plugins
+    # which may attempt to import ``gevent.monkey``, so it is critical that
+    # we have established the correct saved module name first.
+    patch_all(**args)
+
+    import runpy
+    # Use runpy.run_path to closely (exactly) match what the
+    # interpreter does given 'python <path>'. This includes allowing
+    # passing .pyc/.pyo files and packages with a __main__ and
+    # potentially even zip files. Previously we used exec, which only
+    # worked if we directly read a python source file.
+    run_meth = getattr(runpy, run_fn)
+    return run_meth(sys.argv[0], run_name='__main__')
+
+
+def _get_script_help():
+    # pylint:disable=deprecated-method
+    import inspect
+    from . import patch_all
+    getter = inspect.getfullargspec
+
+    patch_all_args = getter(patch_all)[0]
+    modules = [x for x in patch_all_args if 'patch_' + x in globals()]
+    script_help = """gevent.monkey - monkey patch the standard modules to use gevent.
+
+USAGE: ``python -m gevent.monkey [MONKEY OPTIONS] [--module] (script|module) [SCRIPT OPTIONS]``
+
+If no MONKEY OPTIONS are present, monkey patches all the modules as if by calling ``patch_all()``.
+You can exclude a module with --no-<module>, e.g. --no-thread. You can
+specify a module to patch with --<module>, e.g. --socket. In the latter
+case only the modules specified on the command line will be patched.
+
+The default behavior is to execute the script passed as argument. If you wish
+to run a module instead, pass the `--module` argument before the module name.
+
+.. versionchanged:: 1.3b1
+    The *script* argument can now be any argument that can be passed to `runpy.run_path`,
+    just like the interpreter itself does, for example a package directory containing ``__main__.py``.
+    Previously it had to be the path to
+    a .py source file.
+
+.. versionchanged:: 1.5
+    The `--module` option has been added.
+
+MONKEY OPTIONS: ``--verbose %s``""" % ', '.join('--[no-]%s' % m for m in modules)
+    return script_help, patch_all_args, modules
+
+main.__doc__ = _get_script_help()[0]
+
+if __name__ == '__main__':
+    main()

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_patch_thread_common.py

@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+"""
+The implementation of thread patching for Python versions
+prior to 3.13.
+
+Internal use only.
+"""
+import sys
+
+from ._util import _patch_module
+from ._util import _queue_warning
+from ._util import _notify_patch
+
+from ._state import is_object_patched
+
+def _patch_existing_locks(threading):
+    if len(list(threading.enumerate())) != 1:
+        return
+    # This is used to protect internal data structures for enumerate.
+    # It's acquired when threads are started and when they're stopped.
+    # Stopping a thread checks a Condition, which on Python 2 wants to test
+    # _is_owned of its (patched) Lock. Since our LockType doesn't have
+    # _is_owned, it tries to acquire the lock non-blocking; that triggers a
+    # switch. If the next thing in the callback list was a thread that needed
+    # to start or end, we wouldn't be able to acquire this native lock
+    # because it was being held already; we couldn't switch either, so we'd
+    # block permanently.
+    threading._active_limbo_lock = threading._allocate_lock()
+    try:
+        tid = threading.get_ident()
+    except AttributeError:
+        tid = threading._get_ident()
+    rlock_type = type(threading.RLock())
+    try:
+        import importlib._bootstrap
+    except ImportError:
+        class _ModuleLock(object):
+            pass
+    else:
+        _ModuleLock = importlib._bootstrap._ModuleLock # python 2 pylint: disable=no-member
+    # It might be possible to walk up all the existing stack frames to find
+    # locked objects...at least if they use `with`. To be sure, we look at every object
+    # Since we're supposed to be done very early in the process, there shouldn't be
+    # too many.
+
+    # Note that the C implementation of locks, at least on some
+    # versions of CPython, cannot be found and cannot be fixed (they simply
+    # don't show up to GC; see https://github.com/gevent/gevent/issues/1354)
+
+    # By definition there's only one thread running, so the various
+    # owner attributes were the old (native) thread id. Make it our
+    # current greenlet id so that when it wants to unlock and compare
+    # self.__owner with _get_ident(), they match.
+    gc = __import__('gc')
+    for o in gc.get_objects():
+        if isinstance(o, rlock_type):
+            for owner_name in (
+                    '_owner', # Python 3 or backported PyPy2
+                    '_RLock__owner', # Python 2
+            ):
+                if hasattr(o, owner_name):
+                    if getattr(o, owner_name) is not None:
+                        setattr(o, owner_name, tid)
+                    break
+            else: # pragma: no cover
+                raise AssertionError(
+                    "Unsupported Python implementation; "
+                    "Found unknown lock implementation.",
+                    vars(o)
+                )
+        elif isinstance(o, _ModuleLock):
+            if o.owner is not None:
+                o.owner = tid
+
+
+
+class BasePatcher:
+    # Description of the hang:
+    # There is an incompatibility with patching 'thread' and the 'multiprocessing' module:
+    # The problem is that multiprocessing.queues.Queue uses a half-duplex multiprocessing.Pipe,
+    # which is implemented with os.pipe() and _multiprocessing.Connection. os.pipe isn't patched
+    # by gevent, as it returns just a fileno. _multiprocessing.Connection is an internal implementation
+    # class implemented in C, which exposes a 'poll(timeout)' method; under the covers, this issues a
+    # (blocking) select() call: hence the need for a real thread. Except for that method, we could
+    # almost replace Connection with gevent.fileobject.SocketAdapter, plus a trivial
+    # patch to os.pipe (below). Sigh, so close. (With a little work, we could replicate that method)
+
+    # import os
+    # import fcntl
+    # os_pipe = os.pipe
+    # def _pipe():
+    #   r, w = os_pipe()
+    #   fcntl.fcntl(r, fcntl.F_SETFL, os.O_NONBLOCK)
+    #   fcntl.fcntl(w, fcntl.F_SETFL, os.O_NONBLOCK)
+    #   return r, w
+    # os.pipe = _pipe
+
+    gevent_threading_mod = None
+    gevent_thread_mod = None
+
+    thread_mod = None
+    threading_mod = None
+    orig_current_thread = None
+    main_thread = None
+    orig_shutdown = None
+
+    def __init__(self, threading=True, _threading_local=True, Event=True, logging=True,
+                 existing_locks=True,
+                 _warnings=None):
+        self.threading = threading
+        self.threading_local = _threading_local
+        self.Event = Event
+        self.logging = logging
+        self.existing_locks = existing_locks
+        self.warnings = _warnings
+
+
+
+    def __call__(self):
+        # The 'threading' module copies some attributes from the
+        # thread module the first time it is imported. If we patch 'thread'
+        # before that happens, then we store the wrong values in 'saved',
+        # So if we're going to patch threading, we either need to import it
+        # before we patch thread, or manually clean up the attributes that
+        # are in trouble. The latter is tricky because of the different names
+        # on different versions.
+
+
+        self.threading_mod = __import__('threading')
+        # Capture the *real* current thread object before
+        # we start returning DummyThread objects, for comparison
+        # to the main thread.
+        self.orig_current_thread = self.threading_mod.current_thread()
+        self.main_thread = self.threading_mod.main_thread()
+        self.orig_shutdown = self.threading_mod._shutdown
+
+        gevent_thread_mod, thread_mod = _patch_module('thread',
+                                                      _warnings=self.warnings,
+                                                      _notify_did_subscribers=False)
+
+
+        if self.threading:
+            self.patch_threading_event_logging_existing_locks()
+
+        if self.threading_local:
+            self.patch__threading_local()
+
+        if self.threading:
+            self.patch_active_threads()
+
+
+        # Issue 18808 changes the nature of Thread.join() to use
+        # locks. This means that a greenlet spawned in the main thread
+        # (which is already running) cannot wait for the main thread---it
+        # hangs forever. We patch around this if possible. See also
+        # gevent.threading.
+        already_patched = is_object_patched('threading', '_shutdown')
+
+        if self.orig_current_thread == self.threading_mod.main_thread() and not already_patched:
+            self.patch_threading_shutdown_on_main_thread_not_already_patched()
+            self.patch_main_thread_cleanup()
+
+        elif not already_patched:
+            self.patch_shutdown_not_on_main_thread()
+
+        from gevent import events
+        _notify_patch(events.GeventDidPatchModuleEvent('thread',
+                                                       gevent_thread_mod,
+                                                       thread_mod))
+        if self.gevent_threading_mod is not None:
+            _notify_patch(events.GeventDidPatchModuleEvent('threading',
+                                                           self.gevent_threading_mod,
+                                                           self.threading_mod))
+
+    def patch_threading_event_logging_existing_locks(self):
+
+        self.gevent_threading_mod, patched_mod = _patch_module(
+            'threading',
+            _warnings=self.warnings,
+            _notify_did_subscribers=False)
+
+        assert patched_mod is self.threading_mod
+
+        if self.Event:
+            self.patch_event()
+
+        if self.existing_locks:
+            _patch_existing_locks(self.threading_mod)
+
+        if self.logging and 'logging' in sys.modules:
+            self.patch_logging()
+
+    def patch_event(self):
+        from .api import patch_item
+        from gevent.event import Event
+        patch_item(self.threading_mod, 'Event', Event)
+        # Python 2 had `Event` as a function returning
+        # the private class `_Event`. Some code may be relying
+        # on that.
+        if hasattr(self.threading_mod, '_Event'):
+            patch_item(self.threading_mod, '_Event', Event)
+
+    def patch_logging(self):
+        from .api import patch_item
+        logging = __import__('logging')
+        patch_item(logging, '_lock', self.threading_mod.RLock())
+        for wr in logging._handlerList:
+            # In py26, these are actual handlers, not weakrefs
+            handler = wr() if callable(wr) else wr
+            if handler is None:
+                continue
+            if not hasattr(handler, 'lock'):
+                raise TypeError("Unknown/unsupported handler %r" % handler)
+            handler.lock = self.threading_mod.RLock()
+
+    def patch__threading_local(self):
+        _threading_local = __import__('_threading_local')
+        from .api import patch_item
+        from gevent.local import local
+        patch_item(_threading_local, 'local', local)
+
+    def patch_active_threads(self):
+        raise NotImplementedError
+
+    def patch_threading_shutdown_on_main_thread_not_already_patched(self):
+        raise NotImplementedError
+
+    def patch_main_thread_cleanup(self):
+        # We create a bit of a reference cycle here,
+        # so main_thread doesn't get to be collected in a timely way.
+        # Not good. Take it out of dangling so we don't get
+        # warned about it.
+        main_thread = self.main_thread
+        self.threading_mod._dangling.remove(main_thread)
+
+        # Patch up the ident of the main thread to match. This
+        # matters if threading was imported before monkey-patching
+        # thread
+        oldid = main_thread.ident
+        main_thread._ident = self.threading_mod.get_ident()
+        if oldid in self.threading_mod._active:
+            self.threading_mod._active[main_thread.ident] = self.threading_mod._active[oldid]
+        if oldid != main_thread.ident:
+            del self.threading_mod._active[oldid]
+
+    def patch_shutdown_not_on_main_thread(self):
+        _queue_warning("Monkey-patching not on the main thread; "
+                       "threading.main_thread().join() will hang from a greenlet",
+                       self.warnings)
+
+        from .api import patch_item
+
+        main_thread = self.main_thread
+        threading_mod = self.threading_mod
+        get_ident = self.threading_mod.get_ident
+        orig_shutdown = self.orig_shutdown
+        def _shutdown():
+            # We've patched get_ident but *did not* patch the
+            # main_thread.ident value. Beginning in Python 3.9.8
+            # and then later releases (3.10.1, probably), the
+            # _main_thread object is only _stop() if the ident of
+            # the current thread (the *real* main thread) matches
+            # the ident of the _main_thread object. But without doing that,
+            # the main thread's shutdown lock (threading._shutdown_locks) is never
+            # removed *or released*, thus hanging the interpreter.
+            # XXX: There's probably a better way to do this. Probably need to take a
+            # step back and look at the whole picture.
+            main_thread._ident = get_ident()
+            orig_shutdown()
+            patch_item(threading_mod, '_shutdown', orig_shutdown)
+        patch_item(threading_mod, '_shutdown', _shutdown)
+
+    @staticmethod # Static to be sure we don't accidentally capture `self` and keep it alive
+    def _make_existing_non_main_thread_join_func(thread, thread_greenlet, threading_mod):
+        from gevent.hub import sleep
+        from time import time
+        # TODO: This is almost the algorithm that the 3.13 _ThreadHandle class
+        # employs. UNIFY them.
+        def join(timeout=None):
+            end = None
+            if threading_mod.current_thread() is thread:
+                raise RuntimeError("Cannot join current thread")
+            if thread_greenlet is not None and thread_greenlet.dead:
+                return
+            # You may ask: Why not call thread_greenlet.join()?
+            # Well, in the one case we actually have a greenlet, it's the
+            # low-level greenlet.greenlet object for the main thread, which
+            # doesn't have a join method.
+            #
+            # You may ask: Why not become the main greenlet's *parent*
+            # so you can get notified when it finishes? Because you can't
+            # create a greenlet cycle (the current greenlet is a descendent
+            # of the parent), and nor can you set a greenlet's parent to None,
+            # so there can only ever be one greenlet with a parent of None: the main
+            # greenlet, the one we need to watch.
+            #
+            # You may ask: why not swizzle out the problematic lock on the main thread
+            # into a gevent friendly lock? Well, the interpreter actually depends on that
+            # for the main thread in threading._shutdown; see below.
+
+            if not thread.is_alive():
+                return
+
+            if timeout:
+                end = time() + timeout
+
+            while thread.is_alive():
+                if end is not None and time() > end:
+                    return
+                sleep(0.01)
+        return join

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_patch_thread_gte313.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+"""
+The implementation of thread patching for Python versions
+after 3.13.
+
+Internal use only.
+"""
+import sys
+
+
+from ._patch_thread_common import BasePatcher
+
+class Patcher(BasePatcher):
+
+
+    def patch_active_threads(self):
+        from gevent.threading import main_native_thread
+
+        for thread in self.threading_mod._active.values():
+            if thread == main_native_thread():
+                from greenlet import getcurrent
+                from gevent.thread import _ThreadHandle
+                thread._after_fork = lambda new_ident=None: new_ident
+                thread._handle = _ThreadHandle()
+                thread._handle._set_greenlet(getcurrent())
+                thread._ident = thread._handle.ident
+                assert thread.ident == thread._handle.ident
+                continue
+            thread.join = self._make_existing_non_main_thread_join_func(thread,
+                                                                        None,
+                                                                        self.threading_mod)
+
+    def patch_threading_shutdown_on_main_thread_not_already_patched(self):
+        import greenlet
+        from .api import patch_item
+
+        main_thread = self.main_thread
+        threading_mod = self.threading_mod
+        orig_shutdown = self.orig_shutdown
+        _greenlet = main_thread._greenlet = greenlet.getcurrent()
+
+        def _shutdown():
+            # Release anyone trying to join() me,
+            # and let us switch to them.
+            main_thread._handle._set_done()
+            from gevent import sleep
+            try:
+                sleep()
+            except: # pylint:disable=bare-except
+                # A greenlet could have .kill() us
+                # or .throw() to us. I'm the main greenlet,
+                # there's no where else for this to go.
+                from gevent  import get_hub
+                get_hub().print_exception(_greenlet, *sys.exc_info())
+
+            # Now, this may have resulted in us getting stopped
+            # if some other greenlet actually just ran there.
+            # That's not good, we're not supposed to be stopped
+            # when we enter _shutdown.
+            class FakeHandle:
+                def is_done(self):
+                    return False
+                def _set_done(self):
+                    return
+                def join(self):
+                    return
+            main_thread._handle = FakeHandle()
+            assert main_thread.is_alive()
+            # main_thread._is_stopped = False
+            # main_thread._tstate_lock = main_thread.__real_tstate_lock
+            # main_thread.__real_tstate_lock = None
+            # The only truly blocking native shutdown lock to
+            # acquire should be our own (hopefully), and the call to
+            # _stop that orig_shutdown makes will discard it.
+
+            # XXX: What if more get spawned?
+            for t in list(threading_mod.enumerate()):
+                if t.daemon or t is main_thread:
+                    continue
+                while t.is_alive():
+                    try:
+                        t._handle.join(0.001)
+                    except RuntimeError:
+                        # Joining ourself.
+                        t._handle._set_done()
+                        break
+
+            orig_shutdown()
+            patch_item(threading_mod, '_shutdown', self.orig_shutdown)
+
+        patch_item(self.threading_mod, '_shutdown', _shutdown)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_patch_thread_lt313.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+The implementation of thread patching for Python versions
+prior to 3.13.
+
+Internal use only.
+"""
+import sys
+
+
+from ._patch_thread_common import BasePatcher
+
+
+class Patcher(BasePatcher):
+
+    def patch_active_threads(self):
+        from gevent.threading import main_native_thread
+        threading_mod = self.threading_mod
+        for thread in threading_mod._active.values():
+            if thread == main_native_thread():
+                continue
+            thread.join = self._make_existing_non_main_thread_join_func(thread, None, threading_mod)
+
+
+    def patch_threading_shutdown_on_main_thread_not_already_patched(self):
+        import greenlet
+        from .api import patch_item
+        threading_mod = self.threading_mod
+        main_thread = self.main_thread
+        orig_shutdown = self.orig_shutdown
+
+        _greenlet = main_thread._greenlet = greenlet.getcurrent()
+        main_thread._gevent_real_tstate_lock = main_thread._tstate_lock
+        assert main_thread._gevent_real_tstate_lock is not None
+        # The interpreter will call threading._shutdown
+        # when the main thread exits and is about to
+        # go away. It is called *in* the main thread. This
+        # is a perfect place to notify other greenlets that
+        # the main thread is done. We do this by overriding the
+        # lock of the main thread during operation, and only restoring
+        # it to the native blocking version at shutdown time
+        # (the interpreter also has a reference to this lock in a
+        # C data structure).
+        main_thread._tstate_lock = threading_mod.Lock()
+        main_thread._tstate_lock.acquire()
+
+        def _shutdown():
+            # Release anyone trying to join() me,
+            # and let us switch to them.
+            if not main_thread._tstate_lock:
+                return
+
+            main_thread._tstate_lock.release()
+            from gevent import sleep
+            try:
+                sleep()
+            except: # pylint:disable=bare-except
+                # A greenlet could have .kill() us
+                # or .throw() to us. I'm the main greenlet,
+                # there's no where else for this to go.
+                from gevent  import get_hub
+                get_hub().print_exception(_greenlet, *sys.exc_info())
+
+            # Now, this may have resulted in us getting stopped
+            # if some other greenlet actually just ran there.
+            # That's not good, we're not supposed to be stopped
+            # when we enter _shutdown.
+            main_thread._is_stopped = False
+            main_thread._tstate_lock = main_thread._gevent_real_tstate_lock
+            main_thread._gevent_real_tstate_lock = None
+            # The only truly blocking native shutdown lock to
+            # acquire should be our own (hopefully), and the call to
+            # _stop that orig_shutdown makes will discard it.
+
+            orig_shutdown()
+            patch_item(threading_mod, '_shutdown', orig_shutdown)
+
+        patch_item(threading_mod, '_shutdown', _shutdown)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_state.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""
+State management and query functions for tracking and discovering what
+has been patched.
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# maps module name -> {attribute name: original item}
+# e.g. "time" -> {"sleep": built-in function sleep}
+# NOT A PUBLIC API. However, third-party monkey-patchers may be using
+# it? TODO: Provide better API for them.
+saved:dict = {}
+
+
+def is_module_patched(mod_name):
+    """
+    Check if a module has been replaced with a cooperative version.
+
+    :param str mod_name: The name of the standard library module,
+        e.g., ``'socket'``.
+
+    """
+    return mod_name in saved
+
+
+def is_object_patched(mod_name, item_name):
+    """
+    Check if an object in a module has been replaced with a
+    cooperative version.
+
+    :param str mod_name: The name of the standard library module,
+        e.g., ``'socket'``.
+    :param str item_name: The name of the attribute in the module,
+        e.g., ``'create_connection'``.
+
+    """
+    return is_module_patched(mod_name) and item_name in saved[mod_name]
+
+
+def is_anything_patched():
+    """
+    Check if this module has done any patching in the current process.
+    This is currently only used in gevent tests.
+
+    Not currently a documented, public API, because I'm not convinced
+    it is 100% reliable in the event of third-party patch functions that
+    don't use ``saved``.
+
+    .. versionadded:: 21.1.0
+    """
+    return bool(saved)
+
+def _get_original(name, items):
+    d = saved.get(name, {})
+    values = []
+    module = None
+    for item in items:
+        if item in d:
+            values.append(d[item])
+        else:
+            if module is None:
+                module = __import__(name)
+            values.append(getattr(module, item))
+    return values
+
+def _save(module, attr_name, item):
+    saved.setdefault(module.__name__, {}).setdefault(attr_name, item)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/_util.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""
+Utilities used in patching.
+
+Internal use only.
+
+"""
+import sys
+
+
+def _notify_patch(event, _warnings=None):
+    # Raises DoNotPatch if we're not supposed to patch
+    from gevent.events import notify_and_call_entry_points
+
+    event._warnings = _warnings
+    notify_and_call_entry_points(event)
+
+def _ignores_DoNotPatch(func):
+
+    from functools import wraps
+
+    @wraps(func)
+    def ignores(*args, **kwargs):
+        from gevent.events import DoNotPatch
+        try:
+            return func(*args, **kwargs)
+        except DoNotPatch:
+            return False
+
+    return ignores
+
+def _check_availability(name):
+    """
+    Test that the source and target modules for *name* are
+    available and return them.
+
+    :raise ImportError: If the source or target cannot be imported.
+    :return: The tuple ``(gevent_module, target_module, target_module_name)``
+    """
+    # Always import the gevent module first. This helps us be sure we can
+    # use regular imports in gevent files (when we can't use gevent.monkey.get_original())
+    gevent_module = getattr(__import__('gevent.' + name), name)
+    target_module_name = getattr(gevent_module, '__target__', name)
+    target_module = __import__(target_module_name)
+
+    return gevent_module, target_module, target_module_name
+
+
+def _patch_module(name,
+                  items=None,
+                  _warnings=None,
+                  _patch_kwargs=None,
+                  _notify_will_subscribers=True,
+                  _notify_did_subscribers=True,
+                  _call_hooks=True):
+
+    from .api import patch_module
+
+    gevent_module, target_module, target_module_name = _check_availability(name)
+
+    patch_module(target_module, gevent_module, items=items,
+                 _warnings=_warnings, _patch_kwargs=_patch_kwargs,
+                 _notify_will_subscribers=_notify_will_subscribers,
+                 _notify_did_subscribers=_notify_did_subscribers,
+                 _call_hooks=_call_hooks)
+
+    # On Python 2, the `futures` package will install
+    # a bunch of modules with the same name as those from Python 3,
+    # such as `_thread`; primarily these just do `from thread import *`,
+    # meaning we have alternate references. If that's already been imported,
+    # we need to attempt to patch that too.
+
+    # Be sure to keep the original states matching also.
+
+    alternate_names = getattr(gevent_module, '__alternate_targets__', ())
+    from ._state import saved # TODO: Add apis for these use cases.
+    for alternate_name in alternate_names:
+        alternate_module = sys.modules.get(alternate_name)
+        if alternate_module is not None and alternate_module is not target_module:
+            saved.pop(alternate_name, None)
+            patch_module(alternate_module, gevent_module, items=items,
+                         _warnings=_warnings,
+                         _notify_will_subscribers=False,
+                         _notify_did_subscribers=False,
+                         _call_hooks=False)
+            saved[alternate_name] = saved[target_module_name]
+
+    return gevent_module, target_module
+
+
+def _queue_warning(message, _warnings):
+    # Queues a warning to show after the monkey-patching process is all done.
+    # Done this way to avoid extra imports during the process itself, just
+    # in case. If we're calling a function one-off (unusual) go ahead and do it
+    if _warnings is None:
+        _process_warnings([message])
+    else:
+        _warnings.append(message)
+
+
+def _process_warnings(_warnings):
+    import warnings
+    from ._errors import MonkeyPatchWarning
+    for warning in _warnings:
+        warnings.warn(warning, MonkeyPatchWarning, stacklevel=3)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/monkey/api.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""
+Higher level functions that comprise parts of
+the public monkey patching API.
+
+
+"""
+
+
+def get_original(mod_name, item_name):
+    """
+    Retrieve the original object from a module.
+
+    If the object has not been patched, then that object will still be
+    retrieved.
+
+    :param str|sequence mod_name: The name of the standard library module,
+        e.g., ``'socket'``. Can also be a sequence of standard library
+        modules giving alternate names to try, e.g., ``('thread', '_thread')``;
+        the first importable module will supply all *item_name* items.
+    :param str|sequence item_name: A string or sequence of strings naming the
+        attribute(s) on the module ``mod_name`` to return.
+
+    :return: The original value if a string was given for
+             ``item_name`` or a sequence of original values if a
+             sequence was passed.
+    """
+    from ._state import _get_original
+
+    mod_names = [mod_name] if isinstance(mod_name, str) else mod_name
+    if isinstance(item_name, str):
+        item_names = [item_name]
+        unpack = True
+    else:
+        item_names = item_name
+        unpack = False
+
+    for mod in mod_names:
+        try:
+            result = _get_original(mod, item_names)
+        except ImportError:
+            if mod is mod_names[-1]:
+                raise
+        else:
+            return result[0] if unpack else result
+
+_NONE = object()
+
+def patch_item(module, attr, newitem):
+    from ._state import _save
+
+    olditem = getattr(module, attr, _NONE)
+    if olditem is not _NONE:
+        _save(module, attr, olditem)
+    setattr(module, attr, newitem)
+
+
+def remove_item(module, attr):
+    from ._state import _save
+
+    olditem = getattr(module, attr, _NONE)
+    if olditem is _NONE:
+        return
+    _save(module, attr, olditem)
+
+    delattr(module, attr)
+
+def patch_module(target_module, source_module, items=None,
+                 _warnings=None,
+                 _patch_kwargs=None,
+                 _notify_will_subscribers=True,
+                 _notify_did_subscribers=True,
+                 _call_hooks=True):
+    """
+    patch_module(target_module, source_module, items=None)
+
+    Replace attributes in *target_module* with the attributes of the
+    same name in *source_module*.
+
+    The *source_module* can provide some attributes to customize the process:
+
+    * ``__implements__`` is a list of attribute names to copy; if not present,
+      the *items* keyword argument is mandatory. ``__implements__`` must only have
+      names from the standard library module in it.
+    * ``_gevent_will_monkey_patch(target_module, items, warn, **kwargs)``
+    * ``_gevent_did_monkey_patch(target_module, items, warn, **kwargs)``
+      These two functions in the *source_module* are called *if* they exist,
+      before and after copying attributes, respectively. The "will" function
+      may modify *items*. The value of *warn* is a function that should be called
+      with a single string argument to issue a warning to the user. If the "will"
+      function raises :exc:`gevent.events.DoNotPatch`, no patching will be done. These functions
+      are called before any event subscribers or plugins.
+
+    :keyword list items: A list of attribute names to replace. If
+       not given, this will be taken from the *source_module* ``__implements__``
+       attribute.
+    :return: A true value if patching was done, a false value if patching was canceled.
+
+    .. versionadded:: 1.3b1
+    """
+    from gevent import events
+    from ._errors import _BadImplements
+    from ._util import _notify_patch
+
+    if items is None:
+        try:
+            items = source_module.__implements__
+        except AttributeError as e:
+            raise _BadImplements(source_module) from e
+
+        if items is None:
+            raise _BadImplements(source_module)
+
+    try:
+        if _call_hooks:
+            __call_module_hook(source_module, 'will', target_module, items, _warnings)
+        if _notify_will_subscribers:
+            _notify_patch(
+                events.GeventWillPatchModuleEvent(target_module.__name__, source_module,
+                                                  target_module, items),
+                _warnings)
+    except events.DoNotPatch:
+        return False
+
+    # Undocumented, internal use: If the module defines
+    # `_gevent_do_monkey_patch(patch_request: _GeventDoPatchRequest)` call that;
+    # the module is responsible for its own patching.
+    do_patch = getattr(
+        source_module,
+        '_gevent_do_monkey_patch',
+        _GeventDoPatchRequest.default_patch_items
+    )
+    request = _GeventDoPatchRequest(target_module, source_module, items, _patch_kwargs)
+    do_patch(request)
+
+    if _call_hooks:
+        __call_module_hook(source_module, 'did', target_module, items, _warnings)
+
+    if _notify_did_subscribers:
+        # We allow turning off the broadcast of the 'did' event for the benefit
+        # of our internal functions which need to do additional work (besides copying
+        # attributes) before their patch can be considered complete.
+        _notify_patch(
+            events.GeventDidPatchModuleEvent(target_module.__name__, source_module,
+                                             target_module)
+        )
+
+    return True
+
+class _GeventDoPatchRequest(object):
+
+    get_original = staticmethod(get_original)
+
+    def __init__(self,
+                 target_module,
+                 source_module,
+                 items,
+                 patch_kwargs):
+        self.target_module = target_module
+        self.source_module = source_module
+        self.items = items
+        self.patch_kwargs = patch_kwargs or {}
+
+    def __repr__(self):
+        return '<%s target=%r source=%r items=%r kwargs=%r>' % (
+            self.__class__.__name__,
+            self.target_module,
+            self.source_module,
+            self.items,
+            self.patch_kwargs
+        )
+
+    def default_patch_items(self):
+        for attr in self.items:
+            patch_item(self.target_module, attr, getattr(self.source_module, attr))
+
+    def remove_item(self, target_module, *items):
+        if isinstance(target_module, str):
+            items = (target_module,) + items
+            target_module = self.target_module
+
+        for item in items:
+            remove_item(target_module, item)
+
+def __call_module_hook(gevent_module, name, module, items, _warnings):
+    # This function can raise DoNotPatch on 'will'
+
+    def warn(message):
+        from ._util import _queue_warning
+        _queue_warning(message, _warnings)
+
+    func_name = '_gevent_' + name + '_monkey_patch'
+    try:
+        func = getattr(gevent_module, func_name)
+    except AttributeError:
+        func = lambda *args: None
+
+
+    func(module, items, warn)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/os.py

@@ -0,0 +1,543 @@
+"""
+Low-level operating system functions from :mod:`os`.
+
+Cooperative I/O
+===============
+
+This module provides cooperative versions of :func:`os.read` and
+:func:`os.write`. These functions are *not* monkey-patched; you
+must explicitly call them or monkey patch them yourself.
+
+POSIX functions
+---------------
+
+On POSIX, non-blocking IO is available.
+
+- :func:`nb_read`
+- :func:`nb_write`
+- :func:`make_nonblocking`
+
+All Platforms
+-------------
+
+On non-POSIX platforms (e.g., Windows), non-blocking IO is not
+available. On those platforms (and on POSIX), cooperative IO can
+be done with the threadpool.
+
+- :func:`tp_read`
+- :func:`tp_write`
+
+Child Processes
+===============
+
+The functions :func:`fork` and (on POSIX) :func:`forkpty` and :func:`waitpid` can be used
+to manage child processes.
+
+.. warning::
+
+   Forking a process that uses greenlets does not eliminate all non-running
+   greenlets. Any that were scheduled in the hub of the forking thread in the parent
+   remain scheduled in the child; compare this to how normal threads operate. (This behaviour
+   may change is a subsequent major release.)
+"""
+
+from __future__ import absolute_import
+
+import os
+
+from gevent.hub import _get_hub_noargs as get_hub
+from gevent.hub import reinit
+from gevent._config import config
+from gevent._util import copy_globals
+import errno
+
+EAGAIN = getattr(errno, 'EAGAIN', 11)
+
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+
+__implements__ = ['fork']
+__extensions__ = ['tp_read', 'tp_write']
+
+_read = os.read
+_write = os.write
+
+
+ignored_errors = [EAGAIN, errno.EINTR]
+
+
+if fcntl:
+
+    __extensions__ += ['make_nonblocking', 'nb_read', 'nb_write']
+
+    def make_nonblocking(fd):
+        """Put the file descriptor *fd* into non-blocking mode if
+        possible.
+
+        :return: A boolean value that evaluates to True if successful.
+        """
+        flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
+        if not bool(flags & os.O_NONBLOCK):
+            fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+            return True
+
+    def nb_read(fd, n):
+        """
+        Read up to *n* bytes from file descriptor *fd*. Return a
+        byte string containing the bytes read, which may be shorter than
+        *n*. If end-of-file is reached, an empty string is returned.
+
+        The descriptor must be in non-blocking mode.
+        """
+        hub = None
+        event = None
+        try:
+            while 1:
+                try:
+                    result = _read(fd, n)
+                    return result
+                except OSError as e:
+                    if e.errno not in ignored_errors:
+                        raise
+                if hub is None:
+                    hub = get_hub()
+                    event = hub.loop.io(fd, 1)
+                hub.wait(event)
+        finally:
+            if event is not None:
+                event.close()
+                event = None
+                hub = None
+
+
+    def nb_write(fd, buf):
+        """
+        Write some number of bytes from buffer *buf* to file
+        descriptor *fd*. Return the number of bytes written, which may
+        be less than the length of *buf*.
+
+        The file descriptor must be in non-blocking mode.
+        """
+        hub = None
+        event = None
+        try:
+            while 1:
+                try:
+                    result = _write(fd, buf)
+                    return result
+                except OSError as e:
+                    if e.errno not in ignored_errors:
+                        raise
+                if hub is None:
+                    hub = get_hub()
+                    event = hub.loop.io(fd, 2)
+                hub.wait(event)
+        finally:
+            if event is not None:
+                event.close()
+                event = None
+                hub = None
+
+
+def tp_read(fd, n):
+    """Read up to *n* bytes from file descriptor *fd*. Return a string
+    containing the bytes read. If end-of-file is reached, an empty string
+    is returned.
+
+    Reading is done using the threadpool.
+    """
+    return get_hub().threadpool.apply(_read, (fd, n))
+
+
+def tp_write(fd, buf):
+    """Write bytes from buffer *buf* to file descriptor *fd*. Return the
+    number of bytes written.
+
+    Writing is done using the threadpool.
+    """
+    return get_hub().threadpool.apply(_write, (fd, buf))
+
+
+if hasattr(os, 'fork'):
+    # pylint:disable=function-redefined,redefined-outer-name
+
+    _raw_fork = os.fork
+
+    def fork_gevent():
+        """
+        Forks the process using :func:`os.fork` and prepares the
+        child process to continue using gevent before returning.
+
+        .. note::
+
+            The PID returned by this function may not be waitable with
+            either the original :func:`os.waitpid` or this module's
+            :func:`waitpid` and it may not generate SIGCHLD signals if
+            libev child watchers are or ever have been in use. For
+            example, the :mod:`gevent.subprocess` module uses libev
+            child watchers (which parts of gevent use libev child
+            watchers is subject to change at any time). Most
+            applications should use :func:`fork_and_watch`, which is
+            monkey-patched as the default replacement for
+            :func:`os.fork` and implements the ``fork`` function of
+            this module by default, unless the environment variable
+            ``GEVENT_NOWAITPID`` is defined before this module is
+            imported.
+
+        .. versionadded:: 1.1b2
+        """
+        import warnings
+        # The simple `catch_warnings(action='ignore', category=DeprecationWarning)`
+        # is only available in 3.11+.
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            result = _raw_fork()
+        if not result:
+            reinit()
+        return result
+
+    def fork():
+        """
+        A wrapper for :func:`fork_gevent` for non-POSIX platforms.
+        """
+        return fork_gevent()
+
+    if hasattr(os, 'forkpty'):
+        _raw_forkpty = os.forkpty
+
+        def forkpty_gevent():
+            """
+            Forks the process using :func:`os.forkpty` and prepares the
+            child process to continue using gevent before returning.
+
+            Returns a tuple (pid, master_fd). The `master_fd` is *not* put into
+            non-blocking mode.
+
+            Availability: Some Unix systems.
+
+            .. seealso:: This function has the same limitations as :func:`fork_gevent`.
+
+            .. versionadded:: 1.1b5
+            """
+            pid, master_fd = _raw_forkpty()
+            if not pid:
+                reinit()
+            return pid, master_fd
+
+        forkpty = forkpty_gevent
+
+        __implements__.append('forkpty')
+        __extensions__.append("forkpty_gevent")
+
+    if hasattr(os, 'WNOWAIT') or hasattr(os, 'WNOHANG'):
+        # We can only do this on POSIX
+        import time
+
+        _waitpid = os.waitpid
+        _WNOHANG = os.WNOHANG
+
+        # replaced by the signal module.
+        _on_child_hook = lambda: None
+
+        # {pid -> watcher or tuple(pid, rstatus, timestamp)}
+        _watched_children = {}
+
+        def _on_child(watcher, callback):
+            # XXX: Could handle tracing here by not stopping
+            # until the pid is terminated
+            watcher.stop()
+            try:
+                _watched_children[watcher.pid] = (watcher.pid, watcher.rstatus, time.time())
+                if callback:
+                    callback(watcher)
+                # dispatch an "event"; used by gevent.signal.signal
+                _on_child_hook()
+                # now is as good a time as any to reap children
+                _reap_children()
+            finally:
+                watcher.close()
+
+        def _reap_children(timeout=60):
+            # Remove all the dead children that haven't been waited on
+            # for the *timeout* seconds.
+            # Some platforms queue delivery of SIGCHLD for all children that die;
+            # in that case, a well-behaved application should call waitpid() for each
+            # signal.
+            # Some platforms (linux) only guarantee one delivery if multiple children
+            # die. On that platform, the well-behave application calls waitpid() in a loop
+            # until it gets back -1, indicating no more dead children need to be waited for.
+            # In either case, waitpid should be called the same number of times as dead children,
+            # thus removing all the watchers when a SIGCHLD arrives. The (generous) timeout
+            # is to work with applications that neglect to call waitpid and prevent "unlimited"
+            # growth.
+            # Note that we don't watch for the case of pid wraparound. That is, we fork a new
+            # child with the same pid as an existing watcher, but the child is already dead,
+            # just not waited on yet.
+            now = time.time()
+            oldest_allowed = now - timeout
+            dead = [
+                pid for pid, val
+                in _watched_children.items()
+                if isinstance(val, tuple) and val[2] < oldest_allowed
+            ]
+            for pid in dead:
+                del _watched_children[pid]
+
+        def waitpid(pid, options):
+            """
+            Wait for a child process to finish.
+
+            If the child process was spawned using
+            :func:`fork_and_watch`, then this function behaves
+            cooperatively. If not, it *may* have race conditions; see
+            :func:`fork_gevent` for more information.
+
+            The arguments are as for the underlying
+            :func:`os.waitpid`. Some combinations of *options* may not
+            be supported cooperatively (as of 1.1 that includes
+            WUNTRACED). Using a *pid* of 0 to request waiting on only processes
+            from the current process group is not cooperative. A *pid* of -1
+            to wait for any child is non-blocking, but may or may not
+            require a trip around the event loop, depending on whether any children
+            have already terminated but not been waited on.
+
+            Availability: POSIX.
+
+            .. versionadded:: 1.1b1
+            .. versionchanged:: 1.2a1
+               More cases are handled in a cooperative manner.
+            """
+            # pylint: disable=too-many-return-statements
+            # XXX Does not handle tracing children
+
+            # So long as libev's loop doesn't run, it's OK to add
+            # child watchers. The SIGCHLD handler only feeds events
+            # for the next iteration of the loop to handle. (And the
+            # signal handler itself is only called from the next loop
+            # iteration.)
+
+            if pid <= 0:
+                # magic functions for multiple children.
+                if pid == -1:
+                    # Any child. If we have one that we're watching
+                    # and that finished, we will use that one,
+                    # preferring the oldest. Otherwise, let the OS
+                    # take care of it.
+                    finished_at = None
+                    for k, v in _watched_children.items():
+                        if (
+                                isinstance(v, tuple)
+                                and (finished_at is None or v[2] < finished_at)
+                        ):
+                            pid = k
+                            finished_at = v[2]
+
+                if pid <= 0:
+                    # We didn't have one that was ready. If there are
+                    # no funky options set, and the pid was -1
+                    # (meaning any process, not 0, which means process
+                    # group--- libev doesn't know about process
+                    # groups) then we can use a child watcher of pid 0; otherwise,
+                    # pass through to the OS.
+                    if pid == -1 and options == 0:
+                        hub = get_hub()
+                        with hub.loop.child(0, False) as watcher:
+                            hub.wait(watcher)
+                            return watcher.rpid, watcher.rstatus
+                    # There were funky options/pid, so we must go to the OS.
+                    return _waitpid(pid, options)
+
+            if pid in _watched_children:
+                # yes, we're watching it
+
+                # Note that the remainder of this code must be careful to NOT
+                # yield to the event loop except at well known times, or
+                # we have a race condition between the _on_child callback and the
+                # code here that could lead to a process to hang.
+                if options & _WNOHANG or isinstance(_watched_children[pid], tuple):
+                    # We're either asked not to block, or it already finished, in which
+                    # case blocking doesn't matter
+                    result = _watched_children[pid]
+                    if isinstance(result, tuple):
+                        # it finished. libev child watchers
+                        # are one-shot
+                        del _watched_children[pid]
+                        return result[:2]
+                    # it's not finished
+                    return (0, 0)
+
+                # Ok, we need to "block". Do so via a watcher so that we're
+                # cooperative. We know it's our child, etc, so this should work.
+                watcher = _watched_children[pid]
+                # We can't start a watcher that's already started,
+                # so we can't reuse the existing watcher. Notice that the
+                # old watcher must not have fired already, or during this time, but
+                # only after we successfully `start()` the watcher. So this must
+                # not yield to the event loop.
+                with watcher.loop.child(pid, False) as new_watcher:
+                    get_hub().wait(new_watcher)
+                # Ok, so now the new watcher is done. That means
+                # the old watcher's callback (_on_child) should
+                # have fired, potentially taking this child out of
+                # _watched_children (but that could depend on how
+                # many callbacks there were to run, so use the
+                # watcher object directly; libev sets all the
+                # watchers at the same time).
+                return watcher.rpid, watcher.rstatus
+
+            # we're not watching it and it may not even  be our child,
+            # so we must go to the OS to be sure to get the right semantics (exception)
+            # XXX
+            # libuv has a race condition because the signal
+            # handler is a Python function, so the InterruptedError
+            # is raised before the signal handler runs and calls the
+            # child watcher
+            # we're not watching it
+            return _waitpid(pid, options)
+
+        def _watch_child(pid, callback=None, loop=None, ref=False):
+            loop = loop or get_hub().loop
+            watcher = loop.child(pid, ref=ref)
+            _watched_children[pid] = watcher
+            watcher.start(_on_child, watcher, callback)
+
+        def fork_and_watch(callback=None, loop=None, ref=False, fork=fork_gevent):
+            """
+            Fork a child process and start a child watcher for it in the parent process.
+
+            This call cooperates with :func:`waitpid` to enable cooperatively waiting
+            for children to finish. When monkey-patching, these functions are patched in as
+            :func:`os.fork` and :func:`os.waitpid`, respectively.
+
+            In the child process, this function calls :func:`gevent.hub.reinit` before returning.
+
+            Availability: POSIX.
+
+            :keyword callback: If given, a callable that will be called with the child watcher
+                when the child finishes.
+            :keyword loop: The loop to start the watcher in. Defaults to the
+                loop of the current hub.
+            :keyword fork: The fork function. Defaults to :func:`the one defined in this
+                module <gevent.os.fork_gevent>` (which automatically calls :func:`gevent.hub.reinit`).
+                Pass the builtin :func:`os.fork` function if you do not need to
+                initialize gevent in the child process.
+
+            .. versionadded:: 1.1b1
+            .. seealso::
+                :func:`gevent.monkey.get_original` To access the builtin :func:`os.fork`.
+            """
+            pid = fork()
+            if pid:
+                # parent
+                _watch_child(pid, callback, loop, ref)
+            return pid
+
+        __extensions__.append('fork_and_watch')
+        __extensions__.append('fork_gevent')
+
+        if 'forkpty' in __implements__:
+            def forkpty_and_watch(callback=None, loop=None, ref=False, forkpty=forkpty_gevent):
+                """
+                Like :func:`fork_and_watch`, except using :func:`forkpty_gevent`.
+
+                Availability: Some Unix systems.
+
+                .. versionadded:: 1.1b5
+                """
+                result = []
+
+                def _fork():
+                    pid_and_fd = forkpty()
+                    result.append(pid_and_fd)
+                    return pid_and_fd[0]
+                fork_and_watch(callback, loop, ref, _fork)
+                return result[0]
+
+            __extensions__.append('forkpty_and_watch')
+
+        # Watch children by default
+        if not config.disable_watch_children:
+            # Broken out into separate functions instead of simple name aliases
+            # for documentation purposes.
+            def fork(*args, **kwargs):
+                """
+                Forks a child process and starts a child watcher for it in the
+                parent process so that ``waitpid`` and SIGCHLD work as expected.
+
+                This implementation of ``fork`` is a wrapper for :func:`fork_and_watch`
+                when the environment variable ``GEVENT_NOWAITPID`` is *not* defined.
+                This is the default and should be used by most applications.
+
+                .. versionchanged:: 1.1b2
+                """
+                # take any args to match fork_and_watch
+                return fork_and_watch(*args, **kwargs)
+
+            if 'forkpty' in __implements__:
+                def forkpty(*args, **kwargs):
+                    """
+                    Like :func:`fork`, but using :func:`forkpty_gevent`.
+
+                    This implementation of ``forkpty`` is a wrapper for :func:`forkpty_and_watch`
+                    when the environment variable ``GEVENT_NOWAITPID`` is *not* defined.
+                    This is the default and should be used by most applications.
+
+                    .. versionadded:: 1.1b5
+                    """
+                    # take any args to match fork_and_watch
+                    return forkpty_and_watch(*args, **kwargs)
+            __implements__.append("waitpid")
+
+            if hasattr(os, 'posix_spawn'):
+                _raw_posix_spawn = os.posix_spawn
+                _raw_posix_spawnp = os.posix_spawnp
+
+                def posix_spawn(*args, **kwargs):
+                    pid = _raw_posix_spawn(*args, **kwargs)
+                    _watch_child(pid)
+                    return pid
+
+                def posix_spawnp(*args, **kwargs):
+                    pid = _raw_posix_spawnp(*args, **kwargs)
+                    _watch_child(pid)
+                    return pid
+
+                __implements__.append("posix_spawn")
+                __implements__.append("posix_spawnp")
+        else:
+            def fork():
+                """
+                Forks a child process, initializes gevent in the child,
+                but *does not* prepare the parent to wait for the child or receive SIGCHLD.
+
+                This implementation of ``fork`` is a wrapper for :func:`fork_gevent`
+                when the environment variable ``GEVENT_NOWAITPID`` *is* defined.
+                This is not recommended for most applications.
+                """
+                return fork_gevent()
+
+            if 'forkpty' in __implements__:
+                def forkpty():
+                    """
+                    Like :func:`fork`, but using :func:`os.forkpty`
+
+                    This implementation of ``forkpty`` is a wrapper for :func:`forkpty_gevent`
+                    when the environment variable ``GEVENT_NOWAITPID`` *is* defined.
+                    This is not recommended for most applications.
+
+                    .. versionadded:: 1.1b5
+                    """
+                    return forkpty_gevent()
+            __extensions__.append("waitpid")
+
+else:
+    __implements__.remove('fork')
+
+
+__imports__ = copy_globals(os, globals(),
+                           names_to_ignore=__implements__ + __extensions__,
+                           dunder_names_to_keep=())
+
+__all__ = list(set(__implements__ + __extensions__))

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/pool.py

@@ -0,0 +1,677 @@
+# Copyright (c) 2009-2011 Denis Bilenko. See LICENSE for details.
+"""
+Managing greenlets in a group.
+
+The :class:`Group` class in this module abstracts a group of running
+greenlets. When a greenlet dies, it's automatically removed from the
+group. All running greenlets in a group can be waited on with
+:meth:`Group.join`, or all running greenlets can be killed with
+:meth:`Group.kill`.
+
+The :class:`Pool` class, which is a subclass of :class:`Group`,
+provides a way to limit concurrency: its :meth:`spawn <Pool.spawn>`
+method blocks if the number of greenlets in the pool has already
+reached the limit, until there is a free slot.
+"""
+from __future__ import print_function, absolute_import, division
+
+
+from gevent.hub import GreenletExit, getcurrent, kill as _kill
+from gevent.greenlet import joinall, Greenlet
+from gevent.queue import Full as QueueFull
+from gevent.timeout import Timeout
+from gevent.event import Event
+from gevent.lock import Semaphore, DummySemaphore
+
+from gevent._compat import izip
+from gevent._imap import IMap
+from gevent._imap import IMapUnordered
+
+__all__ = [
+    'Group',
+    'Pool',
+    'PoolFull',
+]
+
+
+
+
+class GroupMappingMixin(object):
+    # Internal, non-public API class.
+    # Provides mixin methods for implementing mapping pools. Subclasses must define:
+
+    __slots__ = ()
+
+    def spawn(self, func, *args, **kwargs):
+        """
+        A function that runs *func* with *args* and *kwargs*, potentially
+        asynchronously. Return a value with a ``get`` method that blocks
+        until the results of func are available, and a ``rawlink`` method
+        that calls a callback when the results are available.
+
+        If this object has an upper bound on how many asyncronously executing
+        tasks can exist, this method may block until a slot becomes available.
+        """
+        raise NotImplementedError()
+
+    def _apply_immediately(self):
+        """
+        should the function passed to apply be called immediately,
+        synchronously?
+        """
+        raise NotImplementedError()
+
+    def _apply_async_use_greenlet(self):
+        """
+        Should apply_async directly call Greenlet.spawn(), bypassing
+        `spawn`?
+
+        Return true when self.spawn would block.
+        """
+        raise NotImplementedError()
+
+    def _apply_async_cb_spawn(self, callback, result):
+        """
+        Run the given callback function, possibly
+        asynchronously, possibly synchronously.
+        """
+        raise NotImplementedError()
+
+    def apply_cb(self, func, args=None, kwds=None, callback=None):
+        """
+        :meth:`apply` the given *func(\\*args, \\*\\*kwds)*, and, if a *callback* is given, run it with the
+        results of *func* (unless an exception was raised.)
+
+        The *callback* may be called synchronously or asynchronously. If called
+        asynchronously, it will not be tracked by this group. (:class:`Group` and :class:`Pool`
+        call it asynchronously in a new greenlet; :class:`~gevent.threadpool.ThreadPool` calls
+        it synchronously in the current greenlet.)
+        """
+        result = self.apply(func, args, kwds)
+        if callback is not None:
+            self._apply_async_cb_spawn(callback, result)
+        return result
+
+    def apply_async(self, func, args=None, kwds=None, callback=None):
+        """
+        A variant of the :meth:`apply` method which returns a :class:`~.Greenlet` object.
+
+        When the returned greenlet gets to run, it *will* call :meth:`apply`,
+        passing in *func*, *args* and *kwds*.
+
+        If *callback* is specified, then it should be a callable which
+        accepts a single argument. When the result becomes ready
+        callback is applied to it (unless the call failed).
+
+        This method will never block, even if this group is full (that is,
+        even if :meth:`spawn` would block, this method will not).
+
+        .. caution:: The returned greenlet may or may not be tracked
+           as part of this group, so :meth:`joining <join>` this group is
+           not a reliable way to wait for the results to be available or
+           for the returned greenlet to run; instead, join the returned
+           greenlet.
+
+        .. tip:: Because :class:`~.ThreadPool` objects do not track greenlets, the returned
+           greenlet will never be a part of it. To reduce overhead and improve performance,
+           :class:`Group` and :class:`Pool` may choose to track the returned
+           greenlet. These are implementation details that may change.
+        """
+        if args is None:
+            args = ()
+        if kwds is None:
+            kwds = {}
+        if self._apply_async_use_greenlet():
+            # cannot call self.spawn() directly because it will block
+            # XXX: This is always the case for ThreadPool, but for Group/Pool
+            # of greenlets, this is only the case when they are full...hence
+            # the weasely language about "may or may not be tracked". Should we make
+            # Group/Pool always return true as well so it's never tracked by any
+            # implementation? That would simplify that logic, but could increase
+            # the total number of greenlets in the system and add a layer of
+            # overhead for the simple cases when the pool isn't full.
+            return Greenlet.spawn(self.apply_cb, func, args, kwds, callback)
+
+        greenlet = self.spawn(func, *args, **kwds)
+        if callback is not None:
+            greenlet.link(pass_value(callback))
+        return greenlet
+
+    def apply(self, func, args=None, kwds=None):
+        """
+        Rough quivalent of the :func:`apply()` builtin function blocking until
+        the result is ready and returning it.
+
+        The ``func`` will *usually*, but not *always*, be run in a way
+        that allows the current greenlet to switch out (for example,
+        in a new greenlet or thread, depending on implementation). But
+        if the current greenlet or thread is already one that was
+        spawned by this pool, the pool may choose to immediately run
+        the `func` synchronously.
+
+        Any exception ``func`` raises will be propagated to the caller of ``apply`` (that is,
+        this method will raise the exception that ``func`` raised).
+        """
+        if args is None:
+            args = ()
+        if kwds is None:
+            kwds = {}
+        if self._apply_immediately():
+            return func(*args, **kwds)
+        return self.spawn(func, *args, **kwds).get()
+
+    def __map(self, func, iterable):
+        return [g.get() for g in
+                [self.spawn(func, i) for i in iterable]]
+
+    def map(self, func, iterable):
+        """Return a list made by applying the *func* to each element of
+        the iterable.
+
+        .. seealso:: :meth:`imap`
+        """
+        # We can't return until they're all done and in order. It
+        # wouldn't seem to much matter what order we wait on them in,
+        # so the simple, fast (50% faster than imap) solution would be:
+
+        # return [g.get() for g in
+        #           [self.spawn(func, i) for i in iterable]]
+
+        # If the pool size is unlimited (or more than the len(iterable)), this
+        # is equivalent to imap (spawn() will never block, all of them run concurrently,
+        # we call get() in the order the iterable was given).
+
+        # Now lets imagine the pool if is limited size. Suppose the
+        # func is time.sleep, our pool is limited to 3 threads, and
+        # our input is [10, 1, 10, 1, 1] We would start three threads,
+        # one to sleep for 10, one to sleep for 1, and the last to
+        # sleep for 10. We would block starting the fourth thread. At
+        # time 1, we would finish the second thread and start another
+        # one for time 1. At time 2, we would finish that one and
+        # start the last thread, and then begin executing get() on the first
+        # thread.
+
+        # Because it's spawn that blocks, this is *also* equivalent to what
+        # imap would do.
+
+        # The one remaining difference is that imap runs in its own
+        # greenlet, potentially changing the way the event loop runs.
+        # That's easy enough to do.
+
+        g = Greenlet.spawn(self.__map, func, iterable)
+        return g.get()
+
+    def map_cb(self, func, iterable, callback=None):
+        result = self.map(func, iterable)
+        if callback is not None:
+            callback(result) # pylint:disable=not-callable
+        return result
+
+    def map_async(self, func, iterable, callback=None):
+        """
+        A variant of the map() method which returns a Greenlet object that is executing
+        the map function.
+
+        If callback is specified then it should be a callable which accepts a
+        single argument.
+        """
+        return Greenlet.spawn(self.map_cb, func, iterable, callback)
+
+    def __imap(self, cls, func, *iterables, **kwargs):
+        # Python 2 doesn't support the syntax that lets us mix varargs and
+        # a named kwarg, so we have to unpack manually
+        maxsize = kwargs.pop('maxsize', None)
+        if kwargs:
+            raise TypeError("Unsupported keyword arguments")
+        return cls.spawn(func, izip(*iterables), spawn=self.spawn,
+                         _zipped=True, maxsize=maxsize)
+
+    def imap(self, func, *iterables, **kwargs):
+        """
+        imap(func, *iterables, maxsize=None) -> iterable
+
+        An equivalent of :func:`itertools.imap`, operating in parallel.
+        The *func* is applied to each element yielded from each
+        iterable in *iterables* in turn, collecting the result.
+
+        If this object has a bound on the number of active greenlets it can
+        contain (such as :class:`Pool`), then at most that number of tasks will operate
+        in parallel.
+
+        :keyword int maxsize: If given and not-None, specifies the maximum number of
+            finished results that will be allowed to accumulate awaiting the reader;
+            more than that number of results will cause map function greenlets to begin
+            to block. This is most useful if there is a great disparity in the speed of
+            the mapping code and the consumer and the results consume a great deal of resources.
+
+            .. note:: This is separate from any bound on the number of active parallel
+               tasks, though they may have some interaction (for example, limiting the
+               number of parallel tasks to the smallest bound).
+
+            .. note:: Using a bound is slightly more computationally expensive than not using a bound.
+
+            .. tip:: The :meth:`imap_unordered` method makes much better
+                use of this parameter. Some additional, unspecified,
+                number of objects may be required to be kept in memory
+                to maintain order by this function.
+
+        :return: An iterable object.
+
+        .. versionchanged:: 1.1b3
+            Added the *maxsize* keyword parameter.
+        .. versionchanged:: 1.1a1
+            Accept multiple *iterables* to iterate in parallel.
+        """
+        return self.__imap(IMap, func, *iterables, **kwargs)
+
+    def imap_unordered(self, func, *iterables, **kwargs):
+        """
+        imap_unordered(func, *iterables, maxsize=None) -> iterable
+
+        The same as :meth:`imap` except that the ordering of the results
+        from the returned iterator should be considered in arbitrary
+        order.
+
+        This is lighter weight than :meth:`imap` and should be preferred if order
+        doesn't matter.
+
+        .. seealso:: :meth:`imap` for more details.
+        """
+        return self.__imap(IMapUnordered, func, *iterables, **kwargs)
+
+
+class Group(GroupMappingMixin):
+    """
+    Maintain a group of greenlets that are still running, without
+    limiting their number.
+
+    Links to each item and removes it upon notification.
+
+    Groups can be iterated to discover what greenlets they are tracking,
+    they can be tested to see if they contain a greenlet, and they know the
+    number (len) of greenlets they are tracking. If they are not tracking any
+    greenlets, they are False in a boolean context.
+
+    .. attribute:: greenlet_class
+
+        Either :class:`gevent.Greenlet` (the default) or a subclass.
+        These are the type of
+        object we will :meth:`spawn`. This can be
+        changed on an instance or in a subclass.
+    """
+
+    greenlet_class = Greenlet
+
+    def __init__(self, *args):
+        assert len(args) <= 1, args
+        self.greenlets = set(*args)
+        if args:
+            for greenlet in args[0]:
+                greenlet.rawlink(self._discard)
+        # each item we kill we place in dying, to avoid killing the same greenlet twice
+        self.dying = set()
+        self._empty_event = Event()
+        self._empty_event.set()
+
+    def __repr__(self):
+        return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self.greenlets)
+
+    def __len__(self):
+        """
+        Answer how many greenlets we are tracking. Note that if we are empty,
+        we are False in a boolean context.
+        """
+        return len(self.greenlets)
+
+    def __contains__(self, item):
+        """
+        Answer if we are tracking the given greenlet.
+        """
+        return item in self.greenlets
+
+    def __iter__(self):
+        """
+        Iterate across all the greenlets we are tracking, in no particular order.
+        """
+        return iter(self.greenlets)
+
+    def add(self, greenlet):
+        """
+        Begin tracking the *greenlet*.
+
+        If this group is :meth:`full`, then this method may block
+        until it is possible to track the greenlet.
+
+        Typically the *greenlet* should **not** be started when
+        it is added because if this object blocks in this method,
+        then the *greenlet* may run to completion before it is tracked.
+        """
+        try:
+            rawlink = greenlet.rawlink
+        except AttributeError:
+            pass  # non-Greenlet greenlet, like MAIN
+        else:
+            rawlink(self._discard)
+        self.greenlets.add(greenlet)
+        self._empty_event.clear()
+
+    def _discard(self, greenlet):
+        self.greenlets.discard(greenlet)
+        self.dying.discard(greenlet)
+        if not self.greenlets:
+            self._empty_event.set()
+
+    def discard(self, greenlet):
+        """
+        Stop tracking the greenlet.
+        """
+        self._discard(greenlet)
+        try:
+            unlink = greenlet.unlink
+        except AttributeError:
+            pass  # non-Greenlet greenlet, like MAIN
+        else:
+            unlink(self._discard)
+
+    def start(self, greenlet):
+        """
+        Add the **unstarted** *greenlet* to the collection of greenlets
+        this group is monitoring, and then start it.
+        """
+        self.add(greenlet)
+        greenlet.start()
+
+    def spawn(self, *args, **kwargs): # pylint:disable=arguments-differ
+        """
+        Begin a new greenlet with the given arguments (which are passed
+        to the greenlet constructor) and add it to the collection of greenlets
+        this group is monitoring.
+
+        :return: The newly started greenlet.
+        """
+        greenlet = self.greenlet_class(*args, **kwargs)
+        self.start(greenlet)
+        return greenlet
+
+#     def close(self):
+#         """Prevents any more tasks from being submitted to the pool"""
+#         self.add = RaiseException("This %s has been closed" % self.__class__.__name__)
+
+    def join(self, timeout=None, raise_error=False):
+        """
+        Wait for this group to become empty *at least once*.
+
+        If there are no greenlets in the group, returns immediately.
+
+        .. note:: By the time the waiting code (the caller of this
+           method) regains control, a greenlet may have been added to
+           this group, and so this object may no longer be empty. (That
+           is, ``group.join(); assert len(group) == 0`` is not
+           guaranteed to hold.) This method only guarantees that the group
+           reached a ``len`` of 0 at some point.
+
+        :keyword bool raise_error: If True (*not* the default), if any
+            greenlet that finished while the join was in progress raised
+            an exception, that exception will be raised to the caller of
+            this method. If multiple greenlets raised exceptions, which
+            one gets re-raised is not determined. Only greenlets currently
+            in the group when this method is called are guaranteed to
+            be checked for exceptions.
+
+        :return bool: A value indicating whether this group became empty.
+           If the timeout is specified and the group did not become empty
+           during that timeout, then this will be a false value. Otherwise
+           it will be a true value.
+
+        .. versionchanged:: 1.2a1
+           Add the return value.
+        """
+        greenlets = list(self.greenlets) if raise_error else ()
+        result = self._empty_event.wait(timeout=timeout)
+
+        for greenlet in greenlets:
+            if greenlet.exception is not None:
+                if hasattr(greenlet, '_raise_exception'):
+                    greenlet._raise_exception()
+                raise greenlet.exception
+
+        return result
+
+    def kill(self, exception=GreenletExit, block=True, timeout=None):
+        """
+        Kill all greenlets being tracked by this group.
+        """
+        timer = Timeout._start_new_or_dummy(timeout)
+        try:
+            while self.greenlets:
+                for greenlet in list(self.greenlets):
+                    if greenlet in self.dying:
+                        continue
+                    try:
+                        kill = greenlet.kill
+                    except AttributeError:
+                        _kill(greenlet, exception)
+                    else:
+                        kill(exception, block=False)
+                    self.dying.add(greenlet)
+                if not block:
+                    break
+                joinall(self.greenlets)
+        except Timeout as ex:
+            if ex is not timer:
+                raise
+        finally:
+            timer.cancel()
+
+    def killone(self, greenlet, exception=GreenletExit, block=True, timeout=None):
+        """
+        If the given *greenlet* is running and being tracked by this group,
+        kill it.
+        """
+        if greenlet not in self.dying and greenlet in self.greenlets:
+            greenlet.kill(exception, block=False)
+            self.dying.add(greenlet)
+            if block:
+                greenlet.join(timeout)
+
+    def full(self):
+        """
+        Return a value indicating whether this group can track more greenlets.
+
+        In this implementation, because there are no limits on the number of
+        tracked greenlets, this will always return a ``False`` value.
+        """
+        return False
+
+    def wait_available(self, timeout=None):
+        """
+        Block until it is possible to :meth:`spawn` a new greenlet.
+
+        In this implementation, because there are no limits on the number
+        of tracked greenlets, this will always return immediately.
+        """
+
+    # MappingMixin methods
+
+    def _apply_immediately(self):
+        # If apply() is called from one of our own
+        # worker greenlets, don't spawn a new one---if we're full, that
+        # could deadlock.
+        return getcurrent() in self
+
+    def _apply_async_cb_spawn(self, callback, result):
+        Greenlet.spawn(callback, result)
+
+    def _apply_async_use_greenlet(self):
+        # cannot call self.spawn() because it will block, so
+        # use a fresh, untracked greenlet that when run will
+        # (indirectly) call self.spawn() for us.
+        return self.full()
+
+
+
+class PoolFull(QueueFull):
+    """
+    Raised when a Pool is full and an attempt was made to
+    add a new greenlet to it in non-blocking mode.
+    """
+
+
+class Pool(Group):
+
+    def __init__(self, size=None, greenlet_class=None):
+        """
+        Create a new pool.
+
+        A pool is like a group, but the maximum number of members
+        is governed by the *size* parameter.
+
+        :keyword int size: If given, this non-negative integer is the
+            maximum count of active greenlets that will be allowed in
+            this pool. A few values have special significance:
+
+            * `None` (the default) places no limit on the number of
+              greenlets. This is useful when you want to track, but not limit,
+              greenlets. In general, a :class:`Group`
+              may be a more efficient way to achieve the same effect, but some things
+              need the additional abilities of this class (one example being the *spawn*
+              parameter of :class:`gevent.baseserver.BaseServer` and
+              its subclass :class:`gevent.pywsgi.WSGIServer`).
+
+            * ``0`` creates a pool that can never have any active greenlets. Attempting
+              to spawn in this pool will block forever. This is only useful
+              if an application uses :meth:`wait_available` with a timeout and checks
+              :meth:`free_count` before attempting to spawn.
+        """
+        if size is not None and size < 0:
+            raise ValueError('size must not be negative: %r' % (size, ))
+        Group.__init__(self)
+        self.size = size
+        if greenlet_class is not None:
+            self.greenlet_class = greenlet_class
+        if size is None:
+            factory = DummySemaphore
+        else:
+            factory = Semaphore
+        self._semaphore = factory(size)
+
+    def wait_available(self, timeout=None):
+        """
+        Wait until it's possible to spawn a greenlet in this pool.
+
+        :param float timeout: If given, only wait the specified number
+            of seconds.
+
+        .. warning:: If the pool was initialized with a size of 0, this
+           method will block forever unless a timeout is given.
+
+        :return: A number indicating how many new greenlets can be put into
+           the pool without blocking.
+
+        .. versionchanged:: 1.1a3
+            Added the ``timeout`` parameter.
+        """
+        return self._semaphore.wait(timeout=timeout)
+
+    def full(self):
+        """
+        Return a boolean indicating whether this pool is full, e.g. if
+        :meth:`add` would block.
+
+        :return: False if there is room for new members, True if there isn't.
+        """
+        return self.free_count() <= 0
+
+    def free_count(self):
+        """
+        Return a number indicating *approximately* how many more members
+        can be added to this pool.
+        """
+        if self.size is None:
+            return 1
+        return max(0, self.size - len(self))
+
+    def start(self, greenlet, *args, **kwargs): # pylint:disable=arguments-differ
+        """
+        start(greenlet, blocking=True, timeout=None) -> None
+
+        Add the **unstarted** *greenlet* to the collection of greenlets
+        this group is monitoring and then start it.
+
+        Parameters are as for :meth:`add`.
+        """
+        self.add(greenlet, *args, **kwargs)
+        greenlet.start()
+
+    def add(self, greenlet, blocking=True, timeout=None): # pylint:disable=arguments-differ
+        """
+        Begin tracking the given **unstarted** greenlet, possibly blocking
+        until space is available.
+
+        Usually you should call :meth:`start` to track and start the greenlet
+        instead of using this lower-level method, or :meth:`spawn` to
+        also create the greenlet.
+
+        :keyword bool blocking: If True (the default), this function
+            will block until the pool has space or a timeout occurs.  If
+            False, this function will immediately raise a Timeout if the
+            pool is currently full.
+        :keyword float timeout: The maximum number of seconds this
+            method will block, if ``blocking`` is True.  (Ignored if
+            ``blocking`` is False.)
+        :raises PoolFull: if either ``blocking`` is False and the pool
+            was full, or if ``blocking`` is True and ``timeout`` was
+            exceeded.
+
+        ..  caution:: If the *greenlet* has already been started and
+            *blocking* is true, then the greenlet may run to completion
+            while the current greenlet blocks waiting to track it. This would
+            enable higher concurrency than desired.
+
+        ..  seealso:: :meth:`Group.add`
+
+        ..  versionchanged:: 1.3.0 Added the ``blocking`` and
+            ``timeout`` parameters.
+        """
+        if not self._semaphore.acquire(blocking=blocking, timeout=timeout):
+            # We failed to acquire the semaphore.
+            # If blocking was True, then there was a timeout. If blocking was
+            # False, then there was no capacity. Either way, raise PoolFull.
+            raise PoolFull()
+
+        try:
+            Group.add(self, greenlet)
+        except:
+            self._semaphore.release()
+            raise
+
+    def _discard(self, greenlet):
+        Group._discard(self, greenlet)
+        self._semaphore.release()
+
+
+class pass_value(object):
+    __slots__ = ['callback']
+
+    def __init__(self, callback):
+        self.callback = callback
+
+    def __call__(self, source):
+        if source.successful():
+            self.callback(source.value)
+
+    def __hash__(self):
+        return hash(self.callback)
+
+    def __eq__(self, other):
+        return self.callback == getattr(other, 'callback', other)
+
+    def __str__(self):
+        return str(self.callback)
+
+    def __repr__(self):
+        return repr(self.callback)
+
+    def __getattr__(self, item):
+        assert item != 'callback'
+        return getattr(self.callback, item)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/pywsgi.py

@@ -0,0 +1,1727 @@
+# Copyright (c) 2005-2009, eventlet contributors
+# Copyright (c) 2009-2018, gevent contributors
+"""
+A pure-Python, gevent-friendly WSGI server implementing HTTP/1.1.
+
+The server is provided in :class:`WSGIServer`, but most of the actual
+WSGI work is handled by :class:`WSGIHandler` --- a new instance is
+created for each request. The server can be customized to use
+different subclasses of :class:`WSGIHandler`.
+
+.. important::
+
+   This server is intended primarily for development and testing, and
+   secondarily for other "safe" scenarios where it will not be exposed to
+   potentially malicious input. The code has not been security audited,
+   and is not intended for direct exposure to the public Internet. For production
+   usage on the Internet, either choose a production-strength server such as
+   gunicorn, or put a reverse proxy between gevent and the Internet.
+
+.. versionchanged:: 23.9.0
+
+   Complies more closely with the HTTP specification for chunked transfer encoding.
+   In particular, we are much stricter about trailers, and trailers that
+   are invalid (too long or featuring disallowed characters) forcibly close
+   the connection to the client *after* the results have been sent.
+
+   Trailers otherwise continue to be ignored and are not available to the
+   WSGI application.
+
+"""
+from __future__ import absolute_import
+
+# FIXME: Can we refactor to make smallor?
+# pylint:disable=too-many-lines
+
+import errno
+from io import BytesIO
+import string
+import sys
+import time
+import traceback
+from datetime import datetime
+
+from urllib.parse import unquote
+
+from gevent import socket
+import gevent
+from gevent.server import StreamServer
+from gevent.hub import GreenletExit
+from gevent._compat import reraise
+
+from functools import partial
+unquote_latin1 = partial(unquote, encoding='latin-1')
+
+_no_undoc_members = True # Don't put undocumented things into sphinx
+
+__all__ = [
+    'WSGIServer',
+    'WSGIHandler',
+    'LoggingLogAdapter',
+    'Environ',
+    'SecureEnviron',
+    'WSGISecureEnviron',
+]
+
+
+MAX_REQUEST_LINE = 8192
+# Weekday and month names for HTTP date/time formatting; always English!
+_WEEKDAYNAME = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
+_MONTHNAME = (None,  # Dummy so we can use 1-based month numbers
+              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+
+# The contents of the "HEX" grammar rule for HTTP, upper and lowercase A-F plus digits,
+# in byte form for comparing to the network.
+_HEX = string.hexdigits.encode('ascii')
+
+# The characters allowed in "token" rules.
+
+# token          = 1*tchar
+# tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+#                / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+#                / DIGIT / ALPHA
+#                ; any VCHAR, except delimiters
+# ALPHA          =  %x41-5A / %x61-7A   ; A-Z / a-z
+_ALLOWED_TOKEN_CHARS = frozenset(
+    # Remember we have to be careful because bytestrings
+    # inexplicably iterate as integers, which are not equal to bytes.
+
+    # explicit chars then DIGIT
+    (c.encode('ascii') for c in "!#$%&'*+-.^_`|~0123456789")
+    # Then we add ALPHA
+) | {c.encode('ascii') for c in string.ascii_letters}
+assert b'A' in _ALLOWED_TOKEN_CHARS
+
+
+# Errors
+_ERRORS = {}
+_INTERNAL_ERROR_STATUS = '500 Internal Server Error'
+_INTERNAL_ERROR_BODY = b'Internal Server Error'
+_INTERNAL_ERROR_HEADERS = (
+    ('Content-Type', 'text/plain'),
+    ('Connection', 'close'),
+    ('Content-Length', str(len(_INTERNAL_ERROR_BODY)))
+)
+_ERRORS[500] = (_INTERNAL_ERROR_STATUS, _INTERNAL_ERROR_HEADERS, _INTERNAL_ERROR_BODY)
+
+_BAD_REQUEST_STATUS = '400 Bad Request'
+_BAD_REQUEST_BODY = ''
+_BAD_REQUEST_HEADERS = (
+    ('Content-Type', 'text/plain'),
+    ('Connection', 'close'),
+    ('Content-Length', str(len(_BAD_REQUEST_BODY)))
+)
+_ERRORS[400] = (_BAD_REQUEST_STATUS, _BAD_REQUEST_HEADERS, _BAD_REQUEST_BODY)
+
+_REQUEST_TOO_LONG_RESPONSE = b"HTTP/1.1 414 Request URI Too Long\r\nConnection: close\r\nContent-length: 0\r\n\r\n"
+_BAD_REQUEST_RESPONSE = b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-length: 0\r\n\r\n"
+_CONTINUE_RESPONSE = b"HTTP/1.1 100 Continue\r\n\r\n"
+
+
+def format_date_time(timestamp):
+    # Return a byte-string of the date and time in HTTP format
+    # .. versionchanged:: 1.1b5
+    #  Return a byte string, not a native string
+    year, month, day, hh, mm, ss, wd, _y, _z = time.gmtime(timestamp)
+    value = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (_WEEKDAYNAME[wd], day, _MONTHNAME[month], year, hh, mm, ss)
+    value = value.encode("latin-1")
+    return value
+
+
+class _InvalidClientInput(IOError):
+    # Internal exception raised by Input indicating that the client
+    # sent invalid data at the lowest level of the stream. The result
+    # *should* be a HTTP 400 error.
+    pass
+
+
+class _InvalidClientRequest(ValueError):
+    # Internal exception raised by WSGIHandler.read_request indicating
+    # that the client sent an HTTP request that cannot be parsed
+    # (e.g., invalid grammar). The result *should* be an HTTP 400
+    # error. It must have exactly one argument, the fully formatted
+    # error string.
+
+    def __init__(self, message):
+        ValueError.__init__(self, message)
+        self.formatted_message = message
+
+
+class Input(object):
+
+    __slots__ = ('rfile', 'content_length', 'socket', 'position',
+                 'chunked_input', 'chunk_length', '_chunked_input_error')
+
+    def __init__(self, rfile, content_length, socket=None, chunked_input=False):
+        # pylint:disable=redefined-outer-name
+        self.rfile = rfile
+        self.content_length = content_length
+        self.socket = socket
+        self.position = 0
+        self.chunked_input = chunked_input
+        self.chunk_length = -1
+        self._chunked_input_error = False
+
+    def _discard(self):
+        if self._chunked_input_error:
+            # We are in an unknown state, so we can't necessarily discard
+            # the body (e.g., if the client keeps the socket open, we could hang
+            # here forever).
+            # In this case, we've raised an exception and the user of this object
+            # is going to close the socket, so we don't have to discard
+            return
+
+        if self.socket is None and (self.position < (self.content_length or 0) or self.chunked_input):
+            # ## Read and discard body
+            while 1:
+                d = self.read(16384)
+                if not d:
+                    break
+
+    def _send_100_continue(self):
+        if self.socket is not None:
+            self.socket.sendall(_CONTINUE_RESPONSE)
+            self.socket = None
+
+    def _do_read(self, length=None, use_readline=False):
+        if use_readline:
+            reader = self.rfile.readline
+        else:
+            reader = self.rfile.read
+        content_length = self.content_length
+        if content_length is None:
+            # Either Content-Length or "Transfer-Encoding: chunked" must be present in a request with a body
+            # if it was chunked, then this function would have not been called
+            return b''
+
+        self._send_100_continue()
+        left = content_length - self.position
+        if length is None:
+            length = left
+        elif length > left:
+            length = left
+        if not length:
+            return b''
+
+        # On Python 2, self.rfile is usually socket.makefile(), which
+        # uses cStringIO.StringIO. If *length* is greater than the C
+        # sizeof(int) (typically 32 bits signed), parsing the argument to
+        # readline raises OverflowError. StringIO.read(), OTOH, uses
+        # PySize_t, typically a long (64 bits). In a bare readline()
+        # case, because the header lines we're trying to read with
+        # readline are typically expected to be small, we can correct
+        # that failure by simply doing a smaller call to readline and
+        # appending; failures in read we let propagate.
+        try:
+            read = reader(length)
+        except OverflowError:
+            if not use_readline:
+                # Expecting to read more than 64 bits of data. Ouch!
+                raise
+            # We could loop on calls to smaller readline(), appending them
+            # until we actually get a newline. For uses in this module,
+            # we expect the actual length to be small, but WSGI applications
+            # are allowed to pass in an arbitrary length. (This loop isn't optimal,
+            # but even client applications *probably* have short lines.)
+            read = b''
+            while len(read) < length and not read.endswith(b'\n'):
+                read += reader(MAX_REQUEST_LINE)
+
+        self.position += len(read)
+        if len(read) < length:
+            if (use_readline and not read.endswith(b"\n")) or not use_readline:
+                raise IOError("unexpected end of file while reading request at position %s" % (self.position,))
+
+        return read
+
+    def __read_chunk_length(self, rfile):
+        # Read and return the next integer chunk length. If no
+        # chunk length can be read, raises _InvalidClientInput.
+
+        # Here's the production for a chunk (actually the whole body):
+        # (https://www.rfc-editor.org/rfc/rfc7230#section-4.1)
+
+        # chunked-body   = *chunk
+        #                  last-chunk
+        #                  trailer-part
+        #                  CRLF
+        #
+        # chunk          = chunk-size [ chunk-ext ] CRLF
+        #                  chunk-data CRLF
+        # chunk-size     = 1*HEXDIG
+        # last-chunk     = 1*("0") [ chunk-ext ] CRLF
+        # trailer-part   = *( header-field CRLF )
+        # chunk-data     = 1*OCTET ; a sequence of chunk-size octets
+        #
+        # chunk-ext      = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
+        #
+        # chunk-ext-name = token
+        # chunk-ext-val  = token / quoted-string
+
+        # To cope with malicious or broken clients that fail to send
+        # valid chunk lines, the strategy is to read character by
+        # character until we either reach a ; or newline. If at any
+        # time we read a non-HEX digit, we bail. If we hit a ;,
+        # indicating an chunk-extension, we'll read up to the next
+        # MAX_REQUEST_LINE characters ("A server ought to limit the
+        # total length of chunk extensions received") looking for the
+        # CRLF, and if we don't find it, we bail. If we read more than
+        # 16 hex characters, (the number needed to represent a 64-bit
+        # chunk size), we bail (this protects us from a client that
+        # sends an infinite stream of `F`, for example).
+
+        buf = BytesIO()
+        while 1:
+            char = rfile.read(1)
+            if not char:
+                self._chunked_input_error = True
+                raise _InvalidClientInput("EOF before chunk end reached")
+
+            if char in (
+                b'\r', # Beginning EOL
+                b';', # Beginning extension
+            ):
+                break
+
+            if char not in _HEX: # Invalid data.
+                self._chunked_input_error = True
+                raise _InvalidClientInput("Non-hex data", char)
+
+            buf.write(char)
+
+            if buf.tell() > 16: # Too many hex bytes
+                self._chunked_input_error = True
+                raise _InvalidClientInput("Chunk-size too large.")
+
+        if char == b';':
+            i = 0
+            while i < MAX_REQUEST_LINE:
+                char = rfile.read(1)
+                if char == b'\r':
+                    break
+                i += 1
+            else:
+                # we read more than MAX_REQUEST_LINE without
+                # hitting CR
+                self._chunked_input_error = True
+                raise _InvalidClientInput("Too large chunk extension")
+
+        if char == b'\r':
+            # We either got here from the main loop or from the
+            # end of an extension
+            self.__read_chunk_size_crlf(rfile, newline_only=True)
+            result = int(buf.getvalue(), 16)
+            if result == 0:
+                # The only time a chunk size of zero is allowed is the final
+                # chunk. It is either followed by another \r\n, or some trailers
+                # which are then followed by \r\n.
+                while self.__read_chunk_trailer(rfile):
+                    pass
+            return result
+
+    # Trailers have the following production (they are a header-field followed by CRLF)
+    # See above for the definition of "token".
+    #
+    # header-field   = field-name ":" OWS field-value OWS
+    # field-name     = token
+    # field-value    = *( field-content / obs-fold )
+    # field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+    # field-vchar    = VCHAR / obs-text
+    # obs-fold       = CRLF 1*( SP / HTAB )
+    #                ; obsolete line folding
+    #                ; see Section 3.2.4
+
+
+    def __read_chunk_trailer(self, rfile, ):
+        # With rfile positioned just after a \r\n, read a trailer line.
+        # Return a true value if a non-empty trailer was read, and
+        # return false if an empty trailer was read (meaning the trailers are
+        # done).
+        # If a single line exceeds the MAX_REQUEST_LINE, raise an exception.
+        # If the field-name portion contains invalid characters, raise an exception.
+
+        i = 0
+        empty = True
+        seen_field_name = False
+        while i < MAX_REQUEST_LINE:
+            char = rfile.read(1)
+            if char == b'\r':
+                # Either read the next \n or raise an error.
+                self.__read_chunk_size_crlf(rfile, newline_only=True)
+                break
+            # Not a \r, so we are NOT an empty chunk.
+            empty = False
+            if char == b':' and i > 0:
+                # We're ending the field-name part; stop validating characters.
+                # Unless : was the first character...
+                seen_field_name = True
+            if not seen_field_name and char not in _ALLOWED_TOKEN_CHARS:
+                raise _InvalidClientInput('Invalid token character: %r' % (char,))
+            i += 1
+        else:
+            # We read too much
+            self._chunked_input_error = True
+            raise _InvalidClientInput("Too large chunk trailer")
+        return not empty
+
+    def __read_chunk_size_crlf(self, rfile, newline_only=False):
+        # Also for safety, correctly verify that we get \r\n when expected.
+        if not newline_only:
+            char = rfile.read(1)
+            if char != b'\r':
+                self._chunked_input_error = True
+                raise _InvalidClientInput("Line didn't end in CRLF: %r" % (char,))
+        char = rfile.read(1)
+        if char != b'\n':
+            self._chunked_input_error = True
+            raise _InvalidClientInput("Line didn't end in LF: %r" % (char,))
+
+    def _chunked_read(self, length=None, use_readline=False):
+        # pylint:disable=too-many-branches
+        rfile = self.rfile
+        self._send_100_continue()
+
+        if length == 0:
+            return b""
+
+        if use_readline:
+            reader = self.rfile.readline
+        else:
+            reader = self.rfile.read
+
+        response = []
+        while self.chunk_length != 0:
+            maxreadlen = self.chunk_length - self.position
+            if length is not None and length < maxreadlen:
+                maxreadlen = length
+
+            if maxreadlen > 0:
+                data = reader(maxreadlen)
+                if not data:
+                    self.chunk_length = 0
+                    self._chunked_input_error = True
+                    raise IOError("unexpected end of file while parsing chunked data")
+
+                datalen = len(data)
+                response.append(data)
+
+                self.position += datalen
+                if self.chunk_length == self.position:
+                    self.__read_chunk_size_crlf(rfile)
+
+                if length is not None:
+                    length -= datalen
+                    if length == 0:
+                        break
+                if use_readline and data[-1] == b"\n"[0]:
+                    break
+            else:
+                # We're at the beginning of a chunk, so we need to
+                # determine the next size to read
+                self.chunk_length = self.__read_chunk_length(rfile)
+                self.position = 0
+                # If chunk_length was 0, we already read any trailers and
+                # validated that we have ended with \r\n\r\n.
+
+        return b''.join(response)
+
+    def read(self, length=None):
+        if length is not None and length < 0:
+            length = None
+        if self.chunked_input:
+            return self._chunked_read(length)
+        return self._do_read(length)
+
+    def readline(self, size=None):
+        if size is not None and size < 0:
+            size = None
+        if self.chunked_input:
+            return self._chunked_read(size, True)
+        return self._do_read(size, use_readline=True)
+
+    def readlines(self, hint=None):
+        # pylint:disable=unused-argument
+        return list(self)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        line = self.readline()
+        if not line:
+            raise StopIteration
+        return line
+    __next__ = next
+
+
+try:
+    import mimetools
+    headers_factory = mimetools.Message
+except ImportError:
+    # adapt Python 3 HTTP headers to old API
+    from http import client # pylint:disable=import-error
+
+    class OldMessage(client.HTTPMessage):
+        def __init__(self, **kwargs):
+            super(client.HTTPMessage, self).__init__(**kwargs) # pylint:disable=bad-super-call
+            self.status = ''
+
+        def getheader(self, name, default=None):
+            return self.get(name, default)
+
+        @property
+        def headers(self):
+            for key, value in self._headers:
+                yield '%s: %s\r\n' % (key, value)
+
+        @property
+        def typeheader(self):
+            return self.get('content-type')
+
+    def headers_factory(fp, *args): # pylint:disable=unused-argument
+        try:
+            ret = client.parse_headers(fp, _class=OldMessage)
+        except client.LineTooLong:
+            ret = OldMessage()
+            ret.status = 'Line too long'
+        return ret
+
+
+class WSGIHandler(object):
+    """
+    Handles HTTP requests from a socket, creates the WSGI environment, and
+    interacts with the WSGI application.
+
+    This is the default value of :attr:`WSGIServer.handler_class`.
+    This class may be subclassed carefully, and that class set on a
+    :class:`WSGIServer` instance through a keyword argument at
+    construction time.
+
+    Instances are constructed with the same arguments as passed to the
+    server's :meth:`WSGIServer.handle` method followed by the server
+    itself. The application and environment are obtained from the server.
+
+    """
+    # pylint:disable=too-many-instance-attributes
+
+    protocol_version = 'HTTP/1.1'
+
+    def MessageClass(self, *args):
+        return headers_factory(*args)
+
+    # Attributes reset at various times for each request; not public
+    # documented. Class attributes to keep the constructor fast
+    # (but not make lint tools complain)
+
+    status = None # byte string: b'200 OK'
+    _orig_status = None # native string: '200 OK'
+    response_headers = None # list of tuples (b'name', b'value')
+    code = None # Integer parsed from status
+    provided_date = None
+    provided_content_length = None
+    close_connection = False
+    time_start = 0 # time.time() when begin handling request
+    time_finish = 0 # time.time() when done handling request
+    headers_sent = False # Have we already sent headers?
+    response_use_chunked = False # Write with transfer-encoding chunked
+    # Was the connection upgraded? We shouldn't try to chunk writes in that
+    # case.
+    connection_upgraded = False
+    environ = None # Dict from self.get_environ
+    application = None # application callable from self.server.application
+    requestline = None # native str 'GET / HTTP/1.1'
+    response_length = 0 # How much data we sent
+    result = None # The return value of the WSGI application
+    wsgi_input = None # Instance of Input()
+    content_length = 0 # From application-provided headers Incoming
+    # request headers, instance of MessageClass (gunicorn uses hasattr
+    # on this so the default value needs to be compatible with the
+    # API)
+    headers = headers_factory(BytesIO())
+    request_version = None # str: 'HTTP 1.1'
+    command = None # str: 'GET'
+    path = None # str: '/'
+
+    def __init__(self, sock, address, server, rfile=None):
+        # Deprecation: The rfile kwarg was introduced in 1.0a1 as part
+        # of a refactoring. It was never documented or used. It is
+        # considered DEPRECATED and may be removed in the future. Its
+        # use is not supported.
+
+        self.socket = sock
+        self.client_address = address
+        self.server = server
+        if rfile is None:
+            self.rfile = sock.makefile('rb', -1)
+        else:
+            self.rfile = rfile
+
+    def handle(self):
+        """
+        The main request handling method, called by the server.
+
+        This method runs a request handling loop, calling
+        :meth:`handle_one_request` until all requests on the
+        connection have been handled (that is, it implements
+        keep-alive).
+        """
+        try:
+            while self.socket is not None:
+                self.time_start = time.time()
+                self.time_finish = 0
+
+                result = self.handle_one_request()
+                if result is None:
+                    break
+                if result is True:
+                    continue
+
+                self.status, response_body = result # pylint:disable=unpacking-non-sequence
+                self.socket.sendall(response_body)
+                if self.time_finish == 0:
+                    self.time_finish = time.time()
+                self.log_request()
+                break
+        finally:
+            if self.socket is not None:
+                _sock = getattr(self.socket, '_sock', None) # Python 3
+                try:
+                    # read out request data to prevent error: [Errno 104] Connection reset by peer
+                    if _sock:
+                        try:
+                            # socket.recv would hang
+                            _sock.recv(16384)
+                        finally:
+                            _sock.close()
+                    self.socket.close()
+                except socket.error:
+                    pass
+            self.__dict__.pop('socket', None)
+            self.__dict__.pop('rfile', None)
+            self.__dict__.pop('wsgi_input', None)
+
+    def _check_http_version(self):
+        version_str = self.request_version
+        if not version_str.startswith("HTTP/"):
+            return False
+        version = tuple(int(x) for x in version_str[5:].split("."))  # "HTTP/"
+        if version[1] < 0 or version < (0, 9) or version >= (2, 0):
+            return False
+        return True
+
+    def read_request(self, raw_requestline):
+        """
+        Parse the incoming request.
+
+        Parses various headers into ``self.headers`` using
+        :attr:`MessageClass`. Other attributes that are set upon a successful
+        return of this method include ``self.content_length`` and ``self.close_connection``.
+
+        :param str raw_requestline: A native :class:`str` representing
+           the request line. A processed version of this will be stored
+           into ``self.requestline``.
+
+        :raises ValueError: If the request is invalid. This error will
+           not be logged as a traceback (because it's a client issue, not a server problem).
+        :return: A boolean value indicating whether the request was successfully parsed.
+           This method should either return a true value or have raised a ValueError
+           with details about the parsing error.
+
+        .. versionchanged:: 1.1b6
+           Raise the previously documented :exc:`ValueError` in more cases instead of returning a
+           false value; this allows subclasses more opportunity to customize behaviour.
+        """
+        # pylint:disable=too-many-branches
+        self.requestline = raw_requestline.rstrip()
+        words = self.requestline.split()
+        if len(words) == 3:
+            self.command, self.path, self.request_version = words
+            if not self._check_http_version():
+                raise _InvalidClientRequest('Invalid http version: %r' % (raw_requestline,))
+        elif len(words) == 2:
+            self.command, self.path = words
+            if self.command != "GET":
+                raise _InvalidClientRequest('Expected GET method; Got command=%r; path=%r; raw=%r' % (
+                    self.command, self.path, raw_requestline,))
+            self.request_version = "HTTP/0.9"
+            # QQQ I'm pretty sure we can drop support for HTTP/0.9
+        else:
+            raise _InvalidClientRequest('Invalid HTTP method: %r' % (raw_requestline,))
+
+        self.headers = self.MessageClass(self.rfile, 0)
+
+        if self.headers.status:
+            raise _InvalidClientRequest('Invalid headers status: %r' % (self.headers.status,))
+
+        if self.headers.get("transfer-encoding", "").lower() == "chunked":
+            try:
+                del self.headers["content-length"]
+            except KeyError:
+                pass
+
+        content_length = self.headers.get("content-length")
+        if content_length is not None:
+            content_length = int(content_length)
+            if content_length < 0:
+                raise _InvalidClientRequest('Invalid Content-Length: %r' % (content_length,))
+
+            if content_length and self.command in ('HEAD', ):
+                raise _InvalidClientRequest('Unexpected Content-Length')
+
+        self.content_length = content_length
+
+        if self.request_version == "HTTP/1.1":
+            conntype = self.headers.get("Connection", "").lower()
+            self.close_connection = (conntype == 'close') # pylint:disable=superfluous-parens
+        elif self.request_version == 'HTTP/1.0':
+            conntype = self.headers.get("Connection", "close").lower()
+            self.close_connection = (conntype != 'keep-alive') # pylint:disable=superfluous-parens
+        else:
+            # XXX: HTTP 0.9. We should drop support
+            self.close_connection = True
+
+        return True
+
+    _print_unexpected_exc = staticmethod(traceback.print_exc)
+
+    def log_error(self, msg, *args):
+        if not args:
+            # Already fully formatted, no need to do it again; msg
+            # might contain % chars that would lead to a formatting
+            # error.
+            message = msg
+        else:
+            try:
+                message = msg % args
+            except Exception: # pylint:disable=broad-except
+                self._print_unexpected_exc()
+                message = '%r %r' % (msg, args)
+        try:
+            message = '%s: %s' % (self.socket, message)
+        except Exception: # pylint:disable=broad-except
+            pass
+
+        try:
+            self.server.error_log.write(message + '\n')
+        except Exception: # pylint:disable=broad-except
+            self._print_unexpected_exc()
+
+    def read_requestline(self):
+        """
+        Read and return the HTTP request line.
+
+        Under both Python 2 and 3, this should return the native
+        ``str`` type; under Python 3, this probably means the bytes read
+        from the network need to be decoded (using the ISO-8859-1 charset, aka
+        latin-1).
+        """
+        line = self.rfile.readline(MAX_REQUEST_LINE)
+        line = line.decode('latin-1')
+        return line
+
+    def handle_one_request(self):
+        """
+        Handles one HTTP request using ``self.socket`` and ``self.rfile``.
+
+        Each invocation of this method will do several things, including (but not limited to):
+
+        - Read the request line using :meth:`read_requestline`;
+        - Read the rest of the request, including headers, with :meth:`read_request`;
+        - Construct a new WSGI environment in ``self.environ`` using :meth:`get_environ`;
+        - Store the application in ``self.application``, retrieving it from the server;
+        - Handle the remainder of the request, including invoking the application,
+          with :meth:`handle_one_response`
+
+        There are several possible return values to indicate the state
+        of the client connection:
+
+        - ``None``
+            The client connection is already closed or should
+            be closed because the WSGI application or client set the
+            ``Connection: close`` header. The request handling
+            loop should terminate and perform cleanup steps.
+        - (status, body)
+            An HTTP status and body tuple. The request was in error,
+            as detailed by the status and body. The request handling
+            loop should terminate, close the connection, and perform
+            cleanup steps. Note that the ``body`` is the complete contents
+            to send to the client, including all headers and the initial
+            status line.
+        - ``True``
+            The literal ``True`` value. The request was successfully handled
+            and the response sent to the client by :meth:`handle_one_response`.
+            The connection remains open to process more requests and the connection
+            handling loop should call this method again. This is the typical return
+            value.
+
+        .. seealso:: :meth:`handle`
+
+        .. versionchanged:: 1.1b6
+           Funnel exceptions having to do with invalid HTTP requests through
+           :meth:`_handle_client_error` to allow subclasses to customize. Note that
+           this is experimental and may change in the future.
+        """
+        # pylint:disable=too-many-return-statements
+        if self.rfile.closed:
+            return
+
+        try:
+            self.requestline = self.read_requestline()
+            # Account for old subclasses that haven't done this
+            if isinstance(self.requestline, bytes):
+                self.requestline = self.requestline.decode('latin-1')
+        except socket.error:
+            # "Connection reset by peer" or other socket errors aren't interesting here
+            return
+
+        if not self.requestline:
+            return
+
+        self.response_length = 0
+
+        if len(self.requestline) >= MAX_REQUEST_LINE:
+            return ('414', _REQUEST_TOO_LONG_RESPONSE)
+
+        try:
+            # for compatibility with older versions of pywsgi, we pass self.requestline as an argument there
+            # NOTE: read_request is supposed to raise ValueError on invalid input; allow old
+            # subclasses that return a False value instead.
+            # NOTE: This can mutate the value of self.headers, so self.get_environ() must not be
+            # called until AFTER this call is done.
+            if not self.read_request(self.requestline):
+                return ('400', _BAD_REQUEST_RESPONSE)
+        except Exception as ex: # pylint:disable=broad-except
+            # Notice we don't use self.handle_error because it reports
+            # a 500 error to the client, and this is almost certainly
+            # a client error.
+            # Provide a hook for subclasses.
+            return self._handle_client_error(ex)
+
+        self.environ = self.get_environ()
+        self.application = self.server.application
+
+        self.handle_one_response()
+
+        if self.close_connection:
+            return
+
+        if self.rfile.closed:
+            return
+
+        return True  # read more requests
+
+    def _connection_upgrade_requested(self):
+        if self.headers.get('Connection', '').lower() == 'upgrade':
+            return True
+        if self.headers.get('Upgrade', '').lower() == 'websocket':
+            return True
+        return False
+
+    def finalize_headers(self):
+        if self.provided_date is None:
+            self.response_headers.append((b'Date', format_date_time(time.time())))
+
+        self.connection_upgraded = self.code == 101
+
+        if self.code not in (304, 204):
+            # the reply will include message-body; make sure we have either Content-Length or chunked
+            if self.provided_content_length is None:
+                if hasattr(self.result, '__len__'):
+                    total_len = sum(len(chunk) for chunk in self.result)
+                    total_len_str = str(total_len)
+                    total_len_str = total_len_str.encode("latin-1")
+                    self.response_headers.append((b'Content-Length', total_len_str))
+                else:
+                    self.response_use_chunked = (
+                        not self.connection_upgraded
+                        and self.request_version != 'HTTP/1.0'
+                    )
+                    if self.response_use_chunked:
+                        self.response_headers.append((b'Transfer-Encoding', b'chunked'))
+
+    def _sendall(self, data):
+        try:
+            self.socket.sendall(data)
+        except socket.error as ex:
+            self.status = 'socket error: %s' % ex
+            if self.code > 0:
+                self.code = -self.code
+            raise
+        self.response_length += len(data)
+
+    def _write(self, data,
+               _bytearray=bytearray):
+        if not data:
+            # The application/middleware are allowed to yield
+            # empty bytestrings.
+            return
+
+        if self.response_use_chunked:
+            # Write the chunked encoding header
+            header_str = b'%x\r\n' % len(data)
+            towrite = _bytearray(header_str)
+
+            # data
+            towrite += data
+            # trailer
+            towrite += b'\r\n'
+            self._sendall(towrite)
+        else:
+            self._sendall(data)
+
+    ApplicationError = AssertionError
+
+    def write(self, data):
+        # The write() callable we return from start_response.
+        # https://www.python.org/dev/peps/pep-3333/#the-write-callable
+        # Supposed to do pretty much the same thing as yielding values
+        # from the application's return.
+        if self.code in (304, 204) and data:
+            raise self.ApplicationError('The %s response must have no body' % self.code)
+
+        if self.headers_sent:
+            self._write(data)
+        else:
+            if not self.status:
+                raise self.ApplicationError("The application did not call start_response()")
+            self._write_with_headers(data)
+
+    def _write_with_headers(self, data):
+        self.headers_sent = True
+        self.finalize_headers()
+
+        # self.response_headers and self.status are already in latin-1, as encoded by self.start_response
+        towrite = bytearray(b'HTTP/1.1 ')
+        towrite += self.status
+        towrite += b'\r\n'
+        for header, value in self.response_headers:
+            towrite += header
+            towrite += b': '
+            towrite += value
+            towrite += b"\r\n"
+
+        towrite += b'\r\n'
+        self._sendall(towrite)
+        # No need to copy the data into towrite; we may make an extra syscall
+        # but the copy time could be substantial too, and it reduces the chances
+        # of sendall being able to send everything in one go
+        self._write(data)
+
+    def start_response(self, status, headers, exc_info=None):
+        """
+         .. versionchanged:: 1.2a1
+            Avoid HTTP header injection by raising a :exc:`ValueError`
+            if *status* or any *header* name or value contains a carriage
+            return or newline.
+         .. versionchanged:: 1.1b5
+            Pro-actively handle checking the encoding of the status line
+            and headers during this method. On Python 2, avoid some
+            extra encodings.
+        """
+        # pylint:disable=too-many-branches,too-many-statements
+        if exc_info:
+            try:
+                if self.headers_sent:
+                    # Re-raise original exception if headers sent
+                    reraise(*exc_info)
+            finally:
+                # Avoid dangling circular ref
+                exc_info = None
+
+        # Pep 3333, "The start_response callable":
+        # https://www.python.org/dev/peps/pep-3333/#the-start-response-callable
+        # "Servers should check for errors in the headers at the time
+        # start_response is called, so that an error can be raised
+        # while the application is still running." Here, we check the encoding.
+        # This aids debugging: headers especially are generated programmatically
+        # and an encoding error in a loop or list comprehension yields an opaque
+        # UnicodeError without any clue which header was wrong.
+        # Note that this results in copying the header list at this point, not modifying it,
+        # although we are allowed to do so if needed. This slightly increases memory usage.
+        # We also check for HTTP Response Splitting vulnerabilities
+        response_headers = []
+        header = None
+        value = None
+        try:
+            for header, value in headers:
+                if not isinstance(header, str):
+                    raise UnicodeError("The header must be a native string", header, value)
+                if not isinstance(value, str):
+                    raise UnicodeError("The value must be a native string", header, value)
+                if '\r' in header or '\n' in header:
+                    raise ValueError('carriage return or newline in header name', header)
+                if '\r' in value or '\n' in value:
+                    raise ValueError('carriage return or newline in header value', value)
+                # Either we're on Python 2, in which case bytes is correct, or
+                # we're on Python 3 and the user screwed up (because it should be a native
+                # string). In either case, make sure that this is latin-1 compatible. Under
+                # Python 2, bytes.encode() will take a round-trip through the system encoding,
+                # which may be ascii, which is not really what we want. However, the latin-1 encoding
+                # can encode everything except control characters and the block from 0x7F to 0x9F, so
+                # explicitly round-tripping bytes through the encoding is unlikely to be of much
+                # benefit, so we go for speed (the WSGI spec specifically calls out allowing the range
+                # from 0x00 to 0xFF, although the HTTP spec forbids the control characters).
+                # Note: Some Python 2 implementations, like Jython, may allow non-octet (above 255) values
+                # in their str implementation; this is mentioned in the WSGI spec, but we don't
+                # run on any platform like that so we can assume that a str value is pure bytes.
+                response_headers.append((header.encode("latin-1"),
+                                         value.encode("latin-1")))
+        except UnicodeEncodeError:
+            # If we get here, we're guaranteed to have a header and value
+            raise UnicodeError("Non-latin1 header", repr(header), repr(value))
+
+        # Same as above
+        if not isinstance(status, str):
+            raise UnicodeError("The status string must be a native string")
+        if '\r' in status or '\n' in status:
+            raise ValueError("carriage return or newline in status", status)
+        # don't assign to anything until the validation is complete, including parsing the
+        # code
+        code = int(status.split(' ', 1)[0])
+
+        self.status = status.encode("latin-1")
+        self._orig_status = status # Preserve the native string for logging
+        self.response_headers = response_headers
+        self.code = code
+
+        provided_connection = None # Did the wsgi app give us a Connection header?
+        self.provided_date = None
+        self.provided_content_length = None
+
+        for header, value in headers:
+            header = header.lower()
+            if header == 'connection':
+                provided_connection = value
+            elif header == 'date':
+                self.provided_date = value
+            elif header == 'content-length':
+                self.provided_content_length = value
+
+        if self.request_version == 'HTTP/1.0' and provided_connection is None:
+            conntype = b'close' if self.close_connection else b'keep-alive'
+            response_headers.append((b'Connection', conntype))
+        elif provided_connection == 'close':
+            self.close_connection = True
+
+        if self.code in (304, 204):
+            if self.provided_content_length is not None and self.provided_content_length != '0':
+                msg = 'Invalid Content-Length for %s response: %r (must be absent or zero)' % (self.code, self.provided_content_length)
+                msg = msg.encode('latin-1')
+                raise self.ApplicationError(msg)
+
+        return self.write
+
+    def log_request(self):
+        self.server.log.write(self.format_request() + '\n')
+
+    def format_request(self):
+        now = datetime.now().replace(microsecond=0)
+        length = self.response_length or '-'
+        if self.time_finish:
+            delta = '%.6f' % (self.time_finish - self.time_start)
+        else:
+            delta = '-'
+        client_address = self.client_address[0] if isinstance(self.client_address, tuple) else self.client_address
+        return '%s - - [%s] "%s" %s %s %s' % (
+            client_address or '-',
+            now,
+            self.requestline or '',
+            # Use the native string version of the status, saved so we don't have to
+            # decode. But fallback to the encoded 'status' in case of subclasses
+            # (Is that really necessary? At least there's no overhead.)
+            (self._orig_status or self.status or '000').split()[0],
+            length,
+            delta)
+
+    def process_result(self):
+        for data in self.result:
+            if data:
+                self.write(data)
+        if self.status and not self.headers_sent:
+            # In other words, the application returned an empty
+            # result iterable (and did not use the write callable)
+            # Trigger the flush of the headers.
+            self.write(b'')
+        if self.response_use_chunked:
+            self._sendall(b'0\r\n\r\n')
+
+
+    def run_application(self):
+        assert self.result is None
+        try:
+            self.result = self.application(self.environ, self.start_response)
+            self.process_result()
+        finally:
+            close = getattr(self.result, 'close', None)
+            try:
+                if close is not None:
+                    close()
+            finally:
+                # Discard the result. If it's a generator this can
+                # free a lot of hidden resources (if we failed to iterate
+                # all the way through it---the frames are automatically
+                # cleaned up when StopIteration is raised); but other cases
+                # could still free up resources sooner than otherwise.
+                close = None
+                self.result = None
+
+    #: These errors are silently ignored by :meth:`handle_one_response` to avoid producing
+    #: excess log entries on normal operating conditions. They indicate
+    #: a remote client has disconnected and there is little or nothing
+    #: this process can be expected to do about it. You may change this
+    #: value in a subclass.
+    #:
+    #: The default value includes :data:`errno.EPIPE` and :data:`errno.ECONNRESET`.
+    #: On Windows this also includes :data:`errno.WSAECONNABORTED`.
+    #:
+    #: This is a provisional API, subject to change. See :pr:`377`, :pr:`999`
+    #: and :issue:`136`.
+    #:
+    #: .. versionadded:: 1.3
+    ignored_socket_errors = (errno.EPIPE, errno.ECONNRESET)
+    try:
+        ignored_socket_errors += (errno.WSAECONNABORTED,)
+    except AttributeError:
+        pass # Not windows
+
+    def handle_one_response(self):
+        """
+        Invoke the application to produce one response.
+
+        This is called by :meth:`handle_one_request` after all the
+        state for the request has been established. It is responsible
+        for error handling.
+        """
+        self.time_start = time.time()
+        self.status = None
+        self.headers_sent = False
+
+        self.result = None
+        self.response_use_chunked = False
+        self.connection_upgraded = False
+        self.response_length = 0
+
+        try:
+            try:
+                self.run_application()
+            finally:
+                try:
+                    self.wsgi_input._discard()
+                except _InvalidClientInput:
+                    # This one is deliberately raised to the outer
+                    # scope, because, with the incoming stream in some bad state,
+                    # we can't be sure we can synchronize and properly parse the next
+                    # request.
+                    raise
+                except socket.error:
+                    # Don't let socket exceptions during discarding
+                    # input override any exception that may have been
+                    # raised by the application, such as our own _InvalidClientInput.
+                    # In the general case, these aren't even worth logging (see the comment
+                    # just below)
+                    pass
+        except _InvalidClientInput as ex:
+            # DO log this one because:
+            # - Some of the data may have been read and acted on by the
+            #   application;
+            # - The response may or may not have been sent;
+            # - It's likely that the client is bad, or malicious, and
+            #   users might wish to take steps to block the client.
+            self._handle_client_error(ex)
+            self.close_connection = True
+            self._send_error_response_if_possible(400)
+        except socket.error as ex:
+            if ex.args[0] in self.ignored_socket_errors:
+                # See description of self.ignored_socket_errors.
+                self.close_connection = True
+            else:
+                self.handle_error(*sys.exc_info())
+        except: # pylint:disable=bare-except
+            self.handle_error(*sys.exc_info())
+        finally:
+            self.time_finish = time.time()
+            self.log_request()
+
+    def _send_error_response_if_possible(self, error_code):
+        if self.response_length:
+            self.close_connection = True
+        else:
+            status, headers, body = _ERRORS[error_code]
+            try:
+                self.start_response(status, headers[:])
+                self.write(body)
+            except socket.error:
+                self.close_connection = True
+
+    def _log_error(self, t, v, tb):
+        # TODO: Shouldn't we dump this to wsgi.errors? If we did that now, it would
+        # wind up getting logged twice
+        if not issubclass(t, GreenletExit):
+            context = self.environ
+            if not isinstance(context, self.server.secure_environ_class):
+                context = self.server.secure_environ_class(context)
+            self.server.loop.handle_error(context, t, v, tb)
+
+    def handle_error(self, t, v, tb):
+        # Called for internal, unexpected errors, NOT invalid client input
+        self._log_error(t, v, tb)
+        t = v = tb = None
+        self._send_error_response_if_possible(500)
+
+    def _handle_client_error(self, ex):
+        # Called for invalid client input
+        # Returns the appropriate error response.
+        if not isinstance(ex, (ValueError, _InvalidClientInput)):
+            # XXX: Why not self._log_error to send it through the loop's
+            # handle_error method?
+            # _InvalidClientRequest is a ValueError; _InvalidClientInput is an IOError.
+            traceback.print_exc()
+        if isinstance(ex, _InvalidClientRequest):
+            # No formatting needed, that's already been handled. In fact, because the
+            # formatted message contains user input, it might have a % in it, and attempting
+            # to format that with no arguments would be an error.
+            # However, the error messages do not include the requesting IP
+            # necessarily, so we do add that.
+            self.log_error('(from %s) %s', self.client_address, ex.formatted_message)
+        else:
+            self.log_error('Invalid request (from %s): %s',
+                           self.client_address,
+                           str(ex) or ex.__class__.__name__)
+        return ('400', _BAD_REQUEST_RESPONSE)
+
+    def _headers(self):
+        key = None
+        value = None
+        IGNORED_KEYS = (None, 'CONTENT_TYPE', 'CONTENT_LENGTH')
+        for header in self.headers.headers:
+            if key is not None and header[:1] in " \t":
+                value += header
+                continue
+
+            if key not in IGNORED_KEYS:
+                yield 'HTTP_' + key, value.strip()
+
+            key, value = header.split(':', 1)
+            if '_' in key:
+                # strip incoming bad veaders
+                key = None
+            else:
+                key = key.replace('-', '_').upper()
+
+        if key not in IGNORED_KEYS:
+            yield 'HTTP_' + key, value.strip()
+
+    def get_environ(self):
+        """
+        Construct and return a new WSGI environment dictionary for a specific request.
+
+        This should begin with asking the server for the base environment
+        using :meth:`WSGIServer.get_environ`, and then proceed to add the
+        request specific values.
+
+        By the time this method is invoked the request line and request shall have
+        been parsed and ``self.headers`` shall be populated.
+        """
+        env = self.server.get_environ()
+        env['REQUEST_METHOD'] = self.command
+        # SCRIPT_NAME is explicitly implementation defined. Using an
+        # empty value for SCRIPT_NAME is both explicitly allowed by
+        # both the CGI standard and WSGI PEPs, and also the thing that
+        # makes the most sense from a generic server perspective (we
+        # have no hierarchy or understanding of URLs or files, just a
+        # single application to call. The empty string represents the
+        # application root, which is what we have). Different WSGI
+        # implementations handle this very differently, so portable
+        # applications that rely on SCRIPT_NAME will have to use a
+        # WSGI middleware to set it to a defined value, or otherwise
+        # rely on server-specific mechanisms (e.g, on waitress, use
+        # ``--url-prefix``, in gunicorn set the ``SCRIPT_NAME`` header
+        # or process environment variable, in gevent subclass
+        # WSGIHandler.)
+        #
+        # See https://github.com/gevent/gevent/issues/1667 for discussion.
+        env['SCRIPT_NAME'] = ''
+
+        path, query = self.path.split('?', 1) if '?' in self.path else (self.path, '')
+        # Note that self.path contains the original str object; if it contains
+        # encoded escapes, it will NOT match PATH_INFO.
+        env['PATH_INFO'] = unquote_latin1(path)
+        env['QUERY_STRING'] = query
+
+        if self.headers.typeheader is not None:
+            env['CONTENT_TYPE'] = self.headers.typeheader
+
+        length = self.headers.getheader('content-length')
+        if length:
+            env['CONTENT_LENGTH'] = length
+        env['SERVER_PROTOCOL'] = self.request_version
+
+        client_address = self.client_address
+        if isinstance(client_address, tuple):
+            env['REMOTE_ADDR'] = str(client_address[0])
+            env['REMOTE_PORT'] = str(client_address[1])
+
+        for key, value in self._headers():
+            if key in env:
+                if 'COOKIE' in key:
+                    env[key] += '; ' + value
+                else:
+                    env[key] += ',' + value
+            else:
+                env[key] = value
+
+        sock = self.socket if env.get('HTTP_EXPECT') == '100-continue' else None
+
+        chunked = env.get('HTTP_TRANSFER_ENCODING', '').lower() == 'chunked'
+        # Input refuses to read if the data isn't chunked, and there is no content_length
+        # provided. For 'Upgrade: Websocket' requests, neither of those things is true.
+        handling_reads = not self._connection_upgrade_requested()
+
+        self.wsgi_input = Input(self.rfile, self.content_length, socket=sock, chunked_input=chunked)
+
+        env['wsgi.input'] = self.wsgi_input if handling_reads else self.rfile
+        # This is a non-standard flag indicating that our input stream is
+        # self-terminated (returns EOF when consumed).
+        # See https://github.com/gevent/gevent/issues/1308
+        env['wsgi.input_terminated'] = handling_reads
+        return env
+
+
+class _NoopLog(object):
+    # Does nothing; implements just enough file-like methods
+    # to pass the WSGI validator
+
+    def write(self, *args, **kwargs):
+        # pylint:disable=unused-argument
+        return
+
+    def flush(self):
+        pass
+
+    def writelines(self, *args, **kwargs):
+        pass
+
+
+class LoggingLogAdapter(object):
+    """
+    An adapter for :class:`logging.Logger` instances
+    to let them be used with :class:`WSGIServer`.
+
+    .. warning:: Unless the entire process is monkey-patched at a very
+        early part of the lifecycle (before logging is configured),
+        loggers are likely to not be gevent-cooperative. For example,
+        the socket and syslog handlers use the socket module in a way
+        that can block, and most handlers acquire threading locks.
+
+    .. warning:: It *may* be possible for the logging functions to be
+       called in the :class:`gevent.Hub` greenlet. Code running in the
+       hub greenlet cannot use any gevent blocking functions without triggering
+       a ``LoopExit``.
+
+    .. versionadded:: 1.1a3
+
+    .. versionchanged:: 1.1b6
+       Attributes not present on this object are proxied to the underlying
+       logger instance. This permits using custom :class:`~logging.Logger`
+       subclasses (or indeed, even duck-typed objects).
+
+    .. versionchanged:: 1.1
+       Strip trailing newline characters on the message passed to :meth:`write`
+       because log handlers will usually add one themselves.
+    """
+
+    # gevent avoids importing and using logging because importing it and
+    # creating loggers creates native locks unless monkey-patched.
+
+    __slots__ = ('_logger', '_level')
+
+    def __init__(self, logger, level=20):
+        """
+        Write information to the *logger* at the given *level* (default to INFO).
+        """
+        self._logger = logger
+        self._level = level
+
+    def write(self, msg):
+        if msg and msg.endswith('\n'):
+            msg = msg[:-1]
+        self._logger.log(self._level, msg)
+
+    def flush(self):
+        "No-op; required to be a file-like object"
+
+    def writelines(self, lines):
+        for line in lines:
+            self.write(line)
+
+    def __getattr__(self, name):
+        return getattr(self._logger, name)
+
+    def __setattr__(self, name, value):
+        if name not in LoggingLogAdapter.__slots__:
+            setattr(self._logger, name, value)
+        else:
+            object.__setattr__(self, name, value)
+
+    def __delattr__(self, name):
+        delattr(self._logger, name)
+
+####
+## Environ classes.
+# These subclass dict. They could subclass collections.UserDict on
+# 3.3+ and proxy to the underlying real dict to avoid a copy if we
+# have to print them (on 2.7 it's slightly more complicated to be an
+# instance of collections.MutableMapping; UserDict.UserDict isn't.)
+# Then we could have either the WSGIHandler.get_environ or the
+# WSGIServer.get_environ return one of these proxies, and
+# WSGIHandler.run_application would know to access the `environ.data`
+# attribute to be able to pass the *real* dict to the application
+# (because PEP3333 requires no subclasses, only actual dict objects;
+# wsgiref.validator and webob.Request both enforce this). This has the
+# advantage of not being fragile if anybody else tries to print/log
+# self.environ (and not requiring a copy). However, if there are any
+# subclasses of Handler or Server, this could break if they don't know
+# to return this type.
+####
+
+class Environ(dict):
+    """
+    A base class that can be used for WSGI environment objects.
+
+    Provisional API.
+
+    .. versionadded:: 1.2a1
+    """
+
+    __slots__ = () # add no ivars or weakref ability
+
+    def copy(self):
+        return self.__class__(self)
+
+    if not hasattr(dict, 'iteritems'):
+        # Python 3
+        def iteritems(self):
+            return self.items()
+
+    def __reduce_ex__(self, proto):
+        return (dict, (), None, None, iter(self.iteritems()))
+
+class SecureEnviron(Environ):
+    """
+    An environment that does not print its keys and values
+    by default.
+
+    Provisional API.
+
+    This is intended to keep potentially sensitive information like
+    HTTP authorization and cookies from being inadvertently printed
+    or logged.
+
+    For debugging, each instance can have its *secure_repr* attribute
+    set to ``False``, which will cause it to print like a normal dict.
+
+    When *secure_repr* is ``True`` (the default), then the value of
+    the *whitelist_keys* attribute is consulted; if this value is
+    true-ish, it should be a container (something that responds to
+    ``in``) of key names (typically a list or set). Keys and values in
+    this dictionary that are in *whitelist_keys* will then be printed,
+    while all other values will be masked. These values may be
+    customized on the class by setting the *default_secure_repr* and
+    *default_whitelist_keys*, respectively::
+
+        >>> environ = SecureEnviron(key='value')
+        >>> environ # doctest: +ELLIPSIS
+        <pywsgi.SecureEnviron dict (keys: 1) at ...
+
+    If we whitelist the key, it gets printed::
+
+        >>> environ.whitelist_keys = {'key'}
+        >>> environ
+        {'key': 'value'}
+
+    A non-whitelisted key (*only*, to avoid doctest issues) is masked::
+
+        >>> environ['secure'] = 'secret'; del environ['key']
+        >>> environ
+        {'secure': '<MASKED>'}
+
+    We can turn it off entirely for the instance::
+
+        >>> environ.secure_repr = False
+        >>> environ
+        {'secure': 'secret'}
+
+    We can also customize it at the class level (here we use a new
+    class to be explicit and to avoid polluting the true default
+    values; we would set this class to be the ``environ_class`` of the
+    server)::
+
+        >>> class MyEnviron(SecureEnviron):
+        ...    default_whitelist_keys = ('key',)
+        ...
+        >>> environ = MyEnviron({'key': 'value'})
+        >>> environ
+        {'key': 'value'}
+
+    .. versionadded:: 1.2a1
+    """
+
+    default_secure_repr = True
+    default_whitelist_keys = ()
+    default_print_masked_keys = True
+
+    # Allow instances to override the class values,
+    # but inherit from the class if not present. Keeps instances
+    # small since we can't combine __slots__ with class attributes
+    # of the same name.
+    __slots__ = ('secure_repr', 'whitelist_keys', 'print_masked_keys')
+
+    def __getattr__(self, name):
+        if name in SecureEnviron.__slots__:
+            return getattr(type(self), 'default_' + name)
+        raise AttributeError(name)
+
+    def __repr__(self):
+        if self.secure_repr:
+            whitelist = self.whitelist_keys
+            print_masked = self.print_masked_keys
+            if whitelist:
+                safe = {k: self[k] if k in whitelist else "<MASKED>"
+                        for k in self
+                        if k in whitelist or print_masked}
+                safe_repr = repr(safe)
+                if not print_masked and len(safe) != len(self):
+                    safe_repr = safe_repr[:-1] + ", (hidden keys: %d)}" % (len(self) - len(safe))
+                return safe_repr
+            return "<pywsgi.SecureEnviron dict (keys: %d) at %s>" % (len(self), id(self))
+        return Environ.__repr__(self)
+    __str__ = __repr__
+
+
+class WSGISecureEnviron(SecureEnviron):
+    """
+    Specializes the default list of whitelisted keys to a few
+    common WSGI variables.
+
+    Example::
+
+       >>> environ = WSGISecureEnviron(REMOTE_ADDR='::1', HTTP_AUTHORIZATION='secret')
+       >>> environ
+       {'REMOTE_ADDR': '::1', (hidden keys: 1)}
+       >>> import pprint
+       >>> pprint.pprint(environ)
+       {'REMOTE_ADDR': '::1', (hidden keys: 1)}
+       >>> print(pprint.pformat(environ))
+       {'REMOTE_ADDR': '::1', (hidden keys: 1)}
+    """
+    default_whitelist_keys = ('REMOTE_ADDR', 'REMOTE_PORT', 'HTTP_HOST')
+    default_print_masked_keys = False
+
+
+class WSGIServer(StreamServer):
+    """
+    A WSGI server based on :class:`StreamServer` that supports HTTPS.
+
+
+    :keyword log: If given, an object with a ``write`` method to which
+        request (access) logs will be written. If not given, defaults
+        to :obj:`sys.stderr`. You may pass ``None`` to disable request
+        logging. You may use a wrapper, around e.g., :mod:`logging`,
+        to support objects that don't implement a ``write`` method.
+        (If you pass a :class:`~logging.Logger` instance, or in
+        general something that provides a ``log`` method but not a
+        ``write`` method, such a wrapper will automatically be created
+        and it will be logged to at the :data:`~logging.INFO` level.)
+
+    :keyword error_log: If given, a file-like object with ``write``,
+        ``writelines`` and ``flush`` methods to which error logs will
+        be written. If not given, defaults to :obj:`sys.stderr`. You
+        may pass ``None`` to disable error logging (not recommended).
+        You may use a wrapper, around e.g., :mod:`logging`, to support
+        objects that don't implement the proper methods. This
+        parameter will become the value for ``wsgi.errors`` in the
+        WSGI environment (if not already set). (As with *log*,
+        wrappers for :class:`~logging.Logger` instances and the like
+        will be created automatically and logged to at the :data:`~logging.ERROR`
+        level.)
+
+    .. seealso::
+
+        :class:`LoggingLogAdapter`
+            See important warnings before attempting to use :mod:`logging`.
+
+    .. versionchanged:: 1.1a3
+        Added the ``error_log`` parameter, and set ``wsgi.errors`` in the WSGI
+        environment to this value.
+    .. versionchanged:: 1.1a3
+        Add support for passing :class:`logging.Logger` objects to the ``log`` and
+        ``error_log`` arguments.
+    .. versionchanged:: 20.6.0
+        Passing a ``handle`` kwarg to the constructor is now officially deprecated.
+    """
+
+    #: A callable taking three arguments: (socket, address, server) and returning
+    #: an object with a ``handle()`` method. The callable is called once for
+    #: each incoming socket request, as is its handle method. The handle method should not
+    #: return until all use of the socket is complete.
+    #:
+    #: This class uses the :class:`WSGIHandler` object as the default value. You may
+    #: subclass this class and set a different default value, or you may pass
+    #: a value to use in the ``handler_class`` keyword constructor argument.
+    handler_class = WSGIHandler
+
+    #: The object to which request logs will be written.
+    #: It must never be None. Initialized from the ``log`` constructor
+    #: parameter.
+    log = None
+
+    #: The object to which error logs will be written.
+    #: It must never be None. Initialized from the ``error_log`` constructor
+    #: parameter.
+    error_log = None
+
+    #: The class of environ objects passed to the handlers.
+    #: Must be a dict subclass. For compliance with :pep:`3333`
+    #: and libraries like WebOb, this is simply :class:`dict`
+    #: but this can be customized in a subclass or per-instance
+    #: (probably to :class:`WSGISecureEnviron`).
+    #:
+    #: .. versionadded:: 1.2a1
+    environ_class = dict
+
+    # Undocumented internal detail: the class that WSGIHandler._log_error
+    # will cast to before passing to the loop.
+    secure_environ_class = WSGISecureEnviron
+
+    base_env = {'GATEWAY_INTERFACE': 'CGI/1.1',
+                'SERVER_SOFTWARE': 'gevent/%d.%d Python/%d.%d' % (gevent.version_info[:2] + sys.version_info[:2]),
+                'SCRIPT_NAME': '',
+                'wsgi.version': (1, 0),
+                'wsgi.multithread': False, # XXX: Aren't we really, though?
+                'wsgi.multiprocess': False,
+                'wsgi.run_once': False}
+
+    def __init__(self, listener, application=None, backlog=None, spawn='default',
+                 log='default', error_log='default',
+                 handler_class=None,
+                 environ=None, **ssl_args):
+        if 'handle' in ssl_args:
+            # The ultimate base class (BaseServer) uses 'handle' for
+            # the thing we call 'application'. We never deliberately
+            # bass a `handle` argument to the base class, but one
+            # could sneak in through ``**ssl_args``, even though that
+            # is not the intent, while application is None. That
+            # causes our own ``def handle`` method to be replaced,
+            # probably leading to bad results. Passing a 'handle'
+            # instead of an 'application' can really confuse things.
+            import warnings
+            warnings.warn("Passing 'handle' kwarg to WSGIServer is deprecated. "
+                          "Did you mean application?", DeprecationWarning, stacklevel=2)
+
+        StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **ssl_args)
+
+        if application is not None:
+            self.application = application
+        if handler_class is not None:
+            self.handler_class = handler_class
+
+        # Note that we can't initialize these as class variables:
+        # sys.stderr might get monkey patched at runtime.
+        def _make_log(l, level=20):
+            if l == 'default':
+                return sys.stderr
+            if l is None:
+                return _NoopLog()
+            if not hasattr(l, 'write') and hasattr(l, 'log'):
+                return LoggingLogAdapter(l, level)
+            return l
+        self.log = _make_log(log)
+        self.error_log = _make_log(error_log, 40) # logging.ERROR
+
+        self.set_environ(environ)
+        self.set_max_accept()
+
+    def set_environ(self, environ=None):
+        if environ is not None:
+            self.environ = environ
+        environ_update = getattr(self, 'environ', None)
+
+        self.environ = self.environ_class(self.base_env)
+        if self.ssl_enabled:
+            self.environ['wsgi.url_scheme'] = 'https'
+        else:
+            self.environ['wsgi.url_scheme'] = 'http'
+        if environ_update is not None:
+            self.environ.update(environ_update)
+        if self.environ.get('wsgi.errors') is None:
+            self.environ['wsgi.errors'] = self.error_log
+
+    def set_max_accept(self):
+        if self.environ.get('wsgi.multiprocess'):
+            self.max_accept = 1
+
+    def get_environ(self):
+        return self.environ_class(self.environ)
+
+    def init_socket(self):
+        StreamServer.init_socket(self)
+        self.update_environ()
+
+    def update_environ(self):
+        """
+        Called before the first request is handled to fill in WSGI environment values.
+
+        This includes getting the correct server name and port.
+        """
+        address = self.address
+        if isinstance(address, tuple):
+            if 'SERVER_NAME' not in self.environ:
+                try:
+                    name = socket.getfqdn(address[0])
+                except socket.error:
+                    name = str(address[0])
+                if not isinstance(name, str):
+                    name = name.decode('ascii')
+                self.environ['SERVER_NAME'] = name
+            self.environ.setdefault('SERVER_PORT', str(address[1]))
+        else:
+            self.environ.setdefault('SERVER_NAME', '')
+            self.environ.setdefault('SERVER_PORT', '')
+
+    def handle(self, sock, address):
+        """
+        Create an instance of :attr:`handler_class` to handle the request.
+
+        This method blocks until the handler returns.
+        """
+        # pylint:disable=method-hidden
+        handler = self.handler_class(sock, address, self)
+        handler.handle()
+
+def _main():
+    # Provisional main handler, for quick tests, not production
+    # usage.
+    from gevent import monkey; monkey.patch_all()
+
+    import argparse
+    import importlib
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("app", help="dotted name of WSGI app callable [module:callable]")
+    parser.add_argument("-b", "--bind",
+                        help="The socket to bind",
+                        default=":8080")
+
+    args = parser.parse_args()
+
+    module_name, app_name = args.app.split(':')
+    module = importlib.import_module(module_name)
+    app = getattr(module, app_name)
+    bind = args.bind
+
+    server = WSGIServer(bind, app)
+    server.serve_forever()
+
+if __name__ == '__main__':
+    _main()

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/queue.py

@@ -0,0 +1,772 @@
+# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
+# copyright (c) 2018 gevent
+# cython: auto_pickle=False,embedsignature=True,always_allow_keywords=False
+"""
+Synchronized queues.
+
+The :mod:`gevent.queue` module implements multi-producer, multi-consumer queues
+that work across greenlets, with the API similar to the classes found in the
+standard :mod:`Queue` and :class:`multiprocessing <multiprocessing.Queue>` modules.
+
+The classes in this module implement the iterator protocol. Iterating
+over a queue means repeatedly calling :meth:`get <Queue.get>` until
+:meth:`get <Queue.get>` returns ``StopIteration`` (specifically that
+class, not an instance or subclass).
+
+    >>> import gevent.queue
+    >>> queue = gevent.queue.Queue()
+    >>> queue.put(1)
+    >>> queue.put(2)
+    >>> queue.put(StopIteration)
+    >>> for item in queue:
+    ...    print(item)
+    1
+    2
+
+.. versionchanged:: 1.0
+       ``Queue(0)`` now means queue of infinite size, not a channel. A :exc:`DeprecationWarning`
+       will be issued with this argument.
+"""
+
+
+import sys
+from heapq import heappush as _heappush
+from heapq import heappop as _heappop
+from heapq import heapify as _heapify
+import collections
+
+import queue as __queue__
+# We re-export these exceptions to client modules.
+# But we also want fast access to them from Cython with a cdef,
+# and we do that with the _ definition.
+_Full = Full = __queue__.Full
+_Empty = Empty = __queue__.Empty
+
+from gevent.timeout import Timeout
+from gevent._hub_local import get_hub_noargs as get_hub
+from gevent.exceptions import InvalidSwitchError
+
+__all__ = []
+__implements__ = ['Queue', 'PriorityQueue', 'LifoQueue']
+__extensions__ = ['JoinableQueue', 'Channel']
+__imports__ = ['Empty', 'Full']
+
+
+__all__.append('SimpleQueue')
+# SimpleQueue is implemented in C and directly allocates locks
+# unaffected by monkey patching. We need the Python version.
+SimpleQueue = __queue__._PySimpleQueue # pylint:disable=no-member
+
+if hasattr(__queue__, 'ShutDown'): # New in 3.13
+    ShutDown = __queue__.ShutDown
+    __imports__.append('ShutDown')
+else:
+    class ShutDown(Exception):
+        """
+        gevent extension for Python versions less than 3.13
+        """
+    __extensions__.append('ShutDown')
+
+
+__all__ += (__implements__ + __extensions__ + __imports__)
+
+
+# pylint 2.0.dev2 things collections.dequeue.popleft() doesn't return
+# pylint:disable=assignment-from-no-return
+
+def _safe_remove(deq, item):
+    # For when the item may have been removed by
+    # Queue._unlock
+    try:
+        deq.remove(item)
+    except ValueError:
+        pass
+
+import gevent._waiter
+locals()['Waiter'] = gevent._waiter.Waiter
+locals()['getcurrent'] = __import__('greenlet').getcurrent
+locals()['greenlet_init'] = lambda: None
+
+class ItemWaiter(Waiter): # pylint:disable=undefined-variable
+    # pylint:disable=assigning-non-slot
+    __slots__ = (
+        'item',
+        'queue',
+    )
+
+    def __init__(self, item, queue):
+        Waiter.__init__(self) # pylint:disable=undefined-variable
+        self.item = item
+        self.queue = queue
+
+    def put_and_switch(self):
+        self.queue._put(self.item)
+        self.queue = None
+        self.item = None
+        return self.switch(self)
+
+class Queue(object):
+    """
+    Create a queue object with a given maximum size.
+
+    If *maxsize* is less than or equal to zero or ``None``, the queue
+    size is infinite.
+
+    Queues have a ``len`` equal to the number of items in them (the :meth:`qsize`),
+    but in a boolean context they are always True.
+
+    .. versionchanged:: 1.1b3
+       Queues now support :func:`len`; it behaves the same as :meth:`qsize`.
+    .. versionchanged:: 1.1b3
+       Multiple greenlets that block on a call to :meth:`put` for a full queue
+       will now be awakened to put their items into the queue in the order in which
+       they arrived. Likewise, multiple greenlets that block on a call to :meth:`get` for
+       an empty queue will now receive items in the order in which they blocked. An
+       implementation quirk under CPython *usually* ensured this was roughly the case
+       previously anyway, but that wasn't the case for PyPy.
+    .. versionchanged:: 24.10.1
+       Implement the ``shutdown`` methods from Python 3.13.
+    """
+
+    __slots__ = (
+        '_maxsize',
+        'getters',
+        'putters',
+        'hub',
+        '_event_unlock',
+        'queue',
+        '__weakref__',
+        'is_shutdown', # 3.13
+    )
+
+
+    def __init__(self, maxsize=None, items=(), _warn_depth=2):
+        if maxsize is not None and maxsize <= 0:
+            if maxsize == 0:
+                import warnings
+                warnings.warn(
+                    'Queue(0) now equivalent to Queue(None); if you want a channel, use Channel',
+                    DeprecationWarning,
+                    stacklevel=_warn_depth)
+            maxsize = None
+
+        self._maxsize = maxsize if maxsize is not None else -1
+        # Explicitly maintain order for getters and putters that block
+        # so that callers can consistently rely on getting things out
+        # in the apparent order they went in. This was once required by
+        # imap_unordered. Previously these were set() objects, and the
+        # items put in the set have default hash() and eq() methods;
+        # under CPython, since new objects tend to have increasing
+        # hash values, this tended to roughly maintain order anyway,
+        # but that's not true under PyPy. An alternative to a deque
+        # (to avoid the linear scan of remove()) might be an
+        # OrderedDict, but it's 2.7 only; we don't expect to have so
+        # many waiters that removing an arbitrary element is a
+        # bottleneck, though.
+        self.getters = collections.deque()
+        self.putters = collections.deque()
+        self.hub = get_hub()
+        self._event_unlock = None
+        self.queue = self._create_queue(items)
+        self.is_shutdown = False
+
+    @property
+    def maxsize(self):
+        return self._maxsize if self._maxsize > 0 else None
+
+    @maxsize.setter
+    def maxsize(self, nv):
+        # QQQ make maxsize into a property with setter that schedules unlock if necessary
+        if nv is None or nv <= 0:
+            self._maxsize = -1
+        else:
+            self._maxsize = nv
+
+    def copy(self):
+        return type(self)(self.maxsize, self.queue)
+
+    def _create_queue(self, items=()):
+        return collections.deque(items)
+
+    def _get(self):
+        return self.queue.popleft()
+
+    def _peek(self):
+        return self.queue[0]
+
+    def _put(self, item):
+        self.queue.append(item)
+
+    def __repr__(self):
+        return '<%s at %s%s>' % (type(self).__name__, hex(id(self)), self._format())
+
+    def __str__(self):
+        return '<%s%s>' % (type(self).__name__, self._format())
+
+    def _format(self):
+        result = []
+        if self.maxsize is not None:
+            result.append('maxsize=%r' % (self.maxsize, ))
+        if getattr(self, 'queue', None):
+            result.append('queue=%r' % (self.queue, ))
+        if self.getters:
+            result.append('getters[%s]' % len(self.getters))
+        if self.putters:
+            result.append('putters[%s]' % len(self.putters))
+        if result:
+            return ' ' + ' '.join(result)
+        return ''
+
+    def qsize(self):
+        """Return the size of the queue."""
+        return len(self.queue)
+
+    def __len__(self):
+        """
+        Return the size of the queue. This is the same as :meth:`qsize`.
+
+        .. versionadded: 1.1b3
+
+            Previously, getting len() of a queue would raise a TypeError.
+        """
+
+        return self.qsize()
+
+    def __bool__(self):
+        """
+        A queue object is always True.
+
+        .. versionadded: 1.1b3
+
+           Now that queues support len(), they need to implement ``__bool__``
+           to return True for backwards compatibility.
+        """
+        return True
+
+    def empty(self):
+        """Return ``True`` if the queue is empty, ``False`` otherwise."""
+        return not self.qsize()
+
+    def full(self):
+        """Return ``True`` if the queue is full, ``False`` otherwise.
+
+        ``Queue(None)`` is never full.
+        """
+        return self._maxsize > 0 and self.qsize() >= self._maxsize
+
+    def put(self, item, block=True, timeout=None):
+        """
+        Put an item into the queue.
+
+        If optional arg *block* is true and *timeout* is ``None`` (the default),
+        block if necessary until a free slot is available. If *timeout* is
+        a positive number, it blocks at most *timeout* seconds and raises
+        the :class:`Full` exception if no free slot was available within that time.
+        Otherwise (*block* is false), put an item on the queue if a free slot
+        is immediately available, else raise the :class:`Full` exception (*timeout*
+        is ignored in that case).
+
+        ... versionchanged:: 24.10.1
+           Now raises a ``ValueError`` for a negative *timeout* in the cases
+           that CPython does.
+        """
+        if self.is_shutdown:
+            raise ShutDown
+        if self._maxsize == -1 or self.qsize() < self._maxsize:
+            # there's a free slot, put an item right away.
+            # For compatibility with CPython, verify that the timeout is non-negative.
+            if block and timeout is not None and timeout < 0:
+                raise ValueError("'timeout' must be a non-negative number")
+            self._put(item)
+            if self.getters:
+                self._schedule_unlock()
+            return
+
+        if self.hub is getcurrent(): # pylint:disable=undefined-variable
+            # We're in the mainloop, so we cannot wait; we can switch to other greenlets though.
+            # Check if possible to get a free slot in the queue.
+            while self.getters and self.qsize() and self.qsize() >= self._maxsize:
+                getter = self.getters.popleft()
+                getter.switch(getter)
+            if self.qsize() < self._maxsize:
+                self._put(item)
+                return
+            raise Full
+
+        if block:
+            waiter = ItemWaiter(item, self)
+            self.putters.append(waiter)
+            timeout = Timeout._start_new_or_dummy(timeout, Full)
+            try:
+                if self.getters:
+                    self._schedule_unlock()
+                result = waiter.get()
+                if result is not waiter:
+                    raise InvalidSwitchError("Invalid switch into Queue.put: %r" % (result, ))
+            finally:
+                timeout.cancel()
+                _safe_remove(self.putters, waiter)
+            return
+
+        raise Full
+
+    def put_nowait(self, item):
+        """Put an item into the queue without blocking.
+
+        Only enqueue the item if a free slot is immediately available.
+        Otherwise raise the :class:`Full` exception.
+        """
+        self.put(item, False)
+
+    def __get_or_peek(self, method, block, timeout):
+        # Internal helper method. The `method` should be either
+        # self._get when called from self.get() or self._peek when
+        # called from self.peek(). Call this after the initial check
+        # to see if there are items in the queue.
+
+        if self.is_shutdown:
+            raise ShutDown
+
+        if block and timeout is not None and timeout < 0:
+            raise ValueError("'timeout' must be a non-negative number")
+        if self.hub is getcurrent(): # pylint:disable=undefined-variable
+            # special case to make get_nowait() or peek_nowait() runnable in the mainloop greenlet
+            # there are no items in the queue; try to fix the situation by unlocking putters
+            while self.putters:
+                # Note: get() used popleft(), peek used pop(); popleft
+                # is almost certainly correct.
+                self.putters.popleft().put_and_switch()
+                if self.qsize():
+                    return method()
+            raise Empty
+
+        if not block:
+            # We can't block, we're not the hub, and we have nothing
+            # to return. No choice but to raise the Empty exception.
+            #
+            # CAUTION: Calling ``q.get(False)`` in a tight loop won't
+            # work like it does in CPython where it should eventually
+            # let another thread make progress, because there's never
+            # a chance to switch greenlets here. We don't sleep()
+            # to enforce that, as that would be a significant behaviour
+            # change.
+            raise Empty
+
+        waiter = Waiter() # pylint:disable=undefined-variable
+        timeout = Timeout._start_new_or_dummy(timeout, Empty)
+        try:
+            self.getters.append(waiter)
+            if self.putters:
+                self._schedule_unlock()
+            result = waiter.get()
+            if result is not waiter:
+                raise InvalidSwitchError('Invalid switch into Queue.get: %r' % (result, ))
+            return method()
+        finally:
+            timeout.cancel()
+            _safe_remove(self.getters, waiter)
+
+    def get(self, block=True, timeout=None):
+        """
+        Remove and return an item from the queue.
+
+        If optional args *block* is true and *timeout* is ``None`` (the default),
+        block if necessary until an item is available. If *timeout* is a positive number,
+        it blocks at most *timeout* seconds and raises the :class:`Empty` exception
+        if no item was available within that time. Otherwise (*block* is false), return
+        an item if one is immediately available, else raise the :class:`Empty` exception
+        (*timeout* is ignored in that case).
+        """
+        if self.qsize():
+            if self.putters:
+                self._schedule_unlock()
+            return self._get()
+
+        return self.__get_or_peek(self._get, block, timeout)
+
+    def get_nowait(self):
+        """Remove and return an item from the queue without blocking.
+
+        Only get an item if one is immediately available. Otherwise
+        raise the :class:`Empty` exception.
+        """
+        return self.get(False)
+
+    def peek(self, block=True, timeout=None):
+        """Return an item from the queue without removing it.
+
+        If optional args *block* is true and *timeout* is ``None`` (the default),
+        block if necessary until an item is available. If *timeout* is a positive number,
+        it blocks at most *timeout* seconds and raises the :class:`Empty` exception
+        if no item was available within that time. Otherwise (*block* is false), return
+        an item if one is immediately available, else raise the :class:`Empty` exception
+        (*timeout* is ignored in that case).
+        """
+        if self.qsize():
+            # This doesn't schedule an unlock like get() does because we're not
+            # actually making any space.
+            return self._peek()
+
+        return self.__get_or_peek(self._peek, block, timeout)
+
+    def peek_nowait(self):
+        """Return an item from the queue without blocking.
+
+        Only return an item if one is immediately available. Otherwise
+        raise the :class:`Empty` exception.
+        """
+        return self.peek(False)
+
+    def _unlock(self):
+        while True:
+            repeat = False
+            if self.putters and (self._maxsize == -1 or self.qsize() < self._maxsize):
+                repeat = True
+                try:
+                    putter = self.putters.popleft()
+                    self._put(putter.item)
+                except: # pylint:disable=bare-except
+                    putter.throw(*sys.exc_info())
+                else:
+                    putter.switch(putter)
+            if self.getters and self.qsize():
+                repeat = True
+                getter = self.getters.popleft()
+                getter.switch(getter)
+            if not repeat:
+                return
+
+    def _schedule_unlock(self):
+        if not self._event_unlock:
+            self._event_unlock = self.hub.loop.run_callback(self._unlock)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        result = self.get()
+        if result is StopIteration:
+            raise result
+        return result
+
+    def shutdown(self, immediate=False):
+        """
+        "Shut-down the queue, making queue gets and puts raise
+        `ShutDown`.
+
+        By default, gets will only raise once the queue is empty. Set
+        *immediate* to True to make gets raise immediately instead.
+
+        All blocked callers of `put` and `get` will be unblocked.
+
+        In joinable queues, if *immediate*, a task is marked as done
+        for each item remaining in the queue, which may unblock
+        callers of `join`.
+        """
+        self.is_shutdown = True
+        if immediate:
+            self._drain_for_immediate_shutdown()
+        getters = list(self.getters)
+        putters = list(self.putters)
+        self.getters.clear()
+        self.putters.clear()
+        for waiter in getters + putters:
+            self.hub.loop.run_callback(waiter.throw, ShutDown)
+
+    def _drain_for_immediate_shutdown(self):
+        while self.qsize():
+            self.get()
+
+class UnboundQueue(Queue):
+    # A specialization of Queue that knows it can never
+    # be bound. Changing its maxsize has no effect.
+
+    __slots__ = ()
+
+    def __init__(self, maxsize=None, items=()):
+        if maxsize is not None:
+            raise ValueError("UnboundQueue has no maxsize")
+        Queue.__init__(self, maxsize, items)
+        self.putters = None # Will never be used.
+
+    def put(self, item, block=True, timeout=None):
+        self._put(item)
+        if self.getters:
+            self._schedule_unlock()
+
+
+class PriorityQueue(Queue):
+    '''A subclass of :class:`Queue` that retrieves entries in priority order (lowest first).
+
+    Entries are typically tuples of the form: ``(priority number, data)``.
+
+    .. versionchanged:: 1.2a1
+       Any *items* given to the constructor will now be passed through
+       :func:`heapq.heapify` to ensure the invariants of this class hold.
+       Previously it was just assumed that they were already a heap.
+    '''
+
+    __slots__ = ()
+
+    def _create_queue(self, items=()):
+        q = list(items)
+        _heapify(q)
+        return q
+
+    def _put(self, item):
+        _heappush(self.queue, item)
+
+    def _get(self):
+        return _heappop(self.queue)
+
+
+class JoinableQueue(Queue):
+    """
+    A subclass of :class:`Queue` that additionally has
+    :meth:`task_done` and :meth:`join` methods.
+    """
+
+    __slots__ = (
+        '_cond',
+        'unfinished_tasks',
+    )
+
+    def __init__(self, maxsize=None, items=(), unfinished_tasks=None):
+        """
+
+        .. versionchanged:: 1.1a1
+           If *unfinished_tasks* is not given, then all the given *items*
+           (if any) will be considered unfinished.
+
+        """
+        Queue.__init__(self, maxsize, items, _warn_depth=3)
+
+        from gevent.event import Event
+        self._cond = Event()
+        self._cond.set()
+
+        if unfinished_tasks:
+            self.unfinished_tasks = unfinished_tasks
+        elif items:
+            self.unfinished_tasks = len(items)
+        else:
+            self.unfinished_tasks = 0
+
+        if self.unfinished_tasks:
+            self._cond.clear()
+
+    def copy(self):
+        return type(self)(self.maxsize, self.queue, self.unfinished_tasks)
+
+    def _format(self):
+        result = Queue._format(self)
+        if self.unfinished_tasks:
+            result += ' tasks=%s _cond=%s' % (self.unfinished_tasks, self._cond)
+        return result
+
+    def _put(self, item):
+        Queue._put(self, item)
+        self._did_put_task()
+
+    def _did_put_task(self):
+        self.unfinished_tasks += 1
+        self._cond.clear()
+
+    def task_done(self):
+        '''Indicate that a formerly enqueued task is complete. Used by queue consumer threads.
+        For each :meth:`get <Queue.get>` used to fetch a task, a subsequent call to :meth:`task_done` tells the queue
+        that the processing on the task is complete.
+
+        If a :meth:`join` is currently blocking, it will resume when all items have been processed
+        (meaning that a :meth:`task_done` call was received for every item that had been
+        :meth:`put <Queue.put>` into the queue).
+
+        Raises a :exc:`ValueError` if called more times than there were items placed in the queue.
+        '''
+        if self.unfinished_tasks <= 0:
+            raise ValueError('task_done() called too many times')
+        self.unfinished_tasks -= 1
+        if self.unfinished_tasks == 0:
+            self._cond.set()
+
+    def join(self, timeout=None):
+        '''
+        Block until all items in the queue have been gotten and processed.
+
+        The count of unfinished tasks goes up whenever an item is added to the queue.
+        The count goes down whenever a consumer thread calls :meth:`task_done` to indicate
+        that the item was retrieved and all work on it is complete. When the count of
+        unfinished tasks drops to zero, :meth:`join` unblocks.
+
+        :param float timeout: If not ``None``, then wait no more than this time in seconds
+            for all tasks to finish.
+        :return: ``True`` if all tasks have finished; if ``timeout`` was given and expired before
+            all tasks finished, ``False``.
+
+        .. versionchanged:: 1.1a1
+           Add the *timeout* parameter.
+        '''
+        return self._cond.wait(timeout=timeout)
+
+    def _drain_for_immediate_shutdown(self):
+        while self.qsize():
+            self.get()
+            self.task_done()
+
+
+class LifoQueue(JoinableQueue):
+    """
+    A subclass of :class:`JoinableQueue` that retrieves most recently added entries first.
+
+    .. versionchanged:: 24.10.1
+       Now extends :class:`JoinableQueue` instead of just :class:`Queue`.
+
+    """
+    __slots__ = ()
+
+    def _create_queue(self, items=()):
+        return list(items)
+
+    def _put(self, item):
+        self.queue.append(item)
+        self._did_put_task()
+
+    def _get(self):
+        return self.queue.pop()
+
+    def _peek(self):
+        return self.queue[-1]
+
+
+class Channel(object):
+
+    __slots__ = (
+        'getters',
+        'putters',
+        'hub',
+        '_event_unlock',
+        '__weakref__',
+    )
+
+    def __init__(self, maxsize=1):
+        # We take maxsize to simplify certain kinds of code
+        if maxsize != 1:
+            raise ValueError("Channels have a maxsize of 1")
+        self.getters = collections.deque()
+        self.putters = collections.deque()
+        self.hub = get_hub()
+        self._event_unlock = None
+
+    def __repr__(self):
+        return '<%s at %s %s>' % (type(self).__name__, hex(id(self)), self._format())
+
+    def __str__(self):
+        return '<%s %s>' % (type(self).__name__, self._format())
+
+    def _format(self):
+        result = ''
+        if self.getters:
+            result += ' getters[%s]' % len(self.getters)
+        if self.putters:
+            result += ' putters[%s]' % len(self.putters)
+        return result
+
+    @property
+    def balance(self):
+        return len(self.putters) - len(self.getters)
+
+    def qsize(self):
+        return 0
+
+    def empty(self):
+        return True
+
+    def full(self):
+        return True
+
+    def put(self, item, block=True, timeout=None):
+        if self.hub is getcurrent(): # pylint:disable=undefined-variable
+            if self.getters:
+                getter = self.getters.popleft()
+                getter.switch(item)
+                return
+            raise Full
+
+        if not block:
+            timeout = 0
+
+        waiter = Waiter() # pylint:disable=undefined-variable
+        item = (item, waiter)
+        self.putters.append(item)
+        timeout = Timeout._start_new_or_dummy(timeout, Full)
+        try:
+            if self.getters:
+                self._schedule_unlock()
+            result = waiter.get()
+            if result is not waiter:
+                raise InvalidSwitchError("Invalid switch into Channel.put: %r" % (result, ))
+        except:
+            _safe_remove(self.putters, item)
+            raise
+        finally:
+            timeout.cancel()
+
+    def put_nowait(self, item):
+        self.put(item, False)
+
+    def get(self, block=True, timeout=None):
+        if self.hub is getcurrent(): # pylint:disable=undefined-variable
+            if self.putters:
+                item, putter = self.putters.popleft()
+                self.hub.loop.run_callback(putter.switch, putter)
+                return item
+
+        if not block:
+            timeout = 0
+
+        waiter = Waiter() # pylint:disable=undefined-variable
+        timeout = Timeout._start_new_or_dummy(timeout, Empty)
+        try:
+            self.getters.append(waiter)
+            if self.putters:
+                self._schedule_unlock()
+            return waiter.get()
+        except:
+            self.getters.remove(waiter)
+            raise
+        finally:
+            timeout.close()
+
+    def get_nowait(self):
+        return self.get(False)
+
+    def _unlock(self):
+        while self.putters and self.getters:
+            getter = self.getters.popleft()
+            item, putter = self.putters.popleft()
+            getter.switch(item)
+            putter.switch(putter)
+
+    def _schedule_unlock(self):
+        if not self._event_unlock:
+            self._event_unlock = self.hub.loop.run_callback(self._unlock)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        result = self.get()
+        if result is StopIteration:
+            raise result
+        return result
+
+    next = __next__ # Py2
+
+def _init():
+    greenlet_init() # pylint:disable=undefined-variable
+
+_init()
+
+
+from gevent._util import import_c_accel
+import_c_accel(globals(), 'gevent._queue')

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/resolver/__init__.py

@@ -0,0 +1,285 @@
+# Copyright (c) 2018  gevent contributors. See LICENSE for details.
+
+import _socket
+from _socket import AF_INET
+from _socket import AF_UNSPEC
+from _socket import AI_CANONNAME
+from _socket import AI_PASSIVE
+from _socket import AI_NUMERICHOST
+from _socket import EAI_NONAME
+from _socket import EAI_SERVICE
+from _socket import SOCK_DGRAM
+from _socket import SOCK_STREAM
+from _socket import SOL_TCP
+from _socket import error
+from _socket import gaierror
+from _socket import getaddrinfo as native_getaddrinfo
+from _socket import getnameinfo as native_getnameinfo
+from _socket import gethostbyaddr as native_gethostbyaddr
+from _socket import gethostbyname as native_gethostbyname
+from _socket import gethostbyname_ex as native_gethostbyname_ex
+from _socket import getservbyname as native_getservbyname
+
+
+from gevent._compat import string_types
+from gevent._compat import text_type
+from gevent._compat import hostname_types
+from gevent._compat import integer_types
+from gevent._compat import PYPY
+from gevent._compat import MAC
+
+from gevent.resolver._addresses import is_ipv6_addr
+# Nothing public here.
+__all__ = ()
+
+# trigger import of encodings.idna to avoid https://github.com/gevent/gevent/issues/349
+u'foo'.encode('idna')
+
+
+def _lookup_port(port, socktype):
+    # pylint:disable=too-many-branches
+    socktypes = []
+    if isinstance(port, string_types):
+        try:
+            port = int(port)
+        except ValueError:
+            try:
+                if socktype == 0:
+                    origport = port
+                    try:
+                        port = native_getservbyname(port, 'tcp')
+                        socktypes.append(SOCK_STREAM)
+                    except error:
+                        port = native_getservbyname(port, 'udp')
+                        socktypes.append(SOCK_DGRAM)
+                    else:
+                        try:
+                            if port == native_getservbyname(origport, 'udp'):
+                                socktypes.append(SOCK_DGRAM)
+                        except error:
+                            pass
+                elif socktype == SOCK_STREAM:
+                    port = native_getservbyname(port, 'tcp')
+                elif socktype == SOCK_DGRAM:
+                    port = native_getservbyname(port, 'udp')
+                else:
+                    raise gaierror(EAI_SERVICE, 'Servname not supported for ai_socktype')
+            except error as ex:
+                if 'not found' in str(ex):
+                    raise gaierror(EAI_SERVICE, 'Servname not supported for ai_socktype')
+                raise gaierror(str(ex))
+            except UnicodeEncodeError:
+                raise error('Int or String expected', port)
+    elif port is None:
+        port = 0
+    elif isinstance(port, integer_types):
+        pass
+    else:
+        raise error('Int or String expected', port, type(port))
+    port = int(port % 65536)
+    if not socktypes and socktype:
+        socktypes.append(socktype)
+    return port, socktypes
+
+
+
+def _resolve_special(hostname, family):
+    if not isinstance(hostname, hostname_types):
+        raise TypeError("argument 1 must be str, bytes or bytearray, not %s" % (type(hostname),))
+
+    if hostname in (u'', b''):
+        result = native_getaddrinfo(None, 0, family, SOCK_DGRAM, 0, AI_PASSIVE)
+        if len(result) != 1:
+            raise error('wildcard resolved to multiple address')
+        return result[0][4][0]
+    return hostname
+
+
+class AbstractResolver(object):
+
+    HOSTNAME_ENCODING = 'idna'
+
+    _LOCAL_HOSTNAMES = (
+        b'localhost',
+        b'ip6-localhost',
+        b'::1',
+        b'127.0.0.1',
+    )
+
+    _LOCAL_AND_BROADCAST_HOSTNAMES = _LOCAL_HOSTNAMES + (
+        b'255.255.255.255',
+        b'<broadcast>',
+    )
+
+    EAI_NONAME_MSG = (
+        'nodename nor servname provided, or not known'
+        if MAC else
+        'Name or service not known'
+    )
+
+    EAI_FAMILY_MSG = (
+        'ai_family not supported'
+    )
+
+    _KNOWN_ADDR_FAMILIES = {
+        v
+        for k, v in vars(_socket).items()
+        if k.startswith('AF_')
+    }
+
+    _KNOWN_SOCKTYPES = {
+        v
+        for k, v in vars(_socket).items()
+        if k.startswith('SOCK_')
+        and k not in ('SOCK_CLOEXEC', 'SOCK_MAX_SIZE')
+    }
+
+    def close(self):
+        """
+        Release resources held by this object.
+
+        Subclasses that define resources should override.
+
+        .. versionadded:: 22.10.1
+        """
+
+    @staticmethod
+    def fixup_gaierror(func):
+        import functools
+
+        @functools.wraps(func)
+        def resolve(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except gaierror as ex:
+                if ex.args[0] == EAI_NONAME and len(ex.args) == 1:
+                    # dnspython doesn't set an error message
+                    ex.args = (EAI_NONAME, self.EAI_NONAME_MSG)
+                    ex.errno = EAI_NONAME
+                raise
+        return resolve
+
+    def _hostname_to_bytes(self, hostname):
+        if isinstance(hostname, text_type):
+            hostname = hostname.encode(self.HOSTNAME_ENCODING)
+        elif not isinstance(hostname, (bytes, bytearray)):
+            raise TypeError('Expected str, bytes or bytearray, not %s' % type(hostname).__name__)
+
+        return bytes(hostname)
+
+    def gethostbyname(self, hostname, family=AF_INET):
+        # The native ``gethostbyname`` and ``gethostbyname_ex`` have some different
+        # behaviour with special names. Notably, ``gethostbyname`` will handle
+        # both "<broadcast>" and "255.255.255.255", while ``gethostbyname_ex`` refuses to
+        # handle those; they result in different errors, too. So we can't
+        # pass those through.
+        hostname = self._hostname_to_bytes(hostname)
+        if hostname in self._LOCAL_AND_BROADCAST_HOSTNAMES:
+            return native_gethostbyname(hostname)
+        hostname = _resolve_special(hostname, family)
+        return self.gethostbyname_ex(hostname, family)[-1][0]
+
+    def _gethostbyname_ex(self, hostname_bytes, family):
+        """Raise an ``herror`` or a ``gaierror``."""
+        aliases = self._getaliases(hostname_bytes, family)
+        addresses = []
+        tuples = self.getaddrinfo(hostname_bytes, 0, family,
+                                  SOCK_STREAM,
+                                  SOL_TCP, AI_CANONNAME)
+        canonical = tuples[0][3]
+        for item in tuples:
+            addresses.append(item[4][0])
+        # XXX we just ignore aliases
+        return (canonical, aliases, addresses)
+
+    def gethostbyname_ex(self, hostname, family=AF_INET):
+        hostname = self._hostname_to_bytes(hostname)
+        if hostname in self._LOCAL_AND_BROADCAST_HOSTNAMES:
+            # The broadcast specials aren't handled here, but they may produce
+            # special errors that are hard to replicate across all systems.
+            return native_gethostbyname_ex(hostname)
+        return self._gethostbyname_ex(hostname, family)
+
+    def _getaddrinfo(self, host_bytes, port, family, socktype, proto, flags):
+        raise NotImplementedError
+
+    def getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0):
+        host = self._hostname_to_bytes(host) if host is not None else None
+
+        if (
+                not isinstance(host, bytes)  # 1, 2
+                or (flags & AI_NUMERICHOST) # 3
+                or host in self._LOCAL_HOSTNAMES # 4
+                or (is_ipv6_addr(host) and host.startswith(b'fe80')) # 5
+        ):
+            # This handles cases which do not require network access
+            # 1) host is None
+            # 2) host is of an invalid type
+            # 3) AI_NUMERICHOST flag is set
+            # 4) It's a well-known alias. TODO: This is special casing for c-ares that we don't
+            #    really want to do. It's here because it resolves a discrepancy with the system
+            #    resolvers caught by test cases. In gevent 20.4.0, this only worked correctly on
+            #    Python 3 and not Python 2, by accident.
+            # 5) host is a link-local ipv6; dnspython returns the wrong
+            #    scope-id for those.
+            return native_getaddrinfo(host, port, family, socktype, proto, flags)
+
+        return self._getaddrinfo(host, port, family, socktype, proto, flags)
+
+    def _getaliases(self, hostname, family):
+        # pylint:disable=unused-argument
+        return []
+
+    def _gethostbyaddr(self, ip_address_bytes):
+        """Raises herror."""
+        raise NotImplementedError
+
+    def gethostbyaddr(self, ip_address):
+        ip_address = _resolve_special(ip_address, AF_UNSPEC)
+        ip_address = self._hostname_to_bytes(ip_address)
+        if ip_address in self._LOCAL_AND_BROADCAST_HOSTNAMES:
+            return native_gethostbyaddr(ip_address)
+
+        return self._gethostbyaddr(ip_address)
+
+    def _getnameinfo(self, address_bytes, port, sockaddr, flags):
+        raise NotImplementedError
+
+    def getnameinfo(self, sockaddr, flags):
+        if not isinstance(flags, integer_types):
+            raise TypeError('an integer is required')
+        if not isinstance(sockaddr, tuple):
+            raise TypeError('getnameinfo() argument 1 must be a tuple')
+
+        address = sockaddr[0]
+        address = self._hostname_to_bytes(sockaddr[0])
+
+        if address in self._LOCAL_AND_BROADCAST_HOSTNAMES:
+            return native_getnameinfo(sockaddr, flags)
+
+        port = sockaddr[1]
+        if not isinstance(port, integer_types):
+            raise TypeError('port must be an integer, not %s' % type(port))
+
+        if not PYPY and port >= 65536:
+            # System resolvers do different things with an
+            # out-of-bound port; macOS CPython 3.8 raises ``gaierror: [Errno 8]
+            # nodename nor servname provided, or not known``, while
+            # manylinux CPython 2.7 appears to ignore it and raises ``error:
+            # sockaddr resolved to multiple addresses``. TravisCI, at least ot
+            # one point, successfully resolved www.gevent.org to ``(readthedocs.org, '0')``.
+            # But c-ares 1.16 would raise ``gaierror(25, 'ARES_ESERVICE: unknown')``.
+            # Doing this appears to get the expected results on CPython
+            port = 0
+        if PYPY and (port < 0 or port >= 65536):
+            # PyPy seems to always be strict about that and produce the same results
+            # on all platforms.
+            raise OverflowError("port must be 0-65535.")
+
+        if len(sockaddr) > 2:
+            # Must be IPv6: (host, port, [flowinfo, [scopeid]])
+            flowinfo = sockaddr[2]
+            if flowinfo > 0xfffff:
+                raise OverflowError("getnameinfo(): flowinfo must be 0-1048575.")
+
+        return self._getnameinfo(address, port, sockaddr, flags)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/resolver/_addresses.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2019  gevent contributors. See LICENSE for details.
+#
+# Portions of this code taken from dnspython
+#   https://github.com/rthalley/dnspython
+#
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-2017 Nominum, Inc.
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose with or without fee is hereby granted,
+# provided that the above copyright notice and this permission notice
+# appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+"""
+Private support for parsing textual addresses.
+
+"""
+from __future__ import absolute_import, division, print_function
+
+import binascii
+import re
+import struct
+
+from gevent.resolver import hostname_types
+
+
+class AddressSyntaxError(ValueError):
+    pass
+
+
+def _ipv4_inet_aton(text):
+    """
+    Convert an IPv4 address in text form to binary struct.
+
+    *text*, a ``text``, the IPv4 address in textual form.
+
+    Returns a ``binary``.
+    """
+
+    if not isinstance(text, bytes):
+        text = text.encode()
+    parts = text.split(b'.')
+    if len(parts) != 4:
+        raise AddressSyntaxError(text)
+    for part in parts:
+        if not part.isdigit():
+            raise AddressSyntaxError
+        if len(part) > 1 and part[0] == '0':
+            # No leading zeros
+            raise AddressSyntaxError(text)
+    try:
+        ints = [int(part) for part in parts]
+        return struct.pack('BBBB', *ints)
+    except:
+        raise AddressSyntaxError(text)
+
+
+def _ipv6_inet_aton(text,
+                    _v4_ending=re.compile(br'(.*):(\d+\.\d+\.\d+\.\d+)$'),
+                    _colon_colon_start=re.compile(br'::.*'),
+                    _colon_colon_end=re.compile(br'.*::$')):
+    """
+    Convert an IPv6 address in text form to binary form.
+
+    *text*, a ``text``, the IPv6 address in textual form.
+
+    Returns a ``binary``.
+    """
+    # pylint:disable=too-many-branches
+
+    #
+    # Our aim here is not something fast; we just want something that works.
+    #
+    if not isinstance(text, bytes):
+        text = text.encode()
+
+    if text == b'::':
+        text = b'0::'
+    #
+    # Get rid of the icky dot-quad syntax if we have it.
+    #
+    m = _v4_ending.match(text)
+    if not m is None:
+        b = bytearray(_ipv4_inet_aton(m.group(2)))
+        text = (u"{}:{:02x}{:02x}:{:02x}{:02x}".format(m.group(1).decode(),
+                                                       b[0], b[1], b[2],
+                                                       b[3])).encode()
+    #
+    # Try to turn '::<whatever>' into ':<whatever>'; if no match try to
+    # turn '<whatever>::' into '<whatever>:'
+    #
+    m = _colon_colon_start.match(text)
+    if not m is None:
+        text = text[1:]
+    else:
+        m = _colon_colon_end.match(text)
+        if not m is None:
+            text = text[:-1]
+    #
+    # Now canonicalize into 8 chunks of 4 hex digits each
+    #
+    chunks = text.split(b':')
+    l = len(chunks)
+    if l > 8:
+        raise SyntaxError
+    seen_empty = False
+    canonical = []
+    for c in chunks:
+        if c == b'':
+            if seen_empty:
+                raise AddressSyntaxError(text)
+            seen_empty = True
+            for _ in range(0, 8 - l + 1):
+                canonical.append(b'0000')
+        else:
+            lc = len(c)
+            if lc > 4:
+                raise AddressSyntaxError(text)
+            if lc != 4:
+                c = (b'0' * (4 - lc)) + c
+            canonical.append(c)
+    if l < 8 and not seen_empty:
+        raise AddressSyntaxError(text)
+    text = b''.join(canonical)
+
+    #
+    # Finally we can go to binary.
+    #
+    try:
+        return binascii.unhexlify(text)
+    except (binascii.Error, TypeError):
+        raise AddressSyntaxError(text)
+
+
+def _is_addr(host, parse=_ipv4_inet_aton):
+    if not host or not isinstance(host, hostname_types):
+        return False
+
+    try:
+        parse(host)
+    except AddressSyntaxError:
+        return False
+    return True
+
+# Return True if host is a valid IPv4 address
+is_ipv4_addr = _is_addr
+
+
+def is_ipv6_addr(host):
+    # Return True if host is a valid IPv6 address
+    if host and isinstance(host, hostname_types):
+        s = '%' if isinstance(host, str) else b'%'
+        host = host.split(s, 1)[0]
+    return _is_addr(host, _ipv6_inet_aton)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/resolver/_hostsfile.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2019  gevent contributors. See LICENSE for details.
+#
+# Portions of this code taken from dnspython
+#   https://github.com/rthalley/dnspython
+#
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-2017 Nominum, Inc.
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose with or without fee is hereby granted,
+# provided that the above copyright notice and this permission notice
+# appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+"""
+Private support for parsing /etc/hosts.
+
+"""
+from __future__ import absolute_import, division, print_function
+
+import sys
+import os
+import re
+
+from gevent.resolver._addresses import is_ipv4_addr
+from gevent.resolver._addresses import is_ipv6_addr
+
+from gevent._compat import iteritems
+
+
+class HostsFile(object):
+    """
+    A class to read the contents of a hosts file (/etc/hosts).
+    """
+
+    LINES_RE = re.compile(r"""
+        \s*  # Leading space
+        ([^\r\n#]+?)  # The actual match, non-greedy so as not to include trailing space
+        \s*  # Trailing space
+        (?:[#][^\r\n]+)?  # Comments
+        (?:$|[\r\n]+)  # EOF or newline
+    """, re.VERBOSE)
+
+    def __init__(self, fname=None):
+        self.v4 = {} # name -> ipv4
+        self.v6 = {} # name -> ipv6
+        self.aliases = {} # name -> canonical_name
+        self.reverse = {} # ip addr -> some name
+        if fname is None:
+            if os.name == 'posix':
+                fname = '/etc/hosts'
+            elif os.name == 'nt': # pragma: no cover
+                fname = os.path.expandvars(
+                    r'%SystemRoot%\system32\drivers\etc\hosts')
+        self.fname = fname
+        assert self.fname
+        self._last_load = 0
+
+
+    def _readlines(self):
+        # Read the contents of the hosts file.
+        #
+        # Return list of lines, comment lines and empty lines are
+        # excluded. Note that this performs disk I/O so can be
+        # blocking.
+        with open(self.fname, 'rb') as fp:
+            fdata = fp.read()
+
+
+        # XXX: Using default decoding. Is that correct?
+        udata = fdata.decode(errors='ignore') if not isinstance(fdata, str) else fdata
+
+        return self.LINES_RE.findall(udata)
+
+    def load(self): # pylint:disable=too-many-locals
+        # Load hosts file
+
+        # This will (re)load the data from the hosts
+        # file if it has changed.
+
+        try:
+            load_time = os.stat(self.fname).st_mtime
+            needs_load = load_time > self._last_load
+        except OSError:
+            from gevent import get_hub
+            get_hub().handle_error(self, *sys.exc_info())
+            needs_load = False
+
+        if not needs_load:
+            return
+
+        v4 = {}
+        v6 = {}
+        aliases = {}
+        reverse = {}
+
+        for line in self._readlines():
+            parts = line.split()
+            if len(parts) < 2:
+                continue
+            ip = parts.pop(0)
+            if is_ipv4_addr(ip):
+                ipmap = v4
+            elif is_ipv6_addr(ip):
+                if ip.startswith('fe80'):
+                    # Do not use link-local addresses, OSX stores these here
+                    continue
+                ipmap = v6
+            else:
+                continue
+            cname = parts.pop(0).lower()
+            ipmap[cname] = ip
+            for alias in parts:
+                alias = alias.lower()
+                ipmap[alias] = ip
+                aliases[alias] = cname
+
+            # XXX: This is wrong for ipv6
+            if ipmap is v4:
+                ptr = '.'.join(reversed(ip.split('.'))) + '.in-addr.arpa'
+            else:
+                ptr = ip + '.ip6.arpa.'
+            if ptr not in reverse:
+                reverse[ptr] = cname
+
+        self._last_load = load_time
+        self.v4 = v4
+        self.v6 = v6
+        self.aliases = aliases
+        self.reverse = reverse
+
+    def iter_all_host_addr_pairs(self):
+        self.load()
+        for name, addr in iteritems(self.v4):
+            yield name, addr
+        for name, addr in iteritems(self.v6):
+            yield name, addr

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/resolver/ares.py

@@ -0,0 +1,355 @@
+# Copyright (c) 2011-2015 Denis Bilenko. See LICENSE for details.
+"""
+c-ares based hostname resolver.
+"""
+from __future__ import absolute_import, print_function, division
+import os
+import warnings
+
+from _socket import gaierror
+from _socket import herror
+from _socket import error
+from _socket import EAI_NONAME
+
+from gevent._compat import text_type
+from gevent._compat import integer_types
+
+from gevent.hub import Waiter
+from gevent.hub import get_hub
+
+from gevent.socket import AF_UNSPEC
+from gevent.socket import AF_INET
+from gevent.socket import AF_INET6
+from gevent.socket import SOCK_DGRAM
+from gevent.socket import SOCK_STREAM
+from gevent.socket import SOL_TCP
+from gevent.socket import SOL_UDP
+
+
+from gevent._config import config
+from gevent._config import AresSettingMixin
+
+from .cares import channel, InvalidIP # pylint:disable=import-error,no-name-in-module
+from . import _lookup_port as lookup_port
+from . import AbstractResolver
+
+__all__ = ['Resolver']
+
+
+class Resolver(AbstractResolver):
+    """
+    Implementation of the resolver API using the `c-ares`_ library.
+
+    This implementation uses the c-ares library to handle name
+    resolution. c-ares is natively asynchronous at the socket level
+    and so integrates well into gevent's event loop.
+
+    In comparison to :class:`gevent.resolver_thread.Resolver` (which
+    delegates to the native system resolver), the implementation is
+    much more complex. In addition, there have been reports of it not
+    properly honoring certain system configurations (for example, the
+    order in which IPv4 and IPv6 results are returned may not match
+    the threaded resolver). However, because it does not use threads,
+    it may scale better for applications that make many lookups.
+
+    There are some known differences from the system resolver.
+
+    - ``gethostbyname_ex`` and ``gethostbyaddr`` may return
+      different for the ``aliaslist`` tuple member. (Sometimes the
+      same, sometimes in a different order, sometimes a different
+      alias altogether.)
+
+    - ``gethostbyname_ex`` may return the ``ipaddrlist`` in a
+      different order.
+
+    - ``getaddrinfo`` does not return ``SOCK_RAW`` results.
+
+    - ``getaddrinfo`` may return results in a different order.
+
+    - Handling of ``.local`` (mDNS) names may be different, even
+      if they are listed in the hosts file.
+
+    - c-ares will not resolve ``broadcasthost``, even if listed in
+      the hosts file prior to 2020-04-30.
+
+    - This implementation may raise ``gaierror(4)`` where the
+      system implementation would raise ``herror(1)`` or vice versa,
+      with different error numbers. However, after 2020-04-30, this should be
+      much reduced.
+
+    - The results for ``localhost`` may be different. In
+      particular, some system resolvers will return more results
+      from ``getaddrinfo`` than c-ares does, such as SOCK_DGRAM
+      results, and c-ares may report more ips on a multi-homed
+      host.
+
+    - The system implementation may return some names fully qualified, where
+      this implementation returns only the host name. This appears to be
+      the case only with entries found in ``/etc/hosts``.
+
+    - c-ares supports a limited set of flags for ``getnameinfo`` and
+      ``getaddrinfo``; unknown flags are ignored. System-specific flags
+      such as ``AI_V4MAPPED_CFG`` are not supported.
+
+    - ``getaddrinfo`` may return canonical names even without the ``AI_CANONNAME``
+      being set.
+
+    - ``getaddrinfo`` does not appear to support IPv6 symbolic scope IDs.
+
+    .. caution::
+
+        This module is considered extremely experimental on PyPy, and
+        due to its implementation in cython, it may be slower. It may also lead to
+        interpreter crashes.
+
+    .. versionchanged:: 1.5.0
+       This version of gevent typically embeds c-ares 1.15.0 or newer. In
+       that version of c-ares, domains ending in ``.onion`` `are never
+       resolved <https://github.com/c-ares/c-ares/issues/196>`_ or even
+       sent to the DNS server.
+
+    .. versionchanged:: 20.5.0
+       ``getaddrinfo`` is now implemented using the native c-ares function
+       from c-ares 1.16 or newer.
+
+    .. versionchanged:: 20.5.0
+       Now ``herror`` and ``gaierror`` are raised more consistently with
+       the standard library resolver, and have more consistent errno values.
+
+       Handling of localhost and broadcast names is now more consistent.
+
+    .. versionchanged:: 22.10.1
+       Now has a ``__del__`` method that warns if the object is destroyed
+       without being properly closed.
+
+    .. _c-ares: http://c-ares.haxx.se
+    """
+
+    cares_class = channel
+
+    def __init__(self, hub=None, use_environ=True, **kwargs):
+        AbstractResolver.__init__(self)
+        if hub is None:
+            hub = get_hub()
+        self.hub = hub
+        if use_environ:
+            for setting in config.settings.values():
+                if isinstance(setting, AresSettingMixin):
+                    value = setting.get()
+                    if value is not None:
+                        kwargs.setdefault(setting.kwarg_name, value)
+        self.cares = self.cares_class(hub.loop, **kwargs)
+        self.pid = os.getpid()
+        self.params = kwargs
+        self.fork_watcher = hub.loop.fork(ref=False) # We shouldn't keep the loop alive
+        self.fork_watcher.start(self._on_fork)
+
+    def __repr__(self):
+        return '<gevent.resolver_ares.Resolver at 0x%x ares=%r>' % (id(self), self.cares)
+
+    def _on_fork(self):
+        # NOTE: See comment in gevent.hub.reinit.
+        pid = os.getpid()
+        if pid != self.pid:
+            self.hub.loop.run_callback(self.cares.destroy)
+            self.cares = self.cares_class(self.hub.loop, **self.params)
+            self.pid = pid
+
+    def close(self):
+        AbstractResolver.close(self)
+        if self.cares is not None:
+            self.hub.loop.run_callback(self.cares.destroy)
+            self.cares = None
+        self.fork_watcher.stop()
+
+    def __del__(self):
+        if self.cares is not None:
+            warnings.warn("cares Resolver destroyed while not closed",
+                          ResourceWarning)
+            self.close()
+
+    def _gethostbyname_ex(self, hostname_bytes, family):
+        while True:
+            ares = self.cares
+            try:
+                waiter = Waiter(self.hub)
+                ares.gethostbyname(waiter, hostname_bytes, family)
+                result = waiter.get()
+                if not result[-1]:
+                    raise herror(EAI_NONAME, self.EAI_NONAME_MSG)
+                return result
+            except herror as ex:
+                if ares is self.cares:
+                    if ex.args[0] == 1:
+                        # Somewhere along the line, the internal
+                        # implementation of gethostbyname_ex changed to invoke
+                        # getaddrinfo() as a first pass, much like we do for ``getnameinfo()``;
+                        # this means it raises a different error for not-found hosts.
+                        raise gaierror(EAI_NONAME, self.EAI_NONAME_MSG)
+                    raise
+                # "self.cares is not ares" means channel was destroyed (because we were forked)
+
+    def _lookup_port(self, port, socktype):
+        return lookup_port(port, socktype)
+
+    def __getaddrinfo(
+            self, host, port,
+            family=0, socktype=0, proto=0, flags=0,
+            fill_in_type_proto=True
+    ):
+        """
+        Returns a list ``(family, socktype, proto, canonname, sockaddr)``
+
+        :raises gaierror: If no results are found.
+        """
+        # pylint:disable=too-many-locals,too-many-branches
+        if isinstance(host, text_type):
+            host = host.encode('idna')
+
+
+        if isinstance(port, text_type):
+            port = port.encode('ascii')
+        elif isinstance(port, integer_types):
+            if port == 0:
+                port = None
+            else:
+                port = str(port).encode('ascii')
+
+        waiter = Waiter(self.hub)
+        self.cares.getaddrinfo(
+            waiter,
+            host,
+            port,
+            family,
+            socktype,
+            proto,
+            flags,
+        )
+        # Result is a list of:
+        # (family, socktype, proto, canonname, sockaddr)
+        # Where sockaddr depends on family; for INET it is
+        # (address, port)
+        # and INET6 is
+        # (address, port, flow info, scope id)
+        result = waiter.get()
+
+        if not result:
+            raise gaierror(EAI_NONAME, self.EAI_NONAME_MSG)
+
+        if fill_in_type_proto:
+            # c-ares 1.16 DOES NOT fill in socktype or proto in the results,
+            # ever. It's at least supposed to do that if they were given as
+            # hints, but it doesn't (https://github.com/c-ares/c-ares/issues/317)
+            # Sigh.
+            # The SOL_* constants are another (older?) name for IPPROTO_*
+            if socktype:
+                hard_type_proto = [
+                    (socktype, SOL_TCP if socktype == SOCK_STREAM else SOL_UDP),
+                ]
+            elif proto:
+                hard_type_proto = [
+                    (SOCK_STREAM if proto == SOL_TCP else SOCK_DGRAM, proto),
+                ]
+            else:
+                hard_type_proto = [
+                    (SOCK_STREAM, SOL_TCP),
+                    (SOCK_DGRAM, SOL_UDP),
+                ]
+
+            # pylint:disable=not-an-iterable,unsubscriptable-object
+            result = [
+                (rfamily,
+                 hard_type if not rtype else rtype,
+                 hard_proto if not rproto else rproto,
+                 rcanon,
+                 raddr)
+                for rfamily, rtype, rproto, rcanon, raddr
+                in result
+                for hard_type, hard_proto
+                in hard_type_proto
+            ]
+        return result
+
+    def _getaddrinfo(self, host_bytes, port, family, socktype, proto, flags):
+        while True:
+            ares = self.cares
+            try:
+                return self.__getaddrinfo(host_bytes, port, family, socktype, proto, flags)
+            except gaierror:
+                if ares is self.cares:
+                    raise
+
+    def __gethostbyaddr(self, ip_address):
+        waiter = Waiter(self.hub)
+        try:
+            self.cares.gethostbyaddr(waiter, ip_address)
+            return waiter.get()
+        except InvalidIP:
+            result = self._getaddrinfo(ip_address, None,
+                                       family=AF_UNSPEC, socktype=SOCK_DGRAM,
+                                       proto=0, flags=0)
+            if not result:
+                raise
+            # pylint:disable=unsubscriptable-object
+            _ip_address = result[0][-1][0]
+            if isinstance(_ip_address, text_type):
+                _ip_address = _ip_address.encode('ascii')
+            if _ip_address == ip_address:
+                raise
+            waiter.clear()
+            self.cares.gethostbyaddr(waiter, _ip_address)
+            return waiter.get()
+
+    def _gethostbyaddr(self, ip_address_bytes):
+        while True:
+            ares = self.cares
+            try:
+                return self.__gethostbyaddr(ip_address_bytes)
+            except herror:
+                if ares is self.cares:
+                    raise
+
+    def __getnameinfo(self, hostname, port, sockaddr, flags):
+        result = self.__getaddrinfo(
+            hostname, port,
+            family=AF_UNSPEC, socktype=SOCK_DGRAM,
+            proto=0, flags=0,
+            fill_in_type_proto=False)
+        if len(result) != 1:
+            raise error('sockaddr resolved to multiple addresses')
+
+        family, _socktype, _proto, _name, address = result[0]
+
+        if family == AF_INET:
+            if len(sockaddr) != 2:
+                raise error("IPv4 sockaddr must be 2 tuple")
+        elif family == AF_INET6:
+            address = address[:2] + sockaddr[2:]
+
+        waiter = Waiter(self.hub)
+        self.cares.getnameinfo(waiter, address, flags)
+        node, service = waiter.get()
+
+        if service is None:
+            # ares docs: "If the query did not complete
+            # successfully, or one of the values was not
+            # requested, node or service will be NULL ". Python 2
+            # allows that for the service, but Python 3 raises
+            # an error. This is tested by test_socket in py 3.4
+            err = gaierror(EAI_NONAME, self.EAI_NONAME_MSG)
+            err.errno = EAI_NONAME
+            raise err
+
+        return node, service or '0'
+
+    def _getnameinfo(self, address_bytes, port, sockaddr, flags):
+        while True:
+            ares = self.cares
+            try:
+                return self.__getnameinfo(address_bytes, port, sockaddr, flags)
+            except gaierror:
+                if ares is self.cares:
+                    raise
+
+    # # Things that need proper error handling
+    # gethostbyaddr = AbstractResolver.convert_gaierror_to_herror(AbstractResolver.gethostbyaddr)

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/resolver/blocking.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2018  gevent contributors. See LICENSE for details.
+
+import _socket
+
+__all__ = [
+    'Resolver',
+]
+
+class Resolver(object):
+    """
+    A resolver that directly uses the system's resolver functions.
+
+    .. caution::
+
+        This resolver is *not* cooperative.
+
+    This resolver has the lowest overhead of any resolver and
+    typically approaches the speed of the unmodified :mod:`socket`
+    functions. However, it is not cooperative, so if name resolution
+    blocks, the entire thread and all its greenlets will be blocked.
+
+    This can be useful during debugging, or it may be a good choice if
+    your operating system provides a good caching resolver (such as
+    macOS's Directory Services) that is usually very fast and
+    functionally non-blocking.
+
+    .. versionchanged:: 1.3a2
+       This was previously undocumented and existed in :mod:`gevent.socket`.
+
+    """
+
+    def __init__(self, hub=None):
+        pass
+
+    def close(self):
+        pass
+
+    for method in (
+            'gethostbyname',
+            'gethostbyname_ex',
+            'getaddrinfo',
+            'gethostbyaddr',
+            'getnameinfo'
+    ):
+        locals()[method] = staticmethod(getattr(_socket, method))

miniconda3/envs/ladir/lib/python3.10/site-packages/gevent/resolver/dnspython.py

@@ -0,0 +1,511 @@
+# Copyright (c) 2018  gevent contributors. See LICENSE for details.
+
+# Portions of this code taken from the gogreen project:
+#   http://github.com/slideinc/gogreen
+#
+# Copyright (c) 2005-2010 Slide, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#     * Neither the name of the author nor the names of other
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Portions of this code taken from the eventlet project:
+# https://github.com/eventlet/eventlet/blob/master/eventlet/support/greendns.py
+
+# Unless otherwise noted, the files in Eventlet are under the following MIT license:
+
+# Copyright (c) 2005-2006, Bob Ippolito
+# Copyright (c) 2007-2010, Linden Research, Inc.
+# Copyright (c) 2008-2010, Eventlet Contributors (see AUTHORS)
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+from __future__ import absolute_import, print_function, division
+
+import sys
+import time
+
+from _socket import error
+from _socket import gaierror
+from _socket import herror
+from _socket import NI_NUMERICSERV
+from _socket import AF_INET
+from _socket import AF_INET6
+from _socket import AF_UNSPEC
+from _socket import EAI_NONAME
+from _socket import EAI_FAMILY
+
+
+import socket
+
+from gevent.resolver import AbstractResolver
+from gevent.resolver._hostsfile import HostsFile
+
+from gevent.builtins import __import__ as g_import
+
+from gevent._compat import string_types
+from gevent._compat import iteritems
+from gevent._config import config
+
+
+__all__ = [
+    'Resolver',
+]
+
+# Import the DNS packages to use the gevent modules,
+# even if the system is not monkey-patched. If it *is* already
+# patched, this imports a second copy under a different name,
+# which is probably not strictly necessary, but matches
+# what we've historically done, and allows configuring the resolvers
+# differently.
+
+def _patch_dns():
+    from gevent._patcher import import_patched as importer
+    # The dns package itself is empty but defines __all__
+    # we make sure to import all of those things now under the
+    # patch. Note this triggers two DeprecationWarnings,
+    # one of which we could avoid.
+    extras = {
+        'dns': ('rdata', 'resolver', 'rdtypes'),
+        'dns.rdtypes': ('IN', 'ANY', ),
+        'dns.rdtypes.IN': ('A', 'AAAA',),
+        'dns.rdtypes.ANY': ('SOA', 'PTR'),
+    }
+    def extra_all(mod_name):
+        return extras.get(mod_name, ())
+
+    def after_import_hook(dns): # pylint:disable=redefined-outer-name
+        # Runs while still in the original patching scope.
+        # The dns.rdata:get_rdata_class() function tries to
+        # dynamically import modules using __import__ and then walk
+        # through the attribute tree to find classes in `dns.rdtypes`.
+        # It is critical that this all matches up, otherwise we can
+        # get different exception classes that don't get caught.
+        # We could patch __import__ to do things at runtime, but it's
+        # easier to enumerate the world and populate the cache now
+        # before we then switch the names back.
+        rdata = dns.rdata
+        get_rdata_class = rdata.get_rdata_class
+        try:
+            rdclass_values = list(dns.rdataclass.RdataClass)
+        except AttributeError:
+            # dnspython < 2.0
+            rdclass_values = dns.rdataclass._by_value
+
+        try:
+            rdtype_values = list(dns.rdatatype.RdataType)
+        except AttributeError:
+            # dnspython < 2.0
+            rdtype_values = dns.rdatatype._by_value
+
+
+        for rdclass in rdclass_values:
+            for rdtype in rdtype_values:
+                get_rdata_class(rdclass, rdtype)
+
+    patcher = importer('dns', extra_all, after_import_hook)
+    top = patcher.module
+
+    # Now disable the dynamic imports
+    def _no_dynamic_imports(name):
+        raise ValueError(name)
+
+    top.rdata.__import__ = _no_dynamic_imports
+
+    return top
+
+dns = _patch_dns()
+
+resolver = dns.resolver
+dTimeout = dns.resolver.Timeout
+
+# This is a wrapper for dns.resolver._getaddrinfo with two crucial changes.
+# First, it backports https://github.com/rthalley/dnspython/issues/316
+# from version 2.0. This can be dropped when we support only dnspython 2
+# (which means only Python 3.)
+
+# Second, it adds calls to sys.exc_clear() to avoid failing tests in
+# test__refcount.py (timeouts) on Python 2. (Actually, this isn't
+# strictly necessary, it was necessary to increase the timeouts in
+# that function because dnspython is doing some parsing/regex/host
+# lookups that are not super fast. But it does have a habit of leaving
+# exceptions around which can complicate our memleak checks.)
+def _getaddrinfo(host=None, service=None, family=AF_UNSPEC, socktype=0,
+                 proto=0, flags=0,
+                 _orig_gai=resolver._getaddrinfo,
+                 _exc_clear=getattr(sys, 'exc_clear', lambda: None)):
+    if flags & (socket.AI_ADDRCONFIG | socket.AI_V4MAPPED) != 0:
+        # Not implemented.  We raise a gaierror as opposed to a
+        # NotImplementedError as it helps callers handle errors more
+        # appropriately.  [Issue #316]
+        raise socket.gaierror(socket.EAI_SYSTEM)
+    res = _orig_gai(host, service, family, socktype, proto, flags)
+    _exc_clear()
+    return res
+
+
+resolver._getaddrinfo = _getaddrinfo
+
+HOSTS_TTL = 300.0
+
+
+class _HostsAnswer(dns.resolver.Answer):
+    # Answer class for HostsResolver object
+
+    def __init__(self, qname, rdtype, rdclass, rrset, raise_on_no_answer=True):
+        self.response = None
+        self.qname = qname
+        self.rdtype = rdtype
+        self.rdclass = rdclass
+        self.canonical_name = qname
+        if not rrset and raise_on_no_answer:
+            raise dns.resolver.NoAnswer()
+        self.rrset = rrset
+        self.expiration = (time.time() +
+                           rrset.ttl if hasattr(rrset, 'ttl') else 0)
+
+
+class _HostsResolver(object):
+    """
+    Class to parse the hosts file
+    """
+
+    def __init__(self, fname=None, interval=HOSTS_TTL):
+        self.hosts_file = HostsFile(fname)
+        self.interval = interval
+        self._last_load = 0
+
+    def query(self, qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN,
+              tcp=False, source=None, raise_on_no_answer=True): # pylint:disable=unused-argument
+        # Query the hosts file
+        #
+        # The known rdtypes are dns.rdatatype.A, dns.rdatatype.AAAA and
+        # dns.rdatatype.CNAME.
+        # The ``rdclass`` parameter must be dns.rdataclass.IN while the
+        # ``tcp`` and ``source`` parameters are ignored.
+        # Return a HostAnswer instance or raise a dns.resolver.NoAnswer
+        # exception.
+
+        now = time.time()
+        hosts_file = self.hosts_file
+        if self._last_load + self.interval < now:
+            self._last_load = now
+            hosts_file.load()
+
+        rdclass = dns.rdataclass.IN # Always
+        if isinstance(qname, string_types):
+            name = qname
+            qname = dns.name.from_text(qname)
+        else:
+            name = str(qname)
+
+        name = name.lower()
+        rrset = dns.rrset.RRset(qname, rdclass, rdtype)
+        rrset.ttl = self._last_load + self.interval - now
+
+        mapping = None
+        kind = None
+        if rdtype == dns.rdatatype.A:
+            mapping = hosts_file.v4
+            kind = dns.rdtypes.IN.A.A
+        elif rdtype == dns.rdatatype.AAAA:
+            mapping = hosts_file.v6
+            kind = dns.rdtypes.IN.AAAA.AAAA
+        elif rdtype == dns.rdatatype.CNAME:
+            mapping = hosts_file.aliases
+            kind = lambda c, t, addr: dns.rdtypes.ANY.CNAME.CNAME(c, t, dns.name.from_text(addr))
+        elif rdtype == dns.rdatatype.PTR:
+            mapping = hosts_file.reverse
+            kind = lambda c, t, addr: dns.rdtypes.ANY.PTR.PTR(c, t, dns.name.from_text(addr))
+
+
+        addr = mapping.get(name)
+        if not addr and qname.is_absolute():
+            addr = mapping.get(name[:-1])
+        if addr:
+            rrset.add(kind(rdclass, rdtype, addr))
+        return _HostsAnswer(qname, rdtype, rdclass, rrset, raise_on_no_answer)
+
+    def getaliases(self, hostname):
+        # Return a list of all the aliases of a given cname
+
+        # Due to the way store aliases this is a bit inefficient, this
+        # clearly was an afterthought.  But this is only used by
+        # gethostbyname_ex so it's probably fine.
+        aliases = self.hosts_file.aliases
+        result = []
+        if hostname in aliases: # pylint:disable=consider-using-get
+            cannon = aliases[hostname]
+        else:
+            cannon = hostname
+        result.append(cannon)
+        for alias, cname in iteritems(aliases):
+            if cannon == cname:
+                result.append(alias)
+        result.remove(hostname)
+        return result
+
+class _DualResolver(object):
+
+    def __init__(self):
+        self.hosts_resolver = _HostsResolver()
+        self.network_resolver = resolver.get_default_resolver()
+        self.network_resolver.cache = resolver.LRUCache()
+
+    def query(self, qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN,
+              tcp=False, source=None, raise_on_no_answer=True,
+              _hosts_rdtypes=(dns.rdatatype.A, dns.rdatatype.AAAA, dns.rdatatype.PTR)):
+        # Query the resolver, using /etc/hosts
+
+        # Behavior:
+        # 1. if hosts is enabled and contains answer, return it now
+        # 2. query nameservers for qname
+        if qname is None:
+            qname = '0.0.0.0'
+
+        if not isinstance(qname, string_types):
+            if isinstance(qname, bytes):
+                qname = qname.decode("idna")
+
+        if isinstance(qname, string_types):
+            qname = dns.name.from_text(qname, None)
+
+        if isinstance(rdtype, string_types):
+            rdtype = dns.rdatatype.from_text(rdtype)
+
+        if rdclass == dns.rdataclass.IN and rdtype in _hosts_rdtypes:
+            try:
+                answer = self.hosts_resolver.query(qname, rdtype, raise_on_no_answer=False)
+            except Exception: # pylint: disable=broad-except
+                from gevent import get_hub
+                get_hub().handle_error(self, *sys.exc_info())
+            else:
+                if answer.rrset:
+                    return answer
+
+        return self.network_resolver.query(qname, rdtype, rdclass,
+                                           tcp, source, raise_on_no_answer=raise_on_no_answer)
+
+def _family_to_rdtype(family):
+    if family == socket.AF_INET:
+        rdtype = dns.rdatatype.A
+    elif family == socket.AF_INET6:
+        rdtype = dns.rdatatype.AAAA
+    else:
+        raise socket.gaierror(socket.EAI_FAMILY,
+                              'Address family not supported')
+    return rdtype
+
+
+class Resolver(AbstractResolver):
+    """
+    An *experimental* resolver that uses `dnspython`_.
+
+    This is typically slower than the default threaded resolver
+    (unless there's a cache hit, in which case it can be much faster).
+    It is usually much faster than the c-ares resolver. It tends to
+    scale well as more concurrent resolutions are attempted.
+
+    Under Python 2, if the ``idna`` package is installed, this
+    resolver can resolve Unicode host names that the system resolver
+    cannot.
+
+    .. note::
+
+        This **does not** use dnspython's default resolver object, or share any
+        classes with ``import dns``. A separate copy of the objects is imported to
+        be able to function in a non monkey-patched process. The documentation for the resolver
+        object still applies.
+
+        The resolver that we use is available as the :attr:`resolver` attribute
+        of this object (typically ``gevent.get_hub().resolver.resolver``).
+
+    .. caution::
+
+        Many of the same caveats about DNS results apply here as are documented
+        for :class:`gevent.resolver.ares.Resolver`. In addition, the handling of
+        symbolic scope IDs in IPv6 addresses passed to ``getaddrinfo`` exhibits
+        some differences.
+
+        On PyPy, ``getnameinfo`` can produce results when CPython raises
+        ``socket.error``, and gevent's DNSPython resolver also
+        raises ``socket.error``.
+
+    .. caution::
+
+        This resolver is experimental. It may be removed or modified in
+        the future. As always, feedback is welcome.
+
+    .. versionadded:: 1.3a2
+
+    .. versionchanged:: 20.5.0
+       The errors raised are now much more consistent with those
+       raised by the standard library resolvers.
+
+       Handling of localhost and broadcast names is now more consistent.
+
+    .. _dnspython: http://www.dnspython.org
+    """
+
+    def __init__(self, hub=None): # pylint: disable=unused-argument
+        if resolver._resolver is None:
+            _resolver = resolver._resolver = _DualResolver()
+            if config.resolver_nameservers:
+                _resolver.network_resolver.nameservers[:] = config.resolver_nameservers
+            if config.resolver_timeout:
+                _resolver.network_resolver.lifetime = config.resolver_timeout
+        # Different hubs in different threads could be sharing the same
+        # resolver.
+        assert isinstance(resolver._resolver, _DualResolver)
+        self._resolver = resolver._resolver
+
+    @property
+    def resolver(self):
+        """
+        The dnspython resolver object we use.
+
+        This object has several useful attributes that can be used to
+        adjust the behaviour of the DNS system:
+
+        * ``cache`` is a :class:`dns.resolver.LRUCache`. Its maximum size
+          can be configured by calling :meth:`resolver.cache.set_max_size`
+        * ``nameservers`` controls which nameservers to talk to
+        * ``lifetime`` configures a timeout for each individual query.
+        """
+        return self._resolver.network_resolver
+
+    def close(self):
+        pass
+
+    def _getaliases(self, hostname, family):
+        if not isinstance(hostname, str):
+            if isinstance(hostname, bytes):
+                hostname = hostname.decode("idna")
+        aliases = self._resolver.hosts_resolver.getaliases(hostname)
+        net_resolver = self._resolver.network_resolver
+        rdtype = _family_to_rdtype(family)
+        while 1:
+            try:
+                ans = net_resolver.query(hostname, dns.rdatatype.CNAME, rdtype)
+            except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN, dns.resolver.NoNameservers):
+                break
+            except dTimeout:
+                break
+            except AttributeError as ex:
+                if hostname is None or isinstance(hostname, int):
+                    raise TypeError(ex)
+                raise
+            else:
+                aliases.extend(str(rr.target) for rr in ans.rrset)
+                hostname = ans[0].target
+        return aliases
+
+    def _getaddrinfo(self, host_bytes, port, family, socktype, proto, flags):
+        # dnspython really wants the host to be in native format.
+        if not isinstance(host_bytes, str):
+            host_bytes = host_bytes.decode(self.HOSTNAME_ENCODING)
+
+        if host_bytes == 'ff02::1de:c0:face:8D':
+            # This is essentially a hack to make stdlib
+            # test_socket:GeneralModuleTests.test_getaddrinfo_ipv6_basic
+            # pass. They expect to get back a lowercase ``D``, but
+            # dnspython does not do that.
+            # ``test_getaddrinfo_ipv6_scopeid_symbolic`` also expect
+            # the scopeid to be dropped, but again, dnspython does not
+            # do that; we cant fix that here so we skip that test.
+            host_bytes = 'ff02::1de:c0:face:8d'
+
+        if family == AF_UNSPEC:
+            # This tends to raise in the case that a v6 address did not exist
+            # but a v4 does. So we break it into two parts.
+
+            # Note that if there is no ipv6 in the hosts file, but there *is*
+            # an ipv4, and there *is* an ipv6 in the nameservers, we will return
+            # both (from the first call). The system resolver on OS X only returns
+            # the results from the hosts file. doubleclick.com is one example.
+
+            # See also https://github.com/gevent/gevent/issues/1012
+            try:
+                return _getaddrinfo(host_bytes, port, family, socktype, proto, flags)
+            except gaierror:
+                try:
+                    return _getaddrinfo(host_bytes, port, AF_INET6, socktype, proto, flags)
+                except gaierror:
+                    return _getaddrinfo(host_bytes, port, AF_INET, socktype, proto, flags)
+        else:
+            try:
+                return _getaddrinfo(host_bytes, port, family, socktype, proto, flags)
+            except gaierror as ex:
+                if ex.args[0] == EAI_NONAME and family not in self._KNOWN_ADDR_FAMILIES:
+                    # It's possible that we got sent an unsupported family. Check
+                    # that.
+                    ex.args = (EAI_FAMILY, self.EAI_FAMILY_MSG)
+                    ex.errno = EAI_FAMILY
+                raise
+
+    def _getnameinfo(self, address_bytes, port, sockaddr, flags):
+        try:
+            return resolver._getnameinfo(sockaddr, flags)
+        except error:
+            if not flags:
+                # dnspython doesn't like getting ports it can't resolve.
+                # We have one test, test__socket_dns.py:Test_getnameinfo_geventorg.test_port_zero
+                # that does this. We conservatively fix it here; this could be expanded later.
+                return resolver._getnameinfo(sockaddr, NI_NUMERICSERV)
+
+    def _gethostbyaddr(self, ip_address_bytes):
+        try:
+            return resolver._gethostbyaddr(ip_address_bytes)
+        except gaierror as ex:
+            if ex.args[0] == EAI_NONAME:
+                # Note: The system doesn't *always* raise herror;
+                # sometimes the original gaierror propagates through.
+                # It's impossible to say ahead of time or just based
+                # on the name which it should be. The herror seems to
+                # be by far the most common, though.
+                raise herror(1, "Unknown host")
+            raise
+
+    # Things that need proper error handling
+    getnameinfo = AbstractResolver.fixup_gaierror(AbstractResolver.getnameinfo)
+    gethostbyaddr = AbstractResolver.fixup_gaierror(AbstractResolver.gethostbyaddr)
+    gethostbyname_ex = AbstractResolver.fixup_gaierror(AbstractResolver.gethostbyname_ex)
+    getaddrinfo = AbstractResolver.fixup_gaierror(AbstractResolver.getaddrinfo)