ڎjǖNdZddlmZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z ddl mZddlmZmZddlZdZd Ze d d Gd d Ze d d GddZddZGdde ZddZGddeZdS)uBackend abstraction for builtin tools. Provides a :class:`BackendBase` abstract base class that captures the core I/O primitives shared across all six builtin tools (Bash, Read, Write, Edit, Grep, Glob). Every backend implements exactly **three** abstract primitives whose mechanism genuinely differs per environment: * :meth:`BackendBase.exec_shell` — run a program from an argv list (no shell; callers needing shell features wrap with ``sh -c``). * :meth:`BackendBase.read_file` — read raw bytes. * :meth:`BackendBase.write_file` — write raw bytes. All remaining filesystem operations (``file_exists``, ``is_dir``, ``list_dir``, ``stat_mtime``, ``delete_path``) are derived on the base class from ``exec_shell`` and work out-of-the-box for any remote backend. A backend that has a cheaper native path (e.g. :class:`LocalBackend` using ``os.*``) simply overrides them. Concrete implementations: * :class:`LocalBackend` — default; uses ``asyncio`` subprocesses, ``aiofiles``, and ``os.*`` for host-local I/O. Injected automatically when no explicit backend is given. * ``DockerBackend`` — uses ``aiodocker`` exec / archive APIs. * ``E2BBackend`` — uses the E2B SDK ``commands`` / ``files`` APIs. By accepting a ``BackendBase`` parameter, each builtin tool can operate identically in local, Docker, and E2B workspaces without any workspace-specific branching inside the tool code itself. ) annotationsN)ABCabstractmethod) dataclass) ModuleType)Any AsyncIteratoriz%Y\t%s\t%T@\t%f\0T)frozenslotsc:eZdZUdZded<ded<ded<d d Zd S) ExecResultu@Result of running a shell command via a backend. Attributes: exit_code: Process exit code. ``-1`` conventionally indicates an internal failure (timeout, connection error, …). stdout: Raw bytes captured from standard output. stderr: Raw bytes captured from standard error. int exit_codebytesstdoutstderrreturnboolc|jdkS)zWhether the command exited successfully. Returns: `bool`: ``True`` iff the command exited with code ``0``. r)rselfs OC:\Projects\DSCons\.venv\Lib\site-packages\agentscope\tool\_builtin\_backend.pyokz ExecResult.okLs~""N)rr)__name__ __module__ __qualname____doc____annotations__rrrr r =sQNNNMMMMMM######rr cDeZdZUdZded<ded<dZded<dZd ed <dS) DirEntryuOne entry from :meth:`BackendBase.scandir`. Mirrors :class:`os.DirEntry`: the metadata comes from the same directory read as the name, so a listing costs one round trip instead of one per entry plus one per attribute. Attributes: name: The entry's base name, without any leading directory. is_dir: Whether the entry is a directory, following symlinks. size_bytes: Size in bytes of a file. Always ``None`` for a directory — its on-disk size says nothing a caller wants — and ``None`` when it could not be determined (a broken symlink, a vanished entry). mtime: Modification time as a POSIX timestamp, or ``None`` for the same reasons. strnameris_dirNz int | None size_bytes float | Nonemtime)rrrrrr&r(r rrr"r"VsR"IIILLL!J!!!!Err"textr#rcV|ddddS)aSNormalize Windows/old-Mac line endings to ``\n``. Converts ``\r\n`` (Windows) and lone ``\r`` (classic Mac) to a single ``\n``. Builtin tools read files as raw bytes (so binary payloads survive intact); when the bytes are decoded as text for line-based caching, editing, or matching, the line endings must be normalized so that content written on Windows behaves identically to content written on POSIX. Args: text (`str`): Decoded file contents. Returns: `str`: The text with all line endings collapsed to ``\n``. z   )replace)r)s r_normalize_newlinesr.rs($ << % % - -dD 9 99rceZdZUdZeZded<d5dZd6d Zd6d Z d7d Z d6d Z d8dZ e dddd9dZe d:dZe d;dZdd$Zd6d%Zd7d&Zd7d'Zd(d)d?d+Zd@d-ZdAd/Zd(d0dBd2ZdCd3ZdDd4ZdS)E BackendBaseuFilesystem + subprocess interface consumed by builtin tools. Subclasses must implement three abstract primitives — ``exec_shell``, ``read_file``, and ``write_file`` — which are the only operations whose mechanism genuinely differs per environment. The remaining filesystem helpers are implemented here on top of ``exec_shell`` and work for any backend whose shell is POSIX-like; a backend with a cheaper native path may override them (see :class:`LocalBackend`). r _path_modulepathr#pathsrc(|jj|g|RS)azJoin one or more path components using the backend's separator. Args: path (`str`): The first path component. *paths (`str`): Additional components to join onto ``path``. Returns: `str`: The joined path, using the backend environment's path separator. )r1join)rr2r3s r join_pathzBackendBase.join_paths"&t %d3U3333rc6|j|S)aDReturn the directory component of ``path``. Args: path (`str`): A path inside the backend's environment. Returns: `str`: Everything up to (but not including) the last path separator. Empty string if ``path`` has no separator. )r1dirnamerr2s rr8zBackendBase.dirnames ((...rc6|j|S)a1Return the final component of ``path``. Args: path (`str`): A path inside the backend's environment. Returns: `str`: Everything after the last path separator. Empty string if ``path`` ends with a separator. )r1basenamer9s rr;zBackendBase.basenames ))$///rrc6|j|S)a:Return ``True`` if ``path`` is absolute in the backend. Args: path (`str`): A path inside the backend's environment. Returns: `bool`: ``True`` iff ``path`` is absolute under the backend environment's path semantics. )r1isabsr9s rr=zBackendBase.isabss &&t,,,rc6|j|S)u3Normalize ``path`` (collapse ``..``, ``.``, duplicate seps). Pure string operation — does not touch the filesystem. Args: path (`str`): A path inside the backend's environment. Returns: `str`: The normalized path. )r1normpathr9s rr?zBackendBase.normpaths ))$///rcwdc|j|r|j|S|j|j||S)a>Return an absolute, normalized version of ``path``. Unlike :func:`os.path.abspath`, this helper **never** reads the host process's working directory: when ``path`` is relative it is joined with the explicitly supplied ``cwd``, which must itself be a path that is meaningful inside the backend's environment. This avoids the silent bug where the host's ``os.getcwd()`` leaks into paths that will actually be used on a remote backend. Args: path (`str`): A path inside the backend's environment. cwd (`str`): Directory to resolve a relative ``path`` against. Ignored when ``path`` is already absolute. Returns: `str`: An absolute, normalized path. )r1r=r?r5)rr2r@s rabspathzBackendBase.abspathse,   " "4 ( ( 4$--d33 3 ))   " "3 - -   rNr@timeoutcommand list[str] str | NonerDr'r c KdS)uRun a program directly from an argument vector. *command* is an executable followed by its arguments — it is **not** passed through a shell, so callers never have to quote or escape arguments and there is no platform-specific quoting bug. This makes the primitive portable to Windows, where POSIX single-quote escaping (``shlex.quote``) is not understood by ``cmd.exe``. Callers that genuinely need shell features (pipes, redirects, ``&&``) must wrap their command line explicitly, e.g. ``["/bin/sh", "-c", command_line]``. Args: command (`list[str]`): Executable path/name followed by its arguments. cwd (`str | None`, optional): Working directory to run the command in. When ``None`` the backend's default working directory is used. timeout (`float | None`, optional): Maximum number of seconds to wait. When ``None`` the call waits indefinitely. On timeout the result carries an ``exit_code`` of ``-1``. Returns: `ExecResult`: The captured exit code, stdout, and stderr. Nr )rrEr@rDs r exec_shellzBackendBase.exec_shell rrc KdS)zRead the full contents of ``path`` as raw bytes. Args: path (`str`): Path to the file inside the backend's environment. Returns: `bytes`: The raw file contents. Nr r9s r read_filezBackendBase.read_fileArJrdataNonec KdS)zWrite ``data`` to ``path``, creating parent directories. Args: path (`str`): Destination path inside the backend's environment. data (`bytes`): The raw bytes to write. Nr )rr2rMs r write_filezBackendBase.write_fileNrJrstreamAsyncIterator[bytes]cKd|2d{V}||d|d{VdS)a_Write a byte stream to ``path``, creating parent directories. The default buffers the whole stream and delegates to :meth:`write_file`, so peak memory is the payload size; only backends that override this (``LocalBackend``, ``BubblewrapBackend``, ``K8sBackend``) are constant-memory. Callers handling untrusted input must cap the payload regardless. Args: path (`str`): Destination path inside the backend's environment. stream (`AsyncIterator[bytes]`): The chunks to write, in order. c"Kg|3d{V}| 6S)Nr ).0chunks r z,BackendBase.write_stream..ms.22222222%%2222sNr)rPr5)rr2rQchunkss r write_streamzBackendBase.write_streamYse(326222222222oodCHHV$4$455555555555r chunk_sizercK||d{V}tdt||D]}||||zWVdS)aRead ``path`` as a byte stream. The default reads the whole file through :meth:`read_file` and re-slices it, so peak memory is the file size; only backends that override this (``LocalBackend``) are constant-memory. Overriding requires incremental access to ``exec_shell`` stdout, which the remote backends do not expose today. Args: path (`str`): Path to the file inside the backend's environment. chunk_size (`int`, defaults to 1 MiB): The size of each yielded chunk. Yields: `bytes`: Successive chunks of the file, in order. Nr)rLrangelen)rr2rZrMstarts r read_streamzBackendBase.read_streampsw.^^D))))))))1c$ii44 3 3Euuz112 2 2 2 2 2 3 3rcK|dgd{V}|jddS)u Return the backend environment's current working directory. This is the directory that bare ``exec_shell`` invocations (those with ``cwd=None``) execute in. Tools should call this — instead of :func:`os.getcwd` — whenever they need a default path that is meaningful inside the backend, because the host process's cwd is meaningless for remote backends (Docker / E2B). The default implementation runs ``pwd`` via :meth:`exec_shell`, which works for any POSIX-like backend. Backends with cheaper native access (e.g. :class:`LocalBackend`, or remote backends that already track their workdir) should override it. Returns: `str`: The backend's current working directory. pwdNutf-8r-errors)rIrdecodestrip)rresults rgetcwdzBackendBase.getcwdsT&w////////}##GI#>>DDFFFrc4K|r |ddkr|St|dkr|dd|jjfvr|S|ddgd{V}|jdd }|s|S||ddzS) uExpand a leading ``~`` / ``~/`` to the backend's home directory. Tools should call this — instead of :func:`os.path.expanduser` — whenever they need to expand ``~`` in a path that lives inside the backend's environment, because the host process's ``$HOME`` is meaningless for remote backends. The default implementation queries ``$HOME`` via :meth:`exec_shell` (POSIX-only). Only the leading ``~`` / ``~/foo`` form is expanded; ``~user/...`` is not supported by the default and is returned unchanged. Backends with cheaper native access should override (e.g. :class:`LocalBackend`). Args: path (`str`): A path inside the backend's environment, possibly starting with ``~``. Returns: `str`: ``path`` with a leading ``~`` / ``~/`` expanded. If ``path`` does not start with ``~``, or starts with ``~user`` (unsupported), it is returned unchanged. r~/printenvHOMENrbr-rc)r]r1seprIrrerf)rr2rghomes r expanduserzBackendBase.expandusers2 tAw#~~K t99q==T!WS$2C2G,HHHK F';<<<<<<<<}##GI#>>DDFF Kd122hrcjK|dd|gd{V}|S)aReturn ``True`` if ``path`` exists (file or directory). Args: path (`str`): Path to test inside the backend's environment. Returns: `bool`: ``True`` if the path exists, ``False`` otherwise. testz-eNrIrrr2rgs r file_existszBackendBase.file_exists@d';<<<<<<<<yy{{rcjK|dd|gd{V}|S)a Return ``True`` if ``path`` is an existing directory. Args: path (`str`): Path to test inside the backend's environment. Returns: `bool`: ``True`` if the path is an existing directory. rsz-dNrtrus rr%zBackendBase.is_dirrwrF recursiverzcK|rd|dddg}n d|dddddd g}||d {V}|sgSd |jd DS) aList entries under ``path``. Output is NUL-delimited (``find -print0`` / ``-printf '%f\0'``) and split on ``\0`` so that file names containing spaces or newlines are handled correctly. ``find -printf`` is a GNU extension; backends running on non-GNU userlands should override this method. Args: path (`str`): Directory to list inside the backend's environment. recursive (`bool`, optional): When ``True``, return all files underneath ``path`` as paths (like ``find path -type f``). When ``False`` (default), return the immediate children's base names (like ``os.listdir``). Returns: `list[str]`: The matched entries, or an empty list if ``path`` does not exist or cannot be listed. findz-typefz-print0 -mindepth1 -maxdepth-printfz%f\0Nc@g|]}||ddS)rbsurrogateescaperc)re)rUparts rrWz(BackendBase.list_dir..s?    KK(9K : :   r)rIrrsplit)rr2rzrErgs rlist_dirzBackendBase.list_dirs8  tWc9=GG Gw////////yy{{ I   ++E22    rlist[DirEntry]c VK|d|dddddtgd{VS)aList one directory level with each entry's metadata. The type, size and mtime come back from the same ``find`` run as the names, so listing a directory of N entries costs one round trip rather than 1 + 3N. Prefer this over :meth:`list_dir` plus per-entry calls whenever the metadata is wanted; ``find -printf`` is a GNU extension, so backends on non-GNU userlands should override it. ``%Y`` follows symlinks, matching what :meth:`is_dir` reports; the size and mtime describe the link itself, which only differs for the link's own few bytes. Args: path (`str`): Directory to list inside the backend's environment. Returns: `list[DirEntry]`: The immediate children, or an empty list if ``path`` does not exist or cannot be listed. r|r~rrrN _find_entries_FIND_ENTRY_FORMATr9s rscandirzBackendBase.scandirs[.''"          rDirEntry | NonecnK|d|dddtgdd{V}|r|dndS) aReturn one path's type, size and mtime in a single call. The single-path counterpart of :meth:`scandir`, the way :func:`os.stat` sits beside :func:`os.scandir`. Prefer it over asking :meth:`file_exists`, :meth:`is_dir` and :meth:`stat_mtime` in turn, which is three round trips for what one command answers. Args: path (`str`): Path to stat inside the backend's environment. Returns: `DirEntry | None`: The entry, or ``None`` if ``path`` does not exist. ``name`` is the base name, as :meth:`scandir` reports it. r|r0rTskip_unresolvableNrr)rr2entriess rstatzBackendBase.stat9si&** T;Y8J K"+        %.wqzz$.rrrc @K||d{V}|sgSg}|jdD]}|s|dddd}t |dkrD|\}}} } t |} n#t$rd} YnwxYw t| } n#t$rd} YnwxYw|d vr|rd \} } |d k} | t| | | rdn| | |S) u*Parse the records a ``_FIND_ENTRY_FORMAT`` run prints. Args: command (`list[str]`): The ``find`` argv, already carrying the format. skip_unresolvable (`bool`, defaults to ``False``): Drop entries whose target could not be followed — a dangling symlink, most often. :meth:`stat` wants this (``os.stat`` follows the link and fails, and a caller about to read the file must not be told it is there); :meth:`scandir` does not, since ``os.scandir`` lists a broken link like any other name. Returns: `list[DirEntry]`: One entry per record, or an empty list when ``find`` failed (a missing path, most often). Nrrbrrc )NL?)NNdr$r%r&r() rIrrrrer]r ValueErrorfloatappendr")rrErrgrrecordfieldskindraw_size raw_mtimer$sizer(r%s rrzBackendBase._find_entriesRs0w////////yy{{ I"$m))%00" " F ]]73D]EEKKF6{{a.4 +D(It #&x==     &+I&6&6     &&$( eS[F NN!'-7tt4     s$B,, B;:B;?C CCcBKtj|}d|d|d}|dd|gd{V}|sdS t |jdd S#t$rYdSwxYw) aReturn the modification time of ``path``, or ``None``. Tries GNU ``stat -c %Y`` first and falls back to BSD ``stat -f %m`` so the same call works across coreutils and BSD/macOS userlands. The two attempts are combined with ``||``, so this default wraps a ``sh -c`` script; backends without a POSIX shell (e.g. :class:`LocalBackend`) override it. Args: path (`str`): Path to stat inside the backend's environment. Returns: `float | None`: The modification time as a POSIX timestamp, or ``None`` if the path does not exist or cannot be stat'd. z stat -c %Y z 2>/dev/null || stat -f %m z 2>/dev/nullshz-cNrbr-rc) shlexquoterIrrrrerfr)rr2quotedscriptrgs r stat_mtimezBackendBase.stat_mtimes$T"" /& / /  / / / dF';<<<<<<<<yy{{ 4  $$WY$??EEGG    44 s:B BBcFK|dd|gd{VdS)a)Delete ``path`` (file or directory tree). If ``path`` does not exist the call is a silent no-op (like ``rm -rf``). Handles both files and directories (recursively). Args: path (`str`): Path to delete inside the backend's environment. rmz-rfN)rIr9s r delete_pathzBackendBase.delete_paths9ootUD122222222222r)r2r#r3r#rr#r2r#rr#r2r#rr)r2r#r@r#rr#rErFr@rGrDr'rr r2r#rrr2r#rMrrrNr2r#rQrRrrNr2r#rZrrrRrr#r2r#rzrrrFr2r#rrr2r#rr)rErFrrrrr2r#rr'r2r#rrN)rrrr posixpathr1rr6r8r;r=r?rBrrIrLrPrYDEFAULT_READ_CHUNK_SIZEr_rhrqrvr%rrrrrrr rrr0r0sFL )L((((4444 / / / / 0 0 0 0 - - - - 0 0 0 0    <  $ " " " " " ^" H    ^     ^ 66664233333:GGGG,""""H        $ 0 0 0 0 0 0 d" " " " H////:#( @@@@@@DB 3 3 3 3 3 3rr0dict[str, Any]cTtjdkriSddl}dt|ddiS)aReturn platform-specific subprocess creation options. Returns: `dict[str, Any]`: Extra keyword arguments for ``create_subprocess_shell``. Empty on POSIX; on Windows it sets ``creationflags`` to suppress a console window. ntrN creationflagsCREATE_NO_WINDOWi)osr$ subprocessgetattr)rs r_subprocess_creation_kwargsrsD w$        rceZdZdZejZdddd)d Zd*dZd+dZ d,dZ e fd-dZ d.dZ d/dZd0dZd0dZdd d1d"Zd2d$Zd3d&Zd4d'Zd5d(ZdS)6 LocalBackenduhHost-local :class:`BackendBase` implementation. Uses ``asyncio.create_subprocess_exec``, ``aiofiles``, and the ``os`` module. This is the default backend injected when no explicit one is given to a builtin tool. Commands are spawned directly from their argument vector (no shell), which avoids the POSIX-vs-``cmd.exe`` quoting mismatch and makes the backend work on Windows. The derived filesystem helpers are overridden with native ``os.*`` calls — faster and more robust than shelling out, and portable to Windows where ``test`` / ``find`` / ``stat`` are unavailable. NrCrErFr@rGrDr'rr cKt}|||d< tj|tjjtjjd|d{V}nV#t t tf$r<}tddt| dcYd}~Sd}~wwxYw tj | |d{V\}}nU#tj $rC|| d{Vtd dd cYSwxYwt|jpd ||S) aRun a program via ``asyncio.create_subprocess_exec``. The program is spawned directly from *command* without an intervening shell, so no argument quoting is required and the same code path works on POSIX and Windows. Args: command (`list[str]`): Executable path/name followed by its arguments. cwd (`str | None`, optional): Working directory for the subprocess. When ``None`` the current process working directory is used. timeout (`float | None`, optional): Maximum number of seconds to wait before the process is killed and an ``exit_code`` of ``-1`` is returned. Returns: `ExecResult`: The captured exit code, stdout, and stderr. If the executable cannot be found or spawned, ``exit_code`` is ``127`` (matching a shell's "command not found"), with the OS error message on stderr. Nr@)rrrrb)rrr)rDs timed outr)rasynciocreate_subprocess_execrPIPEFileNotFoundErrorNotADirectoryErrorOSErrorr r#encodewait_for communicate TimeoutErrorkill returncode) rrEr@rDkwargsprocessexcrrs rrIzLocalBackend.exec_shells<-.. ?F5M #:).). GG "#5w?    3xxw//        M#*#3##%%$$$NFFF# M M M LLNNN%%'' ' ' ' ' ' ' '3|LLL L L L M (-A    s08AB%)1B B% B%)1CAD-,D-r2r#rcKtj|d4d{V}|d{Vcdddd{VS#1d{VswxYwYdS)zRead a local file as raw bytes. Args: path (`str`): Path to the local file. Returns: `bytes`: The raw file contents. rbmodeNaiofilesopenread)rr2r}s rrLzLocalBackend.read_file3s=D111 " " " " " " "Q>>>>>> " " " " " " " " " " " " " " " " " " " " " " " " " " " " " "sA  AArMrNc0Ktj|}|rtj|dt j|d4d{V}||d{Vdddd{VdS#1d{VswxYwYdS)zWrite *data* to a local file, creating parent dirs. Args: path (`str`): Destination path on the local filesystem. data (`bytes`): The raw bytes to write. Texist_okwbrNrr2r8makedirsrrwrite)rr2rMparentr}s rrPzLocalBackend.write_fileAs*&&  / K . . . .=D111       Q''$--                                     sB BBrQrRcHKtj|}|rtj|dt j|d4d{V}|23d{V}||d{V#6 dddd{VdS#1d{VswxYwYdS)zWrite a byte stream to a local file, chunk by chunk. Args: path (`str`): Destination path on the local filesystem. stream (`AsyncIterator[bytes]`): The chunks to write, in order. TrrrNr)rr2rQrr}rVs rrYzLocalBackend.write_streamPs\&&  / K . . . .=D111 % % % % % % %Q% % % % % % % %eggenn$$$$$$$$ &v % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %sBA<B BBrZrc Ktj|d4d{V}||d{Vx}r"|WV||d{Vx}" dddd{VdS#1d{VswxYwYdS)aURead a local file chunk by chunk, never holding it whole. Args: path (`str`): Path to the local file. chunk_size (`int`, defaults to 1 MiB): The size of each yielded chunk. Yields: `bytes`: Successive chunks of the file, in order. rrNr)rr2rZr}rVs rr_zLocalBackend.read_streamds@"=D111       Q!" !3!33333333%  "# !3!33333333%                                sAA33 A=A=c,KtjS)uReturn the host process's current working directory. Returns: `str`: ``os.getcwd()`` — avoids spawning a ``pwd`` subprocess. )rrhrs rrhzLocalBackend.getcwdysy{{rcDKtj|S)u"Expand ``~`` using the host process's ``$HOME``. Args: path (`str`): A local path, possibly starting with ``~``. Returns: `str`: ``os.path.expanduser(path)`` — avoids spawning a subprocess. )rr2rqr9s rrqzLocalBackend.expandusersw!!$'''rrcDKtj|S)zCheck if a local path exists. Args: path (`str`): Path to test. Returns: `bool`: ``True`` if the path exists. )rr2existsr9s rrvzLocalBackend.file_existssw~~d###rcDKtj|S)zCheck if a local path is a directory. Args: path (`str`): Path to test. Returns: `bool`: ``True`` if the path is an existing directory. )rr2isdirr9s rr%zLocalBackend.is_dirsw}}T"""rFryrzcK|rWg}tj|D]>\}}}|D]5}|tj||6?|Stj|S)aList local directory entries. Mirrors the base contract using native ``os`` calls. Args: path (`str`): Directory to list. recursive (`bool`, optional): When ``True``, return file paths underneath ``path`` (``os.walk``). When ``False`` (default), return the immediate children's base names (``os.listdir``). Returns: `list[str]`: The matched entries. )rwalkrr2r5listdir)rr2rzresultsroot_dirsfilesr}s rrzLocalBackend.list_dirs,  !#G&(gdmm : :"eU::ANN27<<a#8#89999:Nz$rrc Kg} tj|5}|D]} |}|}|j|j}}n#t $r d\}}}YnwxYw|t|j ||rdn|| dddn #1swxYwYn#t $rgcYSwxYw|S)u List a local directory with each entry's metadata. ``os.scandir`` carries the type in the directory record itself, so this is cheaper than ``os.listdir`` followed by a ``stat`` per entry — the same reason the base class batches its ``find``. Args: path (`str`): Directory to list. Returns: `list[DirEntry]`: The immediate children, or an empty list if ``path`` does not exist or cannot be listed. )FNNNr) rrr%rst_sizest_mtimerrr"r$) rr2ritentryr%rrr(s rrzLocalBackend.scandirsV #% D!! RE@!&$zz||&*lDMe"@@@.?+eee@NN !&#)/5'?tt4"'                $   III sWB6B*6AB*A*'B*)A**3B* B6*B..B61B.2B66 CCrcK tj|}n#t$rYdSwxYwtj|}t tj|||rdn|j|jS)aReturn one local path's type, size and mtime. Args: path (`str`): Path to stat. Returns: `DirEntry | None`: The entry, or ``None`` if ``path`` does not exist or cannot be stat'd. Nr) rrrr2rr"r;rr)rr2infor%s rrzLocalBackend.stats 74==DD   44 t$$!!$''%7tt4<-     s  ''cjK tj|jS#ttf$rYdSwxYw)a3Return the modification time of a local file. Args: path (`str`): Path to stat. Returns: `float | None`: The modification time as a POSIX timestamp, or ``None`` if the path does not exist or cannot be stat'd. N)rrrrrr9s rrzLocalBackend.stat_mtime sD 74==) )*+   44 s 22cKtj|sdStj|rt j|dStj|dS)zDelete a local file or directory tree. No-op if *path* does not exist. Args: path (`str`): Path to delete. N)rr2rrshutilrmtreeremover9s rrzLocalBackend.delete_paths`w~~d##  F 7==    M$      IdOOOOOrrrrrrrrrrrrrr)rrrrrr2r1rIrLrPrYrr_rhrqrvr%rrrrrr rrrrsr   7L  $ B B B B B B H " " " "     %%%%.2* ( ( ( ( $ $ $ $ # # # #"       <&&&&P    2"rr)r)r#rr#)rr)r __future__rrrrrrabcrr dataclassesrtypesrtypingrr rrrr r"r.r0rrr rrr sB#"""""  ########!!!!!!%%%%%%%%& -  $d##########$##0 $d###$#6::::0u3u3u3u3u3#u3u3u3v.LLLLL;LLLLLr