gitbolt 0.0.0.dev11__tar.gz → 0.0.0.dev13__tar.gz

{gitbolt-0.0.0.dev11 → gitbolt-0.0.0.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev11
+Version: 0.0.0.dev13
 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>

{gitbolt-0.0.0.dev11 → gitbolt-0.0.0.dev13}/pyproject.toml

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

{gitbolt-0.0.0.dev11 → gitbolt-0.0.0.dev13}/src/gitbolt/__init__.py

@@ -34,7 +34,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.dev11 → gitbolt-0.0.0.dev13}/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.dev11 → gitbolt-0.0.0.dev13}/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,
@@ -37,7 +40,7 @@ class GitCommand(Git, ABC):
         """
         self.runner: GitCommandRunner = runner
         self._main_cmd_opts: GitOpts = {}
-        self._env_vars: GitEnvVars = {}
+        self._env_vars: GitEnvVars | None = None
 
     # region build_main_cmd_args
     def build_main_cmd_args(self) -> list[str]:
@@ -213,7 +216,7 @@ class GitCommand(Git, ABC):
     # endregion
 
     # region build_git_envs
-    def build_git_envs(self) -> dict[str, str]:
+    def build_git_envs(self) -> dict[str, str] | None:
         """
         Terminal operation to build and return effective Git environment variables
         from the merged ``GitEnvVars`` object.
@@ -223,41 +226,43 @@ class GitCommand(Git, ABC):
 
         :return: A cleaned and normalized GitEnvVars dict suitable for use in subprocesses.
         """
-        env: dict[str, str] = {}
-        for key, val in self._env_vars.items():
-            if not_none_not_unset(val):
-                env[key] = str(val)
-        return env
+        if self._env_vars is None:
+            return None
+        else:
+            env: dict[str, str] = {}
+            for key, val in self._env_vars.items():
+                if not_none_not_unset(val):
+                    env[key] = str(val)
+            return env
 
     @override
     def git_envs_override(self, **overrides: Unpack[GitEnvVars]) -> Self:
         _git_cmd = self.clone()
-        _env_vars = merge_git_envs(overrides, self._env_vars)
+        if self._env_vars:
+            _env_vars = merge_git_envs(overrides, self._env_vars)
+        else:
+            _env_vars = overrides
         _git_cmd._env_vars = _env_vars
         return _git_cmd
 
     # 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 +329,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):
@@ -524,10 +588,11 @@ class UncheckedSubcmd(GitSubcmdCommand, RootDirOp, Protocol):
         envs_vars = self.underlying_git.build_git_envs()
         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
+            if envs_vars is not None:
+                envs_vars.update(another_supplied_env)
+        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.dev11 → gitbolt-0.0.0.dev13}/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)
@@ -251,7 +266,8 @@ class CLISimpleGitCommand(SimpleGitCommand):
     ):
         """
         :param opts: main git cli options.
-        :param envs: main git cli env vars.
+        :param envs: main git cli env vars. Not supplying any env vars (default behavior: ``None``) simply supplies all
+            the env vars to the underlying runner.
         :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.
@@ -278,13 +294,13 @@ class CLISimpleGitCommand(SimpleGitCommand):
         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()
+    def build_git_envs(self) -> dict[str, str] | None:
+        if self._cmd_cli_envs is None:
+            return super().build_git_envs()
+        if self.prefer_cli:
+            return (super().build_git_envs() or {}) | self._cmd_cli_envs
+        else:
+            return self._cmd_cli_envs | (super().build_git_envs() or {})
 
     @override
     def _subclass_clone(self) -> CLISimpleGitCommand:

{gitbolt-0.0.0.dev11 → gitbolt-0.0.0.dev13}/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.dev11 → gitbolt-0.0.0.dev13}/src/gitbolt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitbolt
-Version: 0.0.0.dev11
+Version: 0.0.0.dev13
 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>