github2gerrit 0.1.4__tar.gz → 0.1.5__tar.gz

{github2gerrit-0.1.4/src/github2gerrit.egg-info → github2gerrit-0.1.5}/PKG-INFO

@@ -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.4 → github2gerrit-0.1.5}/action.yaml

@@ -31,11 +31,20 @@ inputs:
     description: "SSH private key content used to authenticate to Gerrit"
     required: true
   GERRIT_SSH_USER_G2G:
-    description: "Gerrit SSH username (e.g. automation bot account)"
-    required: true
+    description: >
+      Gerrit SSH username (e.g. automation bot account). In GitHub Actions,
+      automatically derived as [ORGANIZATION].gh2gerrit when not provided.
+      For local CLI usage, set G2G_ENABLE_DERIVATION=true to enable derivation.
+    required: false
+    default: ""
   GERRIT_SSH_USER_G2G_EMAIL:
-    description: "Email address associated to the Gerrit SSH user"
-    required: true
+    description: >
+      Email address associated to the Gerrit SSH user. In GitHub Actions,
+      automatically derived as
+      releng+[ORGANIZATION]-gh2gerrit@linuxfoundation.org when not provided.
+      For local CLI usage, set G2G_ENABLE_DERIVATION=true to enable derivation.
+    required: false
+    default: ""
 
   # Behavior and metadata
   ORGANIZATION:
@@ -69,7 +78,11 @@ inputs:
 
   # Optional Gerrit overrides (used when .gitreview is missing)
   GERRIT_SERVER:
-    description: "Gerrit server hostname (optional; use .gitreview if present)"
+    description: >
+      Gerrit server hostname (optional; use .gitreview if present). In GitHub
+      Actions, automatically derived as gerrit.[ORGANIZATION].org when not
+      provided. For local CLI usage, set G2G_ENABLE_DERIVATION=true to enable
+      derivation.
     required: false
     default: ""
   GERRIT_SERVER_PORT:

{github2gerrit-0.1.4 → github2gerrit-0.1.5}/pyproject.toml

@@ -71,6 +71,8 @@ dev = [
 
   # Type checking helpers
   "pytest-mock>=3.14.0",
+  "types-requests>=2.31.0",
+  "types-click>=7.1.8",
 ]
 
 [tool.ruff]
@@ -91,6 +93,7 @@ ignore = [
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*.py" = ["S101", "S105", "PLW0603", "E501", "TRY003"]
+"sitecustomize.py" = ["S110", "SIM103", "SIM105", "PLW2901", "E501"]
 
 [tool.ruff.lint.isort]
 known-first-party = ["github2gerrit"]
@@ -127,6 +130,23 @@ exclude = [
 module = ["pygerrit2", "pygerrit2.*"]
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = ["click", "click.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["typer", "typer.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["pytest", "pytest.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disallow_untyped_defs = false
+disallow_untyped_calls = false
+
 [tool.coverage.run]
 branch = true
 source = ["src/github2gerrit"]
@@ -153,5 +173,3 @@ testpaths = ["tests"]
 # No extra settings are required here; this stanza reserves the
 # namespace for future use if needed.
 managed = true
-
-

{github2gerrit-0.1.4 → github2gerrit-0.1.5}/sitecustomize.py

@@ -81,7 +81,9 @@ def _iter_cov_candidates(base: Path) -> Iterable[Path]:
         _dbg(f"Failed to iterate {base}: {exc}")
 
 
-def _clean_stale_coverage_files(bases: Iterable[Path], protect: Path | None) -> None:
+def _clean_stale_coverage_files(
+    bases: Iterable[Path], protect: Path | None
+) -> None:
     protected = str(protect.resolve()) if protect else None
     for base in bases:
         try:
@@ -109,7 +111,10 @@ def _ensure_unique_coverage_file() -> Path:
         except Exception:
             # Fall through to create a sane default
             pass
-    unique = Path(tempfile.gettempdir()) / f".coverage.pytest.{os.getpid()}.{uuid.uuid4().hex}"
+    unique = (
+        Path(tempfile.gettempdir())
+        / f".coverage.pytest.{os.getpid()}.{uuid.uuid4().hex}"
+    )
     os.environ["COVERAGE_FILE"] = str(unique)
     return unique
 

{github2gerrit-0.1.4 → github2gerrit-0.1.5}/src/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-0.1.4 → github2gerrit-0.1.5}/src/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],