scmrepo 3.3.12__tar.gz → 3.5.0__tar.gz

{scmrepo-3.3.12 → scmrepo-3.5.0}/.github/workflows/release.yaml

@@ -21,10 +21,10 @@ jobs:
       with:
         fetch-depth: 0
 
-    - name: Set up Python 3.10
+    - name: Set up Python 3.13
       uses: actions/setup-python@v5
       with:
-        python-version: '3.10'
+        python-version: '3.13'
 
     - name: Upgrade pip and nox
       run: |

{scmrepo-3.3.12 → scmrepo-3.5.0}/.github/workflows/tests.yaml

@@ -33,6 +33,7 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.pyv }}
+        allow-prereleases: true
 
     - name: Upgrade pip and nox
       run: |

{scmrepo-3.3.12 → scmrepo-3.5.0}/.pre-commit-config.yaml

@@ -20,9 +20,9 @@ repos:
       - id: sort-simple-yaml
       - id: trailing-whitespace
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.3'
+    rev: 'v0.12.5'
     hooks:
-      - id: ruff
+      - id: ruff-check
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
   - repo: https://github.com/codespell-project/codespell

{scmrepo-3.3.12/src/scmrepo.egg-info → scmrepo-3.5.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: scmrepo
-Version: 3.3.12
+Version: 3.5.0
 Summary: scmrepo
 Author-email: Iterative <support@dvc.org>
-License: Apache-2.0
+License-Expression: Apache-2.0
 Project-URL: Issues, https://github.com/iterative/scmrepo/issues
 Project-URL: Source, https://github.com/iterative/scmrepo
 Classifier: Programming Language :: Python :: 3
@@ -17,7 +17,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: gitpython>3
-Requires-Dist: dulwich>=0.23.1
+Requires-Dist: dulwich>=0.24.0
 Requires-Dist: pygit2>=1.14.0
 Requires-Dist: pygtrie>=2.3.2
 Requires-Dist: fsspec[tqdm]>=2024.2.0

{scmrepo-3.3.12 → scmrepo-3.5.0}/noxfile.py

@@ -10,7 +10,11 @@ nox.options.sessions = "lint", "tests"
 locations = "src", "tests"
 
 
-@nox.session(python=["3.9", "3.10", "3.11", "3.12", "3.13"])
+project = nox.project.load_toml()
+python_versions = nox.project.python_versions(project)
+
+
+@nox.session(python=python_versions)
 def tests(session: nox.Session) -> None:
     session.install(".[tests]")
     session.run(

{scmrepo-3.3.12 → scmrepo-3.5.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=48", "setuptools_scm[toml]>=6.3.1"]
+requires = ["setuptools>=77", "setuptools_scm[toml]>=8"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
@@ -8,7 +8,8 @@ build-backend = "setuptools.build_meta"
 name = "scmrepo"
 description = "scmrepo"
 readme = "README.rst"
-license = {text = "Apache-2.0"}
+license = "Apache-2.0"
+license-files = ["LICENSE"]
 authors = [{ name = "Iterative", email = "support@dvc.org" }]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -23,7 +24,7 @@ requires-python = ">=3.9"
 dynamic = ["version"]
 dependencies = [
     "gitpython>3",
-    "dulwich>=0.23.1",
+    "dulwich>=0.24.0",
     "pygit2>=1.14.0",
     "pygtrie>=2.3.2",
     "fsspec[tqdm]>=2024.2.0",
@@ -102,7 +103,7 @@ show_error_codes = true
 show_error_context = true
 show_traceback = true
 pretty = true
-check_untyped_defs = false
+check_untyped_defs = true
 # Warnings
 warn_no_return = true
 warn_redundant_casts = true
@@ -192,8 +193,9 @@ select = [
 
 [tool.ruff.lint.per-file-ignores]
 "noxfile.py" = ["D", "PTH"]
-"tests/**" = ["S", "ARG001", "ARG002", "ANN"]
+"tests/**" = ["S", "ARG001", "ARG002", "ANN", "TID251", "TID253"]
 "docs/**" = ["INP"]
+"src/scmrepo/git/backend/gitpython.py" = ["TID251"]
 
 [tool.ruff.lint.flake8-pytest-style]
 fixture-parentheses = false
@@ -203,6 +205,14 @@ parametrize-names-type = "csv"
 [tool.ruff.lint.flake8-type-checking]
 strict = true
 
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"git".msg = "importing from 'git' is not allowed except inside `gitpython` backend"
+
+[tool.ruff.lint.flake8-tidy-imports]
+# Ban certain modules from being imported at module level, instead requiring
+# that they're imported lazily (e.g., within a function definition).
+banned-module-level-imports = ["git"]
+
 [tool.ruff.lint.isort]
 known-first-party = ["scmrepo"]
 

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/git/backend/base.py

@@ -40,7 +40,7 @@ class BaseGitBackend(ABC):
 
     @property
     @abstractmethod
-    def root_dir(self) -> str:
+    def root_dir(self) -> Optional[str]:
         pass
 
     @staticmethod

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/git/backend/dulwich/__init__.py

@@ -17,6 +17,7 @@ from typing import (
 )
 
 from dulwich.config import ConfigFile, StackedConfig
+from dulwich.walk import ORDER_DATE
 from funcy import cached_property, reraise
 
 from scmrepo.exceptions import AuthError, CloneError, InvalidRemote, RevError, SCMError
@@ -203,9 +204,11 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
 
         Submodule paths will be relative to Git repo root.
         """
+
         from dulwich.config import ConfigFile, parse_submodules
 
         submodules: dict[str, str] = {}
+        assert self.root_dir
         config_path = os.path.join(self.root_dir, ".gitmodules")
         if os.path.isfile(config_path):
             config = ConfigFile.from_path(config_path)
@@ -217,7 +220,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
         self.repo.close()
 
     @property
-    def root_dir(self) -> str:
+    def root_dir(self) -> Optional[str]:
         return self.repo.path
 
     @classmethod
@@ -354,6 +357,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
                 # path relative to the submodule root.
                 fs_path = relpath(path, self.root_dir)
                 for sm_path in self._submodules.values():
+                    assert self.root_dir
                     if fs_path.startswith(sm_path):
                         path = os.path.join(
                             self.root_dir,
@@ -378,7 +382,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
 
         with reraise((Error, CommitError), SCMError("Git commit failed")):
             try:
-                commit(self.root_dir, message=msg, no_verify=no_verify)
+                commit(self.repo, message=msg, no_verify=no_verify)
             except InvalidUserIdentity as exc:
                 raise SCMError("Git username and email must be configured") from exc
             except TimezoneFormatError as exc:
@@ -421,7 +425,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
         from dulwich.porcelain import Error, branch_create
 
         try:
-            branch_create(self.root_dir, branch)
+            branch_create(self.repo, branch)
         except Error as exc:
             raise SCMError(f"Failed to create branch '{branch}'") from exc
 
@@ -473,7 +477,25 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
         return sorted(ref[len(base) :] for ref in self.iter_refs(base))
 
     def list_all_commits(self) -> Iterable[str]:
-        raise NotImplementedError
+        from dulwich.objects import Tag
+
+        repo = self.repo
+        starting_points: list[bytes] = []
+
+        # HEAD
+        head_rev = self.get_ref("HEAD")
+        if head_rev:
+            starting_points.append(head_rev.encode("utf-8"))
+
+        # Branches and remotes
+        for ref in repo.refs:
+            if ref.startswith((b"refs/heads/", b"refs/remotes/", b"refs/tags/")):
+                if isinstance(repo.refs[ref], Tag):
+                    ref = self.repo.get_peeled(repo.refs[ref])
+                starting_points.append(repo.refs[ref])
+
+        walker = self.repo.get_walker(include=starting_points, order=ORDER_DATE)
+        return [e.commit.id.decode() for e in walker]
 
     def get_tree_obj(self, rev: str, **kwargs) -> DulwichObject:
         from dulwich.objectspec import parse_tree
@@ -629,8 +651,13 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
         def update_refs(refs):
             from dulwich.objects import ZERO_SHA
 
+            _refspecs = (
+                os.fsencode(refspecs)
+                if isinstance(refspecs, str)
+                else [os.fsencode(refspec) for refspec in refspecs]
+            )
             selected_refs.extend(
-                parse_reftuples(self.repo.refs, refs, refspecs, force=force)
+                parse_reftuples(self.repo.refs, refs, _refspecs, force=force)
             )
             new_refs = {}
             for lh, rh, _ in selected_refs:
@@ -882,7 +909,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
 
         with reraise(Error, SCMError("Git status failed")):
             staged, unstaged, untracked = git_status(
-                self.root_dir, ignored=ignored, untracked_files=untracked_files
+                self.repo, ignored=ignored, untracked_files=untracked_files
             )
 
         return (

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/git/backend/gitpython.py

@@ -161,8 +161,9 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
         return bool(func(str(path)))
 
     @property
-    def root_dir(self) -> str:
-        return self.repo.working_tree_dir
+    def root_dir(self) -> Optional[str]:
+        d = self.repo.working_tree_dir
+        return os.fspath(d) if d is not None else d
 
     @staticmethod
     @requires_git
@@ -241,7 +242,7 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
 
     @property
     def dir(self) -> str:
-        return self.repo.git_dir
+        return os.fspath(self.repo.git_dir)
 
     def add(
         self,
@@ -262,7 +263,7 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
                     paths = [path for path in paths if not self.is_ignored(path)]
                 self.git.add(*paths, **kwargs)
             else:
-                self.repo.index.add(paths)
+                self.repo.index.add(paths if isinstance(paths, str) else list(paths))
         except AssertionError as exc:
             # NOTE: GitPython is not currently able to handle index version >= 3.
             # See https://github.com/iterative/dvc/issues/610 for more details.
@@ -301,7 +302,7 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
             kwargs["force"] = True
         if unshallow:
             kwargs["unshallow"] = True
-        infos = self.repo.remote(name=remote).fetch(**kwargs)
+        infos = self.repo.remote(name=remote).fetch(**kwargs)  # type: ignore[arg-type]
         for info in infos:
             if info.flags & info.ERROR:
                 raise SCMError(f"fetch failed: {info.note}")
@@ -350,7 +351,7 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
 
     def active_branch_remote(self) -> str:
         try:
-            return self.repo.active_branch.tracking_branch()
+            return self.repo.active_branch.tracking_branch()  # type: ignore[return-value]
         except (TypeError, ValueError) as exc:
             raise SCMError("No active branch tracking remote") from exc
 
@@ -428,15 +429,15 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
         return GitCommit(
             commit.hexsha,
             commit.committed_date,
-            commit.committer_tz_offset,
-            commit.message,
+            commit.committer_tz_offset,  # type: ignore[arg-type]
+            commit.message,  # type: ignore[arg-type]
             [str(parent) for parent in commit.parents],
-            commit.committer.name,
-            commit.committer.email,
-            commit.author.name,
-            commit.author.email,
+            commit.committer.name,  # type: ignore[arg-type]
+            commit.committer.email,  # type: ignore[arg-type]
+            commit.author.name,  # type: ignore[arg-type]
+            commit.author.email,  # type: ignore[arg-type]
             commit.authored_date,
-            commit.author_tz_offset,
+            commit.author_tz_offset,  # type: ignore[arg-type]
         )
 
     def set_ref(
@@ -744,6 +745,8 @@ class GitPythonBackend(BaseGitBackend):  # pylint:disable=abstract-method
             if not ref.tag:
                 return ref.commit.hexsha
             tag = ref.tag
+            assert tag.tagger.email
+            assert tag.tagger.name
             return GitTag(
                 tag.tag,
                 tag.hexsha,

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/git/backend/pygit2/__init__.py

@@ -171,7 +171,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             # 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)
+            pygit2.filter_register("lfs", LFSFilter)  # type: ignore[attr-defined]
         except ValueError:
             pass
 
@@ -181,7 +181,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         self.repo.free()
 
     @property
-    def root_dir(self) -> str:
+    def root_dir(self) -> Optional[str]:
         return self.repo.workdir
 
     @cached_property
@@ -194,10 +194,10 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         from pygit2 import Tag
         from pygit2.enums import ObjectType
 
-        commit, ref = self.repo.resolve_refish(refish)
+        commit, ref = self.repo.resolve_refish(refish)  # type: ignore[attr-defined]
         if isinstance(commit, Tag):
             ref = commit
-            commit = commit.peel(ObjectType.COMMIT)
+            commit = commit.peel(ObjectType.COMMIT)  # type: ignore[call-overload]
         return commit, ref
 
     @property
@@ -354,8 +354,8 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         with self.release_odb_handles():
             if create_new:
                 commit = self.repo.revparse_single("HEAD")
-                new_branch = self.repo.branches.local.create(branch, commit)
-                self.repo.checkout(new_branch, strategy=strategy)
+                new_branch = self.repo.branches.local.create(branch, commit)  # type: ignore[arg-type]
+                self.repo.checkout(new_branch, strategy=strategy)  # type: ignore[attr-defined]
             else:
                 if branch == "-":
                     branch = "@{-1}"
@@ -363,12 +363,12 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
                     commit, ref = self._resolve_refish(branch)
                 except (KeyError, GitError) as exc:
                     raise RevError(f"unknown Git revision '{branch}'") from exc
-                self.repo.checkout_tree(commit, strategy=strategy)
+                self.repo.checkout_tree(commit, strategy=strategy)  # type: ignore[attr-defined]
                 detach = kwargs.get("detach", False)
                 if ref and not detach:
-                    self.repo.set_head(ref.name)
+                    self.repo.set_head(ref.name)  # type: ignore[attr-defined]
                 else:
-                    self.repo.set_head(commit.id)
+                    self.repo.set_head(commit.id)  # type: ignore[attr-defined]
 
     def fetch(
         self,
@@ -389,7 +389,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
 
         try:
             commit = self.repo[self.repo.head.target]
-            self.repo.create_branch(branch, commit)
+            self.repo.create_branch(branch, commit)  # type: ignore[arg-type]
         except GitError as exc:
             raise SCMError(f"Failed to create branch '{branch}'") from exc
 
@@ -431,7 +431,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             # if HEAD points to a nonexistent branch we still return the
             # branch name (without "refs/heads/" prefix) to match gitpython's
             # behavior
-            return self.repo.references["HEAD"].target[11:]
+            return self.repo.references["HEAD"].target[11:]  # type: ignore[index]
         return self.repo.head.shorthand
 
     def active_branch_remote(self) -> str:
@@ -452,10 +452,35 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         return sorted(ref[len(base) :] for ref in self.iter_refs(base))
 
     def list_all_commits(self) -> Iterable[str]:
-        raise NotImplementedError
+        import pygit2
+        from pygit2.enums import SortMode
+
+        # Add HEAD
+        starting_points: list[Union[Oid, str]] = []
+        if not self.repo.head_is_unborn:
+            starting_points.append(self.repo.head.target)
+
+        # Add all branches, remotes, and tags
+        for ref in self.repo.references:
+            if ref.startswith(("refs/heads/", "refs/remotes/")):
+                oid = self.repo.revparse_single(ref).id
+                starting_points.append(oid)
+            elif ref.startswith("refs/tags/"):
+                tag_obj = self.repo.revparse_single(ref)
+                if isinstance(tag_obj, pygit2.Tag):
+                    starting_points.append(tag_obj.target)
+                else:
+                    starting_points.append(tag_obj.id)
+
+        # Walk all commits
+        walker = self.repo.walk(None)
+        for o in starting_points:
+            walker.push(o)
+        walker.sort(SortMode.TIME)
+        return [str(commit.id) for commit in walker]
 
     def get_tree_obj(self, rev: str, **kwargs) -> Pygit2Object:
-        tree = self.repo[rev].tree
+        tree = self.repo[rev].tree  # type: ignore[attr-defined]
         return Pygit2Object(tree, backend=self)
 
     def get_rev(self) -> str:
@@ -546,7 +571,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         try:
             obj = self.repo[ref.target]
             if isinstance(obj, Tag):
-                return str(obj.peel(ObjectType.COMMIT).id)
+                return str(obj.peel(ObjectType.COMMIT).id)  # type: ignore[call-overload]
         except ValueError:
             pass
 
@@ -759,7 +784,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         from scmrepo.git import Stash
 
         try:
-            oid = self.repo.stash(
+            oid = self.repo.stash(  # type: ignore[attr-defined]
                 self.committer,
                 message=message,
                 include_untracked=include_untracked,
@@ -770,8 +795,8 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         commit = self.repo[oid]
 
         if ref != Stash.DEFAULT_STASH:
-            self.set_ref(ref, commit.id, message=commit.message)
-            self.repo.stash_drop()
+            self.set_ref(ref, commit.id, message=commit.message)  # type: ignore[attr-defined,arg-type]
+            self.repo.stash_drop()  # type: ignore[attr-defined]
         return str(oid), False
 
     def _stash_apply(
@@ -788,11 +813,11 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
 
         def _apply(index):
             try:
-                self.repo.index.read(False)
+                self.repo.index.read(False)  # type: ignore[attr-defined]
                 strategy = self._get_checkout_strategy()
                 if skip_conflicts:
                     strategy |= CheckoutStrategy.ALLOW_CONFLICTS
-                self.repo.stash_apply(
+                self.repo.stash_apply(  # type: ignore[attr-defined]
                     index, strategy=strategy, reinstate_index=reinstate_index
                 )
             except GitError as exc:
@@ -814,7 +839,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         try:
             _apply(0)
         finally:
-            self.repo.stash_drop()
+            self.repo.stash_drop()  # type: ignore[attr-defined]
 
     def _stash_drop(self, ref: str, index: int):
         from scmrepo.git import Stash
@@ -822,7 +847,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         if ref != Stash.DEFAULT_STASH:
             raise NotImplementedError
 
-        self.repo.stash_drop(index)
+        self.repo.stash_drop(index)  # type: ignore[attr-defined]
 
     def _describe(
         self,
@@ -840,16 +865,16 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
         from pygit2 import IndexEntry
         from pygit2.enums import ResetMode
 
-        self.repo.index.read(False)
+        self.repo.index.read(False)  # type: ignore[attr-defined]
         if paths is not None:
-            tree = self.repo.revparse_single("HEAD").tree
+            tree = self.repo.revparse_single("HEAD").tree  # type: ignore[attr-defined]
             for path in paths:
                 rel = relpath(path, self.root_dir)
                 if os.name == "nt":
                     rel = rel.replace("\\", "/")
                 obj = tree[rel]
-                self.repo.index.add(IndexEntry(rel, obj.id, obj.filemode))
-            self.repo.index.write()
+                self.repo.index.add(IndexEntry(rel, obj.id, obj.filemode))  # type: ignore[attr-defined]
+            self.repo.index.write()  # type: ignore[attr-defined]
         elif hard:
             self.repo.reset(self.repo.head.target, ResetMode.HARD)
         else:
@@ -875,7 +900,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             strategy |= CheckoutStrategy.ALLOW_CONFLICTS
         strategy = self._get_checkout_strategy(strategy)
 
-        index = self.repo.index
+        index = self.repo.index  # type: ignore[attr-defined]
         if paths:
             path_list: Optional[list[str]] = [
                 relpath(path, self.root_dir) for path in paths
@@ -889,7 +914,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             path_list = None
 
         with self.release_odb_handles():
-            self.repo.checkout_index(index=index, paths=path_list, strategy=strategy)
+            self.repo.checkout_index(index=index, paths=path_list, strategy=strategy)  # type: ignore[attr-defined]
 
             if index.conflicts and (ours or theirs):
                 for ancestor, ours_entry, theirs_entry in index.conflicts:
@@ -900,9 +925,10 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
                         index.add(ours_entry)
                     else:
                         entry = theirs_entry
+                    assert self.root_dir
                     path = os.path.join(self.root_dir, entry.path)
                     with open(path, "wb") as fobj:
-                        fobj.write(self.repo.get(entry.id).read_raw())
+                        fobj.write(self.repo.get(entry.id).read_raw())  # type: ignore[attr-defined]
                     index.add(entry.path)
                 index.write()
 
@@ -965,8 +991,8 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             raise SCMError("Cannot merge with 'squash' and 'commit'")
 
         with self.release_odb_handles():
-            self.repo.index.read(False)
-            obj, _ref = self.repo.resolve_refish(rev)
+            self.repo.index.read(False)  # type: ignore[attr-defined]
+            obj, _ref = self.repo.resolve_refish(rev)  # type: ignore[attr-defined]
             try:
                 analysis, ff_pref = self.repo.merge_analysis(obj.id)
             except GitError as exc:
@@ -978,12 +1004,12 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
                 return None
 
             try:
-                self.repo.merge(obj.id)
-                self.repo.index.write()
+                self.repo.merge(obj.id)  # type: ignore[attr-defined]
+                self.repo.index.write()  # type: ignore[attr-defined]
             except GitError as exc:
                 raise SCMError("Merge failed") from exc
 
-            if self.repo.index.conflicts:
+            if self.repo.index.conflicts:  # type: ignore[attr-defined]
                 raise MergeConflictError("Merge contained conflicts")
 
             try:
@@ -992,7 +1018,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
                         return self._merge_ff(rev, obj)
 
                     if analysis & MergeAnalysis.UNBORN:
-                        self.repo.set_head(obj.id)
+                        self.repo.set_head(obj.id)  # type: ignore[attr-defined]
                         return str(obj.id)
 
                 if ff_pref & MergePreference.FASTFORWARD_ONLY:
@@ -1005,12 +1031,12 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
                 # HEAD is not moved and merge changes stay in index
                 return None
             finally:
-                self.repo.state_cleanup()
-                self.repo.index.write()
+                self.repo.state_cleanup()  # type: ignore[attr-defined]
+                self.repo.index.write()  # type: ignore[attr-defined]
 
     def _merge_ff(self, rev: str, obj) -> str:
         if self.repo.head_is_detached:
-            self.repo.set_head(obj.id)
+            self.repo.set_head(obj.id)  # type: ignore[attr-defined]
         else:
             branch = self.get_ref("HEAD", follow=False)
             assert branch
@@ -1024,7 +1050,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
     def _merge_commit(self, msg: Optional[str], obj) -> str:
         if not msg:
             raise SCMError("Merge commit message is required")
-        tree = self.repo.index.write_tree()
+        tree = self.repo.index.write_tree()  # type: ignore[attr-defined]
         merge_commit = self.repo.create_commit(
             "HEAD",
             self.author,
@@ -1078,7 +1104,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
 
         if path:
             return Pygit2Config(_Pygit2Config(path))
-        return Pygit2Config(self.repo.config)
+        return Pygit2Config(self.repo.config)  # type: ignore[attr-defined]
 
     def check_attr(
         self,
@@ -1098,7 +1124,7 @@ class Pygit2Backend(BaseGitBackend):  # pylint:disable=abstract-method
             except (KeyError, GitError) as exc:
                 raise SCMError(f"Invalid commit '{source}'") from exc
         try:
-            return self.repo.get_attr(
+            return self.repo.get_attr(  # type: ignore[attr-defined]
                 path, attr, flags=flags, commit=commit.id if commit else None
             )
         except GitError as exc:

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/git/backend/pygit2/filter.py

@@ -18,22 +18,22 @@ class LFSFilter(Filter):
         self._smudge_root: Optional[str] = None
 
     def check(self, src: "FilterSource", attr_values: list[Optional[str]]):
-        if attr_values[0] == "lfs" and src.mode != GIT_FILTER_CLEAN:
+        if attr_values[0] == "lfs" and src.mode != GIT_FILTER_CLEAN:  # type: ignore[attr-defined]
             self._smudge_buf = io.BytesIO()
-            self._smudge_root = src.repo.workdir or src.repo.path
+            self._smudge_root = src.repo.workdir or src.repo.path  # type: ignore[attr-defined]
             return
         raise Passthrough
 
     def write(
         self, data: bytes, src: "FilterSource", write_next: Callable[[bytes], None]
     ):
-        if src.mode == GIT_FILTER_CLEAN:
+        if src.mode == GIT_FILTER_CLEAN:  # type: ignore[attr-defined]
             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_root = src.repo.workdir or src.repo.path  # type: ignore[attr-defined]
         self._smudge_buf.write(data)
 
     def close(self, write_next: Callable[[bytes], None]):

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/progress.py

@@ -4,7 +4,7 @@ from funcy import compose
 
 
 def code2desc(op_code):
-    from git import RootUpdateProgress as OP  # noqa: N814
+    from git import RootUpdateProgress as OP  # noqa: N814, TID251
 
     ops = {
         OP.COUNTING: "Counting",
@@ -44,16 +44,20 @@ class GitProgressEvent(NamedTuple):
 
 class GitProgressReporter:
     def __init__(self, fn) -> None:
-        from git.util import CallableRemoteProgress
-
-        self._reporter = CallableRemoteProgress(self.wrap_fn(fn))
+        try:
+            from git.util import CallableRemoteProgress  # noqa: TID251
+        except ImportError:
+            self._reporter = None
+        else:
+            self._reporter = CallableRemoteProgress(self.wrap_fn(fn))
 
     def __call__(self, msg: Union[str, bytes]) -> None:
-        self._reporter._parse_progress_line(
-            msg.decode("utf-8", errors="replace").strip()
-            if isinstance(msg, bytes)
-            else msg
-        )
+        if self._reporter is not None:
+            self._reporter._parse_progress_line(
+                msg.decode("utf-8", errors="replace").strip()
+                if isinstance(msg, bytes)
+                else msg
+            )
 
     @staticmethod
     def wrap_fn(fn):

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo/utils.py

@@ -1,9 +1,13 @@
 import os
-from collections.abc import MutableMapping
+from collections.abc import Iterator, MutableMapping
+from typing import Callable, TypeVar, Union
 
+K = TypeVar("K")
+V = TypeVar("V")
 
-class LazyDict(MutableMapping):
-    def __init__(self, values):
+
+class LazyDict(MutableMapping[K, V]):
+    def __init__(self, values: dict[K, Union[V, Callable[[], V]]]):
         self._values = values
 
     def __getitem__(self, item):
@@ -13,16 +17,16 @@ class LazyDict(MutableMapping):
             self._values[item] = value
         return value
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: K, value: Union[V, Callable[[], V]]) -> None:
         self._values[key] = value
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: K) -> None:
         del self._values[key]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[K]:
         return iter(self._values)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._values)
 
 

{scmrepo-3.3.12 → scmrepo-3.5.0/src/scmrepo.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: scmrepo
-Version: 3.3.12
+Version: 3.5.0
 Summary: scmrepo
 Author-email: Iterative <support@dvc.org>
-License: Apache-2.0
+License-Expression: Apache-2.0
 Project-URL: Issues, https://github.com/iterative/scmrepo/issues
 Project-URL: Source, https://github.com/iterative/scmrepo
 Classifier: Programming Language :: Python :: 3
@@ -17,7 +17,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: gitpython>3
-Requires-Dist: dulwich>=0.23.1
+Requires-Dist: dulwich>=0.24.0
 Requires-Dist: pygit2>=1.14.0
 Requires-Dist: pygtrie>=2.3.2
 Requires-Dist: fsspec[tqdm]>=2024.2.0

{scmrepo-3.3.12 → scmrepo-3.5.0}/src/scmrepo.egg-info/requires.txt

@@ -1,5 +1,5 @@
 gitpython>3
-dulwich>=0.23.1
+dulwich>=0.24.0
 pygit2>=1.14.0
 pygtrie>=2.3.2
 fsspec[tqdm]>=2024.2.0

{scmrepo-3.3.12 → scmrepo-3.5.0}/tests/test_credentials.py

@@ -73,7 +73,7 @@ def test_subprocess_strip_trailing_garbage_bytes(git_helper, mocker):
         "subprocess.run",
         # Simulate git-credential-osxkeychain (version 2.45), assuming initial 0-byte
         return_value=mocker.Mock(
-            stdout=f"username=foo\npassword=bar{chr(0)}{random.randbytes(15)}"
+            stdout=f"username=foo\npassword=bar{chr(0)}{random.randbytes(15)}"  # type: ignore[str-bytes-safe]
         ),
     )
     creds = git_helper.get(Credential(protocol="https", host="foo.com", path="foo.git"))

{scmrepo-3.3.12 → scmrepo-3.5.0}/tests/test_dulwich.py

@@ -68,24 +68,24 @@ class Server(paramiko.ServerInterface):
 
     def check_auth_interactive_response(self, responses):
         if responses[0] == PASSWORD:
-            return paramiko.AUTH_SUCCESSFUL
-        return paramiko.AUTH_FAILED
+            return paramiko.AUTH_SUCCESSFUL  # type: ignore[attr-defined]
+        return paramiko.AUTH_FAILED  # type: ignore[attr-defined]
 
     def check_auth_password(self, username, password):
         if username == USER and password == PASSWORD:
-            return paramiko.AUTH_SUCCESSFUL
-        return paramiko.AUTH_FAILED
+            return paramiko.AUTH_SUCCESSFUL  # type: ignore[attr-defined]
+        return paramiko.AUTH_FAILED  # type: ignore[attr-defined]
 
     def check_auth_publickey(self, username, key):
         pubkey = paramiko.RSAKey.from_private_key(StringIO(CLIENT_KEY))
         if username == USER and key == pubkey:
-            return paramiko.AUTH_SUCCESSFUL
-        return paramiko.AUTH_FAILED
+            return paramiko.AUTH_SUCCESSFUL  # type: ignore[attr-defined]
+        return paramiko.AUTH_FAILED  # type: ignore[attr-defined]
 
     def check_channel_request(self, kind, chanid):
         if kind == "session":
-            return paramiko.OPEN_SUCCEEDED
-        return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED
+            return paramiko.OPEN_SUCCEEDED  # type: ignore[attr-defined]
+        return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED  # type: ignore[attr-defined]
 
     def get_allowed_auths(self, username):
         return self.allowed_auths
@@ -111,7 +111,7 @@ def ssh_conn(request: pytest.FixtureRequest) -> dict[str, Any]:
             conn, _ = sock.accept()
         except OSError:
             return False
-        server.transport = transport = paramiko.Transport(conn)
+        server.transport = transport = paramiko.Transport(conn)  # type: ignore[attr-defined]
         request.addfinalizer(transport.close)
         host_key = paramiko.RSAKey.from_private_key(StringIO(CLIENT_KEY))
         transport.add_server_key(host_key)

{scmrepo-3.3.12 → scmrepo-3.5.0}/tests/test_git.py

@@ -1,5 +1,6 @@
 import os
 import shutil
+import time
 from pathlib import Path
 from typing import Any, Optional
 
@@ -422,21 +423,170 @@ def test_iter_remote_refs(
     } == set(git.iter_remote_refs(remote))
 
 
-@pytest.mark.skip_git_backend("dulwich", "pygit2")
+def _gen(scm: Git, s: str, commit_timestamp: Optional[float] = None) -> str:
+    with open(s, mode="w") as f:
+        f.write(s)
+    scm.dulwich.add([s])
+    scm.dulwich.repo.do_commit(
+        message=s.encode("utf-8"), commit_timestamp=commit_timestamp
+    )
+    return scm.get_rev()
+
+
 def test_list_all_commits(tmp_dir: TmpDir, scm: Git, git: Git, matcher: type[Matcher]):
-    def _gen(s):
-        tmp_dir.gen(s, s)
-        scm.add_commit(s, message=s)
-        return scm.get_rev()
+    assert git.list_all_commits() == []
+    # https://github.com/libgit2/libgit2/issues/6336
+    now = time.time()
+
+    rev_a = _gen(scm, "a", commit_timestamp=now - 10)
+    rev_b = _gen(scm, "b", commit_timestamp=now - 8)
+    rev_c = _gen(scm, "c", commit_timestamp=now - 5)
+    rev_d = _gen(scm, "d", commit_timestamp=now - 2)
+
+    assert git.list_all_commits() == [rev_d, rev_c, rev_b, rev_a]
+
+    scm.gitpython.git.reset(rev_b, hard=True)
+    assert git.list_all_commits() == [rev_b, rev_a]
 
-    rev_a = _gen("a")
-    rev_b = _gen("b")
+
+def test_list_all_commits_branch(
+    tmp_dir: TmpDir, scm: Git, git: Git, matcher: type[Matcher]
+):
+    revs = {}
+    now = time.time()
+
+    revs["1"] = _gen(scm, "a", commit_timestamp=now - 10)
+
+    scm.checkout("branch", create_new=True)
+    revs["3"] = _gen(scm, "c", commit_timestamp=now - 9)
+
+    scm.checkout("master")
+    revs["2"] = _gen(scm, "b", commit_timestamp=now - 7)
+
+    scm.checkout("branch")
+    revs["5"] = _gen(scm, "e", commit_timestamp=now - 6)
+
+    scm.checkout("master")
+    revs["4"] = _gen(scm, "d", commit_timestamp=now - 5)
+
+    scm.checkout("branch")
+    revs["6"] = _gen(scm, "f", commit_timestamp=now - 4)
+
+    scm.checkout("master")
+    revs["7"] = _gen(scm, "g", commit_timestamp=now - 3)
+    revs["8"] = scm.merge("branch", msg="merge branch")
+
+    inv_map = {v: k for k, v in revs.items()}
+    assert [inv_map[k] for k in git.list_all_commits()] == [
+        "8",
+        "7",
+        "6",
+        "4",
+        "5",
+        "2",
+        "3",
+        "1",
+    ]
+
+
+def test_list_all_tags(tmp_dir: TmpDir, scm: Git, git: Git, matcher: type[Matcher]):
+    rev_a = _gen(scm, "a")
     scm.tag("tag")
-    rev_c = _gen("c")
+    rev_b = _gen(scm, "b")
+    scm.tag("annotated", annotated=True, message="Annotated Tag")
+    rev_c = _gen(scm, "c")
+    rev_d = _gen(scm, "d")
+    assert git.list_all_commits() == matcher.unordered(rev_d, rev_c, rev_b, rev_a)
+
+    rev_e = _gen(scm, "e")
+    scm.tag(
+        "annotated2",
+        target="refs/tags/annotated",
+        annotated=True,
+        message="Annotated Tag",
+    )
+    assert git.list_all_commits() == matcher.unordered(
+        rev_e, rev_d, rev_c, rev_b, rev_a
+    )
+
+    rev_f = _gen(scm, "f")
+    scm.tag(
+        "annotated3",
+        target="refs/tags/annotated2",
+        annotated=True,
+        message="Annotated Tag 3",
+    )
+    assert git.list_all_commits() == matcher.unordered(
+        rev_f, rev_e, rev_d, rev_c, rev_b, rev_a
+    )
+
     scm.gitpython.git.reset(rev_a, hard=True)
-    scm.set_ref("refs/foo/bar", rev_c)
+    assert git.list_all_commits() == matcher.unordered(rev_b, rev_a)
+
+
+def test_list_all_commits_dangling_annotated_tag(tmp_dir: TmpDir, scm: Git, git: Git):
+    rev_a = _gen(scm, "a")
+    scm.tag("annotated", annotated=True, message="Annotated Tag")
+
+    _gen(scm, "b")
 
-    assert git.list_all_commits() == matcher.unordered(rev_a, rev_b)
+    # Delete branch pointing to rev_a
+    scm.checkout(rev_a)
+    scm.gitpython.repo.delete_head("master", force=True)
+
+    assert git.list_all_commits() == [rev_a]  # Only reachable via the tag
+
+
+def test_list_all_commits_orphan(
+    tmp_dir: TmpDir, scm: Git, git: Git, matcher: type[Matcher]
+):
+    rev_a = _gen(scm, "a")
+
+    # Make an orphan branch
+    scm.gitpython.git.checkout("--orphan", "orphan-branch")
+    rev_orphan = _gen(scm, "orphanfile")
+
+    assert rev_orphan != rev_a
+    assert git.list_all_commits() == matcher.unordered(rev_orphan, rev_a)
+
+
+def test_list_all_commits_refs(
+    tmp_dir: TmpDir, scm: Git, git: Git, matcher: type[Matcher]
+):
+    assert git.list_all_commits() == []
+
+    rev_a = _gen(scm, "a")
+
+    assert git.list_all_commits() == [rev_a]
+    rev_b = _gen(scm, "b")
+    scm.set_ref("refs/remotes/origin/feature", rev_b)
+    assert git.list_all_commits() == matcher.unordered(rev_b, rev_a)
+
+    # also add refs/exps/foo/bar
+    rev_c = _gen(scm, "c")
+    scm.set_ref("refs/exps/foo/bar", rev_c)
+    assert git.list_all_commits() == matcher.unordered(rev_c, rev_b, rev_a)
+
+    # Dangling/broken ref ---
+    scm.set_ref("refs/heads/bad-ref", "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
+    with pytest.raises(Exception):  # noqa: B017, PT011
+        git.list_all_commits()
+    scm.remove_ref("refs/heads/bad-ref")
+
+    scm.gitpython.git.reset(rev_a, hard=True)
+    assert git.list_all_commits() == matcher.unordered(rev_b, rev_a)
+
+
+def test_list_all_commits_detached_head(
+    tmp_dir: TmpDir, scm: Git, git: Git, matcher: type[Matcher]
+):
+    rev_a = _gen(scm, "a")
+    rev_b = _gen(scm, "b")
+    rev_c = _gen(scm, "c")
+    scm.checkout(rev_b)
+
+    assert scm.pygit2.repo.head_is_detached
+    assert git.list_all_commits() == matcher.unordered(rev_c, rev_b, rev_a)
 
 
 @pytest.mark.skip_git_backend("pygit2")
@@ -771,7 +921,7 @@ def test_ignored(tmp_dir: TmpDir, scm: Git, git: Git, git_backend: str):
     assert not git.is_ignored(tmp_dir / "dir1" / "file2.txt")
 
 
-@pytest.mark.skip_git_backend("pygit2", "gitpython", "dulwich")
+@pytest.mark.skip_git_backend("pygit2", "gitpython")
 def test_ignored_dir_unignored_subdirs(tmp_dir: TmpDir, scm: Git, git: Git):
     tmp_dir.gen({".gitignore": "data/**\n!data/**/\n!data/**/*.csv"})
     scm.add([".gitignore"])
@@ -961,6 +1111,7 @@ def proxy_server():
         pass
 
     _ProxyServer.setUpClass()
+    assert _ProxyServer.PROXY
     yield f"http://{_ProxyServer.PROXY.flags.hostname}:{_ProxyServer.PROXY.flags.port}"
     _ProxyServer.tearDownClass()
 

{scmrepo-3.3.12 → scmrepo-3.5.0}/tests/vendor/test_paramiko_vendor.py

@@ -41,19 +41,19 @@ else:
 
         def check_auth_password(self, username, password):
             if username == USER and password == PASSWORD:
-                return paramiko.AUTH_SUCCESSFUL
-            return paramiko.AUTH_FAILED
+                return paramiko.AUTH_SUCCESSFUL  # type: ignore[attr-defined]
+            return paramiko.AUTH_FAILED  # type: ignore[attr-defined]
 
         def check_auth_publickey(self, username, key):
             pubkey = paramiko.RSAKey.from_private_key(StringIO(CLIENT_KEY))
             if username == USER and key == pubkey:
-                return paramiko.AUTH_SUCCESSFUL
-            return paramiko.AUTH_FAILED
+                return paramiko.AUTH_SUCCESSFUL  # type: ignore[attr-defined]
+            return paramiko.AUTH_FAILED  # type: ignore[attr-defined]
 
         def check_channel_request(self, kind, chanid):
             if kind == "session":
-                return paramiko.OPEN_SUCCEEDED
-            return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED
+                return paramiko.OPEN_SUCCEEDED  # type: ignore[attr-defined]
+            return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED  # type: ignore[attr-defined]
 
         def get_allowed_auths(self, username):
             return "password,publickey"