gitstore 0.58.3__py3-none-any.whl

gitstore/__init__.py

@@ -0,0 +1,20 @@
+from .repo import GitStore, RefDict, ReflogEntry, Signature
+from .mirror import MirrorDiff, RefChange, resolve_credentials
+from .notes import NoteDict, NoteNamespace, NotesBatch
+from .fs import FS, StatResult, WriteEntry, retry_write
+from .tree import BlobOid, GitError, WalkEntry
+from .batch import Batch
+from .exceptions import StaleSnapshotError
+from ._exclude import ExcludeFilter
+from .copy import ChangeReport, ChangeAction, ChangeActionKind, ChangeError, FileEntry, FileType, disk_glob
+
+__all__ = [
+    "GitStore", "RefDict", "ReflogEntry", "Signature",
+    "MirrorDiff", "RefChange", "resolve_credentials",
+    "NoteDict", "NoteNamespace", "NotesBatch",
+    "FS", "StatResult", "WriteEntry", "retry_write", "StaleSnapshotError",
+    "Batch", "BlobOid", "GitError",
+    "ChangeReport", "ChangeAction", "ChangeActionKind", "ChangeError",
+    "ExcludeFilter", "FileEntry", "FileType", "disk_glob",
+    "WalkEntry",
+]

gitstore/_exclude.py

@@ -0,0 +1,121 @@
+"""Exclude-filter support for disk→repo operations.
+
+Combines ``--exclude`` patterns, ``--exclude-from`` files, and automatic
+``.gitignore`` loading into a single predicate used by
+``_walk_local_paths`` and ``_enum_disk_to_repo``.
+
+Pattern syntax follows gitignore rules (implemented by
+``dulwich.ignore.IgnoreFilter``).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Sequence
+
+from dulwich.ignore import IgnoreFilter, IgnoreFilterStack
+
+
+class ExcludeFilter:
+    """Gitignore-style exclude filter for disk-to-repo operations.
+
+    Combines ``--exclude`` patterns, ``--exclude-from`` file, and automatic
+    ``.gitignore`` loading into a single predicate.
+
+    Args:
+        patterns: Gitignore-style patterns to exclude.
+        exclude_from: Path to a file containing exclude patterns.
+        gitignore: Load ``.gitignore`` files from walked directories.
+    """
+
+    def __init__(
+        self,
+        *,
+        patterns: Sequence[str] | None = None,
+        exclude_from: str | None = None,
+        gitignore: bool = False,
+    ) -> None:
+        base_lines: list[bytes] = []
+        for p in patterns or ():
+            base_lines.append(p.encode("utf-8"))
+        if exclude_from is not None:
+            path = Path(exclude_from)
+            for raw in path.read_bytes().splitlines():
+                line = raw.strip()
+                if line and not line.startswith(b"#"):
+                    base_lines.append(line)
+        self._base: IgnoreFilter | None = (
+            IgnoreFilter(base_lines) if base_lines else None
+        )
+        self._gitignore = gitignore
+        # {rel_dir: IgnoreFilter | None} — lazily loaded per directory
+        self._dir_filters: dict[str, IgnoreFilter | None] = {}
+
+    # ------------------------------------------------------------------
+    @property
+    def active(self) -> bool:
+        """True if any filtering is configured."""
+        return self._base is not None or self._gitignore
+
+    # ------------------------------------------------------------------
+    def is_excluded(self, rel_path: str, *, is_dir: bool = False) -> bool:
+        """Check against base patterns only (for post-filtering)."""
+        if self._base is None:
+            return False
+        check = rel_path + "/" if is_dir else rel_path
+        return self._base.is_ignored(check) is True
+
+    # ------------------------------------------------------------------
+    def enter_directory(self, abs_dir: Path, rel_dir: str) -> None:
+        """Load .gitignore from *abs_dir* if gitignore mode is on."""
+        if not self._gitignore:
+            return
+        if rel_dir in self._dir_filters:
+            return
+        gi = abs_dir / ".gitignore"
+        if gi.is_file():
+            self._dir_filters[rel_dir] = IgnoreFilter.from_path(str(gi))
+        else:
+            self._dir_filters[rel_dir] = None
+
+    # ------------------------------------------------------------------
+    def is_excluded_in_walk(
+        self, rel_path: str, *, is_dir: bool = False,
+    ) -> bool:
+        """Check base patterns + loaded .gitignore hierarchy.
+
+        Called during ``os.walk()`` after ``enter_directory`` has been
+        invoked for every ancestor.
+        """
+        check = rel_path + "/" if is_dir else rel_path
+
+        # Base patterns (--exclude / --exclude-from)
+        if self._base is not None and self._base.is_ignored(check) is True:
+            return True
+
+        if not self._gitignore:
+            return False
+
+        # Auto-exclude .gitignore files themselves
+        if not is_dir and rel_path.rsplit("/", 1)[-1] == ".gitignore":
+            return True
+
+        # Walk .gitignore filters from root → deepest ancestor.
+        # Git semantics: last (deepest) matching rule wins.
+        parts = rel_path.split("/")
+        excluded = None
+        for depth in range(len(parts)):
+            if depth == 0:
+                dir_key = ""
+            else:
+                dir_key = "/".join(parts[:depth])
+            filt = self._dir_filters.get(dir_key)
+            if filt is not None:
+                # Path relative to this .gitignore's directory
+                sub = "/".join(parts[depth:])
+                sub_check = sub + "/" if is_dir else sub
+                result = filt.is_ignored(sub_check)
+                if result is not None:
+                    excluded = result
+
+        return excluded is True

gitstore/_fileobj.py

@@ -0,0 +1,143 @@
+"""File-like objects for gitstore."""
+
+from __future__ import annotations
+
+import io
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .fs import FS
+    from .batch import Batch
+
+
+class ReadableFile:
+    """Read-only file-like object wrapping bytes."""
+
+    def __init__(self, data: bytes):
+        self._buf = io.BytesIO(data)
+        self._closed = False
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return False
+
+    def seekable(self) -> bool:
+        return True
+
+    def read(self, size: int = -1) -> bytes:
+        if self._closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._buf.read(size)
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        if self._closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._buf.seek(offset, whence)
+
+    def tell(self) -> int:
+        if self._closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._buf.tell()
+
+    def close(self) -> None:
+        self._closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+
+class WritableFile:
+    """Writable file-like object that commits on close."""
+
+    def __init__(self, fs: FS, path: str):
+        self._fs = fs
+        self._path = path
+        self._buf = io.BytesIO()
+        self._closed = False
+        self.fs: FS | None = None
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def readable(self) -> bool:
+        return False
+
+    def writable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def write(self, data: bytes) -> int:
+        if self._closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._buf.write(data)
+
+    def close(self) -> None:
+        if not self._closed:
+            self.fs = self._fs.write(self._path, self._buf.getvalue())
+            self._closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.close()
+        else:
+            self._closed = True
+        return False
+
+
+class BatchWritableFile:
+    """Writable file-like object that stages to a batch on close."""
+
+    def __init__(self, batch: Batch, path: str):
+        self._batch = batch
+        self._path = path
+        self._buf = io.BytesIO()
+        self._closed = False
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def readable(self) -> bool:
+        return False
+
+    def writable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def write(self, data: bytes) -> int:
+        if self._closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._buf.write(data)
+
+    def close(self) -> None:
+        if not self._closed:
+            self._batch.write(self._path, self._buf.getvalue())
+            self._closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.close()
+        else:
+            self._closed = True
+        return False

gitstore/_fuse.py

@@ -0,0 +1,202 @@
+"""Read-only FUSE mount for gitstore."""
+
+from __future__ import annotations
+
+import errno
+import os
+import stat
+import sys
+import threading
+from typing import TYPE_CHECKING
+
+try:
+    import mfusepy
+except OSError as _exc:
+    raise ImportError(f"FUSE support unavailable: {_exc}") from _exc
+
+from .tree import (
+    GIT_FILEMODE_BLOB,
+    GIT_FILEMODE_BLOB_EXECUTABLE,
+    GIT_FILEMODE_LINK,
+    GIT_FILEMODE_TREE,
+)
+
+if TYPE_CHECKING:
+    from .fs import FS
+
+
+def _git_mode_to_stat(git_mode: int) -> int:
+    """Convert a git filemode to a POSIX stat mode."""
+    if git_mode == GIT_FILEMODE_TREE:
+        return stat.S_IFDIR | 0o755
+    if git_mode == GIT_FILEMODE_BLOB_EXECUTABLE:
+        return stat.S_IFREG | 0o755
+    if git_mode == GIT_FILEMODE_LINK:
+        return stat.S_IFLNK | 0o777
+    # GIT_FILEMODE_BLOB and anything else
+    return stat.S_IFREG | 0o644
+
+
+def _fuse_path(path: str) -> str | None:
+    """Convert FUSE path (``/foo/bar``) to gitstore path (``foo/bar``).
+
+    Returns ``None`` for the root directory.
+    """
+    stripped = path.lstrip("/")
+    return stripped if stripped else None
+
+
+class GitStoreOperations(mfusepy.Operations):
+    """Read-only FUSE operations backed by a gitstore FS snapshot."""
+
+    def __init__(self, fs: FS):
+        self._fs = fs
+        self._lock = threading.Lock()
+        self._uid = os.getuid()
+        self._gid = os.getgid()
+
+    def getattr(self, path, fh=None):
+        gs_path = _fuse_path(path)
+        with self._lock:
+            try:
+                st = self._fs.stat(gs_path)
+            except FileNotFoundError:
+                raise mfusepy.FuseOSError(errno.ENOENT)
+            except NotADirectoryError:
+                raise mfusepy.FuseOSError(errno.ENOTDIR)
+
+        return {
+            "st_mode": _git_mode_to_stat(st.mode),
+            "st_size": st.size,
+            "st_nlink": st.nlink,
+            "st_mtime": st.mtime,
+            "st_atime": st.mtime,
+            "st_ctime": st.mtime,
+            "st_uid": self._uid,
+            "st_gid": self._gid,
+        }
+
+    def readdir(self, path, fh):
+        gs_path = _fuse_path(path)
+        with self._lock:
+            try:
+                entries = self._fs.listdir(gs_path)
+            except FileNotFoundError:
+                raise mfusepy.FuseOSError(errno.ENOENT)
+            except NotADirectoryError:
+                raise mfusepy.FuseOSError(errno.ENOTDIR)
+        yield "."
+        yield ".."
+        for entry in entries:
+            yield entry.name
+
+    def read(self, path, size, offset, fh):
+        gs_path = _fuse_path(path)
+        with self._lock:
+            try:
+                return self._fs.read(gs_path, offset=offset, size=size)
+            except FileNotFoundError:
+                raise mfusepy.FuseOSError(errno.ENOENT)
+            except IsADirectoryError:
+                raise mfusepy.FuseOSError(errno.EISDIR)
+
+    def readlink(self, path):
+        gs_path = _fuse_path(path)
+        with self._lock:
+            try:
+                return self._fs.readlink(gs_path)
+            except FileNotFoundError:
+                raise mfusepy.FuseOSError(errno.ENOENT)
+            except ValueError:
+                raise mfusepy.FuseOSError(errno.EINVAL)
+
+    def open(self, path, flags):
+        accmode = flags & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR)
+        if accmode != os.O_RDONLY:
+            raise mfusepy.FuseOSError(errno.EROFS)
+        return 0
+
+    def access(self, path, amode):
+        if amode & os.W_OK:
+            raise mfusepy.FuseOSError(errno.EROFS)
+        gs_path = _fuse_path(path)
+        with self._lock:
+            if gs_path is not None and not self._fs.exists(gs_path):
+                raise mfusepy.FuseOSError(errno.ENOENT)
+        return 0
+
+    def statfs(self, path):
+        return {
+            "f_bsize": 4096,
+            "f_frsize": 4096,
+            "f_blocks": 0,
+            "f_bfree": 0,
+            "f_bavail": 0,
+            "f_files": 0,
+            "f_ffree": 0,
+            "f_favail": 0,
+            "f_namemax": 255,
+        }
+
+    def utimens(self, path, times=None):
+        raise mfusepy.FuseOSError(errno.EROFS)
+
+    def destroy(self, path):
+        with self._lock:
+            self._fs.close()
+
+    # Disable write operations — mfusepy returns ENOSYS at kernel level for None
+    chmod = None
+    chown = None
+    create = None
+    link = None
+    mkdir = None
+    mknod = None
+    rename = None
+    rmdir = None
+    symlink = None
+    truncate = None
+    unlink = None
+    write = None
+
+
+def mount(
+    fs: FS,
+    mountpoint: str,
+    *,
+    foreground: bool = True,
+    debug: bool = False,
+    nothreads: bool = False,
+    allow_other: bool = False,
+) -> None:
+    """Mount a gitstore FS snapshot as a read-only FUSE filesystem.
+
+    Blocks until the filesystem is unmounted (Ctrl-C or ``umount``).
+    """
+    ref_label = fs.ref_name or fs.commit_hash[:12]
+    ops = GitStoreOperations(fs)
+
+    fuse_kwargs: dict = {
+        "ro": True,
+        "attr_timeout": 3600,
+        "entry_timeout": 3600,
+        "fsname": f"gitstore:{ref_label}",
+        "subtype": "gitstore",
+    }
+
+    if allow_other:
+        fuse_kwargs["allow_other"] = True
+
+    if sys.platform == "darwin":
+        fuse_kwargs["noappledouble"] = True
+        fuse_kwargs["noapplexattr"] = True
+        fuse_kwargs["volname"] = f"gitstore ({ref_label})"
+
+    mfusepy.FUSE(
+        ops,
+        mountpoint,
+        foreground=foreground,
+        debug=debug,
+        nothreads=nothreads,
+        **fuse_kwargs,
+    )

gitstore/_glob.py

@@ -0,0 +1,16 @@
+"""Shared dotfile-aware glob matching."""
+
+from __future__ import annotations
+
+from fnmatch import fnmatch as _fnmatch
+
+
+def _glob_match(pattern: str, name: str) -> bool:
+    """Match *name* against a glob *pattern* segment.
+
+    ``*`` and ``?`` do not match a leading ``.`` unless the pattern itself
+    starts with ``.`` (Unix/rsync convention).
+    """
+    if not pattern.startswith(".") and name.startswith("."):
+        return False
+    return _fnmatch(name, pattern)

gitstore/_lock.py

@@ -0,0 +1,76 @@
+"""Advisory repo lock: serializes ref mutations across threads and processes."""
+
+from __future__ import annotations
+
+import os
+import threading
+from contextlib import contextmanager
+
+# Per-process threading locks, keyed by resolved repo path
+_thread_locks: dict[tuple[int, int] | str, threading.Lock] = {}
+_thread_locks_guard = threading.Lock()
+
+
+def _get_thread_lock(repo_path: str) -> threading.Lock:
+    real = os.path.realpath(repo_path)
+    try:
+        st = os.stat(real)
+        key: tuple[int, int] | str = (st.st_dev, st.st_ino)
+        if st.st_ino == 0:
+            key = os.path.normcase(real)
+    except OSError:
+        key = os.path.normcase(real)
+    with _thread_locks_guard:
+        if key not in _thread_locks:
+            _thread_locks[key] = threading.Lock()
+        return _thread_locks[key]
+
+
+try:
+    import fcntl
+
+    def _lock_path(repo_path: str) -> str:
+        if os.path.isdir(repo_path):
+            return os.path.join(repo_path, "gitstore.lock")
+        return repo_path + ".lock"
+
+    @contextmanager
+    def repo_lock(repo_path: str):
+        tlock = _get_thread_lock(repo_path)
+        tlock.acquire()
+        try:
+            lock_path = _lock_path(repo_path)
+            fd = os.open(lock_path, os.O_CREAT | os.O_RDWR | getattr(os, "O_CLOEXEC", 0))
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX)
+                yield
+            finally:
+                fcntl.flock(fd, fcntl.LOCK_UN)
+                os.close(fd)
+        finally:
+            tlock.release()
+
+except ImportError:
+    import msvcrt
+
+    def _lock_path(repo_path: str) -> str:
+        if os.path.isdir(repo_path):
+            return os.path.join(repo_path, "gitstore.lock")
+        return repo_path + ".lock"
+
+    @contextmanager
+    def repo_lock(repo_path: str):
+        tlock = _get_thread_lock(repo_path)
+        tlock.acquire()
+        try:
+            lock_path = _lock_path(repo_path)
+            fd = os.open(lock_path, os.O_CREAT | os.O_RDWR)
+            os.set_inheritable(fd, False)
+            try:
+                msvcrt.locking(fd, msvcrt.LK_LOCK, 1)
+                yield
+            finally:
+                msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+                os.close(fd)
+        finally:
+            tlock.release()

gitstore/_objsize.py

@@ -0,0 +1,107 @@
+"""Efficient object size queries without loading full content.
+
+For non-delta packed objects, reads only the pack entry header.
+For loose objects, decompresses only the object header.
+For delta objects, falls back to full resolution via dulwich.
+"""
+
+from __future__ import annotations
+
+import os
+import zlib
+
+
+class ObjectSizer:
+    """Batch-efficient object size lookup.
+
+    Usage::
+
+        with ObjectSizer(dulwich_object_store) as sizer:
+            size = sizer.size(sha_hex)
+
+    *sha_hex* is a 40-char hex bytes SHA (dulwich native format).
+    """
+
+    __slots__ = ("_store", "_pack_fds", "_pack_index")
+
+    def __init__(self, object_store):
+        self._store = object_store
+        self._pack_fds: dict[str, object] = {}
+        self._pack_index: dict[bytes, tuple[str, int]] | None = None
+
+    # -- public API ----------------------------------------------------------
+
+    def size(self, sha_hex: bytes) -> int:
+        """Return the decompressed size of the object."""
+        if self._pack_index is None:
+            self._build_pack_index()
+
+        sha_raw = bytes.fromhex(
+            sha_hex.decode() if isinstance(sha_hex, bytes) else sha_hex
+        )
+
+        entry = self._pack_index.get(sha_raw)  # type: ignore[union-attr]
+        if entry is not None:
+            fname, offset = entry
+            obj_type, obj_size = self._read_pack_header(fname, offset)
+            if obj_type <= 4:  # commit=1, tree=2, blob=3, tag=4
+                return obj_size
+            # OFS_DELTA=6, REF_DELTA=7 — need full decompression
+            return self._store[sha_hex].raw_length()
+
+        # Loose object
+        return self._read_loose_header(sha_hex)
+
+    # -- internals -----------------------------------------------------------
+
+    def _build_pack_index(self):
+        self._pack_index = {}
+        for pack in self._store.packs:
+            fname = pack.data._filename
+            for sha_raw, offset, _crc32 in pack.index.iterentries():
+                self._pack_index[sha_raw] = (fname, offset)
+
+    def _read_pack_header(self, filename: str, offset: int) -> tuple[int, int]:
+        """Read type and decompressed size from a pack entry header."""
+        f = self._pack_fds.get(filename)
+        if f is None:
+            f = open(filename, "rb")
+            self._pack_fds[filename] = f
+
+        f.seek(offset)
+        byte = f.read(1)[0]
+        obj_type = (byte >> 4) & 0x07
+        size = byte & 0x0F
+        shift = 4
+        while byte & 0x80:
+            byte = f.read(1)[0]
+            size |= (byte & 0x7F) << shift
+            shift += 7
+        return obj_type, size
+
+    def _read_loose_header(self, sha_hex: bytes) -> int:
+        """Read size from a loose object header."""
+        if not hasattr(self._store, 'path') or not os.path.isdir(self._store.path):
+            return self._store[sha_hex].raw_length()
+        h = sha_hex.decode() if isinstance(sha_hex, bytes) else sha_hex
+        path = os.path.join(self._store.path, h[:2], h[2:])
+        with open(path, "rb") as f:
+            d = zlib.decompressobj()
+            header = d.decompress(f.read(64), 256)
+        nul = header.index(b"\x00")
+        _, size_str = header[:nul].split(b" ", 1)
+        return int(size_str)
+
+    # -- context manager -----------------------------------------------------
+
+    def close(self):
+        for fd in self._pack_fds.values():
+            fd.close()
+        self._pack_fds.clear()
+        self._pack_index = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()