!h=!0ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZddlZdd lm Z dd l!m"Z"m#Z#m$Z$m%Z%erdd lm&Z&d Z'ej(d Z)dddde ddddddddd deee*fdee*edeffdeedfdeee*efdddeeee#gdfdeee"e*ge+fde,d e-d!e-d"ee+d#e-d$e-d%e+d&e+d'e-f d(Z.dddde ddddddd) deee*fdee*edeffdeedfdeee*efdddeeee#gefdeee"e*ge+fde,d e-d!e-d"ee+d%e+d&e+d'e-fd*Z/e d+Z0d,e*d'ee*fd-Z1 d@dee*edeffdd.deedfdeee*efd/eee#d'd0f d1Z2dee*edeffd'd.fd2Z3Gd3d0Z4d4e*d5ee*deedfdee*efd'df d6Z5d7e*d'efd8Z6d'ee*fd9Z7ej8d5ee*d'ed:fd;Z9dZ:dAd?Z;dS)BN) import_module) get_context) SpawnProcess)Path)sleep) TYPE_CHECKINGAnyCallableDict GeneratorListOptionalSetTupleUnion) DefaultFilter)Change FileChangeawatchwatch)Literal) run_process arun_processdetect_target_type import_stringzwatchfiles.mainautoi@2TF) argskwargs target_typecallback watch_filter grace_perioddebouncestepdebugsigint_timeoutsigkill_timeout recursiveignore_permission_deniedpathstarget.r!r"r#z&Literal['function', 'command', 'auto']r$r%r&r'r(r)r*r+r,r-returnc |dkrt|}td||tt ||||}d}|r*td|t | t ||||| d| | dD]>}|o |||| | t |||||}|dz }? |n#|wxYw|S) u Run a process and restart it upon file changes. `run_process` can work in two ways: * Using `multiprocessing.Process` † to run a python function * Or, using `subprocess.Popen` to run a command !!! note **†** technically `multiprocessing.get_context('spawn').Process` to avoid forking and improve code reload/import. Internally, `run_process` uses [`watch`][watchfiles.watch] with `raise_interrupt=False` so the function exits cleanly upon `Ctrl+C`. Args: *paths: matches the same argument of [`watch`][watchfiles.watch] target: function or command to run args: arguments to pass to `target`, only used if `target` is a function kwargs: keyword arguments to pass to `target`, only used if `target` is a function target_type: type of target. Can be `'function'`, `'command'`, or `'auto'` in which case [`detect_target_type`][watchfiles.run.detect_target_type] is used to determine the type. callback: function to call on each reload, the function should accept a set of changes as the sole argument watch_filter: matches the same argument of [`watch`][watchfiles.watch] grace_period: number of seconds after the process is started before watching for changes debounce: matches the same argument of [`watch`][watchfiles.watch] step: matches the same argument of [`watch`][watchfiles.watch] debug: matches the same argument of [`watch`][watchfiles.watch] sigint_timeout: the number of seconds to wait after sending sigint before sending sigkill sigkill_timeout: the number of seconds to wait after sending sigkill before raising an exception recursive: matches the same argument of [`watch`][watchfiles.watch] Returns: number of times the function was reloaded. ```py title="Example of run_process running a function" from watchfiles import run_process def callback(changes): print('changes detected:', changes) def foobar(a, b): print('foobar called with:', a, b) if __name__ == '__main__': run_process('./path/to/dir', target=foobar, args=(1, 2), callback=callback) ``` As well as using a `callback` function, changes can be accessed from within the target function, using the `WATCHFILES_CHANGES` environment variable. ```py title="Example of run_process accessing changes" from watchfiles import run_process def foobar(a, b, c): # changes will be an empty list "[]" the first time the function is called changes = os.getenv('WATCHFILES_CHANGES') changes = json.loads(changes) print('foobar called due to changes:', changes) if __name__ == '__main__': run_process('./path/to/dir', target=foobar, args=(1, 2, 3)) ``` Again with the target as `command`, `WATCHFILES_CHANGES` can be used to access changes. ```bash title="example.sh" echo "changers: ${WATCHFILES_CHANGES}" ``` ```py title="Example of run_process running a command" from watchfiles import run_process if __name__ == '__main__': run_process('.', target='./example.sh') ``` rrunning "%s" as %sr3sleeping for %s seconds before watching for changesF)r%r'r(r)raise_interruptr,r-)r*r+r)rloggerr) catch_sigterm start_processrrstop)r/r!r"r#r$r%r&r'r(r)r*r+r,r-r.processreloadschangess Hc:\xampp_lite_8_4\www\timesheet\venv\Lib\site-packages\watchfiles/run.pyrrs3@f(00  LL%v{;;;OOOFKv>>GG JLYYY l %!%=     G  *'** LLL X X X#FKvwOOG qLGG     Ns AC((C>) r!r"r#r$r%r&r'r(r)r,r-c Kddl} |dkrt|}td||t t jt||||d{V}d}|r5td|t j |d{Vt| |||| | | d23d{V}|(||}| |r|d{Vt j|j d{Vt jt|||||d{V}|dz }6t j|j d{V|S)a  Async equivalent of [`run_process`][watchfiles.run_process], all arguments match those of `run_process` except `callback` which can be a coroutine. Starting and stopping the process and watching for changes is done in a separate thread. As with `run_process`, internally `arun_process` uses [`awatch`][watchfiles.awatch], however `KeyboardInterrupt` cannot be caught and suppressed in `awatch` so these errors need to be caught separately, see below. ```py title="Example of arun_process usage" import asyncio from watchfiles import arun_process async def callback(changes): await asyncio.sleep(0.1) print('changes detected:', changes) def foobar(a, b): print('foobar called with:', a, b) async def main(): await arun_process('.', target=foobar, args=(1, 2), callback=callback) if __name__ == '__main__': try: asyncio.run(main()) except KeyboardInterrupt: print('stopped via KeyboardInterrupt') ``` rNrr2r3)r%r'r(r)r,r-r) inspectrr5r)r6anyio to_threadrun_syncr7rr isawaitabler8)r/r!r"r#r$r%r&r'r(r)r,r-r.r>r9r:r;rs r<rrsZNNNf(00  LL%v{;;;OOOO,,]FKQUW]^^^^^^^^GG( JLYYYk,''''''''' ! !9g  !!A""1%% o&&w|44444444400 UY[acjkkkkkkkk1 !" / " "7< 0 00000000 Ns>Espawncmdcddl}|jdk}t j||S)Nrwindows)posix)platformunamesystemlowershlexsplit)rErIrHs r< split_cmdrOsCOOO NN   # ) ) + +y 8E ;s% ( ( ((zLiteral['function', 'command']r;CombinedProcessc"|d}ntjd|D}|tjd<|dkri|pi}t |t r|t ||f}t}i}n|}t |||}| n`|s|rt dt |t s Jdt|}tj|}t!|S)Nz[]c@g|]\}}||gSr)raw_str).0cps r< z!start_process..s)%K%K%K41aqyy{{A&6%K%K%KrPWATCHFILES_CHANGESfunction)r/r!r"z-ignoring args and kwargs for "command" targetz+target must be a string to run as a command)jsondumpsosenviron isinstancestr get_tty_path run_function spawn_contextProcessstartr5warningrO subprocessPopenrQ) r/r#r!r"r;changes_env_vartarget_r9 popen_argss r<r7r7s*%K%K7%K%K%KLL'6BJ#$j  2 fc " " <>>47D"GFFG''wT&'QQ   L6 L NNJ K K K&#&&UU(UUU&v&& ":.. 7 # ##rPct|tsdS|drdStjd|rdSdS)a^ Used by [`run_process`][watchfiles.run_process], [`arun_process`][watchfiles.arun_process] and indirectly the CLI to determine the target type with `target_type` is `auto`. Detects the target type - either `function` or `command`. This method is only called with `target_type='auto'`. The following logic is employed: * If `target` is not a string, it is assumed to be a function * If `target` ends with `.py` or `.sh`, it is assumed to be a command * Otherwise, the target is assumed to be a function if it matches the regex `[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)+` If this logic does not work for you, specify the target type explicitly using the `target_type` function argument or `--target-type` command line argument. Args: target: The target value Returns: either `'function'` or `'command'` rZ)z.pyz.shcommandz[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)+)r_r`endswithre fullmatch)r/s r<rrsS, fc " "z  ( (y 8& A AzyrPceZdZddZddededd fd Zdefd Zedefd Z d edd fdZ ede efdZ d S)rQrW,Union[SpawnProcess, subprocess.Popen[bytes]]c6||_|j JddS)Nzprocess not yet spawned_ppid)selfrWs r<__init__zCombinedProcess.__init__>s&x##%>#####rPr rr*r+r0Nctjdd|rtdtj|jtj  | |n0#tj $rt d|YnwxYw|jUt dtj|jtj| |dStddSt d|jdS)NrYzstopping process...z!SIGINT timed out after %r secondsz+process has not terminated, sending SIGKILLzprocess stoppedz#process already dead, exit code: %d)r]r^popis_aliver5r)killrvsignalSIGINTjoinrgTimeoutExpiredrfexitcodeSIGKILL)rwr*r+s r<r8zCombinedProcess.stopBs( +T222 ==?? Q LL. / / / GDHfm , , ,  .)))),   BNSSS   }$LMMM&.111 /***** .///// NN@$- P P P P Ps4B *B76B7ct|jtr|jS|jduSN)r_rurr{pollrws r<r{zCombinedProcess.is_aliveZs? dg| , , *7##%% %7<<>>T) )rPc|jjSrrtrs r<rvzCombinedProcess.pid`sw{rPtimeoutct|jtr|j|dS|j|dSr)r_rurrwait)rwrs r<rzCombinedProcess.joinesJ dg| , , " GLL ! ! ! ! ! GLL ! ! ! ! !rPcft|jtr |jjS|jjSr)r_rurr returncoders r<rzCombinedProcess.exitcodeks, dg| , , &7# #7% %rP)rWrr)r r) __name__ __module__ __qualname__rxintr8boolr{propertyrvrrrrrPr<rQrQ=s????QQ3QSQQQQQ0*$**** SX"C"D"""" &(3-&&&X&&&rPrZtty_pathct|5t|}||i|ddddS#1swxYwYdSr)set_ttyr)rZrr!r"funcs r<rbrbss   X&& dfs 599 dotted_pathc< |ddd\}}n&#t$r}td|d|d}~wwxYwt |} t ||S#t $r}td|d|d |d}~wwxYw) z Stolen approximately from django. Import a dotted module path and return the attribute/class designated by the last name in the path. Raise ImportError if the import fails.  .r"z!" doesn't look like a module pathNzModule "z" does not define a "z " attribute)striprsplit ValueError ImportErrorrgetattrAttributeError)r module_path class_nameemodules r<rrys V"-"3"3C"8"8"?"?Q"G"G ZZ VVVMkMMMNNTUUV; ' 'Fgvz*** ggg^[^^z^^^__effgs,,/ AA  A%A55 B?BBc tjtjS#t $rYdSt $rYdSwxYw)zr Return the path to the current TTY, if any. Virtually impossible to test in pytest, hence no cover. z/dev/ttyN)r]ttynamesysstdinfilenoOSErrorrrrPr<raras` z#)**,,--- zz tts/2 A  A  A )NNNc#K|rP t|5}|t_dVddddS#1swxYwYdS#t$rdVYdSwxYwdVdSr)openrrr)rttys r<rrs  h 3                       EEEEEE  s,A3 A7A7AAAsignum_framecjtdtj|t)Nz-received signal %s, raising KeyboardInterrupt)r5rfr}SignalsKeyboardInterrupt)rrs r<raise_keyboard_interruptrs( NNBFNSYDZDZ[[[ rPctdtjt jtjt dS)a Catch SIGTERM and raise KeyboardInterrupt instead. This means watchfiles will stop quickly on `docker compose stop` and other cases where SIGTERM is sent. Without this the watchfiles process will be killed while a running process will continue uninterrupted. z8registering handler for SIGTERM on watchfiles process %dN)r5r)r]getpidr}SIGTERMrrrPr<r6r6s: LLKRY[[YYY M&.":;;;;;rPr)r0N)< contextlibr[loggingr]rorMr}rgr importlibrmultiprocessingrmultiprocessing.contextrpathlibrtimertypingrr r r r r rrrrr?filtersrmainrrrrr__all__ getLoggerr5r`rfloatrrrrcrOr7rrQrbrracontextmanagerrrr6rrPr<rsI   ######''''''000000cccccccccccccccccccccccc """"""333333333333 N  , - - '+}}}}#}  !}}}}F'+MM#M MMMMd G$$ )3)49))))*. !$!$ #xS)) *!$1!$ S/!$ T#s(^ $ !$ c*o & !$  !$!$!$!$HuS(38*<%<=Bb@3&3&3&3&3&3&3&3&l3(3-uS#XX\]`be]eXfko gsgsgggg" hsm       hsm  2B(C    S#$ <<<<<