gitbolt 0.0.0.dev16__tar.gz → 0.0.0.dev17__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev16
+Version: 0.0.0.dev17
 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>
@@ -27,7 +27,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: vt-err-hndlr>=0.0.0dev6
-Requires-Dist: vt-commons>=0.0.1.dev9
+Requires-Dist: vt-commons>=0.0.1.dev11
 Provides-Extra: pygit2
 Requires-Dist: pygit2; extra == "pygit2"
 Provides-Extra: test

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

@@ -1,6 +1,6 @@
 [project]
 name = "gitbolt"
-version = "0.0.0.dev16"
+version = "0.0.0.dev17"
 description = "Fast, flexible and type-safe Git commands in Python."
 requires-python = ">=3.12"
 readme = "README.md"
@@ -37,7 +37,7 @@ classifiers = [
 ]
 dependencies = [
   "vt-err-hndlr >= 0.0.0dev6",
-  "vt-commons >= 0.0.1.dev9",
+  "vt-commons >= 0.0.1.dev11",
 ]
 
 [project.optional-dependencies]

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

@@ -9,8 +9,10 @@ from __future__ import annotations
 
 from abc import abstractmethod, ABC
 from collections.abc import Callable
+from contextlib import AbstractContextManager
 from pathlib import Path
 from subprocess import CompletedProcess, Popen, PIPE
+from types import SimpleNamespace
 from typing import override, Protocol, Unpack, Self, overload, Literal, Any
 
 from vt.utils.commons.commons.core_py import is_unset, not_none_not_unset
@@ -295,10 +297,95 @@ class GitCommand(Git, ABC):
     def subcmd_unchecked(self) -> UncheckedSubcmd:
         """
         Run an unchecked git subcommand using subprocess.
+
+        :returns: An unchecked subcommand instance that simply runs the asked command in a ``subprocess.run()`` with
+            optional ``subprocess.Popen()``.
+        """
+        ...
+
+    @abstractmethod
+    def session(self, **commands: list[str] | Callable[[], Popen[bytes]]) -> GitSession:
+        """
+        Run long-running git session with multiple unchecked subcommands using ``subprocess.Popen`` and
+        communicate with them.
+
+        Client/Caller can communicate with ``GitSession``'s processes with their stdin and stdout.
+
+        Examples:
+
+        Obtain a session:
+
+        >>> import gitbolt
+        >>> _git = gitbolt.get_git_command()
+        >>> ses = _git.session(ls_tree=["ls-tree", "HEAD"], cat_file=["cat-file", "--batch"])
+        >>> 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.
+        ...     pass    # any communication can be done by Popen semantics.
+
+        :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.
         """
         ...
 
 
+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.
+
+        Examples:
+
+        Obtain a session:
+
+        >>> import gitbolt
+        >>> _git = gitbolt.get_git_command()
+        >>> ses = _git.session(ls_tree=["ls-tree", "HEAD"], cat_file=["cat-file", "--batch"])
+        >>> 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.
+        ...     pass    # any communication can be done by Popen semantics.
+
+        :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
+
+    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]
+
+    @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]
+        return False
+
+
 class GitSubcmdCommand(GitSubCommand, HasGitUnderneath["GitCommand"], Protocol):
     """
     A ``GitSubCommand`` that holds a reference to ``git`` and provides ``git_opts_override`` by default.

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

@@ -9,7 +9,8 @@ from __future__ import annotations
 
 from abc import ABC
 from pathlib import Path
-from typing import override, Literal, overload
+from subprocess import Popen
+from typing import override, Literal, overload, Callable
 
 from vt.utils.commons.commons.op import RootDirOp
 
@@ -24,6 +25,7 @@ from gitbolt.subprocess import (
     UncheckedSubcmd,
 )
 from gitbolt.subprocess.add import AddCLIArgsBuilder
+from gitbolt.subprocess.base import GitSession
 from gitbolt.subprocess.constants import VERSION_CMD
 from gitbolt.subprocess.ls_tree import LsTreeCLIArgsBuilder
 from gitbolt.subprocess.runner import GitCommandRunner
@@ -168,6 +170,7 @@ class UncheckedSubcmdImpl(UncheckedSubcmd, GitSubcmdCommandImpl):
 
 
 class SimpleGitCommand(GitCommand, RootDirOp):
+
     def __init__(
         self,
         git_root_dir: Path = Path.cwd(),
@@ -245,6 +248,15 @@ class SimpleGitCommand(GitCommand, RootDirOp):
         subcmd_unchecked._set_underlying_git(self)
         return subcmd_unchecked
 
+    def session(self, **commands: list[str] | Callable[[], Popen[bytes]]) -> GitSession:
+        cmds: dict[str, Callable[[], Popen[bytes]]] = {}
+        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)
+        return GitSession(self, **cmds)
+
 
 class CLISimpleGitCommand(SimpleGitCommand):
     """

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

@@ -0,0 +1,33 @@
+#!/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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev16
+Version: 0.0.0.dev17
 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>
@@ -27,7 +27,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: vt-err-hndlr>=0.0.0dev6
-Requires-Dist: vt-commons>=0.0.1.dev9
+Requires-Dist: vt-commons>=0.0.1.dev11
 Provides-Extra: pygit2
 Requires-Dist: pygit2; extra == "pygit2"
 Provides-Extra: test

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

@@ -25,6 +25,7 @@ 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

{gitbolt-0.0.0.dev16 → gitbolt-0.0.0.dev17}/src/gitbolt.egg-info/requires.txt

@@ -1,5 +1,5 @@
 vt-err-hndlr>=0.0.0dev6
-vt-commons>=0.0.1.dev9
+vt-commons>=0.0.1.dev11
 
 [pygit2]
 pygit2