BPc)dZddlZddlZddlmZmZddlmZddlmZm Z ddl m Z m Z GddZ Gd d Zd Zd Zd ZddZdZdZdS)aConvienience library for concurrency GUI apps frequently need concurrency, for example to avoid blocking UI while doing some long running computation. This module provides helpers for doing this kind of thing. The functions/methods here which spawn callables asynchronously don't supply a direct way to provide arguments. Instead, the user is expected to use a lambda, e.g:: holding(lck, lambda: do_stuff(1,2,3, x='hello')) This is because the calling function may have additional arguments which could obscure the user's ability to pass arguments expected by the called function. For example, in the call:: holding(lck, lambda: run_task(blocking=True), blocking=False) the blocking argument to holding might otherwise conflict with the blocking argument to run_task. N)datetime timedeltawraps)AnyTuple)GdkGLibc6eZdZdZdZdZdZdZdZdZ dS) Futurea-A deferred result A `Future` is a result-to-be; it can be used to deliver a result asynchronously. Typical usage: >>> def background_task(task): ... ret = Future() ... def _task(x): ... return x - 4 + 2 ... thread = threading.Thread(target=lambda: ret.run(lambda: _task(7))) ... thread.start() ... return ret >>> # Do other stuff >>> print(ret.wait()) 5 :func:`run` will also propogate exceptions; see it's docstring for details. ctj|_d|_d|_|jdSN) threadingLock_lock_value _exceptionacquireselfs 3/usr/share/inkscape/extensions/inkex/gui/asyncme.py__init__zFuture.__init__Cs9^%%   cp|jd}|r|j|S)z"Return whether the result is readyF)rrrelease)rresults ris_readyzFuture.is_readyIs8##E**  ! J    rcn|j5|j|jcdddS|j#1swxYwYdS)aWait for the result. `wait` blocks until the result is ready (either :func:`result` or :func:`exception` has been called), and then returns it (in the case of :func:`result`), or raises it (in the case of :func:`exception`). N)rrrrs rwaitz Future.waitPsZ & &&{ & & & & & & & &o%  & & & & & & & & & &s**..cF||_|jdS)zSupply the result as a return value. ``value`` is the result to supply; it will be returned when :func:`wait` is called. N)rrrrvalues rrz Future.result]s%   rcF||_|jdS)zSupply an exception as the result. Args: err (Exception): an exception, which will be raised when :func:`wait` is called. N)rrr)rerrs r exceptionzFuture.exceptionfs% rc ||dS#t$r }||Yd}~dSd}~wwxYw)zCalls task(), and supplies the result. If ``task`` raises an exception, pass it to :func:`exception`. Otherwise, pass the return value to :func:`result`. N)r Exceptionr%)rtaskr$s rrunz Future.runpsh  KK        NN3          s! A AA N) __name__ __module__ __qualname____doc__rrrrr%r)rrr r /sx&  & & &      rr cPeZdZdZd dZdZd deeeffdZ dZ d Z d Z d S)DebouncedSyncVara(A synchronized variable, which debounces its value :class:`DebouncedSyncVar` supports three operations: put, replace, and get. get will only retrieve a value once it has "settled," i.e. at least a certain amount of time has passed since the last time the value was modified. rctj|_t||_d|_d|_d|_dS)z?Create a new dsv with the supplied delay, and no initial value.secondsNF)r Condition_cvr_delay _deadliner _have_valuer delay_secondss rrzDebouncedSyncVar.__init__s@&(( 666   rcp|j5t||_ddddS#1swxYwYdS)z)Set the delay in seconds of the debounce.r2N)r5rr6r9s r set_delayzDebouncedSyncVar.set_delays X ; ;#M:::DK ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; +//Treturnc |j5|js1|r|jn ddddS|j1tj}|j}|j}||kr9|rd|_d|_|j|dfcdddS dddn #1swxYwY|r*tj ||z ndS)aRetrieve a value. Args: blocking (bool, optional): if True, block until (1) the dsv has a value and (2) the value has been unchanged for an amount of time greater than or equal to the dsv's delay. Otherwise, if these conditions are not met, return ``(None, False)`` immediately. Defaults to True. remove (bool, optional): if True, remove the value when returning it. Otherwise, leave it where it is.. Defaults to True. Returns: Tuple[Any, bool]: Tuple (value, ok). ``value`` is the value of the variable (if successful, see above), and ok indicates whether or not a value was successfully retrieved. TN)NFF) r5r8rrnowr7rnotifytimesleep total_seconds)rblockingremover@deadliner"s rgetzDebouncedSyncVar.gets|  # ' '*++ * ' ' ' ' ' ' ' '*+ lnn> s??++0(&* HOO%%% $;) ' ' ' ' ' ' ' '# ' ' ' ' ' ' ' ' ' ' ' ' ' ' '. # HsN99;;<<<<"{7 #s%B/AB//B36B3cp|j5||ddddS#1swxYwYdS)a<Replace the current value of the dsv (if any) with ``value``. replace never blocks (except briefly to aquire the lock). It does not wait for any unit of time to pass (though it does reset the timer on completion), nor does it wait for the dsv's value to appear or disappear. N)r5_replacer!s rreplacezDebouncedSyncVar.replacesX ! ! MM%  ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !r=c|j5|jr |j|j ||ddddS#1swxYwYdS)zSet the dsv's value to ``value``. If the dsv already has a value, this blocks until the value is removed. Upon completion, this resets the timer. N)r5r8rrJr!s rputzDebouncedSyncVar.puts X ! !"  " MM%  ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !s=AAAcd|_||_tj|jz|_|jdS)NT)r8rrr@r6r7r5rAr!s rrJzDebouncedSyncVar._replaces= !$+5 rN)r)TT) r*r+r,r-rr<rrboolrHrKrMrJr.rrr0r0|s!!!!;;; +#+#sDy1A+#+#+#+#Z ! ! ! ! ! !rr0cXtj|}||S)zjCall ``func()`` in a separate thread Returns the corresponding :class:`threading.Thread` object. target)rThreadstart)functhreads r spawn_threadrWs)  T * * *F LLNNN Mrc^tfd}tjd|dS)auRun f() in the gtk main loop Returns a :class:`Future` object which can be used to retrieve the return value of the function call. :func:`in_mainloop` exists because Gtk isn't threadsafe, and therefore cannot be manipulated except in the thread running the Gtk main loop. :func:`in_mainloop` can be used by other threads to manipulate Gtk safely. c2dS)z#Function to be called in the futureN)r))_args_kwargsrUfutures rhandlerzin_mainloop..handlers 4rrN)r r threads_add_idle)rUr]r\s` @r in_mainloopr_sIXXFGT*** Mrc<tfd}|S)aA decorator which forces a function to only be run in Gtk's main loop. Invoking a decorated function as ``f(*args, **kwargs)`` is equivalent to using the undecorated function (from a thread other than the one running the Gtk main loop) as:: in_mainloop(lambda: f(*args, **kwargs)).wait() :func:`mainloop_only` should be used to decorate functions which are unsafe to run outside of the Gtk main loop. ctjriStfdS)NciSrr.)argsfkwargssrz0mainloop_only..wrapper..s11d#5f#5#5r)r main_depthr_r)rcrerds``rwrapperzmainloop_only..wrapper sT ?   &1d%f%% %55555566;;===rr)rdrhs` r mainloop_onlyris5 1XX>>>>X> NrTcdsdStfd}tj|S)aRun task() while holding ``lock``. Args: blocking (bool, optional): if True, wait for the lock before running. Otherwise, if the lock is busy, return None immediately, and don't spawn `task`. Defaults to True. Returns: Union[Future, None]: The return value is a future which can be used to retrieve the result of running task (or None if the task was not run). FNcjrdSr)r)rrr)lockretr(sr_targetzholding.._target#s:  >  HHJJJ rrQ)rr rrSrT)rlr(rErnrms`` @rholdingross <<  t ((C G$$$**,,, Jrc<tjfd}|S)zA decorator which runs the function using :func:`holding` This function creates a single lock for this function and waits for the lock to release before returning. See :func:`holding` above, with ``blocking=True`` c6tfddS)NciSrr.rcrUresrrfz-run_or_wait.._inner..8TT4%:6%:%:rTrErorcrerUrls``r_innerzrun_or_wait.._inner7s*t::::::TJJJJrrrrUrxrls` @r run_or_waitr{-s> >  DKKKKKK Mrc<tjfd}|S)zA decorator which runs the function using :func:`holding` This function creates a single lock for this function and returns None if the process is already running (locked) See :func:`holding` above with ``blocking=True`` c6tfddS)NciSrr.rssrrfz-run_or_none.._inner..HrtrFrurvrws``rrxzrun_or_none.._innerGs*t::::::UKKKKrryrzs` @r run_or_noner=s> >  DLLLLLL Mr)T)r-rBrrr functoolsrtypingrr gi.repositoryr r r r0rWr_riror{rr.rrrsK"* ((((((((########J J J J J J J J Z________D(.4        r