GitPython 3.1.52__tar.gz → 3.1.54__tar.gz

{gitpython-3.1.52 → gitpython-3.1.54}/CONTRIBUTING.md

@@ -20,25 +20,16 @@ A contribution that works only narrowly but lowers the quality of the
 codebase may be declined. The maintainers may not always be able to provide
 detailed feedback.
 
-## AI-assisted contributions
+## Prevent agent impersonation
 
-If AI edits files for you, disclose it in the pull request description and commit
-metadata. Prefer making the agent identity part of the commit, for example by using
-an AI author such as `$agent $version <ai-agent@example.invalid>` or a co-author via
-a `Co-authored-by: <agent-identity>` trailer.
+AI agents communicating through a person's account must identify themselves, for
+example in issue or PR descriptions and comments. AI assistance that does not replace
+the person as the speaker, such as proofreading or wording polish, does not require
+identification.
 
-Agents operating through a person's GitHub account must identify themselves. For
-example, comments posted by an agent should say so directly with phrases like
-`AI agent on behalf of <person>: ...`.
-
-Fully AI-generated comments on pull requests or issues must also be disclosed.
-Undisclosed AI-generated comments may lead to the pull request or issue being closed.
-
-AI-assisted proofreading or wording polish does not need disclosure, but it is still
-courteous to mention it when the AI materially influenced the final text.
-
-Automated or "full-auto" AI contributions without a human responsible for reviewing
-and standing behind the work may be closed.
+Attributing AI assistance in commit metadata, for example with a `Co-authored-by`
+trailer, is welcome but not required. Code is reviewed the same way regardless of its
+origin.
 
 ## Fuzzing Test Specific Documentation
 

{gitpython-3.1.52 → gitpython-3.1.54/GitPython.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GitPython
-Version: 3.1.52
+Version: 3.1.54
 Summary: GitPython is a Python library used to interact with Git repositories
 Home-page: https://github.com/gitpython-developers/GitPython
 Author: Sebastian Thiel, Michael Trier

{gitpython-3.1.52/GitPython.egg-info → gitpython-3.1.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GitPython
-Version: 3.1.52
+Version: 3.1.54
 Summary: GitPython is a Python library used to interact with Git repositories
 Home-page: https://github.com/gitpython-developers/GitPython
 Author: Sebastian Thiel, Michael Trier

gitpython-3.1.54/VERSION

@@ -0,0 +1 @@
+3.1.54

{gitpython-3.1.52 → gitpython-3.1.54}/doc/source/changes.rst

@@ -2,6 +2,33 @@
 Changelog
 =========
 
+3.1.54
+======
+
+A security fix for
+
+* https://github.com/gitpython-developers/GitPython/security/advisories/GHSA-r9mr-m37c-5fr3
+* https://github.com/gitpython-developers/GitPython/security/advisories/GHSA-6p8h-3wgx-97gf
+* https://github.com/gitpython-developers/GitPython/security/advisories/GHSA-fjr4-x663-mwxc#event-857190
+
+If you can, also try and provide feedback on the upcoming v4 branch
+https://github.com/gitpython-developers/GitPython/pull/2177 - patches welcome.
+
+See the following for all changes.
+https://github.com/gitpython-developers/GitPython/releases/tag/3.1.54
+
+3.1.53
+======
+
+A security fix for
+https://github.com/gitpython-developers/GitPython/security/advisories/GHSA-3rp5-jjmw-4wv2
+
+If you can, also try and provide feedback on the upcoming v4 branch
+https://github.com/gitpython-developers/GitPython/pull/2177 - patches welcome.
+
+See the following for all changes.
+https://github.com/gitpython-developers/GitPython/releases/tag/3.1.53
+
 3.1.52
 ======
 

{gitpython-3.1.52 → gitpython-3.1.54}/git/__init__.py

@@ -86,7 +86,7 @@ __all__ = [
     "to_hex_sha",
 ]
 
-__version__ = '3.1.52'
+__version__ = '3.1.54'
 
 from typing import Any, List, Optional, Sequence, TYPE_CHECKING, Tuple, Union
 

{gitpython-3.1.52 → gitpython-3.1.54}/git/cmd.py

@@ -1039,11 +1039,18 @@ class Git(metaclass=_GitMeta):
             option for option in cls._unpack_args([arg for arg in args if arg is not None]) if option.startswith("-")
         ]
         if kwargs:
+            split_single_char_options = kwargs.get("split_single_char_options", True)
             for key, value in kwargs.items():
                 values = value if isinstance(value, (list, tuple)) else (value,)
                 if any(value is True or (value is not False and value is not None) for value in values):
                     key = str(key)
                     options.append(f"-{key}" if len(key) == 1 else f"--{dashify(key)}")
+                    if len(key) == 1 and split_single_char_options:
+                        options.extend(
+                            str(value)
+                            for value in values
+                            if value is not True and value not in (False, None) and str(value).startswith("-")
+                        )
         return options
 
     AutoInterrupt: TypeAlias = _AutoInterrupt
@@ -1358,7 +1365,7 @@ class Git(metaclass=_GitMeta):
 
         # Allow the user to have the command executed in their working dir.
         try:
-            cwd = self._working_dir or os.getcwd()  # type: Union[None, str]
+            cwd = self._working_dir or os.getcwd()  # type: Optional[PathLike]
             if not os.access(str(cwd), os.X_OK):
                 cwd = None
         except FileNotFoundError:

{gitpython-3.1.52 → gitpython-3.1.54}/git/config.py

@@ -897,6 +897,22 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
     def _assure_config_name_safe(self, name: "cp._SectionName", label: str) -> None:
         if isinstance(name, str) and UNSAFE_CONFIG_CHARS_RE.search(name):
             raise ValueError("Git config %s names must not contain CR, LF, or NUL" % label)
+        if label == "section" and isinstance(name, str):
+            in_quotes = False
+            escaped = False
+            for index, char in enumerate(name):
+                if escaped:
+                    escaped = False
+                elif in_quotes and char == "\\":
+                    escaped = True
+                elif char == '"':
+                    if not in_quotes and (index == 0 or name[index - 1] not in " \t"):
+                        raise ValueError("Git config quoted subsection names must begin after whitespace")
+                    in_quotes = not in_quotes
+                elif char == "]" and not in_quotes:
+                    raise ValueError("Git config section names must not contain an unquoted closing bracket")
+            if in_quotes:
+                raise ValueError("Git config section names must not contain an unterminated quote")
 
     @needs_values
     @set_dirty_and_flush_changes

{gitpython-3.1.52 → gitpython-3.1.54}/git/diff.py

@@ -9,7 +9,7 @@ import enum
 import re
 import warnings
 
-from git.cmd import handle_process_output
+from git.cmd import Git, handle_process_output
 from git.compat import defenc
 from git.objects.blob import Blob
 from git.objects.util import mode_str_to_int
@@ -35,7 +35,6 @@ from git.types import PathLike, Literal
 if TYPE_CHECKING:
     from subprocess import Popen
 
-    from git.cmd import Git
     from git.objects.base import IndexObject
     from git.objects.commit import Commit
     from git.objects.tree import Tree
@@ -190,6 +189,7 @@ class Diffable:
         other: Union[DiffConstants, "Tree", "Commit", str, None] = INDEX,
         paths: Union[PathLike, List[PathLike], Tuple[PathLike, ...], None] = None,
         create_patch: bool = False,
+        allow_unsafe_options: bool = False,
         **kwargs: Any,
     ) -> "DiffIndex[Diff]":
         """Create diffs between two items being trees, trees and index or an index and
@@ -219,6 +219,10 @@ class Diffable:
             applied makes the self to other. Patches are somewhat costly as blobs have
             to be read and diffed.
 
+        :param allow_unsafe_options:
+            If ``True``, allow options such as ``--output`` that can write to arbitrary
+            filesystem paths.
+
         :param kwargs:
             Additional arguments passed to :manpage:`git-diff(1)`, such as ``R=True`` to
             swap both sides of the diff.
@@ -231,6 +235,12 @@ class Diffable:
             an instance of :class:`~git.objects.tree.Tree` or
             :class:`~git.objects.commit.Commit`, or a git command error will occur.
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([other], kwargs),
+                unsafe_options=self.repo.unsafe_git_revision_options,
+            )
+
         args: List[Union[PathLike, Diffable]] = []
         args.append("--abbrev=40")  # We need full shas.
         args.append("--full-index")  # Get full index paths, not only filenames.

{gitpython-3.1.52 → gitpython-3.1.54}/git/index/base.py

@@ -23,6 +23,7 @@ from gitdb.base import IStream
 from gitdb.db import MemoryDB
 
 from git.compat import defenc, force_bytes
+from git.cmd import Git
 import git.diff as git_diff
 from git.exc import CheckoutError, GitCommandError, GitError, InvalidGitRepositoryError
 from git.objects import Blob, Commit, Object, Submodule, Tree
@@ -1492,6 +1493,7 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         ] = git_diff.INDEX,
         paths: Union[PathLike, List[PathLike], Tuple[PathLike, ...], None] = None,
         create_patch: bool = False,
+        allow_unsafe_options: bool = False,
         **kwargs: Any,
     ) -> git_diff.DiffIndex[git_diff.Diff]:
         """Diff this index against the working copy or a :class:`~git.objects.tree.Tree`
@@ -1504,6 +1506,12 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             Will only work with indices that represent the default git index as they
             have not been initialized with a stream.
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([other], kwargs),
+                unsafe_options=self.repo.unsafe_git_revision_options,
+            )
+
         # Only run if we are the default repository index.
         if self._file_path != self._index_path():
             raise AssertionError("Cannot call %r on indices that do not represent the default git index" % self.diff())
@@ -1560,7 +1568,13 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             # Invert the existing R flag.
             cur_val = kwargs.get("R", False)
             kwargs["R"] = not cur_val
-            return other.diff(self.INDEX, paths, create_patch, **kwargs)
+            return other.diff(
+                self.INDEX,
+                paths,
+                create_patch,
+                allow_unsafe_options=allow_unsafe_options,
+                **kwargs,
+            )
         # END diff against other item handling
 
         # If other is not None here, something is wrong.
@@ -1568,4 +1582,4 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             raise ValueError("other must be None, Diffable.INDEX, a Tree or Commit, was %r" % other)
 
         # Diff against working copy - can be handled by superclass natively.
-        return super().diff(other, paths, create_patch, **kwargs)
+        return super().diff(other, paths, create_patch, allow_unsafe_options=allow_unsafe_options, **kwargs)

{gitpython-3.1.52 → gitpython-3.1.54}/git/index/fun.py

@@ -64,6 +64,17 @@ def hook_path(name: str, git_dir: PathLike) -> str:
     return osp.join(git_dir, "hooks", name)
 
 
+def _commit_hook_path(name: str, index: "IndexFile") -> str:
+    """:return: path to the named commit hook, respecting Git's core.hooksPath."""
+    with index.repo.config_reader() as config:
+        hooks_dir = config.get("core", "hooksPath", fallback="")
+
+    if not hooks_dir:
+        return hook_path(name, index.repo.git_dir)
+
+    return osp.abspath(osp.join(index.repo.working_dir, osp.expanduser(hooks_dir), name))
+
+
 def _has_file_extension(path: str) -> str:
     return osp.splitext(path)[1]
 
@@ -82,7 +93,7 @@ def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
 
     :raise git.exc.HookExecutionError:
     """
-    hp = hook_path(name, index.repo.git_dir)
+    hp = _commit_hook_path(name, index)
     if not os.access(hp, os.X_OK):
         return
 
@@ -94,8 +105,14 @@ def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
         if sys.platform == "win32" and not _has_file_extension(hp):
             # Windows only uses extensions to determine how to open files
             # (doesn't understand shebangs). Try using bash to run the hook.
-            relative_hp = Path(hp).relative_to(index.repo.working_dir).as_posix()
-            cmd = ["bash.exe", relative_hp]
+            try:
+                bash_hp = osp.relpath(hp, index.repo.working_dir)
+            except ValueError:
+                # Different drives have no relative path on Windows. Git Bash accepts
+                # an absolute path in this form, although a relative path is preferable
+                # because it also works with the Windows Subsystem for Linux wrapper.
+                bash_hp = hp
+            cmd = ["bash.exe", Path(bash_hp).as_posix()]
 
         process = safer_popen(
             cmd + list(args),

{gitpython-3.1.52 → gitpython-3.1.54}/git/objects/submodule/base.py

@@ -49,6 +49,7 @@ from typing import (
     Callable,
     Dict,
     Iterator,
+    List,
     Mapping,
     Sequence,
     TYPE_CHECKING,
@@ -738,122 +739,132 @@ class Submodule(IndexObject, TraversableIterableObj):
             mrepo = None
         # END init mrepo
 
+        def fetch_remotes(module_repo: "Repo") -> None:
+            rmts = module_repo.remotes
+            len_rmts = len(rmts)
+            for i, remote in enumerate(rmts):
+                op = FETCH
+                if i == 0:
+                    op |= BEGIN
+                # END handle start
+
+                progress.update(
+                    op,
+                    i,
+                    len_rmts,
+                    prefix + "Fetching remote %s of submodule %r" % (remote, self.name),
+                )
+                # ===============================
+                if not dry_run:
+                    remote.fetch(progress=progress)
+                # END handle dry-run
+                # ===============================
+                if i == len_rmts - 1:
+                    op |= END
+                # END handle end
+                progress.update(
+                    op,
+                    i,
+                    len_rmts,
+                    prefix + "Done fetching remote of submodule %r" % self.name,
+                )
+            # END fetch new data
+
         try:
             # ENSURE REPO IS PRESENT AND UP-TO-DATE
             #######################################
             try:
                 mrepo = self.module()
-                rmts = mrepo.remotes
-                len_rmts = len(rmts)
-                for i, remote in enumerate(rmts):
-                    op = FETCH
-                    if i == 0:
-                        op |= BEGIN
-                    # END handle start
-
-                    progress.update(
-                        op,
-                        i,
-                        len_rmts,
-                        prefix + "Fetching remote %s of submodule %r" % (remote, self.name),
-                    )
-                    # ===============================
-                    if not dry_run:
-                        remote.fetch(progress=progress)
-                    # END handle dry-run
-                    # ===============================
-                    if i == len_rmts - 1:
-                        op |= END
-                    # END handle end
-                    progress.update(
-                        op,
-                        i,
-                        len_rmts,
-                        prefix + "Done fetching remote of submodule %r" % self.name,
-                    )
-                # END fetch new data
+                fetch_remotes(mrepo)
             except InvalidGitRepositoryError:
                 mrepo = None
                 if not init:
                     return self
                 # END early abort if init is not allowed
 
-                # There is no git-repository yet - but delete empty paths.
                 checkout_module_abspath = self.abspath
-                if not dry_run and osp.isdir(checkout_module_abspath):
+                module_abspath = self._module_abspath(self.repo, self.path, self.name)
+
+                # ``git submodule deinit`` leaves the repository in
+                # ``.git/modules`` and empties the checkout. Reconnect that retained
+                # repository instead of trying to clone over it.
+                if not dry_run and osp.isdir(module_abspath):
                     try:
-                        os.rmdir(checkout_module_abspath)
-                    except OSError as e:
-                        raise OSError(
-                            "Module directory at %r does already exist and is non-empty" % checkout_module_abspath
-                        ) from e
-                    # END handle OSError
-                # END handle directory removal
-
-                # Don't check it out at first - nonetheless it will create a local
-                # branch according to the remote-HEAD if possible.
-                progress.update(
-                    BEGIN | CLONE,
-                    0,
-                    1,
-                    prefix
-                    + "Cloning url '%s' to '%s' in submodule %r" % (self.url, checkout_module_abspath, self.name),
-                )
-                if not dry_run:
-                    if self.url.startswith("."):
-                        url = urllib.parse.urljoin(self.repo.remotes.origin.url + "/", self.url)
+                        git.Repo(module_abspath)
+                    except InvalidGitRepositoryError:
+                        pass
                     else:
-                        url = self.url
-                    mrepo = self._clone_repo(
-                        self.repo,
-                        url,
-                        self.path,
-                        self.name,
-                        n=True,
-                        env=env,
-                        multi_options=clone_multi_options,
-                        allow_unsafe_options=allow_unsafe_options,
-                        allow_unsafe_protocols=allow_unsafe_protocols,
+                        if osp.lexists(checkout_module_abspath) and (
+                            osp.islink(checkout_module_abspath)
+                            or not osp.isdir(checkout_module_abspath)
+                            or os.listdir(checkout_module_abspath)
+                        ):
+                            raise OSError(
+                                "Module directory at %r does already exist and is non-empty" % checkout_module_abspath
+                            )
+                        os.makedirs(checkout_module_abspath, exist_ok=True)
+                        self._write_git_file_and_module_config(checkout_module_abspath, module_abspath)
+                        mrepo = git.Repo(checkout_module_abspath)
+                        mrepo.head.reset(mrepo.head.commit, index=True, working_tree=True)
+                        fetch_remotes(mrepo)
+                        with self.repo.config_writer() as writer:
+                            writer.set_value(sm_section(self.name), "url", self.url)
+
+                if mrepo is None:
+                    # There is no git-repository yet - but delete empty paths.
+                    if not dry_run and osp.isdir(checkout_module_abspath):
+                        try:
+                            os.rmdir(checkout_module_abspath)
+                        except OSError as e:
+                            raise OSError(
+                                "Module directory at %r does already exist and is non-empty" % checkout_module_abspath
+                            ) from e
+                    # END handle directory removal
+
+                    # Don't check it out at first - nonetheless it will create a local
+                    # branch according to the remote-HEAD if possible.
+                    progress.update(
+                        BEGIN | CLONE,
+                        0,
+                        1,
+                        prefix
+                        + "Cloning url '%s' to '%s' in submodule %r" % (self.url, checkout_module_abspath, self.name),
                     )
-                # END handle dry-run
-                progress.update(
-                    END | CLONE,
-                    0,
-                    1,
-                    prefix + "Done cloning to %s" % checkout_module_abspath,
-                )
-
-                if not dry_run:
-                    # See whether we have a valid branch to check out.
-                    try:
-                        mrepo = cast("Repo", mrepo)
-                        # Find a remote which has our branch - we try to be flexible.
-                        remote_branch = find_first_remote_branch(mrepo.remotes, self.branch_name)
-                        local_branch = mkhead(mrepo, self.branch_path)
-
-                        # Have a valid branch, but no checkout - make sure we can figure
-                        # that out by marking the commit with a null_sha.
-                        local_branch.set_object(Object(mrepo, self.NULL_BIN_SHA))
-                        # END initial checkout + branch creation
-
-                        # Make sure HEAD is not detached.
-                        mrepo.head.set_reference(
-                            local_branch,
-                            logmsg="submodule: attaching head to %s" % local_branch,
+                    if not dry_run:
+                        if self.url.startswith("."):
+                            url = urllib.parse.urljoin(self.repo.remotes.origin.url + "/", self.url)
+                        else:
+                            url = self.url
+                        mrepo = self._clone_repo(
+                            self.repo,
+                            url,
+                            self.path,
+                            self.name,
+                            n=True,
+                            env=env,
+                            multi_options=clone_multi_options,
+                            allow_unsafe_options=allow_unsafe_options,
+                            allow_unsafe_protocols=allow_unsafe_protocols,
                         )
-                        mrepo.head.reference.set_tracking_branch(remote_branch)
-                    except (IndexError, InvalidGitRepositoryError):
-                        _logger.warning("Failed to checkout tracking branch %s", self.branch_path)
-                    # END handle tracking branch
-
-                    # NOTE: Have to write the repo config file as well, otherwise the
-                    # default implementation will be offended and not update the
-                    # repository. Maybe this is a good way to ensure it doesn't get into
-                    # our way, but we want to stay backwards compatible too... It's so
-                    # redundant!
-                    with self.repo.config_writer() as writer:
-                        writer.set_value(sm_section(self.name), "url", self.url)
-                # END handle dry_run
+                    progress.update(END | CLONE, 0, 1, prefix + "Done cloning to %s" % checkout_module_abspath)
+
+                    if not dry_run:
+                        # See whether we have a valid branch to check out.
+                        try:
+                            mrepo = cast("Repo", mrepo)
+                            remote_branch = find_first_remote_branch(mrepo.remotes, self.branch_name)
+                            local_branch = mkhead(mrepo, self.branch_path)
+                            local_branch.set_object(Object(mrepo, self.NULL_BIN_SHA))
+                            mrepo.head.set_reference(
+                                local_branch,
+                                logmsg="submodule: attaching head to %s" % local_branch,
+                            )
+                            mrepo.head.reference.set_tracking_branch(remote_branch)
+                        except (IndexError, InvalidGitRepositoryError):
+                            _logger.warning("Failed to checkout tracking branch %s", self.branch_path)
+
+                        with self.repo.config_writer() as writer:
+                            writer.set_value(sm_section(self.name), "url", self.url)
             # END handle initialization
 
             # DETERMINE SHAS TO CHECK OUT
@@ -1267,6 +1278,36 @@ class Submodule(IndexObject, TraversableIterableObj):
 
         return self
 
+    @unbare_repo
+    def deinit(self, force: bool = False) -> "Submodule":
+        """Run ``git submodule deinit`` on this submodule.
+
+        This is a thin wrapper around ``git submodule deinit <path>``,
+        which unregisters the submodule (removes its entry from
+        ``.git/config`` and empties the working-tree directory)
+        without deleting the submodule from ``.gitmodules``
+        or its checked-out repository under ``.git/modules/``.
+        A subsequent :meth:`update` will re-initialize the
+        submodule from the retained contents.
+
+        :param force:
+            If ``True``, pass ``--force`` to ``git submodule deinit``. This
+            allows deinitialization even when the submodule's working tree has
+            local modifications that would otherwise block the command.
+
+        :return:
+            self
+
+        :note:
+            Doesn't work in bare repositories.
+        """
+        args: List[str] = []
+        if force:
+            args.append("--force")
+        args.extend(["--", str(self.path)])
+        self.repo.git.submodule("deinit", *args)
+        return self
+
     def set_parent_commit(self, commit: Union[Commit_ish, str, None], check: bool = True) -> "Submodule":
         """Set this instance to use the given commit whose tree is supposed to
         contain the ``.gitmodules`` blob.

{gitpython-3.1.52 → gitpython-3.1.54}/git/repo/base.py

@@ -149,6 +149,8 @@ class Repo:
         # Can override configuration variables that execute arbitrary commands:
         "--config",
         "-c",
+        # Can install hooks that execute during clone:
+        "--template",
     ]
     """Options to :manpage:`git-clone(1)` that allow arbitrary commands to be executed.
 
@@ -159,6 +161,9 @@ class Repo:
     The ``--config``/``-c`` option allows users to override configuration variables like
     ``protocol.allow`` and ``core.gitProxy`` to execute arbitrary commands:
     https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---configltkeygtltvaluegt
+
+    The ``--template`` option can install hooks that execute during clone:
+    https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---templatetemplate-directory
     """
 
     unsafe_git_archive_options = [

{gitpython-3.1.52 → gitpython-3.1.54}/git/util.py

@@ -217,7 +217,7 @@ def rmtree(path: PathLike) -> None:
         couldn't be deleted are read-only. Windows will not remove them in that case.
     """
 
-    def handler(function: Callable, path: PathLike, _excinfo: Any) -> None:
+    def handler(function: Callable[[str], Any], path: str, _excinfo: Any) -> None:
         """Callback for :func:`shutil.rmtree`.
 
         This works as either a ``onexc`` or ``onerror`` style callback.
@@ -401,7 +401,7 @@ def _cygexpath(drive: Optional[str], path: str, expand_vars: bool = True) -> str
     return p_str.replace("\\", "/")
 
 
-_cygpath_parsers: Tuple[Tuple[Pattern[str], Callable, bool], ...] = (
+_cygpath_parsers: Tuple[Tuple[Pattern[str], Callable[..., str], bool], ...] = (
     # See: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
     # and: https://www.cygwin.com/cygwin-ug-net/using.html#unc-paths
     (
@@ -508,7 +508,7 @@ def get_user_id() -> str:
     return "%s@%s" % (getpass.getuser(), platform.node())
 
 
-def finalize_process(proc: Union[subprocess.Popen, "Git.AutoInterrupt"], **kwargs: Any) -> None:
+def finalize_process(proc: Union["subprocess.Popen[Any]", "Git.AutoInterrupt"], **kwargs: Any) -> None:
     """Wait for the process (clone, fetch, pull or push) and handle its errors
     accordingly."""
     # TODO: No close proc-streams??
@@ -520,19 +520,21 @@ def expand_path(p: None, expand_vars: bool = ...) -> None: ...
 
 
 @overload
-def expand_path(p: PathLike, expand_vars: bool = ...) -> str:
+def expand_path(p: PathLike, expand_vars: bool = ...) -> Optional[PathLike]:
     # TODO: Support for Python 3.5 has been dropped, so these overloads can be improved.
     ...
 
 
 def expand_path(p: Union[None, PathLike], expand_vars: bool = True) -> Optional[PathLike]:
-    if isinstance(p, Path):
-        return p.resolve()
+    if p is None:
+        return None
     try:
-        p = osp.expanduser(p)  # type: ignore[arg-type]
+        if isinstance(p, Path):
+            return p.resolve()
+        expanded_path = osp.expanduser(os.fspath(p))
         if expand_vars:
-            p = osp.expandvars(p)
-        return osp.normpath(osp.abspath(p))
+            expanded_path = osp.expandvars(expanded_path)
+        return osp.normpath(osp.abspath(expanded_path))
     except Exception:
         return None
 
@@ -767,7 +769,7 @@ class CallableRemoteProgress(RemoteProgress):
 
     __slots__ = ("_callable",)
 
-    def __init__(self, fn: Callable) -> None:
+    def __init__(self, fn: Callable[..., Any]) -> None:
         self._callable = fn
         super().__init__()
 
@@ -846,7 +848,7 @@ class Actor:
         cls,
         env_name: str,
         env_email: str,
-        config_reader: Union[None, "GitConfigParser", "SectionConstraint"] = None,
+        config_reader: Union[None, "GitConfigParser", "SectionConstraint[GitConfigParser]"] = None,
     ) -> "Actor":
         actor = Actor("", "")
         user_id = None  # We use this to avoid multiple calls to getpass.getuser().
@@ -882,7 +884,9 @@ class Actor:
         return actor
 
     @classmethod
-    def committer(cls, config_reader: Union[None, "GitConfigParser", "SectionConstraint"] = None) -> "Actor":
+    def committer(
+        cls, config_reader: Union[None, "GitConfigParser", "SectionConstraint[GitConfigParser]"] = None
+    ) -> "Actor":
         """
         :return:
             :class:`Actor` instance corresponding to the configured committer. It
@@ -897,7 +901,9 @@ class Actor:
         return cls._main_actor(cls.env_committer_name, cls.env_committer_email, config_reader)
 
     @classmethod
-    def author(cls, config_reader: Union[None, "GitConfigParser", "SectionConstraint"] = None) -> "Actor":
+    def author(
+        cls, config_reader: Union[None, "GitConfigParser", "SectionConstraint[GitConfigParser]"] = None
+    ) -> "Actor":
         """Same as :meth:`committer`, but defines the main author. It may be specified
         in the environment, but defaults to the committer."""
         return cls._main_actor(cls.env_author_name, cls.env_author_email, config_reader)
@@ -980,11 +986,11 @@ class IndexFileSHA1Writer:
 
     __slots__ = ("f", "sha1")
 
-    def __init__(self, f: IO) -> None:
+    def __init__(self, f: IO[bytes]) -> None:
         self.f = f
         self.sha1 = make_sha(b"")
 
-    def write(self, data: AnyStr) -> int:
+    def write(self, data: bytes) -> int:
         self.sha1.update(data)
         return self.f.write(data)
 
@@ -1181,6 +1187,7 @@ class IterableList(List[T_IterableObj]):  # type: ignore[type-var]
         return super().__new__(cls)
 
     def __init__(self, id_attr: str, prefix: str = "") -> None:
+        super().__init__()
         self._id_attr = id_attr
         self._prefix = prefix
 
@@ -1210,7 +1217,9 @@ class IterableList(List[T_IterableObj]):  # type: ignore[type-var]
         # END for each item
         return list.__getattribute__(self, attr)
 
-    def __getitem__(self, index: Union[SupportsIndex, int, slice, str]) -> T_IterableObj:  # type: ignore[override]
+    def __getitem__(  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, index: Union[SupportsIndex, int, slice, str]
+    ) -> T_IterableObj:
         if isinstance(index, int):
             return list.__getitem__(self, index)
         elif isinstance(index, slice):
@@ -1288,7 +1297,7 @@ class IterableObj(Protocol):
         :return:
             list(Item,...) list of item instances
         """
-        out_list: IterableList = IterableList(cls._id_attribute_)
+        out_list: IterableList[T_IterableObj] = IterableList(cls._id_attribute_)
         out_list.extend(cls.iter_items(repo, *args, **kwargs))
         return out_list
 
@@ -1297,7 +1306,8 @@ class IterableClassWatcher(type):
     """Metaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable`
     is subclassed."""
 
-    def __init__(cls, name: str, bases: Tuple, clsdict: Dict) -> None:
+    def __init__(cls, name: str, bases: Tuple[type, ...], clsdict: Dict[str, Any]) -> None:
+        super().__init__(name, bases, clsdict)
         for base in bases:
             if type(base) is IterableClassWatcher:
                 warnings.warn(

{gitpython-3.1.52 → gitpython-3.1.54}/pyproject.toml

@@ -33,6 +33,17 @@ exclude = ["^git/ext/gitdb"]
 module = "gitdb.*"
 ignore_missing_imports = true
 
+[tool.basedpyright]
+typeCheckingMode = "standard"
+pythonVersion = "3.7"
+extraPaths = [
+    "git/ext/gitdb",
+    "git/ext/gitdb/gitdb/ext/smmap",
+]
+exclude = [
+    "git/ext/gitdb",
+]
+
 [tool.coverage.run]
 source = ["git"]
 

gitpython-3.1.52/VERSION

@@ -1 +0,0 @@
-3.1.52