GitPython 3.1.57__py3-none-any.whl → 3.1.59__py3-none-any.whl

git/__init__.py

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

git/cmd.py

@@ -652,6 +652,13 @@ class Git(metaclass=_GitMeta):
     unsafe_git_ls_remote_options = [
         # This option allows arbitrary command execution in git-ls-remote.
         "--upload-pack",
+        "--exec",
+    ]
+
+    unsafe_git_pathspec_from_file_options = [
+        # Reads pathspecs from a caller-controlled file. Some commands include an
+        # unmatched pathspec in their error output, which can disclose the file.
+        "--pathspec-from-file",
     ]
 
     def __getstate__(self) -> Dict[str, Any]:
@@ -970,7 +977,9 @@ class Git(metaclass=_GitMeta):
         return dashify(option_tokens[0])
 
     @classmethod
-    def check_unsafe_options(cls, options: List[str], unsafe_options: List[str]) -> None:
+    def check_unsafe_options(
+        cls, options: List[str], unsafe_options: List[str], clusterable_short_options: str = "46flnqsv"
+    ) -> None:
         """Raise :class:`~git.exc.UnsafeOptionError` for blocked option spellings.
 
         In addition to exact matches, this rejects abbreviated long options accepted
@@ -1005,7 +1014,7 @@ class Git(metaclass=_GitMeta):
         # These value-less Git flags can be clustered before another short option
         # (for example, ``-fuVALUE``). Stop at any other character because it may
         # begin an attached value, as ``o`` does in the safe option ``-oupstream``.
-        clusterable_short_options = frozenset("46flnqsv")
+        clusterable_short_options_set = frozenset(clusterable_short_options)
         options_are_kwargs = all(not option.startswith("-") for option in options)
         for option in options:
             candidate = cls._canonicalize_option_name(option)
@@ -1022,7 +1031,7 @@ class Git(metaclass=_GitMeta):
                         raise UnsafeOptionError(
                             f"{unsafe_option} is not allowed, use `allow_unsafe_options=True` to allow it."
                         )
-                    if option_char not in clusterable_short_options:
+                    if option_char not in clusterable_short_options_set:
                         break
             if not (option.startswith("--") or (options_are_kwargs and len(candidate) > 1)):
                 continue
@@ -1044,13 +1053,21 @@ class Git(metaclass=_GitMeta):
                 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:
+                    if len(key) != 1:
+                        options.append(f"--{dashify(key)}")
+                    elif split_single_char_options:
+                        options.append(f"-{key}")
                         options.extend(
                             str(value)
                             for value in values
                             if value is not True and value not in (False, None) and str(value).startswith("-")
                         )
+                    else:
+                        options.extend(
+                            f"-{key}" if value is True else f"-{key}{value}"
+                            for value in values
+                            if value is True or (value is not False and value is not None)
+                        )
         return options
 
     AutoInterrupt: TypeAlias = _AutoInterrupt
@@ -1119,7 +1136,7 @@ class Git(metaclass=_GitMeta):
         """List references in a remote repository.
 
         :param allow_unsafe_options:
-            Allow unsafe options, like ``--upload-pack``.
+            Allow unsafe options, like ``--upload-pack`` or ``--exec``.
         """
         if not allow_unsafe_options:
             candidate_options = self._option_candidates(args, kwargs)

git/config.py

@@ -75,6 +75,9 @@ See: https://git-scm.com/docs/git-config#_conditional_includes
 UNSAFE_CONFIG_CHARS_RE = re.compile(r"[\r\n\x00]")
 """Characters that cannot be safely written in config names or values."""
 
+VALID_CONFIG_OPTION_NAME_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
+"""Pattern for option names that can be written without changing config syntax."""
+
 
 class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
     """Utility class wrapping base-class methods into decorators that assure read-only
@@ -577,8 +580,12 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
 
             if keyword in ["gitdir", "gitdir/i"]:
                 value = osp.expanduser(value)
+                git_dir = os.fspath(self._repo.git_dir) if self._repo.git_dir else None
+                if sys.platform == "win32":
+                    git_dir = git_dir.replace("\\", "/") if git_dir else None
 
-                if not any(value.startswith(s) for s in ["./", "/"]):
+                drive, _tail = osp.splitdrive(value)
+                if not drive and not any(value.startswith(s) for s in ["./", "/"]):
                     value = "**/" + value
                 if value.endswith("/"):
                     value += "**"
@@ -590,9 +597,8 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
                         lambda m: f"[{m.group().lower()!r}{m.group().upper()!r}]",
                         value,
                     )
-                if self._repo.git_dir:
-                    if fnmatch.fnmatchcase(os.fspath(self._repo.git_dir), value):
-                        paths += _all_items(section)
+                if git_dir and fnmatch.fnmatchcase(git_dir, value):
+                    paths += _all_items(section)
 
             elif keyword == "onbranch":
                 try:
@@ -699,7 +705,11 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
                     continue
 
                 for v in values:
-                    fp.write(("\t%s = %s\n" % (key, self._value_to_string(v).replace("\n", "\n\t"))).encode(defenc))
+                    value = self._value_to_string(v)
+                    if any(char in value for char in '\n\t\b\\"'):
+                        value = value.replace("\\", "\\\\").replace('"', '\\"')
+                        value = '"%s\\\n"' % value.replace("\n", "\\n").replace("\t", "\\t").replace("\b", "\\b")
+                    fp.write(("\t%s = %s\n" % (key, value)).encode(defenc))
                 # END if key is not __name__
 
         # END section writing
@@ -897,6 +907,8 @@ 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 == "option" and isinstance(name, str) and not VALID_CONFIG_OPTION_NAME_RE.fullmatch(name):
+            raise ValueError("Git config option names may contain only letters, digits, '-', '_', or '.'")
         if label == "section" and isinstance(name, str):
             in_quotes = False
             escaped = False

git/db.py

@@ -5,10 +5,14 @@
 
 __all__ = ["GitCmdObjectDB", "GitDB"]
 
-from gitdb.base import OInfo, OStream
+from subprocess import PIPE
+
+from gitdb.base import IStream, OInfo, OStream
 from gitdb.db import GitDB, LooseObjectDB
 from gitdb.exc import BadObject
+from gitdb.fun import stream_copy
 
+from git.compat import force_text
 from git.util import bin_to_hex, hex_to_bin
 from git.exc import GitCommandError
 
@@ -46,6 +50,25 @@ class GitCmdObjectDB(LooseObjectDB):
         hexsha, typename, size, stream = self._git.stream_object_data(bin_to_hex(binsha))
         return OStream(hex_to_bin(hexsha), typename, size, stream)
 
+    def store(self, istream: IStream) -> IStream:
+        """Store an object using git itself."""
+        if istream.binsha is not None or self.ostream() is not None:
+            return super().store(istream)
+
+        proc = self._git.hash_object(
+            "-t", force_text(istream.type), "-w", "--stdin", "--literally", as_process=True, istream=PIPE
+        )
+        assert proc.stdin is not None
+        try:
+            stream_copy(istream.read, proc.stdin.write, istream.size, self.stream_chunk_size)
+        finally:
+            proc.stdin.close()
+        assert proc.stdout is not None
+        hexsha = proc.stdout.read().strip()
+        proc.wait()
+        istream.binsha = hex_to_bin(hexsha)
+        return istream
+
     # { Interface
 
     def partial_to_complete_sha_hex(self, partial_hexsha: str) -> bytes:

git/diff.py

@@ -220,8 +220,8 @@ class Diffable:
             to be read and diffed.
 
         :param allow_unsafe_options:
-            If ``True``, allow options such as ``--output`` that can write to arbitrary
-            filesystem paths.
+            If ``True``, allow options such as ``--output`` and ``-O`` that can write to
+            or read from arbitrary filesystem paths.
 
         :param kwargs:
             Additional arguments passed to :manpage:`git-diff(1)`, such as ``R=True`` to
@@ -238,7 +238,8 @@ class Diffable:
         if not allow_unsafe_options:
             Git.check_unsafe_options(
                 options=Git._option_candidates([other], kwargs),
-                unsafe_options=self.repo.unsafe_git_revision_options,
+                unsafe_options=self.repo.unsafe_git_diff_options,
+                clusterable_short_options="46abceflmnpqrstuvwzBCDMNRW",
             )
 
         args: List[Union[PathLike, Diffable]] = []

git/index/base.py

@@ -34,6 +34,8 @@ from git.util import (
     LockedFD,
     join_path_native,
     file_contents_ro,
+    _is_path_rooted,
+    _to_relative_path,
     to_native_path_linux,
     unbare_repo,
     to_bin_sha,
@@ -58,6 +60,7 @@ from typing import (
     Any,
     BinaryIO,
     Callable,
+    cast,
     Dict,
     Generator,
     IO,
@@ -131,6 +134,7 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
     """
 
     unsafe_git_checkout_index_options = ["--prefix"]
+    unsafe_git_read_tree_options = ["--index-output"]
 
     __slots__ = ("repo", "version", "entries", "_extension_data", "_file_path")
 
@@ -256,7 +260,12 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
 
     @post_clear_cache
     @default_index
-    def merge_tree(self, rhs: Treeish, base: Union[None, Treeish] = None) -> "IndexFile":
+    def merge_tree(
+        self,
+        rhs: Treeish,
+        base: Union[None, Treeish] = None,
+        allow_unsafe_options: bool = False,
+    ) -> "IndexFile":
         """Merge the given `rhs` treeish into the current index, possibly taking
         a common base treeish into account.
 
@@ -270,6 +279,9 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             Optional treeish reference pointing to the common base of `rhs` and this
             index which equals lhs.
 
+        :param allow_unsafe_options:
+            Allow options that may write to arbitrary paths.
+
         :return:
             self (containing the merge and possibly unmerged entries in case of
             conflicts)
@@ -280,6 +292,12 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             yourself, you have to commit the changed index (or make a valid tree from
             it) and retry with a three-way :meth:`index.from_tree <from_tree>` call.
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([base, rhs]),
+                unsafe_options=self.unsafe_git_read_tree_options,
+            )
+
         # -i : ignore working tree status
         # --aggressive : handle more merge cases
         # -m : do an actual merge
@@ -324,7 +342,13 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         return inst
 
     @classmethod
-    def from_tree(cls, repo: "Repo", *treeish: Treeish, **kwargs: Any) -> "IndexFile":
+    def from_tree(
+        cls,
+        repo: "Repo",
+        *treeish: Treeish,
+        allow_unsafe_options: bool = False,
+        **kwargs: Any,
+    ) -> "IndexFile":
         R"""Merge the given treeish revisions into a new index which is returned.
         The original index will remain unaltered.
 
@@ -348,6 +372,9 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         :param kwargs:
             Additional arguments passed to :manpage:`git-read-tree(1)`.
 
+        :param allow_unsafe_options:
+            Allow options that may write to arbitrary paths.
+
         :return:
             New :class:`IndexFile` instance. It will point to a temporary index location
             which does not exist anymore. If you intend to write such a merged Index,
@@ -365,6 +392,12 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         if len(treeish) == 0 or len(treeish) > 3:
             raise ValueError("Please specify between 1 and 3 treeish, got %i" % len(treeish))
 
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates(treeish, kwargs),
+                unsafe_options=cls.unsafe_git_read_tree_options,
+            )
+
         arg_list: List[Union[Treeish, str]] = []
         # Ignore that the working tree and index possibly are out of date.
         if len(treeish) > 1:
@@ -655,16 +688,12 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
 
         :raise ValueError:
         """
-        if not osp.isabs(path):
-            return path
         if self.repo.bare:
-            raise InvalidGitRepositoryError("require non-bare repository")
-        if not osp.normpath(path).startswith(str(self.repo.working_tree_dir)):
-            raise ValueError("Absolute path %r is not in git repository at %r" % (path, self.repo.working_tree_dir))
-        result = os.path.relpath(path, self.repo.working_tree_dir)
-        if os.fspath(path).endswith(os.sep) and not result.endswith(os.sep):
-            result += os.sep
-        return result
+            drive, _tail = osp.splitdrive(os.fspath(path))
+            if drive or _is_path_rooted(path):
+                raise InvalidGitRepositoryError("paths with a drive or root require a non-bare repository")
+            return path
+        return _to_relative_path(cast(PathLike, self.repo.working_tree_dir), path)
 
     def _preprocess_add_items(
         self, items: Union[PathLike, Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]]
@@ -731,14 +760,17 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
     ) -> List[BaseIndexEntry]:
         entries_added: List[BaseIndexEntry] = []
         if path_rewriter:
+            working_tree_dir = self.repo.working_tree_dir
+            if working_tree_dir is None:
+                raise InvalidGitRepositoryError("Cannot rewrite paths without a working tree")
+            working_tree_dir = str(working_tree_dir)
             for path in paths:
                 if osp.isabs(path):
                     abspath = path
-                    gitrelative_path = path[len(str(self.repo.working_tree_dir)) + 1 :]
+                    gitrelative_path = path[len(working_tree_dir) + 1 :]
                 else:
                     gitrelative_path = path
-                    if self.repo.working_tree_dir:
-                        abspath = osp.join(self.repo.working_tree_dir, gitrelative_path)
+                    abspath = osp.join(working_tree_dir, gitrelative_path)
                 # END obtain relative and absolute paths
 
                 blob = Blob(
@@ -992,6 +1024,7 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         self,
         items: Union[PathLike, Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]],
         working_tree: bool = False,
+        allow_unsafe_options: bool = False,
         **kwargs: Any,
     ) -> List[str]:
         R"""Remove the given items from the index and optionally from the working tree
@@ -1022,6 +1055,10 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             physically removing the respective file. This may fail if there are
             uncommitted changes in it.
 
+        :param allow_unsafe_options:
+            Allow unsafe options such as ``--pathspec-from-file`` to be passed to
+            :manpage:`git-rm(1)`.
+
         :param kwargs:
             Additional keyword arguments to be passed to :manpage:`git-rm(1)`, such as
             ``r`` to allow recursive removal.
@@ -1033,6 +1070,11 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             This is interesting to know in case you have provided a directory or globs.
             Paths are relative to the repository.
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([], kwargs),
+                unsafe_options=Git.unsafe_git_pathspec_from_file_options,
+            )
         args = []
         if not working_tree:
             args.append("--cached")
@@ -1414,6 +1456,7 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         working_tree: bool = False,
         paths: Union[None, Iterable[PathLike]] = None,
         head: bool = False,
+        allow_unsafe_options: bool = False,
         **kwargs: Any,
     ) -> "IndexFile":
         """Reset the index to reflect the tree at the given commit. This will not adjust
@@ -1445,6 +1488,9 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
             The paths need to exist at the commit, otherwise an exception will be
             raised.
 
+        :param allow_unsafe_options:
+            Allow options that may write to arbitrary paths.
+
         :param kwargs:
             Additional keyword arguments passed to :manpage:`git-reset(1)`.
 
@@ -1461,15 +1507,15 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         """
         # What we actually want to do is to merge the tree into our existing index,
         # which is what git-read-tree does.
-        new_inst = type(self).from_tree(self.repo, commit)
+        new_inst = type(self).from_tree(self.repo, commit, allow_unsafe_options=allow_unsafe_options)
         if not paths:
             self.entries = new_inst.entries
         else:
             nie = new_inst.entries
             for path in paths:
                 path = self._to_relative_path(path)
+                key = entry_key(path, 0)
                 try:
-                    key = entry_key(path, 0)
                     self.entries[key] = nie[key]
                 except KeyError:
                     # If key is not in theirs, it mustn't be in ours.
@@ -1521,7 +1567,8 @@ class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
         if not allow_unsafe_options:
             Git.check_unsafe_options(
                 options=Git._option_candidates([other], kwargs),
-                unsafe_options=self.repo.unsafe_git_revision_options,
+                unsafe_options=self.repo.unsafe_git_diff_options,
+                clusterable_short_options="46abceflmnpqrstuvwzBCDMNRW",
             )
 
         # Only run if we are the default repository index.

git/index/fun.py

@@ -26,7 +26,7 @@ import sys
 from gitdb.base import IStream
 from gitdb.typ import str_tree_type
 
-from git.cmd import handle_process_output, safer_popen
+from git.cmd import Git, handle_process_output, safer_popen
 from git.compat import defenc, force_bytes, force_text, safe_decode
 from git.exc import HookExecutionError, UnmergedEntriesError
 from git.objects.fun import (
@@ -79,6 +79,99 @@ def _has_file_extension(path: str) -> str:
     return osp.splitext(path)[1]
 
 
+def _is_in_windows_system_root(path: str) -> bool:
+    """Return whether ``path`` is inside the Windows installation directory."""
+    system_root = os.environ.get("SystemRoot")
+    if not system_root:
+        return False
+
+    system_root = osp.normcase(osp.realpath(system_root))
+    path = osp.normcase(osp.realpath(path))
+    try:
+        return osp.commonpath((system_root, path)) == system_root
+    except ValueError:
+        # Paths on different drives have no common path on Windows.
+        return False
+
+
+def _which_from_path(command: str) -> Union[str, None]:
+    """Resolve ``command`` from PATH, excluding the Windows installation."""
+    for directory in os.get_exec_path():
+        # Unlike POSIX, Windows does not define an empty PATH entry as the current
+        # directory. Skip it rather than letting abspath() turn it into one.
+        if not directory:
+            continue
+        directory = osp.abspath(directory)
+        candidate = osp.join(directory, command)
+        # SystemRoot contains the WSL launcher stubs. They are valid executables but
+        # not suitable for running a Windows Git hook: the hook path and environment
+        # were prepared for Git for Windows, and WSL may have no distribution at all.
+        if _is_in_windows_system_root(candidate):
+            continue
+        if osp.isfile(candidate) and os.access(candidate, os.X_OK):
+            return candidate
+    return None
+
+
+_GIT_FOR_WINDOWS_PREFIXES = ("mingw64", "mingw32", "clangarm64", "clang64", "clang32", "ucrt64")
+
+
+def _git_for_windows_root() -> Union[str, None]:
+    """Infer a standard Git for Windows root from GitPython's selected executable."""
+    git_executable = os.fspath(Git.GIT_PYTHON_GIT_EXECUTABLE or Git.git_exec_name)
+    if osp.dirname(git_executable):
+        # CreateProcess resolves a relative executable path containing a directory
+        # from the parent process cwd, even when Popen supplies a different child cwd.
+        git_executable = osp.abspath(git_executable)
+    else:
+        # GitPython deliberately retains a bare executable name so later PATH changes
+        # affect Git commands. Resolve it with the same PATH snapshot used for Bash.
+        names = (git_executable,) if _has_file_extension(git_executable) else (git_executable, f"{git_executable}.exe")
+        for name in names:
+            resolved = _which_from_path(name)
+            if resolved is not None:
+                git_executable = resolved
+                break
+        else:
+            git_executable = ""
+    if not git_executable:
+        return None
+    if osp.basename(git_executable).lower() not in ("git", "git.exe"):
+        return None
+
+    executable_dir = osp.dirname(git_executable)
+    directory_name = osp.basename(executable_dir).lower()
+    if directory_name == "cmd":
+        # The normal system-wide PATH entry is <git-root>/cmd.
+        return osp.dirname(executable_dir)
+    if directory_name == "bin":
+        prefix = osp.dirname(executable_dir)
+        if osp.basename(prefix).lower() in _GIT_FOR_WINDOWS_PREFIXES:
+            # Git Bash commonly exposes <git-root>/<platform>/bin/git.exe.
+            return osp.dirname(prefix)
+        if osp.basename(prefix).lower() != "usr":
+            # An explicitly configured Git may be the root-level bin/git.exe. Do
+            # not make the same inference from usr/bin: unlike the recognized
+            # platform prefixes, "usr" has no reliably bounded parent layout.
+            return prefix
+    return None
+
+
+def _git_for_windows_bash() -> Union[str, None]:
+    """Return Bash from the Git for Windows installation selected by GitPython."""
+    git_root = _git_for_windows_root()
+    if git_root is None:
+        return None
+
+    # Match gix-path's precedence: prefer the lightweight bin shim, then the
+    # underlying usr/bin executable. Both belong to the same installation as Git.
+    for relative_path in ("bin/bash.exe", "usr/bin/bash.exe"):
+        candidate = osp.join(git_root, *relative_path.split("/"))
+        if osp.isfile(candidate) and os.access(candidate, os.X_OK):
+            return candidate
+    return None
+
+
 def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
     """Run the commit hook of the given name. Silently ignore hooks that do not exist.
 
@@ -112,7 +205,12 @@ def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
                 # 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()]
+            # Prefer Bash associated with GitPython's selected Git installation. If
+            # that layout is not recognized, use an explicitly configured non-system
+            # PATH entry. Preserve the bare fallback for installations that previously
+            # relied on WSL or another CreateProcess-resolved Bash.
+            bash_executable = _git_for_windows_bash() or _which_from_path("bash.exe") or "bash.exe"
+            cmd = [bash_executable, Path(bash_hp).as_posix()]
 
         process = safer_popen(
             cmd + list(args),

git/objects/commit.py

@@ -575,11 +575,14 @@ class Commit(base.Object, TraversableIterableObj, Diffable, Serializable):
 
         if hasattr(proc_or_stream, "wait"):
             proc_or_stream = cast(Popen, proc_or_stream)
-            if proc_or_stream.stdout is not None:
-                stream = proc_or_stream.stdout
+            stream = proc_or_stream.stdout
+            if stream is None:
+                raise ValueError("Process has no stdout stream")
         elif hasattr(proc_or_stream, "readline"):
             proc_or_stream = cast(IO, proc_or_stream)  # type: ignore[redundant-cast]
             stream = proc_or_stream
+        else:
+            raise TypeError("Expected a process or stream")
 
         readline = stream.readline
         while True:

git/objects/submodule/base.py

@@ -6,8 +6,10 @@ __all__ = ["Submodule", "UpdateProgress"]
 import gc
 from io import BytesIO
 import logging
+import ntpath
 import os
 import os.path as osp
+import shlex
 import stat
 import sys
 import uuid
@@ -28,6 +30,7 @@ from git.objects.util import TraversableIterableObj
 from git.util import (
     IterableList,
     RemoteProgress,
+    _to_relative_path,
     join_path_native,
     rmtree,
     to_native_path_linux,
@@ -268,7 +271,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             raise ValueError("Cannot write blobs of 'historical' submodule configurations")
         # END handle writes of historical submodules
 
-        return SubmoduleConfigParser(fp_module, read_only=read_only)
+        return SubmoduleConfigParser(fp_module, read_only=read_only, merge_includes=False)
 
     def _clear_cache(self) -> None:
         """Clear the possibly changed values."""
@@ -302,8 +305,20 @@ class Submodule(IndexObject, TraversableIterableObj):
         parser.set_submodule(self)
         return SectionConstraint(parser, sm_section(self.name))
 
+    @classmethod
+    def _validated_name(cls, name: str) -> str:
+        if (
+            not name
+            or name.startswith(("/", "\\"))
+            or ntpath.splitdrive(name)[0]
+            or ".." in name.replace("\\", "/").split("/")
+        ):
+            raise ValueError("Invalid submodule name %r" % name)
+        return name
+
     @classmethod
     def _module_abspath(cls, parent_repo: "Repo", path: PathLike, name: str) -> PathLike:
+        name = cls._validated_name(name)
         if cls._need_gitfile_submodules(parent_repo.git):
             return osp.join(parent_repo.git_dir, "modules", name)
         if parent_repo.working_tree_dir:
@@ -349,6 +364,15 @@ class Submodule(IndexObject, TraversableIterableObj):
         module_abspath = cls._module_abspath(repo, path, name)
         module_checkout_path = module_abspath
         if cls._need_gitfile_submodules(repo.git):
+            if not allow_unsafe_options:
+                Git.check_unsafe_options(Git._option_candidates([], kwargs), repo.unsafe_git_clone_options)
+                multi_options = kwargs.get("multi_options")
+                if multi_options:
+                    Git.check_unsafe_options(
+                        shlex.split(" ".join(cast("Sequence[str]", multi_options))),
+                        repo.unsafe_git_clone_options,
+                    )
+            allow_unsafe_options = True
             kwargs["separate_git_dir"] = module_abspath
             module_abspath_dir = osp.dirname(module_abspath)
             if not osp.isdir(module_abspath_dir):
@@ -379,23 +403,14 @@ class Submodule(IndexObject, TraversableIterableObj):
         :raise ValueError:
             If path is not contained in the parent repository's working tree.
         """
-        path = to_native_path_linux(path)
+        if parent_repo.working_tree_dir:
+            path = _to_relative_path(parent_repo.working_tree_dir, path)
+        else:
+            path = to_native_path_linux(path)
         if path.endswith("/"):
             path = path[:-1]
-        # END handle trailing slash
-
-        if osp.isabs(path) and parent_repo.working_tree_dir:
-            working_tree_linux = to_native_path_linux(parent_repo.working_tree_dir)
-            if not path.startswith(working_tree_linux):
-                raise ValueError(
-                    "Submodule checkout path '%s' needs to be within the parents repository at '%s'"
-                    % (working_tree_linux, path)
-                )
-            path = path[len(working_tree_linux.rstrip("/")) + 1 :]
-            if not path:
-                raise ValueError("Absolute submodule path '%s' didn't yield a valid relative path" % path)
-            # END verify converted relative path makes sense
-        # END convert to a relative path
+        if not path or path == ".":
+            raise ValueError("Submodule checkout path must not be the repository root")
 
         return path
 
@@ -523,6 +538,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             raise InvalidGitRepositoryError("Cannot add submodules to bare repositories")
         # END handle bare repos
 
+        cls._validated_name(name)
         path = cls._to_relative_path(repo, path)
 
         # Ensure we never put backslashes into the URL, as might happen on Windows.
@@ -734,9 +750,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             prefix = "DRY-RUN: "
         # END handle prefix
 
-        # To keep things plausible in dry-run mode.
-        if dry_run:
-            mrepo = None
+        mrepo = None
         # END init mrepo
 
         def fetch_remotes(module_repo: "Repo") -> None:
@@ -771,6 +785,8 @@ class Submodule(IndexObject, TraversableIterableObj):
             # END fetch new data
 
         try:
+            self._validated_name(self.name)
+
             # ENSURE REPO IS PRESENT AND UP-TO-DATE
             #######################################
             try:
@@ -871,6 +887,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             #############################
             binsha = self.binsha
             hexsha = self.hexsha
+            is_detached = False
             if mrepo is not None:
                 # mrepo is only set if we are not in dry-run mode or if the module
                 # existed.
@@ -1020,6 +1037,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             raise ValueError("You must specify to move at least the module or the configuration of the submodule")
         # END handle input
 
+        self._validated_name(self.name)
         module_checkout_path = self._to_relative_path(self.repo, module_path)
 
         # VERIFY DESTINATION
@@ -1160,6 +1178,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             raise ValueError("Need to specify to delete at least the module, or the configuration")
         # END handle parameters
 
+        self._validated_name(self.name)
         # Recursively remove children of this submodule.
         nc = 0
         for csm in self.children():
@@ -1213,6 +1232,7 @@ class Submodule(IndexObject, TraversableIterableObj):
                 for remote in mod.remotes:
                     num_branches_with_new_commits = 0
                     rrefs = remote.refs
+                    rref = None
                     for rref in rrefs:
                         num_branches_with_new_commits += len(mod.git.cherry(rref)) != 0
                     # END for each remote ref
@@ -1416,6 +1436,9 @@ class Submodule(IndexObject, TraversableIterableObj):
         if self.name == new_name:
             return self
 
+        self._validated_name(self.name)
+        self._validated_name(new_name)
+
         # .git/config
         with self.repo.config_writer() as pw:
             # As we ourselves didn't write anything about submodules into the parent
@@ -1463,6 +1486,7 @@ class Submodule(IndexObject, TraversableIterableObj):
             If a repository was not available.
             This could also mean that it was not yet initialized.
         """
+        self._validated_name(self.name)
         module_checkout_abspath = self.abspath
         try:
             repo = git.Repo(module_checkout_abspath)

git/objects/submodule/root.py

@@ -7,6 +7,7 @@ import logging
 
 import git
 from git.exc import InvalidGitRepositoryError
+from git.util import IterableList
 
 from .base import Submodule, UpdateProgress
 from .util import find_first_remote_branch
@@ -19,7 +20,6 @@ from git.types import Commit_ish
 
 if TYPE_CHECKING:
     from git.repo import Repo
-    from git.util import IterableList
 
 # ----------------------------------------------------------------------------
 
@@ -162,6 +162,7 @@ class RootModule(Submodule):
             prefix = "DRY-RUN: "
 
         repo = self.repo
+        sms: "IterableList[Submodule]" = IterableList("name")
 
         try:
             # SETUP BASE COMMIT
@@ -182,7 +183,7 @@ class RootModule(Submodule):
             # END handle previous commit
 
             psms: "IterableList[Submodule]" = self.list_items(repo, parent_commit=previous_commit)
-            sms: "IterableList[Submodule]" = self.list_items(repo)
+            sms = self.list_items(repo)
             spsms = set(psms)
             ssms = set(sms)
 

git/refs/head.py

@@ -19,6 +19,7 @@ from .symbolic import SymbolicReference
 
 from typing import Any, Sequence, TYPE_CHECKING, Union
 
+from git.cmd import Git
 from git.types import Commit_ish, PathLike
 
 if TYPE_CHECKING:
@@ -62,6 +63,7 @@ class HEAD(SymbolicReference):
         index: bool = True,
         working_tree: bool = False,
         paths: Union[PathLike, Sequence[PathLike], None] = None,
+        allow_unsafe_options: bool = False,
         **kwargs: Any,
     ) -> "HEAD":
         """Reset our HEAD to the given commit optionally synchronizing the index and
@@ -84,12 +86,21 @@ class HEAD(SymbolicReference):
             Single path or list of paths relative to the git root directory
             that are to be reset. This allows to partially reset individual files.
 
+        :param allow_unsafe_options:
+            Allow unsafe options such as ``--pathspec-from-file`` to be passed to
+            :manpage:`git-reset(1)`.
+
         :param kwargs:
             Additional arguments passed to :manpage:`git-reset(1)`.
 
         :return:
             self
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([commit], kwargs),
+                unsafe_options=Git.unsafe_git_pathspec_from_file_options,
+            )
         mode: Union[str, None]
         mode = "--soft"
         if index:
@@ -234,7 +245,12 @@ class Head(Reference):
         self.path = "%s/%s" % (self._common_path_default, new_path)
         return self
 
-    def checkout(self, force: bool = False, **kwargs: Any) -> Union["HEAD", "Head"]:
+    def checkout(
+        self,
+        force: bool = False,
+        allow_unsafe_options: bool = False,
+        **kwargs: Any,
+    ) -> Union["HEAD", "Head"]:
         """Check out this head by setting the HEAD to this reference, by updating the
         index to reflect the tree we point to and by updating the working tree to
         reflect the latest index.
@@ -246,6 +262,10 @@ class Head(Reference):
             If ``False``, :exc:`~git.exc.GitCommandError` will be raised in that
             situation.
 
+        :param allow_unsafe_options:
+            Allow unsafe options such as ``--pathspec-from-file`` to be passed to
+            :manpage:`git-checkout(1)`.
+
         :param kwargs:
             Additional keyword arguments to be passed to git checkout, e.g.
             ``b="new_branch"`` to create a new branch at the given spot.
@@ -261,6 +281,11 @@ class Head(Reference):
             the HEAD detached which is allowed and possible, but remains a special state
             that some tools might not be able to handle.
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([], kwargs),
+                unsafe_options=Git.unsafe_git_pathspec_from_file_options,
+            )
         kwargs["f"] = force
         if kwargs["f"] is False:
             kwargs.pop("f")

git/refs/log.py

@@ -269,6 +269,7 @@ class RefLog(List[RefLogEntry], Serializable):
                 return RefLogEntry.from_line(fp.readlines()[index].strip())
             # Read until index is reached.
 
+            line = b""
             for i in range(index + 1):
                 line = fp.readline()
                 if not line:

git/refs/symbolic.py

@@ -119,7 +119,7 @@ class SymbolicReference:
             common_path = os.path.commonpath([base_path, abs_path])
         except ValueError as e:
             raise ValueError("Reference path %r escapes the repository" % path) from e
-        if os.path.normcase(common_path) != os.path.normcase(base_path):
+        if common_path != base_path:
             raise ValueError("Reference path %r escapes the repository" % path)
         return abs_path
 

git/refs/tag.py

@@ -134,15 +134,17 @@ class TagReference(Reference):
         :return:
             A new :class:`TagReference`.
         """
+        legacy_ref = kwargs.pop("ref", None)
+        if legacy_ref:
+            reference = legacy_ref
+
         if not allow_unsafe_options:
             Git.check_unsafe_options(
-                options=Git._option_candidates([], kwargs),
+                options=Git._option_candidates([path, reference], kwargs),
                 unsafe_options=cls.unsafe_git_tag_options,
+                clusterable_short_options="46adefilnqsv",
             )
 
-        if "ref" in kwargs and kwargs["ref"]:
-            reference = kwargs["ref"]
-
         if "message" in kwargs and kwargs["message"]:
             kwargs["m"] = kwargs["message"]
             del kwargs["message"]

git/repo/base.py

@@ -142,6 +142,14 @@ class Repo:
     re_author_committer_start = re.compile(r"^(author|committer)")
     re_tab_full_line = re.compile(r"^\t(.*)$")
 
+    unsafe_git_init_options = [
+        # Can install hooks that execute during later Git commands:
+        "--template",
+        # Redirects the repository metadata to a caller-controlled path:
+        "--separate-git-dir",
+    ]
+    """Options to :manpage:`git-init(1)` that permit unsafe code execution or I/O."""
+
     unsafe_git_clone_options = [
         # Executes arbitrary commands:
         "--upload-pack",
@@ -151,6 +159,8 @@ class Repo:
         "-c",
         # Can install hooks that execute during clone:
         "--template",
+        # Redirects the repository metadata to a caller-controlled path:
+        "--separate-git-dir",
         # Fetches from an additional caller-controlled URI:
         "--bundle-uri",
     ]
@@ -191,6 +201,19 @@ class Repo:
         "-o",
     ]
 
+    unsafe_git_blame_options = unsafe_git_revision_options + [
+        # These options read from arbitrary files and expose their contents through blame output.
+        "--contents",
+        "-S",
+        "--ignore-revs-file",
+    ]
+
+    unsafe_git_diff_options = unsafe_git_revision_options + [
+        # Reads caller-controlled order patterns from an arbitrary file.
+        "-O",
+        "--orderfile",
+    ]
+
     # Invariants
     config_level: ConfigLevels_Tup = ("system", "user", "global", "repository")
     """Represents the configuration level of a configuration file."""
@@ -933,13 +956,17 @@ class Repo:
             return False
 
     def _get_daemon_export(self) -> bool:
-        if self.git_dir:
-            filename = osp.join(self.git_dir, self.DAEMON_EXPORT_FILE)
+        git_dir = getattr(self, "git_dir", None)
+        if git_dir is None:
+            return False
+        filename = osp.join(git_dir, self.DAEMON_EXPORT_FILE)
         return osp.exists(filename)
 
     def _set_daemon_export(self, value: object) -> None:
-        if self.git_dir:
-            filename = osp.join(self.git_dir, self.DAEMON_EXPORT_FILE)
+        git_dir = getattr(self, "git_dir", None)
+        if git_dir is None:
+            return
+        filename = osp.join(git_dir, self.DAEMON_EXPORT_FILE)
         fileexists = osp.exists(filename)
         if value and not fileexists:
             touch(filename)
@@ -961,8 +988,7 @@ class Repo:
         :return:
             List of strings being pathnames of alternates
         """
-        if self.git_dir:
-            alternates_path = osp.join(self.git_dir, "objects", "info", "alternates")
+        alternates_path = osp.join(self.common_dir, "objects", "info", "alternates")
 
         if osp.exists(alternates_path):
             with open(alternates_path, "rb") as f:
@@ -1138,7 +1164,7 @@ class Repo:
             :manpage:`git-rev-parse(1)` is a valid option.
 
         :param allow_unsafe_options:
-            Allow unsafe options in revision argument, like ``--output``.
+            Allow unsafe options in revision argument, like ``--output`` or ``--contents``.
 
         :return:
             Lazy iterator of :class:`BlameEntry` tuples, where the commit indicates the
@@ -1150,7 +1176,9 @@ class Repo:
         """
         if not allow_unsafe_options:
             Git.check_unsafe_options(
-                options=Git._option_candidates([rev], kwargs), unsafe_options=self.unsafe_git_revision_options
+                options=Git._option_candidates([rev], kwargs),
+                unsafe_options=self.unsafe_git_blame_options,
+                clusterable_short_options="46bceflnpqstvw",
             )
 
         data: bytes = self.git.blame(rev, "--", file, p=True, incremental=True, stdout_as_string=False, **kwargs)
@@ -1242,7 +1270,7 @@ class Repo:
             :manpage:`git-rev-parse(1)` is a valid option.
 
         :param allow_unsafe_options:
-            Allow unsafe options in revision argument, like ``--output``.
+            Allow unsafe options in revision argument, like ``--output`` or ``--contents``.
 
         :return:
             list: [git.Commit, list: [<line>]]
@@ -1258,7 +1286,8 @@ class Repo:
         if not allow_unsafe_options:
             Git.check_unsafe_options(
                 options=Git._option_candidates([rev, rev_opts_list], kwargs),
-                unsafe_options=self.unsafe_git_revision_options,
+                unsafe_options=self.unsafe_git_blame_options,
+                clusterable_short_options="46bceflnpqstvw",
             )
         data: bytes = self.git.blame(rev, *rev_opts_list, "--", file, p=True, stdout_as_string=False, **kwargs)
         commits: Dict[str, Commit] = {}
@@ -1280,6 +1309,7 @@ class Repo:
 
         keepends = True
         for line_bytes in data.splitlines(keepends):
+            line_str = ""
             try:
                 line_str = line_bytes.rstrip().decode(defenc)
             except UnicodeDecodeError:
@@ -1394,6 +1424,7 @@ class Repo:
         mkdir: bool = True,
         odbt: Type[GitCmdObjectDB] = GitCmdObjectDB,
         expand_vars: bool = True,
+        allow_unsafe_options: bool = False,
         **kwargs: Any,
     ) -> "Repo":
         """Initialize a git repository at the given path if specified.
@@ -1418,6 +1449,10 @@ class Repo:
             information disclosure, allowing attackers to access the contents of
             environment variables.
 
+        :param allow_unsafe_options:
+            Allow unsafe options to be used, such as ``--template`` and
+            ``--separate-git-dir``.
+
         :param kwargs:
             Keyword arguments serving as additional options to the
             :manpage:`git-init(1)` command.
@@ -1425,6 +1460,11 @@ class Repo:
         :return:
             :class:`Repo` (the newly created repo)
         """
+        if not allow_unsafe_options:
+            Git.check_unsafe_options(
+                options=Git._option_candidates([], kwargs),
+                unsafe_options=cls.unsafe_git_init_options,
+            )
         if path:
             path = expand_path(path, expand_vars)
         if mkdir and path and not osp.exists(path):
@@ -1738,8 +1778,9 @@ class Repo:
 
             ``None`` if we are not currently rebasing.
         """
-        if self.git_dir:
-            rebase_head_file = osp.join(self.git_dir, "REBASE_HEAD")
+        if not self.git_dir:
+            return None
+        rebase_head_file = osp.join(self.git_dir, "REBASE_HEAD")
         if not osp.isfile(rebase_head_file):
             return None
         with open(rebase_head_file, "rt") as f:

git/util.py

@@ -315,6 +315,68 @@ def join_path_native(a: PathLike, *p: PathLike) -> PathLike:
     return to_native_path(join_path(a, *p))
 
 
+def _is_path_rooted(path: PathLike) -> bool:
+    r"""Whether ``path`` has a root, including one encoded in a UNC drive.
+
+    On Windows, ``\directory`` is rooted on the current drive without being
+    absolute, while ``C:\directory`` has both a drive and a root. In contrast,
+    ``directory`` and the drive-relative ``C:directory`` have no root.
+    UNC paths are rooted: ``\\server\share`` stores the share in the drive
+    returned by :func:`os.path.splitdrive`, while ``\\server\share\directory``
+    additionally has a rooted tail.
+    On POSIX, which has no drive concept, this simply distinguishes absolute
+    paths such as ``/directory`` from relative paths such as ``directory``.
+    """
+    drive, tail = osp.splitdrive(os.fspath(path))
+    separators = (os.sep,) if os.altsep is None else (os.sep, os.altsep)
+    return tail.startswith(separators) or drive.startswith(separators)
+
+
+def _to_relative_path(root: PathLike, path: PathLike) -> str:
+    r"""Return a normalized Git-style path confined to ``root``.
+
+    A Windows path such as ``\directory`` is rooted but not absolute. Resolve it
+    against the drive of ``root`` rather than treating it as relative to ``root``.
+    Drive-relative paths such as ``C:directory`` are rejected because their meaning
+    depends on process-global per-drive state.
+
+    For example, with ``root`` set to ``C:\repo`` on Windows:
+
+    * ``directory\file`` -> ``directory/file``
+    * ``directory\`` -> ``directory/``
+    * ``C:\repo\directory\file`` -> ``directory/file``
+    * ``\repo\directory\file`` -> ``directory/file``
+    * ``C:directory\file`` -> :exc:`ValueError`
+    * ``C:\other\file`` -> :exc:`ValueError`
+
+    On POSIX, ``/repo/directory/file`` under ``/repo`` similarly becomes
+    ``directory/file``. A trailing separator is preserved as a Git-style ``/``.
+    """
+    path_str = os.fspath(path)
+    if not path_str:
+        return path_str
+
+    drive, _tail = osp.splitdrive(path_str)
+    rooted = _is_path_rooted(path_str)
+    if drive and not rooted:
+        raise ValueError("Drive-relative path %r is not supported" % path_str)
+
+    root_abs = osp.abspath(os.fspath(root))
+    path_abs = osp.abspath(osp.join(root_abs, path_str))
+    try:
+        common_path = osp.commonpath([root_abs, path_abs])
+    except ValueError as e:
+        raise ValueError("Path %r is not in repository at %r" % (path_str, root_abs)) from e
+    if common_path != root_abs:
+        raise ValueError("Path %r is not in repository at %r" % (path_str, root_abs))
+
+    relative_path = to_native_path_linux(osp.relpath(path_abs, root_abs))
+    separators = (os.sep,) if os.altsep is None else (os.sep, os.altsep)
+    if path_str.endswith(separators) and relative_path != "." and not relative_path.endswith("/"):
+        relative_path += "/"
+    return relative_path
+
+
 def assure_directory_exists(path: PathLike, is_file: bool = False) -> bool:
     """Make sure that the directory pointed to by path exists.
 

{gitpython-3.1.57.dist-info → gitpython-3.1.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GitPython
-Version: 3.1.57
+Version: 3.1.59
 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.57.dist-info → gitpython-3.1.59.dist-info}/RECORD

@@ -1,44 +1,44 @@
-git/__init__.py,sha256=FxGLSM_UucTDAQ6NhNZ1vs-H_GoxqUQWjb5fum6nmpg,8899
-git/cmd.py,sha256=G-SH2Q_mXjA8P54qY7nr5rRF00-cGtOcb2QKsoaZ9pQ,76423
+git/__init__.py,sha256=RQ8_0lssQ6Httk5nXlJwIji5mDSzx_28lTUwZkbXfiA,8899
+git/cmd.py,sha256=y-7TVp8PVWVkXcQrKqrSO2vaD6Bdiue73ZzFlWzLryU,77137
 git/compat.py,sha256=y1E6y6O2q5r8clSlr8ZNmuIWG9nmHuehQEsVsmBffs8,4526
-git/config.py,sha256=aLDSuDiiB67W-OLktJpYVjSLwgIqWJtPYbRllNhQ7Gw,38406
-git/db.py,sha256=vIW9uWSbqu99zbuU2ZDmOhVOv1UPTmxrnqiCtRHCfjE,2368
-git/diff.py,sha256=k7iYB8gBzqrGDNn_XfZPXpS6LFxq02-JnyLo4bdwvVA,28271
+git/config.py,sha256=0fc1F5G_S6CksbO2-pTaB5bspNyyPidYhrEhwD9mvCs,39261
+git/db.py,sha256=X19omm9sk3eEy5WAzMoZ2tG9UmdPZFQYf-8yqpvsYF0,3202
+git/diff.py,sha256=QJylerwXENN87gQ30iJ3KbOIoCHFH27QPeKPgUsw5C8,28363
 git/exc.py,sha256=Gc7g1pHpn8OmTse30NHmJVsBJ2CYH8LxaR8y8UA3lIM,7119
 git/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 git/remote.py,sha256=d68K7XmkYXZUlIoLBDRpRom_df6mbkhWMrcPAP5s11c,46900
 git/types.py,sha256=d3oDduUGjfoqffcUL_GOD-3qroF8m3r9ai6Xi9_FraM,10279
-git/util.py,sha256=ECVUNHcGY7_UTeak3ziyEAuDO20YGEOBxuEC8goD15g,45325
+git/util.py,sha256=TJWZ8zeqpsp2NoIr5u_tcUB7yM3OB_RHoYLy4b95TUQ,48135
 git/index/__init__.py,sha256=i-Nqb8Lufp9aFbmxpQBORmmQnjEVVM1Pn58fsQkyGgQ,406
-git/index/base.py,sha256=LSrCisdF_RnBtDMSvX7tKmWUB8l7AhgwWv2bFw0H0f0,63237
-git/index/fun.py,sha256=Cfrpq6GmhLXGVDDjYiXTN4f4bb35kvw6-cOGOBuJeGc,17862
+git/index/base.py,sha256=cOeIjjS2LYZwqKdSGvrcgVC37TNZcTNtQzHWbGPyRwk,64775
+git/index/fun.py,sha256=AIW3T6Gr6h5E22z_2wKHevzh5K0HhjjEO9kXAK3nHOM,22419
 git/index/typ.py,sha256=ZjRWp5J79OwFQor1XXN4C6JmHTDclD9H-tKZtAeqyTI,7019
 git/index/util.py,sha256=f0BfE2JPkdypsB2Q_HJ8KU7MC45RRHywL_GWwxa_5hw,3676
 git/objects/__init__.py,sha256=O6ZL_olX7e5-8iIbKviRPkVSJxN37WA-EC0q9d48U5Y,637
 git/objects/base.py,sha256=5-p9uSGWvPxX9hidvkGH9tQOJoH2eaRggUbMr9VJiL0,10285
 git/objects/blob.py,sha256=G9PZMNc5CFRQFNnlquBRAM5-jZg8581lRcxkvARobSk,1231
-git/objects/commit.py,sha256=aJYxpbkcmAskmnc6qv6Podswhshu1-GlY306UqNWzvs,33175
+git/objects/commit.py,sha256=YbF2cjl6aziTq2HRgZkxr5TgfU8keIVEEkoBB0DPLKc,33291
 git/objects/fun.py,sha256=bcofjsxrF1NniYWa1r8oAy8uYT_q2rUpLFnYj1aULGU,8949
 git/objects/tag.py,sha256=jAGESnpmTEv-dLakPzheT5ILZFFArcItnXYqfxfDrgc,4441
 git/objects/tree.py,sha256=MmExcS59Iamb2cBqUvoHPdzgixabyvv5voHabossrl8,13898
 git/objects/util.py,sha256=Nlza4zLgdPmr_Yasyvvs6c1rKtW_wMxI6wDmQpQ3ufw,23846
 git/objects/submodule/__init__.py,sha256=6xySp767LVz3UylWgUalntS_nGXRuVzXxDuFAv_Wc2c,303
-git/objects/submodule/base.py,sha256=1w39BpgNnpEmEacCLdCGLH-aeIaAMKU0oWUtgVcyVW0,66347
-git/objects/submodule/root.py,sha256=5eTtYNHasqdPq6q0oDCPr7IaO6uAHL3b4DxMoiO2LhE,20246
+git/objects/submodule/base.py,sha256=JBoT8FiVCk9ODMMQo2DDR89ThZDmj317Qr2L4JZtB2g,67073
+git/objects/submodule/root.py,sha256=767GIhBwCwn2xvXeMHm2uEO3kZlRyaIaFXnSqcfdZxU,20277
 git/objects/submodule/util.py,sha256=sQqAYaiSJdFkZa9NlAuK_wTsMNiS-kkQnQjvIoJtc_o,3509
 git/refs/__init__.py,sha256=DWlJNnsx-4jM_E-VycbP-FZUdn6iWhjnH_uZ_pZXBro,509
-git/refs/head.py,sha256=59MUMVu9phmE_ImkmNw0sDDSCc75s7TxkQj_cKzRhbo,10397
-git/refs/log.py,sha256=X88JTqjwX1ShvHr-NHNAZj0qLiHbVoF-0v3VymZDwoM,12612
+git/refs/head.py,sha256=Q3VZt5MmEUwltBpBHJmcAZM9gYzCekAKgMpJlPrbttk,11309
+git/refs/log.py,sha256=G2e9GR1owwdmDuKmwGGozt5b1y8qIccUoXiuk2q1E1o,12635
 git/refs/reference.py,sha256=uzrvNTZ5fg7A0Aq4VC3KLSMbksgYUf4KvmHau0tFYIM,5646
 git/refs/remote.py,sha256=WTlkJtpu895jJxbknDNOwL31tivQY_AHQrvroUoFBX4,2902
-git/refs/symbolic.py,sha256=7ScmZHwlqPDKX9bxVC5queSZXUgqEY7_J_Si6gDBSLw,36139
-git/refs/tag.py,sha256=27fZPVVkAPvaRoUt6_IX-tXKLleCYwoKA0GAk453w9E,5418
+git/refs/symbolic.py,sha256=MPi5UN0ujdE2GMOrzfW2zt-6HlVreuY5W4P7tnBg4V8,36103
+git/refs/tag.py,sha256=Gm1jn9kClc6f6jGQXRrpLyelrM3-KDcqHRRkD0mL4SE,5510
 git/repo/__init__.py,sha256=CILSVH36fX_WxVFSjD9o1WF5LgsNedPiJvSngKZqfVU,210
-git/repo/base.py,sha256=sCYS-QC5Dan98FYQgqnOFID0J6HzS8rTJf7Ea8i5DWg,64565
+git/repo/base.py,sha256=OrH--uFUNqz5XgK-vQou3LxoOdr1wGRtej3kh0zJN8c,66119
 git/repo/fun.py,sha256=PDFNkuTSGGoQc0EEEXjxHw2_KaKYvVjBZ9rrkwH5Q6Y,23462
-gitpython-3.1.57.dist-info/licenses/AUTHORS,sha256=Iucx_CH3w7_4084yjM6C5BvKfLA8cVfYHWW2pVmpxSk,2410
-gitpython-3.1.57.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
-gitpython-3.1.57.dist-info/METADATA,sha256=3rZoSxhgf4E9RPU4L4agiWkTRO3f54fjSQcZcKZmzXo,13558
-gitpython-3.1.57.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-gitpython-3.1.57.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
-gitpython-3.1.57.dist-info/RECORD,,
+gitpython-3.1.59.dist-info/licenses/AUTHORS,sha256=Iucx_CH3w7_4084yjM6C5BvKfLA8cVfYHWW2pVmpxSk,2410
+gitpython-3.1.59.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
+gitpython-3.1.59.dist-info/METADATA,sha256=x3hW_O_MEvdlUzGbI_Nb4eaXbr00unmxiHwLTIu87ZA,13558
+gitpython-3.1.59.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+gitpython-3.1.59.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
+gitpython-3.1.59.dist-info/RECORD,,

{gitpython-3.1.57.dist-info → gitpython-3.1.59.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any