github2gerrit 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

github2gerrit/cli.py

@@ -7,8 +7,12 @@ import json
 import logging
 import os
 import tempfile
+from collections.abc import Callable
 from pathlib import Path
+from typing import TYPE_CHECKING
 from typing import Any
+from typing import Protocol
+from typing import TypeVar
 from typing import cast
 from urllib.parse import urlparse
 
@@ -16,7 +20,9 @@ import click
 import typer
 
 from . import models
+from .config import _is_github_actions_context
 from .config import apply_config_to_env
+from .config import apply_parameter_derivation
 from .config import load_org_config
 from .core import Orchestrator
 from .core import SubmissionResult
@@ -31,6 +37,21 @@ from .models import GitHubContext
 from .models import Inputs
 
 
+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)
+
+
 class ConfigurationError(Exception):
     """Raised when configuration validation fails.
 
@@ -83,14 +104,36 @@ def _parse_github_target(url: str) -> tuple[str | None, str | None, int | None]:
 APP_NAME = "github2gerrit"
 
 
-class _SingleUsageGroup(click.Group):  # type: ignore[misc]
-    def format_usage(self, ctx: Any, formatter: Any) -> None:
+if TYPE_CHECKING:
+    BaseGroup = object
+else:
+    BaseGroup = click.Group
+
+
+class _FormatterProto(Protocol):
+    def write_usage(self, prog: str, args: str, prefix: str = ...) -> None: ...
+
+
+class _ContextProto(Protocol):
+    @property
+    def command_path(self) -> str: ...
+
+
+class _SingleUsageGroup(BaseGroup):
+    def format_usage(
+        self, ctx: _ContextProto, formatter: _FormatterProto
+    ) -> None:
         # Force a simplified usage line without COMMAND [ARGS]...
         formatter.write_usage(
             ctx.command_path, "[OPTIONS] TARGET_URL", prefix="Usage: "
         )
 
 
+# Error message constants to comply with TRY003
+_MSG_MISSING_REQUIRED_INPUT = "Missing required input: {field_name}"
+_MSG_INVALID_FETCH_DEPTH = "FETCH_DEPTH must be a positive integer"
+_MSG_ISSUE_ID_MULTILINE = "Issue ID must be single line"
+
 app: typer.Typer = typer.Typer(
     add_completion=False,
     no_args_is_help=False,
@@ -108,7 +151,17 @@ def _resolve_org(default_org: str | None) -> str:
     return ""
 
 
-@app.command()  # type: ignore[misc]
+if TYPE_CHECKING:
+    F = TypeVar("F", bound=Callable[..., object])
+
+    def typed_app_command(
+        *args: object, **kwargs: object
+    ) -> Callable[[F], F]: ...
+else:
+    typed_app_command = app.command
+
+
+@typed_app_command()
 def main(
     ctx: typer.Context,
     target_url: str | None = typer.Argument(
@@ -400,7 +453,7 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> None:
                 per_ctx, allow_duplicates=data.allow_duplicates
             )
         except DuplicateChangeError as exc:
-            log.exception("Skipping PR #%d", pr_number)
+            _log_exception_conditionally(log, "Skipping PR #%d", pr_number)
             typer.echo(f"Skipping PR #{pr_number}: {exc}")
             continue
 
@@ -426,7 +479,9 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> None:
                         result_multi.change_numbers,
                     )
         except Exception as exc:
-            log.exception("Failed to process PR #%d", pr_number)
+            _log_exception_conditionally(
+                log, "Failed to process PR #%d", pr_number
+            )
             typer.echo(f"Failed to process PR #{pr_number}: {exc}")
             log.info("Continuing to next PR despite failure")
             continue
@@ -577,6 +632,10 @@ def _load_effective_inputs() -> Inputs:
         or os.getenv("GITHUB_REPOSITORY_OWNER")
     )
     cfg = load_org_config(org_for_cfg)
+
+    # Apply dynamic parameter derivation for missing Gerrit parameters
+    cfg = apply_parameter_derivation(cfg, org_for_cfg, save_to_config=True)
+
     apply_config_to_env(cfg)
 
     # Refresh inputs after applying configuration to environment
@@ -677,7 +736,7 @@ def _process() -> None:
     try:
         _validate_inputs(data)
     except ConfigurationError as exc:
-        log.exception("Configuration validation failed")
+        _log_exception_conditionally(log, "Configuration validation failed")
         typer.echo(f"Configuration validation failed: {exc}", err=True)
         raise typer.Exit(code=2) from exc
 
@@ -722,7 +781,7 @@ def _process() -> None:
         try:
             check_for_duplicates(gh, allow_duplicates=data.allow_duplicates)
         except DuplicateChangeError as exc:
-            log.exception("Duplicate change detected")
+            _log_exception_conditionally(log, "Duplicate change detected")
             typer.echo(f"Error: {exc}", err=True)
             typer.echo(
                 "Use --allow-duplicates to override this check.", err=True
@@ -820,25 +879,85 @@ def _validate_inputs(data: Inputs) -> None:
         )
         raise ConfigurationError(msg)
 
-    # Presence checks for required fields used by existing action
-    for field_name in (
-        "gerrit_known_hosts",
-        "gerrit_ssh_privkey_g2g",
-        "gerrit_ssh_user_g2g",
-        "gerrit_ssh_user_g2g_email",
-    ):
+    # Context-aware validation: different requirements for GH Actions vs CLI
+    is_github_actions = _is_github_actions_context()
+
+    # SSH private key is always required
+    required_fields = ["gerrit_ssh_privkey_g2g"]
+
+    # Gerrit parameters can be derived in GH Actions if organization available
+    # In local CLI context, we're more strict about explicit configuration
+    if is_github_actions:
+        # In GitHub Actions: allow derivation if organization is available
+        if not data.organization:
+            # No organization means no derivation possible
+            required_fields.extend(
+                [
+                    "gerrit_ssh_user_g2g",
+                    "gerrit_ssh_user_g2g_email",
+                ]
+            )
+    else:
+        # In local CLI: require explicit values or organization + derivation
+        # This prevents unexpected behavior when running locally
+        missing_gerrit_params = [
+            field
+            for field in ["gerrit_ssh_user_g2g", "gerrit_ssh_user_g2g_email"]
+            if not getattr(data, field)
+        ]
+        if missing_gerrit_params:
+            if data.organization:
+                log.info(
+                    "Local CLI usage: Gerrit parameters can be derived from "
+                    "organization '%s'. Missing: %s. Consider setting "
+                    "G2G_ENABLE_DERIVATION=true to enable derivation.",
+                    data.organization,
+                    ", ".join(missing_gerrit_params),
+                )
+                # Allow derivation in local mode only if explicitly enabled
+                if not _env_bool("G2G_ENABLE_DERIVATION", False):
+                    required_fields.extend(missing_gerrit_params)
+            else:
+                required_fields.extend(missing_gerrit_params)
+
+    for field_name in required_fields:
         if not getattr(data, field_name):
             log.error("Missing required input: %s", field_name)
-            raise ConfigurationError(f"Missing required input: {field_name}")  # noqa: TRY003
+            if field_name in [
+                "gerrit_ssh_user_g2g",
+                "gerrit_ssh_user_g2g_email",
+            ]:
+                if data.organization:
+                    if is_github_actions:
+                        log.error(
+                            "These fields can be derived automatically from "
+                            "organization '%s'",
+                            data.organization,
+                        )
+                    else:
+                        log.error(
+                            "These fields can be derived from organization "
+                            "'%s'",
+                            data.organization,
+                        )
+                        log.error("Set G2G_ENABLE_DERIVATION=true to enable")
+                else:
+                    log.error(
+                        "These fields require either explicit values or an "
+                        "ORGANIZATION for derivation"
+                    )
+            raise ConfigurationError(
+                _MSG_MISSING_REQUIRED_INPUT.format(field_name=field_name)
+            )
 
     # Validate fetch depth is a positive integer
     if data.fetch_depth <= 0:
         log.error("Invalid FETCH_DEPTH: %s", data.fetch_depth)
-        raise ConfigurationError("FETCH_DEPTH must be a positive integer")  # noqa: TRY003
+        raise ConfigurationError(_MSG_INVALID_FETCH_DEPTH)
 
     # Validate Issue ID is a single line string if provided
     if data.issue_id and ("\n" in data.issue_id or "\r" in data.issue_id):
-        raise ConfigurationError("Issue ID must be single line")  # noqa: TRY003
+        raise ConfigurationError(_MSG_ISSUE_ID_MULTILINE)
 
 
 def _log_effective_config(data: Inputs, gh: GitHubContext) -> None:
@@ -848,10 +967,10 @@ def _log_effective_config(data: Inputs, gh: GitHubContext) -> None:
     log.info("  SUBMIT_SINGLE_COMMITS: %s", data.submit_single_commits)
     log.info("  USE_PR_AS_COMMIT: %s", data.use_pr_as_commit)
     log.info("  FETCH_DEPTH: %s", data.fetch_depth)
-    log.info(
-        "  GERRIT_KNOWN_HOSTS: %s",
-        "<provided>" if data.gerrit_known_hosts else "<missing>",
+    known_hosts_status = (
+        "<provided>" if data.gerrit_known_hosts else "<will auto-discover>"
     )
+    log.info("  GERRIT_KNOWN_HOSTS: %s", known_hosts_status)
     log.info("  GERRIT_SSH_PRIVKEY_G2G: %s", safe_privkey)
     log.info("  GERRIT_SSH_USER_G2G: %s", data.gerrit_ssh_user_g2g)
     log.info("  GERRIT_SSH_USER_G2G_EMAIL: %s", data.gerrit_ssh_user_g2g_email)

github2gerrit/config.py

@@ -80,6 +80,8 @@ KNOWN_KEYS: set[str] = {
     "ISSUE_ID",
     "G2G_VERBOSE",
     "G2G_SKIP_GERRIT_COMMENTS",
+    "G2G_ENABLE_DERIVATION",
+    "G2G_AUTO_SAVE_CONFIG",
     "GITHUB_TOKEN",
     # Optional inputs (reusable workflow compatibility)
     "GERRIT_SERVER",
@@ -313,6 +315,198 @@ def filter_known(
     return {k: v for k, v in cfg.items() if k in KNOWN_KEYS}
 
 
+def _is_github_actions_context() -> bool:
+    """Detect if running in GitHub Actions environment."""
+    return (
+        os.getenv("GITHUB_ACTIONS") == "true"
+        or os.getenv("GITHUB_EVENT_NAME", "").strip() != ""
+    )
+
+
+def _is_local_cli_context() -> bool:
+    """Detect if running as local CLI tool."""
+    return not _is_github_actions_context()
+
+
+def derive_gerrit_parameters(organization: str | None) -> dict[str, str]:
+    """Derive Gerrit parameters from GitHub organization name.
+
+    Args:
+        organization: GitHub organization name
+
+    Returns:
+        Dict with derived parameter values:
+        - GERRIT_SSH_USER_G2G: [org].gh2gerrit
+        - GERRIT_SSH_USER_G2G_EMAIL: releng+[org]-gh2gerrit@linuxfoundation.org
+        - GERRIT_SERVER: gerrit.[org].org
+    """
+    if not organization:
+        return {}
+
+    org = organization.strip().lower()
+    return {
+        "GERRIT_SSH_USER_G2G": f"{org}.gh2gerrit",
+        "GERRIT_SSH_USER_G2G_EMAIL": (
+            f"releng+{org}-gh2gerrit@linuxfoundation.org"
+        ),
+        "GERRIT_SERVER": f"gerrit.{org}.org",
+    }
+
+
+def apply_parameter_derivation(
+    cfg: dict[str, str],
+    organization: str | None = None,
+    save_to_config: bool = True,
+) -> dict[str, str]:
+    """Apply dynamic parameter derivation for missing Gerrit parameters.
+
+    This function derives standard Gerrit parameters when they are not
+    explicitly configured. The derivation is based on the GitHub organization:
+
+    - gerrit_ssh_user_g2g: [org].gh2gerrit
+    - gerrit_ssh_user_g2g_email: releng+[org]-gh2gerrit@linuxfoundation.org
+    - gerrit_server: gerrit.[org].org
+
+    Derivation behavior depends on execution context:
+    - GitHub Actions: Automatic derivation when organization is available
+    - Local CLI: Requires G2G_ENABLE_DERIVATION=true for automatic derivation
+
+    Args:
+        cfg: Configuration dictionary to augment
+        organization: GitHub organization name for derivation
+        save_to_config: Whether to save derived parameters to config file
+
+    Returns:
+        Configuration dictionary with derived values for missing parameters
+    """
+    if not organization:
+        return cfg
+
+    # Check execution context to determine derivation strategy
+    is_github_actions = _is_github_actions_context()
+    enable_derivation = is_github_actions or os.getenv(
+        "G2G_ENABLE_DERIVATION", ""
+    ).strip().lower() in ("1", "true", "yes", "on")
+
+    if not enable_derivation:
+        log.debug(
+            "Parameter derivation disabled for local CLI usage. "
+            "Set G2G_ENABLE_DERIVATION=true to enable automatic derivation."
+        )
+        return cfg
+
+    # Only derive parameters that are missing or empty
+    derived = derive_gerrit_parameters(organization)
+    result = dict(cfg)
+    newly_derived = {}
+
+    for key, value in derived.items():
+        if key not in result or not result[key].strip():
+            log.debug(
+                "Deriving %s from organization '%s': %s (context: %s)",
+                key,
+                organization,
+                value,
+                "GitHub Actions" if is_github_actions else "Local CLI",
+            )
+            result[key] = value
+            newly_derived[key] = value
+
+    # Save newly derived parameters to configuration file for future use
+    # Default to true for local CLI, false for GitHub Actions
+    default_auto_save = "false" if _is_github_actions_context() else "true"
+    auto_save_enabled = os.getenv(
+        "G2G_AUTO_SAVE_CONFIG", default_auto_save
+    ).strip().lower() in ("1", "true", "yes", "on")
+    if save_to_config and newly_derived and auto_save_enabled:
+        # Save to config in local CLI mode to create persistent configuration
+        try:
+            save_derived_parameters_to_config(organization, newly_derived)
+            log.info(
+                "Automatically saved derived parameters to configuration "
+                "file for organization '%s'. "
+                "This creates a persistent configuration that you can "
+                "customize if needed.",
+                organization,
+            )
+        except Exception as exc:
+            log.warning("Failed to save derived parameters to config: %s", exc)
+
+    return result
+
+
+def save_derived_parameters_to_config(
+    organization: str,
+    derived_params: dict[str, str],
+    config_path: str | None = None,
+) -> None:
+    """Save derived parameters to the organization's configuration file.
+
+    This function updates the configuration file to include any derived
+    parameters that are not already present in the organization section.
+    This creates a persistent configuration that users can modify if needed.
+
+    Args:
+        organization: GitHub organization name for config section
+        derived_params: Dictionary of derived parameter key-value pairs
+        config_path: Path to config file (optional, uses default if not
+                    provided)
+
+    Raises:
+        Exception: If saving fails
+    """
+    if not organization or not derived_params:
+        return
+
+    if config_path is None:
+        config_path = (
+            os.getenv("G2G_CONFIG_PATH", "").strip() or DEFAULT_CONFIG_PATH
+        )
+
+    config_file = Path(config_path).expanduser()
+
+    try:
+        # Ensure the directory exists
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Parse existing content using configparser
+        cp = _load_ini(config_file)
+
+        # Find or create the organization section
+        org_section = _select_section(cp, organization)
+        if org_section is None:
+            # Section doesn't exist, we'll need to add it
+            cp.add_section(organization)
+            org_section = organization
+
+        # Add derived parameters that don't already exist
+        params_added = []
+        for key, value in derived_params.items():
+            if not cp.has_option(org_section, key):
+                cp.set(org_section, key, f'"{value}"')
+                params_added.append(key)
+
+        # Only write if we added parameters
+        if params_added:
+            # Write the updated configuration
+            with config_file.open("w", encoding="utf-8") as f:
+                cp.write(f)
+
+            log.debug(
+                "Saved derived parameters to configuration file %s [%s]: %s",
+                config_file,
+                organization,
+                ", ".join(params_added),
+            )
+
+    except Exception as exc:
+        log.warning(
+            "Failed to save derived parameters to configuration file %s: %s",
+            config_file,
+            exc,
+        )
+
+
 def overlay_missing(
     primary: dict[str, str],
     fallback: dict[str, str],

github2gerrit/core.py

@@ -38,14 +38,6 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-
-try:
-    from pygerrit2 import GerritRestAPI
-    from pygerrit2 import HTTPBasicAuth
-except ImportError:
-    GerritRestAPI = None
-    HTTPBasicAuth = None
-
 from .github_api import build_client
 from .github_api import close_pr
 from .github_api import create_pr_comment
@@ -67,9 +59,52 @@ from .models import GitHubContext
 from .models import Inputs
 
 
+try:
+    from pygerrit2 import GerritRestAPI
+    from pygerrit2 import HTTPBasicAuth
+except ImportError:
+    GerritRestAPI = None
+    HTTPBasicAuth = None
+
+try:
+    from .ssh_discovery import SSHDiscoveryError
+    from .ssh_discovery import auto_discover_gerrit_host_keys
+except ImportError:
+    # Fallback if ssh_discovery module is not available
+    auto_discover_gerrit_host_keys = None  # type: ignore[assignment]
+    SSHDiscoveryError = Exception  # type: ignore[misc,assignment]
+
+
+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)
+
+
 log = logging.getLogger("github2gerrit.core")
 
 
+# Error message constants to comply with TRY003
+_MSG_ISSUE_ID_MULTILINE = "Issue ID must be single line"
+_MSG_MISSING_PR_CONTEXT = "missing PR context"
+_MSG_BAD_REPOSITORY_CONTEXT = "bad repository context"
+_MSG_MISSING_GERRIT_SERVER = "missing GERRIT_SERVER"
+_MSG_MISSING_GERRIT_PROJECT = "missing GERRIT_PROJECT"
+_MSG_PYGERRIT2_REQUIRED_REST = "pygerrit2 is required to query Gerrit REST API"
+_MSG_PYGERRIT2_REQUIRED_AUTH = "pygerrit2 is required for HTTP authentication"
+_MSG_PYGERRIT2_MISSING = "pygerrit2 missing"
+_MSG_PYGERRIT2_AUTH_MISSING = "pygerrit2 auth missing"
+
+
 def _insert_issue_id_into_commit_message(message: str, issue_id: str) -> str:
     """
     Insert Issue ID into commit message after the first line.
@@ -87,7 +122,7 @@ def _insert_issue_id_into_commit_message(message: str, issue_id: str) -> str:
     # Validate that Issue ID is a single line string
     cleaned_issue_id = issue_id.strip()
     if "\n" in cleaned_issue_id or "\r" in cleaned_issue_id:
-        raise ValueError("Issue ID must be single line")  # noqa: TRY003
+        raise ValueError(_MSG_ISSUE_ID_MULTILINE)
 
     # Format as proper Issue-ID trailer
     if cleaned_issue_id.startswith("Issue-ID:"):
@@ -235,7 +270,7 @@ class Orchestrator:
             return SubmissionResult(
                 change_urls=[], change_numbers=[], commit_shas=[]
             )
-        self._setup_ssh(inputs)
+        self._setup_ssh(inputs, gerrit)
 
         if inputs.submit_single_commits:
             prep = self._prepare_single_commits(inputs, gh, gerrit)
@@ -281,7 +316,7 @@ class Orchestrator:
 
     def _guard_pull_request_context(self, gh: GitHubContext) -> None:
         if gh.pr_number is None:
-            raise OrchestratorError("missing PR context")  # noqa: TRY003
+            raise OrchestratorError(_MSG_MISSING_PR_CONTEXT)
         log.debug("PR context OK: #%s", gh.pr_number)
 
     def _parse_gitreview_text(self, text: str) -> GerritInfo | None:
@@ -446,7 +481,7 @@ class Orchestrator:
         # Fallback: use the repository name portion only.
         repo_full = gh.repository
         if not repo_full or "/" not in repo_full:
-            raise OrchestratorError("bad repository context")  # noqa: TRY003
+            raise OrchestratorError(_MSG_BAD_REPOSITORY_CONTEXT)
         owner, name = repo_full.split("/", 1)
         # Fallback: map all '-' to '/' for Gerrit path (e.g., 'my/repo/name')
         gerrit_name = name.replace("-", "/")
@@ -466,7 +501,7 @@ class Orchestrator:
 
         host = inputs.gerrit_server.strip()
         if not host:
-            raise OrchestratorError("missing GERRIT_SERVER")  # noqa: TRY003
+            raise OrchestratorError(_MSG_MISSING_GERRIT_SERVER)
         port_s = inputs.gerrit_server_port.strip() or "29418"
         try:
             port = int(port_s)
@@ -486,13 +521,13 @@ class Orchestrator:
                     project,
                 )
             else:
-                raise OrchestratorError("missing GERRIT_PROJECT")  # noqa: TRY003
+                raise OrchestratorError(_MSG_MISSING_GERRIT_PROJECT)
 
         info = GerritInfo(host=host, port=port, project=project)
         log.debug("Resolved Gerrit info: %s", info)
         return info
 
-    def _setup_ssh(self, inputs: Inputs) -> None:
+    def _setup_ssh(self, inputs: Inputs, gerrit: GerritInfo) -> None:
         """Set up temporary SSH configuration for Gerrit access.
 
         This method creates tool-specific SSH files in the workspace without
@@ -506,8 +541,46 @@ class Orchestrator:
 
         Does not modify user files.
         """
-        if not inputs.gerrit_ssh_privkey_g2g or not inputs.gerrit_known_hosts:
-            log.debug("SSH key or known hosts not provided, skipping SSH setup")
+        if not inputs.gerrit_ssh_privkey_g2g:
+            log.debug("SSH private key not provided, skipping SSH setup")
+            return
+
+        # Auto-discover host keys if not provided
+        effective_known_hosts = inputs.gerrit_known_hosts
+        if (
+            not effective_known_hosts
+            and auto_discover_gerrit_host_keys is not None
+        ):
+            log.info(
+                "GERRIT_KNOWN_HOSTS not provided, attempting auto-discovery..."
+            )
+            try:
+                discovered_keys = auto_discover_gerrit_host_keys(
+                    gerrit_hostname=gerrit.host,
+                    gerrit_port=gerrit.port,
+                    organization=inputs.organization,
+                    save_to_config=True,
+                )
+                if discovered_keys:
+                    effective_known_hosts = discovered_keys
+                    log.info(
+                        "Successfully auto-discovered SSH host keys for %s:%d",
+                        gerrit.host,
+                        gerrit.port,
+                    )
+                else:
+                    log.warning(
+                        "Auto-discovery failed, SSH host key verification may "
+                        "fail"
+                    )
+            except Exception as exc:
+                log.warning("SSH host key auto-discovery failed: %s", exc)
+
+        if not effective_known_hosts:
+            log.debug(
+                "No SSH host keys available (manual or auto-discovered), "
+                "skipping SSH setup"
+            )
             return
 
         log.info("Setting up temporary SSH configuration for Gerrit")
@@ -529,7 +602,7 @@ class Orchestrator:
         # Write known hosts to tool-specific location
         known_hosts_path = tool_ssh_dir / "known_hosts"
         with open(known_hosts_path, "w", encoding="utf-8") as f:
-            f.write(inputs.gerrit_known_hosts.strip() + "\n")
+            f.write(effective_known_hosts.strip() + "\n")
         known_hosts_path.chmod(0o644)
         log.debug("Known hosts written to %s", known_hosts_path)
         log.debug("Using isolated known_hosts to prevent user conflicts")
@@ -1123,7 +1196,9 @@ class Orchestrator:
         except CommandError as exc:
             # Analyze the specific failure reason from git review output
             error_details = self._analyze_gerrit_push_failure(exc)
-            log.exception("Gerrit push failed: %s", error_details)
+            _log_exception_conditionally(
+                log, "Gerrit push failed: %s", error_details
+            )
             msg = (
                 f"Failed to push changes to Gerrit with git-review: "
                 f"{error_details}"
@@ -1151,7 +1226,81 @@ class Orchestrator:
         combined_output = f"{stdout}\n{stderr}"
         combined_lower = combined_output.lower()
 
-        if "missing issue-id" in combined_lower:
+        # Check for SSH host key verification failures first
+        if (
+            "host key verification failed" in combined_lower
+            or "no ed25519 host key is known" in combined_lower
+            or "no rsa host key is known" in combined_lower
+            or "no ecdsa host key is known" in combined_lower
+        ):
+            return (
+                "SSH host key verification failed. The GERRIT_KNOWN_HOSTS "
+                "value is missing or contains an outdated host key for the "
+                "Gerrit server. The tool will attempt to auto-discover "
+                "host keys "
+                "on the next run, or you can manually run "
+                "'ssh-keyscan -p 29418 <gerrit-host>' "
+                "to get the current host keys."
+            )
+        elif (
+            "authenticity of host" in combined_lower
+            and "can't be established" in combined_lower
+        ):
+            return (
+                "SSH host key unknown. The GERRIT_KNOWN_HOSTS value does not "
+                "contain the host key for the Gerrit server. "
+                "The tool will attempt "
+                "to auto-discover host keys on the next run, or you can "
+                "manually run "
+                "'ssh-keyscan -p 29418 <gerrit-host>' to get the host keys."
+            )
+        # Check for specific SSH key issues before general permission denied
+        elif (
+            "key_load_public" in combined_lower
+            and "invalid format" in combined_lower
+        ):
+            return (
+                "SSH key format is invalid. Check that the SSH private key "
+                "is properly formatted."
+            )
+        elif "no matching host key type found" in combined_lower:
+            return (
+                "SSH key type not supported by server. The server may not "
+                "accept this SSH key algorithm."
+            )
+        elif "authentication failed" in combined_lower:
+            return (
+                "SSH authentication failed - check SSH key, username, and "
+                "server configuration"
+            )
+        # Check for connection timeout/refused before "could not read" check
+        elif (
+            "connection timed out" in combined_lower
+            or "connection refused" in combined_lower
+        ):
+            return (
+                "Connection failed - check network connectivity and "
+                "Gerrit server availability"
+            )
+        # Check for specific SSH publickey-only authentication failures
+        elif "permission denied (publickey)" in combined_lower and not any(
+            auth_method in combined_lower
+            for auth_method in ["gssapi", "password", "keyboard"]
+        ):
+            return (
+                "SSH public key authentication failed. The SSH key may be "
+                "invalid, not authorized for this user, or the wrong key type."
+            )
+        # Check for general SSH permission issues
+        elif "permission denied" in combined_lower:
+            return "SSH permission denied - check SSH key and user permissions"
+        elif "could not read from remote repository" in combined_lower:
+            return (
+                "Could not read from remote repository - check SSH "
+                "authentication and repository access permissions"
+            )
+        # Check for Gerrit-specific issues
+        elif "missing issue-id" in combined_lower:
             return "Missing Issue-ID in commit message."
         elif "commit not associated to any issue" in combined_lower:
             return "Commit not associated to any issue."
@@ -1169,15 +1318,6 @@ class Orchestrator:
                         return f"Gerrit rejected the push: {reason}"
                     return f"Gerrit rejected the push: {line.strip()}"
             return "Gerrit rejected the push for an unknown reason"
-        elif "permission denied" in combined_lower:
-            return "Permission denied - check SSH key and user permissions"
-        elif "connection" in combined_lower and (
-            "refused" in combined_lower or "timeout" in combined_lower
-        ):
-            return (
-                "Connection failed - check network connectivity and "
-                "Gerrit server availability"
-            )
         else:
             return f"Unknown error: {exc}"
 
@@ -1203,14 +1343,10 @@ class Orchestrator:
         )
         http_pass = os.getenv("GERRIT_HTTP_PASSWORD", "").strip()
         if GerritRestAPI is None:
-            raise OrchestratorError(  # noqa: TRY003
-                "pygerrit2 is required to query Gerrit REST API"
-            )
+            raise OrchestratorError(_MSG_PYGERRIT2_REQUIRED_REST)
         if http_user and http_pass:
             if HTTPBasicAuth is None:
-                raise OrchestratorError(  # noqa: TRY003
-                    "pygerrit2 is required for HTTP authentication"
-                )
+                raise OrchestratorError(_MSG_PYGERRIT2_REQUIRED_AUTH)
             rest = GerritRestAPI(
                 url=base_url, auth=HTTPBasicAuth(http_user, http_pass)
             )
@@ -1691,15 +1827,15 @@ class Orchestrator:
         def _build_client(url: str) -> Any:
             if http_user and http_pass:
                 if GerritRestAPI is None:
-                    raise OrchestratorError("pygerrit2 missing")  # noqa: TRY003
+                    raise OrchestratorError(_MSG_PYGERRIT2_MISSING)
                 if HTTPBasicAuth is None:
-                    raise OrchestratorError("pygerrit2 auth missing")  # noqa: TRY003
+                    raise OrchestratorError(_MSG_PYGERRIT2_AUTH_MISSING)
                 return GerritRestAPI(
                     url=url, auth=HTTPBasicAuth(http_user, http_pass)
                 )
             else:
                 if GerritRestAPI is None:
-                    raise OrchestratorError("pygerrit2 missing")  # noqa: TRY003
+                    raise OrchestratorError(_MSG_PYGERRIT2_MISSING)
                 return GerritRestAPI(url=url)
 
         def _probe(url: str) -> None:

github2gerrit/github_api.py

@@ -30,6 +30,12 @@ from typing import TypeVar
 from typing import cast
 
 
+# Error message constants to comply with TRY003
+_MSG_PYGITHUB_REQUIRED = "PyGithub required"
+_MSG_MISSING_GITHUB_TOKEN = "missing GITHUB_TOKEN"  # noqa: S105
+_MSG_BAD_GITHUB_REPOSITORY = "bad GITHUB_REPOSITORY"
+
+
 class GithubExceptionType(Exception):
     pass
 
@@ -65,7 +71,7 @@ else:
 
     class Github:  # type: ignore[no-redef]
         def __init__(self, *args: Any, **kwargs: Any) -> None:
-            raise RuntimeError("PyGithub required")  # noqa: TRY003
+            raise RuntimeError(_MSG_PYGITHUB_REQUIRED)
 
 
 class GhIssueComment(Protocol):
@@ -201,7 +207,7 @@ def build_client(token: str | None = None) -> GhClient:
     """
     tok = token or _getenv_str("GITHUB_TOKEN")
     if not tok:
-        raise ValueError("missing GITHUB_TOKEN")  # noqa: TRY003
+        raise ValueError(_MSG_MISSING_GITHUB_TOKEN)
     # per_page improves pagination; adjust as needed.
     base_url = _getenv_str("GITHUB_API_URL")
     if not base_url:
@@ -242,7 +248,7 @@ def get_repo_from_env(client: GhClient) -> GhRepository:
     """Return the repository object based on GITHUB_REPOSITORY."""
     full = _getenv_str("GITHUB_REPOSITORY")
     if not full or "/" not in full:
-        raise ValueError("bad GITHUB_REPOSITORY")  # noqa: TRY003
+        raise ValueError(_MSG_BAD_GITHUB_REPOSITORY)
     repo = client.get_repo(full)
     return repo
 

github2gerrit/gitutils.py

@@ -20,6 +20,22 @@ 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)
 
 
 __all__ = [
@@ -41,6 +57,9 @@ __all__ = [
     "run_cmd_with_retries",
 ]
 
+# Error message constants to comply with TRY003
+_MSG_COMMIT_NO_MESSAGE = "Either message or message_file must be provided"
+
 
 _LOGGER_NAME = "github2gerrit.git"
 log = logging.getLogger(_LOGGER_NAME)
@@ -187,7 +206,7 @@ def run_cmd(
         )
     except subprocess.TimeoutExpired as exc:
         msg = f"Command timed out: {cmd!r}"
-        log.exception(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)
@@ -201,7 +220,7 @@ def run_cmd(
         ) from exc
     except OSError as exc:
         msg = f"Failed to execute command: {cmd!r} ({exc})"
-        log.exception(msg)
+        _log_exception_conditionally(log, msg)
         raise CommandError(msg, cmd=cmd) from exc
 
     result = CommandResult(
@@ -471,7 +490,7 @@ def git_commit_new(
 ) -> None:
     """Create a new commit using message or message_file."""
     if not message and not message_file:
-        raise ValueError("Either message or message_file must be provided")  # noqa: TRY003
+        raise ValueError(_MSG_COMMIT_NO_MESSAGE)
 
     args: list[str] = ["commit"]
     if signoff:

github2gerrit/ssh_discovery.py

@@ -0,0 +1,412 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 The Linux Foundation
+
+"""
+SSH host key auto-discovery for github2gerrit.
+
+This module provides functionality to automatically discover and fetch SSH
+host keys for Gerrit servers, eliminating the need for manual
+GERRIT_KNOWN_HOSTS configuration.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import socket
+from pathlib import Path
+
+from .gitutils import CommandError
+from .gitutils import run_cmd
+
+
+log = logging.getLogger(__name__)
+
+
+class SSHDiscoveryError(Exception):
+    """Raised when SSH host key discovery fails."""
+
+
+# Error message constants to comply with TRY003
+_MSG_HOST_UNREACHABLE = (
+    "Host {hostname}:{port} is not reachable. "
+    "Check network connectivity and server availability."
+)
+_MSG_NO_KEYS_FOUND = (
+    "No SSH host keys found for {hostname}:{port}. "
+    "The server may not be running SSH or may be blocking connections."
+)
+_MSG_NO_VALID_KEYS = (
+    "No valid SSH host keys found for {hostname}:{port}. "
+    "The ssh-keyscan output was empty or malformed."
+)
+_MSG_CONNECTION_FAILED = (
+    "Failed to connect to {hostname}:{port} for SSH key discovery. "
+    "Error: {error}"
+)
+_MSG_KEYSCAN_FAILED = (
+    "ssh-keyscan failed with return code {returncode}: {error}"
+)
+_MSG_UNEXPECTED_ERROR = (
+    "Unexpected error during SSH key discovery for {hostname}:{port}: {error}"
+)
+_MSG_SAVE_FAILED = (
+    "Failed to save host keys to configuration file {config_file}: {error}"
+)
+
+
+def is_host_reachable(hostname: str, port: int, timeout: int = 5) -> bool:
+    """Check if a host and port are reachable via TCP."""
+    try:
+        with socket.create_connection((hostname, port), timeout=timeout):
+            return True
+    except OSError:
+        return False
+
+
+def fetch_ssh_host_keys(
+    hostname: str, port: int = 22, timeout: int = 10
+) -> str:
+    """
+    Fetch SSH host keys for a given hostname and port using ssh-keyscan.
+
+    Args:
+        hostname: The hostname to scan
+        port: The SSH port (default: 22)
+        timeout: Connection timeout in seconds (default: 10)
+
+    Returns:
+        A string containing the host keys in known_hosts format
+
+    Raises:
+        SSHDiscoveryError: If the host keys cannot be fetched
+    """
+    log.debug("Fetching SSH host keys for %s:%d", hostname, port)
+
+    # First check if the host is reachable
+    if not is_host_reachable(hostname, port, timeout=5):
+        raise SSHDiscoveryError(
+            _MSG_HOST_UNREACHABLE.format(hostname=hostname, port=port)
+        )
+
+    try:
+        # Use ssh-keyscan to fetch all available key types
+        cmd = [
+            "ssh-keyscan",
+            "-p",
+            str(port),
+            "-T",
+            str(timeout),
+            "-t",
+            "rsa,ecdsa,ed25519",
+            hostname,
+        ]
+
+        result = run_cmd(cmd, timeout=timeout + 5)
+
+        if not result.stdout or not result.stdout.strip():
+            raise SSHDiscoveryError(  # noqa: TRY301
+                _MSG_NO_KEYS_FOUND.format(hostname=hostname, port=port)
+            )
+
+        # Validate that we got proper known_hosts format
+        lines = result.stdout.strip().split("\n")
+        valid_lines = []
+
+        for line in lines:
+            stripped_line = line.strip()
+            if not stripped_line or stripped_line.startswith("#"):
+                continue
+
+            # Basic validation: should have hostname, key type, and key
+            parts = stripped_line.split()
+            if len(parts) >= 3:
+                valid_lines.append(stripped_line)
+
+        if not valid_lines:
+            raise SSHDiscoveryError(  # noqa: TRY301
+                _MSG_NO_VALID_KEYS.format(hostname=hostname, port=port)
+            )
+
+        discovered_keys = "\n".join(valid_lines)
+        log.info(
+            "Successfully discovered %d SSH host key(s) for %s:%d",
+            len(valid_lines),
+            hostname,
+            port,
+        )
+        log.debug("Discovered keys:\n%s", discovered_keys)
+
+    except CommandError as exc:
+        if exc.returncode == 1:
+            # ssh-keyscan returns 1 when it can't connect
+            error_msg = exc.stderr or exc.stdout or "Connection failed"
+            raise SSHDiscoveryError(
+                _MSG_CONNECTION_FAILED.format(
+                    hostname=hostname, port=port, error=error_msg
+                )
+            ) from exc
+        else:
+            error_msg = exc.stderr or exc.stdout or "Unknown error"
+            raise SSHDiscoveryError(
+                _MSG_KEYSCAN_FAILED.format(
+                    returncode=exc.returncode, error=error_msg
+                )
+            ) from exc
+    except Exception as exc:
+        raise SSHDiscoveryError(
+            _MSG_UNEXPECTED_ERROR.format(
+                hostname=hostname, port=port, error=exc
+            )
+        ) from exc
+    else:
+        return discovered_keys
+
+
+def extract_gerrit_info_from_gitreview(content: str) -> tuple[str, int] | None:
+    """
+    Extract Gerrit hostname and port from .gitreview file content.
+
+    Args:
+        content: The content of a .gitreview file
+
+    Returns:
+        A tuple of (hostname, port) or None if not found
+    """
+    hostname = None
+    port = 29418  # Default Gerrit SSH port
+
+    for line in content.split("\n"):
+        stripped_line = line.strip()
+        if "=" not in stripped_line:
+            continue
+
+        key, value = stripped_line.split("=", 1)
+        key = key.strip().lower()
+        value = value.strip()
+
+        if key == "host":
+            hostname = value
+        elif key == "port":
+            try:
+                port = int(value)
+            except ValueError:
+                log.warning("Invalid port in .gitreview: %s", value)
+
+    return (hostname, port) if hostname else None
+
+
+def discover_and_save_host_keys(
+    hostname: str, port: int, organization: str, config_path: str | None = None
+) -> str:
+    """
+    Discover SSH host keys and save them to the organization's configuration.
+
+    Args:
+        hostname: Gerrit hostname
+        port: Gerrit SSH port
+        organization: GitHub organization name for config section
+        config_path: Path to config file (optional, uses default if not
+            provided)
+
+    Returns:
+        The discovered host keys string
+
+    Raises:
+        SSHDiscoveryError: If discovery or saving fails
+    """
+    # Discover the host keys
+    host_keys = fetch_ssh_host_keys(hostname, port)
+
+    # Save to configuration file
+    save_host_keys_to_config(host_keys, organization, config_path)
+
+    return host_keys
+
+
+def save_host_keys_to_config(
+    host_keys: str, organization: str, config_path: str | None = None
+) -> None:
+    """
+    Save SSH host keys to the organization's configuration file.
+
+    Args:
+        host_keys: The host keys in known_hosts format
+        organization: GitHub organization name for config section
+        config_path: Path to config file (optional, uses default if not
+            provided)
+
+    Raises:
+        SSHDiscoveryError: If saving fails
+    """
+    from .config import DEFAULT_CONFIG_PATH
+
+    if config_path is None:
+        config_path = (
+            os.getenv("G2G_CONFIG_PATH", "").strip() or DEFAULT_CONFIG_PATH
+        )
+
+    config_file = Path(config_path).expanduser()
+
+    try:
+        # Ensure the directory exists
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Read existing configuration
+        existing_content = ""
+        if config_file.exists():
+            existing_content = config_file.read_text(encoding="utf-8")
+
+        # Parse existing content to find the organization section
+        lines = existing_content.split("\n")
+        new_lines = []
+        in_org_section = False
+        org_section_found = False
+        gerrit_known_hosts_updated = False
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Check for section headers
+            if stripped.startswith("[") and stripped.endswith("]"):
+                section_name = stripped[1:-1].strip().lower()
+                in_org_section = section_name == organization.lower()
+                if in_org_section:
+                    org_section_found = True
+
+            # If we're in the org section and find GERRIT_KNOWN_HOSTS, replace
+            elif in_org_section and "=" in line:
+                key = line.split("=", 1)[0].strip().upper()
+                if key == "GERRIT_KNOWN_HOSTS":
+                    # Replace with new host keys (properly escaped for INI)
+                    escaped_keys = host_keys.replace("\n", "\\n")
+                    new_lines.append(f'GERRIT_KNOWN_HOSTS = "{escaped_keys}"')
+                    gerrit_known_hosts_updated = True
+                    continue
+
+            new_lines.append(line)
+
+        # If organization section wasn't found, add it
+        if not org_section_found:
+            if new_lines and new_lines[-1].strip():
+                new_lines.append("")  # Add blank line before new section
+            new_lines.append(f"[{organization}]")
+            escaped_keys = host_keys.replace("\n", "\\n")
+            new_lines.append(f'GERRIT_KNOWN_HOSTS = "{escaped_keys}"')
+            gerrit_known_hosts_updated = True
+
+        # If section existed but didn't have GERRIT_KNOWN_HOSTS, add it
+        elif not gerrit_known_hosts_updated:
+            # Find the end of the organization section and add the key there
+            section_end = len(new_lines)
+            for i, line in enumerate(new_lines):
+                stripped = line.strip()
+                if stripped.startswith("[") and stripped.endswith("]"):
+                    section_name = stripped[1:-1].strip().lower()
+                    if section_name == organization.lower():
+                        # Find the end of this section
+                        for j in range(i + 1, len(new_lines)):
+                            if new_lines[j].strip().startswith("["):
+                                section_end = j
+                                break
+                        break
+
+            # Insert the GERRIT_KNOWN_HOSTS entry
+            escaped_keys = host_keys.replace("\n", "\\n")
+            new_lines.insert(
+                section_end, f'GERRIT_KNOWN_HOSTS = "{escaped_keys}"'
+            )
+
+        # Write the updated configuration
+        config_file.write_text("\n".join(new_lines), encoding="utf-8")
+
+        log.info(
+            "Successfully saved SSH host keys to configuration file: %s [%s]",
+            config_file,
+            organization,
+        )
+
+    except Exception as exc:
+        raise SSHDiscoveryError(
+            _MSG_SAVE_FAILED.format(config_file=config_file, error=exc)
+        ) from exc
+
+
+def auto_discover_gerrit_host_keys(
+    gerrit_hostname: str | None = None,
+    gerrit_port: int | None = None,
+    organization: str | None = None,
+    save_to_config: bool = True,
+) -> str | None:
+    """
+    Automatically discover Gerrit SSH host keys and optionally save to config.
+
+    This is the main entry point for auto-discovery functionality.
+
+    Args:
+        gerrit_hostname: Gerrit hostname (if not provided, tries to detect
+            from context)
+        gerrit_port: Gerrit SSH port (defaults to 29418)
+        organization: GitHub organization (if not provided, tries to detect
+            from env)
+        save_to_config: Whether to save discovered keys to config file
+
+    Returns:
+        The discovered host keys string, or None if discovery failed
+    """
+    try:
+        # Set defaults
+        if gerrit_port is None:
+            gerrit_port = 29418
+
+        if organization is None:
+            organization = (
+                os.getenv("ORGANIZATION")
+                or os.getenv("GITHUB_REPOSITORY_OWNER")
+                or ""
+            ).strip()
+
+        if not gerrit_hostname:
+            log.debug("No Gerrit hostname provided for auto-discovery")
+            return None
+
+        if not organization:
+            log.warning(
+                "No organization specified for SSH host key auto-discovery. "
+                "Cannot save to configuration file."
+            )
+            save_to_config = False
+
+        log.info(
+            "Attempting to auto-discover SSH host keys for %s:%d",
+            gerrit_hostname,
+            gerrit_port,
+        )
+
+        # Discover the host keys
+        host_keys = fetch_ssh_host_keys(gerrit_hostname, gerrit_port)
+
+        # Save to configuration if requested and possible
+        if save_to_config and organization:
+            save_host_keys_to_config(host_keys, organization)
+            log.info(
+                "SSH host keys automatically discovered and saved to config "
+                "for organization '%s'. Future runs will use the cached keys.",
+                organization,
+            )
+        else:
+            log.info(
+                "SSH host keys discovered but not saved to configuration. "
+                "Set ORGANIZATION environment variable to enable auto-saving."
+            )
+
+    except SSHDiscoveryError as exc:
+        log.warning("SSH host key auto-discovery failed: %s", exc)
+        return None
+    except Exception as exc:
+        log.warning(
+            "Unexpected error during SSH host key auto-discovery: %s", exc
+        )
+        return None
+    else:
+        return host_keys

{github2gerrit-0.1.4.dist-info → github2gerrit-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github2gerrit
-Version: 0.1.4
+Version: 0.1.5
 Summary: Submit a GitHub pull request to a Gerrit repository.
 Author-email: Matthew Watkins <mwatkins@linuxfoundation.org>
 License-Expression: Apache-2.0
@@ -34,6 +34,8 @@ Requires-Dist: ruff>=0.6.3; extra == "dev"
 Requires-Dist: black>=24.8.0; extra == "dev"
 Requires-Dist: mypy>=1.11.2; extra == "dev"
 Requires-Dist: pytest-mock>=3.14.0; extra == "dev"
+Requires-Dist: types-requests>=2.31.0; extra == "dev"
+Requires-Dist: types-click>=7.1.8; extra == "dev"
 Dynamic: license-file
 
 <!--

github2gerrit-0.1.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+github2gerrit/__init__.py,sha256=N1Vj1HJ28LKCJLAynQdm5jFGQQAz9YSMzZhEfvbBgow,886
+github2gerrit/cli.py,sha256=30hvpwZCs-xeWfP6TJmcluebmPVU88AUUNprd0Szt-8,34043
+github2gerrit/config.py,sha256=4RmAyRFs1CxeGlAjbCaVW63EqEnBt5Vag0jTTMzfKyU,16948
+github2gerrit/core.py,sha256=HKgSmh792sbdTV_vuNLos-eaYgj3W0F0H72N7KBV6IA,75175
+github2gerrit/duplicate_detection.py,sha256=J6a8t3ih-ebr6FEhWsaKnXYPQCzwcnFEWhdstmtjnMo,19475
+github2gerrit/github_api.py,sha256=G_VRvIzpugDeNRyw1y-KGQQ_wvDRl-L6UCqP8BRh-gU,10697
+github2gerrit/gitutils.py,sha256=8Q94BCLC924zIG2kcCSzxkajTpUamQ3Ul07OqzEv9ic,18664
+github2gerrit/models.py,sha256=DAm0pEWvAexOInnxTVrvTnKWhLMd86TfSqT78UohOCo,1791
+github2gerrit/ssh_discovery.py,sha256=xildpri60eQZtnXJuRxcEEb-q71h6D8QUiQvp2P9LlU,13300
+github2gerrit-0.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+github2gerrit-0.1.5.dist-info/METADATA,sha256=5rLt8uNLd0FLcNGqNncQbM7cYm3Ns_cDECz385lqwpk,21545
+github2gerrit-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+github2gerrit-0.1.5.dist-info/entry_points.txt,sha256=MxN2_liIKo3-xJwtAulAeS5GcOS6JS96nvwOQIkP3W8,56
+github2gerrit-0.1.5.dist-info/top_level.txt,sha256=bWTYXjvuu4sSU90KLT1JlnjD7xV_iXZ-vKoulpjLTy8,14
+github2gerrit-0.1.5.dist-info/RECORD,,

github2gerrit-0.1.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-github2gerrit/__init__.py,sha256=N1Vj1HJ28LKCJLAynQdm5jFGQQAz9YSMzZhEfvbBgow,886
-github2gerrit/cli.py,sha256=gvgyoKvNzOdh5H_BaBAkAFXvJEQLsSa4ACqYg_9QdyA,29768
-github2gerrit/config.py,sha256=_r5BAowI3x5vRKSGcZsJn6NGJqkiPF8hAmfqT1id3I8,10282
-github2gerrit/core.py,sha256=qatoJ_M6I8kiQeAA9kFT32uuw5Xo7pnUUWht0RL24io,69593
-github2gerrit/duplicate_detection.py,sha256=J6a8t3ih-ebr6FEhWsaKnXYPQCzwcnFEWhdstmtjnMo,19475
-github2gerrit/github_api.py,sha256=mgiz55GrTgAVozmoOKSLrnUcX59YxV3p2Llch2COmyE,10523
-github2gerrit/gitutils.py,sha256=1KmBACvvVDIte0WiuR-AlgswbWEm69G0J2OpmAgPn7Y,18058
-github2gerrit/models.py,sha256=DAm0pEWvAexOInnxTVrvTnKWhLMd86TfSqT78UohOCo,1791
-github2gerrit-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-github2gerrit-0.1.4.dist-info/METADATA,sha256=jJml8yKtMJgtQSfZ1F-UE5dhQmtdEQeo1kyGoBjf17w,21441
-github2gerrit-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-github2gerrit-0.1.4.dist-info/entry_points.txt,sha256=MxN2_liIKo3-xJwtAulAeS5GcOS6JS96nvwOQIkP3W8,56
-github2gerrit-0.1.4.dist-info/top_level.txt,sha256=bWTYXjvuu4sSU90KLT1JlnjD7xV_iXZ-vKoulpjLTy8,14
-github2gerrit-0.1.4.dist-info/RECORD,,