git-rexec 1.0.0__tar.gz → 1.0.2__tar.gz

git_rexec-1.0.2/.gitignore

@@ -0,0 +1,6 @@
+/coverage.json
+/build
+/dist
+/*.egg-info
+*.pyc
+*/__pycache__

{git_rexec-1.0.0 → git_rexec-1.0.2}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: git-rexec
-Version: 1.0.0
+Version: 1.0.2
 Summary: Locate Git repositories and execute commands against them in parallel.
 Author: James Cherti
-License: GPL-3.0-or-later
+License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/jamescherti/git-rexec
 Keywords: git,parallel,executor,automation
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Console
 Classifier: Topic :: Software Development :: Version Control :: Git
@@ -19,7 +18,7 @@ Requires-Dist: setproctitle; extra == "extras"
 
 # git-rexec: Find Git Repositories and Execute Commands Against Them, either Sequentially or in Parallel
 
-The [git-rexec](https://github.com/jamescherti/git-rexec/) command-line tool that recursively locates Git repositories within a directory and executes commands against them, either sequentially or in parallel.
+The [git-rexec](https://github.com/jamescherti/git-rexec/) command-line tool recursively locates Git repositories within a directory and executes commands against them, either sequentially or in parallel.
 
 Here are examples demonstrating how to use `git-rexec`:
 - Execute `git status -s` across all discovered Git repositories (found by searching recursively under the current working directory) in parallel (`-p` or `--parallel`):
@@ -32,6 +31,12 @@ Here are examples demonstrating how to use `git-rexec`:
   git-rexec -j 5 --parallel -- git fetch
   ```
 
+
+- Include sub-repositories (e.g., Git worktrees and submodules) alongside standard Git repositories during discovery (`-s` or `--include-sub-repos`), and execute `git status` against them:
+  ```bash
+  git-rexec -s -p -- git status
+  ```
+
 - Target a specific base directory (`~/projects`) using the `-C` flag to recursively discover repositories within it, while explicitly excluding a specific subfolder (`~/projects/archive`). This example executes `git status -s` in parallel for all discovered repositories except those within the excluded path:
   ```bash
   git-rexec -C ~/projects --exclude-dir ~/projects/archive --parallel -- git status -s
@@ -42,15 +47,21 @@ Here are examples demonstrating how to use `git-rexec`:
   git-rexec --if-exec 'sh -c "test -f README.md"' --parallel -- wc -l README.md
   ```
 
+- Print the paths of all discovered Git repositories:
+  ```bash
+  git-rexec --print
+  ```
+
 If this helps your workflow, please support the project by **⭐ starring git-rexec on GitHub** and sharing it on your website, blog, Mastodon, Reddit, X, LinkedIn, or other social media platforms to help more Git users discover its benefits.
 
 ## Features
 
 - Recursively discover Git repositories starting from a specified root directory.
+- Optional flag to include sub-repositories (e.g., Git worktrees and submodules) in the execution target list.
 - Execute shell commands across multiple repositories in parallel using worker threads.
 - Filter target repositories based on the exit code of a conditional check (`--if-exec`).
 - Exclude specific directories from the search path.
-- Optional: Can leverage `fd` for fast directory traversal if installed, falling back to standard Python path resolution otherwise.
+- Export discovered repository paths for integration with other shell tools (using `--print` or `--print0`).
 
 ## Installation
 
@@ -67,7 +78,7 @@ sudo cp git-rexec /usr/local/bin/
 Install the package directly from the Git repository using `pip`:
 
 ```bash
-pip install --user git+https://github.com/jamescherti/git-rexec
+pip install --user git-rexec
 ```
 
 ## Dependencies
@@ -75,7 +86,6 @@ pip install --user git+https://github.com/jamescherti/git-rexec
 ### System Dependencies
 
 - `git`: Required for repository validation and execution.
-- `fd` (Optional): Highly recommended for faster repository discovery.
 
 ### Python Dependencies (Optional)
 
@@ -86,14 +96,12 @@ You can install the optional Python dependencies via pip:
 
 ```bash
 pip install colorama setproctitle
-
 ```
 
 ## Usage
 
 ```bash
 git-rexec [OPTIONS] [exec_cmd ...]
-
 ```
 
 *(Assuming the `git-rexec` script is executable and in your PATH.)*
@@ -109,6 +117,7 @@ git-rexec [OPTIONS] [exec_cmd ...]
 - `-p, --parallel`: Execute the command in parallel using threads.
 - `-i, --if-exec <command>`: Execute the main command only if this check command returns an exit code of `0`.
 - `-j, --jobs <int>`: The maximum number of concurrent workers/processors to use for parallel execution. Defaults to the number of CPU cores available.
+- `-s, --include-sub-repos`: Include sub-repositories (e.g., Git worktrees and submodules) in the search target list.
 - `-h, --help`: Show the help message and exit.
 - `-q, --quiet`: Quiet mode. Suppresses the informational tracking headers (`[EXEC]` and `[EXEC-P]`) that prefix execution output. In sequential mode, it hides the `[EXEC]` repository delimiter line entirely; in parallel mode (`-p`), it strips the yellow `[EXEC-P]` header track and removes the four-space indentation, printing only the raw, unindented stdout and stderr streams. This flag has no effect when no execution command is supplied, allowing discovered repository paths to print normally.
 

{git_rexec-1.0.0 → git_rexec-1.0.2}/README.md

@@ -1,6 +1,6 @@
 # git-rexec: Find Git Repositories and Execute Commands Against Them, either Sequentially or in Parallel
 
-The [git-rexec](https://github.com/jamescherti/git-rexec/) command-line tool that recursively locates Git repositories within a directory and executes commands against them, either sequentially or in parallel.
+The [git-rexec](https://github.com/jamescherti/git-rexec/) command-line tool recursively locates Git repositories within a directory and executes commands against them, either sequentially or in parallel.
 
 Here are examples demonstrating how to use `git-rexec`:
 - Execute `git status -s` across all discovered Git repositories (found by searching recursively under the current working directory) in parallel (`-p` or `--parallel`):
@@ -13,6 +13,12 @@ Here are examples demonstrating how to use `git-rexec`:
   git-rexec -j 5 --parallel -- git fetch
   ```
 
+
+- Include sub-repositories (e.g., Git worktrees and submodules) alongside standard Git repositories during discovery (`-s` or `--include-sub-repos`), and execute `git status` against them:
+  ```bash
+  git-rexec -s -p -- git status
+  ```
+
 - Target a specific base directory (`~/projects`) using the `-C` flag to recursively discover repositories within it, while explicitly excluding a specific subfolder (`~/projects/archive`). This example executes `git status -s` in parallel for all discovered repositories except those within the excluded path:
   ```bash
   git-rexec -C ~/projects --exclude-dir ~/projects/archive --parallel -- git status -s
@@ -23,15 +29,21 @@ Here are examples demonstrating how to use `git-rexec`:
   git-rexec --if-exec 'sh -c "test -f README.md"' --parallel -- wc -l README.md
   ```
 
+- Print the paths of all discovered Git repositories:
+  ```bash
+  git-rexec --print
+  ```
+
 If this helps your workflow, please support the project by **⭐ starring git-rexec on GitHub** and sharing it on your website, blog, Mastodon, Reddit, X, LinkedIn, or other social media platforms to help more Git users discover its benefits.
 
 ## Features
 
 - Recursively discover Git repositories starting from a specified root directory.
+- Optional flag to include sub-repositories (e.g., Git worktrees and submodules) in the execution target list.
 - Execute shell commands across multiple repositories in parallel using worker threads.
 - Filter target repositories based on the exit code of a conditional check (`--if-exec`).
 - Exclude specific directories from the search path.
-- Optional: Can leverage `fd` for fast directory traversal if installed, falling back to standard Python path resolution otherwise.
+- Export discovered repository paths for integration with other shell tools (using `--print` or `--print0`).
 
 ## Installation
 
@@ -48,7 +60,7 @@ sudo cp git-rexec /usr/local/bin/
 Install the package directly from the Git repository using `pip`:
 
 ```bash
-pip install --user git+https://github.com/jamescherti/git-rexec
+pip install --user git-rexec
 ```
 
 ## Dependencies
@@ -56,7 +68,6 @@ pip install --user git+https://github.com/jamescherti/git-rexec
 ### System Dependencies
 
 - `git`: Required for repository validation and execution.
-- `fd` (Optional): Highly recommended for faster repository discovery.
 
 ### Python Dependencies (Optional)
 
@@ -67,14 +78,12 @@ You can install the optional Python dependencies via pip:
 
 ```bash
 pip install colorama setproctitle
-
 ```
 
 ## Usage
 
 ```bash
 git-rexec [OPTIONS] [exec_cmd ...]
-
 ```
 
 *(Assuming the `git-rexec` script is executable and in your PATH.)*
@@ -90,6 +99,7 @@ git-rexec [OPTIONS] [exec_cmd ...]
 - `-p, --parallel`: Execute the command in parallel using threads.
 - `-i, --if-exec <command>`: Execute the main command only if this check command returns an exit code of `0`.
 - `-j, --jobs <int>`: The maximum number of concurrent workers/processors to use for parallel execution. Defaults to the number of CPU cores available.
+- `-s, --include-sub-repos`: Include sub-repositories (e.g., Git worktrees and submodules) in the search target list.
 - `-h, --help`: Show the help message and exit.
 - `-q, --quiet`: Quiet mode. Suppresses the informational tracking headers (`[EXEC]` and `[EXEC-P]`) that prefix execution output. In sequential mode, it hides the `[EXEC]` repository delimiter line entirely; in parallel mode (`-p`), it strips the yellow `[EXEC-P]` header track and removes the four-space indentation, printing only the raw, unindented stdout and stderr streams. This flag has no effect when no execution command is supplied, allowing discovered repository paths to print normally.
 

{git_rexec-1.0.0 → git_rexec-1.0.2}/git-rexec

@@ -6,6 +6,7 @@
 #
 # Author: James Cherti
 # URL: https://github.com/jamescherti/git-rexec
+# Version: 1.0.2
 #
 # Copyright (C) 2019-2026 James Cherti
 #
@@ -100,51 +101,95 @@ def git_toplevel(repo_path: Path) -> Optional[Path]:
         return None
 
 
-def git_fd_find_repo(path: Path, max_workers: int) -> set[Path]:
-    """Find all Git repositories in 'path' using fd.
+def git_py_find_repo(root: Path) -> tuple[set[Path], set[Path]]:
+    """Recursively find all Git repositories under the root path using Python.
+
+    :param root: Directory to search under.
+    :return: A tuple containing standard repository paths and sub-repository
+    paths.
+    """
+    repos: set[Path] = set()
+    sub_repos: set[Path] = set()
+
+    for dirpath, dirnames, filenames in os.walk(root):
+        if ".git" in dirnames:
+            repos.add(Path(dirpath).absolute())
+        elif ".git" in filenames:
+            sub_repos.add(Path(dirpath).absolute())
+        else:
+            continue
 
-    :param path: The root directory to search for Git repositories.
-    :param max_workers: Maximum number of threads for fd.
-    :return: set of paths to Git repositories.
+        # Clear dirnames to prevent os.walk from descending into
+        # subdirectories
+        dirnames.clear()
+
+    return repos, sub_repos
+
+
+def get_sub_repos(repo_path: Path) -> set[Path]:
+    """Extract worktrees and submodules from a Git repository.
+
+    :param repo_path: The path to the standard repository.
+    :return: A set of absolute paths to worktrees and submodules.
     """
-    path_str: str = str(path)
+    sub_repos: set[Path] = set()
+
+    # Discover worktrees
+    # pylint: disable=too-many-try-statements
     try:
-        # Use fd to find .git directories efficiently
-        proc: subprocess.CompletedProcess[str] = subprocess.run(
-            [
-                'fd', '--type', 'd', '--hidden',
-                '--no-ignore', '^\\.git$',
-                '--absolute-path',
-                '--threads', str(max_workers),
-                path_str
-            ],
+        wt_proc: subprocess.CompletedProcess[str] = subprocess.run(
+            ["git", "-C", str(repo_path), "worktree", "list", "--porcelain"],
             capture_output=True,
             text=True,
-            check=False
+            check=True,
         )
-    except FileNotFoundError as err:
-        print(f"Error: {err}", file=sys.stderr)
-        sys.exit(1)
 
-    # Use a set comprehension to remove duplicates and normalize paths
-    # efficiently
-    return {
-        Path(git_dir).parent
-        for git_dir in proc.stdout.splitlines()
-    }
+        current_wt: Optional[Path] = None
+        is_bare: bool = False
 
+        for line in wt_proc.stdout.splitlines():
+            line = line.strip()
 
-def git_py_find_repo(root: Path) -> set[Path]:
-    """Recursively find all Git repositories under the root path using Python.
+            # Git porcelain separates blocks with a blank line
+            if not line:
+                if current_wt and not is_bare \
+                        and current_wt != repo_path.resolve():
+                    sub_repos.add(current_wt)
+                # Reset state for the next block
+                current_wt = None
+                is_bare = False
+                continue
 
-    :param root: Directory to search under.
-    :return: set of paths to Git repositories.
-    """
-    return {
-        git_dir.absolute().parent
-        for git_dir in root.rglob(".git")
-        if git_dir.is_dir()
-    }
+            if line.startswith("worktree "):
+                current_wt = Path(line[9:]).resolve()
+            elif line == "bare":
+                is_bare = True
+
+        # Process the final block in case the output lacks a trailing newline
+        if current_wt and not is_bare and current_wt != repo_path.resolve():
+            sub_repos.add(current_wt)
+
+    except subprocess.CalledProcessError:
+        pass
+
+    # Discover submodules
+    try:
+        sm_proc: subprocess.CompletedProcess[str] = subprocess.run(
+            ["git", "-C", str(repo_path),
+             "submodule", "foreach", "--quiet", "pwd"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        for line in sm_proc.stdout.splitlines():
+            sm_path: Path = Path(line.strip()).resolve()
+            sub_repos.add(sm_path)
+
+    except subprocess.CalledProcessError:
+        pass
+
+    return sub_repos
 
 
 def run_command_get_output(repo_path: Path, cmd_list: list[str],
@@ -242,24 +287,39 @@ def process_repo(repo_path: Path, exec_parallel_cmd: Optional[list[str]],
 
 def discover_repos(directory: Path,
                    max_workers: int,
-                   exclude_dirs: list[str]) -> set[Path]:
-    """Discover Git repositories starting from 'directory' and apply exclusions.
+                   exclude_dirs: list[str],
+                   include_sub_repos: bool) -> set[Path]:
+    """Discover Git repositories starting from directory and apply exclusions.
 
     :param directory: The root directory for search.
     :param max_workers: Maximum number of threads/workers.
     :param exclude_dirs: Directories to exclude.
+    :param include_sub_repos: Whether to include sub-repositories.
     :return: A set of repository root paths.
     """
     repos: set[Path] = set()
+    worktrees: set[Path] = set()
 
     # Discover all repositories
     toplevel: Optional[Path] = git_toplevel(directory)
     if toplevel:
         repos = {toplevel}
-    elif shutil.which("fd"):
-        repos = git_fd_find_repo(directory, max_workers)
     else:
-        repos = git_py_find_repo(directory)
+        repos, worktrees = git_py_find_repo(directory)
+
+    # Extract and append sub-repositories concurrently if requested
+    if include_sub_repos:
+        sub_repos: set[Path] = set()
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures: list[Future[set[Path]]] = [
+                executor.submit(get_sub_repos, repo)
+                for repo in repos | worktrees
+            ]
+            for future in as_completed(futures):
+                result: set[Path] = future.result()
+                sub_repos.update(result)
+
+        repos.update(sub_repos)
 
     # Filter out excluded directories
     if not exclude_dirs:
@@ -303,7 +363,7 @@ def execute_parallel_tasks(
                 result: Optional[RepoContext] = future.result()
                 if result:
                     results.append(result)
-            except Exception as exc:
+            except (OSError, ValueError) as exc:
                 print(f"Error processing repository {repo_path}: {exc}",
                       file=sys.stderr)
 
@@ -357,6 +417,25 @@ def parse_args() -> argparse.Namespace:
               "([EXEC] and [EXEC-P]) that prefix execution output."),
         default=False
     )
+    parser.add_argument(
+        "-s", "--include-sub-repos",
+        action="store_true",
+        help="Include sub-repositories (e.g., Git worktrees and submodules)",
+        default=False
+    )
+    parser.add_argument(
+        "--print",
+        action="store_true",
+        help="Print the paths (only when no command is provided)",
+        default=False
+    )
+    parser.add_argument(
+        "--print0",
+        action="store_true",
+        help=("Separate the paths with a null character (only when no "
+              "command is provided)"),
+        default=False
+    )
     parser.add_argument(
         "exec_cmd",
         type=str,
@@ -418,6 +497,11 @@ def main() -> None:
 
     args: argparse.Namespace = parse_args()
 
+    # Check for empty action
+    if not args.exec_cmd and not args.print and not args.print0:
+        print("Nothing to do.", file=sys.stderr)
+        sys.exit(0)
+
     # Verify that the execution command exists
     if args.exec_cmd and not shutil.which(args.exec_cmd[0]):
         print(
@@ -428,7 +512,8 @@ def main() -> None:
     # Discover Repositories
     repos: set[Path] = discover_repos(args.directory.absolute(),
                                       args.max_workers,
-                                      args.exclude_dir)
+                                      args.exclude_dir,
+                                      args.include_sub_repos)
 
     # setup background command list if needed
     exec_parallel_cmd: Optional[list[str]] = None
@@ -499,7 +584,10 @@ def main() -> None:
 
         # If no commands were run, just list the repo
         if not args.exec_cmd:
-            print(repo_path)
+            if args.print0:
+                print(repo_path, end="\0")
+            elif args.print:
+                print(repo_path)
 
     # Final Error Summary
     sys.exit(print_error_summary(execution_errors))

{git_rexec-1.0.0 → git_rexec-1.0.2}/git_rexec.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: git-rexec
-Version: 1.0.0
+Version: 1.0.2
 Summary: Locate Git repositories and execute commands against them in parallel.
 Author: James Cherti
-License: GPL-3.0-or-later
+License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/jamescherti/git-rexec
 Keywords: git,parallel,executor,automation
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Console
 Classifier: Topic :: Software Development :: Version Control :: Git
@@ -19,7 +18,7 @@ Requires-Dist: setproctitle; extra == "extras"
 
 # git-rexec: Find Git Repositories and Execute Commands Against Them, either Sequentially or in Parallel
 
-The [git-rexec](https://github.com/jamescherti/git-rexec/) command-line tool that recursively locates Git repositories within a directory and executes commands against them, either sequentially or in parallel.
+The [git-rexec](https://github.com/jamescherti/git-rexec/) command-line tool recursively locates Git repositories within a directory and executes commands against them, either sequentially or in parallel.
 
 Here are examples demonstrating how to use `git-rexec`:
 - Execute `git status -s` across all discovered Git repositories (found by searching recursively under the current working directory) in parallel (`-p` or `--parallel`):
@@ -32,6 +31,12 @@ Here are examples demonstrating how to use `git-rexec`:
   git-rexec -j 5 --parallel -- git fetch
   ```
 
+
+- Include sub-repositories (e.g., Git worktrees and submodules) alongside standard Git repositories during discovery (`-s` or `--include-sub-repos`), and execute `git status` against them:
+  ```bash
+  git-rexec -s -p -- git status
+  ```
+
 - Target a specific base directory (`~/projects`) using the `-C` flag to recursively discover repositories within it, while explicitly excluding a specific subfolder (`~/projects/archive`). This example executes `git status -s` in parallel for all discovered repositories except those within the excluded path:
   ```bash
   git-rexec -C ~/projects --exclude-dir ~/projects/archive --parallel -- git status -s
@@ -42,15 +47,21 @@ Here are examples demonstrating how to use `git-rexec`:
   git-rexec --if-exec 'sh -c "test -f README.md"' --parallel -- wc -l README.md
   ```
 
+- Print the paths of all discovered Git repositories:
+  ```bash
+  git-rexec --print
+  ```
+
 If this helps your workflow, please support the project by **⭐ starring git-rexec on GitHub** and sharing it on your website, blog, Mastodon, Reddit, X, LinkedIn, or other social media platforms to help more Git users discover its benefits.
 
 ## Features
 
 - Recursively discover Git repositories starting from a specified root directory.
+- Optional flag to include sub-repositories (e.g., Git worktrees and submodules) in the execution target list.
 - Execute shell commands across multiple repositories in parallel using worker threads.
 - Filter target repositories based on the exit code of a conditional check (`--if-exec`).
 - Exclude specific directories from the search path.
-- Optional: Can leverage `fd` for fast directory traversal if installed, falling back to standard Python path resolution otherwise.
+- Export discovered repository paths for integration with other shell tools (using `--print` or `--print0`).
 
 ## Installation
 
@@ -67,7 +78,7 @@ sudo cp git-rexec /usr/local/bin/
 Install the package directly from the Git repository using `pip`:
 
 ```bash
-pip install --user git+https://github.com/jamescherti/git-rexec
+pip install --user git-rexec
 ```
 
 ## Dependencies
@@ -75,7 +86,6 @@ pip install --user git+https://github.com/jamescherti/git-rexec
 ### System Dependencies
 
 - `git`: Required for repository validation and execution.
-- `fd` (Optional): Highly recommended for faster repository discovery.
 
 ### Python Dependencies (Optional)
 
@@ -86,14 +96,12 @@ You can install the optional Python dependencies via pip:
 
 ```bash
 pip install colorama setproctitle
-
 ```
 
 ## Usage
 
 ```bash
 git-rexec [OPTIONS] [exec_cmd ...]
-
 ```
 
 *(Assuming the `git-rexec` script is executable and in your PATH.)*
@@ -109,6 +117,7 @@ git-rexec [OPTIONS] [exec_cmd ...]
 - `-p, --parallel`: Execute the command in parallel using threads.
 - `-i, --if-exec <command>`: Execute the main command only if this check command returns an exit code of `0`.
 - `-j, --jobs <int>`: The maximum number of concurrent workers/processors to use for parallel execution. Defaults to the number of CPU cores available.
+- `-s, --include-sub-repos`: Include sub-repositories (e.g., Git worktrees and submodules) in the search target list.
 - `-h, --help`: Show the help message and exit.
 - `-q, --quiet`: Quiet mode. Suppresses the informational tracking headers (`[EXEC]` and `[EXEC-P]`) that prefix execution output. In sequential mode, it hides the `[EXEC]` repository delimiter line entirely; in parallel mode (`-p`), it strips the yellow `[EXEC-P]` header track and removes the four-space indentation, printing only the raw, unindented stdout and stderr streams. This flag has no effect when no execution command is supplied, allowing discovered repository paths to print normally.
 

{git_rexec-1.0.0 → git_rexec-1.0.2}/git_rexec.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+.gitignore
 README.md
 git-rexec
 pyproject.toml

{git_rexec-1.0.0 → git_rexec-1.0.2}/pyproject.toml

@@ -4,18 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "git-rexec"
-version = "1.0.0"
+version = "1.0.2"
 description = "Locate Git repositories and execute commands against them in parallel."
 readme = "README.md"
 requires-python = ">=3.9"
-license = {text = "GPL-3.0-or-later"}
+license = "GPL-3.0-or-later"
 authors = [
   {name = "James Cherti"}
 ]
 keywords = ["git", "parallel", "executor", "automation"]
 classifiers = [
   "Programming Language :: Python :: 3",
-  "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
   "Operating System :: OS Independent",
   "Environment :: Console",
   "Topic :: Software Development :: Version Control :: Git"