eventlet
********

* eventlet package

  * Subpackages

    * eventlet.green package

      * Subpackages

      * Submodules

      * eventlet.green.BaseHTTPServer module

      * eventlet.green.CGIHTTPServer module

      * eventlet.green.MySQLdb module

      * eventlet.green.Queue module

      * eventlet.green.SimpleHTTPServer module

      * eventlet.green.SocketServer module

      * eventlet.green.asynchat module

      * eventlet.green.asyncore module

      * eventlet.green.builtin module

      * eventlet.green.ftplib module

      * eventlet.green.httplib module

      * eventlet.green.os module

      * eventlet.green.profile module

      * eventlet.green.select module

      * eventlet.green.selectors module

      * eventlet.green.socket module

      * eventlet.green.ssl module

      * eventlet.green.subprocess module

      * eventlet.green.thread module

      * eventlet.green.threading module

      * eventlet.green.time module

      * eventlet.green.urllib2 module

      * eventlet.green.zmq module

      * Module contents

    * eventlet.greenio package

      * Submodules

      * eventlet.greenio.base module

      * eventlet.greenio.py3 module

      * Module contents

    * eventlet.hubs package

      * Submodules

      * eventlet.hubs.asyncio module

      * eventlet.hubs.epolls module

      * eventlet.hubs.hub module

      * eventlet.hubs.kqueue module

      * eventlet.hubs.poll module

      * eventlet.hubs.pyevent module

      * eventlet.hubs.selects module

      * eventlet.hubs.timer module

      * Module contents

    * eventlet.support package

      * Submodules

      * eventlet.support.greendns module

      * eventlet.support.greenlets module

      * eventlet.support.psycopg2_patcher module

      * eventlet.support.pylib module

      * eventlet.support.stacklesspypys module

      * eventlet.support.stacklesss module

      * Module contents

    * eventlet.zipkin package

      * Submodules

      * eventlet.zipkin.api module

      * eventlet.zipkin.client module

      * eventlet.zipkin.greenthread module

      * eventlet.zipkin.http module

      * eventlet.zipkin.log module

      * eventlet.zipkin.patcher module

      * eventlet.zipkin.wsgi module

      * Module contents

  * Submodules

  * eventlet.asyncio module

    * "spawn_for_awaitable()"

  * eventlet.backdoor module

    * "FileProxy"

      * "FileProxy.flush()"

      * "FileProxy.isatty()"

      * "FileProxy.readline()"

      * "FileProxy.write()"

    * "SocketConsole"

      * "SocketConsole.finalize()"

      * "SocketConsole.run()"

      * "SocketConsole.switch()"

      * "SocketConsole.switch_out()"

    * "backdoor()"

    * "backdoor_server()"

  * eventlet.convenience module

    * "ReusePortUnavailableWarning"

    * "ReuseRandomPortWarning"

    * "StopServe"

    * "connect()"

    * "listen()"

    * "serve()"

    * "wrap_ssl()"

  * eventlet.corolocal module

    * "get_ident()"

    * "local"

  * eventlet.coros module

    * "metaphore"

      * "metaphore.dec()"

      * "metaphore.inc()"

      * "metaphore.wait()"

  * eventlet.dagpool module

    * "Collision"

    * "DAGPool"

      * "DAGPool.__init__()"

      * "DAGPool.__getitem__()"

      * "DAGPool.get()"

      * "DAGPool.items()"

      * "DAGPool.keys()"

      * "DAGPool.kill()"

      * "DAGPool.post()"

      * "DAGPool.running()"

      * "DAGPool.running_keys()"

      * "DAGPool.spawn()"

      * "DAGPool.spawn_many()"

      * "DAGPool.wait()"

      * "DAGPool.wait_each()"

      * "DAGPool.wait_each_exception()"

      * "DAGPool.wait_each_success()"

      * "DAGPool.waitall()"

      * "DAGPool.waiting()"

      * "DAGPool.waiting_for()"

    * "PropagateError"

  * eventlet.db_pool module

    * "BaseConnectionPool"

      * "BaseConnectionPool.clear()"

      * "BaseConnectionPool.get()"

      * "BaseConnectionPool.item()"

      * "BaseConnectionPool.put()"

    * "ConnectTimeout"

    * "ConnectionPool"

    * "DatabaseConnector"

      * "DatabaseConnector.credentials_for()"

      * "DatabaseConnector.get()"

    * "GenericConnectionWrapper"

      * "GenericConnectionWrapper.affected_rows()"

      * "GenericConnectionWrapper.autocommit()"

      * "GenericConnectionWrapper.begin()"

      * "GenericConnectionWrapper.change_user()"

      * "GenericConnectionWrapper.character_set_name()"

      * "GenericConnectionWrapper.close()"

      * "GenericConnectionWrapper.commit()"

      * "GenericConnectionWrapper.cursor()"

      * "GenericConnectionWrapper.dump_debug_info()"

      * "GenericConnectionWrapper.errno()"

      * "GenericConnectionWrapper.error()"

      * "GenericConnectionWrapper.errorhandler()"

      * "GenericConnectionWrapper.get_server_info()"

      * "GenericConnectionWrapper.insert_id()"

      * "GenericConnectionWrapper.literal()"

      * "GenericConnectionWrapper.ping()"

      * "GenericConnectionWrapper.query()"

      * "GenericConnectionWrapper.rollback()"

      * "GenericConnectionWrapper.select_db()"

      * "GenericConnectionWrapper.server_capabilities()"

      * "GenericConnectionWrapper.set_character_set()"

      * "GenericConnectionWrapper.set_isolation_level()"

      * "GenericConnectionWrapper.set_server_option()"

      * "GenericConnectionWrapper.set_sql_mode()"

      * "GenericConnectionWrapper.show_warnings()"

      * "GenericConnectionWrapper.shutdown()"

      * "GenericConnectionWrapper.sqlstate()"

      * "GenericConnectionWrapper.stat()"

      * "GenericConnectionWrapper.store_result()"

      * "GenericConnectionWrapper.string_literal()"

      * "GenericConnectionWrapper.thread_id()"

      * "GenericConnectionWrapper.use_result()"

      * "GenericConnectionWrapper.warning_count()"

    * "PooledConnectionWrapper"

      * "PooledConnectionWrapper.close()"

    * "RawConnectionPool"

      * "RawConnectionPool.connect()"

      * "RawConnectionPool.create()"

    * "TpooledConnectionPool"

      * "TpooledConnectionPool.connect()"

      * "TpooledConnectionPool.create()"

    * "cleanup_rollback()"

  * eventlet.debug module

    * "format_asyncio_info()"

    * "format_hub_listeners()"

    * "format_hub_timers()"

    * "format_threads_info()"

    * "hub_blocking_detection()"

    * "hub_exceptions()"

    * "hub_listener_stacks()"

    * "hub_prevent_multiple_readers()"

    * "hub_timer_stacks()"

    * "spew()"

    * "tpool_exceptions()"

    * "unspew()"

  * eventlet.event module

    * "Event"

      * "Event.has_exception()"

      * "Event.has_result()"

      * "Event.poll()"

      * "Event.poll_exception()"

      * "Event.poll_result()"

      * "Event.ready()"

      * "Event.reset()"

      * "Event.send()"

      * "Event.send_exception()"

      * "Event.wait()"

  * eventlet.greenpool module

    * "GreenPile"

      * "GreenPile.next()"

      * "GreenPile.spawn()"

    * "GreenPool"

      * "GreenPool.free()"

      * "GreenPool.imap()"

      * "GreenPool.resize()"

      * "GreenPool.running()"

      * "GreenPool.spawn()"

      * "GreenPool.spawn_n()"

      * "GreenPool.starmap()"

      * "GreenPool.waitall()"

      * "GreenPool.waiting()"

  * eventlet.greenthread module

    * "GreenThread"

      * "GreenThread.cancel()"

      * "GreenThread.kill()"

      * "GreenThread.link()"

      * "GreenThread.main()"

      * "GreenThread.unlink()"

      * "GreenThread.wait()"

    * "getcurrent()"

    * "kill()"

    * "sleep()"

    * "spawn()"

    * "spawn_after()"

    * "spawn_after_local()"

    * "spawn_n()"

  * eventlet.lock module

    * "Lock"

      * "Lock.release()"

  * eventlet.patcher module

    * "import_patched()"

    * "inject()"

    * "is_monkey_patched()"

    * "monkey_patch()"

  * eventlet.pools module

    * "Pool"

      * "Pool.create()"

      * "Pool.free()"

      * "Pool.get()"

      * "Pool.item()"

      * "Pool.put()"

      * "Pool.resize()"

      * "Pool.waiting()"

    * "TokenPool"

      * "TokenPool.create()"

  * eventlet.queue module

    * "Empty"

    * "Full"

    * "LifoQueue"

    * "LightQueue"

      * "LightQueue.empty()"

      * "LightQueue.full()"

      * "LightQueue.get()"

      * "LightQueue.get_nowait()"

      * "LightQueue.getting()"

      * "LightQueue.put()"

      * "LightQueue.put_nowait()"

      * "LightQueue.putting()"

      * "LightQueue.qsize()"

      * "LightQueue.resize()"

    * "PriorityQueue"

    * "Queue"

      * "Queue.join()"

      * "Queue.task_done()"

  * eventlet.semaphore module

    * "BoundedSemaphore"

      * "BoundedSemaphore.release()"

    * "CappedSemaphore"

      * "CappedSemaphore.acquire()"

      * "CappedSemaphore.balance"

      * "CappedSemaphore.bounded()"

      * "CappedSemaphore.locked()"

      * "CappedSemaphore.release()"

    * "Semaphore"

      * "Semaphore.acquire()"

      * "Semaphore.balance"

      * "Semaphore.bounded()"

      * "Semaphore.locked()"

      * "Semaphore.release()"

  * eventlet.timeout module

    * "Timeout"

      * "Timeout.cancel()"

      * "Timeout.is_timeout"

      * "Timeout.pending"

      * "Timeout.start()"

    * "is_timeout()"

    * "with_timeout()"

    * "wrap_is_timeout()"

  * eventlet.tpool module

    * "Proxy"

      * "Proxy.next()"

    * "execute()"

    * "killall()"

    * "set_num_threads()"

  * eventlet.websocket module

    * "WebSocket"

      * "WebSocket.close()"

      * "WebSocket.send()"

      * "WebSocket.wait()"

    * "WebSocketWSGI"

      * "WebSocketWSGI.configured()"

  * eventlet.wsgi module

    * "format_date_time()"

    * "server()"

  * Module contents
