jcF\UdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z  ddl m Zn #e$rdZYnwxYweeeeddndZd Zd Zd Zd Zdad ed<dadad6dZGddZGddZGddZd7dZd8d$Z d9d(Z!dd)dddd*d:d4Z"gd5Z#dS);uThe delivery discipline of a timed pointer plan, apart from any clock. ⛔ WHY THIS IS ITS OWN MODULE. The rules below - absolute deadlines from one ``t0``, drop rather than send late, never two events in one instant - used to live welded into an ``async`` loop in :mod:`._cursor`, which is the only place that could run them. That made them unavailable to the one other place that moves a pointer: the drag, inside the in-process Juggler server, which is synchronous. A drag therefore moved with no discipline at all - two events, both at the destination - and the alternative was to write the rules a second time in synchronous form. So the rules live here, as a state machine with no clock of its own, and the two callers supply the clock and the sleeping. :class:`Pacer` decides WHAT happens next; a driver decides HOW to wait. There is one definition of the discipline and two ways of obeying it, rather than two definitions that agree until one of them is edited. ) annotationsN)AnyIterableListOptionalTuple)_motionSAMPLE_FLOOR_MSg @INVPW_CURSOR_TIMERsleepemitdoner_winmmFreturncvtrtSdatjt pddvrdStj dsdS ddl }| dan#ttf$rdaYnwxYwtS)NT)off0falsewinrwinmm) _winmm_triedrosenvironget TIMER_ENVstriplowersysplatform startswithctypesWinDLLOSError ImportError)r#s MC:\Projects\Historical\venv\Lib\site-packages\invisible_playwright/_pacing.py_timer_resolution_availabler(Bs L y!!'R..006688r*cDeZdZdZdZ dddZeddZddZdS)Evz#One dispatchable instant of a plan.)t_msxykinddxdymoverAfloatrBrCrDstrrErFrr5ct||_t||_t||_||_t||_t||_dSN)rIrArBrCrDrErF)r1rArBrCrDrErFs r'__init__z Ev.__init__{sN$KK qq ))))r>boolc|jdkS)Nwheel)rDr1s r'is_wheelz Ev.is_wheelsyG##r>c<d|j|j|j|jfzS)NzEv(%.1f, %.1f, %.1f, %s))rArBrCrDrQs r'__repr__z Ev.__repr__s)TY ,RRRr>N)rGrHrH)rArIrBrIrCrIrDrJrErIrFrIrr5)rrN)rrJ) r9r:r;r< __slots__rMpropertyrRrTr=r>r'r@r@vsx--6IDJ.1$$$X$SSSSSSr>r@c\eZdZdZdZdZdZdZdeddddZ ddZ ddZ d dZ d!dZ d!dZdS)"Paceru Walk a timeline against ABSOLUTE deadlines, deciding only WHAT is next. Every deadline is measured from one ``t0`` - the clock reading handed to the first :meth:`step` - so oversleeping on one event does not push the next one out: lateness cannot accumulate. When the platform cannot deliver an event on time - Windows quantises a short sleep to the system timer, so a 12 ms request routinely returns after 16 - the event is DROPPED rather than sent late: an event is skipped when the NEXT event is already due, because sending it then would be sending two events at one instant and would push the whole rest of the movement backwards. What survives is a stream whose timestamps still land where the plan put them. ⛔ BUT ONLY WHILE THE DROP STAYS SMALL IN SPACE. A dropped event hands its distance to the next one that goes out, and that rule alone had no ceiling: on a loaded machine nearly every point was overtaken, the destination survived, and one event carried 89% of an 820 px journey with a timestamp exactly where the plan put it - a plausible rhythm wrapped around a jump no device makes. So an event may be dropped only if the event AFTER it lies within REACH of the last position actually sent, where reach is twice the plan's largest step: the one overslept sample the timer case produces merges two steps into one, and that is what is allowed. Beyond it the event is sent late instead, still no closer to the previous one than the floor, and the plan overruns its budget by however much the machine is behind. A hand that is slowed down is a hand; a hand that teleports is not. [B214] The last event is never dropped (it is where the movement ends) and neither is a wheel notch (it carries a delta nobody else will send). ``origin`` is where the pointer is before the first event: the reach of the first drops is measured from there, and without it from the first event of the plan. Usage, from either a synchronous or an asynchronous driver:: pacer = Pacer(evs) while True: what, arg = pacer.step(clock()) if what == DONE: break if what == SLEEP: sleep(arg) elif emitter_for(arg) is None: pacer.dropped() # nothing can carry this one else: emit(arg) pacer.emitted(clock()) deadlinegapr) _evs _emit_last_min_gap_i_phase_t0 _last_emit_ref_reach deliveredTN) emit_last min_gap_msoriginevs Iterable[Ev]rerNrfrIrgOptional[Tuple[float, float]]rr5c t||_||_t|dz |_d|_|j|_d|_d|_ |*t|dt|dfn,|jr$|jdj |jdj fnd|_ dtdt|j|jddDdz|_d|_dS)N@@rr g@c3hK|]-\}}t|j|j|j|jV.dSrL) _distancerBrC).0abs r' z!Pacer.__init__..sP 8 8AqsACac * * 8 8 8 8 8 8r>rH)default)listr[r\rIr]r^ _DEADLINEr_r`rarBrCrbmaxziprcrd)r1rhrerfrgs r'rMzPacer.__init__s#3ii #j))F2 n $(+/5;4FU6!9  uVAY// 0 06:iI49Q<>49Q<>22T C 8 8TY !"" 66 8 8 8ADFFFF r>iintc|j|}|t|jdz ks|jrdS|j|dz}|jdSt |jd|jd|j|j|jdzkS)z?May event *i* be skipped, handing its distance to the next one?r FNTrg& .>)r[lenrRrbrnrBrCrc)r1rxevnxts r' _droppablezPacer._droppables Yq\ DI" " "bk "5iA 9 41ty|SUCEBB{T!" "r>nowTuple[str, Any]c|j||_t|j}|j|krV|j|j}|j|dz k}||j}|j|jkr|j|jdz z|z }|dkr|j|_t|fS|rL|jdz|kr>||j|j|jdzjdz zkr| |j|_|j|jkrX|j E|j ||j z z }|dkr-|r| '|j |_t|fS|j |_|r|js||_n t|fSt dfS)zWhat to do at *now*: ``(SLEEP, seconds)``, ``(EMIT, ev)`` or ``(DONE, None)``. After ``(EMIT, ev)`` the driver must report back with :meth:`emitted` or :meth:`dropped` before stepping again. Nr rlr)r`r{r[r^r~r_rurA_GAPSLEEP_advancerar]_EMITr\EMITDONE)r1rnr|last droppablewaitbehinds r'stepz Pacer.steps 8 DH  NNgkk47#B7a!e#D00I{dn,,x"'F"22S8!88#')DK!4=($'A+//48di! .D.IF.R#RRRMMOOO"i {di'' ?.!]cDO.CDFzz$% MMOOO$&*j %v."j  DO ": d|r>c|xjdz c_||_|j|j}|j|jf|_|dS)z4The event :meth:`step` handed out went out at *now*.r N)rdrar[r^rBrCrbr)r1rr|s r'emittedz Pacer.emittedsG ! Ytw T24L  r>c.|dS)zThe event :meth:`step` handed out could not be carried. It leaves ``_last_emit`` alone deliberately: nothing was sent, so nothing has to be spaced away from it. N)rrQs r'droppedz Pacer.dropped&s r>c>|xjdz c_|j|_dS)Nr )r^rur_rQs r'rzPacer._advance.s 1 n r>) rhrirerNrfrIrgrjrr5)rxryrrN)rrIrr)rrIrr5)rr5)r9r:r;r<rurrrUMIN_EVENT_INTERVAL_MSrMr~rrrrr=r>r'rXrXs..fI D E>I@D%:9=0 " " " "0000d%%%%%%r>rXx0rIy0x1y1c*||z dz||z dzzdzS)Ng?r=)rrrrs r'rnrn3s" "WNb2g!^ + 33r>rBrCwOptional[float]hTuple[float, float]c|r|s||fStt|dt|dz tt|dt|dz fS)uKeep a waypoint somewhere an event can actually land. ⛔ NOT A TIDINESS MEASURE. A pointer event outside the viewport is not merely ignored: the browser parks the cursor at the origin, so one waypoint off the edge teleports the pointer to (0, 0) in the middle of a movement. A curved path near an edge goes outside on its own, without the caller aiming anywhere strange. Unknown size means unknown, so nothing is clamped: guessing a viewport would move points that were fine. The endpoint is the caller's to emit unclamped - it is where the movement has to end - so callers apply this to the waypoints and not to the destination. rHg?)minrvrI)rBrCrrs r'clamp_to_viewportr7sd" A!t  C3KKqC(( C3KKqC(( r>rhList[Ev]budget_scp|sgS|dj}|dkr&||dzkr|dz|z }|D]}|xj|zc_g}t }t|D]\}}|r0|js)|djs|j|djkr||d<7|t |dz k}|jp|p|j|z tk} | sl|rT|rR|jsK|djs>|j|z tkr+||r |djnt }|||j}|S)aFit a timeline inside ``budget_s`` and inside what hardware can report. Two rules, in this order: * if the plan is longer than the budget, every timestamp is scaled - the same movement performed faster, not a movement that stops half way; * events closer together than :data:`MIN_EVENT_INTERVAL_MS` are then DROPPED, not squeezed. Scaling alone is what produced impossible event rates: the waypoint count never changed, so a tighter cap simply meant more events per second, without limit. The last event of the timeline and every wheel notch survive regardless - the first is where the movement has to end, the second carries a delta that would be lost. rrlr )rAr enumeraterRr{popappend) rhrtotalscaler|outlast_trxis_lastkeeps r' fit_timelinerPs  GLE!||6 111F"e+  B GGu GGGC# #F32  r{ 3r7+; Gs2w|++CG s3xx!|# K 9 9w#88     Es E2; Es2w7G E\^\cfl\lpE]E]E GGIII%(DSW\\/D.DF 2 Jr>T) emit_wheelrerr rgri emit_moverrerNrrgrjrycBt|}|sdS||n tj}||n tj}t |||} t 5 | |\} } | tkrn| tkr || D| j r.|| b|| j | j n|| j | j| | dddn #1swxYwY| jS)a*The SYNCHRONOUS driver of :class:`Pacer`. Returns events sent. The asynchronous one lives in :mod:`._cursor`, because it has to ``await`` both the sleep and the emit. This one exists for the in-process Juggler server, whose ops are ordinary blocking calls; the decisions are the pacer's in both cases. ``now`` and ``sleep`` are injectable so a test can drive a whole timeline without waiting for it. ``origin`` is where the pointer is before the plan starts, the reference for the pacer's reach until something is sent. rN)rerg)rttime perf_counterr rXr*rrrrRrrErFrBrCrrd) rhrrrerr rgclockrpacerwhatargs r'driverso s))C q?CC(9E%554:D #6 : : :E ## # 5577++ID#t||u}}S | (%MMOOO 3636**** #%''' MM%%'' " " " # ############### ?sB.DDD) rrr@rrXrrrrrr*)rr) rrIrrIrrIrrIrrI) rBrIrCrIrrrrrr)rhrrrIrr)rhrirrrrrerNrrr rrgrjrry)$r< __future__rrr rtypingrrrrrrr _motion_mod ExceptionrIgetattrrrrrrr__annotations__rr.r(r*r@rXrnrrr__all__r=r>r'rs2"#""""" 77777777777777(((((((KKK E''+0# 6 6777$' !      $DSSSSSSSS0b%b%b%b%b%b%b%b%J444420000fCG T26$$$$$$N   s ,66