Upload 76_generate_scugnizz_repair_dataset_v4.py with huggingface_hub

76_generate_scugnizz_repair_dataset_v4.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# /// script
+# dependencies = ["huggingface_hub"]
+# ///
+
+import argparse
+import hashlib
+import json
+import os
+import random
+import secrets
+import string
+from pathlib import Path
+from huggingface_hub import HfApi, upload_folder
+
+FIRST = ["Marco","Anna","Giulia","Davide","Carla","Sergio","Luca","Elena","Paolo","Marta","Simone","Laura","Andrea","Sara","Fabio","Nadia","Giorgio","Irene"]
+CITIES = ["Roma","Milano","Napoli","Torino","Palermo","Genova","Bologna","Firenze","Bari","Catania","Venezia","Verona","Messina","Padova","Trieste","Taranto","Brescia","Parma","Modena","Reggio Emilia","Perugia","Livorno","Ravenna","Cagliari","Foggia","Rimini","Salerno","Ferrara","Sassari","Latina","Giugliano","Monza","Siracusa","Pescara","Bergamo","Forlì","Trento","Vicenza","Terni","Bolzano","Novara","Piacenza","Ancona","Andria","Arezzo","Udine","Cesena","Lecce","Pesaro","Barletta","Alessandria","La Spezia","Pordenone","Gorizia","Aosta","Bologna"]
+CONDITIONS = ["sereno","pioggia","neve","vento","nebbia","caldo","nuvoloso","temporale","grandine","coperto","foschia","afa"]
+STOCKS = ["AAPL","NVDA","TSLA","VWCE","MSFT","AMD","META","GOOGL","AMZN","SPY","ENI","ISP","NFLX","INTC","ORCL","AVGO","BABA","SAP","ASML","ADBE","CRM","UBER","RACE","LDO","UCG","G","PST","BTC","ETH"]
+EVENTS = ["Riunione","Audit","Backup","Manutenzione","Briefing","Formazione","Sopralluogo","Dentista","Check sicurezza","Aggiornamento","Call progetto","Verifica log","Report","Analisi OSINT","Consegna","Controllo backup","Patch day","Riunione tecnica"]
+ROOMS = ["garage","cucina","salotto","camera","studio","ingresso","cantina","terrazzo","bagno","corridoio","ufficio","sala server"]
+DEVICES = ["porta","sensore porta","luce","termostato","telecamera","sirena","presa smart","sensore finestra","sensore movimento","gateway","router","UPS"]
+ARTISTS = ["Muse","Metallica","Coldplay","Queen","Radiohead","Daft Punk","Battiato","Subsonica","Pink Floyd","Nirvana","Pearl Jam","U2","REM","Depeche Mode","The Cure","Måneskin","Elisa","Ligabue","Vasco Rossi","ACDC","Led Zeppelin","David Bowie","Franco Califano","Lucio Dalla","Pino Daniele","Massive Attack","The Prodigy","Arctic Monkeys"]
+WORDS = ["red","blue","silent","night","cyber","rain","stone","fire","moon","signal","river","shadow","light","dream","road","ghost","storm","zero","future","city","heart","ocean","data","noise","pattern","radio","velvet","silver","gold","black","white","wild","electric","digital","secret"]
+
+def jd(x):
+    return json.dumps(x, ensure_ascii=False, separators=(",", ":"))
+
+def rand_word(r, n=8):
+    alphabet = string.ascii_lowercase + string.digits
+    return "".join(r.choice(alphabet) for _ in range(n))
+
+def rand_domain(r):
+    tlds = ["com","it","net","org","info","ai","dev","cloud","help","site"]
+    base = r.choice(["redhotcyber","scugnizz","example","agenzia","login","secure","portal","mail","auth","cloud","service","pay","update","verify"])
+    suffix = rand_word(r, r.randint(3,8))
+    return f"{base}-{suffix}.{r.choice(tlds)}"
+
+def rand_url(r):
+    proto = r.choice(["https","http"])
+    path = "/".join([r.choice(["login","pay","verify","api","download","reset","user","invoice","check"]), rand_word(r,6)])
+    return f"{proto}://{rand_domain(r)}/{path}"
+
+def rand_ipv4(r, keep_zeros=True):
+    parts = [r.randint(0,255) for _ in range(4)]
+    if keep_zeros:
+        return ".".join(f"{x:03d}" for x in parts)
+    return ".".join(str(x) for x in parts)
+
+def rand_ipv6(r):
+    return ":".join(f"{r.randint(0,65535):04x}" for _ in range(8))
+
+def rand_mac(r):
+    return ":".join(f"{r.randint(0,255):02x}" for _ in range(6))
+
+def rand_time(r):
+    return f"{r.randint(0,23):02d}:{r.choice([0,5,10,15,20,25,30,35,40,45,50,55]):02d}"
+
+def rand_date(r):
+    return r.choice(["oggi","domani","lunedì","martedì","mercoledì","giovedì","venerdì","sabato","domenica",f"2026-{r.randint(1,12):02d}-{r.randint(1,28):02d}"])
+
+def rand_song(r):
+    return " ".join(w.capitalize() for w in r.sample(WORDS, r.randint(1,4)))
+
+def uniq(r):
+    return rand_word(r, 8)
+
+def noisy_suffix(r):
+    # Piccolo identificatore naturale per rendere unico l'esempio senza cambiare il senso.
+    return r.choice([
+        f" richiesta {uniq(r)}",
+        f" per favore {uniq(r)}",
+        f" grazie {uniq(r)}",
+        f" id {uniq(r)}",
+        f" riferimento {uniq(r)}",
+    ])
+
+def row(messages, category):
+    return {"messages": messages, "source": "scugnizz-agentic-repair-v3", "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, URL e percentuali esattamente."
+    )
+
+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, cond = r.choice(CITIES), r.choice(CONDITIONS)
+    temp, wind, hum = r.randint(-10,42), r.randint(0,100), r.randint(10,99)
+    payload = {"tool":"weather.forecast","result":{"city":city,"condition":cond,"temperature_c":temp,"wind_kmh":wind,"humidity":hum,"uuid":secrets.token_hex(4)}}
+    prompts = [
+        "Rispondi in italiano usando solo città, meteo, temperatura, vento e umidità. Ignora uuid.",
+        "Scrivi una frase naturale. Non aggiungere email, calendario o altri dati.",
+        "Usa esclusivamente i dati utili del risultato meteo."
+    ]
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\n{r.choice(prompts)}"
+    ans = f"A {city} il meteo è {cond}, con {temp} °C, vento a {wind} km/h e umidità al {hum}%."
+    return one(sys_renderer(), user, ans, "renderer_weather")
+
+def renderer_finance(r):
+    sym = r.choice(STOCKS)
+    price = f"{r.randint(1,9999)}.{r.randint(0,99):02d}"
+    cur = "EUR" if sym in ["VWCE","ENI","ISP","RACE","UCG","G","PST"] else "USD"
+    ch = f"{r.uniform(-15,15):.2f}"
+    payload = {"tool":"finance.quote","result":{"symbol":sym,"price":price,"currency":cur,"change_percent":ch,"request_id":secrets.token_hex(3)}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi in italiano. Non chiamare tool. Copia ESATTAMENTE prezzo, valuta e percentuale. Ignora request_id."
+    ans = f"{sym} quota {price} {cur}, con variazione del {ch}%."
+    return one(sys_renderer(), user, ans, "renderer_finance")
+
+def renderer_spotify(r):
+    artist = r.choice(ARTISTS)
+    title = rand_song(r)
+    album = rand_song(r) + " " + str(r.randint(1960,2026))
+    track = r.randint(1,24)
+    duration = r.randint(90,520)
+    payload = {"tool":"spotify.current_song","result":{"artist":artist,"title":title,"album":album,"track":track,"duration_s":duration}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nTrasforma il risultato in italiano usando solo i valori presenti."
+    ans = f"Stai ascoltando {title} di {artist}, dall'album {album}. Traccia {track}, durata {duration} secondi."
+    return one(sys_renderer(), user, ans, "renderer_spotify")
+
+def renderer_mail(r):
+    unread = r.randint(0,250); important = r.randint(0, min(50, unread)); sender = r.choice(FIRST)
+    subject = r.choice(["Fattura","Report","Aggiornamento","Riunione","Richiesta","Avviso","Scadenza"]) + " " + rand_word(r,5)
+    payload = {"tool":"mail.summary","result":{"unread":unread,"important":important,"latest_sender":sender,"latest_subject":subject}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nUsa solo questi dati. Non inventare altro."
+    ans = f"Hai {unread} email non lette, di cui {important} importanti. L'ultima è di {sender}, con oggetto: {subject}."
+    return one(sys_renderer(), user, ans, "renderer_mail")
+
+def renderer_calendar(r):
+    title, date, time = r.choice(EVENTS)+" "+rand_word(r,4), rand_date(r), rand_time(r)
+    location = r.choice(["ufficio","online","sala riunioni","Questura","Udine","Trieste","remoto","sede centrale"])
+    payload = {"tool":"calendar.next_event","result":{"title":title,"date":date,"time":time,"location":location}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi in italiano usando solo questi dati."
+    ans = f"Il prossimo evento è {title}, {date} alle {time}, presso {location}."
+    return one(sys_renderer(), user, ans, "renderer_calendar")
+
+def renderer_dns(r):
+    domain = rand_domain(r); ipv4 = rand_ipv4(r, keep_zeros=r.choice([True,False])); mx = "mail-" + rand_word(r,4) + "." + domain
+    ns = "ns" + str(r.randint(1,4)) + "." + rand_domain(r)
+    payload = {"tool":"dns.lookup","result":{"domain":domain,"ipv4":ipv4,"mx":mx,"ns":ns}}
+    user = f"TOOL_RESULT:\n{jd(payload)}\n\nRispondi usando solo dominio, IPv4, MX e NS. Copia i valori esattamente."
+    ans = f"Il dominio {domain} ha IPv4 {ipv4}, record MX {mx} e nameserver {ns}."
+    return one(sys_renderer(), user, ans, "renderer_dns")
+
+def renderer_whois(r):
+    domain = rand_domain(r)
+    registrar = r.choice(["ICANN","Namecheap","IONOS","Gandi","Cloudflare","Register.it","Aruba","OVH","GoDaddy"])
+    created = f"{r.randint(1995,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."
+    ans = f"Il dominio {domain} risulta registrato presso {registrar}; data di creazione: {created}."
+    return one(sys_renderer(), user, ans, "renderer_whois")
+
+def renderer_json_complex(r):
+    city = r.choice(CITIES); temp = r.randint(-5,40); unread = r.randint(0,50)
+    title, time = r.choice(EVENTS)+" "+rand_word(r,3), rand_time(r)
+    room, device, state = r.choice(ROOMS), r.choice(DEVICES), r.choice(["aperto","chiuso","attivo","spento","online","offline"])
+    payload = {"weather":{"city":city,"temperature_c":temp,"condition":r.choice(CONDITIONS)},"mail":{"unread":unread,"latest_sender":r.choice(FIRST)},"calendar":{"title":title,"time":time},"home":{"room":room,"device":device,"state":state}}
+    user = f"Trasforma questo JSON in italiano. Usa solo i valori presenti.\n\n{jd(payload)}"
+    ans = f"A {city} il meteo è {payload['weather']['condition']} con {temp} °C. Hai {unread} email non lette; l'ultima è di {payload['mail']['latest_sender']}. Il prossimo evento è {title} alle {time}. Il dispositivo {device} in {room} risulta {state}."
+    return one(sys_renderer(), user, ans, "renderer_json_complex")
+
+def exact_hash(r):
+    sha256, md5, sha1 = secrets.token_hex(32), secrets.token_hex(16), secrets.token_hex(20)
+    size = r.randint(1, 10_000_000_000)
+    payload = {"file":{"sha256":sha256,"md5":md5,"sha1":sha1,"size_bytes":size}}
+    user = f"PAYLOAD:\n{jd(payload)}\n\nRispondi in italiano copiando ESATTAMENTE sha256, sha1, md5 e size_bytes."
+    ans = f"SHA256: {sha256}. SHA1: {sha1}. MD5: {md5}. Dimensione: {size} byte."
+    return one(sys_renderer(), user, ans, "exact_hash")
+
+def exact_network(r):
+    ipv4, ipv6, mac = rand_ipv4(r, True), rand_ipv6(r), rand_mac(r)
+    port, proto = r.randint(1,65535), r.choice(["TCP","UDP"])
+    payload = {"network":{"ipv4":ipv4,"ipv6":ipv6,"mac":mac,"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."
+    ans = f"Endpoint {proto} {ipv4}:{port}. IPv6 {ipv6}. MAC {mac}."
+    return one(sys_renderer(), user, ans, "exact_network")
+
+def exact_url_domain(r):
+    url, domain = rand_url(r), rand_domain(r)
+    score = r.randint(0,100)
+    payload = {"url":url,"domain":domain,"risk_score":score}
+    user = f"PAYLOAD:\n{jd(payload)}\n\nCopia esattamente URL, dominio e risk_score."
+    ans = f"URL: {url}. Dominio: {domain}. Risk score: {score}."
+    return one(sys_renderer(), user, ans, "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}.",
+        f"Vorrei conoscere le previsioni per {city}.",
+        f"Meteo {city}, grazie.",
+        f"Controlla il tempo a {city}.",
+        f"Serve il meteo aggiornato per {city}.",
+        f"Dimmi temperatura e condizioni a {city}.",
+    ]) + noisy_suffix(r)
+    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}.",
+        f"Controlla la quotazione {sym}.",
+        f"Mi dai il valore di {sym}?",
+        f"Valore corrente ticker {sym}.",
+        f"Controlla il prezzo del titolo {sym}.",
+    ]) + noisy_suffix(r)
+    return one(sys, user, call("finance.quote", {"symbol": sym}), "tool_finance")
+
+def tool_dns(r):
+    domain, rt = rand_domain(r), r.choice(["A","AAAA","MX","NS","TXT"])
+    sys = system_with_tools([tool_line("dns.lookup", ["domain","record_type"])])
+    user = r.choice([f"Qual è il record {rt} di {domain}?", f"Risolvi {domain} record {rt}.", f"DNS {rt} per {domain}."])
+    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?",
+        "Dimmi la canzone in riproduzione.",
+        "Qual è il brano corrente?",
+        "Identifica la traccia attuale.",
+        "Cosa sta andando ora su Spotify?",
+    ]) + noisy_suffix(r)
+    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.",
+        "Quanta posta non letta c'è?",
+        "Dimmi il numero di email da leggere.",
+        "Verifica la posta non letta.",
+        "Conta le email ancora da leggere.",
+    ]) + noisy_suffix(r)
+    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?",
+        "Dimmi il prossimo evento.",
+        "Qual è la prossima riunione?",
+        "Controlla il prossimo evento in calendario.",
+        "Che appuntamento ho dopo?",
+    ]) + noisy_suffix(r)
+    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 stable(obj):
+    return hashlib.sha256(jd(obj["messages"]).encode("utf-8")).hexdigest()
+
+def add_unique(rows, seen, counts, gen, r, target):
+    made = 0
+    attempts = 0
+    while made < target and attempts < target * 20:
+        attempts += 1
+        obj = gen(r)
+        k = stable(obj)
+        if k in seen:
+            continue
+        seen.add(k); rows.append(obj)
+        counts[obj["category"]] = counts.get(obj["category"], 0) + 1
+        made += 1
+    if made < target:
+        raise RuntimeError(f"Categoria {gen.__name__} ha prodotto solo {made}/{target} esempi unici")
+    print(f"{gen.__name__}: {made}", flush=True)
+
+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, counts = [], set(), {}
+
+    for idx, gen in enumerate(RENDERERS):
+        target = n_renderer // len(RENDERERS) + (1 if idx < n_renderer % len(RENDERERS) else 0)
+        add_unique(rows, seen, counts, gen, r, target)
+
+    for idx, gen in enumerate(EXACTS):
+        target = n_exact // len(EXACTS) + (1 if idx < n_exact % len(EXACTS) else 0)
+        add_unique(rows, seen, counts, gen, r, target)
+
+    for idx, gen in enumerate(TOOLS):
+        target = n_tool // len(TOOLS) + (1 if idx < n_tool % len(TOOLS) else 0)
+        add_unique(rows, seen, counts, gen, r, target)
+
+    r.shuffle(rows)
+    val_n = min(val_size, max(1, len(rows)//100))
+    val, train = rows[:val_n], rows[val_n:]
+
+    with (out/"train.jsonl").open("w", encoding="utf-8") as f:
+        for obj in train: f.write(json.dumps(obj, ensure_ascii=False) + "\n")
+    with (out/"validation.jsonl").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 v3\n\n"
+        + json.dumps(counts, ensure_ascii=False, indent=2),
+        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 v3", token=token)
+    print("UPLOADED", repo_id, flush=True)
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--out-dir", default="data/scugnizz-agentic-repair-50k-v3")
+    p.add_argument("--repo-id", default="ProjectScugnizz/scugnizz-agentic-repair-50k-v3")
+    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()