o ˜¸@a"ã@sâdZddlmZe ¡ddlmZddlZddlmZdZ zddl Z Wne y3ddl Z dZ Ynwzddl Z Wne yIddlZ dZ Ynwdd „Zdd d „Zd d „Zdd„Zdd„Zdd„Zdd„ZGdd„deƒZdS)zá Duplicity specific but otherwise generic threading interfaces and utilities. (Not called "threading" because we do not want to conflict with the standard threading module, and absolute imports require at least python 2.5.) é)Ústandard_library)ÚobjectN)ÚerrorsTFcCótS)zU Returns whether threading is supported on the system we are running on. )Ú_threading_supported©rrú9/usr/lib/python3/dist-packages/duplicity/dup_threading.pyÚthreading_supported4ór cCs&tƒs|dur d}t d|f¡‚dS)a Assert that threading is required for operation to continue. Raise an appropriate exception if this is not the case. Reason specifies an optional reason why threading is required, which will be used for error reporting in case threading is not supported. Nz(no reason given)zQthreading was needed because [%s], but is not supported by the python interpreter)r rÚ NotSupported)ÚreasonrrrÚrequire_threading<s þýr cCr)zW Returns the thread module, or dummy_thread if threading is not supported. )Ú_threadrrrrÚ thread_moduleMr rcCr)zZ Returns the threading module, or dummy_thread if threading is not supported. )Ú threadingrrrrÚthreading_moduleUr rcCs$| ¡z|ƒW| ¡S| ¡w)a Call fn with lock acquired. Guarantee that lock is released upon the return of fn. Returns the value returned by fn, or raises the exception raised by fn. (Lock can actually be anything responding to acquire() and release().) )ÚacquireÚrelease)ÚlockÚfnrrrÚ with_lock]s rcCs|ƒs | d¡|ƒrdSdS)aà cv - The threading.Condition instance to wait on test - Callable returning a boolean to indicate whether the criteria being waited on has been satisfied. Perform a wait on a condition such that it is keyboard interruptable when done in the main thread. Due to Python limitations as of <= 2.5, lock acquisition and conditions waits are not interruptable when performed in the main thread. Currently, this comes at a cost additional CPU use, compared to a normal wait. Future implementations may be more efficient if the underlying python supports it. The condition must be acquired. This function should only be used on conditions that are never expected to be acquired for extended periods of time, or the lock-acquire of the underlying condition could cause an uninterruptable state despite the efforts of this function. There is no equivalent for acquireing a lock, as that cannot be done efficiently. Example: Instead of: cv.acquire() while not thing_done: cv.wait(someTimeout) cv.release() do: cv.acquire() interruptable_condwait(cv, lambda: thing_done) cv.release() gš™™™™™¹?N)Úwait)ÚcvÚwaitForrrrÚinterruptably_waitps/ ÿrcs>t ¡‰dddddœ‰‡‡fdd„‰‡‡‡‡fdd„}ˆ|fS)aÖ Splits the act of calling the given function into one front-end part for waiting on the result, and a back-end part for performing the work in another thread. Returns (waiter, caller) where waiter is a function to be called in order to wait for the results of an asynchronous invokation of fn to complete, returning fn's result or propagating it's exception. Caller is the function to call in a background thread in order to execute fn asynchronously. Caller will return (success, waiter) where success is a boolean indicating whether the function suceeded (did NOT raise an exception), and waiter is the waiter that was originally returned by the call to async_split(). FN)ÚdoneÚerrorÚtraceÚvaluecsVˆ ¡z!tˆ‡fdd„ƒˆddurˆdWˆ ¡Sˆd ˆd¡‚ˆ ¡w)NcsˆdS)Nrrr)ÚstaterrÚÅsz-async_split..waiter..rrr)rrrÚwith_tracebackr)rrrrÚwaiterÂs  þ zasync_split..waiterc sžzˆƒ}ˆ ¡dˆd<|ˆd<ˆ ¡ˆ ¡dˆfWStyN}z&ˆ ¡dˆd<|ˆd<t ¡dˆd<ˆ ¡ˆ ¡dˆfWYd}~Sd}~ww)NTrrrérF)rÚnotifyrÚ ExceptionÚsysÚexc_info)rÚe©rrrr"rrÚcallerÎs$ €øzasync_split..caller)rÚ Condition)rr*rr)rÚ async_split£sý r,c@sBeZdZdZddd„Zdd„Zdd„Zd d „Zd d „Zd d„Z dS)ÚValueaË A thread-safe container of a reference to an object (but not the object itself). In particular this means it is safe to: value.set(1) But unsafe to: value.get()['key'] = value Where the latter must be done using something like: def _setprop(): value.get()['key'] = value with_lock(value, _setprop) Operations such as increments are best done as: value.transform(lambda val: val + 1) NcCs||_t ¡|_dS)z2 Initialuze with the given value. N)Ú _Value__valuerr+Ú _Value__cv©ÚselfrrrrÚ__init__ÿszValue.__init__cstˆj‡fdd„ƒS)z< Returns the value protected by this Value. csˆjS©N©r.r©r1rrr szValue.get..©rr/r5rr5rÚgetsz Value.getcs‡‡fdd„}tˆj|ƒdS)z; Resets the value protected by this Value. cs ˆˆ_dSr3r4rr0rrÚ_sets zValue.set.._setNr6)r1rr8rr0rÚset sz Value.setcs‡‡fdd„}tˆj|ƒS)ah Call fn with the current value as the parameter, and reset the value to the return value of fn. During the execution of fn, all other access to this Value is prevented. If fn raised an exception, the value is not reset. Returns the value returned by fn, or raises the exception raised by fn. csˆˆjƒˆ_ˆjSr3r4r©rr1rrÚ _transform#s z#Value.transform.._transform)rr)r1rr;rr:rÚ transforms zValue.transformcCó|j ¡dS)zÄ Acquire this Value for mutually exclusive access. Only ever needed when calling code must perform operations that cannot be done with get(), set() or transform(). N)r/rr5rrrr)sz Value.acquirecCr=)zC Release this Value for mutually exclusive access. N)r/rr5rrrr1sz Value.releaser3) Ú__name__Ú __module__Ú __qualname__Ú__doc__r2r7r9r<rrrrrrr-æs   r-r3)rAÚfuturerÚinstall_aliasesÚbuiltinsrr&Ú duplicityrrrÚ ImportErrorÚ _dummy_threadrÚdummy_threadingr r rrrrr,r-rrrrÚs6     þ  þ 3C