gitbolt 0.0.0.dev15__tar.gz → 0.0.0.dev16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev15
+Version: 0.0.0.dev16
 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>
@@ -327,10 +327,12 @@ no_advice_reset_git = overridden_git.git_opts_override(no_advice=False)
 
 At last, run unchecked commands in git.
 
-Introduced in `0.0.0dev4` to 
+Introduced in `0.0.0.dev4` to 
 - experiment.
 - have consistent interfaced commands run until all subcommands are provided by the library.
 
+#### 🖥️ Run one process per command
+
 ```python
 import gitbolt
 
@@ -340,9 +342,33 @@ git.subcmd_unchecked.run(['--version']) # run the version option for git.
 git.subcmd_unchecked.run(['version']) # run the version subcommand.
 ```
 
+#### 🖥️ Run one long-running process and communicate with it
+
+Introduced in `0.0.0.dev16` to:
+- Make communicable processes using `subprocess.Popen`.
+
+Get a long-running process and communicate with it for batching and faster operations.
+
+```python
+import gitbolt
+import sys
+
+git = gitbolt.get_git_command()
+with git.subcmd_unchecked.popen(["cat-file", "--batch-command"]) as cf:
+    cf.stdin.write(b"contents HEAD\n")
+    cf.stdin.flush()
+    header = cf.stdout.readline().strip()
+    print(f"HEADER: {header}", file=sys.stderr)
+    obj, typ, size = header.split()
+    print(cf.stdout.read(int(size)))
+    cf.stdout.readline()
+```
+
+Error handling and I/O management is left to the client/caller.
+
 #### 💻 Run commands received from CLI
 
-Introduced in `0.0.0dev11` is the ability to take commands from CLI and run it inside `gitbolt`.
+Introduced in `0.0.0.dev11` is the ability to take commands from CLI and run it inside `gitbolt`.
 
 While making a system it may be required to run cli commands as received from cli using gitbolt. An obvious example 
 would be to make a system that receives CLI commands and does certain modifications/additions inside `gitbolt` before

{gitbolt-0.0.0.dev15 → gitbolt-0.0.0.dev16}/README.md

@@ -291,10 +291,12 @@ no_advice_reset_git = overridden_git.git_opts_override(no_advice=False)
 
 At last, run unchecked commands in git.
 
-Introduced in `0.0.0dev4` to 
+Introduced in `0.0.0.dev4` to 
 - experiment.
 - have consistent interfaced commands run until all subcommands are provided by the library.
 
+#### 🖥️ Run one process per command
+
 ```python
 import gitbolt
 
@@ -304,9 +306,33 @@ git.subcmd_unchecked.run(['--version']) # run the version option for git.
 git.subcmd_unchecked.run(['version']) # run the version subcommand.
 ```
 
+#### 🖥️ Run one long-running process and communicate with it
+
+Introduced in `0.0.0.dev16` to:
+- Make communicable processes using `subprocess.Popen`.
+
+Get a long-running process and communicate with it for batching and faster operations.
+
+```python
+import gitbolt
+import sys
+
+git = gitbolt.get_git_command()
+with git.subcmd_unchecked.popen(["cat-file", "--batch-command"]) as cf:
+    cf.stdin.write(b"contents HEAD\n")
+    cf.stdin.flush()
+    header = cf.stdout.readline().strip()
+    print(f"HEADER: {header}", file=sys.stderr)
+    obj, typ, size = header.split()
+    print(cf.stdout.read(int(size)))
+    cf.stdout.readline()
+```
+
+Error handling and I/O management is left to the client/caller.
+
 #### 💻 Run commands received from CLI
 
-Introduced in `0.0.0dev11` is the ability to take commands from CLI and run it inside `gitbolt`.
+Introduced in `0.0.0.dev11` is the ability to take commands from CLI and run it inside `gitbolt`.
 
 While making a system it may be required to run cli commands as received from cli using gitbolt. An obvious example 
 would be to make a system that receives CLI commands and does certain modifications/additions inside `gitbolt` before

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

@@ -1,6 +1,6 @@
 [project]
 name = "gitbolt"
-version = "0.0.0dev15"
+version = "0.0.0.dev16"
 description = "Fast, flexible and type-safe Git commands in Python."
 requires-python = ">=3.12"
 readme = "README.md"
@@ -45,9 +45,7 @@ pygit2 = ['pygit2']
 test = ['pytest']
 
 [dependency-groups]
-# TODO: report the mypy recent version (1.16.0, 1.16.1 issue) RuntimeError: ('Not implemented', <class 'mypy.types.TypeGuardedType'>)
-#   btw, this error doesn't show in the latest developer version. So, this error will go away with 1.17.0 relase
-dev = ["mypy==1.15.0", "ruff"]
+dev = ["mypy", "ruff"]
 doc = ['sphinx', 'sphinx-argparse']
 test = ["pytest", 'pytest-cov', "pytest-xdist"]
 multitest = ['tox']

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

@@ -10,7 +10,7 @@ from __future__ import annotations
 from abc import abstractmethod, ABC
 from collections.abc import Callable
 from pathlib import Path
-from subprocess import CompletedProcess
+from subprocess import CompletedProcess, Popen, PIPE
 from typing import override, Protocol, Unpack, Self, overload, Literal, Any
 
 from vt.utils.commons.commons.core_py import is_unset, not_none_not_unset
@@ -584,12 +584,8 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
 
         :return: ``CompletedProcess`` capturing all the required stdout, stderr, return-code etc.
         """
-        main_cmd_args = self.git.build_main_cmd_args()
-        envs_vars = self.git.build_git_envs()
-        another_supplied_env = subprocess_run_kwargs.pop("env", None)
-        if another_supplied_env:
-            if envs_vars is not None:
-                envs_vars.update(another_supplied_env)
+        main_cmd_args = self.git_main_cmd_args()
+        envs_vars = self.git_envs(subprocess_run_kwargs.pop("env", None))
         cwd = subprocess_run_kwargs.pop("cwd", self.root_dir)
         capture_output = subprocess_run_kwargs.pop("capture_output", True)
         check = subprocess_run_kwargs.pop("check", True)
@@ -607,3 +603,103 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
             **subprocess_run_kwargs,
         )
         return result
+
+    @overload
+    def popen(
+        self,
+        subcommand_args: list[str],
+        *popen_args: Any,
+        text: Literal[True] = True,
+        **popen_kwargs: Any,
+    ) -> Popen[str]: ...
+
+    @overload
+    def popen(
+        self,
+        subcommand_args: list[str],
+        *popen_args: Any,
+        text: Literal[False] = False,
+        **popen_kwargs: Any,
+    ) -> Popen[bytes]: ...
+
+    def popen(
+        self,
+        subcommand_args: list[str],
+        *popen_args: Any,
+        text: Literal[True, False] = 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.
+
+        :param subcommand_args: the full subcommand argument list.
+        :param popen_args: additional subprocess positionals.
+        :param text: ``_input`` and returns both are str if this value is ``True``. Else, bytes are considered.
+        :param popen_kwargs: additional subprocess keyword arguments.
+
+        :return: ``Popen`` capturing all the required stdout, stderr etc and streaming stdin.
+        """
+        main_cmd_args = self.git_main_cmd_args()
+        envs_vars = self.git_envs(popen_kwargs.pop("env", None))
+        cwd = popen_kwargs.pop("cwd", self.root_dir)
+        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,
+            subcommand_args,
+            *popen_args,
+            text=text,
+            env=envs_vars,
+            cwd=cwd,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            bufsize=bufsize,
+            **popen_kwargs,
+        )
+        return result
+
+    def make_cmd(self, subcommand_args: list[str]) -> list[str]:
+        """
+        Make full runnable command for execution from the supplied ``subcommand_args``.
+
+        As knowledge of the git program and the main command is encapsulated within this ``UncheckedSubcmd`` thus,
+        this is a convenience method for any external entities that want to run commands in their own subprocess.
+
+        :param subcommand_args: arguments for subcommand.
+        :returns: a fully made and runnable command for some external ``subprocess`` call.
+        """
+        return self.git.runner.make_cmd(self.git.build_main_cmd_args(), subcommand_args)
+
+    def git_main_cmd_args(self) -> list[str]:
+        """
+        Get CLI args for git main cli command.
+
+        For example, ``--no-pager --no-advice`` is the git main command in ``git --no-pager --no-advice log master -1``.
+
+        :return: CLI args for git main cli command.
+        """
+        return self.git.build_main_cmd_args()
+
+    def git_envs(
+        self, extra_git_envs: dict[str, str] | None = None
+    ) -> dict[str, str] | None:
+        """
+        Get Git environment variables from the merged ``GitEnvVars`` object.
+
+        Skips values that are ``Unset`` or ``None``-like using ``not_none_not_unset()``.
+        Converts ``Path`` and ``datetime`` instances to ``str``.
+
+        :param extra_git_envs: extraneous git envs supplied by the caller. These will be merged into the resultant
+            git envs and then returned.
+        :return: A cleaned and normalized GitEnvVars dict suitable for use in subprocesses.
+        """
+        env_vars = self.git.build_git_envs()
+        if extra_git_envs and env_vars is not None:
+            env_vars.update(extra_git_envs)
+        return env_vars

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

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import pathlib
 from abc import abstractmethod
-from subprocess import CompletedProcess
+from subprocess import CompletedProcess, Popen
 from typing import Protocol, overload, Any, Literal
 
 
@@ -64,6 +64,39 @@ class GitCommandRunner(Protocol):
         **subprocess_run_kwargs: Any,
     ) -> CompletedProcess[bytes]: ...
 
+    @overload
+    @abstractmethod
+    def popen_git_command(
+        self,
+        main_cmd_args: list[str],
+        subcommand_args: list[str],
+        *popen_run_args: Any,
+        text: Literal[False],
+        **popen_run_kwargs: Any,
+    ) -> Popen[bytes]: ...
+
+    @overload
+    @abstractmethod
+    def popen_git_command(
+        self,
+        main_cmd_args: list[str],
+        subcommand_args: list[str],
+        *popen_run_args: Any,
+        text: Literal[True],
+        **popen_run_kwargs: Any,
+    ) -> Popen[str]: ...
+
+    @abstractmethod
+    def make_cmd(self, main_cmd_args: list[str], sub_cmd_args: list[str]) -> list[str]:
+        """
+        Make command for execution for use in an external subprocess.
+
+        :param main_cmd_args: arguments for the main command.
+        :param sub_cmd_args: arguments for subcommand.
+        :returns: a fully made and runnable command for some external ``subprocess`` call.
+        """
+        ...
+
     @property
     @abstractmethod
     def git_prog(self) -> str | pathlib.Path:

{gitbolt-0.0.0.dev15 → gitbolt-0.0.0.dev16}/src/gitbolt/subprocess/runner/simple.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import pathlib
 import subprocess
-from subprocess import CompletedProcess
+from subprocess import CompletedProcess, Popen
 from typing import overload, override, Any, Literal
 
 from gitbolt.subprocess.constants import GIT_CMD
@@ -86,7 +86,7 @@ class SimpleGitCR(GitCommandRunner):
     ) -> CompletedProcess[str] | CompletedProcess[bytes]:
         try:
             return subprocess.run(
-                [str(self.git_prog), *main_cmd_args, *subcommand_args],
+                self.make_cmd(main_cmd_args, subcommand_args),
                 *subprocess_run_args,
                 input=_input,
                 text=text,
@@ -97,6 +97,53 @@ class SimpleGitCR(GitCommandRunner):
                 e.stderr, called_process_error=e, exit_code=e.returncode
             ) from e
 
+    @overload
+    @override
+    def popen_git_command(
+        self,
+        main_cmd_args: list[str],
+        subcommand_args: list[str],
+        *popen_run_args: Any,
+        text: Literal[False],
+        **popen_run_kwargs: Any,
+    ) -> Popen[bytes]: ...
+
+    @overload
+    @override
+    def popen_git_command(
+        self,
+        main_cmd_args: list[str],
+        subcommand_args: list[str],
+        *popen_run_args: Any,
+        text: Literal[True],
+        **popen_run_kwargs: Any,
+    ) -> Popen[str]: ...
+
+    @override
+    def popen_git_command(
+        self,
+        main_cmd_args: list[str],
+        subcommand_args: list[str],
+        *popen_run_args: Any,
+        text: Literal[True, False],
+        **popen_run_kwargs: Any,
+    ) -> Popen[str] | Popen[bytes]:
+        try:
+            return subprocess.Popen(
+                self.make_cmd(main_cmd_args, subcommand_args),
+                *popen_run_args,
+                text=text,
+                **popen_run_kwargs,
+            )
+        except subprocess.CalledProcessError as e:
+            raise GitCmdException(
+                e.stderr, called_process_error=e, exit_code=e.returncode
+            ) from e
+
+    @override
+    def make_cmd(self, main_cmd_args: list[str], sub_cmd_args: list[str]) -> list[str]:
+        return [str(self.git_prog), *main_cmd_args, *sub_cmd_args]
+
     @override
     @property
     def git_prog(self) -> str | pathlib.Path:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev15
+Version: 0.0.0.dev16
 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>
@@ -327,10 +327,12 @@ no_advice_reset_git = overridden_git.git_opts_override(no_advice=False)
 
 At last, run unchecked commands in git.
 
-Introduced in `0.0.0dev4` to 
+Introduced in `0.0.0.dev4` to 
 - experiment.
 - have consistent interfaced commands run until all subcommands are provided by the library.
 
+#### 🖥️ Run one process per command
+
 ```python
 import gitbolt
 
@@ -340,9 +342,33 @@ git.subcmd_unchecked.run(['--version']) # run the version option for git.
 git.subcmd_unchecked.run(['version']) # run the version subcommand.
 ```
 
+#### 🖥️ Run one long-running process and communicate with it
+
+Introduced in `0.0.0.dev16` to:
+- Make communicable processes using `subprocess.Popen`.
+
+Get a long-running process and communicate with it for batching and faster operations.
+
+```python
+import gitbolt
+import sys
+
+git = gitbolt.get_git_command()
+with git.subcmd_unchecked.popen(["cat-file", "--batch-command"]) as cf:
+    cf.stdin.write(b"contents HEAD\n")
+    cf.stdin.flush()
+    header = cf.stdout.readline().strip()
+    print(f"HEADER: {header}", file=sys.stderr)
+    obj, typ, size = header.split()
+    print(cf.stdout.read(int(size)))
+    cf.stdout.readline()
+```
+
+Error handling and I/O management is left to the client/caller.
+
 #### 💻 Run commands received from CLI
 
-Introduced in `0.0.0dev11` is the ability to take commands from CLI and run it inside `gitbolt`.
+Introduced in `0.0.0.dev11` is the ability to take commands from CLI and run it inside `gitbolt`.
 
 While making a system it may be required to run cli commands as received from cli using gitbolt. An obvious example 
 would be to make a system that receives CLI commands and does certain modifications/additions inside `gitbolt` before