batchfetch 1.2.7__tar.gz → 1.2.9__tar.gz

{batchfetch-1.2.7 → batchfetch-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batchfetch
-Version: 1.2.7
+Version: 1.2.9
 Summary: Efficiently clone and pull multiple Git repositories.
 Home-page: https://github.com/jamescherti/batchfetch
 Author: James Cherti
@@ -73,22 +73,33 @@ Execute the `batchfetch` command from the same directory as `batchfetch.yml` to
 Here are the various options that `batchfetch` provides, along with descriptions of their usage:
 
 ```
-usage: batchfetch [--option]
+usage: batchfetch [--option] [TARGET]
 
 Efficiently clone/pull multiple Git repositories in parallel.
 
+positional arguments:
+  target                This is a target path that batchfetch is supposed to
+                        handle. When no target is specified, execute the tasks
+                        of all target paths defined in the batchfetch.yml list
+                        of tasks.
+
 options:
   -h, --help            show this help message and exit
   -f FILE, --file FILE  Specify the batchfetch YAML file (default:
                         './batchfetch.yaml').
   -C DIRECTORY, --directory DIRECTORY
                         Change the working directory before reading the
-                        batchfetch.yaml file. If not specified, the directory is
-                        set to the parent directory of the batchfetch.yaml file.
+                        batchfetch.yaml file. If not specified, the directory
+                        is set to the parent directory of the batchfetch.yaml
+                        file.
   -j JOBS, --jobs JOBS  Run up to N parallel processes (default: 5).
-                        Alternatively, the BATCHFETCH_JOBS environment variable
-                        can be used to configure the number of jobs.
+                        Alternatively, the BATCHFETCH_JOBS environment
+                        variable can be used to configure the number of jobs.
   -v, --verbose         Enable verbose mode.
+  -u, --check-untracked
+                        Abort if untracked files or directories exist.
+                        Alternatively, set the BATCHFETCH_CHECK_UNTRACKED=1
+                        environment variable to enable this check.
 ```
 
 ## Features
@@ -160,6 +171,31 @@ tasks:
     exec_after: ["sh", "-c", "echo exec_after_task"]
 ```
 
+### How to make batchfetch handle only one path?
+
+To configure `batchfetch` to handle a specific path, you can define your tasks in a `batchfetch.yml` file and pass the desired path as an argument to the `batchfetch` command.
+
+#### Example `batchfetch.yml` file:
+
+In the following example, the `easysession` task clones two Git repositories:
+```yaml
+---
+tasks:
+  - git: https://github.com/jamescherti/easysession.el
+    path: easysession
+
+  - git: https://github.com/jamescherti/outline-indent.el
+    revision: "1.1.0"
+```
+
+To make `batchfetch` clone only `easysession`, pass its path as an argument:
+
+```bash
+batchfetch easysession
+```
+
+This will execute only the task corresponding to the `easysession` path, skipping all others in the `batchfetch.yml` file.
+
 ## License
 
 Copyright (C) 2024 [James Cherti](https://www.jamescherti.com)

{batchfetch-1.2.7 → batchfetch-1.2.9}/README.md

@@ -53,22 +53,33 @@ Execute the `batchfetch` command from the same directory as `batchfetch.yml` to
 Here are the various options that `batchfetch` provides, along with descriptions of their usage:
 
 ```
-usage: batchfetch [--option]
+usage: batchfetch [--option] [TARGET]
 
 Efficiently clone/pull multiple Git repositories in parallel.
 
+positional arguments:
+  target                This is a target path that batchfetch is supposed to
+                        handle. When no target is specified, execute the tasks
+                        of all target paths defined in the batchfetch.yml list
+                        of tasks.
+
 options:
   -h, --help            show this help message and exit
   -f FILE, --file FILE  Specify the batchfetch YAML file (default:
                         './batchfetch.yaml').
   -C DIRECTORY, --directory DIRECTORY
                         Change the working directory before reading the
-                        batchfetch.yaml file. If not specified, the directory is
-                        set to the parent directory of the batchfetch.yaml file.
+                        batchfetch.yaml file. If not specified, the directory
+                        is set to the parent directory of the batchfetch.yaml
+                        file.
   -j JOBS, --jobs JOBS  Run up to N parallel processes (default: 5).
-                        Alternatively, the BATCHFETCH_JOBS environment variable
-                        can be used to configure the number of jobs.
+                        Alternatively, the BATCHFETCH_JOBS environment
+                        variable can be used to configure the number of jobs.
   -v, --verbose         Enable verbose mode.
+  -u, --check-untracked
+                        Abort if untracked files or directories exist.
+                        Alternatively, set the BATCHFETCH_CHECK_UNTRACKED=1
+                        environment variable to enable this check.
 ```
 
 ## Features
@@ -140,6 +151,31 @@ tasks:
     exec_after: ["sh", "-c", "echo exec_after_task"]
 ```
 
+### How to make batchfetch handle only one path?
+
+To configure `batchfetch` to handle a specific path, you can define your tasks in a `batchfetch.yml` file and pass the desired path as an argument to the `batchfetch` command.
+
+#### Example `batchfetch.yml` file:
+
+In the following example, the `easysession` task clones two Git repositories:
+```yaml
+---
+tasks:
+  - git: https://github.com/jamescherti/easysession.el
+    path: easysession
+
+  - git: https://github.com/jamescherti/outline-indent.el
+    revision: "1.1.0"
+```
+
+To make `batchfetch` clone only `easysession`, pass its path as an argument:
+
+```bash
+batchfetch easysession
+```
+
+This will execute only the task corresponding to the `easysession` path, skipping all others in the `batchfetch.yml` file.
+
 ## License
 
 Copyright (C) 2024 [James Cherti](https://www.jamescherti.com)

{batchfetch-1.2.7 → batchfetch-1.2.9}/batchfetch/batchfetch_base.py

@@ -138,7 +138,7 @@ class TaskBatchFetch(TaskBase):
         # Mark values as initialized
         self._values_initialized = True
 
-    def _run(self, *args, **kwargs):
+    def _pre_run(self, *args, **kwargs):
         stdout = run_indent_str(*args, **kwargs)
 
         if not stdout.endswith("\n"):
@@ -151,7 +151,7 @@ class TaskBatchFetch(TaskBase):
         if self["delete"] or not cmd:
             return
 
-        self._run(cmd, cwd=str(cwd), env=self.env, spaces=self.indent)
+        self._pre_run(cmd, cwd=str(cwd), env=self.env, spaces=self.indent)
 
     def _run_post_exec(self, cwd: os.PathLike = Path(".")):
         self._initialize_data()
@@ -159,7 +159,7 @@ class TaskBatchFetch(TaskBase):
         if not cmd or self["delete"] or not self.is_changed():
             return
 
-        self._run(cmd, cwd=str(cwd), env=self.env, spaces=self.indent)
+        self._pre_run(cmd, cwd=str(cwd), env=self.env, spaces=self.indent)
 
     def is_changed(self) -> bool:
         self._initialize_data()

{batchfetch-1.2.7 → batchfetch-1.2.9}/batchfetch/batchfetch_cli.py

@@ -25,7 +25,7 @@ import subprocess
 import sys
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
-from typing import Any, Dict, Set, Union
+from typing import Any, Dict, List, Set, Union
 
 import colorama
 import yaml  # type: ignore
@@ -40,15 +40,16 @@ from .batchfetch_git import BatchFetchGit
 class BatchFetchCli:
     """Command-line-interface that downloads."""
 
-    def __init__(self, max_workers: int, verbose: bool, check_untracked: bool):
+    def __init__(self, max_workers: int, verbose: bool, check_untracked: bool,
+                 targets: List[str]):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        self.targets = {Path(item).absolute() for item in targets}
         self.cfg: dict = {}
-        self.folder = Path(".")
         self.check_untracked = check_untracked
         self.tracked_paths: Dict[Path, Set[str]] = {}
         self.ignore_untracked_paths: Set[Path] = set()
         self.verbose = verbose
         self.max_workers = max_workers
-        self._logger = logging.getLogger(self.__class__.__name__)
         self.dirs_relative_to_batchfetch: Set[str] = set()
 
         # Plugin
@@ -183,10 +184,31 @@ class BatchFetchCli:
             self.dirs_relative_to_batchfetch = set()
 
             all_tasks = self.cfg["tasks"]
+
+            # Check targets
+            if self.targets:
+                targets_executed = set()
+                for task in all_tasks:
+                    full_path = Path(task["path"]).absolute()
+                    if full_path not in self.targets:
+                        continue
+
+                    targets_executed.add(full_path)
+
+                targets_not_found = self.targets - targets_executed
+                if targets_not_found:
+                    err_str = \
+                        f"Error: Target(s) not found: "
+                    err_str += ", ".join([str(item)
+                                         for item in targets_not_found])
+                    print(f"Error: {err_str}", file=sys.stderr)
+                    sys.exit(1)
+
             for task in all_tasks:
+                full_path = Path(task["path"]).absolute()
+
                 self.dirs_relative_to_batchfetch.add(str(task["path"]))
                 if not task["delete"]:
-                    full_path = Path(task["path"]).absolute()
                     base_path = full_path.parent
                     try:
                         self.tracked_paths[base_path]
@@ -195,6 +217,8 @@ class BatchFetchCli:
 
                     self.tracked_paths[base_path].add(full_path.name)
 
+                if self.targets and full_path not in self.targets:
+                    continue
                 threads.append(executor_update.submit(task.update))
 
             for future in as_completed(threads):
@@ -292,9 +316,16 @@ def parse_args():
         check_untracked = bool(check_untracked)
 
     desc = "Efficiently clone/pull multiple Git repositories in parallel."
-    usage = "%(prog)s [--option]"
+    usage = "%(prog)s [--option] [TARGET]"
     parser = argparse.ArgumentParser(description=desc, usage=usage)
 
+    parser.add_argument(
+        "targets", metavar="target", type=str, nargs="*",
+        help=("This is a target path that batchfetch is supposed to handle. "
+              "When no target is specified, execute the tasks of all target "
+              "paths defined in the batchfetch.yml list of tasks."),
+    )
+
     parser.add_argument("-f",
                         "--file",
                         default=None,
@@ -350,31 +381,6 @@ def parse_args():
     return args
 
 
-def run_batchfetch_procedure(file: Path,
-                             directory: Union[None, Path],
-                             verbose: bool,
-                             jobs: int,
-                             check_untracked: bool) -> int:
-    errno = 0
-    batchfetch_cli = BatchFetchCli(verbose=verbose,
-                                   max_workers=int(jobs),
-                                   check_untracked=check_untracked)
-    os.chdir(directory)
-    batchfetch_cli.load(file)
-
-    try:
-        if not batchfetch_cli.run_tasks():
-            errno = 1
-    except KeyboardInterrupt:
-        print("Interrupted.", file=sys.stderr)
-        errno = 1
-    except BatchFetchError as err:
-        print(f"Error: {err}.", file=sys.stderr)
-        errno = 1
-
-    return errno
-
-
 def command_line_interface():
     """Command line interface."""
     try:
@@ -388,7 +394,7 @@ def command_line_interface():
 
         args = parse_args()
         done = []
-        file = Path(args.file)
+        file = Path(args.file).absolute()
         file_resolved = file.absolute()
         if not file_resolved:
             print(f"Error: cannot resolve the path {file}",
@@ -405,12 +411,23 @@ def command_line_interface():
             print(f"[CHECK UNTRACKED] {args.check_untracked}")
             print()
 
-        errno |= run_batchfetch_procedure(file=file,
-                                          directory=args.directory,
-                                          verbose=args.verbose,
-                                          jobs=args.jobs,
-                                          check_untracked=args.check_untracked)
+        os.chdir(args.directory)
+        batchfetch_cli = BatchFetchCli(verbose=args.verbose,
+                                       max_workers=args.jobs,
+                                       check_untracked=args.check_untracked,
+                                       targets=args.targets)
+        batchfetch_cli.load(file)
+
+        try:
+            if not batchfetch_cli.run_tasks():
+                errno = 1
+        except KeyboardInterrupt:
+            print("Interrupted.", file=sys.stderr)
+            errno = 1
+        except BatchFetchError as err:
+            print(f"Error: {err}.", file=sys.stderr)
+            errno = 1
 
         sys.exit(errno)
     except BrokenPipeError:
-        pass
+        sys.exit(1)

{batchfetch-1.2.7 → batchfetch-1.2.9}/batchfetch/batchfetch_git.py

@@ -18,13 +18,13 @@
 #
 "Clone and update Git repositories."
 
-
+import os
 import posixpath
 import shutil
 import subprocess
 import textwrap
 from pathlib import Path
-from typing import List, Union
+from typing import List, Tuple, Union
 
 from schema import Optional
 
@@ -59,7 +59,6 @@ class BatchFetchGit(TaskBatchFetch):
             # Local options
             self.main_key: str,
             Optional("revision"): str,
-            Optional("reference"): str,
 
             # Same as global options
             Optional("git_clone_args"): [str],
@@ -104,11 +103,6 @@ class BatchFetchGit(TaskBatchFetch):
         """Clone or update a Git repository."""
         super().update()
 
-        # Backward compatibility
-        if "reference" in self._item_values \
-                and "revision" not in self._item_values:
-            self._item_values["revision"] = "reference"
-
         is_clone = False
         if not self.git_local_dir.exists():
             is_clone = True
@@ -141,7 +135,18 @@ class BatchFetchGit(TaskBatchFetch):
                 self._repo_fix_remote_origin()
                 self._run_pre_exec(cwd=self.git_local_dir)
 
-                # self._repo_reset()
+                if not self["revision"]:
+                    self.values["revision"] = self._run_get_firstline(
+                        "git symbolic-ref refs/remotes/origin/HEAD"
+                    ).split("/")[-1]
+                    if not self["revision"]:
+                        raise BatchFetchError(
+                            "Unable to determine the default origin branch"
+                        )
+
+                    self.add_output(self.indent_spaces +
+                                    f"[INFO] Update revision to: '" +
+                                    self["revision"] + "'\n")
 
                 git_fetch_done = self._repo_fetch()
 
@@ -152,9 +157,6 @@ class BatchFetchGit(TaskBatchFetch):
                 if git_fetch_done:
                     git_merge_done = self._git_merge()
 
-                # if (git_fetch_done and git_merge_done) or git_branch_changed:
-                #     self._repo_update_submodules()
-
                 if self.get_changed():
                     self._run_post_exec(cwd=self.git_local_dir)
         except BatchFetchError as err:
@@ -173,6 +175,31 @@ class BatchFetchGit(TaskBatchFetch):
 
         return self.values
 
+    def _run_get_firstline(self, *args, **kwargs):
+        stdout, _ = self._run(*args, **kwargs)
+        try:
+            return stdout[0]
+        except IndexError:
+            return ""
+
+    def _run(self, cmd: Union[List[str], str],
+             cwd: Union[None, os.PathLike] = None,
+             env: Union[None, dict] = None,
+             **kwargs) -> Tuple[List[str], List[str]]:
+        """
+        Executes a command and returns stdout and stderr as separate lists of
+        strings.
+
+        :param cmd: Command to be executed. Can be a list or a string.
+        :param kwargs: Additional keyword arguments for Popen.
+        :return: Tuple containing two lists: stdout lines and stderr lines.
+        """
+        if not cwd:
+            cwd = self.git_local_dir
+        if not env:
+            env = self.env
+        return run_simple(cmd=cmd, env=env, cwd=cwd, **kwargs)
+
     def _git_ref(self, cwd: Union[None, Path] = None) -> str:
         """Get the commit revision of HEAD.
 
@@ -180,7 +207,7 @@ class BatchFetchGit(TaskBatchFetch):
         """
         cmd = ["git", "show-ref", "--head", "--verify", "HEAD"]
         try:
-            stdout, _ = run_simple(cmd, cwd=cwd, env=self.env)
+            stdout, _ = self._run(cmd, cwd=cwd)
             output = stdout[0].split(" ")[0]
         except IndexError:
             return ""
@@ -189,11 +216,7 @@ class BatchFetchGit(TaskBatchFetch):
     def _update_current_branch_name(self):
         try:
             # This returns the branch name
-            stdout, _ = run_simple(
-                ["git", "symbolic-ref", "--short", "HEAD"],
-                env=self.env,
-                cwd=self.git_local_dir,
-            )
+            stdout, _ = self._run(["git", "symbolic-ref", "--short", "HEAD"])
             self.current_branch = stdout[0]
             self.is_branch = True
         except (IndexError, subprocess.CalledProcessError):
@@ -230,58 +253,46 @@ class BatchFetchGit(TaskBatchFetch):
 
     def _repo_clone(self):
         git_clone_args = self["git_clone_args"]
-        git_clone_args += ["--recurse-submodules"]
+        # git_clone_args += ["--recurse-submodules"]
 
         cmd = ["git", "clone"] + git_clone_args + \
             [self[self.main_key], str(self.git_local_dir)]
-        self._run(cmd, env=self.env)
+        self._run(cmd, cwd=".")
         self.set_changed(True)
 
-    def _repo_reset(self):
-        # Remove local changes
-        cmd = ["git", "reset", "--hard", "HEAD"]
-        self._run(cmd, cwd=str(self.git_local_dir), env=self.env)
-
     def _repo_fetch(self):
         # Merge
         do_git_fetch = self["git_pull"]
-        if not self["revision"]:
+        do_git_fetch = False
+        commit_ref = None
+
+        try:
+            # Check if the revision such as
+            stdout, _ = self._run(["git", "cat-file", "-e",
+                                   self["revision"]])
+        except subprocess.CalledProcessError:
             do_git_fetch = True
-            self.add_output(self.indent_spaces
-                            + "[INFO] Git fetch origin reason: "
-                            + "No 'revision:' specified\n")
-        else:
-            do_git_fetch = False
-            commit_ref = None
+            self.add_output(
+                self.indent_spaces
+                + "[INFO] Git fetch origin reason: "
+                + f"The revision does not exist: {self['revision']}"
+                + "\n")
 
+        # The revision exists, but if it a branch, git pull anyway
+        if not do_git_fetch:
             try:
-                # Check if the revision such as
-                # 0560fe21d1173b2221fd8c600fab818f7eecbad4 exist
-                commit_ref = self._git_rev_parse_verify(self["revision"])[0]
-                commit_ref = commit_ref.strip()
-            except GitRevisionDoesNotExist:
-                do_git_fetch = True
+                # Check if the branch is a tag or a branch
+                cmd = ["git", "show-ref", "--verify", "--quiet",
+                       f"refs/heads/{self['revision']}"]
+                self._run(cmd)
                 self.add_output(
                     self.indent_spaces
                     + "[INFO] Git fetch origin reason: "
-                    + f"The revision does not exist: {self['revision']}"
+                    + f"{self['revision']} is a branch, not a tag"
                     + "\n")
-
-            # The revision exists, but if it a branch, git pull anyway
-            if not do_git_fetch:
-                try:
-                    # Check if the branch is a tag or a branch
-                    cmd = ["git", "show-ref", "--verify", "--quiet",
-                           f"refs/heads/{self['revision']}"]
-                    run_simple(cmd, env=self.env, cwd=self.git_local_dir)
-                    self.add_output(
-                        self.indent_spaces
-                        + "[INFO] Git fetch origin reason: "
-                        + f"{self['revision']} is a branch, not a tag"
-                        + "\n")
-                    do_git_fetch = True
-                except subprocess.CalledProcessError:
-                    pass
+                do_git_fetch = True
+            except subprocess.CalledProcessError:
+                pass
 
         if not do_git_fetch:
             self.add_output(self.indent_spaces + "[INFO] git fetch ignored\n")
@@ -300,8 +311,7 @@ class BatchFetchGit(TaskBatchFetch):
             # TODO: only merge when difference from upstream
             commit_ref_head = self._git_ref(cwd=self.git_local_dir)
             self._run(["git", "merge", "--ff-only",
-                       f"origin/{self.current_branch}"],
-                      cwd=str(self.git_local_dir), env=self.env)
+                       f"origin/{self.current_branch}"])
             git_ref_after_merge = self._git_ref(cwd=self.git_local_dir)
             if commit_ref_head != git_ref_after_merge:
                 git_merge = True
@@ -309,19 +319,15 @@ class BatchFetchGit(TaskBatchFetch):
                 self._run(["git", "log",
                            '--pretty=format:"%h %ad %s [%cn]"',
                            "--decorate", "--date=short",
-                           f"{commit_ref_head}..{git_ref_after_merge}"],
-                          cwd=str(self.git_local_dir),
-                          env=self.env)
+                           f"{commit_ref_head}..{git_ref_after_merge}"])
 
         return git_merge
 
     def _git_get_remote_url(self, remote_name: str = "origin") -> str:
         origin_url = ""
         try:
-            stdout, _ = run_simple(["git", "config",
-                                    f"remote.{remote_name}.url"],
-                                   env=self.env,
-                                   cwd=self.git_local_dir)
+            stdout, _ = self._run(["git", "config",
+                                   f"remote.{remote_name}.url"])
             origin_url = stdout[0]
         except (subprocess.CalledProcessError, IndexError) as err:
             raise GitRemoteError(
@@ -333,18 +339,13 @@ class BatchFetchGit(TaskBatchFetch):
                             remote_name: str = "origin") -> str:
         origin_url = ""
         try:
-            run_simple(["git", "remote", "remove", remote_name],
-                       env=self.env, cwd=self.git_local_dir)
+            self._run(["git", "remote", "remove", remote_name])
         except subprocess.CalledProcessError:
             # Ignore when it cannot be removed when it does not exist
             pass
 
         try:
-            stdout, _ = run_simple(
-                ["git", "remote", "add", remote_name, url],
-                env=self.env,
-                cwd=self.git_local_dir,
-            )
+            stdout, _ = self._run(["git", "remote", "add", remote_name, url])
             origin_url = stdout[0]
         except (subprocess.CalledProcessError, IndexError) as err:
             raise GitRemoteError(
@@ -355,9 +356,8 @@ class BatchFetchGit(TaskBatchFetch):
     def _git_is_local_branch(self, branch: str) -> bool:
         "Return True if it is a local branch that exists."
         try:
-            stdout, _ = run_simple(["git", "rev-parse", "--symbolic-full-name",
-                                    branch], env=self.env,
-                                   cwd=self.git_local_dir)
+            stdout, _ = self._run(["git", "rev-parse", "--symbolic-full-name",
+                                   branch])
             if not stdout:
                 return False
 
@@ -374,9 +374,7 @@ class BatchFetchGit(TaskBatchFetch):
         stdout: List[str] = []
         error = False
         try:
-            stdout, _ = run_simple(["git", "rev-parse", "--verify", revision],
-                                   env=self.env,
-                                   cwd=self.git_local_dir)
+            stdout, _ = self._run(["git", "rev-parse", "--verify", revision])
             if not stdout:
                 error = True
         except subprocess.CalledProcessError:
@@ -394,11 +392,7 @@ class BatchFetchGit(TaskBatchFetch):
         if self["revision"]:
             # We also need tags because sometimes, a branch
             # returns a different commit revision
-            git_tags, _ = run_simple(
-                ["git", "tag", "--points-at", "HEAD"],
-                env=self.env,
-                cwd=self.git_local_dir,
-            )
+            git_tags, _ = self._run(["git", "tag", "--points-at", "HEAD"])
 
             # Also check the commit revision in case
             # branch is a commit revision instead of a tag
@@ -410,8 +404,8 @@ class BatchFetchGit(TaskBatchFetch):
             except GitRevisionDoesNotExist:
                 # Check if the commit ref exists
                 try:
-                    git_ref_branch = self._git_rev_parse_verify(self["revision"])[
-                        0]
+                    git_ref_branch = \
+                        self._git_rev_parse_verify(self["revision"])[0]
                 except GitRevisionDoesNotExist as err:
                     raise BatchFetchError(f"The branch '{self['revision']}' "
                                           "does not exist.") from err
@@ -419,8 +413,7 @@ class BatchFetchGit(TaskBatchFetch):
             if git_ref_after_merge != git_ref_branch and \
                     self["revision"] not in git_tags:
                 # Update the branch
-                self._run(["git", "checkout"] + [self["revision"]],
-                          cwd=str(self.git_local_dir), env=self.env)
+                self._run(["git", "checkout"] + [self["revision"]])
                 self.add_output(self.indent_spaces
                                 + "[INFO] Branch changed to "
                                 + self["revision"] + "\n")
@@ -436,26 +429,9 @@ class BatchFetchGit(TaskBatchFetch):
         # Fetch
         if not self._git_fetch_origin_done:
             cmd = ["git", "fetch", "origin"]
-            self._run(cmd, cwd=str(self.git_local_dir), env=self.env)
+            self._run(cmd)
             self._git_fetch_origin_done = True
 
-    # def _repo_update_submodules(self):
-    #     # This parameter instructs Git to initiate the update
-    #     # process for submodules:
-    #     # 1. Git fetches the commits specified in the parent
-    #     # repository's configuration for each submodule.
-    #     # 2. Updates are based solely on the commit pointers stored
-    #     # within the parent repository's submodule configuration.
-    #     # 3. It does not directly consult the upstream repositories
-    #     # of the submodules.
-    #     # 4. Submodules are updated to reflect the exact commits
-    #     # revision in the parent repository's configuration,
-    #     # potentially lagging behind the latest changes made in the
-    #     # upstream repositories.
-    #     if self.git_local_dir.joinpath(".gitmodules").is_file():
-    #         cmd = ["git", "submodule", "update", "--recursive"]
-    #         self._run(cmd, cwd=str(self.git_local_dir), env=self.env)
-
     def _repo_fix_remote_origin(self):
         correct_origin_url = self[self.main_key]
         update_remote_origin = False
@@ -489,8 +465,7 @@ class BatchFetchGit(TaskBatchFetch):
 
                     cmd = ["git", "branch",
                            f"--set-upstream-to=origin/{self.current_branch}"]
-                    _, _ = run_simple(cmd, env=self.env,
-                                      cwd=self.git_local_dir)
+                    _, _ = self._run(cmd)
                     # TODO: handle errors
                 except subprocess.CalledProcessError as err:
                     raise BatchFetchError(str(err)) from err

{batchfetch-1.2.7 → batchfetch-1.2.9}/batchfetch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batchfetch
-Version: 1.2.7
+Version: 1.2.9
 Summary: Efficiently clone and pull multiple Git repositories.
 Home-page: https://github.com/jamescherti/batchfetch
 Author: James Cherti
@@ -73,22 +73,33 @@ Execute the `batchfetch` command from the same directory as `batchfetch.yml` to
 Here are the various options that `batchfetch` provides, along with descriptions of their usage:
 
 ```
-usage: batchfetch [--option]
+usage: batchfetch [--option] [TARGET]
 
 Efficiently clone/pull multiple Git repositories in parallel.
 
+positional arguments:
+  target                This is a target path that batchfetch is supposed to
+                        handle. When no target is specified, execute the tasks
+                        of all target paths defined in the batchfetch.yml list
+                        of tasks.
+
 options:
   -h, --help            show this help message and exit
   -f FILE, --file FILE  Specify the batchfetch YAML file (default:
                         './batchfetch.yaml').
   -C DIRECTORY, --directory DIRECTORY
                         Change the working directory before reading the
-                        batchfetch.yaml file. If not specified, the directory is
-                        set to the parent directory of the batchfetch.yaml file.
+                        batchfetch.yaml file. If not specified, the directory
+                        is set to the parent directory of the batchfetch.yaml
+                        file.
   -j JOBS, --jobs JOBS  Run up to N parallel processes (default: 5).
-                        Alternatively, the BATCHFETCH_JOBS environment variable
-                        can be used to configure the number of jobs.
+                        Alternatively, the BATCHFETCH_JOBS environment
+                        variable can be used to configure the number of jobs.
   -v, --verbose         Enable verbose mode.
+  -u, --check-untracked
+                        Abort if untracked files or directories exist.
+                        Alternatively, set the BATCHFETCH_CHECK_UNTRACKED=1
+                        environment variable to enable this check.
 ```
 
 ## Features
@@ -160,6 +171,31 @@ tasks:
     exec_after: ["sh", "-c", "echo exec_after_task"]
 ```
 
+### How to make batchfetch handle only one path?
+
+To configure `batchfetch` to handle a specific path, you can define your tasks in a `batchfetch.yml` file and pass the desired path as an argument to the `batchfetch` command.
+
+#### Example `batchfetch.yml` file:
+
+In the following example, the `easysession` task clones two Git repositories:
+```yaml
+---
+tasks:
+  - git: https://github.com/jamescherti/easysession.el
+    path: easysession
+
+  - git: https://github.com/jamescherti/outline-indent.el
+    revision: "1.1.0"
+```
+
+To make `batchfetch` clone only `easysession`, pass its path as an argument:
+
+```bash
+batchfetch easysession
+```
+
+This will execute only the task corresponding to the `easysession` path, skipping all others in the `batchfetch.yml` file.
+
 ## License
 
 Copyright (C) 2024 [James Cherti](https://www.jamescherti.com)

{batchfetch-1.2.7 → batchfetch-1.2.9}/setup.py

@@ -22,7 +22,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="batchfetch",
-    version="1.2.7",
+    version="1.2.9",
     packages=find_packages(),
     description="Efficiently clone and pull multiple Git repositories.",
     license="GPLv3",