github2gerrit 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

github2gerrit/github_api.py

@@ -18,10 +18,7 @@ from __future__ import annotations
 
 import logging
 import os
-import random
 import re
-import time
-from collections.abc import Callable
 from collections.abc import Iterable
 from importlib import import_module
 from typing import Any
@@ -29,6 +26,9 @@ from typing import Protocol
 from typing import TypeVar
 from typing import cast
 
+from .external_api import ApiType
+from .external_api import external_api_call
+
 
 # Error message constants to comply with TRY003
 _MSG_PYGITHUB_REQUIRED = "PyGithub required"
@@ -111,7 +111,6 @@ __all__ = [
     "get_recent_change_ids_from_comments",
     "get_repo_from_env",
     "iter_open_pulls",
-    "time",
 ]
 
 log = logging.getLogger("github2gerrit.github_api")
@@ -124,74 +123,7 @@ def _getenv_str(name: str) -> str:
     return val.strip()
 
 
-def _backoff_delay(attempt: int, base: float = 0.5, cap: float = 6.0) -> float:
-    # Exponential backoff with jitter; cap prevents unbounded waits.
-    delay: float = float(min(base * (2 ** max(0, attempt - 1)), cap))
-    # Using random.uniform for jitter is appropriate here - we only need
-    # pseudorandom distribution to avoid thundering herd, not crypto security
-    jitter: float = float(random.uniform(0.0, delay / 2.0))  # noqa: S311
-    return float(delay + jitter)
-
-
-def _should_retry(exc: BaseException) -> bool:
-    # Retry on common transient conditions:
-    # - RateLimitExceededException
-    # - GithubException with 5xx codes
-    # - GithubException with 403 and rate limit hints
-    if isinstance(exc, _RATE_LIMIT_EXC | RateLimitExceededExceptionType):
-        return True
-    if isinstance(exc, _GITHUB_EXCEPTION | GithubExceptionType):
-        status = getattr(exc, "status", None)
-        if isinstance(status, int) and 500 <= status <= 599:
-            return True
-        data = getattr(exc, "data", "")
-        if status == 403 and isinstance(data, str | bytes):
-            try:
-                text = data.decode("utf-8") if isinstance(data, bytes) else data
-            except Exception:
-                text = str(data)
-            if "rate limit" in text.lower():
-                return True
-    return False
-
-
-def _retry_on_github(
-    attempts: int = 5,
-) -> Callable[[Callable[..., _T]], Callable[..., _T]]:
-    def decorator(func: Callable[..., _T]) -> Callable[..., _T]:
-        def wrapper(*args: Any, **kwargs: Any) -> _T:
-            last_exc: BaseException | None = None
-            for attempt in range(1, attempts + 1):
-                try:
-                    return func(*args, **kwargs)
-                except BaseException as exc:
-                    last_exc = exc
-                    if not _should_retry(exc) or attempt == attempts:
-                        log.debug(
-                            "GitHub call failed (no retry) at attempt %d: %s",
-                            attempt,
-                            exc,
-                        )
-                        raise
-                    delay = _backoff_delay(attempt)
-                    log.warning(
-                        "GitHub call failed (attempt %d): %s; retrying in %.2fs",
-                        attempt,
-                        exc,
-                        delay,
-                    )
-                    time.sleep(delay)
-            # Should not reach here, but raise if it does.
-            if last_exc is None:
-                raise RuntimeError("unreachable")
-            raise last_exc
-
-        return wrapper
-
-    return decorator
-
-
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "build_client")
 def build_client(token: str | None = None) -> GhClient:
     """Construct a PyGithub client from a token or environment.
 
@@ -209,7 +141,8 @@ def build_client(token: str | None = None) -> GhClient:
     base_url = _getenv_str("GITHUB_API_URL")
     if not base_url:
         server_url = _getenv_str("GITHUB_SERVER_URL")
-        if server_url:
+        # Only synthesize API URL for non-github.com servers (GHE instances)
+        if server_url and server_url.rstrip("/") != "https://github.com":
             base_url = server_url.rstrip("/") + "/api/v3"
     client_any: Any
     try:
@@ -234,7 +167,7 @@ def build_client(token: str | None = None) -> GhClient:
     return cast(GhClient, client_any)
 
 
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "get_repo_from_env")
 def get_repo_from_env(client: GhClient) -> GhRepository:
     """Return the repository object based on GITHUB_REPOSITORY."""
     full = _getenv_str("GITHUB_REPOSITORY")
@@ -244,7 +177,7 @@ def get_repo_from_env(client: GhClient) -> GhRepository:
     return repo
 
 
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "get_pull")
 def get_pull(repo: GhRepository, number: int) -> GhPullRequest:
     """Fetch a pull request by number."""
     pr = repo.get_pull(number)
@@ -266,14 +199,14 @@ def get_pr_title_body(pr: GhPullRequest) -> tuple[str, str]:
 _CHANGE_ID_RE: re.Pattern[str] = re.compile(r"Change-Id:\s*([A-Za-z0-9._-]+)")
 
 
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "get_pr_comments")
 def _get_issue(pr: GhPullRequest) -> GhIssue:
     """Return the issue object corresponding to a pull request."""
     issue = pr.as_issue()
     return issue
 
 
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "get_issue_from_pr")
 def get_recent_change_ids_from_comments(
     pr: GhPullRequest,
     *,
@@ -308,7 +241,7 @@ def get_recent_change_ids_from_comments(
     return found
 
 
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "create_pr_comment")
 def create_pr_comment(pr: GhPullRequest, body: str) -> None:
     """Create a new comment on the pull request."""
     if not body.strip():
@@ -317,7 +250,7 @@ def create_pr_comment(pr: GhPullRequest, body: str) -> None:
     issue.create_comment(body)
 
 
-@_retry_on_github()
+@external_api_call(ApiType.GITHUB, "close_pr")
 def close_pr(pr: GhPullRequest, *, comment: str | None = None) -> None:
     """Close a pull request, optionally posting a comment first."""
     if comment and comment.strip():

github2gerrit/gitutils.py

@@ -20,20 +20,8 @@ from collections.abc import Mapping
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
 
-
-def _is_verbose_mode() -> bool:
-    """Check if verbose mode is enabled via environment variable."""
-    return os.getenv("G2G_VERBOSE", "").lower() in ("true", "1", "yes")
-
-
-def _log_exception_conditionally(logger: logging.Logger, message: str, *args: Any) -> None:
-    """Log exception with traceback only if verbose mode is enabled."""
-    if _is_verbose_mode():
-        logger.exception(message, *args)
-    else:
-        logger.error(message, *args)
+from .utils import log_exception_conditionally
 
 
 __all__ = [
@@ -202,7 +190,7 @@ def run_cmd(
         )
     except subprocess.TimeoutExpired as exc:
         msg = f"Command timed out: {cmd!r}"
-        _log_exception_conditionally(log, msg)
+        log_exception_conditionally(log, msg)
         # TimeoutExpired carries 'output' and 'stderr' attributes,
         # which may be bytes depending on invocation context.
         out = getattr(exc, "output", None)
@@ -216,7 +204,7 @@ def run_cmd(
         ) from exc
     except OSError as exc:
         msg = f"Failed to execute command: {cmd!r} ({exc})"
-        _log_exception_conditionally(log, msg)
+        log_exception_conditionally(log, msg)
         raise CommandError(msg, cmd=cmd) from exc
 
     result = CommandResult(
@@ -245,32 +233,48 @@ def run_cmd(
         if result.stdout:
             log.debug("stdout: %s", mask_text(result.stdout, masks))
         if result.stderr:
-            log.debug("stderr: %s", mask_text(result.stderr, masks))
+            # Filter out git init default branch hints to keep logs clean
+            stderr_lines = result.stderr.splitlines()
+            filtered_lines = []
+            skip_hint = False
+            for line in stderr_lines:
+                if "hint: Using '" in line and "as the name for the initial branch" in line:
+                    skip_hint = True
+                elif (skip_hint and line.startswith("hint:")) or (skip_hint and not line.strip()):
+                    continue
+                else:
+                    skip_hint = False
+                    filtered_lines.append(line)
+
+            if filtered_lines:
+                filtered_stderr = "\n".join(filtered_lines)
+                log.debug("stderr: %s", mask_text(filtered_stderr, masks))
 
     return result
 
 
-def non_interactive_env() -> dict[str, str]:
+def non_interactive_env(include_git_ssh_command: bool = True) -> dict[str, str]:
     """Return a non-interactive SSH/Git environment to bypass local
-    agents/keychains."""
-    return {
-        "GIT_SSH_COMMAND": (
-            "ssh -F /dev/null "
-            "-o IdentitiesOnly=yes "
-            "-o IdentityAgent=none "
-            "-o BatchMode=yes "
-            "-o PreferredAuthentications=publickey "
-            "-o StrictHostKeyChecking=yes "
-            "-o PasswordAuthentication=no "
-            "-o PubkeyAcceptedKeyTypes=+ssh-rsa "
-            "-o ConnectTimeout=10"
-        ),
-        "SSH_AUTH_SOCK": "",
-        "SSH_AGENT_PID": "",
-        "SSH_ASKPASS": "/usr/bin/false",
-        "DISPLAY": "",
-        "SSH_ASKPASS_REQUIRE": "never",
-    }
+    agents/keychains.
+
+    Args:
+        include_git_ssh_command: Whether to include a default GIT_SSH_COMMAND.
+                                Set to False when the caller will provide their own.
+
+    Returns:
+        Dictionary of environment variables for non-interactive operations.
+    """
+    # Import here to avoid circular imports
+    from .ssh_common import build_non_interactive_ssh_env
+
+    env = build_non_interactive_ssh_env()
+
+    if include_git_ssh_command:
+        from .ssh_common import build_git_ssh_command
+
+        env["GIT_SSH_COMMAND"] = build_git_ssh_command()
+
+    return env
 
 
 def run_cmd_with_retries(
@@ -474,16 +478,78 @@ def git_commit_amend(
 
     If message is provided, it takes precedence over message_file.
     """
+    # Write message to a temp file to avoid shell-escaping issues
+    tmp_path: Path | None = None
+    if message is not None:
+        import tempfile as _tempfile
+
+        with _tempfile.NamedTemporaryFile("w", delete=False, encoding="utf-8") as _tf:
+            _tf.write(message)
+            _tf.flush()
+            tmp_path = Path(_tf.name)
+        message_file = tmp_path
+        message = None
+
+    # Determine whether to add -s; only suppress if message already has a sign-off for current committer
+    effective_signoff = bool(signoff)
+    try:
+        import os
+        import re
+
+        # Resolve committer email (prefer repo-local; fallback to global/env)
+        committer_email = os.getenv("GIT_COMMITTER_EMAIL", "").strip()
+        if not committer_email:
+            try:
+                res = run_cmd(["git", "config", "--get", "user.email"], cwd=cwd)
+                committer_email = (res.stdout or "").strip()
+            except Exception:
+                committer_email = ""
+        if not committer_email:
+            try:
+                ge = git_config_get("user.email", global_=True)
+                if ge:
+                    committer_email = ge.strip()
+            except Exception:
+                committer_email = ""
+
+        def _has_committer_signoff(text: str) -> bool:
+            for ln in text.splitlines():
+                if ln.lower().startswith("signed-off-by:"):
+                    m = re.search(r"<([^>]+)>", ln)
+                    if m and committer_email and m.group(1).strip().lower() == committer_email.lower():
+                        return True
+            return False
+
+        msg_text: str | None = None
+        if message_file is not None:
+            try:
+                msg_text = Path(message_file).read_text(encoding="utf-8")
+            except Exception:
+                msg_text = None
+
+        if msg_text is not None:
+            if committer_email and _has_committer_signoff(msg_text):
+                effective_signoff = False
+        else:
+            # No explicit message provided; check current commit body
+            try:
+                body = git_show("HEAD", cwd=cwd, fmt="%B")
+                if committer_email and _has_committer_signoff(body):
+                    effective_signoff = False
+            except GitError:
+                pass
+    except Exception:
+        # Best effort only; default to requested signoff
+        effective_signoff = bool(signoff)
+
     args: list[str] = ["commit", "--amend"]
     if no_edit and not message and not message_file:
         args.append("--no-edit")
-    if signoff:
+    if effective_signoff:
         args.append("-s")
     if author:
         args.extend(["--author", author])
-    if message:
-        args.extend(["-m", message])
-    elif message_file:
+    if message_file:
         args.extend(["-F", str(message_file)])
 
     try:
@@ -496,6 +562,12 @@ def git_commit_amend(
             stdout=exc.stdout,
             stderr=exc.stderr,
         ) from exc
+    finally:
+        if tmp_path is not None:
+            from contextlib import suppress
+
+            with suppress(Exception):
+                tmp_path.unlink(missing_ok=True)
 
 
 def git_commit_new(
@@ -511,17 +583,67 @@ def git_commit_new(
     if not message and not message_file:
         raise ValueError(_MSG_COMMIT_NO_MESSAGE)
 
+    # Write message to a temp file to avoid shell-escaping issues
+    tmp_path: Path | None = None
+    if message is not None:
+        import tempfile as _tempfile
+
+        with _tempfile.NamedTemporaryFile("w", delete=False, encoding="utf-8") as _tf:
+            _tf.write(message)
+            _tf.flush()
+            tmp_path = Path(_tf.name)
+        message_file = tmp_path
+        message = None
+
+    # Determine whether to add -s; only suppress if message already has a sign-off for current committer
+    effective_signoff = bool(signoff)
+    try:
+        import os
+        import re
+
+        # Resolve committer email (prefer repo-local; fallback to global/env)
+        committer_email = os.getenv("GIT_COMMITTER_EMAIL", "").strip()
+        if not committer_email:
+            try:
+                res = run_cmd(["git", "config", "--get", "user.email"], cwd=cwd)
+                committer_email = (res.stdout or "").strip()
+            except Exception:
+                committer_email = ""
+        if not committer_email:
+            try:
+                ge = git_config_get("user.email", global_=True)
+                if ge:
+                    committer_email = ge.strip()
+            except Exception:
+                committer_email = ""
+
+        def _has_committer_signoff(text: str) -> bool:
+            for ln in text.splitlines():
+                if ln.lower().startswith("signed-off-by:"):
+                    m = re.search(r"<([^>]+)>", ln)
+                    if m and committer_email and m.group(1).strip().lower() == committer_email.lower():
+                        return True
+            return False
+
+        if message_file is not None:
+            try:
+                msg_text = Path(message_file).read_text(encoding="utf-8")
+            except Exception:
+                msg_text = None
+            if msg_text and _has_committer_signoff(msg_text):
+                effective_signoff = False
+    except Exception:
+        effective_signoff = bool(signoff)
+
     args: list[str] = ["commit"]
-    if signoff:
+    if effective_signoff:
         args.append("-s")
     if author:
         args.extend(["--author", author])
     if allow_empty:
         args.append("--allow-empty")
 
-    if message:
-        args.extend(["-m", message])
-    else:
+    if message_file:
         args.extend(["-F", str(message_file)])
 
     try:
@@ -534,6 +656,12 @@ def git_commit_new(
             stdout=exc.stdout,
             stderr=exc.stderr,
         ) from exc
+    finally:
+        if tmp_path is not None:
+            from contextlib import suppress
+
+            with suppress(Exception):
+                tmp_path.unlink(missing_ok=True)
 
 
 def git_show(
@@ -561,21 +689,60 @@ def git_show(
 
 
 def _parse_trailers(text: str) -> dict[str, list[str]]:
-    """Parse trailers from a commit message body.
+    """Parse trailers from a commit message footer only.
 
-    Expects lines like 'Key: Value'. Multiple values per key are supported.
+    Git trailers are key-value pairs that appear at the end of commit messages,
+    separated from the body by a blank line. This function only parses trailers
+    from the actual footer section to avoid false positives from the message body.
     """
     trailers: dict[str, list[str]] = {}
-    for raw in text.splitlines():
-        line = raw.strip()
+    lines = text.splitlines()
+
+    # Find the start of the trailer block by working backwards
+    # Trailers must be at the end, separated by a blank line from the body
+    trailer_start = len(lines)
+    in_trailer_block = True
+
+    for i in range(len(lines) - 1, -1, -1):
+        line = lines[i].strip()
+
+        if not line and in_trailer_block:
+            # Found blank line, trailers end here
+            trailer_start = i + 1
+            break
+        elif not line:
+            # Blank line in middle, not in trailer block anymore
+            in_trailer_block = False
+            trailer_start = len(lines)
+        elif in_trailer_block and ":" in line:
+            # Potential trailer line
+            key, val = line.split(":", 1)
+            k = key.strip()
+            v = val.strip()
+            if k and v and not k.startswith(" ") and not k.startswith("\t"):
+                # Valid trailer format
+                continue
+            else:
+                # Invalid trailer format, stop looking
+                in_trailer_block = False
+                trailer_start = len(lines)
+        elif in_trailer_block:
+            # Non-trailer line in what we thought was trailer block
+            in_trailer_block = False
+            trailer_start = len(lines)
+
+    # Parse only the trailer section
+    for i in range(trailer_start, len(lines)):
+        line = lines[i].strip()
         if not line or ":" not in line:
             continue
         key, val = line.split(":", 1)
         k = key.strip()
         v = val.strip()
-        if not k or not v:
+        if not k or not v or k.startswith((" ", "\t")):
             continue
         trailers.setdefault(k, []).append(v)
+
     return trailers
 
 

github2gerrit/models.py

@@ -45,6 +45,7 @@ class Inputs:
     # Behavior toggles
     preserve_github_prs: bool
     dry_run: bool
+    normalise_commit: bool
 
     # Optional (reusable workflow compatibility / overrides)
     gerrit_server: str
@@ -52,6 +53,7 @@ class Inputs:
     gerrit_project: str
     issue_id: str
     allow_duplicates: bool
+    ci_testing: bool
     duplicates_filter: str = "open"