vKgB $SSKJr SSKJrJr SSKJr SSKJrJ r J r SSK r SSK J r Jr SSKrSSKJrJrJrJrJr SS KJrJrJrJr SS KJrJrJr \(a SS KJ r SS K!J"r" SS jr#\(a"SS\ S5r$O\"\#5r$\ RJ"SS55r&\ RN"SS\ \55r(\\ RN"SSSS9"SS\\\S955r)\\ RN"SSSS9"SS\\\S955r*g)) annotations) OrderedDictdeque)inf) TYPE_CHECKINGGenericTupleN)ErrorValue)ReceiveChannel ReceiveType SendChannelSendTypeT)Abort RaiseCancelTTaskenable_ki_protection)NoPublicConstructorfinalgeneric_function) TracebackType)SelfcU[:wa [U[5(d [S5eUS:a [ S5e[ U5n[ [RU5[[RU54$)u1 Open a channel for passing objects between tasks within a process. Memory channels are lightweight, cheap to allocate, and entirely in-memory. They don't involve any operating-system resources, or any kind of serialization. They just pass Python objects directly between tasks (with a possible stop in an internal buffer along the way). Channel objects can be closed by calling `~trio.abc.AsyncResource.aclose` or using ``async with``. They are *not* automatically closed when garbage collected. Closing memory channels isn't mandatory, but it is generally a good idea, because it helps avoid situations where tasks get stuck waiting on a channel when there's no-one on the other side. See :ref:`channel-shutdown` for details. Memory channel operations are all atomic with respect to cancellation, either `~trio.abc.ReceiveChannel.receive` will successfully return an object, or it will raise :exc:`Cancelled` while leaving the channel unchanged. Args: max_buffer_size (int or math.inf): The maximum number of items that can be buffered in the channel before :meth:`~trio.abc.SendChannel.send` blocks. Choosing a sensible value here is important to ensure that backpressure is communicated promptly and avoid unnecessary latency; see :ref:`channel-buffering` for more details. If in doubt, use 0. Returns: A pair ``(send_channel, receive_channel)``. If you have trouble remembering which order these go in, remember: data flows from left → right. In addition to the standard channel methods, all memory channel objects provide a ``statistics()`` method, which returns an object with the following fields: * ``current_buffer_used``: The number of items currently stored in the channel buffer. * ``max_buffer_size``: The maximum number of items allowed in the buffer, as passed to :func:`open_memory_channel`. * ``open_send_channels``: The number of open :class:`MemorySendChannel` endpoints pointing to this channel. Initially 1, but can be increased by :meth:`MemorySendChannel.clone`. * ``open_receive_channels``: Likewise, but for open :class:`MemoryReceiveChannel` endpoints. * ``tasks_waiting_send``: The number of tasks blocked in ``send`` on this channel (summing over all clones). * ``tasks_waiting_receive``: The number of tasks blocked in ``receive`` on this channel (summing over all clones). z.max_buffer_size must be an integer or math.infrzmax_buffer_size must be >= 0) r isinstanceint TypeError ValueErrorMemoryChannelStateMemorySendChannelr_createMemoryReceiveChannel)max_buffer_sizestates M/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/trio/_channel.py_open_memory_channelr'ssl#j#&F&FHII788#5o#FE!$$U+Q''. c0\rSrSrSSjrSSjrSrg)open_memory_channelac[U5$N)r')clsr$s r&__new__open_memory_channel.__new__bs(8 8r(cgr-)selfr$s r&__init__open_memory_channel.__init__hs r(r2Nr$ int | floatreturnz4tuple[MemorySendChannel[T], MemoryReceiveChannel[T]])r$r7)__name__ __module__ __qualname____firstlineno__r/r4__static_attributes__r2r(r&r*r*as 9( 9B 9  r(r*)zMemorySendChannel[T]zMemoryReceiveChannel[T]cR\rSrSr%S\S'S\S'S\S'S\S'S\S'S\S 'S rg ) MemoryChannelStatisticsqrcurrent_buffer_usedr7r$open_send_channelsopen_receive_channelstasks_waiting_sendtasks_waiting_receiver2N)r9r:r;r<__annotations__r=r2r(r&r?r?qs&  r(r?c\rSrSr%S\S'\R "\5rS\S'Sr S\S'Sr S\S '\R "\ 5r S \S '\R "\ 5r S \S 'SSjrSrg)r {r7r$zdeque[T]datarrrBrCzOrderedDict[Task, T] send_taskszOrderedDict[Task, None] receive_tasksc [[UR5URURUR [UR 5[UR5S9$)N)rAr$rBrCrDrE)r?lenrIr$rBrCrJrKr3s r& statisticsMemoryChannelState.statisticssO& #DII 00#66"&"<"<"4??3"%d&8&8"9   r(r2Nr8r?)r9r:r;r<rFattrsFactoryrrIrBrCrrJrKrOr=r2r(r&r r {s^  ]]5)D()!"3"',}}['AJ$A-2]];-GM*G r(r F)eqreprslotsc\rSrSr%S\S'SrS\S'\R"\5r S\S'SS jr SS jr SS jr \ SS j5r\ SS j5r\ SSj5rSSjrSSjr\ SSj5r\ SSj5rSrg)r!zMemoryChannelState[SendType]_stateFbool_closedz set[Task]_taskscBUR=RS- slgNr )rYrBrNs r&__attrs_post_init__%MemorySendChannel.__attrs_post_init__s &&!+&r(cPS[U5SS[UR5SS3$)NzidrYrNs r&__repr__MemorySendChannel.__repr__s+"2d8B-/A"T[[/RTAUUVWWr(c6URR5$zSReturns a `MemoryChannelStatistics` for the memory channel this is associated with.rYrOrNs r&rOMemorySendChannel.statisticss{{%%''r(cUR(a[ReURRS:Xa[R eURR (aURR(aeURR RSS9up#URRRU5 [RRU[U55 g[URR5URR :a&URRR#U5 g[R$e)zrLike `~trio.abc.SendChannel.send`, but if the channel's buffer is full, raises `WouldBlock` instead of blocking. rFlastN)r[trioClosedResourceErrorrYrCBrokenResourceErrorrKrIpopitemcustom_sleep_datar\removelowlevel rescheduler rMr$append WouldBlock)r3valuetask_s r& send_nowaitMemorySendChannel.send_nowaits <<** * ;; , , 1** * ;; $ ${{'' ''kk//77U7CGD  " " ) ) 0 0 6 MM $ $T5< 8 !! "T[[%@%@ @ KK   # #E *// !r(c^^# [RR5IShvN TRU5 [RR 5IShvN gN=N![R a Of=f[RR 5mTRRT5 UTRRT'TTl SUU4Sjjn[RRU5IShvN g7f)z|See `SendChannel.send `. Memory channels allow multiple tasks to call `send` at the same time. Nc>TRRT5 TRRT [R R R$r-)r\rurYrJrprvr SUCCEEDEDr|r3r{s r&abort_fn(MemorySendChannel.send..abort_fns= KK  t $ &&t,==&&00 0r(r|rr8r) rprvcheckpoint_if_cancelledr}cancel_shielded_checkpointry current_taskr\addrYrJrtwait_task_rescheduledr3rzrr{s` @r&sendMemorySendChannel.sendsmm33555    U #--::< < <  6 =    }}))+ ', t$!% 1 1 mm11(;;;sP"D A$D A(!D A&D &D (A?<D >A??BD D D cUR(a[Re[R UR 5$)atClone this send channel object. This returns a new `MemorySendChannel` object, which acts as a duplicate of the original: sending on the new object does exactly the same thing as sending on the old object. (If you're familiar with `os.dup`, then this is a similar idea.) However, closing one of the objects does not close the other, and receivers don't get `EndOfChannel` until *all* clones have been closed. This is useful for communication patterns that involve multiple producers all sending objects to the same destination. If you give each producer its own clone of the `MemorySendChannel`, and then make sure to close each `MemorySendChannel` when it's finished, receivers will automatically get notified when all producers are finished. See :ref:`channel-mpmc` for examples. Raises: trio.ClosedResourceError: if you already closed this `MemorySendChannel` object. )r[rprqr!r"rYrNs r&cloneMemorySendChannel.clones,2 <<** * ((55r(cU$r-r2rNs r& __enter__MemorySendChannel.__enter__ r(c$UR5 gr-closer3exc_type exc_value tracebacks r&__exit__MemorySendChannel.__exit__ r(c(UR(agSUlURHVn[RR U[ [R "555 URRU MX URR5 UR=RS-sl URRS:XaURR(aeURRHdnURRRU5 [RR U[ [R"555 Mf URRR5 gg)aClose this send channel object synchronously. All channel objects have an asynchronous `~.AsyncResource.aclose` method. Memory channels can also be closed synchronously. This has the same effect on the channel and other tasks using it, but `close` is not a trio checkpoint. This simplifies cleaning up in cancelled tasks. Using ``with send_channel:`` will close the channel object on leaving the with block. NTr r)r[r\rprvrwr rqrYrJclearrBrKrtru EndOfChannelr3r{s r&rMemorySendChannel.closes <<  KKD MM $ $T51I1I1K+L M &&t,   &&!+& ;; ) )Q .{{-- -- 11&&--44T: ((uT5F5F5H/IJ2 KK % % + + - /r(c|# UR5 [RR5IShvN gN7f)zNClose this send channel object asynchronously. See `MemorySendChannel.close`.Nrrprv checkpointrNs r&acloseMemorySendChannel.aclose& mm&&((( 2<:<r[Nr8Noner8strrQ)rzrr8r)r8zMemorySendChannel[SendType]r8rrztype[BaseException] | NonerzBaseException | NonerzTracebackType | Noner8r)r9r:r;r<rFr[rRrSsetr\r_rgrOrr}rrrrrrr=r2r(r&r!r!s )(GT c*FI*,X( ""&<<8668,((   ..6))r(r!) metaclassc\rSrSr%S\S'SrS\S'\R"\5r S\S'SS jr SS jr SS jr \ SS j5r\ SS j5r\ SSj5rSSjrSSjr\ SSj5r\ SSj5rSrg)r#i&zMemoryChannelState[ReceiveType]rYFrZr[zset[trio._core._run.Task]r\cBUR=RS- slgr^)rYrCrNs r&r_(MemoryReceiveChannel.__attrs_post_init__-s ))Q.)r(c6URR5$rjrkrNs r&rOMemoryReceiveChannel.statistics0s{{%%''r(cPS[U5SS[UR5SS3$)Nz`. Memory channels allow multiple tasks to call `receive` at the same time. The first task will get the first item sent, the second task will get the second item sent, and so on. Nc>TRRT5 TRRT [R R R$r-)r\rurYrKrprvrrrs r&r.MemoryReceiveChannel.receive..abort_fnes= KK  t $ ))$/==&&00 0r(r) rprvrrrryrr\rrYrKrtrrs` @r&receiveMemoryReceiveChannel.receiveNsmm33555 '')E--::< < <L 6 =    }}))+ *. !!$'!% 1 1]]88BBBBsP"D A$D A(!D A&D &D (A?<D >A??BD D D cUR(a[Re[R UR 5$)a<Clone this receive channel object. This returns a new `MemoryReceiveChannel` object, which acts as a duplicate of the original: receiving on the new object does exactly the same thing as receiving on the old object. However, closing one of the objects does not close the other, and the underlying channel is not closed until all clones are closed. (If you're familiar with `os.dup`, then this is a similar idea.) This is useful for communication patterns that involve multiple consumers all receiving objects from the same underlying channel. See :ref:`channel-mpmc` for examples. .. warning:: The clones all share the same underlying channel. Whenever a clone :meth:`receive`\s a value, it is removed from the channel and the other clones do *not* receive that value. If you want to send multiple copies of the same stream of values to multiple destinations, like :func:`itertools.tee`, then you need to find some other solution; this method does *not* do that. Raises: trio.ClosedResourceError: if you already closed this `MemoryReceiveChannel` object. )r[rprqr#r"rYrNs r&rMemoryReceiveChannel.clonens,8 <<** *#++DKK88r(cU$r-r2rNs r&rMemoryReceiveChannel.__enter__rr(c$UR5 gr-rrs r&rMemoryReceiveChannel.__exit__rr(cpUR(agSUlURHVn[RR U[ [R "555 URRU MX URR5 UR=RS-sl URRS:XaURR(aeURRHdnURRRU5 [RR U[ [R"555 Mf URRR5 URRR5 gg)aClose this receive channel object synchronously. All channel objects have an asynchronous `~.AsyncResource.aclose` method. Memory channels can also be closed synchronously. This has the same effect on the channel and other tasks using it, but `close` is not a trio checkpoint. This simplifies cleaning up in cancelled tasks. Using ``with receive_channel:`` will close the channel object on leaving the with block. NTr r)r[r\rprvrwr rqrYrKrrCrJrtrurrrIrs r&rMemoryReceiveChannel.closes& <<  KKD MM $ $T51I1I1K+L M ))$/   ))Q.) ;; , , 1{{00 00 ..&&--44T: ((uT5M5M5O/PQ/ KK " " ( ( * KK   " " $ 2r(c|# UR5 [RR5IShvN gN7f)zTClose this receive channel object asynchronously. See `MemoryReceiveChannel.close`.NrrNs r&rMemoryReceiveChannel.acloserrrNrrQr)r8r)r8z!MemoryReceiveChannel[ReceiveType]rr)r9r:r;r<rFr[rRrSrr\r_rOrgrrrrrrrrr=r2r(r&r#r#&s ,+GT(- c(:F %:/(  &CC>99>,((   %%8))r(r#r6)+ __future__r collectionsrrmathrtypingrrr rRoutcomer r rp_abcr rrrr_corerrrr_utilrrrtypesrtyping_extensionsrr'r*frozenr?definer r!r#r2r(r&rs0"*  GGBB??#&> >9>He$UV++?@   ,U%0O) H-9LO)1O)dU%0T)>+6BUT)1T)r(