gitbolt 0.0.0.dev10__tar.gz → 0.0.0.dev12__tar.gz

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev10
+Version: 0.0.0.dev12
 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>
@@ -26,8 +26,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: vt-err-hndlr>=0.0.0dev3
-Requires-Dist: vt-commons>=0.0.1.dev4
+Requires-Dist: vt-err-hndlr>=0.0.0dev5
+Requires-Dist: vt-commons>=0.0.1.dev9
 Provides-Extra: pygit2
 Requires-Dist: pygit2; extra == "pygit2"
 Provides-Extra: test
@@ -64,6 +64,7 @@ Dynamic: license-file
 * 🧪 **Terminal Functions:** Git subcommands are terminal functions.
 * 🧼 **Idiomatic Python:** Write commands in idiomatic Python at compile-time and be confident they’ll execute smoothly at runtime.
 * 🎀 **Add-ons:** Special features provided to ease programming with git. These can be added if required.
+* 💻 **CLI-cmd:** Take commands from cli and run in `gitbolt`.
 
 ---
 
@@ -340,6 +341,24 @@ git.subcmd_unchecked.run(['--version']) # run the version option for git.
 git.subcmd_unchecked.run(['version']) # run the version subcommand.
 ```
 
+#### 💻 Run commands received from CLI
+
+Introduced in `0.0.0dev11` 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
+actually running them. An example:
+
+```python
+from gitbolt.git_subprocess.impl.simple import CLISimpleGitCommand
+
+opts = ["--no-pager", "--namespace", "n1"]   # options received from outside your program.
+envs = dict(GIT_AUTHOR_NAME="ss")   # env-vars received form outside your program.
+git = CLISimpleGitCommand(opts=opts, envs=envs)
+
+# these can later be overridden
+git = git.git_opts_override(namespace="n2")
+```
 
 ---
 

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/README.md

@@ -28,6 +28,7 @@
 * 🧪 **Terminal Functions:** Git subcommands are terminal functions.
 * 🧼 **Idiomatic Python:** Write commands in idiomatic Python at compile-time and be confident they’ll execute smoothly at runtime.
 * 🎀 **Add-ons:** Special features provided to ease programming with git. These can be added if required.
+* 💻 **CLI-cmd:** Take commands from cli and run in `gitbolt`.
 
 ---
 
@@ -304,6 +305,24 @@ git.subcmd_unchecked.run(['--version']) # run the version option for git.
 git.subcmd_unchecked.run(['version']) # run the version subcommand.
 ```
 
+#### 💻 Run commands received from CLI
+
+Introduced in `0.0.0dev11` 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
+actually running them. An example:
+
+```python
+from gitbolt.git_subprocess.impl.simple import CLISimpleGitCommand
+
+opts = ["--no-pager", "--namespace", "n1"]   # options received from outside your program.
+envs = dict(GIT_AUTHOR_NAME="ss")   # env-vars received form outside your program.
+git = CLISimpleGitCommand(opts=opts, envs=envs)
+
+# these can later be overridden
+git = git.git_opts_override(namespace="n2")
+```
 
 ---
 

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gitbolt"
-version = "0.0.0dev10"
+version = "0.0.0dev12"
 description = "Fast, flexible and type-safe Git commands in Python."
 requires-python = ">=3.12"
 readme = "README.md"
@@ -36,8 +36,8 @@ classifiers = [
   "Typing :: Typed"
 ]
 dependencies = [
-  "vt-err-hndlr >= 0.0.0dev3",
-  "vt-commons >= 0.0.1.dev4",
+  "vt-err-hndlr >= 0.0.0dev5",
+  "vt-commons >= 0.0.1.dev9",
 ]
 
 [project.optional-dependencies]
@@ -49,7 +49,7 @@ test = ['pytest']
 #   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"]
 doc = ['sphinx', 'sphinx-argparse']
-test = ["pytest", 'pytest-cov']
+test = ["pytest", 'pytest-cov', "pytest-xdist"]
 multitest = ['tox']
 
 

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/src/gitbolt/__init__.py

@@ -23,6 +23,7 @@ from gitbolt.constants import GIT_DIR as GIT_DIR
 # endregion
 
 
+# TODO: check failing test on macos
 def get_git(git_root_dir: Path = Path.cwd()) -> Git:
     """
     Get operational and programmatic ``Git``.
@@ -34,7 +35,7 @@ def get_git(git_root_dir: Path = Path.cwd()) -> Git:
     >>> import subprocess
     >>> import gitbolt
     >>> git = gitbolt.get_git()
-    >>> assert git.version == subprocess.run(['git', 'version'], capture_output=True, text=True).stdout.strip()
+    >>> assert git.version().version() == subprocess.run(['git', 'version'], capture_output=True, text=True).stdout.strip()
 
     :param git_root_dir: Path to the git repo root directory. Defaults to current working directory.
     """

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/src/gitbolt/base.py

@@ -230,8 +230,29 @@ class Version(GitSubCommand, Protocol):
     Interface for ``git version`` command.
     """
 
+    class VersionInfo:
+        @abstractmethod
+        def version(self) -> str: ...
+
+        @abstractmethod
+        def semver(self) -> tuple: ...
+
+    class VersionWithBuildInfo(VersionInfo):
+        @abstractmethod
+        def build_options(self) -> dict[str, str]: ...
+
+    @overload
+    @abstractmethod
+    def version(self) -> VersionInfo: ...
+
+    @overload
     @abstractmethod
-    def version(self, build_options: bool = False) -> str:
+    def version(self, build_options: Literal[True]) -> VersionWithBuildInfo: ...
+
+    @abstractmethod
+    def version(
+        self, build_options: Literal[True, False] = False
+    ) -> VersionInfo | VersionWithBuildInfo:
         """
         All the parameters are mirrors of the parameters of ``git version`` CLI command
         from `git version documentation <https://git-scm.com/docs/git-version>`_.
@@ -276,14 +297,12 @@ class Git(CanOverrideGitOpts, CanOverrideGitEnvs, Protocol):
     Class designed analogous to documentation provided on `git documentation <https://git-scm.com/docs/git>`_.
     """
 
-    @property
-    def version(self) -> str:
+    def version(self) -> Version.VersionInfo:
         """
         :return: current git version.
         """
         return self.version_subcmd.version()
 
-    @property
     @abstractmethod
     def exec_path(self) -> Path:
         """
@@ -291,7 +310,6 @@ class Git(CanOverrideGitOpts, CanOverrideGitEnvs, Protocol):
         """
         ...
 
-    @property
     @abstractmethod
     def html_path(self) -> Path:
         """
@@ -299,7 +317,6 @@ class Git(CanOverrideGitOpts, CanOverrideGitEnvs, Protocol):
         """
         ...
 
-    @property
     @abstractmethod
     def info_path(self) -> Path:
         """
@@ -307,7 +324,6 @@ class Git(CanOverrideGitOpts, CanOverrideGitEnvs, Protocol):
         """
         ...
 
-    @property
     @abstractmethod
     def man_path(self) -> Path:
         """

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/src/gitbolt/git_subprocess/base.py

@@ -8,14 +8,17 @@ Git command interfaces with default implementation using subprocess calls.
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
+from collections.abc import Callable
 from pathlib import Path
 from subprocess import CompletedProcess
 from typing import override, Protocol, Unpack, Self, overload, Literal, Any
 
 from vt.utils.commons.commons.core_py import is_unset, not_none_not_unset
 from vt.utils.commons.commons.op import RootDirOp
+from vt.utils.errors.error_specs import ERR_INVALID_USAGE
 
 from gitbolt import Git, Version, LsTree, GitSubCommand, HasGitUnderneath, Add
+from gitbolt.exceptions import GitExitingException
 from gitbolt.git_subprocess.add import AddCLIArgsBuilder, IndividuallyOverridableACAB
 from gitbolt.git_subprocess.ls_tree import (
     LsTreeCLIArgsBuilder,
@@ -239,25 +242,21 @@ class GitCommand(Git, ABC):
     # endregion
 
     @override
-    @property
     def html_path(self) -> Path:
         html_path_str = "--html-path"
         return self._get_path(html_path_str)
 
     @override
-    @property
     def info_path(self) -> Path:
         info_path_str = "--info-path"
         return self._get_path(info_path_str)
 
     @override
-    @property
     def man_path(self) -> Path:
         man_path_str = "--man-path"
         return self._get_path(man_path_str)
 
     @override
-    @property
     def exec_path(self) -> Path:
         exec_path_str = "--exec-path"
         return self._get_path(exec_path_str)
@@ -324,7 +323,66 @@ class GitSubcmdCommand(GitSubCommand, HasGitUnderneath["GitCommand"], Protocol):
 
 
 class VersionCommand(Version, GitSubcmdCommand, Protocol):
-    pass
+    class _Cache:
+        def __init__(self):
+            self.version = None
+            self.semver = None
+            self.build_options = None
+
+    class VersionInfoForCmd(Version.VersionInfo):
+        def __init__(self, rosetta_supplier: Callable[[], str]):
+            self.rosetta_supplier = rosetta_supplier
+            self.rosetta: str | None = None
+            self._cache = VersionCommand._Cache()
+
+        @override
+        def version(self) -> str:
+            if self.rosetta is None:
+                self.rosetta = self.rosetta_supplier()
+            if self._cache.version is not None:
+                return self._cache.version
+            v_str = self.rosetta.splitlines()[0]
+            self._cache.version = v_str
+            return v_str
+
+        @override
+        def semver(self) -> tuple:
+            if self._cache.semver is not None:
+                return self._cache.semver
+            t_ver = self.version().split()[-1].split(".")
+            return tuple(t_ver)
+
+        @override
+        def __str__(self):
+            if self.rosetta is None:
+                self.rosetta = self.rosetta_supplier()
+            return self.rosetta
+
+    class VersionWithBuildInfoForCmd(VersionInfoForCmd, Version.VersionWithBuildInfo):
+        def __init__(
+            self, rosetta_supplier: Callable[[], str], splitter_expr: str = ": "
+        ):
+            super().__init__(rosetta_supplier)
+            self.splitter_expr = splitter_expr
+
+        @override
+        def build_options(self) -> dict[str, str]:
+            if self.rosetta is None:
+                self.rosetta = self.rosetta_supplier()
+            if self._cache.build_options is not None:
+                return self._cache.build_options
+            if not self.rosetta.splitlines()[1:]:
+                errmsg = "Unable to populate build_options as possibly --build-options switch wasn't used."
+                raise GitExitingException(
+                    errmsg, exit_code=ERR_INVALID_USAGE
+                ) from ValueError(errmsg)
+
+            self._cache.build_options = {}
+            for b_str in self.rosetta.splitlines()[1:]:
+                if self.splitter_expr in b_str:
+                    b_k, b_v = b_str.split(self.splitter_expr)
+                    self._cache.build_options[b_k] = b_v
+            return self._cache.build_options
 
 
 class LsTreeCommand(LsTree, GitSubcmdCommand, Protocol):
@@ -525,9 +583,9 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
         another_supplied_env = subprocess_run_kwargs.pop("env", None)
         if another_supplied_env:
             envs_vars.update(another_supplied_env)
-        cwd = subprocess_run_kwargs.pop("cwd", None) or self.root_dir
-        capture_output = subprocess_run_kwargs.pop("capture_output", None) or True
-        check = subprocess_run_kwargs.pop("check", None) or True
+        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)
         # Run the git command
         result = self.underlying_git.runner.run_git_command(
             main_cmd_args,

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/src/gitbolt/git_subprocess/impl/simple.py

@@ -9,10 +9,11 @@ from __future__ import annotations
 
 from abc import ABC
 from pathlib import Path
-from typing import override
+from typing import override, Literal, overload
 
 from vt.utils.commons.commons.op import RootDirOp
 
+from gitbolt.base import Version
 from gitbolt.add import AddArgsValidator
 from gitbolt.git_subprocess import (
     GitCommand,
@@ -43,22 +44,36 @@ class GitSubcmdCommandImpl(GitSubcmdCommand, ABC):
 
 
 class VersionCommandImpl(VersionCommand, GitSubcmdCommandImpl):
+    @overload
+    def version(self) -> Version.VersionInfo: ...
+
+    @overload
+    def version(self, build_options: Literal[True]) -> Version.VersionWithBuildInfo: ...
+
     @override
-    def version(self, build_options: bool = False) -> str:
+    def version(
+        self, build_options: Literal[True, False] = False
+    ) -> Version.VersionInfo | Version.VersionWithBuildInfo:
         self._require_valid_args(build_options)
         main_cmd_args = self.underlying_git.build_main_cmd_args()
         sub_cmd_args = [VERSION_CMD]
         env_vars = self.underlying_git.build_git_envs()
         if build_options:
             sub_cmd_args.append("--build-options")
-        return self.underlying_git.runner.run_git_command(
-            main_cmd_args,
-            sub_cmd_args,
-            check=True,
-            text=True,
-            capture_output=True,
-            env=env_vars,
-        ).stdout.strip()
+
+        def rosetta_supplier():
+            return self.underlying_git.runner.run_git_command(
+                main_cmd_args,
+                sub_cmd_args,
+                check=True,
+                text=True,
+                capture_output=True,
+                env=env_vars,
+            ).stdout.strip()
+
+        if build_options:
+            return VersionCommand.VersionWithBuildInfoForCmd(rosetta_supplier)
+        return VersionCommand.VersionInfoForCmd(rosetta_supplier)
 
     def clone(self) -> "VersionCommandImpl":
         return VersionCommandImpl(self.underlying_git)
@@ -196,9 +211,21 @@ class SimpleGitCommand(GitCommand, RootDirOp):
         return add_subcmd
 
     @override
-    def clone(self) -> "SimpleGitCommand":
+    def clone(self) -> SimpleGitCommand:
         # region obtain class instance
-        cloned = SimpleGitCommand(
+        cloned = self._subclass_clone()
+        # endregion
+        # region clone protected members
+        cloned._main_cmd_opts = self._main_cmd_opts
+        cloned._env_vars = self._env_vars
+        # endregion
+        return cloned
+
+    def _subclass_clone(self) -> SimpleGitCommand:
+        """
+        :returns: clone as defined by the subclass.
+        """
+        return SimpleGitCommand(
             self.root_dir,
             self.runner,
             version_subcmd=self.version_subcmd,
@@ -206,12 +233,6 @@ class SimpleGitCommand(GitCommand, RootDirOp):
             add_subcmd=self.add_subcmd,
             subcmd_unchecked=self.subcmd_unchecked,
         )
-        # endregion
-        # region clone protected members
-        cloned._main_cmd_opts = self._main_cmd_opts
-        cloned._env_vars = self._env_vars
-        # endregion
-        return cloned
 
     @override
     @property
@@ -223,3 +244,73 @@ class SimpleGitCommand(GitCommand, RootDirOp):
         subcmd_unchecked = self._subcmd_unchecked.clone()
         subcmd_unchecked._set_underlying_git(self)
         return subcmd_unchecked
+
+
+class CLISimpleGitCommand(SimpleGitCommand):
+    """
+    A simple git command that can run using CLI params.
+    """
+
+    def __init__(
+        self,
+        git_root_dir: Path = Path.cwd(),
+        runner: GitCommandRunner = SimpleGitCR(),
+        *,
+        opts: list[str] | None = None,
+        envs: dict[str, str] | None = None,
+        prefer_cli: bool = False,
+        version_subcmd: VersionCommand | None = None,
+        ls_tree_subcmd: LsTreeCommand | None = None,
+        add_subcmd: AddCommand | None = None,
+        subcmd_unchecked: UncheckedSubcmd | None = None,
+    ):
+        """
+        :param opts: main git cli options.
+        :param envs: main git cli env vars.
+        :param prefer_cli: cli opts and envs will be given priority over programmatically set opts and envs. Setting
+            this param to ``True`` will make cli opts and envs appear later in the opts and envs strings which will
+            make them override previously programmatically set opts and envs.
+        """
+        super().__init__(
+            git_root_dir,
+            runner,
+            version_subcmd=version_subcmd,
+            ls_tree_subcmd=ls_tree_subcmd,
+            add_subcmd=add_subcmd,
+            subcmd_unchecked=subcmd_unchecked,
+        )
+        self._main_cmd_cli_opts = opts
+        self._cmd_cli_envs = envs
+        self.prefer_cli = prefer_cli
+
+    @override
+    def build_main_cmd_args(self) -> list[str]:
+        if self._main_cmd_cli_opts:
+            if self.prefer_cli:
+                return super().build_main_cmd_args() + self._main_cmd_cli_opts
+            else:
+                return self._main_cmd_cli_opts + super().build_main_cmd_args()
+        return super().build_main_cmd_args()
+
+    @override
+    def build_git_envs(self) -> dict[str, str]:
+        if self._cmd_cli_envs:
+            if self.prefer_cli:
+                return super().build_git_envs() | self._cmd_cli_envs
+            else:
+                return self._cmd_cli_envs | super().build_git_envs()
+        return super().build_git_envs()
+
+    @override
+    def _subclass_clone(self) -> CLISimpleGitCommand:
+        return CLISimpleGitCommand(
+            self.root_dir,
+            self.runner,
+            opts=self._main_cmd_cli_opts,
+            envs=self._cmd_cli_envs,
+            prefer_cli=self.prefer_cli,
+            version_subcmd=self.version_subcmd,
+            ls_tree_subcmd=self.ls_tree_subcmd,
+            add_subcmd=self.add_subcmd,
+            subcmd_unchecked=self.subcmd_unchecked,
+        )

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/src/gitbolt/git_subprocess/ls_tree.py

@@ -108,9 +108,25 @@ class IndividuallyOverridableLTCAB(LsTreeCLIArgsBuilder):
         * With --format::
 
         >>> builder.build("HEAD", format_="%(objectname)")
-        ['ls-tree', '--format=%(objectname)', 'HEAD']
+        ['ls-tree', '--format', '%(objectname)', 'HEAD']
+
         >>> builder.build("HEAD", format_="")
-        ['ls-tree', '--format=', 'HEAD']
+        ['ls-tree', '--format', '', 'HEAD']
+
+        >>> builder.build("HEAD", format_="''")
+        ['ls-tree', '--format', "''", 'HEAD']
+
+        >>> builder.build("HEAD", format_='""')
+        ['ls-tree', '--format', '""', 'HEAD']
+
+        >>> builder.build("HEAD", format_="%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)")
+        ['ls-tree', '--format', '%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)', 'HEAD']
+
+        >>> builder.build("HEAD", format_="'%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)'")
+        ['ls-tree', '--format', "'%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)'", 'HEAD']
+
+        >>> builder.build("HEAD", format_='"%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)"')
+        ['ls-tree', '--format', '"%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)"', 'HEAD']
 
         * With paths::
 
@@ -140,7 +156,7 @@ class IndividuallyOverridableLTCAB(LsTreeCLIArgsBuilder):
         ...     format_="%(objectname) %(path)",
         ...     path=["dir1", "dir2/file.txt"]
         ... )
-        ['ls-tree', '-d', '-r', '-t', '-l', '-z', '--name-only', '--object-only', '--full-name', '--full-tree', '--abbrev=10', '--format=%(objectname) %(path)', 'HEAD', 'dir1', 'dir2/file.txt']
+        ['ls-tree', '-d', '-r', '-t', '-l', '-z', '--name-only', '--object-only', '--full-name', '--full-tree', '--abbrev=10', '--format', '%(objectname) %(path)', 'HEAD', 'dir1', 'dir2/file.txt']
 
         * Empty or falsy values, mostly will fail at validation::
 
@@ -344,11 +360,17 @@ class IndividuallyOverridableLTCAB(LsTreeCLIArgsBuilder):
         >>> IndividuallyOverridableLTCAB().format_arg(None)
         []
         >>> IndividuallyOverridableLTCAB().format_arg('%(objectname)')
-        ['--format=%(objectname)']
-        >>> IndividuallyOverridableLTCAB().format_arg('')
-        ['--format=']
-        """
-        return [f"--format={_format}"] if _format is not None else []
+        ['--format', '%(objectname)']
+        >>> IndividuallyOverridableLTCAB().format_arg('""')
+        ['--format', '""']
+        >>> IndividuallyOverridableLTCAB().format_arg("''")
+        ['--format', "''"]
+        >>> IndividuallyOverridableLTCAB().format_arg('%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)')
+        ['--format', '%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)']
+        >>> IndividuallyOverridableLTCAB().format_arg('"%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)"')
+        ['--format', '"%(objectmode) %(objecttype) %(objectname) %(objectsize:padded)%x09%(path)"']
+        """
+        return ["--format", _format] if _format is not None else []
 
     def tree_ish_arg(self, tree_ish: str) -> list[str]:
         """

{gitbolt-0.0.0.dev10 → gitbolt-0.0.0.dev12}/src/gitbolt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev10
+Version: 0.0.0.dev12
 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>
@@ -26,8 +26,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: vt-err-hndlr>=0.0.0dev3
-Requires-Dist: vt-commons>=0.0.1.dev4
+Requires-Dist: vt-err-hndlr>=0.0.0dev5
+Requires-Dist: vt-commons>=0.0.1.dev9
 Provides-Extra: pygit2
 Requires-Dist: pygit2; extra == "pygit2"
 Provides-Extra: test
@@ -64,6 +64,7 @@ Dynamic: license-file
 * 🧪 **Terminal Functions:** Git subcommands are terminal functions.
 * 🧼 **Idiomatic Python:** Write commands in idiomatic Python at compile-time and be confident they’ll execute smoothly at runtime.
 * 🎀 **Add-ons:** Special features provided to ease programming with git. These can be added if required.
+* 💻 **CLI-cmd:** Take commands from cli and run in `gitbolt`.
 
 ---
 
@@ -340,6 +341,24 @@ git.subcmd_unchecked.run(['--version']) # run the version option for git.
 git.subcmd_unchecked.run(['version']) # run the version subcommand.
 ```
 
+#### 💻 Run commands received from CLI
+
+Introduced in `0.0.0dev11` 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
+actually running them. An example:
+
+```python
+from gitbolt.git_subprocess.impl.simple import CLISimpleGitCommand
+
+opts = ["--no-pager", "--namespace", "n1"]   # options received from outside your program.
+envs = dict(GIT_AUTHOR_NAME="ss")   # env-vars received form outside your program.
+git = CLISimpleGitCommand(opts=opts, envs=envs)
+
+# these can later be overridden
+git = git.git_opts_override(namespace="n2")
+```
 
 ---
 

gitbolt-0.0.0.dev12/src/gitbolt.egg-info/requires.txt

@@ -0,0 +1,8 @@
+vt-err-hndlr>=0.0.0dev5
+vt-commons>=0.0.1.dev9
+
+[pygit2]
+pygit2
+
+[test]
+pytest

gitbolt-0.0.0.dev10/src/gitbolt.egg-info/requires.txt

@@ -1,8 +0,0 @@
-vt-err-hndlr>=0.0.0dev3
-vt-commons>=0.0.1.dev4
-
-[pygit2]
-pygit2
-
-[test]
-pytest