Maak ieder citaat terugvindbaar

import re
import hashlib
import numpy as np

def document_snapshots(records):
    if not isinstance(records, list) or not 1 <= len(records) <= 32:
        raise ValueError('Geef 1 tot 32 documenten')
    seen, result = set(), []
    for row in records:
        if not isinstance(row, dict) or set(row) != {'id', 'title', 'text'}:
            raise ValueError('Document heeft exact id/title/text')
        if not isinstance(row['id'], str) or not re.fullmatch(r'[A-Za-z0-9_-]{1,40}', row['id']) or row['id'] in seen:
            raise ValueError('Unieke begrensde document-ID vereist')
        if not isinstance(row['title'], str) or not 1 <= len(row['title'].strip()) or len(row['title']) > 100:
            raise ValueError('Titel is niet leeg en maximaal 100 tekens')
        if not isinstance(row['text'], str) or not row['text'].strip() or len(row['text']) > 20000:
            raise ValueError('Brontekst is niet leeg en maximaal 20000 tekens')
        try:
            revision = hashlib.sha256(row['text'].encode('utf-8')).hexdigest()
        except UnicodeError as exc:
            raise ValueError('Tekst moet geldige UTF-8 zijn') from exc
        seen.add(row['id'])
        result.append({**row, 'revision': revision})
    return result

def word_chunks(document, window=40, overlap=8):
    if not isinstance(document, dict) or set(document) != {'id', 'title', 'text', 'revision'}:
        raise ValueError('Geef een document-snapshot')
    checked = document_snapshots([{k: document[k] for k in ['id', 'title', 'text']}])[0]
    if document['revision'] != checked['revision']:
        raise ValueError('Documenttekst en versiehash verschillen')
    if type(window) is not int or not 1 <= window <= 256 or type(overlap) is not int or not 0 <= overlap < window:
        raise ValueError('Window 1–256, overlap 0 tot window-1')
    words = list(re.finditer(r'\S+', document['text']))
    result, first = [], 0
    while first < len(words):
        last = min(first + window, len(words))
        start, end = words[first].start(), words[last - 1].end()
        result.append({'id': f'{document["id"]}:{first}', 'document_id': document['id'],
                       'revision': document['revision'], 'word_start': first, 'word_end': last,
                       'start': start, 'end': end, 'text': document['text'][start:end]})
        if last == len(words):
            break
        first += window - overlap
    return result

def chunk_coverage(document, chunks):
    # Reuse the snapshot check without changing the source text.
    word_chunks(document, 256, 0)
    if not isinstance(chunks, list) or len(chunks) > 20000:
        raise ValueError('Geef maximaal 20000 chunks')
    words = list(re.finditer(r'\S+', document['text']))
    covered, seen, occurrences = set(), set(), 0
    for chunk in chunks:
        if not isinstance(chunk, dict) or set(chunk) != {'id', 'document_id', 'revision', 'word_start', 'word_end', 'start', 'end', 'text'}:
            raise ValueError('Ongeldige chunkvelden')
        a, b = chunk['word_start'], chunk['word_end']
        if type(a) is not int or type(b) is not int or not 0 <= a < b <= len(words):
            raise ValueError('Ongeldig woordinterval')
        if chunk['id'] != f'{document["id"]}:{a}' or chunk['id'] in seen or chunk['document_id'] != document['id'] or chunk['revision'] != document['revision']:
            raise ValueError('Chunk-ID, document of versie klopt niet')
        start, end = words[a].start(), words[b - 1].end()
        if type(chunk['start']) is not int or type(chunk['end']) is not int or chunk['start'] != start or chunk['end'] != end or chunk['text'] != document['text'][start:end]:
            raise ValueError('Chunktekst/offsets komen niet overeen met de bron')
        seen.add(chunk['id']);covered.update(range(a, b));occurrences += b - a
    return {'total_words': len(words), 'covered_words': len(covered),
            'coverage': len(covered) / len(words), 'word_occurrences': occurrences,
            'duplication_factor': occurrences / len(covered) if covered else None,
            'missing_word_indices': sorted(set(range(len(words))) - covered)}

def checked_sources(documents):
    if not isinstance(documents, list) or any(not isinstance(d, dict) or set(d) != {'id', 'title', 'text', 'revision'} for d in documents):
        raise ValueError('Document-snapshots vereist')
    checked = document_snapshots([{k: d[k] for k in ['id', 'title', 'text']} for d in documents])
    if any(d['revision'] != c['revision'] for d, c in zip(documents, checked)):
        raise ValueError('Brontekst en versie verschillen')
    return {d['id']: d for d in checked}

def pack_context(chunks, documents, budget):
    sources = checked_sources(documents)
    if not isinstance(chunks, list) or len(chunks) > 256 or type(budget) is not int or not 0 <= budget <= 60000:
        raise ValueError('Maximaal 256 chunks en budget 0–60000 tekens')
    for chunk in chunks:
        if not isinstance(chunk, dict) or not isinstance(chunk.get('document_id'), str) or chunk['document_id'] not in sources:
            raise ValueError('Onbekende bron')
        chunk_coverage(sources[chunk['document_id']], [chunk])
    text, citations, seen_texts = '', [], set()
    for chunk in chunks:
        if chunk['text'] in seen_texts:
            continue
        label = 'S' + str(len(citations) + 1)
        block = f'[{label}] {chunk["document_id"]}@{chunk["revision"][:12]} [{chunk["start"]},{chunk["end"]})\n{chunk["text"]}'
        candidate = text + ('\n\n' if text else '') + block
        if len(candidate) > budget:
            continue
        text = candidate
        seen_texts.add(chunk['text'])
        citations.append({'source_id': label, 'document_id': chunk['document_id'], 'revision': chunk['revision'],
                          'start': chunk['start'], 'end': chunk['end'], 'quote': chunk['text']})
    return {'text': text, 'used_chars': len(text), 'citations': citations}

def verify_citations(citations, documents):
    sources = checked_sources(documents)
    if not isinstance(citations, list) or len(citations) > 256:
        raise ValueError('Maximaal 256 verwijzingen')
    results, seen = [], set()
    for c in citations:
        if not isinstance(c, dict) or set(c) != {'source_id', 'document_id', 'revision', 'start', 'end', 'quote'}:
            raise ValueError('Ongeldige verwijzingsvelden')
        if not isinstance(c['source_id'], str) or not re.fullmatch(r'S[1-9][0-9]{0,3}', c['source_id']) or c['source_id'] in seen or not isinstance(c['document_id'], str) or not re.fullmatch(r'[A-Za-z0-9_-]{1,40}', c['document_id']):
            raise ValueError('Unieke bronlabels en document-IDs vereist')
        if not isinstance(c['revision'], str) or not re.fullmatch(r'[a-f0-9]{64}', c['revision']) or type(c['start']) is not int or type(c['end']) is not int or not isinstance(c['quote'], str) or not 1 <= len(c['quote']) <= 20000:
            raise ValueError('Versie, posities of citaat ongeldig')
        seen.add(c['source_id']); source = sources.get(c['document_id'])
        status = 'valid'
        if source is None:
            status = 'unknown-source'
        elif c['revision'] != source['revision']:
            status = 'stale-source'
        elif not 0 <= c['start'] < c['end'] <= len(source['text']):
            status = 'invalid-span'
        elif c['quote'] != source['text'][c['start']:c['end']]:
            status = 'quote-mismatch'
        results.append({'source_id': c['source_id'], 'status': status})
    return results

def citation_scores(claims, valid_ids, support):
    def identifiers(items):
        return isinstance(items, list) and len(items) <= 256 and all(isinstance(i, str) and 1 <= len(i) <= 100 for i in items) and len(set(items)) == len(items)
    if not isinstance(claims, list) or len(claims) > 128 or not identifiers(valid_ids) or not isinstance(support, dict) or len(support) > 128:
        raise ValueError('Begrensde claims, geldige bronlabels en supporttabel vereist')
    if any(not isinstance(k, str) or not 1 <= len(k) <= 100 or not identifiers(v) for k, v in support.items()):
        raise ValueError('Supporttabel gebruikt claim-IDs en unieke bronlabels')
    seen, total, valid, supporting, covered = set(), 0, 0, 0, 0
    for claim in claims:
        if not isinstance(claim, dict) or set(claim) != {'id', 'refs'} or not isinstance(claim['id'], str) or not 1 <= len(claim['id']) <= 100 or claim['id'] in seen or not identifiers(claim['refs']):
            raise ValueError('Elke claim heeft een unieke ID en unieke refs')
        seen.add(claim['id'])
        refs, allowed = set(claim['refs']), set(support.get(claim['id'], []))
        good = refs & set(valid_ids)
        total += len(refs); valid += len(good); supporting += len(good & allowed); covered += bool(good & allowed)
    return {'reference_validity': valid / total if total else None,
            'support_precision': supporting / total if total else None,
            'claim_coverage': covered / len(claims) if claims else None}

Voer de code uit en verklaar voor jezelf waarom elke stap werkt.