gitbolt 0.0.0.dev15__tar.gz → 0.0.0.dev17__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev15
+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
@@ -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.dev17}/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.dev17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gitbolt"
-version = "0.0.0dev15"
+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]
@@ -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.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
+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,9 +297,94 @@ 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):
     """
@@ -584,12 +671,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 +690,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.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.dev15 → gitbolt-0.0.0.dev17}/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.dev17}/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.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.dev15 → 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.dev15
+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
@@ -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.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.dev15 → 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