import hashlib
import json
from safetensors import safe_open
 
def verify_model_integrity(model_path, expected_checksums):
    """
    Verifieer de integriteit van modelbestanden tegen bekend-goede checksums.
    Geeft een lijst van niet-overeenkomende bestanden terug.
    """
    mismatches = []
 
    for filename, expected_hash in expected_checksums.items():
        filepath = f"{model_path}/{filename}"
 
        sha256 = hashlib.sha256()
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(8192), b""):
                sha256.update(chunk)
 
        actual_hash = sha256.hexdigest()
 
        if actual_hash != expected_hash:
            mismatches.append({
                "file": filename,
                "expected": expected_hash,
                "actual": actual_hash
            })
 
    return mismatches
 
def generate_layer_checksums(model_path):
    """
    Genereer checksums per laag voor gedetailleerde integriteitstracking.
    """
    checksums = {}
    with safe_open(f"{model_path}/model.safetensors", framework="pt") as f:
        for key in f.keys():
            tensor = f.get_tensor(key)
            tensor_bytes = tensor.numpy().tobytes()
            checksums[key] = hashlib.sha256(tensor_bytes).hexdigest()
 
    return checksums

from transformers import AutoConfig
 
def validate_architecture(model_path, expected_config):
    """
    Valideer de modelarchitectuur tegen de verwachte specificatie.
    """
    actual_config = AutoConfig.from_pretrained(model_path)
    discrepancies = []
 
    checks = {
        "num_hidden_layers": expected_config.get("num_hidden_layers"),
        "hidden_size": expected_config.get("hidden_size"),
        "num_attention_heads": expected_config.get("num_attention_heads"),
        "vocab_size": expected_config.get("vocab_size"),
        "intermediate_size": expected_config.get("intermediate_size"),
        "model_type": expected_config.get("model_type"),
    }
 
    for key, expected_value in checks.items():
        actual_value = getattr(actual_config, key, None)
        if actual_value != expected_value:
            discrepancies.append({
                "parameter": key,
                "expected": expected_value,
                "actual": actual_value
            })
 
    return discrepancies

from peft import PeftConfig
import json
 
def inspect_adapter(adapter_path):
    """
    Inspecteer een LoRA-adapter op verdachte kenmerken.
    """
    config = PeftConfig.from_pretrained(adapter_path)
 
    report = {
        "adapter_type": config.peft_type,
        "base_model": config.base_model_name_or_path,
        "rank": config.r,
        "lora_alpha": config.lora_alpha,
        "target_modules": list(config.target_modules),
        "modules_to_save": config.modules_to_save,
        "lora_dropout": config.lora_dropout,
    }
 
    # Markeer verdachte kenmerken
    flags = []
    if config.r > 64:
        flags.append("HIGH_RANK: LoRA-rank > 64 duidt op uitgebreide "
                     "wijzigingsmogelijkheid")
    if "embed_tokens" in str(config.target_modules):
        flags.append("EMBEDDING_TARGET: Adapter wijzigt invoer-embeddings, "
                     "wat gedrag op tokenniveau kan veranderen")
    if config.modules_to_save:
        flags.append("FULL_MODULES: Adapter vervangt sommige modules volledig, "
                     "niet alleen low-rank-aanpassing")
 
    report["flags"] = flags
    return report

import numpy as np
 
def verify_quantization_stats(model_path, expected_format, expected_bits):
    """
    Verifieer kwantisatieparameters en detecteer anomalieën.
    """
    # Laad de kwantisatieconfiguratie
    with open(f"{model_path}/quantize_config.json") as f:
        quant_config = json.load(f)
 
    issues = []
 
    if quant_config.get("bits") != expected_bits:
        issues.append(f"Bitbreedte komt niet overeen: verwacht {expected_bits}, "
                     f"gekregen {quant_config.get('bits')}")
 
    if quant_config.get("quant_method") != expected_format:
        issues.append(f"Formaat komt niet overeen: verwacht {expected_format}, "
                     f"gekregen {quant_config.get('quant_method')}")
 
    # Controleer op gemengde precisie (sommige lagen op andere precisie)
    if quant_config.get("mixed_precision"):
        issues.append("Gemengde precisie gedetecteerd -- verifieer welke lagen "
                     "op verminderde precisie staan")
 
    return issues