g3fi dZddlmZddlmZmZmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZedZGd d Zd eed eed eeedeedeeddff dZGddeeZeZdedzdeedeeefdZy)z%Utilities for working with iterators.)deque) GeneratorIterableIterator)AbstractContextManager)islice) TracebackType)AnyGenericLiteralTypeVaroverloadTc NeZdZdZd dZdeedzdedzdedzdedfd Z y) NoLockz@Dummy lock that provides the proper interface but no protection.returnNcy)z Do nothing.Nselfs W/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_core/utils/iter.py __enter__zNoLock.__enter__sexc_typeexc_valexc_tbFcy)z(Return False (exception not suppressed).Frrrrrs r__exit__zNoLock.__exit__srrN) __name__ __module__ __qualname____doc__rtype BaseExceptionr r rrrrrrsMJ}%,%$   rriteratorbufferpeerslockrNc#K |s<|5|r ddd t|}|D]}|j| ddd|jQ#t$r YdddnwxYw#1swY3xYw |5t |D]\}}||us |j |n|st |dr|jdddy#1swYyxYw#|5t |D]\}}||us |j |n|st |dr|jdddw#1swYwxYwxYww)aAn individual iterator of a `.tee`. This function is a generator that yields items from the shared iterator `iterator`. It buffers items until the least advanced iterator has yielded them as well. The buffer is shared with all other peers. Args: iterator: The shared iterator. buffer: The buffer for this peer. peers: The buffers of all peers. lock: The lock to synchronise access to the shared buffers. Yields: The next item from the shared iterator. Nclose)nextappend StopIterationpopleft enumeratepophasattrr,)r'r(r)r*item peer_bufferidxs rtee_peerr7#s].!5 55 5#H~,15K'..t455".." "')55555& !$-e$4  [&(IIcN  WXw7  ! ! !T !$-e$4  [&(IIcN  WXw7  ! ! !sD>CA- C AA-C A*A- C)A**A--A62C:D><C2C D>CD>D;D/42D/& D;/D8 4D;;D>c &eZdZdZ ddddeededeedzfdZ defd Z e d edeefd Z e d e deeed ffd Z d ee zdeeeeed fzfdZ deeefdZddZdeedzdedzdedzdedfdZddZy)TeeaCreate `n` separate asynchronous iterators over `iterable`. This splits a single `iterable` into multiple iterators, each providing the same items in the same order. All child iterators may advance separately but share the same items from `iterable` -- when the most advanced iterator retrieves an item, it is buffered until the least advanced iterator has yielded it as well. A `tee` works lazily and can handle an infinite `iterable`, provided that all iterators advance. ```python async def derivative(sensor_data): previous, current = a.tee(sensor_data, n=2) await a.anext(previous) # advance one iterator return a.map(operator.sub, previous, current) ``` Unlike `itertools.tee`, `.tee` returns a custom type instead of a :py`tuple`. Like a tuple, it can be indexed, iterated and unpacked to get the child iterators. In addition, its `.tee.aclose` method immediately closes all children, and it can be used in an `async with` context for the same effect. If `iterable` is an iterator and read elsewhere, `tee` will *not* provide these items. Also, `tee` must internally buffer each item until the last iterator has yielded it; if the most and least advanced iterator differ by most data, using a :py`list` is more efficient (but not lazy). If the underlying iterable is concurrency safe (`anext` may be awaited concurrently) the resulting iterators are concurrency safe as well. Otherwise, the iterators are safe if there is only ever one single "most advanced" iterator. To enforce sequential use of `anext`, provide a `lock` - e.g. an :py`asyncio.Lock` instance in an :py:mod:`asyncio` application - and access is automatically synchronised. N)r*iterablenr*ct|_t|Dcgc] }tc}_t fdjD_ycc}w)zCreate a `tee`. Args: iterable: The iterable to split. n: The number of iterators to create. lock: The lock to synchronise access to the shared buffers. c3|K|]3}tj|jn t5yw)N)r'r(r)r*)r7 _iterator_buffersr).0r(r*rs r zTee.__init__..sB  mm!-T68    s9<N)iterr>rangerr?tuple _children)rr:r;r*_s` ` r__init__z Tee.__init__sMh:?((CQ(C  --  )DsArc,t|jS)z%Return the number of child iterators.)lenrErs r__len__z Tee.__len__s4>>""rr4cyNrrr4s r __getitem__zTee.__getitem__s58r.cyrLrrMs rrNzTee.__getitem__sCFrc |j|S)z9Return the child iterator(s) at the given index or slice.rErMs rrNzTee.__getitem__s~~d##rc#8K|jEd{y7w)zgReturn an iterator over the child iterators. Yields: The child iterators. NrQrs r__iter__z Tee.__iter__s >>!!s c|S)zReturn Tee instance.rrs rrz Tee.__enter__s rrrrFc$|jy)zcClose all child iterators. Returns: False (exception not suppressed). F)r,rs rrz Tee.__exit__s rcF|jD]}|jy)zClose all child iterators.N)rEr,)rchilds rr,z Tee.closes^^ E KKM r))rzTee[T]r )r!r"r#r$rrintrr rGrJrrNslicerDrSrr%r&r r rr,rrrr9r9[s'#P 48  1+   %S)D0  6##88 88 FF% S0@*AFF$e $ eHQKQTDT>U0U$"(8A;/" }%, % $   rr9sizer:c#\Kt|} tt||}|sy|w)zUtility batching function. Args: size: The size of the batch. If `None`, returns a single batch. iterable: The iterable to batch. Yields: The batches of the iterable. N)rBlistr)r[r:itchunks r batch_iterater`s5 hB VB%&  s*,)r$ collectionsrcollections.abcrrr contextlibr itertoolsrtypesr typingr r r r rrrr]r7r9safeteerYr`rrrrhs+99- CL   5!qk5! !H5! a> 5! ! % 5!q$}5!pl'!*l` d hqkhtAw>Or