#!/usr/bin/env python3
"""Extract one query/key rotary pair and its full-head comparison from Pythia-70M."""
import argparse
import hashlib
import json
import math
from pathlib import Path
import torch
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.models.gpt_neox.modeling_gpt_neox import apply_rotary_pos_emb

MODEL='EleutherAI/pythia-70m'
REVISION='a39f36b100fe8a5377810d56c3f4789b9c53ac42'
TEXT='The capital of France is'


def encode_text(tokenizer, text):
    if not 1 <= len(text) <= 500:
        raise ValueError('Teksten skal indeholde 1–500 tegn.')
    ids=tokenizer.encode(text, add_special_tokens=False)
    if not 2 <= len(ids) <= 32:
        raise ValueError('Teksten skal give 2–32 tokens uden automatiske specialtokens.')
    return ids


def extract(model, tokenizer, text=TEXT, query=None, key=None, layer=0, head_index=0, component=0):
    if not 0 <= layer < 6 or not 0 <= head_index < 8 or not 0 <= component < 8:
        raise ValueError('Vælg lag 0–5, head 0–7 og komponentpar 0–7.')
    ids=encode_text(tokenizer,text)
    query=len(ids)-1 if query is None else query
    key=max(0,query-2) if key is None else key
    if not 0 <= key <= query < len(ids):
        raise ValueError('Positioner tælles fra 0; vælg 0 ≤ key ≤ query < antal tokens.')
    inputs=torch.tensor([ids]); cache={}
    attention=model.gpt_neox.layers[layer].attention
    def capture(_module, _inputs, output): cache['qkv']=output.detach()
    handle=attention.query_key_value.register_forward_hook(capture)
    try:
        with torch.inference_mode():
            result=model(inputs, output_attentions=True, use_cache=False)
            cos,sin=model.gpt_neox.rotary_emb(torch.zeros(1,len(ids),model.config.hidden_size),torch.arange(len(ids)).unsqueeze(0))
    finally:
        handle.remove()
    head=attention.head_size; rotary=cos.shape[-1]; half=rotary//2
    qkv=cache['qkv'].view(1,len(ids),model.config.num_attention_heads,3*head).transpose(1,2)
    q,k,_=qkv.chunk(3,dim=-1)
    qr,kr=apply_rotary_pos_emb(q,k,cos,sin)
    scores=(qr[0,head_index,query] @ kr[0,head_index,:query+1].T) * attention.scaling
    verified=torch.softmax(scores.float(),dim=-1)
    if not torch.allclose(verified,result.attentions[layer][0,head_index,query,:query+1],atol=1e-6,rtol=1e-5):
        raise ValueError('Den genberegnede attention stemmer ikke med modellen.')
    def pair(t,pos): return [float(t[0,head_index,pos,component]),float(t[0,head_index,pos,component+half])]
    before_q,before_k=pair(q,query),pair(k,key)
    after_q,after_k=pair(qr,query),pair(kr,key)
    def dot(a,b): return sum(x*y for x,y in zip(a,b))
    data={'format':'learning-lab-pythia-rope-v1','model':MODEL,'revision':REVISION,'prompt':text,
          'tokens':[tokenizer.decode([i],clean_up_tokenization_spaces=False) for i in ids], 'ids':ids,
          'layer':layer,'head':head_index,'head_dimensions':head,'rotary_dimensions':rotary,'pair_indices':[component,component+half],
          'query_position':query,'key_position':key,'query_before':before_q,'key_before':before_k,
          'query_after':after_q,'key_after':after_k,'pair_before_dot':dot(before_q,before_k),
          'pair_after_dot':dot(after_q,after_k),
          'full_before_dot':float((q[0,head_index,query]*k[0,head_index,key]).sum()),
          'full_after_dot':float((qr[0,head_index,query]*kr[0,head_index,key]).sum()),
          'attention_weight':float(result.attentions[layer][0,head_index,query,key]),
          'torch_version':str(torch.__version__),'transformers_version':transformers.__version__,
          'script_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()}
    if not all(math.isfinite(x) for x in [*before_q,*before_k,*after_q,*after_k,data['full_after_dot'],data['attention_weight']]):
        raise ValueError('Målingen indeholder ugyldige tal.')
    return data


def main():
    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--offline',action='store_true');p.add_argument('--output',type=Path,default=Path('rope-pythia.json'));source=p.add_mutually_exclusive_group();source.add_argument('--text');source.add_argument('--text-file',type=Path,help='Læs den præcise UTF-8-tekst fra en lokal fil.');p.add_argument('--query',type=int);p.add_argument('--key',type=int);p.add_argument('--layer',type=int,default=0);p.add_argument('--head',type=int,default=0);p.add_argument('--pair',type=int,default=0);p.add_argument('--list-tokens',action='store_true',help='Vis positioner og ID’er uden at indlæse modelvægte.');args=p.parse_args()
    try:
        if args.text_file is not None:
            with args.text_file.open('r',encoding='utf-8',newline='') as source_file:
                text=source_file.read(501)
        else:
            text=TEXT if args.text is None else args.text
    except (OSError,UnicodeError) as exc:p.error(f'Kunne ikke læse tekstfilen: {exc}')
    if not args.list_tokens and args.output.exists(): p.error('Outputfilen findes allerede; vælg et nyt navn.')
    if not 1 <= len(text) <= 500: p.error('Teksten skal indeholde 1–500 tegn.')
    if not 0 <= args.layer < 6 or not 0 <= args.head < 8 or not 0 <= args.pair < 8: p.error('Vælg lag 0–5, head 0–7 og komponentpar 0–7.')
    if (args.query is not None and args.query < 0) or (args.key is not None and args.key < 0) or (args.query is not None and args.key is not None and args.key > args.query): p.error('Positioner tælles fra 0; key må ikke være efter query.')
    torch.set_num_threads(1)
    try:
        tokenizer=AutoTokenizer.from_pretrained(MODEL,revision=REVISION,local_files_only=args.offline)
        if args.list_tokens:
            ids=encode_text(tokenizer,text)
            print('Position · token-ID · dekodet token (uden automatiske specialtokens)')
            for position, token_id in enumerate(ids):
                piece=tokenizer.decode([token_id],clean_up_tokenization_spaces=False)
                print(f'{position} · {token_id} · {json.dumps(piece,ensure_ascii=False)}')
            print('Enkeltvis dekodning kan vise erstatningstegn for bytefragmenter.')
            return
        model=AutoModelForCausalLM.from_pretrained(MODEL,revision=REVISION,local_files_only=args.offline,attn_implementation='eager').eval()
        data=extract(model,tokenizer,text,args.query,args.key,args.layer,args.head,args.pair)
        with args.output.open('x',encoding='utf-8') as f:json.dump(data,f,ensure_ascii=False,indent=2,allow_nan=False)
    except (OSError,ValueError,RuntimeError) as exc:p.error(str(exc))
    print(f"Par: {data['pair_before_dot']:.4f} → {data['pair_after_dot']:.4f}. Gemt: {args.output}")
if __name__=='__main__':main()
