GitPython 3.1.52__py3-none-any.whl → 3.1.53__py3-none-any.whl

git/__init__.py

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

git/cmd.py

@@ -1358,7 +1358,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:

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

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),

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.

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.dist-info → gitpython-3.1.53.dist-info}/METADATA

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

@@ -1,17 +1,17 @@
-git/__init__.py,sha256=Bf3B3KGHpiniZ1c-Cx-Asw21tS4qW2C-YQP3-sO4W8U,8899
-git/cmd.py,sha256=-GN7kZ2ryCgBZq654lYrWdYVjgI6N2LN_zb65zSA-XE,75228
+git/__init__.py,sha256=JfSdrpLoaZem4xHAf_iZARfzAGTDgpy7K60ptkzAFC8,8899
+git/cmd.py,sha256=nIJlOcTeRoOPVtg5IO_EmhVRCejB8reAfukilRXR6Yo,75230
 git/compat.py,sha256=y1E6y6O2q5r8clSlr8ZNmuIWG9nmHuehQEsVsmBffs8,4526
-git/config.py,sha256=VWk1i09HN_nrghQc2iTm4yLpAkPwppHnEBU74XqZl1o,37533
+git/config.py,sha256=aLDSuDiiB67W-OLktJpYVjSLwgIqWJtPYbRllNhQ7Gw,38406
 git/db.py,sha256=vIW9uWSbqu99zbuU2ZDmOhVOv1UPTmxrnqiCtRHCfjE,2368
 git/diff.py,sha256=qkL8g0m7UoIB5TcY7X23DgEMAmBJ0ZpEVFdHR1pDKJU,27767
 git/exc.py,sha256=Gc7g1pHpn8OmTse30NHmJVsBJ2CYH8LxaR8y8UA3lIM,7119
 git/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 git/remote.py,sha256=rCbrMMjILsX08TGYai8wdxzHCHc4ba6vPt6tP9efOog,46881
 git/types.py,sha256=d3oDduUGjfoqffcUL_GOD-3qroF8m3r9ai6Xi9_FraM,10279
-git/util.py,sha256=jJlcOeHKBIL8Q5Fc6dq1mHwU9rYmxEDvdidk7cbBU24,44322
+git/util.py,sha256=27MIkq6AhpjyAHF9r7UEA1pGYRAkxRMiZNo5IJGdJhU,44712
 git/index/__init__.py,sha256=i-Nqb8Lufp9aFbmxpQBORmmQnjEVVM1Pn58fsQkyGgQ,406
 git/index/base.py,sha256=6U-gbvhVa2YmW1v-JeT1TOW6wJHi1li5g9wume-iCmw,62260
-git/index/fun.py,sha256=v0WnKQxaAffMZxXXC7pQOiMvRRJfODhUNKDMruxKrN4,17110
+git/index/fun.py,sha256=Cfrpq6GmhLXGVDDjYiXTN4f4bb35kvw6-cOGOBuJeGc,17862
 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
@@ -23,7 +23,7 @@ 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=EWkbiJsFSpCt5zacoVrq-9JQFJWn4BWA7kdsXtjL5PU,64412
+git/objects/submodule/base.py,sha256=NR8eP-dEr-U_EG8LahRRgJ2n2z1wZXY9V0w57pBbiIo,66328
 git/objects/submodule/root.py,sha256=5eTtYNHasqdPq6q0oDCPr7IaO6uAHL3b4DxMoiO2LhE,20246
 git/objects/submodule/util.py,sha256=sQqAYaiSJdFkZa9NlAuK_wTsMNiS-kkQnQjvIoJtc_o,3509
 git/refs/__init__.py,sha256=DWlJNnsx-4jM_E-VycbP-FZUdn6iWhjnH_uZ_pZXBro,509
@@ -36,9 +36,9 @@ git/refs/tag.py,sha256=AKrFrMhkNzX8e9x5WmDRtHovbN9zYQghuKoneVW-TJg,5002
 git/repo/__init__.py,sha256=CILSVH36fX_WxVFSjD9o1WF5LgsNedPiJvSngKZqfVU,210
 git/repo/base.py,sha256=1HFBIKTLLjmVQXhJlesWIXP90xoNM1RTVQF2eIwLkgs,63781
 git/repo/fun.py,sha256=PDFNkuTSGGoQc0EEEXjxHw2_KaKYvVjBZ9rrkwH5Q6Y,23462
-gitpython-3.1.52.dist-info/licenses/AUTHORS,sha256=Iucx_CH3w7_4084yjM6C5BvKfLA8cVfYHWW2pVmpxSk,2410
-gitpython-3.1.52.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
-gitpython-3.1.52.dist-info/METADATA,sha256=qWOjT4R0uoWQ7C7j9752MZ9TRxrFDV8BBMYDrQkjWbM,14187
-gitpython-3.1.52.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-gitpython-3.1.52.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
-gitpython-3.1.52.dist-info/RECORD,,
+gitpython-3.1.53.dist-info/licenses/AUTHORS,sha256=Iucx_CH3w7_4084yjM6C5BvKfLA8cVfYHWW2pVmpxSk,2410
+gitpython-3.1.53.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
+gitpython-3.1.53.dist-info/METADATA,sha256=IdYoD67td8TnivPczpNQpgODxRb9jAnqG-bA_RcL40g,14187
+gitpython-3.1.53.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+gitpython-3.1.53.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
+gitpython-3.1.53.dist-info/RECORD,,