U @fd@sXddlZddlmZddlmZddgZGdddZGdddZGd ddeZdS) N)contextmanager)queuePool TokenPoolc@sVeZdZdZdddZdd Zed d Zd d ZddZ ddZ ddZ ddZ dS)ra  Pool class implements resource limitation and construction. There are two ways of using Pool: passing a `create` argument or subclassing. In either case you must provide a way to create the resource. When using `create` argument, pass a function with no arguments:: http_pool = pools.Pool(create=httplib2.Http) If you need to pass arguments, build a nullary function with either `lambda` expression:: http_pool = pools.Pool(create=lambda: httplib2.Http(timeout=90)) or :func:`functools.partial`:: from functools import partial http_pool = pools.Pool(create=partial(httplib2.Http, timeout=90)) When subclassing, define only the :meth:`create` method to implement the desired resource:: class MyPool(pools.Pool): def create(self): return MyObject() If using 2.5 or greater, the :meth:`item` method acts as a context manager; that's the best way to use it:: with mypool.item() as thing: thing.dostuff() The maximum size of the pool can be modified at runtime via the :meth:`resize` method. Specifying a non-zero *min-size* argument pre-populates the pool with *min_size* items. *max-size* sets a hard limit to the size of the pool -- it cannot contain any more items than *max_size*, and if there are already *max_size* items 'checked out' of the pool, the pool will cause any greenthread calling :meth:`get` to cooperatively yield until an item is :meth:`put` in. rFNcCsl||_||_||_d|_td|_t|_ |dk r<||_ t |D]"}|jd7_|j | qDdS)a*order_as_stack* governs the ordering of the items in the free pool. If ``False`` (the default), the free items collection (of items that were created and were put back in the pool) acts as a round-robin, giving each item approximately equal utilization. If ``True``, the free pool acts as a FILO stack, which preferentially re-uses items that have most recently been used. rN) min_sizemax_sizeorder_as_stack current_sizerZ LightQueuechannel collectionsdeque free_itemscreaterangeappend)selfrr r rxrH/var/www/html/chatgpt/venv/lib/python3.8/site-packages/eventlet/pools.py__init__8s   z Pool.__init__cCsp|jr|jS|jd7_|j|jkrXz |}Wn|jd8_YnX|S|jd8_|jS)zwReturn an item from the pool, when one is available. This may cause the calling greenthread to block. r)rpopleftr r rr get)rcreatedrrrrMs   zPool.getc cs$|}z |VW5||XdS)a$ Get an object out of the pool, for use with with statement. >>> from eventlet import pools >>> pool = pools.TokenPool(max_size=4) >>> with pool.item() as obj: ... print("got token") ... got token >>> pool.free() 4 N)rput)robjrrritem^s  z Pool.itemcCsx|j|jkr|jd8_dS|rTz|jj|ddWdStjk rRYnX|jrh|j |n |j |dS)zmPut an item back into the pool, when done. This may cause the putting greenthread to block. rNF)block) r r waitingr rrFullr r appendleftr)rrrrrrqs zPool.putcCs ||_dS)ayResize the pool to *new_size*. Adjusting this number does not affect existing items checked out of the pool, nor on any greenthreads who are waiting for an item to free up. Some indeterminate number of :meth:`get`/:meth:`put` cycles will be necessary before the new maximum size truly matches the actual operation of the pool. N)r )rnew_sizerrrresizes z Pool.resizecCst|j|j|jS)zReturn the number of free items in the pool. This corresponds to the number of :meth:`get` calls needed to empty the pool. )lenrr r rrrrfreesz Pool.freecCstd|j|jS)z?Return the number of routines waiting for a pool item. r)maxr ZgettingZputtingr%rrrrsz Pool.waitingcCs tddS)a%Generate a new pool item. In order for the pool to function, either this method must be overriden in a subclass or the pool must be constructed with the `create` argument. It accepts no arguments and returns a single instance of whatever thing the pool is supposed to contain. In general, :meth:`create` is called whenever the pool exceeds its previous high-water mark of concurrently-checked-out-items. In other words, in a new pool with *min_size* of 0, the very first call to :meth:`get` will result in a call to :meth:`create`. If the first caller calls :meth:`put` before some other caller calls :meth:`get`, then the first item will be returned, and :meth:`create` will not be called a second time. zImplement in subclassN)NotImplementedErrorr%rrrrsz Pool.create)rrFN) __name__ __module__ __qualname____doc__rrrrrr#r&rrrrrrr s-   c@s eZdZdS)TokenN)r)r*r+rrrrr-sr-c@seZdZdZddZdS)rzA pool which gives out tokens (opaque unique objects), which indicate that the coroutine which holds the token has a right to consume some limited resource. cCstS)N)r-r%rrrrszTokenPool.createN)r)r*r+r,rrrrrrs) r contextlibrZeventletr__all__rr-rrrrrs  $