RPf6 PddlZddlZddlZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZddlZddlmZddlmZdZej.d ZGd d eZeeefZ e r?ddlZdd lmZddlZeej>ej>ej>fZ Gd deZ!edddddddddddd deeefde e d ege"fde#de#de dde#de"de"de"de e"d e#d!e"d"e e"d#e eeddffd$Z$edddddddddddd deeefde e eege"fde#de#de d%de e#de"de"de e"de e"d e#d!e"d"e e"d#e eedffd&Z%d'eee#efde e eege"fd#eefd(Z&d)eed#dfd*Z'd+e e#d#e#fd,Z(de e"d#e"fd-Z)d#e"fd.Z*d"e e"d#e"fd/Z+y)0N)IntEnum)Path) TYPE_CHECKINGAsyncGeneratorCallable GeneratorOptionalSetTupleUnion) RustNotify) DefaultFilter)watchawatchChange FileChangezwatchfiles.mainc.eZdZdZdZ dZ dZ defdZy)rz= Enum representing the type of change that occurred. r returnc|jSN)nameselfs I/var/www/fastapitest/venv/lib/python3.12/site-packages/watchfiles/main.pyraw_strzChange.raw_strs yyN) __name__ __module__ __qualname____doc__addedmodifieddeletedstrrrrrrs- E,HTG*rr)ProtocolceZdZdefdZy) AbstractEventrcyrr(rs ris_setzAbstractEvent.is_set1s rN)r r!r"boolr-r(rrr+r+0s D rr+i@2FTi,) watch_filterdebouncestep stop_event rust_timeoutyield_on_timeoutdebugraise_interrupt force_polling poll_delay_ms recursiveignore_permission_deniedpathsr1r2r3r4r5r6r7r8r9r:r;r<rc 'Kt|}t| } t| D cgc] } t| c} ||| | | 5} |j ||||}|dk(r%|r t nt jdno|dk(r'|rtt jd dddy|dk(r dddyt||}|rt||nt jd|cc} w#1swYyxYww)aj Watch one or more paths and yield a set of changes whenever files change. The paths watched can be directories or files, directories are watched recursively - changes in subdirectories are also detected. #### Force polling Notify will fall back to file polling if it can't use file system notifications, but we also force notify to us polling if the `force_polling` argument is `True`; if `force_polling` is unset (or `None`), we enable force polling thus: * if the `WATCHFILES_FORCE_POLLING` environment variable exists and is not empty: * if the value is `false`, `disable` or `disabled`, force polling is disabled * otherwise, force polling is enabled * otherwise, we enable force polling only if we detect we're running on WSL (Windows Subsystem for Linux) Args: *paths: filesystem paths to watch. watch_filter: callable used to filter out changes which are not important, you can either use a raw callable or a [`BaseFilter`][watchfiles.BaseFilter] instance, defaults to an instance of [`DefaultFilter`][watchfiles.DefaultFilter]. To keep all changes, use `None`. debounce: maximum time in milliseconds to group changes over before yielding them. step: time to wait for new changes in milliseconds, if no changes are detected in this time, and at least one change has been detected, the changes are yielded. stop_event: event to stop watching, if this is set, the generator will stop iteration, this can be anything with an `is_set()` method which returns a bool, e.g. `threading.Event()`. rust_timeout: maximum time in milliseconds to wait in the rust code for changes, `0` means no timeout. yield_on_timeout: if `True`, the generator will yield upon timeout in rust even if no changes are detected. debug: whether to print information about all filesystem changes in rust to stdout. raise_interrupt: whether to re-raise `KeyboardInterrupt`s, or suppress the error and just stop iterating. force_polling: See [Force polling](#force-polling) above. poll_delay_ms: delay between polling for changes, only used if `force_polling=True`. recursive: if `True`, watch for changes in sub-directories recursively, otherwise watch only for changes in the top-level directory, default is `True`. ignore_permission_denied: if `True`, will ignore permission denied errors, otherwise will raise them by default. Setting the `WATCHFILES_IGNORE_PERMISSION_DENIED` environment variable will set this value too. Yields: The generator yields sets of [`FileChange`][watchfiles.main.FileChange]s. ```py title="Example of watch usage" from watchfiles import watch for changes in watch('./first/dir', './second/dir', raise_interrupt=False): print(changes) ``` timeoutrust notify timeout, continuingsignalz(KeyboardInterrupt caught, stopping watchNstop(all changes filtered out, raw_changes=%s) _default_force_polling!_default_ignore_permission_deniedrr'rsetloggerr7KeyboardInterruptwarning _prep_changes _log_changes)r1r2r3r4r5r6r7r8r9r:r;r<r=pwatcher raw_changeschangess rrr5s ~+=9M@AYZ AQ }iQi Z !--$ jQKi'#%KLL!BC("++NN#MNZZ &#ZZ&( \B )!MLL!K[Y+ ZZs@ DC0 DA#C5# D,C52 D;5C50D5C>:DAnyEventc K|tjdt|tj} n|} t |}t | } t| Dcgc] }t|c}||| | | 5}t|}tj} tj4d{} tjj|j|||| d{}|j"j%dddd{dk(r&|rt!njt&j)dnT|dk(r dddy|dk(r t+dt-||}|rt/||nt&j)d|cc}w77#|tf$r| j!wxYw7#1d{7swYxYw#1swYyxYww) a Asynchronous equivalent of [`watch`][watchfiles.watch] using threads to wait for changes. Arguments match those of [`watch`][watchfiles.watch] except `stop_event`. All async methods use [anyio](https://anyio.readthedocs.io/en/latest/) to run the event loop. Unlike [`watch`][watchfiles.watch] `KeyboardInterrupt` cannot be suppressed by `awatch` so they need to be caught where `asyncio.run` or equivalent is called. Args: *paths: filesystem paths to watch. watch_filter: matches the same argument of [`watch`][watchfiles.watch]. debounce: matches the same argument of [`watch`][watchfiles.watch]. step: matches the same argument of [`watch`][watchfiles.watch]. stop_event: `anyio.Event` which can be used to stop iteration, see example below. rust_timeout: matches the same argument of [`watch`][watchfiles.watch], except that `None` means use `1_000` on Windows and `5_000` on other platforms thus helping with exiting on `Ctrl+C` on Windows, see [#110](https://github.com/samuelcolvin/watchfiles/issues/110). yield_on_timeout: matches the same argument of [`watch`][watchfiles.watch]. debug: matches the same argument of [`watch`][watchfiles.watch]. raise_interrupt: This is deprecated, `KeyboardInterrupt` will cause this coroutine to be cancelled and then be raised by the top level `asyncio.run` call or equivalent, and should be caught there. See [#136](https://github.com/samuelcolvin/watchfiles/issues/136) force_polling: if true, always use polling instead of file system notifications, default is `None` where `force_polling` is set to `True` if the `WATCHFILES_FORCE_POLLING` environment variable exists. poll_delay_ms: delay between polling for changes, only used if `force_polling=True`. recursive: if `True`, watch for changes in sub-directories recursively, otherwise watch only for changes in the top-level directory, default is `True`. ignore_permission_denied: if `True`, will ignore permission denied errors, otherwise will raise them by default. Setting the `WATCHFILES_IGNORE_PERMISSION_DENIED` environment variable will set this value too. Yields: The generator yields sets of [`FileChange`][watchfiles.main.FileChange]s. ```py title="Example of awatch usage" import asyncio from watchfiles import awatch async def main(): async for changes in awatch('./first/dir', './second/dir'): print(changes) if __name__ == '__main__': try: asyncio.run(main()) except KeyboardInterrupt: print('stopped via KeyboardInterrupt') ``` ```py title="Example of awatch usage with a stop event" import asyncio from watchfiles import awatch async def main(): stop_event = asyncio.Event() async def stop_soon(): await asyncio.sleep(3) stop_event.set() stop_soon_task = asyncio.create_task(stop_soon()) async for changes in awatch('/path/to/dir', stop_event=stop_event): print(changes) # cleanup by awaiting the (now complete) stop_soon_task await stop_soon_task asyncio.run(main()) ``` Nzraise_interrupt is deprecated, KeyboardInterrupt will cause this coroutine to be cancelled and then be raised by the top level asyncio.run call or equivalent, and should be caught there. See #136.r?r@rBrAz+watch thread unexpectedly received a signalrC)warningswarnDeprecationWarninganyioEventrDrErr'_calc_async_timeoutget_cancelled_exc_classcreate_task_group to_threadrun_syncrrHrF cancel_scopecancelrGr7 RuntimeErrorrJrK)r1r2r3r4r5r6r7r8r9r:r;r<r= stop_event_rLrMr?CancelledErrortgrNrOs rrrsl"  o  "'++-  *=9M@AYZ AQ }iQi  Z %l3668..0 ) )B(-(@(@PXZ^`git(u"uK &&( ) )i'#%KLL!BC&- Z Z.("#PQQ' \B )!MLL!K[Y5  )"u&(9:OO% ) ) ) ) Z ZsAGF) G59G.F/G2F>40F$F%F)F> GF<5G G AGGGFF99F><G>G GG GGGrNc|Dchc]\}}t||f}}}|r|Dchc]}||d|ds|}}|Scc}}wcc}w)Nrr )r)rNr1changepathrOcs rrJrJsZ;FF,&$v%FGF%BadAaD)A1BB NGBsAA A rOctjtjrht |}|dk(rdnd}tjtj rtj d|||ytjd||yy)Nr sz%d change%s detected: %sz%d change%s detected)rG isEnabledForloggingINFOlenDEBUGr7info)rOcountplurals rrKrK"se 7<<(G zs   w}} - LL3UFG L KK.v > )rr?c4|tjdk(ryy|S)zC see https://github.com/samuelcolvin/watchfiles/issues/110 win32ir0)sysplatform)r?s rrWrW,s  <<7 "rcp||Stjd}|r|jdvStS)z See docstring for `watch` above for details. See samuelcolvin/watchfiles#167 and samuelcolvin/watchfiles#187 for discussion and rationale. WATCHFILES_FORCE_POLLING>falsedisabledisabled)osgetenvlower_auto_force_polling)r9env_vars rrDrD9s=  ii23G}}&FFF"$$rcddl}|j}d|jjvxr|jjdk(S)z Whether to auto-enable force polling, it should be enabled automatically only on WSL. See samuelcolvin/watchfiles#187 for discussion. rNzmicrosoft-standardlinux)rtunamereleaser|system)rtrs rr}r}HsC  NN E 5==#6#6#8 8 \U\\=O=O=QU\=\\rcJ||Stjd}t|S)N#WATCHFILES_IGNORE_PERMISSION_DENIED)rzr{r.)r<r~s rrErETs'+''ii=>G =r),rjrzrsrRenumrpathlibrtypingrrrrr r r r rU _rust_notifyrfiltersr__all__ getLoggerrGrr'rasyncior)triorVrPr+r.intrrrJrKrWrDr}rEr(rrrsi bbb $" 3   , - W  63;   U[['--;YZYZYZ'tnYZs:d*+YZ|=JO'+"&"&*$(/3DZ $) DZ8VSM4$789DZDZ  DZ $ DZ 3- DZDZ DZd^DZD>DZDZDZ'tnDZC OT)*DZNU38_%5=hPS}VZGZ>[5\_?#j/?d? # 3  %(4. %T % ]T ]SWr