fss-cli 0.11.0__py3-none-any.whl

fss_cli/_tree.py

@@ -0,0 +1,208 @@
+"""Walk validation and Unicode rendering for the central ``tree`` callback."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, TypeGuard
+
+from ._command import (
+    _collate,
+    _Failure,
+    _MappedOperand,
+    _run_single_operand_text,
+)
+from ._metadata import valid_display_text
+from ._path import _lexical_join, _lexical_root
+from ._walk import _IncompatibleListingError, _walk
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from fsspec.asyn import AsyncFileSystem
+
+    from ._app import AsyncFilesystemSource
+
+_WALK_ROW_LENGTH = 3
+
+
+@dataclass(frozen=True)
+class _TreeRequest:
+    maxdepth: int | None
+    operand: _MappedOperand
+
+
+@dataclass(frozen=True)
+class _WalkRow:
+    root: str
+    directories: tuple[str, ...]
+    files: tuple[str, ...]
+
+
+def _valid_root(value: object) -> TypeGuard[str]:
+    return type(value) is str and valid_display_text(value)
+
+
+def _valid_entry(value: object, *, root_file: bool = False) -> TypeGuard[str]:
+    return type(value) is str and (bool(value) or root_file) and "/" not in value and valid_display_text(value)
+
+
+def _entries(
+    values: Sequence[object],
+    *,
+    root_file: bool = False,
+) -> tuple[str, ...] | None:
+    entries: list[str] = []
+    for value in values:
+        if not _valid_entry(value, root_file=root_file):
+            return None
+        entries.append(value)
+    if len(set(entries)) != len(entries):
+        return None
+    return tuple(entries)
+
+
+def _row(value: object) -> _WalkRow | None:
+    if type(value) is not tuple or len(value) != _WALK_ROW_LENGTH:
+        return None
+    root, directories, files = value
+    if not (_valid_root(root) and type(directories) is list and type(files) is list):
+        return None
+    typed_directories = _entries(directories)
+    typed_files = _entries(files, root_file=True)
+    if typed_directories is None or typed_files is None:
+        return None
+    if set(typed_directories).intersection(typed_files):
+        return None
+    return _WalkRow(root, typed_directories, typed_files)
+
+
+def _index_rows(values: list[object]) -> tuple[_WalkRow, dict[str, _WalkRow]] | None:
+    indexed: dict[str, _WalkRow] = {}
+    first = None
+    for value in values:
+        row = _row(value)
+        if row is None:
+            return None
+        if first is None:
+            first = row
+        canonical = _lexical_root(row.root)
+        if canonical in indexed:
+            return None
+        indexed[canonical] = row
+    if first is None:
+        return None
+    return first, indexed
+
+
+def _valid_root_file(rows: Mapping[str, _WalkRow], root: _WalkRow) -> bool:
+    rows_with_empty_file = [row for row in rows.values() if "" in row.files]
+    if not rows_with_empty_file:
+        return True
+    return rows_with_empty_file == [root] and root.directories == () and root.files == ("",) and len(rows) == 1
+
+
+def _all_rows_reachable(rows: Mapping[str, _WalkRow], root: _WalkRow) -> bool:
+    reachable = {_lexical_root(root.root)}
+    pending = [root]
+    while pending:
+        parent = pending.pop()
+        for directory in parent.directories:
+            child_key = _lexical_root(_lexical_join(parent.root, directory))
+            child = rows.get(child_key)
+            if child is not None and child_key not in reachable:
+                reachable.add(child_key)
+                pending.append(child)
+    return reachable == rows.keys()
+
+
+def _validated_rows(
+    request: _TreeRequest,
+    values: list[object],
+) -> Mapping[str, _WalkRow] | None:
+    indexed = _index_rows(values)
+    if indexed is None:
+        return None
+    root, rows = indexed
+
+    root_key = _lexical_root(root.root)
+    if root_key != _lexical_root(request.operand.path):
+        return None
+    if not _valid_root_file(rows, root):
+        return None
+    if not _all_rows_reachable(rows, root):
+        return None
+    return rows
+
+
+def _sorted_entries(entries: tuple[str, ...]) -> list[str]:
+    return sorted(entries, key=_collate)
+
+
+def _render_tree(request: _TreeRequest, rows: Mapping[str, _WalkRow]) -> str:
+    lines = [request.operand.path]
+    root = rows[_lexical_root(request.operand.path)]
+    if root.files == ("",):
+        return f"{request.operand.path}\n"
+
+    stack: list[tuple[_WalkRow, int, str, str, bool, bool]] = []
+
+    def push_children(row: _WalkRow, depth: int, prefix: str) -> None:
+        if request.maxdepth is not None and depth >= request.maxdepth:
+            return
+        directories = _sorted_entries(row.directories)
+        files = _sorted_entries(row.files)
+        children = [(name, True) for name in directories]
+        children.extend((name, False) for name in files)
+        for index in range(len(children) - 1, -1, -1):
+            name, is_directory = children[index]
+            is_last = index == len(children) - 1
+            stack.append((row, depth, prefix, name, is_directory, is_last))
+
+    push_children(root, 0, "")
+    while stack:
+        parent, depth, prefix, name, is_directory, is_last = stack.pop()
+        connector = "└── " if is_last else "├── "
+        lines.append(f"{prefix}{connector}{name}")
+        if not is_directory:
+            continue
+        child = rows.get(_lexical_root(_lexical_join(parent.root, name)))
+        if child is None:
+            continue
+        continuation = "    " if is_last else "│   "
+        push_children(child, depth + 1, prefix + continuation)
+
+    return "\n".join(lines) + "\n"
+
+
+async def _walk_tree(
+    request: _TreeRequest,
+    filesystem: AsyncFileSystem,
+) -> str | _Failure:
+    try:
+        listed = await _walk(
+            filesystem,
+            request.operand.path,
+            maxdepth=1 if request.maxdepth == 0 else request.maxdepth,
+        )
+    except _IncompatibleListingError:
+        return _Failure(request.operand)
+    except Exception as error:  # noqa: BLE001 - classify awaited backend failure.
+        return _Failure(request.operand, backend_error=error)
+    values: list[object] = [(row.root, list(row.directories), list(row.files)) for row in listed]
+    rows = _validated_rows(request, values)
+    if rows is None:
+        return _Failure(request.operand)
+    return _render_tree(request, rows)
+
+
+async def _run_tree(
+    command: str,
+    request: _TreeRequest,
+    sources: Mapping[str, AsyncFilesystemSource],
+) -> None:
+    await _run_single_operand_text(
+        command,
+        request.operand,
+        sources,
+        lambda filesystem: _walk_tree(request, filesystem),
+    )

fss_cli/_unlink.py

@@ -0,0 +1,90 @@
+"""Typed async execution for ``unlink``."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from ._command import (
+    _drain_current_operation,
+    _Failure,
+    _MappedOperand,
+    _raise_operand_failures,
+    _render_backend_failure,
+    _render_operand_diagnostic,
+    _run_mapped_command,
+)
+
+if TYPE_CHECKING:
+    from fsspec.asyn import AsyncFileSystem
+
+    from ._app import AsyncFilesystemSource
+
+
+@dataclass(frozen=True)
+class _UnlinkFailure(_Failure):
+    """A failure raised on the single-file removal path.
+
+    Structurally identical to the base failure; the distinct type is how ``rm``
+    tells a file-path failure from a directory-path one, because the two render
+    different diagnostic vocabularies for the same condition.
+    """
+
+
+async def _confirmed_rm_file(  # noqa: PLR0911 - explicit outcome branches.
+    operand: _MappedOperand,
+    filesystem: AsyncFileSystem,
+) -> _UnlinkFailure | None:
+    """Remove one source-reported file and confirm absence."""
+    try:
+        info = await _drain_current_operation(filesystem._info(operand.path))
+    except Exception as error:  # noqa: BLE001 - classify awaited backend failure.
+        return _UnlinkFailure(operand, backend_error=error)
+
+    if not isinstance(info, Mapping) or not isinstance(info.get("type"), str):
+        return _UnlinkFailure(operand, incompatible="result")
+
+    result_type = info["type"]
+    if result_type == "directory":
+        return _UnlinkFailure(operand, incompatible="directory")
+    if result_type != "file":
+        return _UnlinkFailure(operand, incompatible="result")
+
+    try:
+        await _drain_current_operation(filesystem._rm_file(operand.path))
+    except Exception as error:  # noqa: BLE001 - mutation may have partially applied.
+        return _UnlinkFailure(operand, backend_error=error, uncertain=True)
+
+    try:
+        await _drain_current_operation(filesystem._info(operand.path))
+    except FileNotFoundError:
+        return None
+    except Exception as error:  # noqa: BLE001 - never hide non-not-found errors.
+        return _UnlinkFailure(operand, backend_error=error, uncertain=True)
+    else:
+        return _UnlinkFailure(operand, uncertain=True)
+
+
+def _render_failure(command: str, failure: _UnlinkFailure) -> None:
+    if failure.uncertain:
+        _render_operand_diagnostic(command, failure.operand, "uncertain mutation state")
+    elif failure.incompatible == "directory":
+        _render_operand_diagnostic(command, failure.operand, "is a directory")
+    elif failure.incompatible == "result" or failure.backend_error is None:
+        _render_operand_diagnostic(command, failure.operand, "incompatible result")
+    else:
+        _render_backend_failure(command, failure.operand, failure.backend_error)
+
+
+async def _run_unlink(
+    command: str,
+    operand: _MappedOperand,
+    sources: Mapping[str, AsyncFilesystemSource],
+) -> None:
+    async def operation(filesystems: Mapping[str, AsyncFileSystem]) -> None:
+        failure = await _confirmed_rm_file(operand, filesystems[operand.name])
+        if failure is not None:
+            _raise_operand_failures(command, (failure,), _render_failure)
+
+    await _run_mapped_command(command, (operand,), sources, operation)

fss_cli/_walk.py

@@ -0,0 +1,141 @@
+"""Breadth-first directory walks over bounded concurrent ``_ls`` listings.
+
+fsspec's inherited ``_walk`` lists one directory at a time, and its nested
+calls do not forward ``on_error``: with ``on_error="raise"`` an unreadable
+*descendant* is silently treated as empty, so a walk can report success with
+content missing. Commands that walk a tree therefore list it here instead:
+every directory of one depth is listed concurrently under the shared bound,
+and a listing failure at **any** depth raises.
+
+Rows match fsspec's ``_walk(detail=True)`` format. Each row contains the listed
+root and child directory and file metadata, keyed by basename. A file-like
+entry for the root itself uses the key ``""``. This module checks the fields
+needed to build a row. Commands validate the remaining fields under ADR 0006.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import partial
+from typing import TYPE_CHECKING, cast
+
+from ._command import _call
+from ._concurrent import _outcome_value, _run_bounded
+from ._path import _lexical_join, _same_lexical_path
+from ._results import _BadResultError, snapshot_listing
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from fsspec.asyn import AsyncFileSystem
+
+
+class _IncompatibleListingError(Exception):
+    """A listing whose shape cannot form a walk row."""
+
+
+class _ListingLimitError(Exception):
+    """A listing longer than the caller's remaining entry capacity."""
+
+
+@dataclass(frozen=True)
+class _ListedRow:
+    """One listed directory, shaped like an fsspec ``_walk(detail=True)`` row."""
+
+    root: str
+    directories: Mapping[str, Mapping[object, object]]
+    files: Mapping[str, Mapping[object, object]]
+
+
+def _listed_row(
+    root: str,
+    listing: object,
+    capacity: int | None,
+) -> tuple[_ListedRow, tuple[str, ...]]:
+    """Freeze one ``_ls(detail=True)`` result into a row and its child paths.
+
+    The listing length is checked against ``capacity`` before any entry is
+    read, so an oversized listing is refused without materializing it.
+    """
+    if not isinstance(listing, list):
+        raise _IncompatibleListingError
+    if capacity is not None and len(listing) > capacity:
+        raise _ListingLimitError
+    try:
+        indexed = snapshot_listing(root, listing)
+    except _BadResultError as error:
+        raise _IncompatibleListingError from error
+    directories: dict[str, Mapping[object, object]] = {}
+    files: dict[str, Mapping[object, object]] = {}
+    children: list[str] = []
+    for value in indexed.values():
+        info = cast("Mapping[object, object]", value)
+        pathname = cast("str", info["name"]).rstrip("/")
+        if _same_lexical_path(pathname, root):
+            collection, key = files, ""
+        else:
+            key = pathname.rsplit("/", 1)[-1]
+            collection = directories if info["type"] == "directory" else files
+        collection[key] = info
+        if collection is directories:
+            children.append(_lexical_join(root, key))
+    return _ListedRow(root, directories, files), tuple(children)
+
+
+async def _walk(
+    filesystem: AsyncFileSystem,
+    root: str,
+    *,
+    maxdepth: int | None = None,
+    accept: Callable[[_ListedRow], None] | None = None,
+    capacity: Callable[[], int] | None = None,
+) -> list[_ListedRow]:
+    """List ``root`` and its descendants breadth-first.
+
+    Every directory of one depth is listed concurrently under the shared
+    bound. Rows are frozen and passed to ``accept`` in breadth-first order,
+    before any directory of the next depth is listed, so a caller rejecting a
+    row stops the walk before it reads further.
+
+    Args:
+        filesystem: The async filesystem to list.
+        root: The directory (or file) to walk, passed to ``_ls`` literally.
+        maxdepth: Number of directory levels to list; ``None`` is unbounded.
+        accept: Optional validator for each row; raising stops the walk.
+        capacity: Optional remaining-entry budget checked before each listing
+            is materialized.
+
+    Returns:
+        Every listed row in breadth-first order.
+
+    Raises:
+        _IncompatibleListingError: A listing has an unusable shape.
+        _ListingLimitError: A listing exceeds the remaining capacity.
+        Exception: The first listing failure in breadth-first order.
+    """
+    rows: list[_ListedRow] = []
+    level = [root]
+    depth = 1
+    while level:
+        outcomes = await _run_bounded(
+            [partial(_call, filesystem, "_ls", directory, detail=True) for directory in level]
+        )
+        next_level: list[str] = []
+        # Settle in breadth-first order, so an earlier malformed listing wins
+        # over a later sibling's listing failure.
+        for directory, outcome in zip(level, outcomes, strict=True):
+            listing = _outcome_value(outcome)
+            row, children = _listed_row(
+                directory,
+                listing,
+                None if capacity is None else capacity(),
+            )
+            if accept is not None:
+                accept(row)
+            rows.append(row)
+            next_level.extend(children)
+        if maxdepth is not None and depth >= maxdepth:
+            break
+        level = next_level
+        depth += 1
+    return rows

fss_cli-0.11.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: fss-cli
+Version: 0.11.0
+Summary: Library-only POSIX-shaped commands for async fsspec filesystems
+Keywords: fsspec,cli,posix,typer,filesystem
+Author: Shiny Brar  (he/il)
+Author-email: Shiny Brar  (he/il) <charanjotbrar@gmail.com>
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Utilities
+Requires-Dist: fsspec>=2026.6.0
+Requires-Dist: rich>=13.8.0
+Requires-Dist: typer>=0.27.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/opencadc/fsspec-tools
+Project-URL: Documentation, https://opencadc.github.io/fsspec-tools/
+Project-URL: Repository, https://github.com/opencadc/fsspec-tools
+Project-URL: Issues, https://github.com/opencadc/fsspec-tools/issues
+Project-URL: Changelog, https://github.com/opencadc/fsspec-tools/blob/main/libs/fss-cli/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# fss-cli
+
+[![CI](https://github.com/opencadc/fsspec-tools/actions/workflows/ci.yml/badge.svg)](https://github.com/opencadc/fsspec-tools/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
+[![License: AGPL-3.0-or-later](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)](LICENSE)
+
+`fss-cli` provides POSIX-shaped [Typer](https://typer.tiangolo.com/) commands
+for async [`fsspec`](https://github.com/fsspec/filesystem_spec) filesystems.
+Your application configures the filesystems and embeds the commands in its CLI.
+The package installs no executable or module entry point.
+
+Releases up to 0.10.0 were named `fsspec-cli`, imported as `fsspec_cli`. See
+[ADR 0010](../../docs/adr/0010-rename-fsspec-cli-to-fss-cli.md).
+
+## Install
+
+```bash
+uv add "git+https://github.com/opencadc/fsspec-tools@main#subdirectory=libs/fss-cli"
+```
+
+## Quick start
+
+```python
+from contextlib import asynccontextmanager
+
+import fsspec
+import typer
+from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+from fss_cli import App
+
+
+@asynccontextmanager
+async def data_source():
+    # One fresh async-capable filesystem per command invocation.
+    yield AsyncFileSystemWrapper(fsspec.filesystem("memory"))
+
+
+app = typer.Typer()
+app.add_typer(App({"data": data_source}).typer_app, name="fs")
+
+if __name__ == "__main__":
+    app()
+```
+
+Operands use `name:/path` to select a configured source:
+
+```bash
+python app.py fs ls data:/
+```
+
+The example uses an in-memory filesystem. The
+[overview](https://opencadc.github.io/fsspec-tools/cli/) shows how to configure
+local disk and a remote VOSpace archive. With sources named `local` and `archive`,
+copy a file between them with:
+
+```bash
+python app.py fs cp local:/results.csv archive:/2026/results.csv
+```
+
+## Commands
+
+`ls` · `du` · `find` · `tree` · `size` · `test` · `info` · `stat` ·
+`head` · `tail` · `cat` · `cp` · `mv` · `mkdir` · `rmdir` · `unlink` · `rm`.
+
+Recursive `cp -R` is available by default. Enable recursive `rm -R` explicitly:
+
+```python
+App({"data": data_source}, capabilities={"recursion": {"remove": True}})
+```
+
+## Public API
+
+`App`, `AppCapabilities`, `RecursionCapabilities`, `AsyncFilesystemSource`,
+`CommandCallback`, and `CommandContext`.
+
+## Documentation
+
+| For | Read |
+| --- | --- |
+| Embedding it: sources, lifecycle, capabilities, exit statuses | [Integration guide](https://opencadc.github.io/fsspec-tools/cli/integration/) |
+| What each command does | [Command reference](https://opencadc.github.io/fsspec-tools/cli/commands/) |
+| The public API | [API reference](https://opencadc.github.io/fsspec-tools/cli/api-reference/) |
+| The command contract and its rationale | [`docs/design/`](docs/design/) |
+| Architecture decisions | [`docs/adr/`](../../docs/adr/) |
+
+## Scope
+
+`fss-cli` uses familiar shell layouts for backend metadata and marks missing
+values as unknown. It does not claim POSIX, GNU, BSD/macOS, or all-fsspec
+compatibility. Supported host platforms are Linux and macOS.
+
+## License
+
+Copyright (c) 2026 National Research Council of Canada / Government of Canada.
+
+`fss-cli` is distributed under the terms of the
+[GNU Affero General Public License v3.0 or later](LICENSE) (AGPL-3.0-or-later).
+`fss-cli` 0.10.0 and earlier releases were published under the BSD 3-Clause
+License.
+
+## Long listings and repeated copies
+
+`ls -l` keeps shell column order even when metadata is sparse. Unknown scalar
+fields show `-`, unknown permission bits show `?`, and old dates show the year.
+VOSpace access groups share one field (`r=OSSOS,w=NONE`) rather than implying
+POSIX group ownership; raw access and lock metadata remain available in `info`.
+
+Recursive `cp -R` skips files only after compatible MD5 metadata or staged
+SHA-256 comparison establishes equality. Equal size alone is insufficient.
+Without content checksums, comparison downloads both files. If their contents
+differ, the upload reuses the staged source bytes.

fss_cli-0.11.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+fss_cli/__init__.py,sha256=rDS1Ud7EN7h23W8vOayqeELLvv8yBsdRj8F3aXZYas8,520
+fss_cli/_accounts.py,sha256=VEuXGonYn3NINHye2Sv8XX0DV84iLtslDbpE-Bpkrg0,819
+fss_cli/_app.py,sha256=ONAJgoRK9ZKCCm661uchV2x6JPhMYY0xlXsf5Aczeyw,22546
+fss_cli/_cat.py,sha256=oUjJBTpQShMvksEGZlcc7K4KS5ud8XuK-Wb9_oegTYc,12484
+fss_cli/_command.py,sha256=tv2VpnIQihYTB2S8N45iVTbCvrCWGcsOVUb066o3RX4,11993
+fss_cli/_concurrent.py,sha256=L70Omh5wOq8H5JGidKWldWpVcQQHaQ1Jgtnc44AKyXI,6832
+fss_cli/_content.py,sha256=eQeLl3HAJqVCAO3IT0cgSjy8uVOf5i4nGccvDkSgp2M,3202
+fss_cli/_copy_file.py,sha256=9wdrDyZvrORyHBSbuLn6rrDBupzH9LLmmk9G1pFqCzc,1912
+fss_cli/_cp.py,sha256=i6ZAkhjumzpo9dP_3i5dUDeqqJ8YObltIsQ65eNOOjs,24854
+fss_cli/_diagnostics.py,sha256=05JPZ0U-zZqN8MoPNXG06fiouVQQ_kzbKnj9HMsQPbE,347
+fss_cli/_du.py,sha256=McMYQ8r-YoLYnbKcIjImZFmngccRGpWeB_oejhFMJg8,2668
+fss_cli/_find.py,sha256=kGAJuC7fpyYhso4o0jbpPF4s7HMtbca6TYrwnndF334,3358
+fss_cli/_head_tail.py,sha256=Y6Bpk69zjEd3D2xIjR9CK_M5TIOMglCv2jkzAcZqG8o,3946
+fss_cli/_info.py,sha256=ocWr-G__32FBWoxX9ueKo6sl_6UP5AYFsxTbq8R87eE,5373
+fss_cli/_listing.py,sha256=HP96xZx7ZRaxJjTvRO7KnMpIO3u3uAgyyhYZ8CYrp2I,9352
+fss_cli/_logging.py,sha256=T-frFsVEWWA6rm3KeDAi2fNyUiWBm-zC9tKLR9PODf0,2272
+fss_cli/_ls.py,sha256=pxy2BrLGMgZKzHd21CqRyEgF1abHBo8Szo_v0Y26riU,13959
+fss_cli/_manifest.py,sha256=iMDQQ7belP9TzMX5FN1zTVy_wFnJ7YQRV6BQcLdQ-rM,8068
+fss_cli/_metadata.py,sha256=jhFZndn-vOqpoEB-wbUTm5m8PK9V2g8wr8s6RwEsv2o,2246
+fss_cli/_mkdir.py,sha256=l4TDDYJshADcy7C3H38BcCccVbCF931W90fsKzNolMI,2972
+fss_cli/_mv.py,sha256=7f27UZjiPXYO72D5plnOFu63c3baSBjCgUjnVCHh-fY,4502
+fss_cli/_path.py,sha256=le9_z48UVLTxSjlJ5ciAM6O8DNOXFKUT-edi16pKygQ,1723
+fss_cli/_post_copy.py,sha256=aXnt_bDsIwL5AFGlmkDmzvo6nAaY7qILa56NNFXVYSw,6777
+fss_cli/_progress.py,sha256=E_pc6QBwSmTNf3iSsFTeBRAUV1hLded3ZTa9mALFW6Q,4531
+fss_cli/_recursive_cp.py,sha256=WNVtLuGFNm5NZYtZhN51WliHCP0iuuA8g9T6h96RR3Y,33604
+fss_cli/_recursive_rm.py,sha256=Rm_9B9AES81aCbfKsXQ57qf2-5UArYQ-7tg7FuhMQ9w,10635
+fss_cli/_results.py,sha256=uNkc_28nQkcCnaJPioHxlcBiDJnqJ7j2TnCfP5-NgQQ,4484
+fss_cli/_rm.py,sha256=-sNFtCu7T9edhKNc4YXPNp4EZEWsubpRx0HcX6uT-aE,4848
+fss_cli/_rmdir.py,sha256=CvrDQP2UrEMUT2c7t2_g_O7RJAgdWSfwoeZ2ARNbE7o,5249
+fss_cli/_size.py,sha256=IRi1ALxu4R6Hkq1uMKnwzJ0z6Gf4DOXNpWHq4BANBIA,2895
+fss_cli/_sources.py,sha256=QJDLz0f0UNuspu28-imMKyyycsT3McarLiD_Yyh-kls,6684
+fss_cli/_stat.py,sha256=N6rI5ac5M2uw_jEwtnXzJdRmJYCxZStj60b0xbbSwpg,5863
+fss_cli/_test.py,sha256=qfyYeRmoibS1Hr9uJqnqXbqo8M31VvyvKDOuQPbF8vY,1614
+fss_cli/_tree.py,sha256=Fuldi4jIJnmkus25R7eLOlyT4mxx5kaCoI9wnQM-h-s,6525
+fss_cli/_unlink.py,sha256=5cp94CidKvouXuIKDow4nSzc8hrK7ePWLBZ4zU4agoU,3299
+fss_cli/_walk.py,sha256=4zuoFRAKZqFxze-a5E8q5f4lVqRgtkMipOtRVb8pm84,5272
+fss_cli-0.11.0.dist-info/licenses/LICENSE,sha256=dql8h4yceoMhuzlcK0TT_i-NgTFNIZsgE47Q4t3dUYI,34520
+fss_cli-0.11.0.dist-info/WHEEL,sha256=si2p8vW03RnhyBnhWl4tj-ObJa78SpE-c9HsEtblGR0,80
+fss_cli-0.11.0.dist-info/METADATA,sha256=UJw4pfU6ec0v5h-f5QBCk3lgIswcfdjZ6o_Gr6fH3CI,5410
+fss_cli-0.11.0.dist-info/RECORD,,

fss_cli-0.11.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.5
+Root-Is-Purelib: true
+Tag: py3-none-any