#!/usr/bin/env python3
"""Audit PEFT target candidates against a local Transformers checkpoint.

The default mode reads only a local config. `--load-model` is explicit and
requires weights already on disk; `local_files_only=True` prevents downloads.
The script proposes names, but never claims that PEFT can wrap them until the
actual package smoke test succeeds.
"""
from __future__ import annotations

import argparse
import json
from pathlib import Path


ALLOWED_LINEAR_SUFFIXES = {
    "q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj",
    "in_proj_qkv", "in_proj_z", "in_proj_b", "in_proj_a", "out_proj",
}
BLOCKED_PATH_PARTS = ("visual", "vision", "patch_embed", "merger", "projector", "router")


def is_text_path(name: str) -> bool:
    low = name.lower()
    return not any(part in low for part in BLOCKED_PATH_PARTS) and (
        "language_model" in low or ".layers." in low or low.startswith("layers.")
    )


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("model_path", type=Path, help="local checkpoint directory; no Hub id")
    parser.add_argument("--load-model", action="store_true", help="also inspect named_modules/parameters")
    args = parser.parse_args()
    if not args.model_path.is_dir():
        raise SystemExit("Refusing non-local model path; provide a checkpoint directory already on disk.")

    from transformers import AutoConfig

    config = AutoConfig.from_pretrained(args.model_path, local_files_only=True, trust_remote_code=False)
    result: dict[str, object] = {
        "model_path": str(args.model_path),
        "model_type": getattr(config, "model_type", None),
        "architectures": getattr(config, "architectures", None),
        "text_model_type": getattr(getattr(config, "text_config", None), "model_type", None),
        "candidate_dense_targets": [
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj",
            "in_proj_qkv", "in_proj_z", "in_proj_b", "in_proj_a", "out_proj",
        ],
        "candidate_moe_target_parameters": ["mlp.experts.gate_up_proj", "mlp.experts.down_proj"],
        "note": "Candidates require actual module/parameter presence and PEFT forward/backward smoke test.",
    }

    if args.load_model:
        try:
            from transformers import AutoModelForImageTextToText
            model = AutoModelForImageTextToText.from_pretrained(
                args.model_path, local_files_only=True, trust_remote_code=False, device_map="cpu"
            )
        except (ImportError, AttributeError):
            from transformers import AutoModelForMultimodalLM
            model = AutoModelForMultimodalLM.from_pretrained(
                args.model_path, local_files_only=True, trust_remote_code=False, device_map="cpu"
            )
        linear = []
        text_linear = []
        excluded_linear = []
        parameters_3d = []
        for name, module in model.named_modules():
            if module.__class__.__name__ == "Linear":
                linear.append(name)
                if is_text_path(name) and name.rsplit(".", 1)[-1] in ALLOWED_LINEAR_SUFFIXES:
                    text_linear.append(name)
                else:
                    excluded_linear.append(name)
        for name, parameter in model.named_parameters():
            if len(parameter.shape) == 3:
                parameters_3d.append({"name": name, "shape": list(parameter.shape)})
        result["linear_module_names"] = linear
        result["text_target_linear_module_names"] = text_linear
        result["excluded_visual_router_or_unsupported_linear_names"] = excluded_linear
        result["three_dimensional_parameters"] = parameters_3d
        result["present_target_suffixes"] = sorted(
            {
                suffix
                for suffix in result["candidate_dense_targets"]
                if any(name.endswith("." + suffix) or name == suffix for name in text_linear)
            }
        )
        result["present_moe_parameter_suffixes"] = sorted(
            {
                suffix
                for suffix in result["candidate_moe_target_parameters"]
                if any(name.endswith(suffix) for item in parameters_3d for name in [item["name"]])
            }
        )

    print(json.dumps(result, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()
