gluekit 1.0.1.dev1__py3-none-any.whl

gluekit/commands/build.py

@@ -0,0 +1,816 @@
+from __future__ import annotations
+
+import re
+import shutil
+import tarfile
+import tomllib
+import zipfile
+from email.parser import Parser
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any, Optional
+
+import typer
+from slugify import slugify
+
+from ..job_mgmt.glue_jobs import (
+    _resolve_notebook_path,
+    upload_glue_job_files_from_config,
+)
+
+from .constants import PUSH_COMPONENT_ALIASES, PUSH_COMPONENTS
+from .helpers import (
+    _apply_saved_params_to_config_path,
+    _examples_epilog,
+    _find_workspace_root,
+    _get_checked_out_jobs,
+    _get_checked_out_profile,
+    _load_config_index,
+    _load_glue_set_store,
+    _raise_missing_local_config,
+    _resolve_single_job_name,
+    _save_checkout_local_paths,
+    _set_saved_scope,
+    _write_config_changes,
+    run_command,
+)
+from ..cli import app
+
+
+def run_uv(
+    *args: str,
+    cwd: Optional[Path] = None,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> None:
+    run_command(["uv", *args], cwd=cwd, dry_run=dry_run, verbose=verbose)
+
+
+def run_python_build(
+    cwd: Optional[Path] = None,
+    out_dir: Optional[Path] = None,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> None:
+    command = ["python", "-m", "build"]
+    if out_dir is not None:
+        command.extend(["--outdir", str(out_dir)])
+    run_command(command, cwd=cwd, dry_run=dry_run, verbose=verbose)
+
+
+def _zip_path_for_sdist(sdist_path: Path) -> Path:
+    return sdist_path.with_name(f"{sdist_path.name[:-7]}.zip")
+
+
+def _package_name_from_sdist_contents(temp_root: Path, fallback: str) -> str:
+    extracted_entries = [entry for entry in temp_root.iterdir() if entry.exists()]
+    package_root = extracted_entries[0] if len(extracted_entries) == 1 else temp_root
+
+    pkg_info_candidates = [package_root / "PKG-INFO"]
+    pkg_info_candidates.extend(package_root.glob("*.dist-info/PKG-INFO"))
+
+    for pkg_info_path in pkg_info_candidates:
+        if not pkg_info_path.exists() or not pkg_info_path.is_file():
+            continue
+        message = Parser().parsestr(
+            pkg_info_path.read_text(encoding="utf-8", errors="ignore")
+        )
+        package_name = (message.get("Name") or "").strip()
+        if package_name:
+            return package_name
+
+    for entry in extracted_entries:
+        if entry.is_dir() and entry.name != fallback:
+            return entry.name
+
+    return fallback
+
+
+def _resolve_sdist_package_dir(temp_root: Path, package_name: str) -> Path | None:
+    extracted_entries = [entry for entry in temp_root.iterdir() if entry.exists()]
+    package_root = extracted_entries[0] if len(extracted_entries) == 1 else temp_root
+    src_dir = package_root / "src"
+    if not src_dir.is_dir():
+        return None
+
+    package_dirs = sorted(
+        entry
+        for entry in src_dir.iterdir()
+        if entry.is_dir() and (entry / "__init__.py").is_file()
+    )
+    if not package_dirs:
+        return None
+
+    normalized_package_name = package_name.replace("-", "_")
+    for package_dir in package_dirs:
+        if package_dir.name == normalized_package_name:
+            return package_dir
+
+    if len(package_dirs) == 1:
+        return package_dirs[0]
+
+    return None
+
+
+def _write_package_zip(package_dir: Path, zip_path: Path) -> None:
+    zip_path.unlink(missing_ok=True)
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for file_path in sorted(
+            path for path in package_dir.rglob("*") if path.is_file()
+        ):
+            archive.write(file_path, arcname=file_path.relative_to(package_dir.parent))
+
+
+def _build_zip_artifacts_from_sdists(
+    dist_dir: Path,
+    dry_run: bool = False,
+    no_version_suffix: bool = False,
+) -> None:
+    sdist_paths = sorted(path for path in dist_dir.glob("*.tar.gz") if path.is_file())
+    if not sdist_paths:
+        if dry_run:
+            typer.echo(
+                f"Would create zip artifact(s) from source distributions in: {dist_dir}"
+            )
+        else:
+            typer.echo(f"No source distribution archives found in: {dist_dir}")
+        return
+
+    for sdist_path in sdist_paths:
+        versioned_zip_path = _zip_path_for_sdist(sdist_path)
+        fallback_name = sdist_path.name[:-7]
+        with TemporaryDirectory() as temp_dir:
+            temp_root = Path(temp_dir)
+            with tarfile.open(sdist_path, "r:gz") as archive:
+                try:
+                    archive.extractall(temp_root, filter="data")
+                except TypeError:
+                    archive.extractall(temp_root)
+            extracted_entries = list(temp_root.iterdir())
+            package_name = _package_name_from_sdist_contents(temp_root, fallback_name)
+            package_dir = _resolve_sdist_package_dir(temp_root, package_name)
+            zip_package_name = (
+                package_dir.name if package_dir is not None else package_name
+            )
+
+            if dry_run:
+                if no_version_suffix:
+                    typer.echo(
+                        f"Would create zip artifact: {dist_dir / f'{zip_package_name}.zip'} from {sdist_path}"
+                    )
+                else:
+                    typer.echo(
+                        f"Would create zip artifact: {versioned_zip_path} from {sdist_path}"
+                    )
+                    typer.echo(
+                        "Would create unversioned zip artifact: "
+                        f"{dist_dir / f'{zip_package_name}.zip'} from {versioned_zip_path}"
+                    )
+                continue
+
+            zip_path = (
+                dist_dir / f"{zip_package_name}.zip"
+                if no_version_suffix
+                else versioned_zip_path
+            )
+            if package_dir is not None:
+                _write_package_zip(package_dir, zip_path)
+            else:
+                zip_path.unlink(missing_ok=True)
+                archive_base_name = str(zip_path.with_suffix(""))
+                if len(extracted_entries) == 1:
+                    shutil.make_archive(
+                        archive_base_name,
+                        "zip",
+                        root_dir=temp_root,
+                        base_dir=extracted_entries[0].name,
+                    )
+                else:
+                    shutil.make_archive(archive_base_name, "zip", root_dir=temp_root)
+
+            unversioned_zip_path = zip_path
+            if not no_version_suffix:
+                unversioned_zip_path = dist_dir / f"{zip_package_name}.zip"
+                if unversioned_zip_path != zip_path:
+                    shutil.copy2(zip_path, unversioned_zip_path)
+                else:
+                    unversioned_zip_path = zip_path
+
+        if dry_run:
+            continue
+
+        typer.echo(f"Created zip artifact: {zip_path}")
+        if not no_version_suffix and unversioned_zip_path != zip_path:
+            typer.echo(f"Created unversioned zip artifact: {unversioned_zip_path}")
+
+
+def _resolve_build_output_dir(cwd: Optional[Path], out_dir: Optional[Path]) -> Path:
+    base_dir = cwd or Path.cwd()
+    if out_dir is None:
+        return base_dir / "dist"
+    if out_dir.is_absolute():
+        return out_dir
+    return base_dir / out_dir
+
+
+def _parse_version_parts(version: str) -> tuple[int, int, int]:
+    parts = version.split(".")
+    if len(parts) != 3 or not all(part.isdigit() for part in parts):
+        raise typer.BadParameter(
+            f"Cannot bump non-semver project version: {version}. "
+            "Use --bump-version with an explicit X.Y.Z value."
+        )
+    return int(parts[0]), int(parts[1]), int(parts[2])
+
+
+def _next_project_version(current_version: str, bump: str) -> str:
+    normalized = bump.strip().lower()
+    if normalized in {"major", "minor", "patch"}:
+        major, minor, patch = _parse_version_parts(current_version)
+        if normalized == "major":
+            return f"{major + 1}.0.0"
+        if normalized == "minor":
+            return f"{major}.{minor + 1}.0"
+        return f"{major}.{minor}.{patch + 1}"
+
+    if re.match(r"^\d+\.\d+\.\d+(?:[a-zA-Z0-9.+_-]+)?$", bump.strip()):
+        return bump.strip()
+    raise typer.BadParameter(
+        "Invalid --bump-version. Use major, minor, patch, or an explicit X.Y.Z version."
+    )
+
+
+def _bump_project_version(
+    pyproject_path: Path,
+    bump: str,
+    *,
+    dry_run: bool = False,
+) -> tuple[str, str]:
+    if not pyproject_path.exists():
+        raise typer.BadParameter(f"pyproject.toml not found: {pyproject_path}")
+    text = pyproject_path.read_text(encoding="utf-8")
+    project_match = re.search(r"(?ms)^\[project\]\s*(?P<body>.*?)(?=^\[|\Z)", text)
+    if not project_match:
+        raise typer.BadParameter("pyproject.toml is missing a [project] section.")
+    version_match = re.search(
+        r'(?m)^(?P<prefix>\s*version\s*=\s*")(?P<version>[^"]+)(?P<suffix>"\s*)$',
+        project_match.group("body"),
+    )
+    if not version_match:
+        raise typer.BadParameter("pyproject.toml [project] section is missing version.")
+
+    current_version = version_match.group("version")
+    next_version = _next_project_version(current_version, bump)
+    if current_version == next_version:
+        typer.echo(f"Project version already {next_version}.")
+        return current_version, next_version
+
+    if dry_run:
+        typer.echo(f"Would bump project version: {current_version} -> {next_version}")
+        return current_version, next_version
+
+    section_start = project_match.start("body")
+    version_start = section_start + version_match.start("version")
+    version_end = section_start + version_match.end("version")
+    pyproject_path.write_text(
+        f"{text[:version_start]}{next_version}{text[version_end:]}",
+        encoding="utf-8",
+    )
+    typer.echo(f"Bumped project version: {current_version} -> {next_version}")
+    return current_version, next_version
+
+
+def _read_project_name_version(pyproject_path: Path) -> tuple[str, str]:
+    if not pyproject_path.exists():
+        raise typer.BadParameter(f"pyproject.toml not found: {pyproject_path}")
+    with pyproject_path.open("rb") as handle:
+        pyproject = tomllib.load(handle)
+    project = pyproject.get("project")
+    if not isinstance(project, dict):
+        raise typer.BadParameter("pyproject.toml is missing a [project] section.")
+    name = project.get("name")
+    version = project.get("version")
+    if not isinstance(name, str) or not name.strip():
+        raise typer.BadParameter("pyproject.toml [project] section is missing name.")
+    if not isinstance(version, str) or not version.strip():
+        raise typer.BadParameter("pyproject.toml [project] section is missing version.")
+    return name.strip(), version.strip()
+
+
+def _wheel_distribution_name(project_name: str) -> str:
+    return re.sub(r"[-_.]+", "_", project_name).lower()
+
+
+def _workspace_relative_path(path: Path, workspace_root: Path) -> Path:
+    try:
+        return path.resolve().relative_to(workspace_root.resolve())
+    except ValueError:
+        return path
+
+
+def _resolve_built_package_wheel_path(
+    *,
+    workspace_root: Path,
+    out_dir: Optional[Path],
+) -> Path:
+    project_name, project_version = _read_project_name_version(
+        workspace_root / "pyproject.toml"
+    )
+    dist_dir = _resolve_build_output_dir(workspace_root, out_dir)
+    if not dist_dir.exists():
+        raise typer.BadParameter(f"Package wheel directory not found: {dist_dir}")
+    if not dist_dir.is_dir():
+        raise typer.BadParameter(f"Package wheel path is not a directory: {dist_dir}")
+
+    wheel_prefix = f"{_wheel_distribution_name(project_name)}-{project_version}-"
+    matching_wheels = sorted(
+        path
+        for path in dist_dir.glob("*.whl")
+        if path.name.lower().startswith(wheel_prefix.lower())
+    )
+    if len(matching_wheels) == 1:
+        return _workspace_relative_path(matching_wheels[0], workspace_root)
+
+    all_wheels = sorted(path.as_posix() for path in dist_dir.glob("*.whl"))
+    if not matching_wheels:
+        rendered = ", ".join(all_wheels) or "(none)"
+        raise typer.BadParameter(
+            f"No package wheel found for {project_name}=={project_version} in {dist_dir}. "
+            f"Available wheels: {rendered}"
+        )
+
+    rendered = ", ".join(path.as_posix() for path in matching_wheels)
+    raise typer.BadParameter(
+        f"Multiple package wheels found for {project_name}=={project_version}: {rendered}."
+    )
+
+
+def _apply_package_wheel_to_job(
+    *,
+    job_name: Optional[str],
+    config_dir: Path,
+    profile: Optional[str],
+    dry_run: bool,
+    package_wheel_path: Optional[Path] = None,
+) -> Optional[str]:
+    from .add import (
+        _resolve_package_wheel_path,
+    )
+
+    resolved_job_name = _resolve_single_job_name(job_name, "glue build --package-whl")
+    config_index = _load_config_index(config_dir)
+    config_entry = config_index.get(resolved_job_name)
+    if not config_entry:
+        _raise_missing_local_config(resolved_job_name, config_dir, "glue build")
+
+    config_path: Path = config_entry["config_path"]
+    config_data = config_entry["config"]
+    _apply_saved_params_to_config_path(
+        config_path=config_path,
+        config_data=config_data,
+        job_name=resolved_job_name,
+        profile=profile,
+        dry_run=dry_run,
+    )
+    try:
+        wheel_path = package_wheel_path or _resolve_package_wheel_path()
+    except typer.BadParameter:
+        if not dry_run:
+            raise
+        typer.echo(f"Would update package wheel for {resolved_job_name}: dist/*.whl")
+        return resolved_job_name
+
+    _apply_package_wheel_to_config(
+        job_name=resolved_job_name,
+        config_path=config_path,
+        config_data=config_data,
+        package_wheel_path=wheel_path,
+        profile=profile,
+        dry_run=dry_run,
+    )
+    return resolved_job_name
+
+
+def _apply_package_wheel_to_config(
+    *,
+    job_name: str,
+    config_path: Path,
+    config_data: dict[str, Any],
+    package_wheel_path: Path,
+    profile: Optional[str],
+    dry_run: bool,
+) -> None:
+    from .add import (
+        _apply_add_mutations,
+        _remove_tracked_package_wheels,
+        _sync_existing_notebook_config,
+    )
+
+    removal_updates = _remove_tracked_package_wheels(config_data)
+    replacement_updates = _remove_existing_additional_python_modules(config_data)
+    updates = removal_updates + replacement_updates + _apply_add_mutations(
+        config_data=config_data,
+        job_name=job_name,
+        items=[package_wheel_path.as_posix()],
+        as_path=True,
+        as_pypi=False,
+    )
+    _write_config_changes(config_path, config_data, updates, dry_run=dry_run)
+    if updates:
+        _sync_existing_notebook_config(
+            config_data=config_data,
+            job_name=job_name,
+            dry_run=dry_run,
+        )
+    _save_package_wheel_mapping_param(
+        job_name=job_name,
+        config_data=config_data,
+        package_wheel_path=package_wheel_path,
+        profile=profile,
+        dry_run=dry_run,
+    )
+    _sync_checked_out_build_artifacts(
+        job_name=job_name,
+        config_path=config_path,
+        config_data=config_data,
+        dry_run=dry_run,
+    )
+
+
+def _remove_existing_additional_python_modules(config_data: dict[str, Any]) -> list[str]:
+    default_args = config_data.setdefault("DefaultArguments", {})
+    if not isinstance(default_args, dict):
+        raise typer.BadParameter("DefaultArguments must be an object.")
+
+    existing_modules = default_args.pop("--additional-python-modules", None)
+    if existing_modules:
+        return [
+            "Replaced --additional-python-modules entries: "
+            f"{existing_modules}"
+        ]
+    return []
+
+
+def _save_package_wheel_mapping_param(
+    *,
+    job_name: str,
+    config_data: dict[str, Any],
+    package_wheel_path: Path,
+    profile: Optional[str],
+    dry_run: bool,
+) -> None:
+    local_path = package_wheel_path.as_posix()
+    sc = config_data.get("SourceControlDetails", {})
+    additional_files = sc.get("AdditionalPythonFiles") if isinstance(sc, dict) else None
+    if not isinstance(additional_files, list):
+        return
+
+    remote_path = None
+    for entry in additional_files:
+        if not isinstance(entry, dict):
+            continue
+        if entry.get("LocalPath") == local_path and isinstance(entry.get("S3Path"), str):
+            remote_path = entry["S3Path"]
+            break
+    if not remote_path:
+        return
+
+    mapping = {"local": local_path, "remote": remote_path}
+    key = "DefaultArguments.--additional-python-modules"
+    if dry_run:
+        profile_label = f" for profile {profile}" if profile else ""
+        typer.echo(f"Would save wheel mapping{profile_label}: {job_name} {mapping}")
+        return
+    _set_saved_scope({key: mapping}, job_name, False, profile=profile)
+
+
+def _automation_build_enabled(key: str) -> bool:
+    store = _load_glue_set_store()
+    automation = store.get("automation", {})
+    if not isinstance(automation, dict):
+        return False
+    build = automation.get("build", {})
+    if not isinstance(build, dict):
+        return False
+    return build.get(key) is True
+
+
+def _sync_checked_out_build_artifacts(
+    *,
+    job_name: str,
+    config_path: Path,
+    config_data: dict[str, Any],
+    dry_run: bool,
+) -> None:
+    from .convert import _update_notebook_config_cell, _update_script_config_cell
+
+    _save_checkout_local_paths(
+        job_name=job_name,
+        config_path=config_path,
+        config_data=config_data,
+        dry_run=dry_run,
+    )
+
+    sc = config_data.get("SourceControlDetails", {})
+    if not isinstance(sc, dict):
+        sc = {}
+    script_path = Path(
+        sc.get("ScriptLocation")
+        or sc.get("LocalPath")
+        or f"glue/scripts/{slugify(job_name)}.py"
+    )
+    notebook_value = sc.get("NotebookLocation") or sc.get("NotebookPath")
+    notebook_path = (
+        Path(notebook_value)
+        if isinstance(notebook_value, str)
+        else Path(_resolve_notebook_path(script_path))
+    )
+
+    _update_script_config_cell(script_path, config_data, dry_run)
+    if notebook_path.exists():
+        _update_notebook_config_cell(
+            notebook_path,
+            config_data,
+            {"--additional-python-modules", "--extra-py-files"},
+            dry_run,
+        )
+
+
+def _sync_checked_out_configs_after_build(
+    *,
+    job_name: Optional[str],
+    config_dir: Path,
+    profile: Optional[str],
+    dry_run: bool,
+) -> Optional[str]:
+    job_names = [job_name] if job_name else _get_checked_out_jobs()
+    if not job_names:
+        return None
+
+    config_index = _load_config_index(config_dir)
+    for selected_job in job_names:
+        config_entry = config_index.get(selected_job)
+        if not config_entry:
+            _raise_missing_local_config(selected_job, config_dir, "glue build")
+        config_path: Path = config_entry["config_path"]
+        config_data = config_entry["config"]
+        _apply_saved_params_to_config_path(
+            config_path=config_path,
+            config_data=config_data,
+            job_name=selected_job,
+            profile=profile,
+            dry_run=dry_run,
+        )
+        _sync_checked_out_build_artifacts(
+            job_name=selected_job,
+            config_path=config_path,
+            config_data=config_data,
+            dry_run=dry_run,
+        )
+
+    if len(job_names) == 1:
+        return job_names[0]
+    return None
+
+
+def _push_after_build(
+    *,
+    job_name: Optional[str],
+    config_dir: Path,
+    profile: Optional[str],
+    dry_run: bool,
+    include: Optional[list[str]],
+    exclude: Optional[list[str]],
+    update_config: bool,
+    auto_login: bool,
+) -> None:
+    from .edit import _normalize_component_filters
+
+    components = _normalize_component_filters(
+        include,
+        exclude,
+        allowed=PUSH_COMPONENTS,
+        aliases=PUSH_COMPONENT_ALIASES,
+        context_label="glue build --push",
+    )
+    active_profile = profile or _get_checked_out_profile()
+    job_names = [job_name] if job_name else _get_checked_out_jobs()
+    if not job_names:
+        raise typer.BadParameter(
+            "glue build --push requires --job-name or an active checkout."
+        )
+
+    config_index = _load_config_index(config_dir)
+    for selected_job in job_names:
+        config_entry = config_index.get(selected_job)
+        if not config_entry:
+            _raise_missing_local_config(selected_job, config_dir, "glue build --push")
+        config_path: Path = config_entry["config_path"]
+        config_data = config_entry["config"]
+        _apply_saved_params_to_config_path(
+            config_path=config_path,
+            config_data=config_data,
+            job_name=selected_job,
+            profile=active_profile,
+            dry_run=dry_run,
+        )
+        typer.echo(f"Pushing after build: {selected_job}")
+        upload_glue_job_files_from_config(
+            config_data,
+            dry_run=dry_run,
+            update_job_config=update_config and "job-config" in components,
+            include_components=components,
+            profile_name=active_profile,
+            auto_login=auto_login,
+        )
+
+
+def run_project_build(
+    build_tool: str,
+    cwd: Optional[Path] = None,
+    out_dir: Optional[Path] = None,
+    no_version_suffix: bool = False,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> None:
+    tool = build_tool.strip().lower()
+    if tool not in {"auto", "uv", "build"}:
+        raise typer.BadParameter("Invalid --build-tool. Use one of: auto, uv, build.")
+
+    if tool == "uv":
+        args = ["build"]
+        if out_dir is not None:
+            args.extend(["--out-dir", str(out_dir)])
+        run_uv(*args, cwd=cwd, dry_run=dry_run, verbose=verbose)
+    elif tool == "build":
+        run_python_build(cwd=cwd, out_dir=out_dir, dry_run=dry_run, verbose=verbose)
+    elif shutil.which("uv"):
+        args = ["build"]
+        if out_dir is not None:
+            args.extend(["--out-dir", str(out_dir)])
+        run_uv(*args, cwd=cwd, dry_run=dry_run, verbose=verbose)
+    else:
+        typer.echo("uv not found, falling back to: python -m build")
+        run_python_build(cwd=cwd, out_dir=out_dir, dry_run=dry_run, verbose=verbose)
+
+    dist_dir = _resolve_build_output_dir(cwd, out_dir)
+    _build_zip_artifacts_from_sdists(
+        dist_dir,
+        dry_run=dry_run,
+        no_version_suffix=no_version_suffix,
+    )
+
+
+@app.command(
+    "build",
+    epilog=_examples_epilog(
+        "gluekit build",
+        "gluekit build --build-tool uv",
+        "gluekit build --out-dir build/artifacts --no-version-suffix",
+        "gluekit build --build-tool build --dry-run",
+    ),
+)
+def glue_build(
+    job_name: Optional[str] = typer.Option(
+        None,
+        "--job-name",
+        help="Checked-out or explicit local Glue job to update when using --package-whl or --push.",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Show what would be built and zipped without running build commands.",
+    ),
+    bump_version: Optional[str] = typer.Option(
+        None,
+        "--bump-version",
+        "--bump",
+        help="Bump pyproject.toml [project].version before building: major, minor, patch, or X.Y.Z.",
+    ),
+    build_tool: str = typer.Option(
+        "auto",
+        "--build-tool",
+        help="Build frontend to use: auto, uv, or build.",
+    ),
+    out_dir: Optional[Path] = typer.Option(
+        None,
+        "--out-dir",
+        help="The output directory to which distributions should be written.",
+    ),
+    no_version_suffix: bool = typer.Option(
+        False,
+        "--no-version-suffix",
+        help="Remove the version suffix from generated zip artifact names.",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Print build commands before execution.",
+    ),
+    package_whl: bool = typer.Option(
+        False,
+        "--package-whl",
+        help="After building, replace the tracked dist/*.whl in the selected Glue config.",
+    ),
+    push: bool = typer.Option(
+        False,
+        "--push",
+        help="Push the selected Glue config and artifacts after building.",
+    ),
+    include: Optional[list[str]] = typer.Option(
+        None,
+        "--include",
+        "-i",
+        help=(
+            "For --push, include only specific components (script, notebook, "
+            "additional-python-modules, extra-files, job-config)."
+        ),
+    ),
+    exclude: Optional[list[str]] = typer.Option(
+        None,
+        "--exclude",
+        "-x",
+        help=(
+            "For --push, exclude specific components (script, notebook, "
+            "additional-python-modules, extra-files, job-config)."
+        ),
+    ),
+    update_config: bool = typer.Option(
+        True,
+        "--update-config/--no-update-config",
+        help="For --push, update Glue job configuration after uploading files.",
+    ),
+    config_dir: Path = typer.Option(
+        Path("glue/configs"),
+        "--config-dir",
+        help="Directory containing Glue job config files.",
+    ),
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        "-p",
+        help=(
+            "AWS CLI credential profile for profile-scoped config params and, with "
+            "--push, real AWS Glue/S3 API calls."
+        ),
+    ),
+    auto_login: bool = typer.Option(
+        True,
+        "--auto-login/--no-auto-login",
+        help="For --push with a real AWS profile, automatically run 'aws sso login' when credentials are missing or expired.",
+    ),
+) -> None:
+    """Build local artifacts; only touches AWS when --push is used."""
+    workspace_root = _find_workspace_root()
+    if bump_version:
+        _bump_project_version(
+            workspace_root / "pyproject.toml",
+            bump_version,
+            dry_run=dry_run,
+        )
+    run_project_build(
+        build_tool,
+        cwd=workspace_root,
+        out_dir=out_dir,
+        no_version_suffix=no_version_suffix,
+        dry_run=dry_run,
+        verbose=verbose,
+    )
+    selected_job_name = job_name
+    active_profile = profile or _get_checked_out_profile()
+    effective_package_whl = package_whl or push or _automation_build_enabled(
+        "package_whl"
+    )
+    if effective_package_whl:
+        package_wheel_path = None
+        if not dry_run and (bump_version or _automation_build_enabled("package_whl")):
+            package_wheel_path = _resolve_built_package_wheel_path(
+                workspace_root=workspace_root,
+                out_dir=out_dir,
+            )
+        selected_job_name = _apply_package_wheel_to_job(
+            job_name=job_name,
+            config_dir=config_dir,
+            profile=active_profile,
+            dry_run=dry_run,
+            package_wheel_path=package_wheel_path,
+        )
+    else:
+        selected_job_name = _sync_checked_out_configs_after_build(
+            job_name=job_name,
+            config_dir=config_dir,
+            profile=active_profile,
+            dry_run=dry_run,
+        )
+    if push:
+        _push_after_build(
+            job_name=selected_job_name,
+            config_dir=config_dir,
+            profile=active_profile,
+            dry_run=dry_run,
+            include=include,
+            exclude=exclude,
+            update_config=update_config,
+            auto_login=auto_login,
+        )