gluekit 1.0.1.dev1__py3-none-any.whl

gluekit/commands/edit.py

@@ -0,0 +1,1104 @@
+from __future__ import annotations
+
+import csv
+import copy
+import json
+import re
+import shutil
+import subprocess
+import tarfile
+import uuid
+import zipfile
+from collections.abc import Mapping
+from datetime import datetime, timezone
+from email.parser import Parser
+from fnmatch import fnmatch
+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 (
+    download_glue_job_files,
+    list_glue_jobs,
+    normalize_glue_config_data,
+    convert_script_to_notebook,
+    convert_notebook_to_script,
+    _resolve_notebook_path,
+    upload_glue_job_files_from_config,
+)
+from ..job_mgmt.magics import build_magic_cell_sources as _build_magic_cell_sources
+
+from .constants import *
+from .helpers import *
+from .helpers import _parse_datetime, _get_local_last_modified, _write_glue_job_list_csv
+from ..cli import app, glue_config_app
+
+
+def _parse_csv_list(value: Optional[str]) -> list[str]:
+    if not value:
+        return []
+    return [item.strip() for item in next(csv.reader([value])) if item.strip()]
+
+
+def _append_csv_items(existing_value: Optional[str], items: list[str]) -> str:
+    existing_value = existing_value or ""
+    existing_items = _parse_csv_list(existing_value)
+    existing_set = {item for item in existing_items}
+    new_items: list[str] = []
+    for item in items:
+        stripped = item.strip()
+        if stripped and stripped not in existing_set:
+            existing_set.add(stripped)
+            new_items.append(stripped)
+
+    if not new_items:
+        return existing_value
+
+    for item in new_items:
+        formatted = _format_csv_item(item)
+        if existing_value:
+            existing_value = f"{existing_value},{formatted}"
+        else:
+            existing_value = formatted
+    return existing_value
+
+
+def _remove_csv_items(
+    existing_value: Optional[str], items: list[str]
+) -> tuple[Optional[str], list[str]]:
+    existing_items = _parse_csv_list(existing_value)
+    if not existing_items:
+        return existing_value, []
+
+    removals = {item.strip() for item in items if item.strip()}
+    kept_items = [item for item in existing_items if item not in removals]
+    removed_items = [item for item in existing_items if item in removals]
+    if kept_items == existing_items:
+        return existing_value, []
+    if not kept_items:
+        return None, removed_items
+    return ",".join(_format_csv_item(item) for item in kept_items), removed_items
+
+
+def _normalize_component_filters(
+    include: Optional[list[str]],
+    exclude: Optional[list[str]],
+    allowed: set[str],
+    aliases: dict[str, str],
+    context_label: str,
+) -> set[str]:
+    def collect(values: Optional[list[str]]) -> list[str]:
+        items: list[str] = []
+        for raw in values or []:
+            items.extend(_parse_csv_list(raw))
+        return [item.strip().lower() for item in items if item.strip()]
+
+    def resolve(item: str) -> str:
+        if item == "all":
+            return item
+        mapped = aliases.get(item, item)
+        if mapped not in allowed:
+            raise typer.BadParameter(
+                f"{context_label} component '{item}' is not valid. "
+                f"Valid values: {', '.join(sorted(allowed))}."
+            )
+        return mapped
+
+    include_items = collect(include)
+    exclude_items = collect(exclude)
+
+    include_set: set[str] = set()
+    include_all = False
+    for item in include_items:
+        resolved = resolve(item)
+        if resolved == "all":
+            include_all = True
+            continue
+        include_set.add(resolved)
+
+    if include_all:
+        include_set = set(allowed)
+    elif not include_items:
+        include_set = set(allowed)
+
+    exclude_set: set[str] = set()
+    exclude_all = False
+    for item in exclude_items:
+        resolved = resolve(item)
+        if resolved == "all":
+            exclude_all = True
+            continue
+        exclude_set.add(resolved)
+
+    if exclude_all:
+        exclude_set = set(allowed)
+
+    resolved = include_set - exclude_set
+    if not resolved:
+        raise typer.BadParameter(
+            f"{context_label} include/exclude filters removed all components."
+        )
+    return resolved
+
+
+def _apply_csv_additions(
+    container: dict[str, Any],
+    key: str,
+    items: list[str],
+    changes: list[str],
+    label: str,
+) -> None:
+    values = [item.strip() for item in items if item and item.strip()]
+    if not values:
+        return
+    existing_value = container.get(key)
+    updated_value = _append_csv_items(existing_value, values)
+    if updated_value == existing_value:
+        return
+    container[key] = updated_value
+    for value in values:
+        changes.append(f"Added {label}: {value}")
+
+
+def _apply_csv_removals(
+    container: dict[str, Any],
+    key: str,
+    items: list[str],
+    changes: list[str],
+    label: str,
+) -> None:
+    values = [item.strip() for item in items if item and item.strip()]
+    if not values:
+        return
+    existing_value = container.get(key)
+    updated_value, removed_items = _remove_csv_items(existing_value, values)
+    if not removed_items:
+        return
+    if updated_value is None:
+        container.pop(key, None)
+    else:
+        container[key] = updated_value
+    for value in removed_items:
+        changes.append(f"Removed {label}: {value}")
+
+
+def _parse_key_value_pairs(
+    items: Optional[list[str]], option_name: str
+) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    for item in items or []:
+        if "=" not in item:
+            raise typer.BadParameter(f"{option_name} must use KEY=VALUE format: {item}")
+        key, value = item.split("=", 1)
+        normalized_key = key.strip()
+        if not normalized_key:
+            raise typer.BadParameter(f"{option_name} key cannot be empty: {item}")
+        parsed[normalized_key] = value.strip()
+    return parsed
+
+
+def _ensure_list_of_dicts(container: dict[str, Any], key: str) -> list[dict[str, Any]]:
+    existing = container.get(key)
+    if existing is None:
+        existing = []
+    if not isinstance(existing, list):
+        raise typer.BadParameter(f"SourceControlDetails.{key} must be a list.")
+    for entry in existing:
+        if not isinstance(entry, dict):
+            raise typer.BadParameter(
+                f"SourceControlDetails.{key} entries must be objects."
+            )
+    container[key] = existing
+    return existing
+
+
+def _ensure_connections_list(config_data: dict[str, Any]) -> list[str]:
+    connections = config_data.setdefault("Connections", {})
+    if not isinstance(connections, dict):
+        raise typer.BadParameter("Connections must be an object.")
+    items = connections.get("Connections")
+    if items is None:
+        items = []
+    if not isinstance(items, list):
+        raise typer.BadParameter("Connections.Connections must be a list.")
+    connections["Connections"] = items
+    return items
+
+
+def _apply_list_additions(
+    target: list[str], items: list[str], changes: list[str], label: str
+) -> None:
+    for item in items:
+        normalized = item.strip()
+        if not normalized or normalized in target:
+            continue
+        target.append(normalized)
+        changes.append(f"Added {label}: {normalized}")
+
+
+def _apply_list_removals(
+    target: list[str], items: list[str], changes: list[str], label: str
+) -> None:
+    removals = {item.strip() for item in items if item.strip()}
+    if not removals:
+        return
+    remaining = [item for item in target if item not in removals]
+    removed = [item for item in target if item in removals]
+    if removed:
+        target[:] = remaining
+        for item in removed:
+            changes.append(f"Removed {label}: {item}")
+
+
+def _default_argument_key(argument_name: str) -> str:
+    return argument_name if argument_name.startswith("--") else f"--{argument_name}"
+
+
+def _apply_argument_updates(
+    container: dict[str, Any],
+    additions: Optional[list[str]],
+    removals: Optional[list[str]],
+    changes: list[str],
+    label: str,
+) -> None:
+    addition_pairs = _parse_key_value_pairs(additions, label)
+    for key, value in addition_pairs.items():
+        normalized_key = _default_argument_key(key)
+        if container.get(normalized_key) != value:
+            container[normalized_key] = value
+            changes.append(f"Set {label}: {normalized_key}={value}")
+    for key in removals or []:
+        normalized_key = _default_argument_key(key.strip())
+        if normalized_key and normalized_key in container:
+            container.pop(normalized_key, None)
+            changes.append(f"Removed {label}: {normalized_key}")
+
+
+def _build_file_mapping_indexes(
+    entries: list[dict[str, Any]], key_name: str
+) -> tuple[dict[str, dict[str, str]], dict[str, str]]:
+    local_to_entry: dict[str, dict[str, str]] = {}
+    s3_to_local: dict[str, str] = {}
+    for entry in entries:
+        local = entry.get("LocalPath")
+        s3_path = entry.get("S3Path")
+        if (
+            not isinstance(local, str)
+            or not isinstance(s3_path, str)
+            or not local
+            or not s3_path
+        ):
+            raise typer.BadParameter(
+                f"SourceControlDetails.{key_name} entries must include LocalPath and S3Path."
+            )
+        if local in local_to_entry:
+            raise typer.BadParameter(
+                f"Duplicate LocalPath in SourceControlDetails.{key_name}: {local}"
+            )
+        if s3_path in s3_to_local and s3_to_local[s3_path] != local:
+            raise typer.BadParameter(
+                f"S3Path {s3_path} already mapped to {s3_to_local[s3_path]}"
+            )
+        local_to_entry[local] = entry
+        s3_to_local[s3_path] = local
+    return local_to_entry, s3_to_local
+
+
+def _apply_file_mapping_updates(
+    *,
+    config_data: dict[str, Any],
+    job_name: str,
+    source_control_key: str,
+    add_paths: Optional[list[str]],
+    remove_paths: Optional[list[str]],
+    default_arg_key: Optional[str],
+    changes: list[str],
+    label: str,
+) -> None:
+    source_control = config_data.setdefault("SourceControlDetails", {})
+    if not isinstance(source_control, dict):
+        raise typer.BadParameter("SourceControlDetails must be an object.")
+    default_args = config_data.setdefault("DefaultArguments", {})
+    command = config_data.get("Command", {})
+    script_location = command.get("ScriptLocation")
+    if add_paths and not script_location:
+        raise typer.BadParameter("Missing Command.ScriptLocation in config.")
+    local_script_path = Path(
+        source_control.get("ScriptLocation")
+        or source_control.get("LocalPath")
+        or f"glue/scripts/{slugify(job_name)}.py"
+    )
+
+    entries = _ensure_list_of_dicts(source_control, source_control_key)
+    local_to_entry, s3_to_local = _build_file_mapping_indexes(
+        entries, source_control_key
+    )
+
+    add_path_values = [
+        item.strip() for item in add_paths or [] if item and item.strip()
+    ]
+    remove_path_values = [
+        item.strip() for item in remove_paths or [] if item and item.strip()
+    ]
+
+    removed_s3_paths: list[str] = []
+    if remove_path_values:
+        remaining_entries: list[dict[str, Any]] = []
+        removals = set(remove_path_values)
+        for entry in entries:
+            local_path = entry["LocalPath"]
+            if local_path in removals:
+                removed_s3_paths.append(entry["S3Path"])
+                changes.append(f"Removed {label}: {local_path}")
+                continue
+            remaining_entries.append(entry)
+        entries[:] = remaining_entries
+        if not entries:
+            source_control.pop(source_control_key, None)
+
+    if add_path_values:
+        for raw_path in add_path_values:
+            path = Path(raw_path)
+            if path.is_absolute():
+                raise typer.BadParameter(f"Local path must be relative: {path}")
+            if not path.exists():
+                raise typer.BadParameter(f"Local path not found: {path}")
+            s3_path = _derive_s3_target(
+                path, job_name, script_location, local_script_path
+            )
+            if path.is_dir() and not s3_path.endswith(".zip"):
+                s3_path = f"{s3_path}.zip"
+
+            local_key = path.as_posix()
+            if s3_path in s3_to_local and s3_to_local[s3_path] != local_key:
+                raise typer.BadParameter(
+                    f"S3Path {s3_path} already mapped to {s3_to_local[s3_path]}"
+                )
+
+            existing_entry = local_to_entry.get(local_key)
+            if existing_entry:
+                old_s3 = existing_entry.get("S3Path")
+                if old_s3 != s3_path:
+                    existing_entry["S3Path"] = s3_path
+                    changes.append(f"Updated {label}: {local_key} -> {s3_path}")
+            else:
+                new_entry = {"LocalPath": local_key, "S3Path": s3_path}
+                entries.append(new_entry)
+                local_to_entry[local_key] = new_entry
+                s3_to_local[s3_path] = local_key
+                changes.append(f"Added {label}: {local_key} -> {s3_path}")
+
+    if default_arg_key:
+        add_s3_values = [
+            entry["S3Path"]
+            for entry in entries
+            if entry["LocalPath"]
+            in {Path(value).as_posix() for value in add_path_values}
+        ]
+        _apply_csv_additions(
+            default_args, default_arg_key, add_s3_values, changes, default_arg_key
+        )
+        _apply_csv_removals(
+            default_args, default_arg_key, removed_s3_paths, changes, default_arg_key
+        )
+
+
+def _derive_bucket_root_s3_target(local_path: Path, script_location: str) -> str:
+    bucket, _script_key = _parse_s3_url(script_location)
+    return f"s3://{bucket}/{local_path.as_posix()}"
+
+
+def _apply_extra_py_file_updates(
+    *,
+    config_data: dict[str, Any],
+    add_paths: Optional[list[str]],
+    remove_paths: Optional[list[str]],
+    changes: list[str],
+) -> None:
+    source_control = config_data.setdefault("SourceControlDetails", {})
+    if not isinstance(source_control, dict):
+        raise typer.BadParameter("SourceControlDetails must be an object.")
+    default_args = config_data.setdefault("DefaultArguments", {})
+    command = config_data.get("Command", {})
+    script_location = command.get("ScriptLocation")
+    if add_paths and not script_location:
+        raise typer.BadParameter("Missing Command.ScriptLocation in config.")
+
+    entries = _ensure_list_of_dicts(source_control, "ExtraPyFiles")
+    local_to_entry, s3_to_local = _build_file_mapping_indexes(entries, "ExtraPyFiles")
+    existing_s3_values = set(_parse_csv_list(default_args.get("--extra-py-files")))
+
+    add_path_values = [
+        item.strip() for item in add_paths or [] if item and item.strip()
+    ]
+    remove_path_values = [
+        item.strip() for item in remove_paths or [] if item and item.strip()
+    ]
+
+    removed_s3_paths: list[str] = []
+    if remove_path_values:
+        remaining_entries: list[dict[str, Any]] = []
+        removals = set(remove_path_values)
+        for entry in entries:
+            local_path = entry["LocalPath"]
+            if local_path in removals:
+                removed_s3_paths.append(entry["S3Path"])
+                changes.append(f"Removed extra py file mapping: {local_path}")
+                continue
+            remaining_entries.append(entry)
+        entries[:] = remaining_entries
+        if not entries:
+            source_control.pop("ExtraPyFiles", None)
+
+    add_s3_values: list[str] = []
+    if add_path_values:
+        for raw_path in add_path_values:
+            path = Path(raw_path)
+            if path.is_absolute():
+                raise typer.BadParameter(f"Local path must be relative: {path}")
+            if not path.exists():
+                raise typer.BadParameter(f"Local path not found: {path}")
+            if path.is_dir():
+                raise typer.BadParameter(
+                    f"--add-extra-py-files only accepts files: {path}"
+                )
+
+            s3_path = _derive_bucket_root_s3_target(path, script_location)
+            local_key = path.as_posix()
+            existing_entry = local_to_entry.get(local_key)
+            if s3_path in existing_s3_values:
+                mapped_local = s3_to_local.get(s3_path)
+                if existing_entry and existing_entry.get("S3Path") == s3_path:
+                    changes.append(
+                        f"Skipped extra py file mapping: {local_key} -> {s3_path} (already tracked)"
+                    )
+                elif mapped_local:
+                    changes.append(
+                        f"Skipped extra py file mapping: {local_key} -> {s3_path} (already mapped to {mapped_local})"
+                    )
+                else:
+                    changes.append(
+                        f"Skipped extra py file mapping: {local_key} -> {s3_path} (already in --extra-py-files)"
+                    )
+                continue
+
+            if s3_path in s3_to_local and s3_to_local[s3_path] != local_key:
+                changes.append(
+                    f"Skipped extra py file mapping: {local_key} -> {s3_path} (already mapped to {s3_to_local[s3_path]})"
+                )
+                continue
+
+            if existing_entry:
+                old_s3 = existing_entry.get("S3Path")
+                if old_s3 != s3_path:
+                    existing_entry["S3Path"] = s3_path
+                    if old_s3:
+                        s3_to_local.pop(old_s3, None)
+                    s3_to_local[s3_path] = local_key
+                    existing_s3_values.add(s3_path)
+                    changes.append(
+                        f"Updated extra py file mapping: {local_key} -> {s3_path}"
+                    )
+                    add_s3_values.append(s3_path)
+                else:
+                    changes.append(
+                        f"Skipped extra py file mapping: {local_key} -> {s3_path} (already tracked)"
+                    )
+            else:
+                new_entry = {"LocalPath": local_key, "S3Path": s3_path}
+                entries.append(new_entry)
+                local_to_entry[local_key] = new_entry
+                s3_to_local[s3_path] = local_key
+                existing_s3_values.add(s3_path)
+                changes.append(f"Added extra py file mapping: {local_key} -> {s3_path}")
+                add_s3_values.append(s3_path)
+
+    _apply_csv_additions(
+        default_args, "--extra-py-files", add_s3_values, changes, "--extra-py-files"
+    )
+    _apply_csv_removals(
+        default_args,
+        "--extra-py-files",
+        removed_s3_paths,
+        changes,
+        "--extra-py-files",
+    )
+
+
+def _apply_edit_mutations(
+    *,
+    config_data: dict[str, Any],
+    job_name: str,
+    description: Optional[str],
+    role: Optional[str],
+    glue_version: Optional[str],
+    worker_type: Optional[str],
+    number_of_workers: Optional[int],
+    timeout: Optional[int],
+    max_retries: Optional[int],
+    execution_class: Optional[str],
+    max_concurrent_runs: Optional[int],
+    job_run_queuing_enabled: Optional[bool],
+    security_configuration: Optional[str],
+    maintenance_window: Optional[str],
+    log_uri: Optional[str],
+    command_name: Optional[str],
+    python_version: Optional[str],
+    runtime: Optional[str],
+    remote_script_location: Optional[str],
+    connections_to_add: Optional[list[str]],
+    connections_to_remove: Optional[list[str]],
+    source_control_provider: Optional[str],
+    source_control_owner: Optional[str],
+    source_control_repository: Optional[str],
+    source_control_branch: Optional[str],
+    source_control_folder: Optional[str],
+    local_script_location: Optional[str],
+    notebook_location: Optional[str],
+    add_additional_python_modules: Optional[list[str]],
+    remove_additional_python_modules: Optional[list[str]],
+    add_extra_py_files: Optional[list[str]],
+    remove_extra_py_files: Optional[list[str]],
+    add_extra_jars: Optional[list[str]],
+    remove_extra_jars: Optional[list[str]],
+    add_additional_python_files: Optional[list[str]],
+    remove_additional_python_files: Optional[list[str]],
+    add_extra_files: Optional[list[str]],
+    remove_extra_files: Optional[list[str]],
+    add_default_argument: Optional[list[str]],
+    remove_default_argument: Optional[list[str]],
+    add_non_overridable_argument: Optional[list[str]],
+    remove_non_overridable_argument: Optional[list[str]],
+    enable_metrics: Optional[bool],
+    enable_observability_metrics: Optional[bool],
+    enable_glue_datacatalog: Optional[bool],
+    enable_continuous_cloudwatch_log: Optional[bool],
+    enable_spark_ui: Optional[bool],
+    enable_job_insights: Optional[bool],
+    enable_auto_scaling: Optional[bool],
+    job_bookmark_option: Optional[str],
+    temp_dir: Optional[str],
+    spark_event_logs_path: Optional[str],
+    datalake_formats: Optional[str],
+    spark_conf: Optional[str],
+    continuous_log_log_group: Optional[str],
+    continuous_log_log_stream_prefix: Optional[str],
+    continuous_log_conversion_pattern: Optional[str],
+    executor_cores: Optional[int],
+    customer_driver_env_vars: Optional[str],
+    customer_executor_env_vars: Optional[str],
+    python_modules_installer_option: Optional[str],
+) -> list[str]:
+    changes: list[str] = []
+    default_args = config_data.setdefault("DefaultArguments", {})
+    non_overridable_args = config_data.setdefault("NonOverridableArguments", {})
+    source_control = config_data.setdefault("SourceControlDetails", {})
+    command = config_data.setdefault("Command", {})
+    execution_property = config_data.setdefault("ExecutionProperty", {})
+
+    scalar_updates = {
+        "Description": description,
+        "Role": role,
+        "GlueVersion": glue_version,
+        "WorkerType": worker_type,
+        "NumberOfWorkers": number_of_workers,
+        "Timeout": timeout,
+        "MaxRetries": max_retries,
+        "ExecutionClass": execution_class,
+        "JobRunQueuingEnabled": job_run_queuing_enabled,
+        "SecurityConfiguration": security_configuration,
+        "MaintenanceWindow": maintenance_window,
+        "LogUri": log_uri,
+    }
+    for key, value in scalar_updates.items():
+        if value is not None:
+            _set_if_changed(config_data, key, value, changes)
+
+    if max_concurrent_runs is not None:
+        _set_if_changed(
+            execution_property, "MaxConcurrentRuns", max_concurrent_runs, changes
+        )
+
+    command_updates = {
+        "Name": command_name,
+        "PythonVersion": python_version,
+        "Runtime": runtime,
+        "ScriptLocation": remote_script_location,
+    }
+    for key, value in command_updates.items():
+        if value is not None:
+            _set_if_changed(command, key, value, changes)
+
+    source_control_updates = {
+        "Provider": source_control_provider,
+        "Owner": source_control_owner,
+        "Repository": source_control_repository,
+        "Branch": source_control_branch,
+        "Folder": source_control_folder,
+        "ScriptLocation": local_script_location,
+    }
+    for key, value in source_control_updates.items():
+        if value is not None:
+            _set_if_changed(source_control, key, value, changes)
+    if notebook_location is not None:
+        _set_if_changed(source_control, "NotebookLocation", notebook_location, changes)
+        _set_if_changed(source_control, "NotebookPath", notebook_location, changes)
+
+    connections = _ensure_connections_list(config_data)
+    _apply_list_additions(connections, connections_to_add or [], changes, "connection")
+    _apply_list_removals(
+        connections, connections_to_remove or [], changes, "connection"
+    )
+
+    _apply_csv_additions(
+        default_args,
+        "--additional-python-modules",
+        add_additional_python_modules or [],
+        changes,
+        "--additional-python-modules",
+    )
+    _apply_csv_removals(
+        default_args,
+        "--additional-python-modules",
+        remove_additional_python_modules or [],
+        changes,
+        "--additional-python-modules",
+    )
+    _apply_csv_additions(
+        default_args,
+        "--extra-jars",
+        add_extra_jars or [],
+        changes,
+        "--extra-jars",
+    )
+    _apply_csv_removals(
+        default_args,
+        "--extra-jars",
+        remove_extra_jars or [],
+        changes,
+        "--extra-jars",
+    )
+
+    _apply_argument_updates(
+        default_args,
+        add_default_argument,
+        remove_default_argument,
+        changes,
+        "default argument",
+    )
+    _apply_argument_updates(
+        non_overridable_args,
+        add_non_overridable_argument,
+        remove_non_overridable_argument,
+        changes,
+        "non-overridable argument",
+    )
+
+    explicit_default_argument_updates = {
+        "--enable-metrics": enable_metrics,
+        "--enable-observability-metrics": enable_observability_metrics,
+        "--enable-glue-datacatalog": enable_glue_datacatalog,
+        "--enable-continuous-cloudwatch-log": enable_continuous_cloudwatch_log,
+        "--enable-spark-ui": enable_spark_ui,
+        "--enable-job-insights": enable_job_insights,
+        "--enable-auto-scaling": enable_auto_scaling,
+        "--job-bookmark-option": job_bookmark_option,
+        "--TempDir": temp_dir,
+        "--spark-event-logs-path": spark_event_logs_path,
+        "--datalake-formats": datalake_formats,
+        "--conf": spark_conf,
+        "--continuous-log-logGroup": continuous_log_log_group,
+        "--continuous-log-logStreamPrefix": continuous_log_log_stream_prefix,
+        "--continuous-log-conversionPattern": continuous_log_conversion_pattern,
+        "--executor-cores": executor_cores,
+        "--customer-driver-env-vars": customer_driver_env_vars,
+        "--customer-executor-env-vars": customer_executor_env_vars,
+        "--python-modules-installer-option": python_modules_installer_option,
+    }
+    for key, value in explicit_default_argument_updates.items():
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            stored_value = str(value).lower()
+        elif isinstance(value, (int, float)):
+            stored_value = str(value)
+        else:
+            stored_value = value
+        _set_if_changed(default_args, key, stored_value, changes)
+
+    _apply_file_mapping_updates(
+        config_data=config_data,
+        job_name=job_name,
+        source_control_key="AdditionalPythonFiles",
+        add_paths=add_additional_python_files,
+        remove_paths=remove_additional_python_files,
+        default_arg_key="--extra-py-files",
+        changes=changes,
+        label="additional python file mapping",
+    )
+    _apply_extra_py_file_updates(
+        config_data=config_data,
+        add_paths=add_extra_py_files,
+        remove_paths=remove_extra_py_files,
+        changes=changes,
+    )
+    _apply_file_mapping_updates(
+        config_data=config_data,
+        job_name=job_name,
+        source_control_key="ExtraFiles",
+        add_paths=add_extra_files,
+        remove_paths=remove_extra_files,
+        default_arg_key="--extra-files",
+        changes=changes,
+        label="extra file mapping",
+    )
+
+    if not connections:
+        config_data.pop("Connections", None)
+    if not execution_property:
+        config_data.pop("ExecutionProperty", None)
+    if not default_args:
+        config_data.pop("DefaultArguments", None)
+    if not non_overridable_args:
+        config_data.pop("NonOverridableArguments", None)
+    if not source_control:
+        config_data.pop("SourceControlDetails", None)
+    if not command:
+        config_data.pop("Command", None)
+
+    return changes
+
+
+@app.command(
+    "edit",
+    epilog=_examples_epilog(
+        "gluekit edit my-job --description 'Updated job description' --glue-version 5.0",
+        "gluekit edit --add-additional-python-files glue/libs/helper.py --add-extra-files glue/resources/job.json",
+        "gluekit edit my-job --temp-dir s3://bucket/tmp --remove-default-argument legacy-arg --enable-metrics",
+        "gluekit edit my-job --enable-auto-scaling --enable-job-insights --executor-cores 8",
+    ),
+)
+def glue_edit(
+    job_name: Optional[str] = typer.Argument(
+        None,
+        help="Glue job name to edit. Defaults to the active checkout selection.",
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="Set the job description."
+    ),
+    role: Optional[str] = typer.Option(
+        None, "--role", help="Set the IAM role for the job."
+    ),
+    glue_version: Optional[str] = typer.Option(
+        None, "--glue-version", help="Set the Glue version."
+    ),
+    worker_type: Optional[str] = typer.Option(
+        None, "--worker-type", help="Set the worker type."
+    ),
+    number_of_workers: Optional[int] = typer.Option(
+        None, "--number-of-workers", help="Set the number of workers."
+    ),
+    timeout: Optional[int] = typer.Option(
+        None, "--timeout", help="Set the job timeout in minutes."
+    ),
+    max_retries: Optional[int] = typer.Option(
+        None, "--max-retries", help="Set the max retry count."
+    ),
+    execution_class: Optional[str] = typer.Option(
+        None, "--execution-class", help="Set the execution class."
+    ),
+    max_concurrent_runs: Optional[int] = typer.Option(
+        None, "--max-concurrent-runs", help="Set the max concurrent runs."
+    ),
+    job_run_queuing_enabled: Optional[bool] = typer.Option(
+        None,
+        "--job-run-queuing-enabled/--no-job-run-queuing-enabled",
+        help="Enable or disable job run queuing.",
+    ),
+    security_configuration: Optional[str] = typer.Option(
+        None, "--security-configuration", help="Set the security configuration name."
+    ),
+    maintenance_window: Optional[str] = typer.Option(
+        None, "--maintenance-window", help="Set the maintenance window."
+    ),
+    log_uri: Optional[str] = typer.Option(None, "--log-uri", help="Set the log URI."),
+    command_name: Optional[str] = typer.Option(
+        None, "--command-name", help="Set Command.Name."
+    ),
+    python_version: Optional[str] = typer.Option(
+        None, "--python-version", help="Set Command.PythonVersion."
+    ),
+    runtime: Optional[str] = typer.Option(
+        None, "--runtime", help="Set Command.Runtime."
+    ),
+    remote_script_location: Optional[str] = typer.Option(
+        None, "--remote-script-location", help="Set Command.ScriptLocation."
+    ),
+    local_script_location: Optional[str] = typer.Option(
+        None, "--local-script-location", help="Set SourceControlDetails.ScriptLocation."
+    ),
+    notebook_location: Optional[str] = typer.Option(
+        None,
+        "--notebook-location",
+        help="Set SourceControlDetails.NotebookLocation and NotebookPath.",
+    ),
+    source_control_provider: Optional[str] = typer.Option(
+        None, "--source-control-provider", help="Set SourceControlDetails.Provider."
+    ),
+    source_control_owner: Optional[str] = typer.Option(
+        None, "--source-control-owner", help="Set SourceControlDetails.Owner."
+    ),
+    source_control_repository: Optional[str] = typer.Option(
+        None, "--source-control-repository", help="Set SourceControlDetails.Repository."
+    ),
+    source_control_branch: Optional[str] = typer.Option(
+        None, "--source-control-branch", help="Set SourceControlDetails.Branch."
+    ),
+    source_control_folder: Optional[str] = typer.Option(
+        None, "--source-control-folder", help="Set SourceControlDetails.Folder."
+    ),
+    add_connection: Optional[list[str]] = typer.Option(
+        None, "--add-connection", help="Add one or more Glue connections."
+    ),
+    remove_connection: Optional[list[str]] = typer.Option(
+        None, "--remove-connection", help="Remove one or more Glue connections."
+    ),
+    add_additional_python_modules: Optional[list[str]] = typer.Option(
+        None,
+        "--add-additional-python-modules",
+        help="Add one or more values to --additional-python-modules.",
+    ),
+    remove_additional_python_modules: Optional[list[str]] = typer.Option(
+        None,
+        "--remove-additional-python-modules",
+        help="Remove one or more values from --additional-python-modules.",
+    ),
+    add_extra_py_files: Optional[list[str]] = typer.Option(
+        None,
+        "--add-extra-py-files",
+        help="Track one or more local relative Python files in SourceControlDetails.ExtraPyFiles and --extra-py-files.",
+    ),
+    remove_extra_py_files: Optional[list[str]] = typer.Option(
+        None,
+        "--remove-extra-py-files",
+        help="Remove one or more local relative Python files from SourceControlDetails.ExtraPyFiles and --extra-py-files.",
+    ),
+    add_extra_jars: Optional[list[str]] = typer.Option(
+        None, "--add-extra-jars", help="Add one or more values to --extra-jars."
+    ),
+    remove_extra_jars: Optional[list[str]] = typer.Option(
+        None, "--remove-extra-jars", help="Remove one or more values from --extra-jars."
+    ),
+    add_additional_python_files: Optional[list[str]] = typer.Option(
+        None,
+        "--add-additional-python-files",
+        help="Track one or more local paths in SourceControlDetails.AdditionalPythonFiles and --extra-py-files.",
+    ),
+    remove_additional_python_files: Optional[list[str]] = typer.Option(
+        None,
+        "--remove-additional-python-files",
+        help="Remove one or more local paths from SourceControlDetails.AdditionalPythonFiles and --extra-py-files.",
+    ),
+    add_extra_files: Optional[list[str]] = typer.Option(
+        None,
+        "--add-extra-files",
+        help="Track one or more local paths in SourceControlDetails.ExtraFiles and --extra-files.",
+    ),
+    remove_extra_files: Optional[list[str]] = typer.Option(
+        None,
+        "--remove-extra-files",
+        help="Remove one or more local paths from SourceControlDetails.ExtraFiles and --extra-files.",
+    ),
+    add_default_argument: Optional[list[str]] = typer.Option(
+        None,
+        "--add-default-argument",
+        help="Set a DefaultArguments entry using KEY=VALUE. Repeat as needed.",
+    ),
+    remove_default_argument: Optional[list[str]] = typer.Option(
+        None,
+        "--remove-default-argument",
+        help="Remove a DefaultArguments entry by key. Repeat as needed.",
+    ),
+    add_non_overridable_argument: Optional[list[str]] = typer.Option(
+        None,
+        "--add-non-overridable-argument",
+        help="Set a NonOverridableArguments entry using KEY=VALUE. Repeat as needed.",
+    ),
+    remove_non_overridable_argument: Optional[list[str]] = typer.Option(
+        None,
+        "--remove-non-overridable-argument",
+        help="Remove a NonOverridableArguments entry by key. Repeat as needed.",
+    ),
+    enable_metrics: Optional[bool] = typer.Option(
+        None,
+        "--enable-metrics/--disable-metrics",
+        help="Set DefaultArguments.--enable-metrics to true or false.",
+    ),
+    enable_observability_metrics: Optional[bool] = typer.Option(
+        None,
+        "--enable-observability-metrics/--disable-observability-metrics",
+        help="Set DefaultArguments.--enable-observability-metrics to true or false.",
+    ),
+    enable_glue_datacatalog: Optional[bool] = typer.Option(
+        None,
+        "--enable-glue-datacatalog/--disable-glue-datacatalog",
+        help="Set DefaultArguments.--enable-glue-datacatalog to true or false.",
+    ),
+    enable_continuous_cloudwatch_log: Optional[bool] = typer.Option(
+        None,
+        "--enable-continuous-cloudwatch-log/--disable-continuous-cloudwatch-log",
+        help="Set DefaultArguments.--enable-continuous-cloudwatch-log to true or false.",
+    ),
+    enable_spark_ui: Optional[bool] = typer.Option(
+        None,
+        "--enable-spark-ui/--disable-spark-ui",
+        help="Set DefaultArguments.--enable-spark-ui to true or false.",
+    ),
+    enable_job_insights: Optional[bool] = typer.Option(
+        None,
+        "--enable-job-insights/--disable-job-insights",
+        help="Set DefaultArguments.--enable-job-insights to true or false.",
+    ),
+    enable_auto_scaling: Optional[bool] = typer.Option(
+        None,
+        "--enable-auto-scaling/--disable-auto-scaling",
+        help="Set DefaultArguments.--enable-auto-scaling to true or false.",
+    ),
+    job_bookmark_option: Optional[str] = typer.Option(
+        None,
+        "--job-bookmark-option",
+        help="Set DefaultArguments.--job-bookmark-option.",
+    ),
+    temp_dir: Optional[str] = typer.Option(
+        None, "--temp-dir", help="Set DefaultArguments.--TempDir."
+    ),
+    spark_event_logs_path: Optional[str] = typer.Option(
+        None,
+        "--spark-event-logs-path",
+        help="Set DefaultArguments.--spark-event-logs-path.",
+    ),
+    datalake_formats: Optional[str] = typer.Option(
+        None, "--datalake-formats", help="Set DefaultArguments.--datalake-formats."
+    ),
+    spark_conf: Optional[str] = typer.Option(
+        None, "--spark-conf", help="Set DefaultArguments.--conf."
+    ),
+    continuous_log_log_group: Optional[str] = typer.Option(
+        None,
+        "--continuous-log-log-group",
+        help="Set DefaultArguments.--continuous-log-logGroup.",
+    ),
+    continuous_log_log_stream_prefix: Optional[str] = typer.Option(
+        None,
+        "--continuous-log-log-stream-prefix",
+        help="Set DefaultArguments.--continuous-log-logStreamPrefix.",
+    ),
+    continuous_log_conversion_pattern: Optional[str] = typer.Option(
+        None,
+        "--continuous-log-conversion-pattern",
+        help="Set DefaultArguments.--continuous-log-conversionPattern.",
+    ),
+    executor_cores: Optional[int] = typer.Option(
+        None, "--executor-cores", help="Set DefaultArguments.--executor-cores."
+    ),
+    customer_driver_env_vars: Optional[str] = typer.Option(
+        None,
+        "--customer-driver-env-vars",
+        help="Set DefaultArguments.--customer-driver-env-vars.",
+    ),
+    customer_executor_env_vars: Optional[str] = typer.Option(
+        None,
+        "--customer-executor-env-vars",
+        help="Set DefaultArguments.--customer-executor-env-vars.",
+    ),
+    python_modules_installer_option: Optional[str] = typer.Option(
+        None,
+        "--python-modules-installer-option",
+        help="Set DefaultArguments.--python-modules-installer-option.",
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Show what would be updated without writing files."
+    ),
+    config_dir: Path = typer.Option(
+        Path("glue/configs"),
+        "--config-dir",
+        help="Directory containing Glue job config files.",
+    ),
+) -> None:
+    """Edit one local Glue job config with explicit mutation flags."""
+    job_name = _resolve_single_job_name(job_name, "glue edit")
+    config_index = _load_config_index(config_dir)
+    config_entry = config_index.get(job_name)
+    if not config_entry:
+        _raise_missing_local_config(job_name, config_dir, "glue edit")
+
+    config_path: Path = config_entry["config_path"]
+    config_data = config_entry["config"]
+    changes = _apply_edit_mutations(
+        config_data=config_data,
+        job_name=job_name,
+        description=description,
+        role=role,
+        glue_version=glue_version,
+        worker_type=worker_type,
+        number_of_workers=number_of_workers,
+        timeout=timeout,
+        max_retries=max_retries,
+        execution_class=execution_class,
+        max_concurrent_runs=max_concurrent_runs,
+        job_run_queuing_enabled=job_run_queuing_enabled,
+        security_configuration=security_configuration,
+        maintenance_window=maintenance_window,
+        log_uri=log_uri,
+        command_name=command_name,
+        python_version=python_version,
+        runtime=runtime,
+        remote_script_location=remote_script_location,
+        connections_to_add=add_connection,
+        connections_to_remove=remove_connection,
+        source_control_provider=source_control_provider,
+        source_control_owner=source_control_owner,
+        source_control_repository=source_control_repository,
+        source_control_branch=source_control_branch,
+        source_control_folder=source_control_folder,
+        local_script_location=local_script_location,
+        notebook_location=notebook_location,
+        add_additional_python_modules=add_additional_python_modules,
+        remove_additional_python_modules=remove_additional_python_modules,
+        add_extra_py_files=add_extra_py_files,
+        remove_extra_py_files=remove_extra_py_files,
+        add_extra_jars=add_extra_jars,
+        remove_extra_jars=remove_extra_jars,
+        add_additional_python_files=add_additional_python_files,
+        remove_additional_python_files=remove_additional_python_files,
+        add_extra_files=add_extra_files,
+        remove_extra_files=remove_extra_files,
+        add_default_argument=add_default_argument,
+        remove_default_argument=remove_default_argument,
+        add_non_overridable_argument=add_non_overridable_argument,
+        remove_non_overridable_argument=remove_non_overridable_argument,
+        enable_metrics=enable_metrics,
+        enable_observability_metrics=enable_observability_metrics,
+        enable_glue_datacatalog=enable_glue_datacatalog,
+        enable_continuous_cloudwatch_log=enable_continuous_cloudwatch_log,
+        enable_spark_ui=enable_spark_ui,
+        enable_job_insights=enable_job_insights,
+        enable_auto_scaling=enable_auto_scaling,
+        job_bookmark_option=job_bookmark_option,
+        temp_dir=temp_dir,
+        spark_event_logs_path=spark_event_logs_path,
+        datalake_formats=datalake_formats,
+        spark_conf=spark_conf,
+        continuous_log_log_group=continuous_log_log_group,
+        continuous_log_log_stream_prefix=continuous_log_log_stream_prefix,
+        continuous_log_conversion_pattern=continuous_log_conversion_pattern,
+        executor_cores=executor_cores,
+        customer_driver_env_vars=customer_driver_env_vars,
+        customer_executor_env_vars=customer_executor_env_vars,
+        python_modules_installer_option=python_modules_installer_option,
+    )
+
+    _write_config_changes(config_path, config_data, changes, dry_run=dry_run)