id~ddlZddlmZddlmZddgZGddZGddZGd deZdS) N)contextmanager)queuePool TokenPoolcTeZdZdZddZdZedZd Zd Z d Z d Z d Z 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. rFNcN||_||_||_d|_t jd|_tj|_ |||_ t|D]>}|xjdz c_|j | ?dS)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_sizer LightQueuechannel collectionsdeque free_itemscreaterangeappend)selfr r r rxs 9/usr/local/lib/python3.11/dist-packages/eventlet/pools.py__init__z Pool.__init__8s!   ,'** %+--   DKx 2 2A    "   O " "4;;== 1 1 1 1 2 2c0|jr|jS|xjdz c_|j|jkr. |}n#|xjdzc_xYw|S|xjdzc_|jS)zwReturn an item from the pool, when one is available. This may cause the calling greenthread to block. r )rpopleftrr rrget)rcreateds rrzPool.getMs ? -?**,, , Q   - - ++-- !!Q&!!N Q|!!!s AA*c#K|} |V||dS#||wxYw)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)robjs ritemz Pool.item^sJhhjj III HHSMMMMMDHHSMMMMs 3A cT|j|jkr|xjdzc_dS|r4 |j|ddS#t j$rYnwxYw|jr|j |dS|j |dS)zmPut an item back into the pool, when done. This may cause the putting greenthread to block. r NF)block) rr waitingrr!rFullr r appendleftr)rr#s rr!zPool.putqs  t} , ,    "   F <<>>     U 333:       ) O & &t , , , , , O " "4 ( ( ( ( (sAA('A(c||_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_sizes rresizez Pool.resizes! rcJt|j|jz|jz S)zReturn the number of free items in the pool. This corresponds to the number of :meth:`get` calls needed to empty the pool. )lenrr rrs rfreez Pool.frees#4?##dm3d6GGGrctd|j|jz S)z?Return the number of routines waiting for a pool item. r)maxrgettingputtingr.s rr&z Pool.waitings51dl**,,t|/C/C/E/EEFFFrc td)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 subclass)NotImplementedErrorr.s rrz Pool.creates""9:::r)rrFN) __name__ __module__ __qualname____doc__rrrr#r!r+r/r&rrrrr s++Z2222*""""^$)))( ! ! !HHH GGG ;;;;;rceZdZdS)TokenN)r6r7r8r:rrr<r<sDrr<ceZdZdZdZdS)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. ctS)N)r<r.s rrzTokenPool.creates wwrN)r6r7r8r9rr:rrrrs- r) r contextlibreventletr__all__rr<rr:rrrBs%%%%%% ; `;`;`;`;`;`;`;`;F        r