github2gerrit 0.1.5__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"
@@ -44,9 +44,7 @@ class RateLimitExceededExceptionType(GithubExceptionType):
     pass
 
 
-def _load_github_classes() -> tuple[
-    Any | None, type[BaseException], type[BaseException]
-]:
+def _load_github_classes() -> tuple[Any | None, type[BaseException], type[BaseException]]:
     try:
         exc_mod = import_module("github.GithubException")
         ge = exc_mod.GithubException
@@ -113,7 +111,6 @@ __all__ = [
     "get_recent_change_ids_from_comments",
     "get_repo_from_env",
     "iter_open_pulls",
-    "time",
 ]
 
 log = logging.getLogger("github2gerrit.github_api")
@@ -126,75 +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.
 
@@ -212,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:
@@ -221,29 +151,23 @@ def build_client(token: str | None = None) -> GhClient:
         if auth_factory is not None and hasattr(auth_factory, "Token"):
             auth_obj = auth_factory.Token(tok)
             if base_url:
-                client_any = Github(
-                    auth=auth_obj, per_page=100, base_url=base_url
-                )
+                client_any = Github(auth=auth_obj, per_page=100, base_url=base_url)
             else:
                 client_any = Github(auth=auth_obj, per_page=100)
         else:
             if base_url:
-                client_any = Github(
-                    login_or_token=tok, per_page=100, base_url=base_url
-                )
+                client_any = Github(login_or_token=tok, per_page=100, base_url=base_url)
             else:
                 client_any = Github(login_or_token=tok, per_page=100)
     except Exception:
         if base_url:
-            client_any = Github(
-                login_or_token=tok, per_page=100, base_url=base_url
-            )
+            client_any = Github(login_or_token=tok, per_page=100, base_url=base_url)
         else:
             client_any = Github(login_or_token=tok, per_page=100)
     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")
@@ -253,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)
@@ -275,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,
     *,
@@ -317,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():
@@ -326,14 +250,12 @@ 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():
         try:
             create_pr_comment(pr, comment)
         except Exception as exc:
-            log.warning(
-                "Failed to add close comment to PR #%s: %s", pr.number, exc
-            )
+            log.warning("Failed to add close comment to PR #%s: %s", pr.number, exc)
     pr.edit(state="closed")

github2gerrit/gitutils.py

@@ -20,22 +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__ = [
@@ -67,10 +53,7 @@ if not log.handlers:
     # Provide a minimal default if the app has not configured logging.
     level_name = os.getenv("G2G_LOG_LEVEL", "INFO").upper()
     level = getattr(logging, level_name, logging.INFO)
-    fmt = (
-        "%(asctime)s %(levelname)-8s %(name)s "
-        "%(filename)s:%(lineno)d | %(message)s"
-    )
+    fmt = "%(asctime)s %(levelname)-8s %(name)s %(filename)s:%(lineno)d | %(message)s"
     logging.basicConfig(level=level, format=fmt)
 
 
@@ -189,6 +172,7 @@ def run_cmd(
     - Raises CommandError on failure when check=True.
     """
     masks = list(masks or [])
+    env = env or non_interactive_env()
     env_full = _merge_env(None, env)
 
     log.debug("Executing: %s", _format_cmd_for_log(cmd, masks))
@@ -206,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)
@@ -220,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(
@@ -249,11 +233,50 @@ 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(include_git_ssh_command: bool = True) -> dict[str, str]:
+    """Return a non-interactive SSH/Git environment to bypass local
+    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(
     cmd: Sequence[str],
     *,
@@ -271,6 +294,7 @@ def run_cmd_with_retries(
     The default retry predicate considers common transient git errors.
     """
     masks = list(masks or [])
+    env = env or non_interactive_env()
 
     def _default_retry_on(res: CommandResult) -> bool:
         return res.returncode != 0 and _is_transient_git_error(res.stderr)
@@ -308,8 +332,7 @@ def run_cmd_with_retries(
         if predicate(res):
             delay = _backoff_delay(attempt)
             log.warning(
-                "Retrying (attempt %d) after transient error; delay %.1fs. "
-                "cmd=%s",
+                "Retrying (attempt %d) after transient error; delay %.1fs. cmd=%s",
                 attempt,
                 delay,
                 _format_cmd_for_log(cmd, masks),
@@ -370,7 +393,7 @@ def git_quiet(
         return run_cmd(
             cmd,
             cwd=cwd,
-            env=env,
+            env=env or non_interactive_env(),
             timeout=timeout,
             check=False,
         )
@@ -455,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:
@@ -477,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(
@@ -492,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:
@@ -515,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(
@@ -542,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
 
 
@@ -618,9 +804,7 @@ def git_config_get_all(
     try:
         res = git_quiet(args, cwd=None)
         if res.returncode == 0:
-            values = [
-                ln.strip() for ln in res.stdout.splitlines() if ln.strip()
-            ]
+            values = [ln.strip() for ln in res.stdout.splitlines() if ln.strip()]
             return values
         else:
             return []

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,8 @@ class Inputs:
     gerrit_project: str
     issue_id: str
     allow_duplicates: bool
+    ci_testing: bool
+    duplicates_filter: str = "open"
 
 
 @dataclass(frozen=True)