gitbolt 0.0.0.dev17__tar.gz → 0.0.0.dev18__tar.gz

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev17
+Version: 0.0.0.dev18
 Summary: Fast, flexible and type-safe Git commands in Python.
 Author-email: Suhas Krishna Srivastava <suhas.srivastava@vaastav.tech>
 Maintainer-email: Suhas Krishna Srivastava <suhas.srivastava@vaastav.tech>
@@ -366,6 +366,38 @@ with git.subcmd_unchecked.popen(["cat-file", "--batch-command"]) as cf:
 
 Error handling and I/O management is left to the client/caller.
 
+#### 🏃 Communicate with long-running git sessions
+
+Introduced in `0.0.0.dev17` to:
+- Make long-running git command sessions.
+- Have reentrant sessions.
+- Communicate with long-running git command session using their `stdin` and `stdout`.
+
+Get long-running process sessions and communicate with them for batching and faster operations.
+
+```python
+import gitbolt
+from gitbolt.subprocess.utils.session import cat_file_blob_content, cat_file_tree_content
+
+git = gitbolt.get_git_command()
+with git.session(
+    cat_file1=["cat-file", "--batch"],
+    cat_file2=["cat-file", "--batch"],
+    cat_file3=lambda: git.subcmd_unchecked.popen(["cat-file", "--batch"]),  # pass your own git subcmd Popen(s)
+    mktree=["mktree"]
+) as ses:
+    for mode_, sha_, name_ in cat_file_tree_content(ses.commands.cat_file2, b"HEAD^{tree}"):
+        print(mode_, sha_, name_)
+    print("+" * 40)
+    print(cat_file_blob_content(ses.commands.cat_file3, b"9854cb4d432a881f59d38582791cf2636e7819d9"))
+    with ses:   # is reentrant, if you want
+        ses.commands.mktree.stdin.write(b"100644 blob <some-blob-hash> <some-filename>\n")
+        ses.commands.mktree.stdin.flush()
+        tree_hash = ses.commands.mktree.stdout.read()
+
+assert not ses.active # session no long active
+```
+
 #### 💻 Run commands received from CLI
 
 Introduced in `0.0.0.dev11` is the ability to take commands from CLI and run it inside `gitbolt`.

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/README.md

@@ -330,6 +330,38 @@ with git.subcmd_unchecked.popen(["cat-file", "--batch-command"]) as cf:
 
 Error handling and I/O management is left to the client/caller.
 
+#### 🏃 Communicate with long-running git sessions
+
+Introduced in `0.0.0.dev17` to:
+- Make long-running git command sessions.
+- Have reentrant sessions.
+- Communicate with long-running git command session using their `stdin` and `stdout`.
+
+Get long-running process sessions and communicate with them for batching and faster operations.
+
+```python
+import gitbolt
+from gitbolt.subprocess.utils.session import cat_file_blob_content, cat_file_tree_content
+
+git = gitbolt.get_git_command()
+with git.session(
+    cat_file1=["cat-file", "--batch"],
+    cat_file2=["cat-file", "--batch"],
+    cat_file3=lambda: git.subcmd_unchecked.popen(["cat-file", "--batch"]),  # pass your own git subcmd Popen(s)
+    mktree=["mktree"]
+) as ses:
+    for mode_, sha_, name_ in cat_file_tree_content(ses.commands.cat_file2, b"HEAD^{tree}"):
+        print(mode_, sha_, name_)
+    print("+" * 40)
+    print(cat_file_blob_content(ses.commands.cat_file3, b"9854cb4d432a881f59d38582791cf2636e7819d9"))
+    with ses:   # is reentrant, if you want
+        ses.commands.mktree.stdin.write(b"100644 blob <some-blob-hash> <some-filename>\n")
+        ses.commands.mktree.stdin.flush()
+        tree_hash = ses.commands.mktree.stdout.read()
+
+assert not ses.active # session no long active
+```
+
 #### 💻 Run commands received from CLI
 
 Introduced in `0.0.0.dev11` is the ability to take commands from CLI and run it inside `gitbolt`.

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gitbolt"
-version = "0.0.0.dev17"
+version = "0.0.0.dev18"
 description = "Fast, flexible and type-safe Git commands in Python."
 requires-python = ">=3.12"
 readme = "README.md"

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/src/gitbolt/__init__.py

@@ -17,6 +17,7 @@ from gitbolt.base import LsTree as LsTree
 from gitbolt.base import Version as Version
 from gitbolt.base import Add as Add
 from gitbolt.subprocess.base import GitCommand
+from gitbolt.subprocess.base import GitSession as GitSession
 # endregion
 
 

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/src/gitbolt/subprocess/base.py

@@ -7,6 +7,7 @@ Git command interfaces with default implementation using subprocess calls.
 
 from __future__ import annotations
 
+import sys
 from abc import abstractmethod, ABC
 from collections.abc import Callable
 from contextlib import AbstractContextManager
@@ -326,65 +327,136 @@ class GitCommand(Git, ABC):
         >>> with _git.session(cat_file=["cat-file", "--batch"]) as ses: # obtain, start and ctx manage the session.
         ...     pass    # any communication can be done by Popen semantics.
 
+
+       Note: All commands/processes are assumed:
+
+       - in bytes mode.
+       - pipe their stdin and stdout.
+
         :param commands: list of string git commands suppliable to ``subprocess.Popen`` or ``subprocess.Popen`` lambdas.
         :returns: A (not yet started) long-running ``GitSession`` context manager.
         """
         ...
 
 
+# TODO: extract a base session class from this
 class GitSession(HasGitUnderneath[GitCommand], AbstractContextManager):
-
     def __init__(self, git: GitCommand, **commands: Callable[[], Popen[bytes]]):
         """
-        Context Manager to start a git long-running session. Useful when a command is to be held in open state and be
-        communicated with its stdin and stdout. This is way faster that spawning multiple processes each time.
+        Reusable and reentrant context Manager to start a git long-running session. Useful when a command is to be
+        held in open state and be communicated with its stdin and stdout. This is way faster that spawning multiple
+        processes each time.
 
         Examples:
 
         Obtain a session:
 
         >>> import gitbolt
+        >>> from gitbolt.subprocess.base import GitSession
         >>> _git = gitbolt.get_git_command()
-        >>> ses = _git.session(ls_tree=["ls-tree", "HEAD"], cat_file=["cat-file", "--batch"])
+        >>> ses = GitSession(_git, ls_tree= lambda : _git.subcmd_unchecked.popen(["ls-tree", "HEAD"], text=False),
+        ...                 cat_file= lambda : _git.subcmd_unchecked.popen(["cat-file", "--batch"], text=False))
         >>> with ses:   # start the session by ctx mgr
         ...     pass    # any communication can be done by Popen semantics.
 
         Start the session in one go:
 
-        >>> with _git.session(cat_file=["cat-file", "--batch"]) as ses: # obtain, start and ctx manage the session.
+        >>> with GitSession(_git, cat_file= lambda : _git.subcmd_unchecked.popen(["cat-file", "--batch"], text=False)) as ses: # obtain, start and ctx manage the session.
         ...     pass    # any communication can be done by Popen semantics.
 
+
+       Note: All processes are assumed:
+
+       - in bytes mode.
+       - pipe their stdin and stdout.
+
         :param git: ``gitbolt.subprocess.GitCommand`` instance.
         :param commands: commands in kwargs fashion.
         """
         self._git = git
         self.unstarted_commands: dict[str, Callable[[], Popen[bytes]]] = commands
         self.started_commands: dict[str, Popen[bytes]] = dict()
-        self.commands: SimpleNamespace | None = None
+        self._commands: SimpleNamespace | None = None
+        self.__started = False
+        self.__done = False
+        self.__depth = 0
 
+    @override
     def __enter__(self) -> Self:
-        processes_started_keys: list[str] = []
-        for unstarted_command_key, unstarted_command in self.unstarted_commands.items():
-            self.started_commands[unstarted_command_key] = unstarted_command().__enter__()
-            processes_started_keys.append(unstarted_command_key)
-        self.commands = SimpleNamespace(**self.started_commands)
-        for pk in processes_started_keys:
-            del self.unstarted_commands[pk]
+        if self.depth == 0:
+            processes_started_keys: list[str] = []
+            for unstarted_command_key, unstarted_command in self.unstarted_commands.items():
+                try:
+                    self.started_commands[unstarted_command_key] = unstarted_command().__enter__()
+                except Exception:
+                    for k in reversed(processes_started_keys):
+                        self.started_commands[k].__exit__(*sys.exc_info())
+                    raise
+                processes_started_keys.append(unstarted_command_key)
+            self._commands = SimpleNamespace(**self.started_commands)
+            for pk in processes_started_keys:
+                del self.unstarted_commands[pk]
+            self.__started = True
+        self.__depth += 1
+        return self
 
+    @override
     @property
     def git(self) -> GitCommand:
         return self._git
 
-    def __exit__(self, exc_type, exc_value, traceback, /):
-        process_done_keys: list[str] = []
-        for started_popen_key, started_popen in self.started_commands.items():
-            started_popen.__exit__(exc_type, exc_value, traceback)
-            process_done_keys.append(started_popen_key)
-        self.commands = None
-        for pk in process_done_keys:
-            del self.started_commands[pk]
+    @override
+    def __exit__(self, exc_type, exc_value, traceback, /) -> Literal[False]:
+        self.__depth -= 1
+        if self.__depth == 0:
+            process_done_keys: list[str] = []
+            for started_popen_key, started_popen in self.started_commands.items():
+                started_popen.__exit__(exc_type, exc_value, traceback)
+                process_done_keys.append(started_popen_key)
+            self._commands = None
+            for pk in process_done_keys:
+                del self.started_commands[pk]
+            self.__done = True
         return False
 
+    @property
+    def started(self) -> bool:
+        """
+        :returns: Whether the session has started.
+        """
+        return self.__started
+
+    @property
+    def done(self) -> bool:
+        """
+        :returns: Whether the session has completed and thus exited/closed.
+        """
+        return self.__done
+
+    @property
+    def active(self) -> bool:
+        """
+        :returns: Whether the session is currently actively running.
+        """
+        return self.started and not self.done
+
+    @property
+    def commands(self) -> SimpleNamespace:
+        """
+        :returns: All the registered commands and these can be accessed by member notations.
+        :raises RuntimeError: if commands are queried when the session is inactive.
+        """
+        if self._commands is None or not self.active:
+            raise RuntimeError("GitSession not active")
+        return self._commands
+
+    @property
+    def depth(self) -> int:
+        """
+        :returns: The current session depth. Multilevel context managers increment the depth each y one.
+        """
+        return self.__depth
+
 
 class GitSubcmdCommand(GitSubCommand, HasGitUnderneath["GitCommand"], Protocol):
     """
@@ -696,30 +768,30 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
         self,
         subcommand_args: list[str],
         *popen_args: Any,
-        text: Literal[True] = True,
+        text: Literal[False] = False,
         **popen_kwargs: Any,
-    ) -> Popen[str]: ...
+    ) -> Popen[bytes]: ...
 
     @overload
     def popen(
         self,
         subcommand_args: list[str],
         *popen_args: Any,
-        text: Literal[False] = False,
+        text: Literal[True] = True,
         **popen_kwargs: Any,
-    ) -> Popen[bytes]: ...
+    ) -> Popen[str]: ...
 
     def popen(
         self,
         subcommand_args: list[str],
         *popen_args: Any,
-        text: Literal[True, False] = False,
+        text: Literal[False, True] = False,
         **popen_kwargs: Any,
     ) -> Popen[str] | Popen[bytes]:
         """
         Open unchecked git subcommand communicable process, using ``subprocess.Popen``.
 
-        All the arguments are congruent to ``subprocess.Popen`` and mostly passes as-is.
+        All the arguments are congruent to ``subprocess.Popen`` and mostly pass as-is.
 
         :param subcommand_args: the full subcommand argument list.
         :param popen_args: additional subprocess positionals.
@@ -734,7 +806,6 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
         stdin = popen_kwargs.pop("stdin", PIPE)
         stdout = popen_kwargs.pop("stdout", PIPE)
         stderr = popen_kwargs.pop("stderr", PIPE)
-        bufsize = popen_kwargs.pop("bufsize", 0)
         # Popen the git command
         result = self.git.runner.popen_git_command(
             main_cmd_args,
@@ -746,7 +817,6 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
             stdin=stdin,
             stdout=stdout,
             stderr=stderr,
-            bufsize=bufsize,
             **popen_kwargs,
         )
         return result

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/src/gitbolt/subprocess/impl/simple.py

@@ -170,7 +170,6 @@ class UncheckedSubcmdImpl(UncheckedSubcmd, GitSubcmdCommandImpl):
 
 
 class SimpleGitCommand(GitCommand, RootDirOp):
-
     def __init__(
         self,
         git_root_dir: Path = Path.cwd(),
@@ -250,11 +249,17 @@ class SimpleGitCommand(GitCommand, RootDirOp):
 
     def session(self, **commands: list[str] | Callable[[], Popen[bytes]]) -> GitSession:
         cmds: dict[str, Callable[[], Popen[bytes]]] = {}
+
+        # curb the lambda-late-binding-trap
+        # resource: https://medium.com/skiller-whale/late-binding-variables-its-a-trap-c17af980164f
+        def lambda_for_subcmd_popen(_runnable_cmd: list[str]):
+            return lambda: self.subcmd_unchecked.popen(_runnable_cmd)
+
         for cmd_name, runnable_cmd in commands.items():
             if callable(runnable_cmd):
                 cmds[cmd_name] = runnable_cmd
             else:
-                cmds[cmd_name] = lambda : self.subcmd_unchecked.popen(runnable_cmd, text=False)
+                cmds[cmd_name] = lambda_for_subcmd_popen(runnable_cmd)
         return GitSession(self, **cmds)
 
 

gitbolt-0.0.0.dev18/src/gitbolt/subprocess/utils/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+"""
+Utilities related to processors specific to git commands using subprocess.
+"""

gitbolt-0.0.0.dev18/src/gitbolt/subprocess/utils/session.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+"""
+Git command sessions utilities for long-running commands.
+
+Create sessions for long-running commands and communicate with them using their stdin/stdout.
+
+Much faster that subprocess creation for each input/output pair.
+"""
+
+import subprocess
+from typing import Iterable, IO, cast
+
+
+def cat_file_blob_content(
+    cat_file_popen: subprocess.Popen[bytes], blob_hash: bytes
+) -> bytes:
+    """
+    Read git blob contents using a long-running batched cat-file process.
+
+    Spawning new ``git show`` processes can be slower and resource consuming.
+
+    Note: ``cat_file_popen`` must pipe its ``stdin`` and ``stdout`` and run in ``bytes`` mode.
+
+    :param cat_file_popen: long-running ``git cat-file --batch`` process in bytes mode and pipes its stdin and stdout.
+    :param blob_hash: hash to be read from cat-file.
+    :return: contents of blob hash in bytes.
+    """
+    write_obj = blob_hash + b"\n"
+    cat_file_popen_stdin: IO[bytes] = cast(IO[bytes], cat_file_popen.stdin) # stdin is assumed to be piped
+    cat_file_popen_stdout: IO[bytes] = cast(IO[bytes], cat_file_popen.stdout) # stdout is assumed to be piped
+    cat_file_popen_stdin.write(write_obj)
+    cat_file_popen_stdin.flush()
+    header = cat_file_popen_stdout.readline()
+    obj, typ, size = header.split()
+    blob_content: bytes = cat_file_popen_stdout.read(int(size))
+    cat_file_popen_stdout.read(1)
+    return blob_content
+
+
+def parse_tree(data: bytes) -> Iterable[tuple[bytes, bytes, bytes]]:
+    """
+    Parse bytes tree data.
+
+    Typically best for parsing tree data from the stdout of a long-running cat-file query for tree.
+
+    :param data: tree data in bytes format.
+    :returns: iterable of (mode, sha, filename/filepath).
+    """
+    i = 0
+    n = len(data)
+    while i < n:
+        # mode
+        j = data.find(b" ", i)
+        mode = data[i:j]
+        # filename
+        k = data.find(b"\x00", j)
+        name = data[j + 1 : k]
+        # sha (20 bytes binary)
+        sha = data[k + 1 : k + 21]
+
+        yield mode, sha.hex().encode(), name
+        i = k + 21
+
+
+def cat_file_tree_content(
+    cat_file_popen: subprocess.Popen[bytes], tree_hash: bytes, recursive: bool = False,
+    prefix: bytes = b"",
+) -> list[tuple[bytes, bytes, bytes]]:
+    """
+    Get tree data from the stdout of a long-running cat-file query for tree hash.
+
+    Note: ``cat_file_popen`` must pipe its ``stdin`` and ``stdout`` and run in ``bytes`` mode.
+
+    :param cat_file_popen: long-running ``git cat-file --batch`` process in bytes mode and pipes its stdin and stdout.
+    :param tree_hash: tree hash to be read from cat-file.
+    :param recursive: recursively query the full tree.
+    :param prefix: prefix, useful when doing recursive tree query.
+    :return: list of (mode, sha, filename).
+    """
+    tree_content = cat_file_blob_content(cat_file_popen, tree_hash)
+    output: list[tuple[bytes, bytes, bytes]] = []
+    if not recursive:
+        for mode, sha, name in parse_tree(tree_content):
+            # leaf node (blob, symlink, submodule)
+            output.append((mode, sha, name,))
+    else:
+        for mode, sha, name in parse_tree(tree_content):
+            full_name = prefix + name
+
+            if mode == b"40000":  # directory (tree)
+                # recurse into subtree
+                sub_tree = cat_file_tree_content(
+                    cat_file_popen,
+                    sha,
+                    recursive=True,
+                    prefix=full_name + b"/",
+                )
+                output.extend(sub_tree)
+            else:
+                # leaf node (blob, symlink, submodule)
+                output.append((mode, sha, full_name,))
+
+    return output
+
+
+if __name__ == "__main__":
+    import gitbolt
+
+    git = gitbolt.get_git_command()
+    # with git.session(cat_file=["cat-file", "--batch"]) as ses1, git.session(cat_file=["catfile", "--batch"]) as ses2:
+    #     for mode_, sha_, name_ in cat_file_tree_content(ses1.commands.cat_file, b"HEAD^{tree}"):
+    #         print(mode_, sha_, name_)
+    with git.session(
+        cat_file1=["catfile", "--batch"],
+        cat_file2=["cat-file", "--batch"],
+        cat_file3=["cat-file", "--batch"],
+        mktree=lambda: git.subcmd_unchecked.popen(["mktree"]),
+    ) as ses:
+        for mode_, sha_, name_ in cat_file_tree_content(ses.commands.cat_file2, b"HEAD^{tree}"):
+            print(mode_, sha_, name_)
+        print("+" * 40)
+        print(cat_file_blob_content(ses.commands.cat_file3, b"9854cb4d432a881f59d38582791cf2636e7819d9"))
+    # cf_p_2 = git.subcmd_unchecked.popen(["catfile", "--batch"])
+    # cf_p_1 = git.subcmd_unchecked.popen(["cat-file", "--batch"])
+    # for mode_, sha_, name_ in cat_file_tree_content(cf_p_1, b"HEAD^{tree}"):
+    #         print(mode_, sha_, name_)
+    # sess = gitbolt.GitSession(git, cf_p_2=lambda: git.subcmd_unchecked.popen(["catfile", "--batch"]),
+    #                           cf_p_1=lambda: git.subcmd_unchecked.popen(["cat-file", "--batch"]),
+    #                           mktree=lambda: git.subcmd_unchecked.popen(["mktree", "--batch"]))
+    # with sess:
+    #     for mode_, sha_, name_ in cat_file_tree_content(sess.commands.cf_p_1, b"HEAD^{tree}"):
+    #             print(mode_, sha_, name_)

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/src/gitbolt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev17
+Version: 0.0.0.dev18
 Summary: Fast, flexible and type-safe Git commands in Python.
 Author-email: Suhas Krishna Srivastava <suhas.srivastava@vaastav.tech>
 Maintainer-email: Suhas Krishna Srivastava <suhas.srivastava@vaastav.tech>
@@ -366,6 +366,38 @@ with git.subcmd_unchecked.popen(["cat-file", "--batch-command"]) as cf:
 
 Error handling and I/O management is left to the client/caller.
 
+#### 🏃 Communicate with long-running git sessions
+
+Introduced in `0.0.0.dev17` to:
+- Make long-running git command sessions.
+- Have reentrant sessions.
+- Communicate with long-running git command session using their `stdin` and `stdout`.
+
+Get long-running process sessions and communicate with them for batching and faster operations.
+
+```python
+import gitbolt
+from gitbolt.subprocess.utils.session import cat_file_blob_content, cat_file_tree_content
+
+git = gitbolt.get_git_command()
+with git.session(
+    cat_file1=["cat-file", "--batch"],
+    cat_file2=["cat-file", "--batch"],
+    cat_file3=lambda: git.subcmd_unchecked.popen(["cat-file", "--batch"]),  # pass your own git subcmd Popen(s)
+    mktree=["mktree"]
+) as ses:
+    for mode_, sha_, name_ in cat_file_tree_content(ses.commands.cat_file2, b"HEAD^{tree}"):
+        print(mode_, sha_, name_)
+    print("+" * 40)
+    print(cat_file_blob_content(ses.commands.cat_file3, b"9854cb4d432a881f59d38582791cf2636e7819d9"))
+    with ses:   # is reentrant, if you want
+        ses.commands.mktree.stdin.write(b"100644 blob <some-blob-hash> <some-filename>\n")
+        ses.commands.mktree.stdin.flush()
+        tree_hash = ses.commands.mktree.stdout.read()
+
+assert not ses.active # session no long active
+```
+
 #### 💻 Run commands received from CLI
 
 Introduced in `0.0.0.dev11` is the ability to take commands from CLI and run it inside `gitbolt`.

{gitbolt-0.0.0.dev17 → gitbolt-0.0.0.dev18}/src/gitbolt.egg-info/SOURCES.txt

@@ -25,10 +25,11 @@ src/gitbolt/subprocess/base.py
 src/gitbolt/subprocess/constants.py
 src/gitbolt/subprocess/exceptions.py
 src/gitbolt/subprocess/ls_tree.py
-src/gitbolt/subprocess/session.py
-src/gitbolt/subprocess/utils.py
 src/gitbolt/subprocess/impl/__init__.py
 src/gitbolt/subprocess/impl/simple.py
 src/gitbolt/subprocess/runner/__init__.py
 src/gitbolt/subprocess/runner/base.py
-src/gitbolt/subprocess/runner/simple.py
+src/gitbolt/subprocess/runner/simple.py
+src/gitbolt/subprocess/utils/__init__.py
+src/gitbolt/subprocess/utils/cmd.py
+src/gitbolt/subprocess/utils/session.py

gitbolt-0.0.0.dev17/src/gitbolt/subprocess/session.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-# coding=utf-8
-
-"""
-Git command sessions utilities for long-running commands.
-
-Create sessions for long-running commands and communicate with them using their stdin/stdout.
-
-Much faster that subprocess creation for each input/output pair.
-"""
-import subprocess
-
-from vt.utils.commons.commons.core_py import read_exact
-
-
-def cat_file_blob_content(cat_file_popen: subprocess.Popen[bytes], blob_hash: bytes) -> bytes:
-    """
-    Read git blob contents using a long-running batched cat-file process.
-
-    Spawning new ``git show`` processes can be slower and resource consuming.
-
-    :param cat_file_popen: long-running ``git cat-file --batch`` process in bytes mode.
-    :param blob_hash: hash to be read from cat-file.
-    :return: contents of blob hash in bytes.
-    """
-    write_obj = blob_hash + b"\n"
-    cat_file_popen.stdin.write(write_obj)
-    cat_file_popen.stdin.flush()
-    header = cat_file_popen.stdout.readline()
-    obj, typ, size = header.split()
-    blob_content: bytes = read_exact(cat_file_popen.stdout, int(size))
-    cat_file_popen.stdout.readline()
-    return blob_content