Remote git registry

gto/cli.py

@@ -18,6 +18,7 @@
     VersionSort,
 )
 from gto.exceptions import GTOException, NotImplementedInGTO, WrongArgs
+from gto.index import RepoIndexManager
 from gto.ui import (
     EMOJI_FAIL,
     EMOJI_GTO,
@@ -857,10 +858,8 @@ def print_state(repo: str = option_repo):
 @gto_command(hidden=True)
 def print_index(repo: str = option_repo):
     """Technical cmd: Print repo index."""
-    index = gto.api._get_index(  # pylint: disable=protected-access
-        repo
-    ).artifact_centric_representation()
-    format_echo(index, "json")
+    with RepoIndexManager.from_repo(repo) as index:
+        format_echo(index.artifact_centric_representation(), "json")
 
 
 @gto_command(section=CommandGroups.enriching)

gto/git_utils.py

@@ -1,166 +1,84 @@
 import inspect
 import logging
 from contextlib import contextmanager
-from functools import wraps
 from tempfile import TemporaryDirectory
-from typing import Callable, Dict, List, Tuple
+from typing import Callable, Dict, List, Tuple, Union
 
 import git
+from git import Repo
 
-from gto.commit_message_generator import generate_empty_commit_message
+from gto.config import RegistryConfig
 from gto.constants import remote_git_repo_regex
 from gto.exceptions import GTOException, WrongArgs
 
 
-def clone_on_remote_repo(f: Callable):
-    @wraps(f)
-    def wrapped_f(*args, **kwargs):
-        kwargs = _turn_args_into_kwargs(f, args, kwargs)
+class RemoteRepoMixin:
+    @classmethod
+    def from_local_repo(cls, repo: Union[str, Repo], config: RegistryConfig = None):
+        raise NotImplementedError()
 
-        if isinstance(kwargs["repo"], str) and is_url_of_remote_repo(
-            repo=kwargs["repo"]
-        ):
+    @classmethod
+    @contextmanager
+    def from_repo(cls, repo: Union[str, Repo], config: RegistryConfig = None):
+        if isinstance(repo, str) and is_url_of_remote_repo(repo_path=repo):
             try:
-                with cloned_git_repo(repo=kwargs["repo"]) as tmp_dir:
-                    kwargs["repo"] = tmp_dir
-                    return f(**kwargs)
+                with cloned_git_repo(repo=repo) as tmp_dir:
+                    yield cls.from_local_repo(repo=tmp_dir, config=config)
             except (NotADirectoryError, PermissionError) as e:
                 raise e.__class__(
                     "Are you using windows with python < 3.9? "
                     "This may be the reason of this error: https://bugs.python.org/issue42796. "
                     "Consider upgrading python."
                 ) from e
-
-        return f(**kwargs)
-
-    return wrapped_f
-
-
-def set_push_on_remote_repo(f: Callable):
-    @wraps(f)
-    def wrapped_f(*args, **kwargs):
-        kwargs = _turn_args_into_kwargs(f, args, kwargs)
-
-        if isinstance(kwargs["repo"], str) and is_url_of_remote_repo(
-            repo=kwargs["repo"]
+        else:
+            yield cls.from_local_repo(repo=repo, config=config)
+
+    def _call_commit_push(
+        self, func, commit=False, commit_message=None, push=False, **kwargs
+    ):
+        if not (commit or push):
+            return func(**kwargs)
+        with stashed_changes(repo=self.repo, include_untracked=True) as (
+            stashed_tracked,
+            stashed_untracked,
         ):
-            kwargs["push"] = True
-
-        return f(**kwargs)
-
-    return wrapped_f
-
-
-def commit_produced_changes_on_commit(
-    message_generator: Callable[..., str] = generate_empty_commit_message
-):
-    """
-    The function `message_generator` can use any argument that the decorated function has.
-
-    Example: here we are using the argument b of the function f to generate the commit message
-
-        def create_message(b: str) -> str:
-            return "commit message with b={b}"
-
-        @commit_produced_changes_on_commit(message_generator=create_message)
-        def f(a: str, b: str, c: str):
-            ...
-
-    """
-
-    def generate_commit_message(**kwargs) -> str:
-        kwargs_for_message_generator = {
-            k: kwargs.get(k, None)
-            for k in inspect.getfullargspec(message_generator).args
-        }
-        return message_generator(**kwargs_for_message_generator)
-
-    def wrap(f: Callable):
-        @wraps(f)
-        def wrapped_f(*args, **kwargs):
-            kwargs = _turn_args_into_kwargs(f, args, kwargs)
-
-            if kwargs.get("commit", False) is True:
-                if "repo" in kwargs:
-                    with stashed_changes(
-                        repo_path=kwargs["repo"], include_untracked=True
-                    ) as (stashed_tracked, stashed_untracked):
-                        result = f(**kwargs)
-                        if are_files_in_repo_changed(
-                            repo_path=kwargs["repo"],
-                            files=stashed_tracked + stashed_untracked,
-                        ):
-                            _reset_repo_to_head(repo_path=kwargs["repo"])
-                            raise GTOException(
-                                msg="The command would have changed files that were not committed, "
-                                "automated committing is not possible.\n"
-                                "Suggested action: Commit the changes and re-run this command."
-                            )
-                        git_add_and_commit_all_changes(
-                            repo_path=kwargs["repo"],
-                            message=generate_commit_message(**kwargs),
-                        )
-                else:
-                    raise ValueError(
-                        "Function decorated with commit_produced_changes_on_commit was called with "
-                        "`commit=True` but `repo` was not provided."
-                        "Argument `repo` is necessary."
-                    )
-            else:
-                result = f(**kwargs)
-
-            return result
-
-        return wrapped_f
-
-    return wrap
-
-
-def push_on_push(f: Callable):
-    @wraps(f)
-    def wrapped_f(*args, **kwargs):
-        kwargs = _turn_args_into_kwargs(f, args, kwargs)
-        if kwargs.get("push", False) is True:
-            kwargs["commit"] = True
-            result = f(**kwargs)
-            if "repo" in kwargs:
-                try:
-                    git_push(repo_path=kwargs["repo"])
-                except Exception as e:
-                    raise GTOException(  # pylint: disable=raise-missing-from
-                        "It was not possible to run `git push`. "
-                        "The detailed error message was:\n"
-                        f"{str(e)}"
-                    )
-            else:
-                raise ValueError(
-                    "Function decorated with push_on_push was called with "
-                    "`push=True` but `repo` was not provided."
-                    "Argument `repo` is necessary."
+            result = func(**kwargs)
+            if are_files_in_repo_changed(
+                repo=self.repo,
+                files=stashed_tracked + stashed_untracked,
+            ):
+                _reset_repo_to_head(repo=self.repo)
+                raise GTOException(
+                    msg="The command would have changed files that were not committed, "
+                    "automated committing is not possible.\n"
+                    "Suggested action: Commit the changes and re-run this command."
                 )
-        else:
-            result = f(**kwargs)
+            git_add_and_commit_all_changes(
+                repo=self.repo,
+                message=commit_message,
+            )
+            if push:
+                git_push(repo=self.repo)
         return result
 
-    return wrapped_f
-
 
-def are_files_in_repo_changed(repo_path: str, files: List[str]) -> bool:
-    tracked, untracked = _get_repo_changed_tracked_and_untracked_files(
-        repo_path=repo_path
-    )
+def are_files_in_repo_changed(repo: Union[str, git.Repo], files: List[str]) -> bool:
+    tracked, untracked = _get_repo_changed_tracked_and_untracked_files(repo=repo)
     return (
         len(set(files).intersection(tracked)) > 0
         or len(set(files).intersection(untracked)) > 0
     )
 
 
-def is_url_of_remote_repo(repo: str) -> bool:
-    if remote_git_repo_regex.fullmatch(repo) is not None:
-        logging.debug("%s recognized as remote git repo", repo)
+def is_url_of_remote_repo(repo_path: str) -> bool:
+    if (
+        isinstance(repo_path, str)
+        and remote_git_repo_regex.fullmatch(repo_path) is not None
+    ):
+        logging.debug("%s recognized as remote git repo", repo_path)
         return True
 
-    logging.debug("%s NOT recognized as remote git repo", repo)
+    logging.debug("%s NOT recognized as remote git repo", repo_path)
     return False
 
 
@@ -180,19 +98,22 @@ def git_clone(repo: str, dir: str) -> None:
 
 
 def git_push_tag(
-    repo_path: str, tag_name: str, delete: bool = False, remote_name: str = "origin"
+    repo: Union[str, git.Repo],
+    tag_name: str,
+    delete: bool = False,
+    remote_name: str = "origin",
 ) -> None:
-    repo = git.Repo(path=repo_path)
+    repo = read_repo(repo)
     remote = repo.remote(name=remote_name)
     if not hasattr(remote, "url"):
         raise WrongArgs(
-            f"provided repo_path={repo_path} does not appear to have a remote to push to"
+            f"provided repo={repo} does not appear to have a remote to push to"
         )
     logging.debug(
         "push %s tag %s from directory %s to remote %s with url %s",
         "--delete" if delete else "",
         tag_name,
-        repo_path,
+        repo.working_dir,
         remote_name,
         remote.url,
     )
@@ -207,33 +128,33 @@ def git_push_tag(
         )
 
 
-def git_push(repo_path: str) -> None:
-    git.Repo(path=repo_path).git.push()
+def git_push(repo: Union[str, git.Repo]) -> None:
+    read_repo(repo).git.push()
 
 
-def git_add_and_commit_all_changes(repo_path: str, message: str) -> None:
-    repo = git.Repo(path=repo_path)
-    tracked, untracked = _get_repo_changed_tracked_and_untracked_files(
-        repo_path=repo_path
-    )
+def git_add_and_commit_all_changes(repo: Union[str, git.Repo], message: str) -> None:
+    repo = read_repo(repo)
+    tracked, untracked = _get_repo_changed_tracked_and_untracked_files(repo=repo)
     if len(tracked) + len(untracked) > 0:
         logging.debug("Adding to the index the untracked files %s", untracked)
         logging.debug("Add and commit changes to files %s", tracked + untracked)
         repo.index.add(items=tracked + untracked)
         repo.index.commit(message=message)
 
 
+def read_repo(repo: Union[str, git.Repo]) -> git.Repo:
+    return git.Repo(path=repo) if isinstance(repo, str) else repo
+
+
 @contextmanager
-def stashed_changes(repo_path: str, include_untracked: bool = False):
-    repo = git.Repo(path=repo_path)
+def stashed_changes(repo: Union[str, git.Repo], include_untracked: bool = False):
+    repo = read_repo(repo)
     if len(repo.refs) == 0:
         raise RuntimeError(
             "Cannot stash because repository has no ref. Please create a first commit."
         )
 
-    tracked, untracked = _get_repo_changed_tracked_and_untracked_files(
-        repo_path=repo_path
-    )
+    tracked, untracked = _get_repo_changed_tracked_and_untracked_files(repo=repo)
 
     stash_arguments = ["push"]
     if include_untracked:
@@ -250,16 +171,16 @@ def stashed_changes(repo_path: str, include_untracked: bool = False):
             repo.git.stash("pop")
 
 
-def _reset_repo_to_head(repo_path: str) -> None:
-    repo = git.Repo(path=repo_path)
+def _reset_repo_to_head(repo: Union[str, git.Repo]) -> None:
+    repo = read_repo(repo)
     repo.git.stash(["push", "--include-untracked"])
     repo.git.stash(["drop"])
 
 
 def _get_repo_changed_tracked_and_untracked_files(
-    repo_path: str,
+    repo: Union[str, git.Repo],
 ) -> Tuple[List[str], List[str]]:
-    repo = git.Repo(path=repo_path)
+    repo = read_repo(repo)
     return [item.a_path for item in repo.index.diff(None)], repo.untracked_files