scmrepo 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

scmrepo/git/backend/pygit2/__init__.py

@@ -3,13 +3,14 @@ import logging
 import os
 import stat
 from contextlib import contextmanager
-from io import BytesIO, StringIO
+from io import BytesIO, StringIO, TextIOWrapper
 from typing import (
     TYPE_CHECKING,
     Callable,
     Dict,
     Generator,
     Iterable,
+    Iterator,
     List,
     Mapping,
     Optional,
@@ -20,8 +21,15 @@ from urllib.parse import urlparse
 
 from funcy import cached_property, reraise
 
-from scmrepo.exceptions import CloneError, MergeConflictError, RevError, SCMError
+from scmrepo.exceptions import (
+    CloneError,
+    InvalidRemote,
+    MergeConflictError,
+    RevError,
+    SCMError,
+)
 from scmrepo.git.backend.base import BaseGitBackend, SyncStatus
+from scmrepo.git.config import Config
 from scmrepo.git.objects import GitCommit, GitObject, GitTag
 from scmrepo.utils import relpath
 
@@ -29,7 +37,8 @@ logger = logging.getLogger(__name__)
 
 
 if TYPE_CHECKING:
-    from pygit2 import Signature
+    from pygit2 import Commit, Oid, Signature
+    from pygit2.config import Config as _Pygit2Config
     from pygit2.remote import Remote  # type: ignore
     from pygit2.repository import Repository
 
@@ -37,13 +46,47 @@ if TYPE_CHECKING:
 
 
 class Pygit2Object(GitObject):
-    def __init__(self, obj):
+    def __init__(self, obj, backend: Optional["Pygit2Backend"] = None):
         self.obj = obj
+        self.backend = backend
+
+    def open(
+        self,
+        mode: str = "r",
+        encoding: str = None,
+        key: Optional[Tuple[str, ...]] = None,
+        raw: bool = True,
+        rev: Optional[str] = None,
+        **kwargs,
+    ):
+        from pygit2 import BlobIO, GitError
 
-    def open(self, mode: str = "r", encoding: str = None):
         if not encoding:
             encoding = locale.getpreferredencoding(False)
-        data = self.obj.read_raw()
+        if self.backend is not None:
+            try:
+                if rev:
+                    # pylint: disable-next=protected-access
+                    commit, _ref = self.backend._resolve_refish(rev)
+                else:
+                    pass
+                if raw:
+                    blob_kwargs = {}
+                else:
+                    assert key is not None
+                    path = "/".join(key)
+                    blob_kwargs = {
+                        "as_path": path,
+                        "commit_id": commit.oid,
+                    }
+                blobio = BlobIO(self.obj, **blob_kwargs)
+                if mode == "rb":
+                    return blobio
+                return TextIOWrapper(blobio, encoding=encoding)
+            except GitError as exc:
+                raise SCMError("failed to read git blob") from exc
+        else:
+            data = self.obj.read_raw()
         if mode == "rb":
             return BytesIO(data)
         return StringIO(data.decode(encoding))
@@ -74,7 +117,34 @@ class Pygit2Object(GitObject):
 
     def scandir(self) -> Iterable["Pygit2Object"]:
         for entry in self.obj:  # noqa: B301
-            yield Pygit2Object(entry)
+            yield Pygit2Object(entry, backend=self.backend)
+
+
+class Pygit2Config(Config):
+    def __init__(self, config: "_Pygit2Config"):
+        self._config = config
+
+    def _key(self, section: Tuple[str, ...], name: str) -> str:
+        return ".".join(section + (name,))
+
+    def get(self, section: Tuple[str, ...], name: str) -> str:
+        return self._config[self._key(section, name)]
+
+    def get_bool(self, section: Tuple[str, ...], name: str) -> bool:
+        from pygit2 import GitError
+
+        try:
+            return self._config.get_bool(self._key(section, name))
+        except GitError as exc:
+            raise ValueError("invalid boolean config entry") from exc
+
+    def get_multivar(self, section: Tuple[str, ...], name: str) -> Iterator[str]:
+        from pygit2 import GitError
+
+        try:
+            yield from self._config.get_multivar(self._key(section, name))
+        except GitError as exc:
+            raise ValueError("invalid multivar config entry") from exc
 
 
 class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
@@ -83,6 +153,8 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
     ):
         import pygit2
 
+        from .filter import LFSFilter
+
         if search_parent_directories:
             ceiling_dirs = ""
         else:
@@ -99,6 +171,14 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
 
         self._stashes: dict = {}
 
+        try:
+            # NOTE: we want this init to be lazy so we do it on backend init.
+            # for subsequent backend instances, this call will error out since
+            # the filter is already registered
+            pygit2.filter_register("lfs", LFSFilter)
+        except ValueError:
+            pass
+
     def close(self):
         if hasattr(self, "_refdb"):
             del self._refdb
@@ -353,6 +433,15 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             return self.repo.references["HEAD"].target[11:]
         return self.repo.head.shorthand
 
+    def active_branch_remote(self) -> str:
+        try:
+            upstream = self.repo.branches[self.active_branch()].upstream
+            if upstream:
+                return upstream.remote_name
+        except (KeyError, ValueError):
+            pass
+        raise SCMError("No active branch tracking remote")
+
     def list_branches(self) -> Iterable[str]:
         base = "refs/heads/"
         return sorted(ref[len(base) :] for ref in self.iter_refs(base))
@@ -366,7 +455,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
 
     def get_tree_obj(self, rev: str, **kwargs) -> Pygit2Object:
         tree = self.repo[rev].tree
-        return Pygit2Object(tree)
+        return Pygit2Object(tree, backend=self)
 
     def get_rev(self) -> str:
         raise NotImplementedError
@@ -551,7 +640,8 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         raise SCMError("Unknown merge analysis result")
 
     @contextmanager
-    def get_remote(self, url: str) -> Generator["Remote", None, None]:
+    def _get_remote(self, url: str) -> Generator["Remote", None, None]:
+        """Return a pygit2.Remote suitable for the specified Git URL or remote name."""
         try:
             remote = self.repo.remotes[url]
             url = remote.url
@@ -577,57 +667,84 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         progress: Callable[["GitProgressEvent"], None] = None,
         **kwargs,
     ) -> Mapping[str, SyncStatus]:
+        import fnmatch
+
         from pygit2 import GitError
 
         from .callbacks import RemoteCallbacks
 
-        if isinstance(refspecs, str):
-            refspecs = [refspecs]
+        refspecs = self._refspecs_list(refspecs, force=force)
 
-        with self.get_remote(url) as remote:
-            fetch_refspecs: List[str] = []
-            for refspec in refspecs:
-                if ":" in refspec:
-                    lh, rh = refspec.split(":")
-                else:
-                    lh = rh = refspec
-                if not rh.startswith("refs/"):
-                    rh = f"refs/heads/{rh}"
-                if not lh.startswith("refs/"):
-                    lh = f"refs/heads/{lh}"
-                rh = rh[len("refs/") :]
-                refspec = f"+{lh}:refs/remotes/{remote.name}/{rh}"
-                fetch_refspecs.append(refspec)
-
-            logger.debug("fetch_refspecs: %s", fetch_refspecs)
+        # libgit2 rejects diverged refs but does not have a callback to notify
+        # when a ref was rejected so we have to determine whether no callback
+        # means up to date or rejected
+        def _default_status(
+            src: str, dst: str, remote_refs: Dict[str, "Oid"]
+        ) -> SyncStatus:
+            try:
+                if remote_refs[src] != self.repo.references[dst].target:
+                    return SyncStatus.DIVERGED
+            except KeyError:
+                # remote_refs lookup is skipped when force is set, refs cannot
+                # be diverged on force
+                pass
+            return SyncStatus.UP_TO_DATE
+
+        with self._get_remote(url) as remote:
             with reraise(
                 GitError,
                 SCMError(f"Git failed to fetch ref from '{url}'"),
             ):
                 with RemoteCallbacks(progress=progress) as cb:
+                    remote_refs: Dict[str, "Oid"] = (
+                        {
+                            head["name"]: head["oid"]
+                            for head in remote.ls_remotes(callbacks=cb)
+                        }
+                        if not force
+                        else {}
+                    )
                     remote.fetch(
-                        refspecs=fetch_refspecs,
+                        refspecs=refspecs,
                         callbacks=cb,
+                        message="fetch",
                     )
 
             result: Dict[str, "SyncStatus"] = {}
-            for refspec in fetch_refspecs:
-                _, rh = refspec.split(":")
-                if not rh.endswith("*"):
-                    refname = rh.split("/", 3)[-1]
-                    refname = f"refs/{refname}"
-                    result[refname] = self._merge_remote_branch(
-                        rh, refname, force, on_diverged
-                    )
-                    continue
-                rh = rh.rstrip("*").rstrip("/") + "/"
-                for branch in self.iter_refs(base=rh):
-                    refname = f"refs/{branch[len(rh):]}"
-                    result[refname] = self._merge_remote_branch(
-                        branch, refname, force, on_diverged
-                    )
+            for refspec in refspecs:
+                lh, rh = refspec.split(":")
+                if lh.endswith("*"):
+                    assert rh.endswith("*")
+                    lh_prefix = lh[:-1]
+                    rh_prefix = rh[:-1]
+                    for refname in remote_refs:
+                        if fnmatch.fnmatch(refname, lh):
+                            src = refname
+                            dst = f"{rh_prefix}{refname[len(lh_prefix):]}"
+                            result[dst] = cb.result.get(
+                                src, _default_status(src, dst, remote_refs)
+                            )
+                else:
+                    result[rh] = cb.result.get(lh, _default_status(lh, rh, remote_refs))
+
         return result
 
+    @staticmethod
+    def _refspecs_list(
+        refspecs: Union[str, Iterable[str]],
+        force: bool = False,
+    ) -> List[str]:
+        if isinstance(refspecs, str):
+            if force and not refspecs.startswith("+"):
+                refspecs = f"+{refspecs}"
+            return [refspecs]
+        if force:
+            return [
+                (refspec if refspec.startswith("+") else f"+{refspec}")
+                for refspec in refspecs
+            ]
+        return list(refspecs)
+
     def _stash_iter(self, ref: str):
         raise NotImplementedError
 
@@ -940,6 +1057,12 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
     def validate_git_remote(self, url: str, **kwargs):
         raise NotImplementedError
 
+    def get_remote_url(self, remote: str) -> str:
+        try:
+            return self.repo.remotes[remote].url
+        except KeyError as exc:
+            raise InvalidRemote(remote) from exc
+
     def check_ref_format(self, refname: str):
         raise NotImplementedError
 
@@ -968,3 +1091,38 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         except KeyError:
             pass
         return str(ref.target)
+
+    def get_config(self, path: Optional[str] = None) -> "Config":
+        from pygit2.config import Config as _Pygit2Config
+
+        if path:
+            return Pygit2Config(_Pygit2Config(path))
+        return Pygit2Config(self.repo.config)
+
+    def check_attr(
+        self,
+        path: str,
+        attr: str,
+        source: Optional[str] = None,
+    ) -> Optional[Union[bool, str]]:
+        from pygit2 import (
+            GIT_ATTR_CHECK_FILE_THEN_INDEX,
+            GIT_ATTR_CHECK_INCLUDE_COMMIT,
+            GIT_ATTR_CHECK_INDEX_ONLY,
+            GitError,
+        )
+
+        commit: Optional["Commit"] = None
+        flags = GIT_ATTR_CHECK_FILE_THEN_INDEX
+        if source:
+            try:
+                commit, _ref = self._resolve_refish(source)
+                flags = GIT_ATTR_CHECK_INDEX_ONLY | GIT_ATTR_CHECK_INCLUDE_COMMIT
+            except (KeyError, GitError) as exc:
+                raise SCMError(f"Invalid commit '{source}'") from exc
+        try:
+            return self.repo.get_attr(
+                path, attr, flags=flags, commit=commit.id if commit else None
+            )
+        except GitError as exc:
+            raise SCMError("Failed to check attribute") from exc

scmrepo/git/backend/pygit2/callbacks.py

@@ -1,13 +1,15 @@
 from contextlib import AbstractContextManager
 from types import TracebackType
-from typing import TYPE_CHECKING, Callable, Optional, Type, Union
+from typing import TYPE_CHECKING, Callable, Dict, Optional, Type, Union
 
 from pygit2 import RemoteCallbacks as _RemoteCallbacks
 
+from scmrepo.git.backend.base import SyncStatus
 from scmrepo.git.credentials import Credential, CredentialNotFoundError
 from scmrepo.progress import GitProgressReporter
 
 if TYPE_CHECKING:
+    from pygit2 import Oid
     from pygit2.credentials import Keypair, Username, UserPass
 
     from scmrepo.progress import GitProgressEvent
@@ -27,6 +29,7 @@ class RemoteCallbacks(_RemoteCallbacks, AbstractContextManager):
         self.progress = GitProgressReporter(progress) if progress else None
         self._store_credentials: Optional["Credential"] = None
         self._tried_credentials = False
+        self.result: Dict[str, SyncStatus] = {}
 
     def __exit__(
         self,
@@ -66,3 +69,9 @@ class RemoteCallbacks(_RemoteCallbacks, AbstractContextManager):
     def _approve_credentials(self):
         if self._store_credentials:
             self._store_credentials.approve()
+
+    def update_tips(self, refname: str, old: "Oid", new: "Oid"):
+        if old == new:
+            self.result[refname] = SyncStatus.UP_TO_DATE
+        else:
+            self.result[refname] = SyncStatus.SUCCESS

scmrepo/git/backend/pygit2/filter.py

@@ -0,0 +1,65 @@
+import io
+import logging
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from pygit2 import GIT_FILTER_CLEAN, Filter, Passthrough
+
+if TYPE_CHECKING:
+    from pygit2 import FilterSource
+
+logger = logging.getLogger(__name__)
+
+
+class LFSFilter(Filter):
+    attributes = "filter=*"
+
+    def __init__(self, *args, **kwargs):
+        self._smudge_buf: Optional[io.BytesIO] = None
+        self._smudge_root: Optional[str] = None
+
+    def check(self, src: "FilterSource", attr_values: List[str]):
+        if attr_values[0] == "lfs":
+            if src.mode != GIT_FILTER_CLEAN:
+                self._smudge_buf = io.BytesIO()
+                self._smudge_root = src.repo.workdir or src.repo.path
+                return
+        raise Passthrough
+
+    def write(
+        self, data: bytes, src: "FilterSource", write_next: Callable[[bytes], None]
+    ):
+        if src.mode == GIT_FILTER_CLEAN:
+            write_next(data)
+            return
+        if self._smudge_buf is None:
+            self._smudge_buf = io.BytesIO()
+        if self._smudge_root is None:
+            self._smudge_root = src.repo.workdir or src.repo.path
+        self._smudge_buf.write(data)
+
+    def close(self, write_next: Callable[[bytes], None]):
+        if self._smudge_buf is not None:
+            assert self._smudge_root
+            self._smudge(write_next)
+
+    def _smudge(self, write_next: Callable[[bytes], None]):
+        from scmrepo.exceptions import InvalidRemote
+        from scmrepo.git import Git
+        from scmrepo.git.lfs import smudge
+        from scmrepo.git.lfs.fetch import get_fetch_url
+
+        assert self._smudge_buf is not None
+        self._smudge_buf.seek(0)
+        with Git(self._smudge_root) as scm:
+            try:
+                url = get_fetch_url(scm)
+            except InvalidRemote:
+                url = None
+            fobj = smudge(scm.lfs_storage, self._smudge_buf, url=url)
+            data = fobj.read(io.DEFAULT_BUFFER_SIZE)
+            try:
+                while data:
+                    write_next(data)
+                    data = fobj.read(io.DEFAULT_BUFFER_SIZE)
+            except KeyboardInterrupt:
+                return

scmrepo/git/config.py

@@ -0,0 +1,35 @@
+"""git config convenience wrapper."""
+import logging
+from abc import ABC, abstractmethod
+from typing import Iterator, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class Config(ABC):
+    """Read-only Git config."""
+
+    @abstractmethod
+    def get(self, section: Tuple[str, ...], name: str) -> str:
+        """Return the specified setting as a string.
+
+        Raises:
+            KeyError: Option was not set.
+        """
+
+    @abstractmethod
+    def get_bool(self, section: Tuple[str, ...], name: str) -> bool:
+        """Return the specified setting as a boolean.
+
+        Raises:
+            KeyError: Option was not set.
+            ValueError: Option is not a valid boolean.
+        """
+
+    @abstractmethod
+    def get_multivar(self, section: Tuple[str, ...], name: str) -> Iterator[str]:
+        """Iterate over string values in the specified multivar setting.
+
+        Raises:
+            KeyError: Option was not set.
+        """

scmrepo/git/lfs/__init__.py

@@ -0,0 +1,8 @@
+from .client import LFSClient
+from .exceptions import LFSError
+from .fetch import fetch
+from .pointer import Pointer
+from .smudge import smudge
+from .storage import LFSStorage
+
+__all__ = ["LFSClient", "LFSError", "LFSStorage", "Pointer", "fetch", "smudge"]