Upload 76_generate_scugnizz_repair_dataset_v2.py with huggingface_hub

76_generate_scugnizz_repair_dataset_v2.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# /// script
+# dependencies = ["huggingface_hub"]
+# ///
+
+"""
+76_generate_scugnizz_repair_dataset.py
+
+Dataset sintetico mirato per correggere i problemi emersi nel benchmark:
+
+1) TOOL_RESULT -> risposta naturale senza inventare dati
+2) Copia esatta di hash, IP, IPv6, porte, domini, URL, numeri
+3) TOOL_CALL con nome tool e argomenti corretti
+
+Default:
+- 30.000 renderer
+- 10.000 exact-copy tecnico
+- 10.000 tool-calling
+Totale train circa 50.000 + validation.
+
+Uso:
+  uv run 76_generate_scugnizz_repair_dataset.py --upload --repo-id ProjectScugnizz/scugnizz-agentic-repair-50k
+
+HF Job:
+  hf jobs uv run --namespace ProjectScugnizz --flavor h200 --timeout 1h 76_generate_scugnizz_repair_dataset.py --upload --repo-id ProjectScugnizz/scugnizz-agentic-repair-50k
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import random
+from pathlib import Path
+
+from huggingface_hub import HfApi, upload_folder
+
+
+CITIES = ["Napoli","Trento","Udine","Genova","Bologna","Roma","Milano","Verona","Palermo","Cagliari","Aosta","Ancona","Lecce","Bari","Trieste","Pordenone"]
+CONDITIONS = ["sereno","pioggia","neve","vento","nebbia","caldo","nuvoloso","temporale"]
+STOCKS = ["AAPL","NVDA","TSLA","VWCE","MSFT","AMD","META","GOOGL","AMZN","SPY","ENI","ISP"]
+CURRENCIES = {"VWCE":"EUR","ENI":"EUR","ISP":"EUR"}
+ARTISTS = ["Metallica","Muse","Coldplay","Queen","Daft Punk","Radiohead","Battiato","Subsonica"]
+SONGS = ["One","Uprising","Yellow","Bohemian Rhapsody","One More Time","No Surprises","La cura","Nuvole rapide"]
+ALBUMS = ["...And Justice for All","The Resistance","Parachutes","A Night at the Opera","Discovery","OK Computer","L'imboscata","Microchip emozionale"]
+SENDERS = ["Marco","Anna","Giulia","Davide","Carla","Sergio","Luca","Elena"]
+EVENTS = ["Riunione","Audit","Backup","Manutenzione","Briefing","Formazione","Sopralluogo","Dentista"]
+DATES = ["oggi","domani","lunedì","martedì","mercoledì","giovedì","venerdì"]
+TIMES = ["08:30","09:00","09:30","10:15","14:00","15:45","16:30","18:00"]
+DOMAINS = ["redhotcyber.com","example.org","openai.com","scugnizz.ai","trenitaly.help","agenzia-login.info"]
+URLS = ["https://example.org/login","https://redhotcyber.com/article","https://trenitaly.help/pay","http://test.local/a.zip"]
+IPV4S = ["010.000.001.255","192.168.001.010","104.21.10.12","008.008.008.008","001.001.001.001","043.157.095.055"]
+IPV6S = [
+    "2001:0db8:0000:0000:0000:ff00:0042:8329",
+    "2001:db8:0000:0000:0000:ff00:0042:8329",
+    "fe80:0000:0000:0000:0202:b3ff:fe1e:8329",
+]
+HASHES_SHA256 = [
+    "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+    "a3f5c9019b2d44e7aa00ff11cc22dd33ee44ff556677889900aabbccddeeff00",
+    "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+    "0000000000000000000000000000000000000000000000000000000000000000",
+]
+HASHES_MD5 = [
+    "00112233445566778899aabbccddeeff",
+    "44d88612fea8a8f36de82e1278abb02f",
+    "ffffffffffffffffffffffffffffffff",
+    "00000000000000000000000000000000",
+]
+
+
+def jd(x):
+    return json.dumps(x, ensure_ascii=False, separators=(",", ":"))
+
+
+def row(messages, category):
+    return {
+        "messages": messages,
+        "source": "scugnizz-agentic-repair-v1",
+        "category": category,
+    }
+
+
+def one(system, user, assistant, category):
+    return row([
+        {"role": "system", "content": system},
+        {"role": "user", "content": user},
+        {"role": "assistant", "content": assistant},
+    ], category)
+
+
+def sys_renderer():
+    return (
+        "Se ricevi TOOL_RESULT o PAYLOAD, NON chiamare strumenti.\n"
+        "Rispondi solo usando i dati presenti.\n"
+        "Non inventare email, eventi, dispositivi, nomi, tool o valori.\n"
+        "Copia numeri, hash, IP, porte, domini e percentuali esattamente."
+    )
+
+
+def sys_tool():
+    return (
+        "You can call tools when needed.\n"
+        "Use only the available tool names and copy arguments exactly.\n"
+        "If a tool is required, answer only with TOOL_CALL JSON."
+    )
+
+
+def system_with_tools(lines):
+    return "\n".join([
+        "You can call tools when needed.",
+        "Use only the available tool names and copy arguments exactly.",
+        "If the user request requires a tool, answer only with TOOL_CALL.",
+        "",
+        "Available tools:",
+        *lines
+    ])
+
+
+def tool_line(name, required):
+    return f"- {name} | required: {', '.join(required)}" if required else f"- {name}"
+
+
+def call(name, args):
+    return "TOOL_CALL:\n" + jd({"name": name, "arguments": args})
+
+
+def renderer_weather(r):
+    city = r.choice(CITIES)
+    cond = r.choice(CONDITIONS)
+    temp = r.randint(-5, 39)
+    wind = r.randint(0, 80)
+    payload = {"tool":"weather.forecast","result":{"city":city,"condition":cond,"temperature_c":temp,"wind_kmh":wind,"uuid":"ignore"}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi in italiano usando solo città, meteo, temperatura e vento. Ignora uuid. Non aggiungere email o calendario."
+    assistant = f"A {city} il meteo è {cond}, con {temp} °C e vento a {wind} km/h."
+    return one(sys_renderer(), user, assistant, "renderer_weather")
+
+
+def renderer_finance(r):
+    sym = r.choice(STOCKS)
+    price = f"{r.randint(10,999)}.{r.randint(0,99):02d}"
+    cur = CURRENCIES.get(sym, "USD")
+    change = f"{r.uniform(-8,8):.2f}"
+    payload = {"tool":"finance.quote","result":{"symbol":sym,"price":price,"currency":cur,"change_percent":change}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi in italiano. Non chiamare tool. Copia ESATTAMENTE prezzo, valuta e percentuale."
+    assistant = f"{sym} quota {price} {cur}, con variazione del {change}%."
+    return one(sys_renderer(), user, assistant, "renderer_finance")
+
+
+def renderer_spotify(r):
+    i = r.randrange(len(ARTISTS))
+    payload = {"tool":"spotify.current_song","result":{"artist":ARTISTS[i],"title":SONGS[i],"album":ALBUMS[i]}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nTrasforma il risultato in italiano usando solo i valori presenti."
+    assistant = f"Stai ascoltando {SONGS[i]} di {ARTISTS[i]}, dall'album {ALBUMS[i]}."
+    return one(sys_renderer(), user, assistant, "renderer_spotify")
+
+
+def renderer_mail(r):
+    unread = r.randint(0, 99)
+    important = r.randint(0, min(15, unread))
+    sender = r.choice(SENDERS)
+    payload = {"tool":"mail.summary","result":{"unread":unread,"important":important,"latest_sender":sender}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nUsa solo questi dati. Non inventare altro."
+    assistant = f"Hai {unread} email non lette, di cui {important} importanti. L'ultima è di {sender}."
+    return one(sys_renderer(), user, assistant, "renderer_mail")
+
+
+def renderer_calendar(r):
+    title = r.choice(EVENTS); date = r.choice(DATES); time = r.choice(TIMES)
+    payload = {"tool":"calendar.next_event","result":{"title":title,"date":date,"time":time}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi in italiano usando solo questi dati."
+    assistant = f"Il prossimo evento è {title}, {date} alle {time}."
+    return one(sys_renderer(), user, assistant, "renderer_calendar")
+
+
+def renderer_dns(r):
+    domain = r.choice(DOMAINS)
+    ipv4 = r.choice(IPV4S)
+    mx = "mail." + domain
+    payload = {"tool":"dns.lookup","result":{"domain":domain,"ipv4":ipv4,"mx":mx}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi usando solo dominio, IPv4 e MX. Copia i valori esattamente."
+    assistant = f"Il dominio {domain} ha IPv4 {ipv4} e record MX {mx}."
+    return one(sys_renderer(), user, assistant, "renderer_dns")
+
+
+def renderer_whois(r):
+    domain = r.choice(DOMAINS)
+    registrar = r.choice(["ICANN","Namecheap","IONOS","Gandi","Cloudflare"])
+    created = f"{r.randint(2000,2026)}-{r.randint(1,12):02d}-{r.randint(1,28):02d}"
+    payload = {"tool":"whois.lookup","result":{"domain":domain,"registrar":registrar,"created":created}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi usando solo questi dati. Non aggiungere next steps."
+    assistant = f"Il dominio {domain} risulta registrato presso {registrar}; data di creazione: {created}."
+    return one(sys_renderer(), user, assistant, "renderer_whois")
+
+
+def renderer_json_complex(r):
+    city = r.choice(CITIES); temp = r.randint(-3, 38)
+    unread = r.randint(0, 25)
+    title = r.choice(EVENTS); time = r.choice(TIMES)
+    payload = {"weather":{"city":city,"temperature_c":temp},"mail":{"unread":unread},"calendar":{"title":title,"time":time}}
+    user = f"Trasforma questo JSON in italiano. Usa solo i valori presenti.\n\n{jd(payload)}"
+    assistant = f"A {city} ci sono {temp} °C. Hai {unread} email non lette. Il prossimo evento è {title} alle {time}."
+    return one(sys_renderer(), user, assistant, "renderer_json_complex")
+
+
+def exact_hash(r):
+    sha = r.choice(HASHES_SHA256)
+    md5 = r.choice(HASHES_MD5)
+    size = r.choice([2048,1048576,512000,123456789])
+    payload = {"file":{"sha256":sha,"md5":md5,"size_bytes":size}}
+    user = f"PAYLOAD:\n{jd(payload)}\n\nRispondi in italiano copiando ESATTAMENTE sha256, md5 e size_bytes."
+    assistant = f"SHA256: {sha}. MD5: {md5}. Dimensione: {size} byte."
+    return one(sys_renderer(), user, assistant, "exact_hash")
+
+
+def exact_network(r):
+    ipv4 = r.choice(IPV4S); ipv6 = r.choice(IPV6S); port = r.choice([80,443,8080,8443,53]); proto = r.choice(["TCP","UDP"])
+    payload = {"network":{"ipv4":ipv4,"ipv6":ipv6,"port":port,"protocol":proto},"debug":"ignore"}
+    user = f"PAYLOAD:\n{jd(payload)}\n\nVerbalizza i dati. Non cambiare nessun numero, zero iniziale o separatore. Ignora debug."
+    assistant = f"Endpoint {proto} {ipv4}:{port}. IPv6 {ipv6}."
+    return one(sys_renderer(), user, assistant, "exact_network")
+
+
+def exact_url_domain(r):
+    url = r.choice(URLS); domain = r.choice(DOMAINS)
+    payload = {"url":url,"domain":domain,"risk_score":r.randint(0,100)}
+    user = f"PAYLOAD:\n{jd(payload)}\n\nCopia esattamente URL, dominio e risk_score."
+    assistant = f"URL: {url}. Dominio: {domain}. Risk score: {payload['risk_score']}."
+    return one(sys_renderer(), user, assistant, "exact_url_domain")
+
+
+def tool_weather(r):
+    city = r.choice(CITIES)
+    sys = system_with_tools([tool_line("weather.forecast", ["city"])])
+    user = r.choice([f"Che tempo fa a {city}?", f"Mi dici il meteo di {city}?", f"Weather for {city}."])
+    return one(sys, user, call("weather.forecast", {"city":city}), "tool_weather")
+
+
+def tool_finance(r):
+    sym = r.choice(STOCKS)
+    sys = system_with_tools([tool_line("finance.quote", ["symbol"])])
+    user = r.choice([f"Quanto quota {sym}?", f"Prezzo attuale di {sym}.", f"Quote for {sym}."])
+    return one(sys, user, call("finance.quote", {"symbol":sym}), "tool_finance")
+
+
+def tool_dns(r):
+    domain = r.choice(DOMAINS)
+    sys = system_with_tools([tool_line("dns.lookup", ["domain","record_type"])])
+    rt = r.choice(["A","AAAA","MX","NS","TXT"])
+    user = r.choice([f"Qual è il record {rt} di {domain}?", f"Risolvi {domain} record {rt}."])
+    return one(sys, user, call("dns.lookup", {"domain":domain,"record_type":rt}), "tool_dns")
+
+
+def tool_spotify(r):
+    sys = system_with_tools([tool_line("spotify.current_song", [])])
+    user = r.choice(["Che brano sto ascoltando?", "Che canzone sta suonando?", "Current song?"])
+    return one(sys, user, call("spotify.current_song", {}), "tool_spotify")
+
+
+def tool_mail(r):
+    sys = system_with_tools([tool_line("unread_mail_count", [])])
+    user = r.choice(["Quante email non lette ho?", "Unread emails?", "Controlla le mail non lette."])
+    return one(sys, user, call("unread_mail_count", {}), "tool_mail")
+
+
+def tool_calendar(r):
+    sys = system_with_tools([tool_line("calendar.next_event", [])])
+    user = r.choice(["Qual è il mio prossimo appuntamento?", "Cosa ho in agenda?", "Next calendar event?"])
+    return one(sys, user, call("calendar.next_event", {}), "tool_calendar")
+
+
+RENDERERS = [renderer_weather, renderer_finance, renderer_spotify, renderer_mail, renderer_calendar, renderer_dns, renderer_whois, renderer_json_complex]
+EXACTS = [exact_hash, exact_network, exact_url_domain]
+TOOLS = [tool_weather, tool_finance, tool_dns, tool_spotify, tool_mail, tool_calendar]
+
+
+def key(obj):
+    return hashlib.sha256(jd(obj["messages"]).encode("utf-8")).hexdigest()
+
+
+def generate(out_dir, n_renderer, n_exact, n_tool, val_size, seed):
+    r = random.Random(seed)
+    out = Path(out_dir); out.mkdir(parents=True, exist_ok=True)
+    rows = []
+    seen = set()
+    counts = {}
+
+    def add(gen):
+        for _ in range(1000):
+            obj = gen(r)
+            k = key(obj)
+            if k not in seen:
+                seen.add(k)
+                rows.append(obj)
+                counts[obj["category"]] = counts.get(obj["category"],0)+1
+                return
+        rows.append(gen(r))
+
+    # Distribuzione forzata: ogni categoria riceve lo stesso numero di esempi
+    per_renderer = n_renderer // len(RENDERERS)
+    rem_renderer = n_renderer % len(RENDERERS)
+    for idx, gen in enumerate(RENDERERS):
+        target = per_renderer + (1 if idx < rem_renderer else 0)
+        for i in range(target):
+            add(gen)
+        print(f"{gen.__name__}: {target}", flush=True)
+        if (i+1) % 5000 == 0:
+            print(f"RENDERER {i+1}/{n_renderer}", flush=True)
+
+    per_exact = n_exact // len(EXACTS)
+    rem_exact = n_exact % len(EXACTS)
+    for idx, gen in enumerate(EXACTS):
+        target = per_exact + (1 if idx < rem_exact else 0)
+        for i in range(target):
+            add(gen)
+        print(f"{gen.__name__}: {target}", flush=True)
+        if (i+1) % 2500 == 0:
+            print(f"EXACT {i+1}/{n_exact}", flush=True)
+
+    per_tool = n_tool // len(TOOLS)
+    rem_tool = n_tool % len(TOOLS)
+    for idx, gen in enumerate(TOOLS):
+        target = per_tool + (1 if idx < rem_tool else 0)
+        for i in range(target):
+            add(gen)
+        print(f"{gen.__name__}: {target}", flush=True)
+        if (i+1) % 2500 == 0:
+            print(f"TOOL {i+1}/{n_tool}", flush=True)
+
+    r.shuffle(rows)
+    val_n = min(val_size, max(1, len(rows)//100))
+    val = rows[:val_n]
+    train = rows[val_n:]
+
+    train_path = out / "train.jsonl"
+    val_path = out / "validation.jsonl"
+
+    with train_path.open("w", encoding="utf-8") as f:
+        for obj in train:
+            f.write(json.dumps(obj, ensure_ascii=False) + "\n")
+
+    with val_path.open("w", encoding="utf-8") as f:
+        for obj in val:
+            f.write(json.dumps(obj, ensure_ascii=False) + "\n")
+
+    (out / "README.md").write_text(
+        "---\nlicense: cc-by-4.0\nlanguage:\n- it\n- en\ntask_categories:\n- text-generation\n---\n\n"
+        "# Scugnizz Agentic Repair 50k\n\n"
+        "Dataset sintetico bilanciato per correggere renderer, copia esatta e tool calling.\n\n"
+        f"Train: {len(train)}\n\nValidation: {len(val)}\n\n"
+        "Categorie:\n```json\n" + json.dumps(counts, ensure_ascii=False, indent=2) + "\n```\n",
+        encoding="utf-8"
+    )
+
+    print("DONE", out, "TRAIN", len(train), "VAL", len(val), flush=True)
+    print(json.dumps(counts, ensure_ascii=False, indent=2), flush=True)
+    print("SAMPLE", json.dumps(rows[0], ensure_ascii=False)[:2000], flush=True)
+    return out
+
+
+def upload(folder, repo_id, private=False):
+    token = os.environ.get("HF_TOKEN") or os.environ.get("UV_SCRIPT_HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    api = HfApi(token=token)
+    api.create_repo(repo_id, repo_type="dataset", private=private, exist_ok=True)
+    upload_folder(repo_id=repo_id, repo_type="dataset", folder_path=str(folder), commit_message="Add Scugnizz agentic repair dataset", token=token)
+    print("UPLOADED", repo_id, flush=True)
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--out-dir", default="data/scugnizz-agentic-repair-50k")
+    p.add_argument("--repo-id", default="ProjectScugnizz/scugnizz-agentic-repair-50k")
+    p.add_argument("--n-renderer", type=int, default=30000)
+    p.add_argument("--n-exact", type=int, default=10000)
+    p.add_argument("--n-tool", type=int, default=10000)
+    p.add_argument("--val-size", type=int, default=1000)
+    p.add_argument("--seed", type=int, default=20260710)
+    p.add_argument("--upload", action="store_true")
+    p.add_argument("--private", action="store_true")
+    a = p.parse_args()
+
+    folder = generate(a.out_dir, a.n_renderer, a.n_exact, a.n_tool, a.val_size, a.seed)
+    if a.upload:
+        upload(folder, a.repo_id, a.private)
+
+
+if __name__ == "__main__":
+    main()