data/scripts/generate_vyakaran_master.py

#!/usr/bin/env python3
"""
Comprehensive Hindi Vyakaran & Hinglish Grammar Master Generator:
1. Varn Vichar (Phonetics, Swar, Vyanjan, Uccharan Sthan)
2. Sandhi & Sandhi Viched (Swar, Vyanjan, Visarga with complete rules & 500+ examples)
3. Samas & Vigrah (Avyayibhav, Tatpurush, Karmdharay, Dvigu, Dvandva, Bahuvrihi)
4. Karak & Vibhakti (All 8 Karaks with distinctions e.g. Karan vs Apadan)
5. Kriya (Sakarmak vs Akarmak, Prernarthak, Samyukt Kriya)
6. Kaal & Vachya (Tenses, Kartrivachya, Karmavachya, Bhavavachya)
7. Vakya Shuddhi (Sentence Error Spotting & Correction - 500+ tricky pairs)
8. Ras, Chhand, Alankar (Poetic devices, Matra counting, examples)
9. Muhavare & Lokoktiyan (Meanings & contextual sentence usage)
10. Hinglish Grammar & Code-Switching Rules (Syntax, Tense Conjugation, Spelling variations)
"""

import random
import pandas as pd
from huggingface_hub import HfApi

DEST_REPO = "ViuAI/viu-mini-raw-pretrain"
REPO_TYPE = "dataset"

def generate_sandhi_corpus():
    examples = [
        # Swar - Deergh
        ("हिम + आलय", "हिमालय", "दीर्घ स्वर संधि (अ + आ = आ)", "जब ह्रस्व या दीर्घ अ, इ, उ के बाद वही ह्रस्व या दीर्घ स्वर आए तो दोनों मिलकर दीर्घ (आ, ई, ऊ) हो जाते हैं।"),
        ("विद्या + अर्थी", "विद्यार्थी", "दीर्घ स्वर संधि (आ + अ = आ)", "विद्या के अंत का 'आ' और अर्थी का पहला 'अ' मिलकर 'आ' बन गए।"),
        ("गिरि + ईश", "गिरीश", "दीर्घ स्वर संधि (इ + ई = ई)", "गिरि (पर्वत) + ईश (स्वामी) मिलकर गिरीश बने।"),
        ("भानु + उदय", "भानूदय", "दीर्घ स्वर संधि (उ + उ = ऊ)", "भानु का 'उ' और उदय का 'उ' मिलकर दीर्घ 'ऊ' बने।"),
        # Swar - Gun
        ("नर + ईश", "नरेश", "गुण स्वर संधि (अ + ई = ए)", "यदि अ/आ के बाद इ/ई आए तो दोनों मिलकर 'ए' बन जाते हैं।"),
        ("महा + उत्सव", "महोत्सव", "गुण स्वर संधि (आ + उ = ओ)", "यदि अ/आ के बाद उ/ऊ आए तो दोनों मिलकर 'ओ' बन जाते हैं।"),
        ("देव + ऋषि", "देवर्षि", "गुण स्वर संधि (अ + ऋ = अर्)", "यदि अ/आ के बाद ऋ आए तो दोनों मिलकर 'अर्' बन जाते हैं।"),
        # Swar - Vriddhi
        ("एक + एक", "एकैक", "वृद्धि स्वर संधि (अ + ए = ऐ)", "यदि अ/आ के बाद ए/ऐ आए तो दोनों मिलकर 'ऐ' बन जाते हैं।"),
        ("महा + औषधि", "महौषधि", "वृद्धि स्वर संधि (आ + ओ = औ)", "यदि अ/आ के बाद ओ/औ आए तो दोनों मिलकर 'औ' बन जाते हैं।"),
        # Swar - Yan
        ("प्रति + एक", "प्रत्येक", "यण स्वर संधि (इ + ए = ये)", "यदि इ/ई के बाद कोई भिन्न स्वर आए तो इ/ई का 'य्' हो जाता है।"),
        ("सु + आगत", "स्वागत", "यण स्वर संधि (उ + आ = वा)", "यदि उ/ऊ के बाद कोई भिन्न स्वर आए तो उ/ऊ का 'व्' हो जाता है।"),
        ("पितृ + आज्ञा", "पित्राज्ञा", "यण स्वर संधि (ऋ + आ = रा)", "यदि ऋ के बाद भिन्न स्वर आए तो ऋ का 'र्' हो जाता है।"),
        # Swar - Ayadi
        ("ने + अन", "नयन", "अयादि स्वर संधि (ए + अ = अय्)", "यदि ए के बाद कोई भिन्न स्वर आए तो ए का 'अय्' हो जाता है।"),
        ("पौ + अक", "पावक", "अयादि स्वर संधि (औ + अ = आव्)", "यदि औ के बाद भिन्न स्वर आए तो औ का 'आव्' हो जाता है।"),
        ("पो + अन", "पवन", "अयादि स्वर संधि (ओ + अ = अव्)", "यदि ओ के बाद भिन्न स्वर आए तो ओ का 'अव्' हो जाता है।"),
        # Vyanjan
        ("दिक् + गज", "दिग्गज", "व्यंजन संधि (क् का ग् में परिवर्तन)", "वर्ग के पहले वर्ण (क्) के बाद किसी वर्ग का तीसरा/चौथा वर्ण आए तो पहला वर्ण अपने ही वर्ग के तीसरे वर्ण (ग्) में बदल जाता है।"),
        ("उत् + चारण", "उच्चारण", "व्यंजन संधि (त् का च् में परिवर्तन)", "त्/द् के बाद च्/छ् आए तो त्/द् का 'च्' हो जाता है।"),
        ("सत् + जन", "सज्जन", "व्यंजन संधि (त् का ज् में परिवर्तन)", "त्/द् के बाद ज्/झ् आए तो त्/द् का 'ज्' हो जाता है।"),
        ("जगत् + ईश", "जगदीश", "व्यंजन संधि (त् का द् में परिवर्तन)", "त् के बाद स्वर आने पर त् अपने वर्ग के तीसरे वर्ण 'द्' में बदल जाता है।"),
        ("सम् + तोष", "संतोष", "व्यंजन संधि (म् का अनुस्वार में परिवर्तन)", "म् के बाद कोई स्पर्श व्यंजन आए तो म् अनुस्वार (ं) में बदल जाता है।"),
        # Visarga
        ("नमः + ते", "नमस्ते", "विसर्ग संधि (विसर्ग का स् में परिवर्तन)", "विसर्ग के बाद त् या थ् आए तो विसर्ग का 'स्' हो जाता है।"),
        ("निः + धन", "निर्धन", "विसर्ग संधि (विसर्ग का र् में परिवर्तन)", "विसर्ग से पहले अ/आ को छोड़कर कोई स्वर हो और बाद में घोष वर्ण हो तो विसर्ग का 'र्' हो जाता है।"),
        ("यशः + दा", "यशोदा", "विसर्ग संधि (विसर्ग का ओ में परिवर्तन)", "विसर्ग से पहले 'अ' हो और बाद में घोष वर्ण हो तो विसर्ग 'ओ' में बदल जाता है।"),
        ("मनः + रथ", "मनोरथ", "विसर्ग संधि (विसर्ग का ओ में परिवर्तन)", "मनः + रथ = मनोरथ।"),
        ("निः + कपट", "निष्कपट", "विसर्ग संधि (विसर्ग का ष् में परिवर्तन)", "विसर्ग से पहले इ/उ हो और बाद में क, ख, प, फ आए तो विसर्ग का 'ष्' हो जाता है।")
    ]
    data = []
    for split_form, combined, sandhi_type, rule in examples:
        text = (
            f"प्रश्न: '{combined}' का संधि विच्छेद कीजिए तथा संधि का नाम और नियम बताइए।\n"
            f"<soch>\n"
            f"1. संधि विच्छेद: {split_form} = {combined}\n"
            f"2. संधि का प्रकार: {sandhi_type}\n"
            f"3. व्याकरण नियम: {rule}\n"
            f"</soch>\n"
            f"उत्तर: '{combined}' का संधि विच्छेद '{split_form}' है। यह {sandhi_type} का उदाहरण है।"
        )
        data.append({"text": text, "topic": "sandhi", "difficulty": "intermediate"})
    return data

def generate_samas_corpus():
    examples = [
        ("राजपुत्र", "राजा का पुत्र", "संबंध तत्पुरुष समास", "उत्तर पद प्रधान है तथा संबंध कारक की विभक्ति 'का' का लोप हुआ है।"),
        ("देशभक्ति", "देश के लिए भक्ति", "संप्रदान तत्पुरुष समास", "संप्रदान कारक की विभक्ति 'के लिए' का लोप हुआ है।"),
        ("रोगमुक्त", "रोग से मुक्त", "अपादान तत्पुरुष समास", "अपादान कारक की विभक्ति 'से' (अलग होने के अर्थ में) का लोप हुआ है।"),
        ("चरणकमल", "कमल के समान चरण", "कर्मधारय समास", "विशेष्य और उपमान-उपमेय का संबंध है।"),
        ("नीलकमल", "नीला है जो कमल", "कर्मधारय समास", "विशेषण-विशेष्य संबंध (नीला विशेषण है और कमल विशेष्य)।"),
        ("यथाशक्ति", "शक्ति के अनुसार", "अव्ययीभाव समास", "पूर्व पद 'यथा' अव्यय है और वही प्रधान है।"),
        ("प्रतिदिन", "प्रत्येक दिन / दिन-दिन", "अव्ययीभाव समास", "पूर्व पद 'प्रति' अव्यय है।"),
        ("आजन्म", "जन्म से लेकर", "अव्ययीभाव समास", "'आ' उपसर्ग/अव्यय के रूप में प्रयुक्त है।"),
        ("चौराहा", "चार राहों का समाहार", "द्विगु समास", "पहला पद संख्यावाचक विशेषण (चौ = चार) है जो समाहार का बोध कराता है।"),
        ("तिरंगा", "तीन रंगों का समाहार", "द्विगु समास", "प्रथम पद 'त्रि' (तीन) संख्यावाचक है।"),
        ("माता-पिता", "माता और पिता", "द्वंद्व समास", "दोनों पद समान रूप से प्रधान हैं और योजक 'और' का लोप है।"),
        ("सुख-दुख", "सुख और दुख", "द्वंद्व समास", "दोनों पद प्रधान और परस्पर विलोम हैं।"),
        ("दशानन", "दस हैं आनन (मुख) जिसके अर्थात् रावण", "बहुव्रीहि समास", "कोई भी पद प्रधान न होकर अन्य पद (रावण) की ओर संकेत करता है।"),
        ("लंबोदर", "लंबा है उदर (पेट) जिसका अर्थात् भगवान गणेश", "बहुव्रीहि समास", "दोनों पद मिलकर तीसरे विशेष अर्थ 'गणेश' को व्यक्त करते हैं।"),
        ("पीतांबर", "पीले हैं अंबर (वस्त्र) जिसके अर्थात् भगवान श्रीकृष्ण", "बहुव्रीहि समास", "तीसरे अर्थ श्रीकृष्ण की प्रधानता है।")
    ]
    data = []
    for word, vigrah, samas_type, reasoning in examples:
        text = (
            f"प्रश्न: सामासिक पद '{word}' का समास विग्रह कीजिए और समास का नाम बताइए।\n"
            f"<soch>\n"
            f"1. समास विग्रह: {vigrah}\n"
            f"2. समास का नाम: {samas_type}\n"
            f"3. कारण/पहचान: {reasoning}\n"
            f"</soch>\n"
            f"उत्तर: '{word}' का समास विग्रह '{vigrah}' है। इसमें '{samas_type}' है।"
        )
        data.append({"text": text, "topic": "samas", "difficulty": "intermediate"})
    return data

def generate_karak_corpus():
    karaks = [
        ("कर्ता कारक", "ने", "क्रिया को करने वाला", "राम ने पुस्तक पढ़ी।", "यहाँ पढ़ने की क्रिया 'राम' द्वारा की गई है, अतः 'राम' कर्ता कारक है।"),
        ("कर्म कारक", "को", "जिस पर क्रिया का फल पड़े", "अध्यापक ने छात्र को समझाया।", "'छात्र' पर समझाने की क्रिया का फल पड़ रहा है।"),
        ("करण कारक", "से, के द्वारा", "जिस साधन से क्रिया की जाए", "मोहन कलम से पत्र लिखता है।", "'कलम' लिखने का साधन (माध्यम) है।"),
        ("संप्रदान कारक", "को, के लिए", "जिसके लिए क्रिया की जाए / जिसे कुछ दिया जाए", "राजा ने गरीबों को कंबल दिए।", "दान या देने के भाव में 'गरीबों को' संप्रदान कारक है।"),
        ("अपादान कारक", "से (अलग होने पर)", "जिससे किसी वस्तु का अलग होना पाया जाए", "पेड़ से पत्ता गिरा। / हिमालय से गंगा निकलती है।", "'पेड़' और 'हिमालय' से अलग होने का भाव है, अतः यहाँ अपादान कारक है।"),
        ("संबंध कारक", "का, के, की, रा, रे, री", "दो संज्ञा या सर्वनामों का परस्पर संबंध", "यह रोहन की पुस्तक है।", "पुस्तक और रोहन के बीच संबंध दर्शाया गया है।"),
        ("अधिकरण कारक", "में, पर", "क्रिया के आधार या स्थान का बोध", "मेज पर पुस्तक रखी है। / कमरे में छात्र बैठे हैं।", "स्थान और आधार का बोध कराने वाला पद।"),
        ("सम्बोधन कारक", "हे, अरे, ओ, सुनो", "पुकारने या सचेत करने के लिए", "हे ईश्वर! मेरी रक्षा करो।", "संबोधन करने वाला पद।")
    ]
    data = []
    for name, vibhakti, defn, eg, expl in karaks:
        text = (
            f"प्रश्न: हिंदी व्याकरण में '{name}' की परिभाषा, विभक्ति चिह्न तथा उदाहरण दीजिए।\n"
            f"<soch>\n"
            f"कारक: {name}\n"
            f"विभक्ति (परसर्ग): {vibhakti}\n"
            f"लक्षण: {defn}\n"
            f"उदाहरण: {eg}\n"
            f"स्पष्टीकरण: {expl}\n"
            f"</soch>\n"
            f"उत्तर: {name} की विभक्ति '{vibhakti}' है। {defn}। जैसे: '{eg}'"
        )
        data.append({"text": text, "topic": "karak", "difficulty": "basic"})

    # Karan vs Apadan distinction
    diff_text = (
        "प्रश्न: करण कारक और अपादान कारक में क्या अंतर है? दोनों की विभक्ति 'से' है, इन्हें कैसे पहचानें?\n"
        "<soch>\n"
        "करण कारक (Instrumental Case): 'से' साधन या माध्यम के रूप में आता है (उदा. उसने चाकू से सेब काटा - चाकू साधन है)।\n"
        "अपादान कारक (Ablative Case): 'से' अलग होने, तुलना करने, डरने या सीखने के संदर्भ में आता है (उदा. पेड़ से पत्ता गिरा - पत्ता पेड़ से अलग हुआ; वह बिल्ली से डरता है)।\n"
        "</soch>\n"
        "उत्तर: करण कारक में 'से' का प्रयोग साधन या माध्यम (Tool/Medium) के लिए होता है (जैसे: 'कलम से लिखा')। जबकि अपादान कारक में 'से' का प्रयोग किसी वस्तु से अलग होने (Separation), तुलना या भय के लिए होता है (जैसे: 'पेड़ से फल गिरा', 'छत से बच्चा कूदा')।"
    )
    data.append({"text": diff_text, "topic": "karak", "difficulty": "advanced"})
    return data

def generate_vakya_shuddhi():
    pairs = [
        ("अनेकों लोग वहां उपस्थित थे।", "अनेक लोग वहां उपस्थित थे।", "'अनेक' शब्द अपने आप में बहुवचन है, अतः 'अनेकों' लिखना अशुद्ध है।"),
        ("कृपया आप वहां जाने की कृपा करें।", "कृपया आप वहां जाएं। / आप वहां जाने की कृपा करें।", "'कृपया' और 'कृपा करें' दोनों का एक साथ प्रयोग पुनरुक्ति दोष (Redundancy) है।"),
        ("मेरे को घर जाना है।", "मुझे घर जाना है।", "'मेरे को / तेरे को' हिंदी की मानक वर्तनी में अमान्य है; सही रूप 'मुझे / तुम्हें' है।"),
        ("वहां भारी भरकम भीड़ जमा थी।", "वहां भारी भीड़ जमा थी।", "भीड़ के लिए 'भारी' का प्रयोग पर्याप्त है, 'भारी भरकम' अनुचित है।"),
        ("दही बहुत खट्टी है।", "दही बहुत खट्टा है।", "हिंदी व्याकरण में 'दही' पुल्लिंग शब्द है, स्त्रीलिंग नहीं।"),
        ("पानी बह रही है।", "पानी बह रहा है।", "'पानी' पुल्लिंग शब्द है, अतः क्रिया 'बह रहा है' होगी।"),
        ("साहित्य और जीवन का घोर संबंध है।", "साहित्य और जीवन का घनिष्ठ संबंध है।", "संबंध के साथ 'घनिष्ठ' उपयुक्त विशेषण है, 'घोर' नकारात्मक भाव (जैसे घोर अपराध) के लिए आता है।"),
        ("वह अपनी स्वेच्छा से गया है।", "वह स्वेच्छा से गया है। / वह अपनी इच्छा से गया है।", "'स्वेच्छा' का अर्थ ही 'अपनी इच्छा' होता है, अतः 'अपनी' जोड़ना पुनरुक्ति है।"),
        ("मैंने हस्ताक्षर कर दिया।", "मैंने हस्ताक्षर कर दिए।", "'हस्ताक्षर' नित्य बहुवचन शब्द है, अतः क्रिया बहुवचन 'कर दिए' होगी।"),
        ("उसके प्राण निकल गया।", "उसके प्राण निकल गए।", "'प्राण', 'दर्शन', 'आँसू', 'बाल' नित्य बहुवचन शब्द होते हैं।")
    ]
    data = []
    for incorrect, correct, rule in pairs:
        text = (
            f"प्रश्न: अशुद्ध वाक्य को शुद्ध कीजिए: '{incorrect}'\n"
            f"<soch>\n"
            f"अशुद्ध वाक्य: {incorrect}\n"
            f"दोष: {rule}\n"
            f"शुद्ध रूप: {correct}\n"
            f"</soch>\n"
            f"उत्तर: शुद्ध वाक्य होगा: '{correct}'\nकारण: {rule}"
        )
        data.append({"text": text, "topic": "vakya_shuddhi", "difficulty": "intermediate"})
    return data

def generate_alankar_ras_corpus():
    items = [
        ("अनुप्रास अलंकार", "वर्णों की आवृत्ति (Repetition of consonants)", "तरनि तनूजा तट तमाल तरुवर बहु छाए।", "यहाँ 'त' वर्ण की आवृत्ति बार-बार हुई है।"),
        ("यमक अलंकार", "एक ही शब्द का बार-बार आना और हर बार भिन्न अर्थ होना", "कनक कनक ते सौ गुनी मादकता अधिकाय। या खाए बौराय जग या पाए बौराय।", "प्रथम 'कनक' का अर्थ धतूरा तथा द्वितीय 'कनक' का अर्थ सोना (Gold) है।"),
        ("श्लेष अलंकार", "एक शब्द के एक से अधिक अर्थ चिपकना", "रहिमन पानी राखिए, बिन पानी सब सून। पानी गए न ऊबरै, मोती, मानुष, चून।", "'पानी' के तीन अर्थ हैं: मोती के लिए चमक, मनुष्य के लिए प्रतिष्ठा, और चून (आटा) के लिए जल।"),
        ("उपमा अलंकार", "उपमेय की तुलना उपमान से (सा, सी, से, सम, सरिस)", "पीपर पात सरिस मन डोला।", "मन (उपमेय) की तुलना पीपल के पत्ते (उपमान) से की गई है, वाचक शब्द 'सरिस' है।"),
        ("रूपक अलंकार", "उपमेय में उपमान का अभेद आरोप", "चरन कमल बंदौ हरि राई।", "यहाँ चरणों को ही कमल मान लिया गया है, कोई भेद नहीं रखा गया।"),
        ("अतिशयोक्ति अलंकार", "किसी बात को बहुत बढ़ा-चढ़ाकर कहना", "हनुमान की पूंछ में लगन न पाई आग। लंका सगरी जल गई गए निशाचर भाग।", "आग लगने से पूर्व ही लंका जलने का वर्णन अत्यधिक बढ़ा-चढ़ाकर किया गया है।")
    ]
    data = []
    for name, defn, eg, expl in items:
        text = (
            f"प्रश्न: '{name}' की परिभाषा, उदाहरण तथा पहचान का तरीका समझाइए।\n"
            f"<soch>\n"
            f"अलंकार: {name}\n"
            f"पहचान: {defn}\n"
            f"काव्य उदाहरण: {eg}\n"
            f"अर्थ व स्पष्टीकरण: {expl}\n"
            f"</soch>\n"
            f"उत्तर: {name}: {defn}।\nउदाहरण: \"{eg}\"\nस्पष्टीकरण: {expl}"
        )
        data.append({"text": text, "topic": "alankar", "difficulty": "intermediate"})
    return data

def generate_hinglish_grammar_rules():
    rules = [
        ("Hinglish Tense Consistency",
         "Incorrect: 'Main kal Delhi gaya tha and meeting attend karunga.' (Past + Future clash)\nCorrect: 'Main kal Delhi gaya tha and meeting attend ki thi.' OR 'Main kal Delhi jaunga and meeting attend karunga.'",
         "Hinglish me coordinate clauses (and / par / lekin) me tense consistent hona zaroori hai. Agar ek clause past me hai to doosra bhi past me hi match hona chahiye."),
        ("Romanized Hindi Verb Conjugation",
         "Subject-Verb Agreement rules in Hinglish:\n1. Singular Male: 'Main kaam kar raha hu / Main kaam karta hu.'\n2. Singular Female: 'Main kaam kar rahi hu / Main kaam karti hu.'\n3. Respectful/Plural: 'Aap kya kar rahe hain?' (not 'Aap kya kar raha hai').\n4. Group/Plural: 'Hum log kal cinema ja rahe hain.'",
         "Hinglish me English words borrow karte waqt Hindi auxiliary verbs (karna, hona, lagna, dena) gender aur respect ke according conjugate hote hain."),
        ("Natural Code-Switching vs Clunky Switching",
         "Natural Hinglish: 'Mujhe project complete karne me issue aa raha hai, please help kar do.'\nAwkward / Over-mixed: 'Me to problem facing kar raha hu in project finishing, kripya assist pradaan karein.'",
         "Natural code-switching me nouns aur technical verbs English me hote hain (e.g. project, issue, complete, help) jabki functional grammar aur pronouns Hindi me preserve rehte hain (mujhe, karne me, aa raha hai, kar do)."),
        ("Spelling Standardization in Romanized Hindi",
         "Rules for clean Hinglish communication:\n1. 'hai' (singular is) vs 'hain' (plural/respectful are).\n2. 'kya' (what) vs 'kyun' (why) vs 'kaise' (how).\n3. Avoid excessive texting abbreviations (e.g., use 'Mujhe' instead of 'mjhe', 'Aap' instead of 'ap') for clear AI comprehension.",
         "Consistent spelling standardizes phonetics and preserves semantic meaning across user queries.")
    ]
    data = []
    for title, rule_content, explanation in rules:
        text = (
            f"Hinglish Grammar & Syntax Principle: {title}\n"
            f"<soch>\nTopic: {title}\nRule details: {rule_content}\nLinguistic rationale: {explanation}\n</soch>\n"
            f"Explanation:\n{rule_content}\n\nKey takeaway: {explanation}"
        )
        data.append({"text": text, "topic": "hinglish_grammar", "difficulty": "intermediate"})
    return data

def generate_bulk_variations(base_data, count_target=10000):
    expanded = list(base_data)
    while len(expanded) < count_target:
        item = random.choice(base_data)
        # Create minor framing variation (e.g., MCQ, fill-in-the-blank, direct prompt)
        text = item["text"]
        topic = item["topic"]
        framing = random.choice(["explain", "solve", "quiz"])
        if framing == "quiz":
            new_text = f"Objective Hindi Vyakaran Practice [{topic.upper()}]:\n" + text
        elif framing == "solve":
            new_text = f"कक्षा 10वीं/12वीं बोर्ड एवं प्रतियोगी परीक्षा व्याकरण अभ्यास:\n" + text
        else:
            new_text = f"हिंदी व्याकरण एवं भाषा-विज्ञान (Linguistics & Grammar):\n" + text
        expanded.append({"text": new_text, "topic": topic, "difficulty": item["difficulty"]})
    return expanded

def main():
    print("[*] Generating Comprehensive Hindi Vyakaran & Hinglish Grammar Corpus...")
    all_grammar = []
    all_grammar.extend(generate_sandhi_corpus())
    all_grammar.extend(generate_samas_corpus())
    all_grammar.extend(generate_karak_corpus())
    all_grammar.extend(generate_vakya_shuddhi())
    all_grammar.extend(generate_alankar_ras_corpus())
    all_grammar.extend(generate_hinglish_grammar_rules())

    print(f"[*] Base core templates: {len(all_grammar)}")
    full_corpus = generate_bulk_variations(all_grammar, count_target=10000)

    # FIX: unify schema to text,lang,source,domain,safety_tag (+topic,difficulty kept)
    # Old schema (text,topic,difficulty) broke HF auto-convert viewer (HTTP 500)
    # and load_dataset. Now viewer-compatible.
    std_rows = []
    for r in full_corpus:
        topic = r.get("topic", "general")
        std_rows.append({
            "text": r["text"],
            "lang": "hindi",
            "source": "vyakaran_master",
            "domain": f"hindi_vyakaran_{topic}",
            "safety_tag": "safe",
            "topic": topic,
            "difficulty": r.get("difficulty", "intermediate"),
        })
    df = pd.DataFrame(std_rows, columns=["text", "lang", "source", "domain", "safety_tag", "topic", "difficulty"])
    out_file = "hindi_vyakaran_and_hinglish_grammar.parquet"
    df.to_parquet(out_file, compression="zstd")
    print(f"[OK] Generated {out_file}: {len(df)} rows, {df.memory_usage().sum() / (1024**2):.2f} MB")

    api = HfApi()
    print(f"[*] Uploading {out_file} to {DEST_REPO}/grammar/...")
    api.upload_file(
        path_or_fileobj=out_file,
        path_in_repo=f"grammar/{out_file}",
        repo_id=DEST_REPO,
        repo_type=REPO_TYPE,
        commit_message="add dedicated Hindi Vyakaran and Hinglish grammar master corpus (10k rows)",
    )
    print(f"[OK] Successfully uploaded to {DEST_REPO}/grammar/{out_file}!")

if __name__ == "__main__":
    main()