tj? ddlZddlZddlZddlmZddlmZddlmZm Z m Z ddl m Z m Z mZmZddlmZddlmZej(eZd gZd ZGd d ZGd dZGddZGddZGdd Zy)N)deque)contextmanager)AnyIterableIterator) asynchronous is_dunder is_privateshare)reload) TranslatorStatez*__trame__: non_init_value_that_is_not_NonecNeZdZdZd dedefdZdZedefdZe dZ y ) StateStatusz* Tracks status flags for a State. flushingreadyc ||_||_yNrr)selfrrs ?/DATA/.local/lib/python3.12/site-packages/trame_server/state.py__init__zStateStatus.__init__s   cd|_y)NTrrs r mark_readyzStateStatus.mark_readys  rreturnc8|jxs |j Srrrs r skip_flushingzStateStatus.skip_flushing!s}}.DJJ.rc#JKd|_ dd|_y#d|_wxYww)z*Context manager for flushing state safely.TNF)rrs rflushing_contextzStateStatus.flushing_context%s%  " !DMEDMs## #N)FF) __name__ __module__ __qualname____doc__boolrrpropertyr!rr#rrrrsNd/t//""rrceZdZdZdeddfdZdefdZdedefdZde efd Z deddfd Z dd Z deddfd Z d eeddfdZy) _OrderedSetz} Lightweight ordered set implementation based on dict to preserve insertion order without external dependencies. argsrNcBi|_|D]}|j|yr)_dataadd)rr-args rrz_OrderedSet.__init__5s&( C HHSMrc,t|jSr)r(r/rs r__bool__z_OrderedSet.__bool__:DJJrkeyc||jvSrr/rr5s r __contains__z_OrderedSet.__contains__=sdjj  rc,t|jSr)iterr/rs r__iter__z_OrderedSet.__iter__@r4rc"d|j|<yrr7r8s rr0z_OrderedSet.addCs 3rc8|jjyr)r/clearrs rr?z_OrderedSet.clearFs rc<|jj|dyr)r/popr8s rdiscardz_OrderedSet.discardIs sD!riterablec4|D]}|j|yrr0)rrCitems rupdatez_OrderedSet.updateLsD HHTNrrN)r$r%r&r'rrr(r3r9rr<r0r?rBrrGr*rrr,r,/s cd  $ !!! (3- st"3"4"x}rr,c*eZdZdZdZdZdZdZy)StateChangeHandlerc0||_t|_yr)_all_listenersr, _currents)r listenerss rrzStateChangeHandler.__init__Rs'$rc||jvr0|j|D]}|jj|yyr)rLrMr0)rr5callbacks rr0zStateChangeHandler.addVs< $%% % //4""8,5 &rc4|D]}|j|yrrE)rkeysr5s radd_allzStateChangeHandler.add_all[sC HHSMrc8|jjyr)rMr?rs rr?zStateChangeHandler.clear_s rc>tt|jSr)r;listrMrs rr<zStateChangeHandler.__iter__bsD())rN)r$r%r&rr0rSr?r<r*rrrJrJQs'- *rrJczeZdZdZdZdeddfdZdeddfdZdeddfd Zdd Z dd Z de fd Z dede fd ZddZy)_SuppressListenersChangeStackzW Helper class to handle change listener keys to suppress and which to trigger. cNt|_d|_t|_yr)r_deque_suppressed_keysr,_listener_keysrs rrz&_SuppressListenersChangeStack.__init__ks*/' 48+6=rr5rNc^|j|s|jj|yyr)_is_suppressedr\r0r8s ron_pending_key_addedz2_SuppressListenersChangeStack.on_pending_key_addedps)""3'    # #C ((rc:|jj|yr)r\rBr8s ron_pending_key_removedz4_SuppressListenersChangeStack.on_pending_key_removedts ##C(rrRcf|jjt||jyr)rZappendr,_update_suppressed_keysrrRs rpushz"_SuppressListenersChangeStack.pushws% ;-. $$&rcr|jsy|jj|jyr)rZrArdrs rrAz!_SuppressListenersChangeStack.pop{s&{{   $$&rc"t|_yr)r,r\rs rr?z#_SuppressListenersChangeStack.clears )mrc|jSr)r\rs rget_change_listener_keysz6_SuppressListenersChangeStack.get_change_listener_keyss"""rcR|jy|jsy||jvS)NFT)r[r8s rr^z,_SuppressListenersChangeStack._is_suppresseds.  ($$d++++rc|jsd|_yt|_|jD];}|s|jjy|jj |=y)aI Updates the suppressed keys set. If the stack is empty, the suppressed keys will be reset to None. If the stack contains one empty set (catch all) the suppressed set will be updated to an empty set (catch all). Otherwise, the suppressed keys will represent the union of the stack's sets. N)rZr[r,r?rG)rd_sets rrdz5_SuppressListenersChangeStack._update_suppressed_keyssZ{{$(D !  + [[E%%++-  ! ! ( ( / !rrH)r$r%r&r'rstrr_rarfrAr?r,rjr(r^rdr*rrrXrXfss9 ))))#)$)'#'$'',#+#,#,$,0rrXceZdZdZ ddZedefdZedefdZ ddZ dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZdZedZdeefdZdZedZdZdZdZ e!defdZ"y) rz Flexible dictionary managing a server shared state. Variables can be accessed with either the `[]` or `.` notation. :examples: >>> with state: ... state.a = 1 ... state.b = 2 ... # state is flushed() Nc||_||_|r|n t|_t |dt |_t |di|_t |di|_t |di|_ t |dt|j|_ t |dt||_ ||_g|_|r|jj!|t#|_y)N_modified_keys_change_callbacks_pending_update _pushed_state_state_listeners_statusr)_push_state_fn _hot_reloadr _translatorr setrqrrrsrtrJrurrv _parent_state_children_statercrX_suppress_change_stack)r translatorinternal commit_fn hot_reloadrs rrzState.__init__s(%)3:#H.>F!&x1Db!I$X/@"E"8_bA % (*|jj|}||jvrJ||j|k(r8|jj |d|j j |y||j|<|j j|yr)ryrrtrsrAr}rar_rr5values r __setitem__zState.__setitem__s,,S1 $$$ $**3//$$((d3++BB3G$)S! ##88=rct|rtt|St|r|jj |S|j |Sr)r getattrobjectr __dict__rrr8s r __getattr__zState.__getattr__sC S>63' ' c?==$$S) )$$rc^t|r||j|<y|j||yr)r rrrs r __setattr__zState.__setattr__s' c?!&DMM#    S% (rc:|jj|}d}g|jjdg|jjdg}|D]}||vs|j ||dz }|r ||jd<|j yy)at Tag a given set of variable name(s) to be client only. This means that when they get changed on the client side, the server will not be aware of their change and no network bandwidth will be used to maintain the server in sync with the client state. :param *_args: A list a variable name :type *_args: str rtrame__client_onlyrN)rytranslate_listrsrrtrcr)r_argschange_detected full_listnames r client_onlyzState.client_onlys  //6  ! ! % %&:B ?    # #$8" = D9$  &1$ 9BD !5 6 JJL rc:|j|jS)zq Flush current state modification and return the resulting state state as a python dict. )rrtrs rto_dictz State.to_dicts !!!rc|jj|}||jvxs||jv}tj d||||S)z2Check is a key is currently available in the statezhas(%s => %s) = %s)ryrrtrsloggerinfo)rr5_keyresults rhasz State.hassP--c2+++Ktt7K7K/K (#tV< rc|jj|}||jvr|j|S|jj ||S)z~ Set an initial value if the key is not present yet :returns the value in the state for the given key )ryrrtrs setdefaultrs rrzState.setdefault#sR ,,S1 $$$ $%%c* *##..sE::rch|jj|}|D]}||jvsyy)zu Check if any provided key name(s) still has a pending changed that will need to be flushed. TF)ryrrs)rrrs ris_dirtyzState.is_dirty-s:   //6Dt+++rcd}|jj|}|D]}||jvs|dz }|t|k(S)zo Check if all provided key name(s) has a pending changed that will need to be flushed. rr)ryrrslen)rrcountrs r is_dirty_allzState.is_dirty_all9sQ   //6Dt+++ E ""rc|jj|}|D]R}|jj||jj ||j j|Ty)z Mark existing variable name(s) to be modified in a way that they will be pushed again at flush time. Note that the variable(s) will be unmarked automatically when reset to its previous value. N)ryrrsrrtrr}r_rrr5s rdirtyz State.dirtyFs_  //6C  + +C1C1C1G1G1L M  ' ' < *>*B*B3*G""3'++BB3Grcp|jj|}|jj||D]{}|||jj |t k(r8|jj|d|jj|a|jj|}y)z3Update the current state dict with the provided oneN) rytranslate_dictrsrGrtrTRAME_NON_INIT_VALUErAr}rar_)r_dictr5s rrGz State.update_s  //6 ##E*CSzT//33C9MNN$$((d3++BB3G++@@E rc|jS)a Return the set of state's keys that are modified for the current state.change update. Usage example: -------------- >>> NAMES = ["a", "b", "c"] >>> state.update({"a": 1, "b": 2, "c": 3}) >>> @state.change(*NAMES) ... def on_change(*_): ... for name in state.modified_keys: ... print(f"{name} value updated to {state[name]}") >>> with state: ... state.a += 1 >>> with state: ... state.a += 1 ... state.b += 2 >>> with state: ... state.a += 1 ... state.b += 2 ... state.c += 3 )rqrs r modified_keyszState.modified_keysjs>"""rct|jj}|jj |xj|zc_|j r|j |j|j j|j|jj |jj|jj|jj |jD]\}}t|tjr |}|*|}|jr t!j"|s t%|}|j'|j }|di|}t!j(|st+j,||jj |S)Nr*)rzrsrRrqr?rwrtrGrurSr}rj isinstanceweakref WeakMethodrxinspectiscoroutinefunctionr reverse_translate_dict isawaitabler create_task)r_keysfnr~rPreverse_translated_state coroutines r_flush_pending_keyszState._flush_pending_keyssD((--/0 !!# u$       4 4 5 !!$"6"67 ""$ %%  ' ' @ @ B ##))+"33NB "g0014#228<%h/H'1'H'H""( $!<#;BBc|jj|j|jj|jS)z3Return the initial state without triggering a flush)rtrGrsr?rs rinitialz State.initials< !!$"6"67 ""$!!!rc|Srr*rs r __enter__zState.__enter__s rc$|jyr)r)rexc_type exc_value exc_tracebacks r__exit__zState.__exit__s  rcfd}|S)a Use as decorator `@server.change(key1, key2, ...)` so the decorated function will be called like so `_fn(**state)` when any of the listed key name is getting modified from either client or server. Can also be used as a function to decorate method functions (see 2nd example below) :param *_args: A list of variable name to monitor :type *_args: str :examples: >>> @state.change("a", "b") # for functions ... def on_change(a, b, **kwargs): ... pass >>> state.change("a")(self.on_a_change) # for methods :see-also TrameApp cD]d}jj|}|jvrgj|<j|j|jff|Sr)ryrrrrc)funcnrrrs rregister_change_callbackz.State.change..register_change_callbacksl''55a8t55535D**40&&t,33T4;K;K4LM  Krr*)rr_kwargsrs`` rchangez State.changes( ('rrRc'K|jj|Dcgc]}|jj|c} d|jj ycc}w#|jj wxYww)a Suppresses input keys from triggering a state.change callback event in the scope of the context manager. Suppression only impacts the server and any state changed will be properly sent to the client. If called without arguments, suppress_change_listeners will suppress all listener changes in its scope. When used in a child state, the input key should be the untranslated state key. N)r}rfr~rrA)rrRks rsuppress_change_listenerszState.suppress_change_listenersss )##((8< =1doo++A. =  .   ' ' + + - >  ' ' + + -s'B"A#BA( B(BB)NNNFFrH)#r$r%r&r'rr)r(rrr~rrrrrrrrrrrrrrGrrzrnrrrrrrrrr*rrrrs  F4"$"" J  J >%) 4";  # B H F##@)SX)V""" (>.s..r)rloggingr collectionsr contextlibrtypingrrrutilsr r r r utils.hot_reloadr utils.namespacer getLoggerr$r__all__rrr,rJrXrr*rrrs%**==$'   8 $  D""4D***9090xe.e.r