D_ix) SrSSKJr SSKJrJrJrJrJrJ r SSK J r SSK J r SSKJrJrJrJrJr SSKJr SSKJr \"S 5r\"5r\"S S S 9\4S \\S\\-S\\\-S-4Sjj5r"SS5rS \\S\\S\\\S\ \S\\S44 Sjr"SS\\5r\r "SS\ 5r!S\"S\\S\\\4Sjr#g)zAsynchronous iterator utilities. Adapted from https://github.com/maxfischer2781/asyncstdlib/blob/master/asyncstdlib/itertools.py MIT License. )deque)AsyncGenerator AsyncIterable AsyncIterator AwaitableCallableIterator)AbstractAsyncContextManager) TracebackType)AnyGenericTypeVarcastoverload)override) deprecatedTz1.1.2z2.0.0)sinceremovaliteratordefaultreturnNc^^^[S[T5R5mT[ LaT"T5$S[ [-4UUU4SjjnU"5$![anT<S3n[ U5UeSnAff=f)a{Pure-Python implementation of anext() for testing purposes. Closely matches the builtin anext() C implementation. Can be used to compare the built-in implementation of the inner coroutines machinery to C-implementation of __anext__() and send() or throw() on the returned generator. Args: iterator: The async iterator to advance. default: The value to return if the iterator is exhausted. If not provided, a StopAsyncIteration exception is raised. Returns: The next value from the iterator, or the default value if the iterator is exhausted. Raises: TypeError: If the iterator is not an async iterator. z*Callable[[AsyncIterator[T]], Awaitable[T]]z is not an async iteratorNrcV># T"T5IShvN $N![a Ts$f=f7fN)StopAsyncIteration) __anext__rrsT/home/james-whalen/.local/lib/python3.13/site-packages/langchain_core/utils/aiter.py anext_implpy_anext..anext_implGs1  #8,, ,,! N s() ) &)&))rtyperAttributeError TypeError _no_defaultrr )rremsgrrs`` @rpy_anextr'%s.$ 8$x.:R:R +"" a#g   <% $ 56n!#$sA A4A//A4cT\rSrSrSrS SjrS\\S-S\S-S\S-S\ 4S jr S r g) NoLockUz@Dummy lock that provides the proper interface but no protection.rNc # g7f)z Do nothing.Nselfs r __aenter__NoLock.__aenter__Xsexc_typeexc_valexc_tbc # g7f)z'Return False, exception not suppressed.Fr,r.r2r3r4s r __aexit__NoLock.__aexit__[s r1r,rN) __name__ __module__ __qualname____firstlineno____doc__r/r! BaseExceptionr boolr7__static_attributes__r,rr)r)UsIJ}%,%$   rBr)bufferpeerslockc # U(dcUIShvN U(aSSS5IShvN M-[U5IShvN nUHnURU5 M SSS5IShvN UR57v MNqN[NG![a SSS5IShvN O f=fN@!,IShvN (df  NU=fUIShvN [ U5HupeXQLdM UR U5 O U(d*[ US5(aUR5IShvN SSS5IShvN g!,IShvN (df  g=f!UIShvN [ U5HupeXQLdM UR U5 O U(d*[ US5(aUR5IShvN SSS5IShvN f!,IShvN (df  f=f=f7f)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. Naclose)anextappendrpopleft enumeratepophasattrrG)rrCrDrEitem peer_bufferidxs rtee_peerrQesS.(4  44 5%*8_4,1K'..t4,1 4".." "' 5- 44 444&4$-e$4 (IIcN%5 WXx88oo'''4444444$-e$4 (IIcN%5 WXx88oo'''44444sUG3EBE B- EBEB BB B- E*B++EEB  B(B- E B#!E'B((B-+E-C3B6 4 CEG3 CG3E)AE)D,*E/ G3:D=;G3EE  EG3G0"E% #G0'G>AG>G ?G G0GG0G- G G- )G00G3c >\rSrSrSrSSS.S\\S\S\\ S-4Sjjjr S \4S jr \ S \S \\4S j5r \ S \S \\\S 44Sj5r S \\-S \\\\\S 4-4Sjr S \\\4SjrSSjrS\\S-S\S-S\S-S \4SjrSSjrSrg)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)rEiterablenrEc^^UR5Tl[U5Vs/sH n[5PM snTl[ UU4SjTR55Tlgs snf)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~># UH2n[TRUTRTbTO [5S9v M4 g7f)N)rrCrDrE)rQ _iterator_buffersr)).0rCrEr.s r Tee.__init__..s> ( mm!-T68   (s:=N) __aiter__rYrangerrZtuple _children)r.rUrVrE_s` ` r__init__ Tee.__init__sV"++-:?((C(Q((C  --  )DsA'rc,[UR5$)z%Return the number of child iterators.)lenrar-s r__len__ Tee.__len__s4>>""rBrNcgrr,r.rNs r __getitem__Tee.__getitem__s:=rB.cgrr,rjs rrkrlsHKrBc URU$)z:Return the child iterator(s) for the given index or slice.rarjs rrkrls~~d##rBc#8# URShvN gN7f)zDIterate over the child iterators. Yields: The child iterators. Nror-s r__iter__ Tee.__iter__s >>!!s c# U$7f)zReturn the tee instance.r,r-s rr/Tee.__aenter__s  sr2r3r4c@# UR5IShvN gN7f)zKClose all child iterators. Returns: False, exceptions not suppressed. NF)rGr6s rr7 Tee.__aexit__skkm s cf# URHnUR5IShvN M gN 7f)z Async close all child iterators.N)rarG)r.childs rrG Tee.acloses%^^E,,. $ s #1/ 1)rZrarY))rzTee[T]r9)r:r;r<r=r>rrintr r rcrgrrkslicer`r rqr/r!r?r r@r7rGrAr,rBrrSrSs*#P 9=  "   *#.5  6##== a(8== KK% a0@#0E*FKK$%K$ q E-"2C"78 8$ "(=#34" }%, % $   !rBrSc \rSrSrSrS\\\4\\-SS4Sjr\ S\\\4\\-4Sj5r \ S\ \ S-S \ S-S \ S-SS4S j5rS rg) aclosingia1Async context manager to wrap an AsyncGenerator that has a `aclose()` method. Code like this: ```python async with aclosing(.fetch()) as agen: ``` is equivalent to this: ```python agen = .fetch() try: finally: await agen.aclose() ``` thingrNcXlg)zDCreate the context manager. Args: thing: The resource to wrap. Nr)r.rs rrcaclosing.__init__'s  rBc"# UR$7frrr-s rr/aclosing.__aenter__/szzs r2 exc_value tracebackc# [URS5(a#URR5IShvN ggN7f)NrG)rMrrG)r.r2rrs rr7aclosing.__aexit__3s6 4::x ( (**##% % % ) %s9AAAr)r:r;r<r=r>rr rrcrr/r!r?r r7rAr,rBrr~r~s*nS#X6s9KKPT.c":]3=O"O&}%,&!4'&!4' &  &&rBr~sizerUc# /nUShvN n[U5U:aURU5 [U5U:dM:U7v /nMCN> U(aU7v gg7f)zUtility batching function for async iterables. Args: size: The size of the batch. iterable: The async iterable to batch. Yields: The batches. N)rfrI)rrUbatchelements rabatch_iterater>sZE!g u:  LL ! u: KE    s+AA A A .A A A  A)$r> collectionsrcollections.abcrrrrrr contextlibr typesr typingr r rrrtyping_extensionsrlangchain_core._api.deprecationrrobjectr$r'r)listrQrSateer~r{rr,rBrrsB3'6 CLh  '7+3>,A,)*S,q3w~,,,^   5(A5( !H5( a> 5( &c * 5(AtG5(pn!'!*n!b *&**&Z &q)47rB