+ ~j;`^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RI H t H t ^RI H t ^RIHt^RIHt^RIHt^RIHt^RIHtHt^RIt^R IHt^R IHtHtHtH t ]'d^R IH!t!R7t"]PF!R 4t$R R8RRRRRRR]!4R^RRR^2RRR^R^RRRR/ RRllt%R R8RRRRRRR]!4R^RRR^2RRRRRR/ R R!llt&]!R"4t'R#R$lt(R9R%R&llt)R'R(lt*!R)R*4t+R+R,lt,R-R.lt-R/R0lt.]P^R1R2l4t0R3R4lt1R5R6lt2R#):N)Callable Generator) import_module) get_context) SpawnProcess)Path)sleep) TYPE_CHECKINGAny) DefaultFilter)Change FileChangeawatchwatch)Literalzwatchfiles.mainargskwargs target_typeautocallback watch_filter grace_perioddebouncei@stepdebugsigint_timeoutsigkill_timeout recursiveTignore_permission_deniedFc V^8dQhR\\,R\\R\3,,R\\R3,R\ \\3,R,RRR \\ \,.R3,R,R \\\.\3,R,R \R \R \R\R,R\R\R\R\R\/#)pathstarget.rrNr&Literal['function', 'command', 'auto']rrrrrrrrrrreturn rstrrr tupledictsetrr boolfloatint)formats"c/Users/mitch_tango/dev/rabbit-r1-livekit/agent/.venv/lib/python3.14/site-packages/watchfiles/run.py __annotate__r0s}} 3J} (38$ $} S/} cNT ! } : } J($./$6 }FC=$./$6}}} } $;}}}}#}  !}cVR8Xd \V4p\PRW4\4\ WW4p^pV'd"\PRV4\ V4\ VRVRVRVRV RR R V R V /F=pT;'d V!V4VPWR 7\ WWV4pV^, pK? VP4V# TP4i;i) 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 %s3sleeping for %s seconds before watching for changesrrrrraise_interruptFrr)rr)detect_target_typeloggerr catch_sigterm start_processr rstop)r#rrrrrrrrrrrrrr"processreloadschangess$$$$$$$$$$$$$$* r/ run_processr>s@f(0  LL%v;OF>GG JLY l   %        "     &>  G  * *'* LLL X#FwOG qLG     N  s+"C5CC'cV^8dQhR\\,R\\R\3,,R\\R3,R\ \\3,R,RRR \\ \,.\3,R,R \\\.\3,R,R \R \R \R\R,R\R\R\/#)r!r"r#.rrNrr$rrrrrrrrr%r&)r.s"r/r0r0sMM 3JM (38$ $M S/M cNT ! M : M J(#-.5 MFC=$./$6MMM M $;MM#M Mr1c :"^RIp VR8Xd \V4p\PRW4\ 4\ P P\WW4GRjxL p^pV'd5\PRV4\ P!V4GRjxL \V RVRVRVRV R V R V /RjxL pVe*V!V4pV PV4'd VGRjxL \ P PVP4GRjxL \ P P\WWV4GRjxL pV^, pKLLLLtLELD\ P PTP4GRjxL T#5i) 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') ``` Nrr3r4rrrrrr) inspectr6r7rr8anyio to_threadrun_syncr9r r isawaitabler:)r#rrrrrrrrrrrr"rAr;r<r=rs$$$$$$$$$$$$* r/ arun_processrGsxZf(0  LL%v;OOO,,]FQU^^GG JLYkk,''' !     ":g  !A""1%%oo&&w||44400UYcjkk1 /_ (4k" // " "7<< 000 NsAF!E" F0/FE F9E&=E>E&$F&F+E ,0FE"-F E$ FFE& F"F$F&-FFFspawncFV^8dQhR\R\\,/#)r!cmdr%)r'list)r.s"r/r0r0s))3)49)r1c^RIpVP4PP4R8gp\P !WR7#)rNwindows)posix)platformunamesystemlowershlexsplit)rJrOrNs& r/ split_cmdrUs4 NN  # # ) ) +y 8E ;;s ((r1c V^8dQhR\\R\3,,RRR\\R3,R\\\3,R,R\ \ ,R,R R /#) r!r#.rLiteral['function', 'command']rrNr=r%CombinedProcess)r'rr r(r)r*r)r.s"r/r0r0sp!$!$ (38$ $!$1!$ S/!$ cNT ! !$ _t # !$  !$r1cdVfRpM:\P!VUUu.uFwrgVP4V.NK upp4pV\PR&VR8XdcT;'g/p\ V\ 4'dV\4W#3p\p/pMTp\PWVR7p V P4McV'g V'd\PR4\ V\ 4'gQR4h\V4p \P !V 4p \#V 4#uuppi)Nz[]WATCHFILES_CHANGESfunction)r#rrz-ignoring args and kwargs for "command" targetz+target must be a string to run as a command)jsondumpsraw_strosenviron isinstancer' get_tty_path run_function spawn_contextProcessstartr7warningrU subprocessPopenrX) r#rrrr=changes_env_varcptarget_r; popen_argss &&&&& r/r9r9s**7%K741qyy{A&67%KL'6BJJ#$j 2 fc " "<>47D"GFG''w&'Q  6 NNJ K&#&&U(UU&v& "":. 7 ##/&LsD, cXV^8dQhR\\R\3,,RR/#)r!r#.r%rW)r'rr )r.s"r/r0r0s)sXc3h%77<\r1c\V\4'gR#VPR4'dR#\P!RV4'dR#R#)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'` r[commandz[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)+)z.pyz.sh)rar'endswithre fullmatch)r#s&r/r6r6s>, fc " "  ( ( 8& A Ar1ca]tRtRtoV3RlRltRV3RlRlltV3RlRlt]V3RlR l4tV3R lR lt ]V3R lR l4t Rt Vt R#)rXi>c<V^8dQhRR/#)r!rlz&SpawnProcess | subprocess.Popen[bytes])r. __classdict__s"r/r0CombinedProcess.__annotate__?s??B?r1c<WnVPfQR4hR#)Nzprocess not yet spawned_ppid)selfrls&&r/__init__CombinedProcess.__init__?sxx#>%>>#r1c*<V^8dQhRS[RS[RR/#)r!rrr%Nr-)r.rxs"r/r0ryCs'QQ3QSQQr1c\PPRR4VP4'd\P R4\P !VP\P4VPV4VPfX\PR4\P !VP\P4VPV4R#\P R4R#\PRVP4R# \Pd\PRT4Li;i)rZNzstopping process...z!SIGINT timed out after %r secondsz+process has not terminated, sending SIGKILLzprocess stoppedz#process already dead, exit code: %d)r_r`popis_aliver7rkillr}signalSIGINTjoinrhTimeoutExpiredrgexitcodeSIGKILL)r~rrs&&&r/r:CombinedProcess.stopCs +T2 ==?? LL. / GGDHHfmm ,  .)}}$LM&..1 /* ./ NN@$-- P,, BNS  s<D+++EEc <V^8dQhRS[/#r!r%)r+)r.rxs"r/r0ry[s**$*r1c\VP\4'dVPP4#VPP 4RJ#N)rar|rrpollr~s&r/rCombinedProcess.is_alive[s; dgg| , ,77##% %77<<>T) )r1c <V^8dQhRS[/#rr)r.rxs"r/r0rybsSr1c.VPP#rr{rs&r/r}CombinedProcess.pidasww{{r1c$<V^8dQhRS[RR/#)r!timeoutr%Nr)r.rxs"r/r0ryfs""C"D"r1c\VP\4'dVPPV4R#VPP V4R#r)rar|rrwait)r~rs&&r/rCombinedProcess.joinfs3 dgg| , , GGLL ! GGLL !r1c.<V^8dQhRS[R,/#r!r%Nr)r.rxs"r/r0ryms&&#*&r1c\VP\4'dVPP#VPP#r)rar|rr returncoders&r/rCombinedProcess.exitcodels3 dgg| , ,77## #77%% %r1)r|N)) __name__ __module__ __qualname____firstlineno__rr:rpropertyr}rr__static_attributes____classdictcell__)rxs@r/rXrX>sW??QQ0** "" &&r1rXc V^8dQhR\R\R,R\\R3,R\\\3,RR/#)r!r[tty_pathNr.rr%)r'r(r r))r.s"r/r0r0tsI3#*E#s(OUYZ]_bZbUchlr1c\V4;_uu_4\V4pV!V/VBRRR4R# +'giR#;ir)set_tty import_string)r[rrrfuncs&&&& r/rcrcts3   X& df    s 2 A c0V^8dQhR\R\/#)r! dotted_pathr%)r'r )r.s"r/r0r0zsggsgsgr1c VPR4PR^4wr\ T4p\ YB4# \dp\RT R24ThRp?ii;i \ dp\RT RT R24ThRp?ii;i) 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.  ."z!" doesn't look like a module pathNzModule "z" does not define a "z " attribute)striprsplit ValueError ImportErrorrgetattrAttributeError)r module_path class_nameemodules& r/rrzs V"-"3"3C"8"?"?Q"G ; 'Fgv** VAk]*LMNTUUV gH[M1FzlR]^_effgs,#< A AAA B*A==Bc2V^8dQhR\R,/#r)r')r.s"r/r0r0s  cDj r1c\P!\PP 44# \ dR#\ dR#i;i)zf Return the path to the current TTY, if any. Virtually impossible to test in pytest, hence no cover. z/dev/ttyN)r_ttynamesysstdinfilenoOSErrorrrwr1r/rbrbs@ zz#))**,--  s14 AA AAcLV^8dQhR\R,R\R,/#)r!rNr%)NNN)r'r)r.s"r/r0r0s$  cDj Y/?%@ r1c#"V'd/\V4;_uu_4pV\nRxRRR4R#RxR# +'giR#;i \d RxR#i;i5ir)openrrr)rttys& r/rrsJ h3       sG A)A?AA) A AA)AA&"A)%A&&A)c4V^8dQhR\R\RR/#)r!signum_framer%N)r-r )r.s"r/r0r0s!S#$r1cb\PR\P!V44\h)z-received signal %s, raising KeyboardInterrupt)r7rgrSignalsKeyboardInterrupt)rrs&&r/raise_keyboard_interruptrs! NNBFNNSYDZ[ r1cV^8dQhRR/#rrw)r.s"r/r0r0s<rGr6rrwr)3 contextlibr\loggingr_rsrSrrhrcollections.abcrr importlibrmultiprocessingrmultiprocessing.contextrpathlibrtimer typingr r rBfiltersr mainr rrrr__all__ getLoggerr7r>rGrdrUr9r6rXrcrrbcontextmanagerrrr8rwr1r/rs   /#'0% "33 N   , -}}%) } =C } :> }:G}}}}}}}}&+}@MM%) M =C M 9= M:GMMMMMM&+MdG$ )!$H@3&3&l g"