protonfs 0.1.dev43__py3-none-any.whl

protonfs/install.py

@@ -0,0 +1,288 @@
+# src/protonfs/install.py
+"""Self-diagnosing installer for the `proton-drive` prebuilt binary (Tier 3).
+
+`pip install protonfs` gives you the Python package; `protonfs install-drive`
+fetches and verifies the official `proton-drive` CLI binary, and `protonfs auth
+login` (a thin passthrough) authenticates it. The installer detects the
+platform, hard-gates on AVX2 for the linux-x64 Bun-compiled prebuilt, downloads
+over HTTPS and verifies the pinned SHA-512 before ever marking the binary
+executable — it never installs an unverified binary.
+
+Design notes / accepted deviations from the roadmap decision text:
+- The decision described a bash installer checking curl/unzip. This Python
+  implementation downloads via urllib and verifies via hashlib, so those external
+  tools are not prerequisites; the decision's intent (self-diagnosing,
+  resolve-what-it-can, precise instructive errors) is preserved and the installer
+  is unit-testable.
+- The no-AVX2 path emits precise build-from-source instructions rather than
+  automating a Bun-baseline source build. That path is defensive only (no current
+  target machine lacks AVX2), so automating it is deferred as YAGNI.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import platform as _platform
+import shutil
+import stat
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+
+DEFAULT_VERSION = "0.4.6"
+VERSION_ENV = "PROTONFS_DRIVE_VERSION"
+SHA512_ENV = "PROTONFS_DRIVE_SHA512"
+DOWNLOAD_BASE = "https://proton.me/download/drive/cli"
+DOWNLOAD_TIMEOUT = 60  # seconds; avoids a stalled connection hanging the installer
+
+# Pinned SHA-512 of the official prebuilt, keyed by (version, slug). linux-x64 is
+# verified against the released 0.4.6 binary. darwin checksums are added when a
+# maintainer pins them from the official downloads; until then those platforms
+# require an explicit PROTONFS_DRIVE_SHA512 override (we never install unverified).
+PINNED_SHA512 = {
+    ("0.4.6", "linux-x64"): (
+        "d187409932742e6fdc6aae2995998f4c89ea51999283395bc8d0bdc5343a79d3"
+        "1bf5a485d5af9adf3b7909fc92f2d2ef0b133edc4939d5faf1d096eb744425bb"
+    ),
+}
+
+# glibc below this is too old for the Bun-compiled linux-x64 prebuilt. Bun supports
+# glibc >= 2.17 (per the roadmap's target-machine survey: exo2 on CentOS 7 / glibc
+# 2.17 is a confirmed headless-installable target), so we only warn below that.
+MIN_GLIBC = (2, 17)
+
+
+class InstallError(RuntimeError):
+    """Raised with a precise, instructive message when install cannot proceed."""
+
+
+@dataclass
+class Platform:
+    slug: str  # e.g. "linux-x64"
+    os_name: str  # "linux" | "darwin"
+    arch: str  # "x64" | "arm64"
+
+
+@dataclass
+class InstallResult:
+    path: Path
+    on_path: bool
+    sha512: str
+    warnings: list[str] = field(default_factory=list)
+
+
+def detect_platform(system: str | None = None, machine: str | None = None) -> Platform:
+    system = (system or _platform.system()).lower()
+    machine = (machine or _platform.machine()).lower()
+    if machine in ("x86_64", "amd64"):
+        arch = "x64"
+    elif machine in ("arm64", "aarch64"):
+        arch = "arm64"
+    else:
+        raise InstallError(
+            f"unsupported CPU architecture '{machine}'. The proton-drive prebuilt is "
+            f"published for x86_64 and arm64 only."
+        )
+    if system == "linux":
+        if arch != "x64":
+            raise InstallError(
+                f"no official proton-drive prebuilt for linux-{arch}; only linux-x64 is "
+                f"published. Build from source or run on an x86_64 host."
+            )
+        slug = "linux-x64"
+        os_name = "linux"
+    elif system == "darwin":
+        slug = f"darwin-{arch}"
+        os_name = "darwin"
+    else:
+        raise InstallError(
+            f"unsupported OS '{system}'. proton-drive prebuilts exist for linux and macOS."
+        )
+    return Platform(slug=slug, os_name=os_name, arch=arch)
+
+
+def resolve_version(version: str | None = None) -> str:
+    return version or os.environ.get(VERSION_ENV) or DEFAULT_VERSION
+
+
+def binary_url(version: str, slug: str) -> str:
+    return f"{DOWNLOAD_BASE}/{version}/{slug}/proton-drive"
+
+
+def pinned_sha512(version: str, slug: str) -> str | None:
+    """The expected SHA-512, from the env override first, then the pinned table."""
+    override = os.environ.get(SHA512_ENV)
+    if override:
+        return override.strip().lower()
+    return PINNED_SHA512.get((version, slug))
+
+
+def has_avx2(cpuinfo_text: str | None = None) -> bool:
+    """Whether the CPU advertises AVX2 (read from /proc/cpuinfo on linux)."""
+    if cpuinfo_text is None:
+        try:
+            cpuinfo_text = Path("/proc/cpuinfo").read_text()
+        except OSError:
+            return False
+    for line in cpuinfo_text.splitlines():
+        if line.startswith("flags") and "avx2" in line.split():
+            return True
+    return False
+
+
+def _glibc_version(raw: str | None = None) -> tuple[int, int] | None:
+    """Parse the running glibc version, e.g. 'glibc 2.35' -> (2, 35). None if unknown."""
+    if raw is None:
+        libc, _ = _platform.libc_ver()
+        raw = _platform.libc_ver()[1] if libc == "glibc" else ""
+    if not raw:
+        return None
+    try:
+        major, minor = (int(x) for x in raw.split(".")[:2])
+    except (ValueError, IndexError):
+        return None
+    return (major, minor)
+
+
+def diagnose(plat: Platform, cpuinfo_text: str | None = None,
+             glibc_raw: str | None = None) -> list[str]:
+    """Return a list of warning strings for soft issues (empty == all clear).
+
+    Hard blockers (missing AVX2, unverifiable checksum) are raised by
+    install_drive; diagnose covers advisory concerns like an old glibc.
+    """
+    warnings: list[str] = []
+    if plat.os_name == "linux":
+        glibc = _glibc_version(glibc_raw)
+        if glibc is not None and glibc < MIN_GLIBC:
+            warnings.append(
+                f"glibc {glibc[0]}.{glibc[1]} detected; the linux-x64 prebuilt targets "
+                f">= {MIN_GLIBC[0]}.{MIN_GLIBC[1]} and may fail to start on this host."
+            )
+    return warnings
+
+
+def _no_avx2_message() -> str:
+    have_bun = shutil.which("bun") is not None
+    have_git = shutil.which("git") is not None
+    steps = (
+        "This CPU lacks AVX2, which the official linux-x64 prebuilt requires. "
+        "Build a Bun-baseline binary from source instead:"
+    )
+    prereqs = []
+    if not have_bun:
+        prereqs.append("install Bun (https://bun.sh)")
+    if not have_git:
+        prereqs.append("install git")
+    if prereqs:
+        return (
+            f"{steps} first {', and '.join(prereqs)}, then clone "
+            f"github.com/ProtonDriveApps/sdk and build the CLI with a baseline target, "
+            f"and point PROTONFS_DRIVE_BIN at the result."
+        )
+    return (
+        f"{steps} clone github.com/ProtonDriveApps/sdk, build the CLI with "
+        f"`bun build --compile --target=bun-linux-x64-baseline`, and point "
+        f"PROTONFS_DRIVE_BIN at the result."
+    )
+
+
+def resolve_install_dir(path_env: str | None = None) -> tuple[Path, bool]:
+    """Return (install_dir, on_path). Prefer ~/.local/bin when it is on PATH; else a
+    managed dir the user surfaces via PROTONFS_DRIVE_BIN."""
+    local_bin = Path.home() / ".local" / "bin"
+    path_value = os.environ.get("PATH", "") if path_env is None else path_env
+    on_path = str(local_bin) in path_value.split(os.pathsep)
+    if on_path:
+        return local_bin, True
+    managed = Path.home() / ".local" / "share" / "protonfs" / "bin"
+    return managed, False
+
+
+def _default_opener(url: str):
+    return urllib.request.urlopen(url, timeout=DOWNLOAD_TIMEOUT)
+
+
+def download_and_verify(url: str, expected_sha512: str, dest: Path, opener=None) -> str:
+    """Download `url`, verify its SHA-512 equals `expected_sha512`, and write it to
+    `dest` (only after verification). Returns the verified digest. Raises InstallError
+    on any network/HTTP error or checksum mismatch, always leaving no partial file
+    behind."""
+    opener = opener or _default_opener
+    hasher = hashlib.sha512()
+    tmp = dest.with_suffix(dest.suffix + ".part")
+    tmp.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        with opener(url) as resp, open(tmp, "wb") as out:
+            while True:
+                chunk = resp.read(1024 * 256)
+                if not chunk:
+                    break
+                hasher.update(chunk)
+                out.write(chunk)
+    except OSError as exc:
+        # urllib.error.URLError/HTTPError subclass OSError, as do socket timeouts.
+        tmp.unlink(missing_ok=True)
+        raise InstallError(
+            f"failed to download {url}: {exc}. Check your connection, or verify "
+            f"{VERSION_ENV} points at a real release."
+        ) from exc
+    digest = hasher.hexdigest()
+    if digest.lower() != expected_sha512.lower():
+        tmp.unlink(missing_ok=True)
+        raise InstallError(
+            f"SHA-512 mismatch for {url}: expected {expected_sha512}, got {digest}. "
+            f"Refusing to install an unverified binary."
+        )
+    tmp.replace(dest)
+    return digest
+
+
+def install_drive(
+    version: str | None = None,
+    plat: Platform | None = None,
+    dest_dir: Path | None = None,
+    cpuinfo_text: str | None = None,
+    downloader=None,
+) -> InstallResult:
+    """Detect, diagnose, download+verify and install the proton-drive binary."""
+    version = resolve_version(version)
+    plat = plat or detect_platform()
+
+    if plat.os_name == "linux" and not has_avx2(cpuinfo_text):
+        raise InstallError(_no_avx2_message())
+
+    expected = pinned_sha512(version, plat.slug)
+    if expected is None:
+        raise InstallError(
+            f"no pinned SHA-512 for proton-drive {version} on {plat.slug}. Set "
+            f"{SHA512_ENV} to the official checksum to install, or install manually. "
+            f"Refusing to install an unverified binary."
+        )
+
+    if dest_dir is None:
+        dest_dir, on_path = resolve_install_dir()
+    else:
+        on_path = str(dest_dir) in os.environ.get("PATH", "").split(os.pathsep)
+
+    warnings = diagnose(plat, cpuinfo_text)
+    override = os.environ.get(SHA512_ENV)
+    base_pin = PINNED_SHA512.get((version, plat.slug))
+    if override and base_pin and override.strip().lower() != base_pin.lower():
+        warnings.append(
+            f"{SHA512_ENV} overrides the pinned checksum for {plat.slug} {version}; "
+            f"installing against the override, not the audited pin."
+        )
+    url = binary_url(version, plat.slug)
+    dest = dest_dir / "proton-drive"
+    digest = download_and_verify(url, expected, dest, opener=downloader)
+
+    mode = dest.stat().st_mode
+    dest.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    if not on_path:
+        warnings.append(
+            f"{dest_dir} is not on PATH; export PROTONFS_DRIVE_BIN={dest} (or add the "
+            f"directory to PATH) so protonfs can find the binary."
+        )
+    return InstallResult(path=dest, on_path=on_path, sha512=digest, warnings=warnings)

protonfs/lfs.py

@@ -0,0 +1,37 @@
+# src/protonfs/lfs.py
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+POINTER_SIGNATURE = "version https://git-lfs.github.com/spec/v1"
+
+
+def is_lfs_tracked(repo_root: Path) -> bool:
+    gitattributes = repo_root / ".gitattributes"
+    if gitattributes.exists() and "filter=lfs" in gitattributes.read_text():
+        return True
+    result = subprocess.run(
+        ["git", "-C", str(repo_root), "lfs", "ls-files"],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def is_pointer_stub(path: Path) -> bool:
+    try:
+        with path.open("r", errors="ignore") as fh:
+            first_line = fh.readline()
+    except OSError:
+        return False
+    return first_line.strip() == POINTER_SIGNATURE
+
+
+def find_pointer_stubs(root: Path, subpath: Path) -> list[Path]:
+    base = root / subpath if subpath != Path(".") else root
+    stubs = []
+    for file_path in sorted(base.rglob("*")):
+        if file_path.is_file() and file_path.stat().st_size < 200 and is_pointer_stub(file_path):
+            stubs.append(file_path)
+    return stubs

protonfs/localscan.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+
+from protonfs.config import CONFIG_DIR_NAME
+from protonfs.ignore import IgnoreMatcher
+from protonfs.index import IndexStore
+
+
+@dataclass
+class ScanEntry:
+    rel_path: str
+    size: int
+    mtime: float
+    sha256: str
+
+
+def hash_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def scan(
+    root: Path,
+    subpath: Path,
+    ignore: IgnoreMatcher,
+    index: IndexStore,
+    low_io: bool = False,
+) -> dict[str, ScanEntry]:
+    entries: dict[str, ScanEntry] = {}
+    base = root / subpath if subpath != Path(".") else root
+    for file_path in sorted(base.rglob("*")):
+        if not file_path.is_file():
+            continue
+        rel_path = str(file_path.relative_to(root))
+        if rel_path == CONFIG_DIR_NAME or rel_path.startswith(f"{CONFIG_DIR_NAME}/"):
+            continue
+        if ignore.matches(rel_path):
+            continue
+        stat = file_path.stat()
+        size = stat.st_size
+        mtime = stat.st_mtime
+        cached = index.get(rel_path)
+        if low_io and cached is not None and cached.size == size and cached.mtime == mtime:
+            sha256 = cached.sha256
+        else:
+            sha256 = hash_file(file_path)
+        entries[rel_path] = ScanEntry(rel_path=rel_path, size=size, mtime=mtime, sha256=sha256)
+    return entries

protonfs-0.1.dev43.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: protonfs
+Version: 0.1.dev43
+Summary: Sync a local directory tree with Proton Drive via the official Proton Drive CLI, with conflict-aware push/pull and a local sync manifest.
+Project-URL: Homepage, https://github.com/will-roscoe/protonfs
+Project-URL: Issues, https://github.com/will-roscoe/protonfs/issues
+Author: Will Roscoe
+License: PolyForm Noncommercial License 1.0.0
+        
+        <https://polyformproject.org/licenses/noncommercial/1.0.0>
+        
+        Required Notice: Copyright Will Roscoe (https://github.com/will-roscoe)
+        
+        ## Acceptance
+        
+        In order to get any license under these terms, you must agree
+        to them as both strict obligations and conditions to all
+        your licenses.
+        
+        ## Copyright License
+        
+        The licensor grants you a copyright license for the
+        software to do everything you might do with the software
+        that would otherwise infringe the licensor's copyright
+        in it for any permitted purpose. However, you may
+        only distribute the software according to Distribution
+        License and make changes or new works
+        based on the software according to Changes and New Works
+        License.
+        
+        ## Distribution License
+        
+        The licensor grants you an additional copyright license
+        to distribute copies of the software. Your license
+        to distribute covers distributing the software with
+        changes and new works permitted by Changes and New Works
+        License.
+        
+        ## Notices
+        
+        You must ensure that anyone who gets a copy of any part of
+        the software from you also gets a copy of these terms or the
+        URL for them above, as well as copies of any plain-text lines
+        beginning with "Required Notice:" that the licensor provided
+        with the software. For example:
+        
+        Required Notice: Copyright Will Roscoe (https://github.com/will-roscoe)
+        
+        ## Changes and New Works License
+        
+        The licensor grants you an additional copyright license to
+        make changes and new works based on the software for any
+        permitted purpose.
+        
+        ## Patent License
+        
+        The licensor grants you a patent license for the software that
+        covers patent claims the licensor can license, or becomes able
+        to license, that you would infringe by using the software.
+        
+        ## Noncommercial Purposes
+        
+        Any noncommercial purpose is a permitted purpose.
+        
+        ## Personal Uses
+        
+        Personal use for research, experiment, and testing for
+        the benefit of public knowledge, personal study, private
+        entertainment, hobby projects, amateur pursuits, or religious
+        observance, without any anticipated commercial application,
+        is use for a permitted purpose.
+        
+        ## Noncommercial Organizations
+        
+        Use by any charitable organization, educational institution,
+        public research organization, public safety or health
+        organization, environmental protection organization,
+        or government institution is use for a permitted purpose
+        regardless of the source of funding or obligations resulting
+        from the funding.
+        
+        ## Fair Use
+        
+        You may have "fair use" rights for the software under the
+        law. These terms do not limit them.
+        
+        ## No Other Rights
+        
+        These terms do not allow you to sublicense or transfer any of
+        your licenses to anyone else, or prevent the licensor from
+        granting licenses to anyone else. These terms do not imply
+        any other licenses.
+        
+        ## Patent Defense
+        
+        If you make any written claim that the software infringes or
+        contributes to infringement of any patent, your patent license
+        for the software granted under these terms ends immediately. If
+        your company makes such a claim, your patent license ends
+        immediately for work on behalf of your company.
+        
+        ## Violations
+        
+        The first time you are notified in writing that you have
+        violated any of these terms, or done anything with the software
+        not covered by your licenses, your licenses can nonetheless
+        continue if you come into full compliance with these terms,
+        and take practical steps to correct past violations, within
+        32 days of receiving notice. Otherwise, all your licenses
+        end immediately.
+        
+        ## No Liability
+        
+        As far as the law allows, the software comes as is, without
+        any warranty or condition, and the licensor will not be liable
+        to you for any damages arising out of these terms or the use
+        or nature of the software, under any kind of legal claim.
+        
+        ## Definitions
+        
+        The licensor is the individual or entity offering these
+        terms, and the software is the software the licensor makes
+        available under these terms.
+        
+        You refers to the individual or entity agreeing to these
+        terms.
+        
+        Your company is any legal entity, sole proprietorship,
+        or other kind of organization that you work for, plus all
+        organizations that have control over, are under the control of,
+        or are under common control with that organization. Control
+        means ownership of substantially all the assets of an entity,
+        or the power to direct its management and policies by vote,
+        contract, or otherwise. Control can be direct or indirect.
+        
+        Your licenses are all the licenses granted to you for the
+        software under these terms.
+        
+        Use means anything you do with the software requiring one
+        of your licenses.
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: click>=8.1
+Requires-Dist: pathspec>=0.12
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo; extra == 'docs'
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-autobuild; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
+Requires-Dist: sphinx-copybutton; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# protonfs
+
+Sync a local directory tree with [Proton Drive](https://proton.me/drive), via
+the official [Proton Drive CLI](https://github.com/ProtonDriveApps/sdk/tree/main/cli),
+with conflict-aware push/pull and a local sync manifest.
+
+Originally built to replace git-lfs as the storage layer for large,
+write-once simulation output — data that doesn't need version history, just
+somewhere durable to live and a way to fetch it back on demand.
+
+The command surface (`setup`, `status`, `ls`, `push`, `pull`, `rm`, `restore`,
+`refresh`, `install-drive`, `auth`) is implemented — see `src/protonfs/cli.py`.
+
+## Requirements
+
+- Python >= 3.9
+- The [`proton-drive`](https://proton.me/download/drive/cli/index.html) CLI
+  binary — install it with `protonfs install-drive` (below), or supply your own
+  on `PATH` / via `PROTONFS_DRIVE_BIN`.
+
+## Install
+
+```bash
+pip install protonfs
+protonfs install-drive     # downloads + SHA-512-verifies the official proton-drive binary
+protonfs auth login        # opens a URL to authenticate (passthrough to proton-drive)
+```
+
+`install-drive` detects your platform, requires AVX2 for the linux-x64 prebuilt
+(with an instructive fallback otherwise), and never installs a binary whose
+SHA-512 does not match the pinned checksum. Override the version with
+`PROTONFS_DRIVE_VERSION` and the expected checksum with `PROTONFS_DRIVE_SHA512`.
+
+## License
+
+[PolyForm Noncommercial 1.0.0](LICENSE) — free for noncommercial use with
+attribution; contact the author for commercial use.

protonfs-0.1.dev43.dist-info/RECORD

@@ -0,0 +1,27 @@
+protonfs/__init__.py,sha256=p9EGklRYIQg4Fm6G8jh5R9ALXXn7nnjZBVcCmd1cmBQ,168
+protonfs/batching.py,sha256=_jqOk6e9Le43kyzJKgTG1iD-cFUy58cnPenCd_gP1b0,470
+protonfs/cli.py,sha256=SQNX5khaOzEkttpSfxHzQQI8jhDZ0umjxJF3ihoWIKk,8170
+protonfs/config.py,sha256=iEcSiFaQSCTVL5aFP5dWdbxJwSUV9wXl2i9jENIgMw8,1768
+protonfs/context.py,sha256=m9rsZ_psfGgPxbQyE_MyHViRxV-t94Z7HD7xG_FVBEg,729
+protonfs/diff.py,sha256=ROV21UClQ6mz71NuZFuDbc-4c98gzA6k1Be0-zd6Aio,2732
+protonfs/drive.py,sha256=-8d8eIrAfVfHnB8ypOGthZ_BzGSQISqVijAuLxyWVtA,7743
+protonfs/ignore.py,sha256=EfjBMFtmAz8UsrC7ZaHOJ0fxrDi_U0CL4Q2pHaNLxPo,1076
+protonfs/index.py,sha256=KNswlDVaNZJhPCCmeox31p58cTf5Ygz_8Vejs3Y0xMI,1579
+protonfs/install.py,sha256=lMWQfdVN6KSeWpoEtDJnevACcRSjdjN7yqMNUlIWwOI,11053
+protonfs/lfs.py,sha256=QBD9gM22v9iCJvYwOpn9rg11306w1GbrXfoNaYLJpJE,1141
+protonfs/localscan.py,sha256=KOFO7vPnKtCgo0KzYspVVoN4tnPenDpMXkUjugQf-bo,1547
+protonfs/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+protonfs/commands/auth.py,sha256=n3YV7ptj_TlLjDer0-U6QiEM36zEUDXtHn3py_VlM1U,1517
+protonfs/commands/ls.py,sha256=q-mbVMBlIPxMEtg2Z0p7sHCGoKH5J4YwKFiHyrBLf4I,2268
+protonfs/commands/pull.py,sha256=HEGBEikTeX0GfEH_Ch9OF25dr6R0rP56aVJj4uZYHxE,3378
+protonfs/commands/push.py,sha256=ZTTvLb18th-T4Tnr-XhhM93SykT0AyTKMVVxyt4EZCs,3661
+protonfs/commands/refresh.py,sha256=3OeQOnle9uiqs4z4SpodZ6tw5WLS249jJPf-2Qhsf_k,3077
+protonfs/commands/restore.py,sha256=yqEAPP--EmJOU54_e8aNgsKBM4MLaDHGg8CqGhqmI8I,295
+protonfs/commands/rm.py,sha256=_pc5tYwEuGyh4miXS6kywjQeMckp6ph4qFoNN56PGJs,2123
+protonfs/commands/setup.py,sha256=eZb7P6ZKLGZ5zhh8WraoiJ0BDn2kXbGKxD3BPme6qLA,6689
+protonfs/commands/status.py,sha256=DSFWWOswnFY6fEyGmHQc9Jq-__0WLLFljAUxkKdzexM,615
+protonfs-0.1.dev43.dist-info/METADATA,sha256=75pGLawuWNLVeRaaAiNuopXES_mN2bNYNkMKqGrkp3s,8180
+protonfs-0.1.dev43.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+protonfs-0.1.dev43.dist-info/entry_points.txt,sha256=d4DtJu8SQN6WiDq9GBx8ezCPG_EvjIqvBxfe37YFCzw,47
+protonfs-0.1.dev43.dist-info/licenses/LICENSE,sha256=XDZ7TIaWLSypaEoIOAM-LDTBCVdJrGErQr4OdWVGf4A,4507
+protonfs-0.1.dev43.dist-info/RECORD,,

protonfs-0.1.dev43.dist-info/WHEEL

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

protonfs-0.1.dev43.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+protonfs = protonfs.cli:main