H>qjddlZddlZddlZddlZddlmZmZmZm Z m Z m Z m Z m Z ddlmZmZmZGddZddlmZmZmZmZmZm ZmZmZmZmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2dd l3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;dd lZ>dd l?m@Z@dd lAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJddlKmLZLmMZMmNZNmOZOmPZPddlQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZey)N)Any AsyncIterable AwaitableIterableListOptionalTupleUnion)NO_VALUEget_event_loopmain_event_loopc ~eZdZUdZdZeZejeZe de d<e de d<e e d<e e d<e e e d<ee d<e de d <dd e d efd Zde fdZdefdZdZdZ ddeddfdZddZdZdZdZdZde fdZddZddZdZdZed Z dd!ed"efd#Z!eZ"eZ#eZ$eZ%d$Z&d%Z'd&Z(dd'Z)d(Z*e!Z+ d)Z,d*Z-ed+e.fd,Z/ed-Z0ed.e1dd/fd0Z2ed1e3dd2fd3Z4e dd5e.d6e5d7e6e.e5dfdd8fd9Z7eed:d4dfd6e5d7e6e.e5dfdd;fd<Z8ed4dd=d6e5d7e6e.e5dfdd>fd?Z9eddd@Z:edd6e5dAe6e;dfddBfdCZddAe;ddHfdIZ?ddAe;ddJfdKZ@efddLZAdMfddNZBddOZCddPZDddQZEdddRZFdddSZGddTZHddUZIddVZJddWZKddXZLdYe6e;e fddZfd[ZM d dd\ZNdd]ZOdd^ZPdd_ZQdd`ZRddaZSefddbZTddcZUdddZVdddeZWdddfZXddgZYddhZZddiZ[ ddje6e;dfdke6e5dfddlfdmZ\ddAe;ddnfdoZ]ddpZ^ddqZ_dddrZ`ddsZaddtZbddduZcdddvZddwe;ddxfdyZe ddzdd{edd|fd}Zfdd~ZgddZhddZiddZjddZkd ddeddfdZlddZmddZn d ddZoddeddfdZpddZqddZrddZsddZtddZuy)Eventz Enable event passing between loosely coupled components. The event emits values to connected listeners and has a selection of operators to create general data flow pipelines. Args: name: Name to use for this event. ) error_event done_event_name_value_slots_done_source __weakref__rrrrrrrTname_with_error_done_eventscd|_ d|_ |r"tdd|_tdd|_g|_|xs|jj |_t|_d|_ d|_ y)NerrorFdone) rrrr __class__ __qualname__rr rrr)selfrrs M/opt/rentech/trading_bot/.venv/lib/python3.12/site-packages/eventkit/event.py__init__zEvent.__init__%sq   #$We4D #FE2DO 8T^^88    returnc|jS)z$ This event's name. )rr s r!rz Event.name9szzr#c|jS)ze ``True`` if event has ended with no more emits coming, ``False`` otherwise. )rr&s r!rz Event.done?s zzr#cb|js#d|_|jj|yy)zd Set this event to be ended. The event should not emit anything after that. TN)rremitr&s r!set_donezEvent.set_doneFs) zzDJ OO  &r#cp|j}|turtSt|dk(r|dS|r|StS)z2 This event's last emitted value. r r)rr len)r vs r!valuez Event.valueOsC KK=x :FaKAaD :*+Q :19 :r#Nkeep_refct|tr|j||S|j|\}}|s/t |dr#t j ||j}d}nd}|||g}|jj||jr||jj||jr||jj||S)a- Connect a listener to this event. If the listener is added multiple times then it is invoked just as many times on emit. The ``+=`` operator can be used as a synonym for this method:: import eventkit as ev def f(a, b): print(a * b) def g(a, b): print(a / b) event = ev.Event() event += f event += g event.emit(10, 5) Args: listener: The callback to invoke on emit of this event. It gets the ``*args`` from an emit as arguments. If the listener is a coroutine function, or a function that returns an awaitable, the awaitable is run in the asyncio event loop. error: The callback to invoke on error of this event. It gets (this event, exception) as two arguments. done: The callback to invoke on ending of this event. It gets this event as single argument. keep_ref: * ``True``: A strong reference to the callable is kept * ``False``: If the callable allows weak refs and it is garbage collected, then it is automatically disconnected from this event. rN) isinstanceOp set_source_splithasattrweakrefref _onFinalizerappendrconnectr) r listenerrrr/objfuncr7slots r!r:z Event.connectWsJ h #    %KKK) TGC7++c4#3#34CCCS$ 4 ??t/ OO # #D )    1    $ $U + r#c|j|\}}|jD]4}|d|us|ds|d|us|d|us%dx|d<x|d<|d<n|jDcgc] }|gdk7s |c}|_||jj|||jj||Scc}w)a Disconnect a listener from this event. The ``-=`` operator can be used as a synonym for this method. Args: listener: The callback to disconnect. The callback is removed at most once. It is valid if the callback is already not connected. error: The error callback to disconnect. done: The done callback to disconnect. rr NNNN)r4rr disconnectr)r r;rrr<r=r>ss r!rBzEvent.disconnectsKK) TKK DQ3$q'gd1gi3.>Q4.22Q2$q'DG   #'++IQ6H1HqI      ' ' .   OO & &t , Js & B;3B;cn|jD]+}|d|us|ds|d|usdx|d<x|d<|d<-|jDcgc] }|gdk7s |c}|_|j|jj||j|jj|yycc}w)z Disconnect all listeners on the given object. (also the error and done listeners). Args: obj: The target object that is to be completely removed from this event. rr Nr@rA)rrdisconnect_objr)r r<r>rCs r!rEzEvent.disconnect_objsKK 3DAw#~aWT!WY#-=.22Q2$q'DG 3#'++IQ6H1HqI    '    + +C 0 ?? & OO * *3 / 'Js B2B2c||_|jjD]\\}}} |r|}d}||r||}n|r ||g|}n||}|r-t|dr!t }t j ||^y#t$ra}t|jr|jj||n%tjjd|d|Yd}~d}~wwxYw)z Emit a new value to all connected listeners. Args: args: Argument values to emit to listeners. N __await__)loopzValue z caused exception for event )rrcopyr5r asyncio ensure_future Exceptionr,rr)rlogger exception)r argsr<r7r=resultrHrs r!r)z Event.emits "kk..0 KNCd K%C;!%t!%c!1D!1!$dgfk:)+D))&t<# K& Kt''($$))$6LL** &B4&IK  KsAB C, AC''C,cDtj|jg|y)z Threadsafe version of :meth:`emit` that doesn't invoke the listeners directly but via the event loop of the main thread. N)rcall_soon_threadsafer))r rOs r!emit_threadsafezEvent.emit_threadsafes ,,TYY>>r#cR|jD]}dx|d<x|d<|d<g|_y)z+ Disconnect all listeners. Nrr r@r)r r>s r!clearz Event.clears9KK /D*. .DG .d1gQ / r#cTt}|j|jS)a Start the asyncio event loop, run this event to completion and return all values as a list:: import eventkit as ev ev.Timer(0.25, count=10).run() -> [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5] .. note:: When running inside a Jupyter notebook this will give an error that the asyncio event loop is already running. This can be remedied by applying `nest_asyncio `_ or by using the top-level ``await`` statement of Jupyter:: await event.list() )r run_until_completelist)r rHs r!runz Event.runs#*&&tyy{33r#ch|}|D]*}tj|}|j||},|S)a Form several events into a pipe:: import eventkit as ev e1 = ev.Sequence('abcde') e2 = ev.Enumerate().map(lambda i, c: (i, i + ord(c))) e3 = ev.Star().pluck(1).map(chr) e1.pipe(e2, e3) # or: ev.Event.Pipe(e1, e2, e3) -> ['a', 'c', 'e', 'g', 'i'] Args: targets: One or more Events that have no source yet, or ``Event`` constructors that needs no arguments. )rcreater3)r targetssourcets r!pipez Event.pipes=$ A QA LL F  r#ct}|D]9}tj|}|j||j |;|S)a Fork this event into one or more target events. Square brackets can be used as a synonym:: import eventkit as ev ev.Range(2, 5)[ev.Min, ev.Max, ev.Sum].zip() -> [(2, 2, 2), (2, 3, 5), (2, 4, 9)] The events in the fork can be combined by one of the join methods of ``Fork``. Args: targets: One or more events that have no source yet, or ``Event`` constructors that need no arguments. )Forkrr\r3r9)r r]forkr_s r!rcz Event.forksE$v A QA LL  KKN  r#c||_yN)r)r r^s r!r3zEvent.set_source5s  r#c|jD]}|d|us dx|d<x|d<|d<|jDcgc] }|gdk7s |c}|_ycc}w)Nr rr@rArU)r r7r>rCs r!r8zEvent._onFinalize8s^KK 3DAw#~.22Q2$q'DG 3#'++IQ6H1HqI Is AAclt|tjrd|fSt|tjr|j|j fSt|tj r-t|jtur|j|fSd|fSt|dr|dfStd|)zC Split given callable in (object, function) tuple. N__call__zInvalid callable: ) r1types FunctionType MethodType__self____func__BuiltinMethodTypetyper5 ValueError)cs r!r4z Event._split>s a++ ,!9  5++ ,JJ + + 522 3AJJ4' A&ay Q #t9 1!56 6r# skip_to_lasttuplescKfd}fd}fd}|jrytj|j||| j d{\}}|s%|r|nt |dk(r|dn |r|nt n|dk(r|nK |j|||y7L#|j|||wxYww)a" Create an asynchronous iterator that yields the emitted values from this event:: async def coro(): async for args in event.aiter(): ... :meth:`__aiter__` is a synonym for :meth:`aiter` with default arguments, Args: skip_to_last: * ``True``: Backlogged source values are skipped over to yield only the latest value. Can be used as a slipper clutch between a source that produces too fast and the handling that can't keep up. * ``False``: All events are yielded. tuples: * ``True``: Always yield arguments as a tuple. * ``False``: Unpack single argument tuples. cr1jr!jjr!jd|fy)N)qsize get_nowait put_nowait)rOqrrs r!on_eventzEvent.aiter..on_eventjs3ggiLLNggi LL"d $r#c,jd|fy)NERRORry)r^rrzs r!on_errorzEvent.aiter..on_errorps LL'5) *r#c(jdy)N)DONENr~)r^rzs r!on_donezEvent.aiter..on_doness LL (r#Nr rr})rrJQueuer:getr,r rB) r rrrsr{rrwhatrOrzs ` @r!aiterz Event.aiterSs. %  + ) 99; 07  Xx1 9#$557] d"($Tad1g%)Tx8W_J OOHh 8+ OOHh 8s0A C B1"B/#7B1C /B11CC cDd|jd|jdS)NzEvent)rrr&s r!__repr__zEvent.__repr__s! }Bt{{m155r#c,t|jSre)r,rr&s r!__len__z Event.__len__s4;;r#cy)NTr&s r!__bool__zEvent.__bool__sr#c>t|ds|f}|j|S)N__iter__)r5rc)r fork_targetss r! __getitem__zEvent.__getitem__s$|Z0(?Ltyy,''r#cfdfdfd}jr tdtjj j |j S)aN Asynchronously await the next emit of an event:: async def coro(): args = await event ... If the event does an empty ``emit()``, then the value of ``args`` is set to ``util.NO_VALUE``. :meth:`wait` and :meth:`__await__` are each other's inverse. cjs-jt|dk(r|dn |r|ntyy)Nr r)r set_resultr,r )rOfuts r!r{z!Event.__await__..on_events588:"4yA~DG44XOr#cJjsj|yyre)r set_exception)r^rrs r!rz!Event.__await__..on_errors88:!!%(r#c*jyre)rB)frr{r s r!on_future_donez'Event.__await__..on_future_dones OOHh /r#zEvent already done)rrprJFuturer:add_done_callbackrG)r rrrr{s` @@@r!rGzEvent.__await__s^ O  ) 0 99;12 2nn Xx( n-}}r#cl|j|\tfd|jDS)z7 See if callable is already connected. c3hK|])}|duxs|dxr |duxr|du+yw)rr r@Nr).0rCr=r<s r! z%Event.__contains__..sK"qTS[ 2AaD2TQqTVs] D! D"s/2)r4anyr)r rqr=r<s @@r! __contains__zEvent.__contains__s4KKN T"[["" "r#cr|jduxs|jdu}|j|j|ffS)z% Don't pickle slots. N)rrrr)r with_error_done_events r! __reduce__zEvent.__reduce__s>   D ( GDOO4,G ~~ ,ABBBr# event_namesc>|D]}t||t|y)z Convenience function for initializing multiple events as members of the given object. Args: event_names: Names to use for the created events. N)setattrr)r<rrs r!initz Event.inits#  ,D CuT{ + ,r#ct|tr|St|dr|}t|tr|St|drtj|St|drtj |St d|)z Create an event from a async iterator, awaitable, or event constructor without arguments. Args: obj: The source object. If it's already an event then it is passed as-is. rh __aiter__rGzInvalid type: )r1rr5aiteratewaitrp)r<s r!r\z Event.createsv c5 !J 3 #%C c5 !J S+ &>>#& & S+ &::c? "~cU34 4r#futureWaitct|S)a Create a new event that emits the value of the awaitable when it becomes available and then set this event done. :meth:`wait` and :meth:`__await__` are each other's inverse. Args: future: Future to wait on. )r)rs r!rz Event.waitsF|r#aitAiteratect|S)a Create a new event that emits the yielded values from the asynchronous iterator. The asynchronous iterator serves as a source for both the time and value of emits. :meth:`aiterate` and :meth:`__aiter__` are each other's inverse. Args: ait: The asynchronous source iterator. It must ``await`` at least once; If necessary use:: await asyncio.sleep(0) )r)rs r!rzEvent.aiterate s"}r#rvaluesintervaltimesSequencect|||S)a| Create a new event that emits the given values. Supply at most one ``interval`` or ``times``. Args: values: The source values. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match ``values``. )r)rrrs r!sequencezEvent.sequences%00r#r Repeatct||||S)a Create a new event that repeats ``value`` a number of ``count`` times. Args: value: The value to emit. count: Number of times to emit. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match ``values``. )r)r.countrrs r!repeatz Event.repeat,shue44r#rrRangect|||dS)aW Create a new event that emits the values from a range. Args: args: Same as for built-in ``range``. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match the range. r)r)rrrOs r!rangez Event.range<sdXU;;r#ct|||S)a Create a new event that emits the datetime value, at that datetime, from a range of datetimes. Args: start: Start time, can be specified as: * ``datetime.datetime``. * ``datetime.time``: Today is used as date. * ``int`` or ``float``: Number of seconds relative to now. Values will be quantized to the given step. end: End time, can be specified as: * ``datetime.datetime``. * ``datetime.time``: Today is used as date. * ``None``: No end limit. step: Number of seconds, or ``datetime.timedelta``, to space between values. ) Timerange)startendsteps r! timerangezEvent.timerangeKs*T**r#rTimerct||S)a Create a new timer event that emits at regularly paced intervals the number of seconds since starting it. Args: interval: Time interval in seconds between emits. count: Number of times to emit, or ``None`` for no limit. )r)rrs r!timerz Event.timerbsXu%%r#rCMarblect|||S)az Create a new event that emits the values from a Rx-type marble string. Args: s: The string with characters that are emitted. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match the marble string. )r)rCrrs r!marblez Event.marblensa5))r#ct||S)z For every source value, apply predicate and re-emit when True. Args: predicate: The function to test every source value with. The default is to test the general truthiness with ``bool()``. )Filterr predicates r!filterz Event.filtersi&&r#Skipct||S)z Drop the first ``count`` values from source and follow the source after that. Args: count: Number of source values to drop. )rr rs r!skipz Event.skipsE4  r#Takect||S)z Re-emit first ``count`` values from the source and then end. Args: count: Number of source values to re-emit. )rrs r!takez Event.takesE4  r#ct||S)a  Re-emit values from the source until the predicate becomes False and then end. Args: predicate: The function to test every source value with. The default is to test the general truthiness with ``bool()``. ) TakeWhilers r! takewhilezEvent.takewhileD))r#c| Srer)xs r!zEvent.sEr#ct||S)a Drop source values until the predicate becomes False and after that re-emit everything from the source. Args: predicate: The function to test every source value with. The default is to test the inverted general truthiness. ) DropWhilers r! dropwhilezEvent.dropwhilerr#ct||S)z Re-emit values from the source until the ``notifier`` emits and then end. If the notifier ends without any emit then keep passing source values. Args: notifier: Event that signals to end this event. ) TakeUntil)r notifiers r! takeuntilzEvent.takeuntils4((r#ct||S)z On emit of the source emit a constant value:: emit(value) -> emit(constant) Args: constant: The constant value to emit. )Constant)r constants r!rzEvent.constants$''r#ct||S)av On emit of the source, emit the next value from an iterator:: emit(a, b, ...) -> emit(next(it)) The time of events follows the source and the values follow the iterator. Args: it: The source iterator to use for generating values. When the iterator is exhausted the event is set to be done. )Iterate)r its r!iteratez Event.iteratesr4  r#ct|||S)z Count and emit the number of source emits:: emit(a, b, ...) -> emit(count) Args: start: Start count. step: Add count by this amount for every new source value. )Countr rrs r!rz Event.countsUD$''r#ct|||S)z Add a count to every source value:: emit(a, b, ...) -> emit(count, a, b, ...) Args: start: Start count. step: Increase by this amount for every new source value. ) Enumeraters r! enumeratezEvent.enumeratesd++r#ct|S)z Add a timestamp (from time.time()) to every source value:: emit(a, b, ...) -> emit(timestamp, a, b, ...) The timestamp is the float number in seconds since the midnight Jan 1, 1970 epoch. ) Timestampr&s r! timestampzEvent.timestampsr#ct|d|iS)z Pad source values with extra arguments on the left:: emit(a, b, ...) -> emit(*left_args, a, b, ...) Args: left_args: Arguments to inject. r^)Partial)r left_argss r!partialz Event.partials /$//r#ct|d|iS)z Pad source values with extra arguments on the right:: emit(a, b, ...) -> emit(a, b, ..., *right_args) Args: right_args: Arguments to inject. r^) PartialRight)r right_argss r! partial_rightzEvent.partial_rightsZ555r#ct|S)z Unpack a source tuple into positional arguments, similar to the star operator:: emit((a, b, ...)) -> emit(a, b, ...) :meth:`star` and :meth:`pack` are each other's inverse. )Starr&s r!starz Event.starsDzr#ct|S)z Pack positional arguments into a tuple:: emit(a, b, ...) -> emit((a, b, ...)) :meth:`star` and :meth:`pack` are each other's inverse. )Packr&s r!packz Event.packsDzr# selectionsPluckct|d|iS)a Extract arguments or nested properties from the source values. Select which argument positions to keep:: emit(a, b, c, d).pluck(1, 2) -> emit(b, c) Re-order arguments:: emit(a, b, c).pluck(2, 1, 0) -> emit(c, b, a) To do an empty emit leave ``selections`` empty:: emit(a, b).pluck() -> emit() Select nested properties from positional arguments:: emit(person, account).pluck( '1.number', '0.address.street') -> emit(account.number, person.address.street) If no value can be extracted then ``NO_VALUE`` is emitted in its place. Args: selections: The values to extract. r^)r)r rs r!pluckz Event.pluck&s8j...r#c t|||||S)ao Apply a sync or async function to source values using positional arguments:: emit(a, b, ...) -> emit(func(a, b, ...)) or if ``func`` returns an awaitable then it will be awaited:: emit(a, b, ...) -> emit(await func(a, b, ...)) In case of timeout or other failure, ``NO_VALUE`` is emitted. Args: func: The function or coroutine constructor to apply. timeout: Timeout in seconds since coroutine is started ordered: * ``True``: The order of emitted results preserves the order of the source values. * ``False``: Results are in order of completion. task_limit: Max number of concurrent tasks, or None for no limit. ``timeout``, ``ordered`` and ``task_limit`` apply to async functions only. )Map)r r=timeoutordered task_limits r!mapz Event.mapDs64':t< new Event constr(a, b, ...) Args: constr: Constructor function for creating a new event. Apart from returning an ``Event``, the constructor may also return an awaitable or an asynchronous iterator, in which case an ``Event`` will be created. joiner: Join operator to combine the emits of nested events. )Emap)r constrjoiners r!emapz Event.emapasFFD))r#ct||S)as :meth:`emap` that uses :meth:`merge` to combine the nested events:: marbles = [ 'A B C D', '_1 2 3 4', '__K L M N'] ev.Range(3).mergemap(lambda v: ev.Marble(marbles[v])) -> ['A', '1', 'K', 'B', '2', 'L', '3', 'C', 'M', '4', 'D', 'N'] )Mergemapr rs r!mergemapzEvent.mergemapq%%r#ct||S)a :meth:`emap` that uses :meth:`concat` to combine the nested events:: marbles = [ 'A B C D', '_ 1 2 3 4', '__ K L M N'] ev.Range(3).concatmap(lambda v: ev.Marble(marbles[v])) -> ['A', 'B', '1', '2', '3', 'K', 'L', 'M', 'N'] ) Concatmaprs r! concatmapzEvent.concatmap&&r#ct||S)a :meth:`emap` that uses :meth:`chain` to combine the nested events:: marbles = [ 'A B C D ', '_ 1 2 3 4', '__ K L M N'] ev.Range(3).chainmap(lambda v: ev.Marble(marbles[v])) -> ['A', 'B', 'C', 'D', '1', '2', '3', '4', 'K', 'L', 'M', 'N'] )Chainmaprs r!chainmapzEvent.chainmaprr#ct||S)a :meth:`emap` that uses :meth:`switch` to combine the nested events:: marbles = [ 'A B C D ', '_ K L M N', '__ 1 2 3 4' ] ev.Range(3).switchmap(lambda v: Event.marble(marbles[v])) -> ['A', 'B', '1', '2', 'K', 'L', 'M', 'N']) ) Switchmaprs r! switchmapzEvent.switchmaprr#ct|||S)a Apply a two-argument reduction function to the previous reduction result and the current value and emit the new reduction result. Args: func: Reduction function:: emit(args) -> emit(func(prev_args, args)) initializer: First argument of first reduction:: first_result = func(initializer, first_value) If no initializer is given, then the first result is emitted on the second source emit. )Reduce)r r= initializers r!reducez Event.reduces"dK..r#ct|S)z Minimum value. )Minr&s r!minz Event.min4yr#ct|S)z Maximum value. )Maxr&s r!maxz Event.maxr,r#ct||S)zX Total sum. Args: start: Value added to total sum. )Sumr rs r!sumz Event.sums5$r#ct||S)zW Total product. Args: start: Initial start value. )Productr2s r!productz Event.productsud##r#ct|S)z Total average. )Meanr&s r!meanz Event.meanDzr#ct|S)zH Test if predicate holds for at least one source value. )rr&s r!rz Event.anyr,r#ct|S)z@ Test if predicate holds for all source values. )Allr&s r!allz Event.allr,r#nweightEmact|||S)z Exponential moving average. Args: n: Number of periods. weight: Weight of new value. Give either ``n`` or ``weight``. The relation is ``weight = 2 / (n + 1)``. )rA)r r?r@s r!emaz Event.emas1fd##r#Previousct||S)a For every source value, emit the ``count``-th previous value:: source: -ab---c--d-e- output: --a---b--c-d- Starts emitting on the ``count + 1``-th source emit. Args: count: Number of periods to go back. )rDrs r!previouszEvent.previousst$$r#ct|S)z Emit ``(previous_source_value, current_source_value)`` tuples. Starts emitting on the second source emit:: source: -a----b------c--------d----- output: ------(a,b)--(b,c)----(c,d)- )Pairwiser&s r!pairwisezEvent.pairwise s~r#ct|S)zT Emit only source values that have changed from the previous value. )Changesr&s r!changesz Event.changesst}r#ct||S)a1 Emit only unique values, dropping values that have already been emitted. Args: key: `The callable `'key(value)`` is used to group values. The default of ``None`` groups values by equality. The resulting group must be hashable. )Unique)r keys r!uniquez Event.uniquesc4  r#ct|S)zI Wait until source has ended and re-emit its last value. )Lastr&s r!lastz Event.last(r:r#ct|S)zR Collect all source values and emit as list when the source ends. )ListOpr&s r!rYz Event.list.d|r#ct||S)z Emit a ``deque`` with the last ``count`` values from the source (or less in the lead-in phase). Args: count: Number of last periods to use, or 0 to use all. )Dequers r!dequez Event.deque4UD!!r#ct||S)z Emit a numpy array with the last ``count`` values from the source (or less in the lead-in phase). Args: count: Number of last periods to use, or 0 to use all. )Arrayrs r!arrayz Event.array>rZr#sizeChunkct||S)z Chunk values up in lists of equal size. The last chunk can be shorter. Args: size: Chunk size. )r_)r r^s r!chunkz Event.chunkHsT4  r#r emit_empty ChunkWithct|||S)z Emit a chunked list of values when the timer emits. Args: timer: Event to use for timing the chunks. emit_empty: Emit empty list if no values present since last emit. )rc)r rrbs r! chunkwithzEvent.chunkwithQs D11r#ct|g|S)a Re-emit from a source until it ends, then move to the next source, Repeat until all sources have ended, ending the chain. Emits from pending sources are queued up:: source 1: -a----b---c| source 2: --2-----3--4| source 3: ------------x---------y--| output: -a----b---c2--3--4x---y--| Args: sources: Source events. )Chainr sourcess r!chainz Event.chain\sT$G$$r#ct|g|S)a> Re-emit everything from the source events:: source 1: -a----b-------------c------d-| source 2: ------1-----2------3--4-| source 3: --------x----y--| output: -a----b--1--x--2-y--c-3--4-d-| Args: sources: Source events. )Mergerhs r!mergez Event.mergemsT$G$$r#ct|g|S)ai Re-emit everything from one source until it ends and then move to the next source:: source 1: -a----b-----| source 2: --1-----2-----3----4--| source 3: -----------x--y--| output: -a----b---------3----4----x--y--| Args: sources: Source events. )Concatrhs r!concatz Event.concat{d%W%%r#ct|g|S)az Re-emit everything from one source and move to another source as soon as that other source starts to emit:: source 1: -a----b---c-----d---| source 2: -----------x---y-| source 3: ---------1----2----3-----| output: -a----b--1----2--x---y---| Args: sources: Source events. )Switchrhs r!switchz Event.switchrqr#ct|g|S)a Zip sources together: The i-th emit has the i-th value from each source as positional arguments. Only emits when each source has emtted its i-th value and ends when any source ends:: source 1: -a----b------------------c------d---e--f---| source 2: --------1-------2-------3---------4-----| output emit: --------(a,1)---(b,2)----(c,3)----(d,4)-| Args: sources: Source events. )Ziprhs r!zipz Event.zips4"'""r#)rr Ziplatestc t|g|d|iS)a$ Emit zipped values with the latest value from each of the source events. Emits every time when a source emits:: source 1: -a-------------------b-------c---| source 2: ---------------1--------------------2------| output emit: (a,NoValue)---(a,1)-(b,1)---(c,1)--(c,2)--| Args: sources: Source events. partial: * True: Use ``NoValue`` for sources that have not emitted yet. * False: Wait until all sources have emitted. r)rx)r rris r! ziplatestzEvent.ziplatests9999r#ct||S)a! Time-shift all source events by a delay:: source: -abc-d-e---f---| output: ---abc-d-e---f---| This applies to the source errors and the source done event as well. Args: delay: Time delay of all events (in seconds). )Delay)r delays r!r}z Event.delaysUD!!r#ct||S)z When the source doesn't emit for longer than the timeout period, do an empty emit and set this event as done. Args: timeout: Timeout value. )Timeout)r r s r!r z Event.timeoutsw%%r#ct||||S)a Limit number of emits per time without dropping values. Values that come in too fast are queued and re-emitted as soon as allowed by the limits. A nested ``status_event`` emits ``True`` when throttling starts and ``False`` when throttling ends. The limit can be dynamically changed with ``set_limit``. Args: maximum: Maximum payload per interval. interval: Time interval (in seconds). cost_func: The sum of ``cost_func(value)`` for every source value inside the ``interval`` that is to remain under the ``maximum``. The default is to count every source value as 1. )Throttle)r maximumr cost_funcs r!throttlezEvent.throttles(9d;;r#on_firstDebouncect|||S)a Filter out values from the source that happen in rapid succession. Args: delay: Maximal time difference (in seconds) between successive values before debouncing kicks in. on_first: * True: First value is send immediately and following values in the rapid succession are dropped:: source: -abcd----efg- output: -a-------e--- * False: Last value of a rapid succession is send after the delay and the values before that are dropped:: source: -abcd----efg-- output: ----d------g- )r)r r}rs r!debouncezEvent.debounces(x..r#ct|S)z= Create a shallow copy of the source values. )Copyr&s r!rIz Event.copyr:r#ct|S)z: Create a deep copy of the source values. )Deepcopyr&s r!deepcopyzEvent.deepcopys~r#ct||S)z At the times that the timer emits, sample the value from this event and emit the sample. Args: timer: Event used to time the samples. )Sample)r rs r!samplez Event.sample seT""r#ct|S)z. Emit errors from the source. )Errorsr&s r!errorsz Event.errorsrVr#ct|S)z3 End on any error from the source. ) EndOnErrorr&s r! end_on_errorzEvent.end_on_errors$r#)rvT)NNF)NN)r]r)r]rr$rb)FF)r$rb)rN)rNr )r$rre)r$r)r )r$r)r$r)rrr$r)r$r)r$r)rr )r$r)r$r)r$r)r$r)r$r)r$r)r$r)NTN)r$r )r AddableJoinOpr$r)r$r)r$r)r$r )r$r#)r$r&)r$r*)r$r.)r)r$r1)r$r5)r$r8)r$r)r$r=)r$rH)r$rK)r$rN)r$rR)r$rU)r$rX)r$r\)T)rirr$rg)r$rl)r$ro)r$rs)r$rv)r$r|)r$r)r$r)F)r$r)r$r)rrr$r)r$r)r$r)v__name__ __module__r__doc__ __slots__r logging getLoggerrMr__annotations__strAnyTyperboolr"rrr*r.r:rBrEr)rSrVrZr`rcr3r8 staticmethodr4r__iadd____isub__rh__or__rrrrrGrrrrrr\rrrrfloatr rrrrintrrrrrrrrrrrrrrrrrr rrrrr!r$r(r+r/r3r6r9rr>rCrFrIrLrPrSrYrYr]rarerjrmrprtrwrzr}r rrrIrrrrrr#r!rr s25IH W  x (F'""!! J O J K g S(c d':26!&55+25n40$ KD?4T4022J 77(2929d29hHHH F6 ( @I"C ,x , ,55. Y 6  m $0126 1 1(- 1%$./ 1;E 1 1!q26 5/4 5%$./ 5;C 5 5%&26 <" <%$./ <;B < <++, & &eCI&6 &' & &&'26 * *# *%$./ *;C * *" $'!#!f!!#!f!#' *#2 * ) ( ! ( ,  0 6 /sCx/W/>/3= %=:* & ' & '(0/&   $   )-)- $U39% $%+& $27 $ %c %* % !  ""!#!'!6: 2  2.2 2>I 2%" % & &# 37:4:;:" "&04<8B<,///,  #  r#r) r=rrrXrArr.r8r*rHr5r&r1) r\ArrayAllArrayAnyArrayMax ArrayMeanArrayMin ArrayProdArrayStdArraySum)rrgrorbrlrsrvrx)rrrrrrrr)rr)r2) rKrrrRrrrrrN)rr|rrr)r r_rcrrrrrrrr rrrrrrDrr#r)frJrrir6typingrrrrrrrr r utilr r rr ops.aggregater=rrXrArUr.r8r*rHr5r&r1 ops.arrayr\rrrrrrrr ops.combinerrgrorbrlrsrvrx ops.createrrrrrrrrops.miscrrops.opr2 ops.selectrKrrrRrrrrrN ops.timingrr|rrr ops.transformr r_rcrrrrrrrr rrrrrrDrr#rrr#r!rs <;R R j(GGGGGG(PPP00******r#