Git + Python

import zipfile
import io
import os
from pathlib import Path


def archive_repo_mock(repo_path, output_path="repo_archive.zip"):
    """Create a zip archive of a repository directory (mock export)."""
    repo = Path(repo_path)
    if not repo.exists():
        raise FileNotFoundError(f"Repository not found: {repo}")

…

import json
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs

REPOSITORIES = {
    "alpha": {
        "default_branch": "main",
        "branches": ["main", "develop", "feature-x"],
        "protection_rules": {
            "main": {"required_reviews": 2, "dismiss_…

import re
from pathlib import Path


def format_patch_series_mbox(commits, output_path="series.mbox"):
    entries = []
    for idx, commit in enumerate(commits, start=1):
        subject = commit["subject"]
        author = commit["author"]
        email = commit["email"]
        date = commit["date"]
        body = …

import subprocess
import re
from datetime import datetime

def get_git_log(since_tag="HEAD~10", format_str="%s"):
    """Retrieve commit messages from git log."""
    try:
        result = subprocess.run(
            ["git", "log", f"--since={since_tag}", f"--format={format_str}"],
            capture_output=True,
   …

import subprocess
from unittest.mock import patch, MagicMock
from git import Repo
import os


def get_current_branch(repo_path="."):
    """Get the current branch name of a git repository."""
    repo = Repo(repo_path)
    return repo.active_branch.name


if __name__ == "__main__":
    # Mock subprocess to control the…

import re
from collections import Counter
from datetime import datetime

def parse_commits(log_text):
    """Parse git log lines and count commits by (weekday, hour)."""
    pattern = re.compile(r"^Date:\s+(.+)$")
    counts = Counter()
    
    for line in log_text.splitlines():
        match = pattern.match(line)
  …

from unittest.mock import patch, MagicMock

class GitCherryPicker:
    def __init__(self):
        self.applied_commits = []
    
    def cherry_pick(self, commit_hash, repo):
        try:
            result = repo.git.cherry_pick(commit_hash)
            self.applied_commits.append(commit_hash)
            return f"A…

import sys
import subprocess
from unittest.mock import patch

def run_hook(command: list[str]) -> int:
    with patch("subprocess.run") as mock_run:
        mock_run.return_value.returncode = 0
        mock_run.return_value.stdout = f"Mocked: {' '.join(command)}"
        result = subprocess.run(command, capture_output…

import git
from unittest.mock import Mock, patch

def stash_and_pop(repo):
    """Mock a stash operation and then pop it back."""
    repo.git.stash("save", "WIP: temp changes")
    stashed_output = repo.git.stash("list")
    
    # Simulate the stash was applied, then pop
    repo.git.stash("apply", "stash@{0}")
    …

import unittest
from unittest.mock import patch, mock_open


def apply_reverse_check(file_path, expected_patch):
    """
    Check if a patch can be reverse-applied by comparing file content
    with the expected patch's reverse result.
    """
    try:
        with open(file_path, "r") as f:
            content = f.r…

import re
from collections import namedtuple

Commit = namedtuple("Commit", ["hash", "subject"])

def generate_rebase_todo(commits, action="pick"):
    todo_lines = []
    for i, commit in enumerate(commits):
        if i == 0 and action == "reword":
            todo_lines.append(f"reword {commit.hash} {commit.subject…

import subprocess
from collections import Counter

def get_blame_authors(file_path):
    """Extract author names from git blame output using subprocess."""
    result = subprocess.run(
        ["git", "blame", "--line-porcelain", file_path],
        capture_output=True,
        text=True,
        check=True,
    )
   …