import ast import copy import hashlib import json import os import subprocess import tempfile from pathlib import Path APP = Path("/app") PEFT = APP / "vendor/transformers/src/transformers/integrations/peft.py" MODELING = APP / "vendor/transformers/src/transformers/modeling_utils.py" PUBLIC_CASES = APP / "fixtures/adapter_cases.json" RUNNER = APP / "tools/run_adapter_workflow.py" REPORT = APP / "output.json" FIXTURES = Path("/tests/fixtures") ORIGINAL_MUTABLE_HASHES = { "vendor/transformers/src/transformers/integrations/peft.py": "98acfa293447e61c6ddd65d4efffcc0f018525ea0c2a7361af40e1fdd11a7c0e", "vendor/transformers/src/transformers/modeling_utils.py": "11debbf5d5b51e98d78ed6289c4c90e5aa3e97fe3e606a25b6cc5c0fe176cacb", } def file_hash(path): return hashlib.sha256(path.read_bytes()).hexdigest() def extract_helper(): tree = ast.parse(PEFT.read_text(encoding="utf-8"), filename=str(PEFT)) node = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "maybe_load_adapters") module = ast.Module(body=[copy.deepcopy(node)], type_ignores=[]) ast.fix_missing_locations(module) return module def execute_helper(case): calls = {"cached": [], "find": []} with tempfile.TemporaryDirectory(prefix="private-adapter-") as directory: root = Path(directory) config_path = None if case.get("adapter_config") is not None: config_path = root / "adapter_config.json" config_path.write_text(json.dumps(case["adapter_config"]), encoding="utf-8") def cached_file(*args, **kwargs): calls["cached"].append((args, kwargs)) return str(root / "base-config.json") def find_adapter_config_file(*args, **kwargs): calls["find"].append((args, kwargs)) return str(config_path) if case["discovery"] == "local_config" else None namespace = { "DownloadKwargs": dict, "CONFIG_NAME": "config.json", "cached_file": cached_file, "extract_commit_hash": lambda path, value: "offline-resolved-commit" if path else value, "find_adapter_config_file": find_adapter_config_file, "is_peft_available": lambda: case["peft_available"], "json": json, "os": os, } exec(compile(extract_helper(), "private_helper", "exec"), namespace) adapter_kwargs = copy.deepcopy(case["adapter_kwargs"]) if adapter_kwargs.get("_adapter_model_path") == "$LOCAL_CONFIG": adapter_kwargs["_adapter_model_path"] = str(config_path) download_kwargs = copy.deepcopy(case["download_kwargs"]) result = namespace["maybe_load_adapters"]( case["pretrained_model_name_or_path"], download_kwargs, **adapter_kwargs ) return result, download_kwargs, calls def expected_case(case): kwargs = copy.deepcopy(case["adapter_kwargs"]) if case["discovery"] == "disabled": return None, case["pretrained_model_name_or_path"], kwargs, 0, 0 if case["discovery"] == "explicit_path": kwargs.pop("_adapter_model_path") return case["pretrained_model_name_or_path"], case["adapter_config"]["base_model_name_or_path"], kwargs, 0, 0 cached_calls = 0 if case["download_kwargs"].get("commit_hash") is not None else 1 if case["discovery"] == "local_config": return case["pretrained_model_name_or_path"], case["adapter_config"]["base_model_name_or_path"], kwargs, 1, cached_calls return None, case["pretrained_model_name_or_path"], kwargs, 1, cached_calls def caller_contract(): tree = ast.parse(MODELING.read_text(encoding="utf-8"), filename=str(MODELING)) target_names = None forwards = False for node in ast.walk(tree): if isinstance(node, ast.Assign) and isinstance(node.value, ast.Call): if getattr(node.value.func, "id", None) == "maybe_load_adapters": assert len(node.targets) == 1 assert isinstance(node.targets[0], ast.Tuple) target_names = [getattr(item, "id", None) for item in node.targets[0].elts] if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == "load_adapter": forwards = forwards or any( keyword.arg == "adapter_kwargs" and isinstance(keyword.value, ast.Name) and keyword.value.id == "adapter_kwargs" for keyword in node.keywords ) return target_names, forwards def test_gate_schema_and_protected_tree(): assert REPORT.is_file() report = json.loads(REPORT.read_text(encoding="utf-8")) assert set(report) == {"schema_version", "workflow", "caller_contract", "cases", "checks"} assert report["schema_version"] == "transformers.adapter_contract.v1" assert report["workflow"] == "pretrained_adapter_resolution" protected = json.loads((FIXTURES / "protected_hashes.json").read_text(encoding="utf-8")) for relative, expected_hash in protected.items(): path = APP / relative assert path.is_file(), relative assert file_hash(path) == expected_hash, relative for relative, original_hash in ORIGINAL_MUTABLE_HASHES.items(): path = APP / relative assert path.is_file(), relative assert file_hash(path) != original_hash, relative ast.parse(path.read_text(encoding="utf-8"), filename=str(path)) def test_core_hidden_local_resolution_and_cache_state(): cases = json.loads((FIXTURES / "hidden_adapter_cases.json").read_text(encoding="utf-8"))["cases"] case = next(item for item in cases if item["id"] == "hidden_nested_adapter") result, download_after, calls = execute_helper(case) expected_adapter, expected_model, expected_kwargs, expected_find, expected_cached = expected_case(case) assert isinstance(result, tuple) and len(result) == 3 assert result == (expected_adapter, expected_model, expected_kwargs) assert download_after["commit_hash"] == "offline-resolved-commit" assert len(calls["cached"]) == expected_cached assert len(calls["find"]) == expected_find discovery_kwargs = calls["find"][0][1] assert discovery_kwargs["local_files_only"] is True assert discovery_kwargs["revision"] == "release-7" assert discovery_kwargs["subfolder"] == "adapter" assert discovery_kwargs["_commit_hash"] == "offline-resolved-commit" assert discovery_kwargs["revision"] != result[2]["adapter_name"] def test_core_explicit_hint_and_early_return_contracts(): cases = json.loads((FIXTURES / "hidden_adapter_cases.json").read_text(encoding="utf-8"))["cases"] explicit = next(item for item in cases if item["id"] == "hidden_explicit") result, download_after, calls = execute_helper(explicit) expected = expected_case(explicit) assert result[:2] == expected[:2] assert result[2] == expected[2] assert "_adapter_model_path" not in result[2] assert len(calls["find"]) == 0 assert len(calls["cached"]) == 0 assert download_after["commit_hash"] == "fixed-commit" early = next(item for item in cases if item["id"] == "hidden_none_path") early_result, _, early_calls = execute_helper(early) assert early_result == (None, None, early["adapter_kwargs"]) assert early_calls == {"cached": [], "find": []} def test_core_caller_unpack_and_downstream_handoff(): targets, forwards = caller_contract() assert targets == ["_adapter_model_path", "pretrained_model_name_or_path", "adapter_kwargs"] assert forwards is True with tempfile.TemporaryDirectory(prefix="private-runner-") as directory: output = Path(directory) / "output.json" completed = subprocess.run( ["python3", str(RUNNER), "--cases", str(FIXTURES / "hidden_adapter_cases.json"), "--output", str(output)], cwd=APP, env={**os.environ, "APP_ROOT": str(APP)}, text=True, capture_output=True, timeout=20, ) assert completed.returncode == 0, completed.stderr report = json.loads(output.read_text(encoding="utf-8")) assert all(report["checks"].values()) assert len(report["cases"]) == 4 for result in report["cases"]: assert result["adapter_kwargs"] == result["load_adapter_kwargs"] def test_edge_public_report_and_missing_adapter_recompute(): cases = json.loads(PUBLIC_CASES.read_text(encoding="utf-8"))["cases"] report = json.loads(REPORT.read_text(encoding="utf-8")) assert [item["id"] for item in report["cases"]] == [item["id"] for item in cases] by_id = {item["id"]: item for item in report["cases"]} for case in cases: expected_adapter, expected_model, expected_kwargs, expected_find, expected_cached = expected_case(case) actual = by_id[case["id"]] assert actual["adapter_model_path"] == expected_adapter assert actual["resolved_model_name_or_path"] == expected_model assert actual["adapter_kwargs"] == expected_kwargs assert actual["discovery_calls"] == expected_find assert actual["cached_file_calls"] == expected_cached missing = by_id["adapter_not_found"] assert missing["download_kwargs_after"]["commit_hash"] == "already-resolved" assert missing["discovery_commit_hash"] == "already-resolved" assert all(report["checks"].values())