Add initial implementation of Afghan Pashto Voice Processing and update .gitignore

.gitignore

@@ -0,0 +1,4 @@
+
+
+#Ignore insiders AI rules
+.github/instructions/codacy.instructions.md

app.py

@@ -0,0 +1,662 @@
+"""
+COMPLETE Afghan Pashto Voice & Speech Processing Space
+Pure Afghan Pashto - له اصل پښتو سره
+Author: Afghan Voice Technology Initiative
+Version: 2.0 - Lightweight Complete Demo
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Dict, List, Tuple
+
+import gradio as gr
+import numpy as np
+
+try:
+    import torch
+except Exception:  # pragma: no cover - optional dependency
+    torch = None
+
+
+AFGHAN_PASHTO_DIALECTS: Dict[str, Dict[str, Any]] = {
+    "کندهاري (Kandahari)": {
+        "code": "ps-kan",
+        "region": "کندهار، زابل، ارزگان",
+        "characteristics": ["Hard ږ (g)", "ښ as خ", "Emphatic consonants", "Traditional poetry"],
+        "traditional_name": "کندهاري غه",
+        "voice_models": {"male": "kan_male_v2.pth", "female": "kan_female_v2.pth", "elder": "kan_elder_v2.pth"},
+        "pronunciation_guide": "ږ = hard 'g', ښ = 'kh', Retroflex sounds preserved",
+    },
+    "پکتياوي (Paktiawal)": {
+        "code": "ps-pak",
+        "region": "پکتيا، پکتيکا، خوست",
+        "characteristics": ["Retroflex ڼ", "Nasal vowels", "Tribal vocabulary", "Mountain accent"],
+        "traditional_name": "پکتياوي خښه",
+        "voice_models": {"male": "pak_male_v2.pth", "female": "pak_female_v2.pth", "elder": "pak_elder_v2.pth"},
+        "pronunciation_guide": "ڼ = retroflex 'n', Nasalized vowels, Tribal words",
+    },
+    "پېښوري (Peshawri)": {
+        "code": "ps-pes",
+        "region": "پېښور، مردان، سوات",
+        "characteristics": ["ښ as ش", "Soft ږ (zh)", "Urban vocabulary", "Trade language"],
+        "traditional_name": "پېښوري ژبه",
+        "voice_models": {"male": "pes_male_v2.pth", "female": "pes_female_v2.pth", "elder": "pes_elder_v2.pth"},
+        "pronunciation_guide": "ښ = 'sh', ږ = soft 'zh', Urban expressions",
+    },
+    "مزارۍ (Mazari)": {
+        "code": "ps-maz",
+        "region": "مزار شريف، بلخ، جوزجان",
+        "characteristics": ["Uzbek influence", "Northern vowels", "Turkic loanwords", "Plains accent"],
+        "traditional_name": "مزارۍ غږ",
+        "voice_models": {"male": "maz_male_v2.pth", "female": "maz_female_v2.pth", "elder": "maz_elder_v2.pth"},
+        "pronunciation_guide": "Uzbek-influenced vowels, Turkic words, Northern tone",
+    },
+    "هراتۍ (Herati)": {
+        "code": "ps-her",
+        "region": "هرات، فراه، نيمروز",
+        "characteristics": ["Persian influence", "Western vowels", "Herati accent", "Cultural sophistication"],
+        "traditional_name": "هراتۍ لهجه",
+        "voice_models": {"male": "her_male_v2.pth", "female": "her_female_v2.pth", "elder": "her_elder_v2.pth"},
+        "pronunciation_guide": "Persian-influenced sounds, Western vowels, Cultural words",
+    },
+    "ننګرهاري (Nangarhari)": {
+        "code": "ps-nan",
+        "region": "جلال اباد، ننګرهار، کنړ",
+        "characteristics": ["Eastern dialect", "Khattak influence", "Jalalabad accent", "Border influences"],
+        "traditional_name": "ننګرهاري وړاندې",
+        "voice_models": {"male": "nan_male_v2.pth", "female": "nan_female_v2.pth", "elder": "nan_elder_v2.pth"},
+        "pronunciation_guide": "Eastern sounds, Khattak influence, Border variations",
+    },
+}
+
+
+CULTURAL_CONTEXTS: Dict[str, Dict[str, Any]] = {
+    "ملي (National)": {
+        "description": "National songs, anthems, patriotic poetry",
+        "examples": ["ملي سرود", "وطن شعرونه", "غازي قومي"],
+        "voice_style": "proud, formal, clear",
+        "suffix": "د ملي غرور سره",
+    },
+    "قومي (Tribal)": {
+        "description": "Tribal traditions, ethnic heritage, clan stories",
+        "examples": ["قومي کیسې", "نسب او شجره", "قبیلوي ویاړونه"],
+        "voice_style": "traditional, elder-like, respectful",
+        "suffix": "د قومي وياړ سره",
+    },
+    "مذهبي (Religious)": {
+        "description": "Religious content, spiritual guidance, Islamic teachings",
+        "examples": ["دیني دروس", "اخلاقي کیسې", "روحاني مواعظ"],
+        "voice_style": "soft, respectful, spiritual",
+        "suffix": "د مذهبي احترام سره",
+    },
+    "فرهنګي (Cultural)": {
+        "description": "Cultural education, traditional values, customs",
+        "examples": ["فرهنګي ارزښتونه", "دودونه او دستورونه", "کلتني کیسې"],
+        "voice_style": "educational, warm, cultural",
+        "suffix": "د فرهنګي ارزښتونو سره",
+    },
+    "تاريخي (Historical)": {
+        "description": "Historical narratives, ancient stories, past events",
+        "examples": ["تاريخي کیسې", "پخوانۍ پیښې", "قدیم افسانې"],
+        "voice_style": "storyteller, dramatic, engaging",
+        "suffix": "د تاريخي روايت په انداز",
+    },
+    "سنګي (Musical)": {
+        "description": "Traditional music, folk songs, cultural rhythms",
+        "examples": ["سنګي ملودۍ", "فولکلوري سندرې", "کلاسیکي موسیقي"],
+        "voice_style": "melodic, rhythmic, artistic",
+        "suffix": "د دوديزې نغمې په رنګ",
+    },
+    "پېغلوي (Folk Tales)": {
+        "description": "Folk tales, traditional stories, cultural narratives",
+        "examples": ["پېغلوي کیسې", "افسانوي کیسې", "کلتني حکیات"],
+        "voice_style": "storyteller, engaging, traditional",
+        "suffix": "د ولسي کيسې له خوند سره",
+    },
+}
+
+
+COMPLETE_PHONEMES: Dict[str, Dict[str, Dict[str, Any]]] = {
+    "پښتني حروف": {
+        "ښ": {"symbol": "ښ", "ipa": "/ʂ/", "description": "Voiceless retroflex fricative", "dialects": {"کندهاري": "خ", "پېښوري": "ش"}},
+        "ږ": {"symbol": "ږ", "ipa": "/ʐ/", "description": "Voiced retroflex fricative", "dialects": {"کندهاري": "گ", "پېښوري": "ژ"}},
+        "ڼ": {"symbol": "ڼ", "ipa": "/ɳ/", "description": "Retroflex nasal", "dialects": {"پکتياوي": "ڼ", "کندهاري": "ن"}},
+        "ړ": {"symbol": "ړ", "ipa": "/ɽ/", "description": "Retroflex flap", "dialects": {"ټول": "ړ"}},
+        "ټ": {"symbol": "ټ", "ipa": "/ʈ/", "description": "Voiceless retroflex stop", "dialects": {"ټول": "ټ"}},
+        "ډ": {"symbol": "ډ", "ipa": "/ɖ/", "description": "Voiced retroflex stop", "dialects": {"ټول": "ډ"}},
+    },
+    "عربي حروف": {
+        "ص": {"symbol": "ص", "ipa": "/sˤ/", "description": "Emphatic voiceless alveolar fricative", "dialects": {}},
+        "ض": {"symbol": "ض", "ipa": "/dˤ/", "description": "Emphatic voiced alveolar stop", "dialects": {}},
+        "ط": {"symbol": "ط", "ipa": "/tˤ/", "description": "Emphatic voiceless alveolar stop", "dialects": {}},
+        "ظ": {"symbol": "ظ", "ipa": "/zˤ/", "description": "Emphatic voiced alveolar fricative", "dialects": {}},
+    },
+    "ويي": {
+        "ا": {"symbol": "ا", "ipa": "/a/", "description": "Open front vowel", "dialects": {}},
+        "ې": {"symbol": "ې", "ipa": "/e/", "description": "Close-mid front vowel", "dialects": {}},
+        "ۍ": {"symbol": "ۍ", "ipa": "/ei/", "description": "Diphthong", "dialects": {}},
+        "و": {"symbol": "و", "ipa": "/o/", "description": "Close-mid back rounded vowel", "dialects": {}},
+        "ۀ": {"symbol": "ۀ", "ipa": "/ə/", "description": "Schwa", "dialects": {}},
+    },
+}
+
+
+VOICE_TYPE_MODEL_MAP = {
+    "مشر (Elder Male)": "elder",
+    "ځوان (Young Male)": "male",
+    "ښځينه (Female)": "female",
+    "وړکتي (Child)": "child",
+}
+
+EMOTION_MAP = {
+    "طبيعي (Natural)": "neutral",
+    "خوشحال (Joyful)": "joyful",
+    "غميز (Sorrowful)": "sorrowful",
+    "جګ افتخار (Proud)": "proud",
+}
+
+
+class AudioProcessor:
+    def preprocess_audio(self, audio_input: Tuple[int, np.ndarray] | np.ndarray | None) -> np.ndarray:
+        if audio_input is None:
+            raise ValueError("No audio input was provided.")
+
+        if isinstance(audio_input, tuple):
+            _, waveform = audio_input
+        else:
+            waveform = audio_input
+
+        waveform = np.asarray(waveform, dtype=np.float32).squeeze()
+        if waveform.ndim > 1:
+            waveform = waveform.mean(axis=1)
+
+        peak = float(np.max(np.abs(waveform))) if waveform.size else 0.0
+        if peak > 0:
+            waveform = waveform / peak
+        return waveform
+
+    def analyze_audio(self, waveform: np.ndarray, sample_rate: int) -> Dict[str, Any]:
+        if waveform.size == 0:
+            return {"duration_seconds": 0.0, "energy": 0.0, "pitch_band": "unknown"}
+
+        energy = float(np.mean(np.abs(waveform)))
+        zero_crossing = float(np.mean(np.abs(np.diff(np.signbit(waveform))))) if waveform.size > 1 else 0.0
+        pitch_band = "high" if zero_crossing > 0.12 else "mid" if zero_crossing > 0.05 else "low"
+        return {
+            "duration_seconds": round(waveform.size / max(sample_rate, 1), 2),
+            "energy": round(energy, 4),
+            "pitch_band": pitch_band,
+        }
+
+
+class CulturalContextProcessor:
+    tribal_terms = ["احمدزي", "محسود", "خټک", "یوسفزي", "دواني", "ننګيال"]
+    cultural_terms = ["پښتونولي", "مېلمستيا", "ننګ", "غيرت", "توره", "نګاه"]
+    traditional_expressions = ["ښه راغلاست", "په خير", "الله دې مل شه", "ستړی مه شې"]
+    honorifics = ["صاحب", "ملا", "خان", "استاد"]
+
+    def apply_cultural_context(self, text: str, context: str) -> str:
+        context_info = CULTURAL_CONTEXTS.get(context)
+        if not context_info:
+            return text
+        return f"{text} ({context_info['suffix']})"
+
+    def analyze_text(self, text: str) -> Dict[str, List[str]]:
+        return {
+            "tribal_references": [term for term in self.tribal_terms if term in text],
+            "cultural_concepts": [term for term in self.cultural_terms if term in text],
+            "traditional_expressions": [term for term in self.traditional_expressions if term in text],
+            "honorifics": [term for term in self.honorifics if term in text],
+        }
+
+
+class CompleteAfghanPashtoProcessor:
+    def __init__(self) -> None:
+        self.device = "cuda" if torch is not None and torch.cuda.is_available() else "cpu"
+        self.models: Dict[str, Any] = {}
+        self.audio_processor = AudioProcessor()
+        self.cultural_processor = CulturalContextProcessor()
+        self.dialect_rules = self.load_dialect_rules()
+        self.load_all_models()
+
+    def load_all_models(self) -> None:
+        self.models = {
+            "tts": {"base": self.load_tts_model(), "dialects": self.load_dialectal_tts_models()},
+            "asr": {"base": self.load_asr_model(), "dialectal": self.load_dialectal_asr_models()},
+            "voice_clone": self.load_voice_cloning_model(),
+        }
+
+    def load_tts_model(self) -> Dict[str, str]:
+        return {"model": "base_tts", "status": "placeholder"}
+
+    def load_dialectal_tts_models(self) -> Dict[str, Dict[str, str]]:
+        return {dialect: info["voice_models"] for dialect, info in AFGHAN_PASHTO_DIALECTS.items()}
+
+    def load_asr_model(self) -> Dict[str, str]:
+        return {"model": "base_asr", "status": "placeholder"}
+
+    def load_dialectal_asr_models(self) -> Dict[str, str]:
+        return {dialect: f"{info['code']}_asr" for dialect, info in AFGHAN_PASHTO_DIALECTS.items()}
+
+    def load_voice_cloning_model(self) -> Dict[str, str]:
+        return {"model": "voice_clone", "status": "placeholder"}
+
+    def load_dialect_rules(self) -> Dict[str, Dict[str, Dict[str, Any]]]:
+        return {
+            "pronunciation": {
+                "کندهاري (Kandahari)": {"ښ": "خ", "ږ": "گ", "emphatic_consonants": True},
+                "پکتياوي (Paktiawal)": {"ڼ": "ڼ", "nasal_vowels": True, "tribal_pronunciation": True},
+                "پېښوري (Peshawri)": {"ښ": "ش", "ږ": "ژ", "urban_influence": True},
+                "هراتۍ (Herati)": {"ښ": "خ", "ږ": "گ", "western_vowels": True},
+            },
+            "vocabulary": {
+                "کندهاري (Kandahari)": {"traditional_words": ["غه", "خه", "ګه"], "poetic_expressions": True},
+                "پکتياوي (Paktiawal)": {"tribal_words": ["خېل", "قوم", "نګهبان"], "mountain_vocabulary": True},
+                "هراتۍ (Herati)": {"persian_loanwords": True, "cultural_terms": ["فرهنګ", "تمدن", "ادب"]},
+            },
+            "grammar": {
+                "ننګرهاري (Nangarhari)": {"eastern_constructions": True, "border_influences": True},
+                "مزارۍ (Mazari)": {"uzbek_influence": True, "northern_constructions": True},
+            },
+        }
+
+    def process_authentic_tts(
+        self,
+        text: str,
+        dialect: str,
+        voice_type: str,
+        context: str,
+        emotion: str,
+        speed: float,
+    ) -> Tuple[np.ndarray, int, Dict[str, Any]]:
+        dialectal_text = self.apply_comprehensive_dialect_rules(text, dialect)
+        contextualized_text = self.cultural_processor.apply_cultural_context(dialectal_text, context)
+        emotional_text = self.apply_emotional_coloring(contextualized_text, emotion)
+        audio, sample_rate = self.generate_synthetic_speech(emotional_text, dialect, voice_type, speed, emotion)
+        return audio, sample_rate, {
+            "dialectal_text": dialectal_text,
+            "contextualized_text": contextualized_text,
+            "emotional_text": emotional_text,
+            "model": self.resolve_voice_model(dialect, voice_type),
+            "device": self.device,
+        }
+
+    def process_authentic_asr(self, audio_input: Tuple[int, np.ndarray] | None, dialect: str) -> Dict[str, Any]:
+        if audio_input is None:
+            raise ValueError("Please record or upload Pashto speech first.")
+
+        sample_rate, waveform = audio_input
+        processed_audio = self.audio_processor.preprocess_audio((sample_rate, waveform))
+        result = self.basic_speech_recognition(processed_audio, dialect)
+        corrected_text = self.apply_dialectal_corrections(result["text"], dialect)
+        cultural_info = self.extract_comprehensive_cultural_markers(corrected_text)
+        audio_stats = self.audio_processor.analyze_audio(processed_audio, sample_rate)
+        return {
+            "text": corrected_text,
+            "confidence": result.get("confidence", 0.85),
+            "dialect": dialect,
+            "audio_stats": audio_stats,
+            "cultural_markers": cultural_info,
+            "pronunciation_notes": self.get_pronunciation_notes(corrected_text, dialect),
+        }
+
+    def process_voice_cloning(
+        self,
+        reference_audio: Tuple[int, np.ndarray] | None,
+        text: str,
+        dialect: str,
+        voice_characteristics: Dict[str, str],
+    ) -> Tuple[np.ndarray, int, Dict[str, Any]]:
+        if reference_audio is None:
+            raise ValueError("Reference audio is required for voice cloning.")
+
+        sample_rate, waveform = reference_audio
+        processed_audio = self.audio_processor.preprocess_audio((sample_rate, waveform))
+        features = self.extract_authentic_voice_features(processed_audio, sample_rate, dialect)
+        merged_features = {**features, **voice_characteristics}
+        cloned_audio, cloned_rate = self.basic_voice_cloning(text, merged_features, dialect)
+        return cloned_audio, cloned_rate, merged_features
+
+    def apply_comprehensive_dialect_rules(self, text: str, dialect: str) -> str:
+        pronunciation_rules = self.dialect_rules.get("pronunciation", {}).get(dialect, {})
+        vocabulary_rules = self.dialect_rules.get("vocabulary", {}).get(dialect, {})
+
+        transformed = text
+        for original, replacement in pronunciation_rules.items():
+            if isinstance(replacement, str):
+                transformed = transformed.replace(original, replacement)
+
+        if vocabulary_rules.get("poetic_expressions") and "وطن" in transformed:
+            transformed = transformed.replace("وطن", "پلرنی وطن")
+        if vocabulary_rules.get("persian_loanwords") and "کلتور" in transformed:
+            transformed = transformed.replace("کلتور", "فرهنګ")
+        return transformed
+
+    def apply_emotional_coloring(self, text: str, emotion: str) -> str:
+        emotional_suffix = {
+            "neutral": "په طبيعي انداز",
+            "joyful": "په خوشحال رنګ",
+            "sorrowful": "په غمجن اهنګ",
+            "proud": "په ویاړلي انداز",
+        }.get(emotion)
+        return f"{text} ({emotional_suffix})" if emotional_suffix else text
+
+    def generate_synthetic_speech(
+        self,
+        text: str,
+        dialect: str,
+        voice_type: str,
+        speed: float,
+        emotion: str,
+    ) -> Tuple[np.ndarray, int]:
+        sample_rate = 24000
+        duration = max(1.5, min(len(text) * 0.11 / max(speed, 0.1), 18.0))
+        timeline = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+
+        base_freq = {"female": 210, "child": 280, "elder": 105, "male": 130}.get(voice_type, 140)
+        dialect_shift = {
+            "کندهاري (Kandahari)": -5,
+            "پکتياوي (Paktiawal)": 7,
+            "پېښوري (Peshawri)": 13,
+            "مزارۍ (Mazari)": 3,
+            "هراتۍ (Herati)": -2,
+            "ننګرهاري (Nangarhari)": 8,
+        }.get(dialect, 0)
+        emotion_shift = {"neutral": 0, "joyful": 16, "sorrowful": -10, "proud": 9}.get(emotion, 0)
+        modulation = 18 * np.sin(2 * math.pi * 0.42 * timeline)
+        frequency = base_freq + dialect_shift + emotion_shift + modulation
+
+        audio = np.zeros_like(timeline)
+        for harmonic in range(1, 7):
+            audio += (1 / harmonic) * np.sin(2 * math.pi * harmonic * frequency * timeline)
+
+        syllable_envelope = 0.6 + 0.4 * np.sin(2 * math.pi * (2.0 * speed) * timeline) ** 2
+        fade = np.exp(-timeline / (3.8 / max(speed, 0.1)))
+        breath = np.random.normal(0, 0.008, timeline.shape)
+        audio = np.clip(audio * syllable_envelope * fade * 0.24 + breath, -1.0, 1.0)
+        return audio.astype(np.float32), sample_rate
+
+    def basic_speech_recognition(self, waveform: np.ndarray, dialect: str) -> Dict[str, Any]:
+        energy = float(np.mean(np.abs(waveform))) if waveform.size else 0.0
+        transcript = "دا يو پښتو متن دی چې د وينا پېژندنې له لارې ترلاسه شوی"
+        if energy > 0.06:
+            transcript += " او غږ يې روښانه دی"
+        if dialect == "کندهاري (Kandahari)":
+            transcript += " د کندهارۍ رنګ سره"
+        elif dialect == "پکتياوي (Paktiawal)":
+            transcript += " د پکتياوي انداز سره"
+        elif dialect == "هراتۍ (Herati)":
+            transcript += " د هراتي نرمۍ سره"
+        return {"text": transcript, "confidence": 0.85}
+
+    def apply_dialectal_corrections(self, text: str, dialect: str) -> str:
+        corrections = {
+            "کندهاري (Kandahari)": {"شګ": "ښګ", "ژګ": "ږګ"},
+            "پکتياوي (Paktiawal)": {"نګ": "ڼګ"},
+            "پېښوري (Peshawri)": {"ښ": "ش"},
+        }
+        corrected = text
+        for wrong, correct in corrections.get(dialect, {}).items():
+            corrected = corrected.replace(wrong, correct)
+        return corrected
+
+    def extract_comprehensive_cultural_markers(self, text: str) -> Dict[str, List[str]]:
+        return self.cultural_processor.analyze_text(text)
+
+    def get_pronunciation_notes(self, text: str, dialect: str) -> List[str]:
+        notes = [AFGHAN_PASHTO_DIALECTS[dialect]["pronunciation_guide"]]
+        if "ښ" in text:
+            notes.append("Text contains ښ, which is one of the key dialect markers.")
+        if "ږ" in text:
+            notes.append("Text contains ږ, so dialect-specific realization matters here.")
+        return notes
+
+    def extract_authentic_voice_features(self, waveform: np.ndarray, sample_rate: int, dialect: str) -> Dict[str, Any]:
+        stats = self.audio_processor.analyze_audio(waveform, sample_rate)
+        return {
+            "pitch_band": stats["pitch_band"],
+            "energy": stats["energy"],
+            "accent": AFGHAN_PASHTO_DIALECTS[dialect]["traditional_name"],
+            "quality": "clear" if stats["energy"] > 0.04 else "soft",
+        }
+
+    def basic_voice_cloning(self, text: str, voice_features: Dict[str, Any], dialect: str) -> Tuple[np.ndarray, int]:
+        pitch_band = voice_features.get("pitch_band", "mid")
+        voice_type = "female" if pitch_band == "high" else "elder" if voice_features.get("age_profile") == "elder" else "male"
+        return self.generate_synthetic_speech(text, dialect, voice_type, 1.0, "neutral")
+
+    def resolve_voice_model(self, dialect: str, voice_type: str) -> str:
+        model_map = AFGHAN_PASHTO_DIALECTS[dialect]["voice_models"]
+        return model_map.get(voice_type, f"{AFGHAN_PASHTO_DIALECTS[dialect]['code']}_{voice_type}.pth")
+
+
+processor = CompleteAfghanPashtoProcessor()
+
+
+def format_dialect_summary(dialect: str) -> str:
+    info = AFGHAN_PASHTO_DIALECTS[dialect]
+    return (
+        f"لهجه: {dialect}\n"
+        f"کوډ: {info['code']}\n"
+        f"سيمه: {info['region']}\n"
+        f"دوديز نوم: {info['traditional_name']}\n"
+        f"اواز ماډلونه: {', '.join(info['voice_models'].values())}\n"
+        f"تلفظ: {info['pronunciation_guide']}\n"
+        f"ځانګړنې: {', '.join(info['characteristics'])}"
+    )
+
+
+def format_context_summary(context_name: str) -> str:
+    info = CULTURAL_CONTEXTS[context_name]
+    return (
+        f"تشريح: {info['description']}\n"
+        f"بېلګې: {', '.join(info['examples'])}\n"
+        f"اواز سبک: {info['voice_style']}"
+    )
+
+
+def phoneme_markdown() -> str:
+    lines: List[str] = []
+    for category, items in COMPLETE_PHONEMES.items():
+        lines.append(f"### {category}")
+        for symbol, data in items.items():
+            dialects = data.get("dialects", {})
+            dialect_text = ", ".join(f"{key}: {value}" for key, value in dialects.items()) if dialects else "—"
+            lines.append(f"- **{symbol}** · IPA `{data['ipa']}` · {data['description']} · Dialects: {dialect_text}")
+    return "\n".join(lines)
+
+
+def available_examples() -> List[List[Any]]:
+    return [
+        ["زما وطن د وياړ کور دی او پښتونولي زموږ د ژوند لار ده.", "کندهاري (Kandahari)", "مشر (Elder Male)", "ملي (National)", "جګ افتخار (Proud)", 1.0],
+        ["مېلمستيا او غيرت زموږ کلتوري ارزښتونه دي.", "پکتياوي (Paktiawal)", "ځوان (Young Male)", "فرهنګي (Cultural)", "طبيعي (Natural)", 1.1],
+        ["ښه راغلاست، دا يوه ولسي کيسه ده چې د زاړه وخت ياد راژوندی کوي.", "هراتۍ (Herati)", "ښځينه (Female)", "پېغلوي (Folk Tales)", "خوشحال (Joyful)", 0.9],
+    ]
+
+
+def generate_voice(text: str, dialect: str, voice_label: str, context_name: str, emotion_label: str, speed: float):
+    if not text.strip():
+        raise gr.Error("مهرباني وکړئ پښتو متن وليکئ / Please enter Pashto text.")
+
+    voice_type = VOICE_TYPE_MODEL_MAP[voice_label]
+    emotion = EMOTION_MAP[emotion_label]
+    audio, sample_rate, metadata = processor.process_authentic_tts(text, dialect, voice_type, context_name, emotion, speed)
+    info = (
+        f"Model: {metadata['model']}\n"
+        f"Device: {metadata['device']}\n"
+        f"Dialectal text: {metadata['dialectal_text']}\n"
+        f"Contextualized text: {metadata['contextualized_text']}\n"
+        f"Emotional text: {metadata['emotional_text']}"
+    )
+    context_analysis = processor.extract_comprehensive_cultural_markers(metadata["emotional_text"])
+    marker_lines = [f"{key}: {', '.join(values)}" for key, values in context_analysis.items() if values]
+    markers_text = "\n".join(marker_lines) if marker_lines else "No explicit cultural markers detected yet."
+    return (sample_rate, audio), info, format_dialect_summary(dialect), format_context_summary(context_name), markers_text
+
+
+def recognize_speech(audio_input, dialect: str):
+    result = processor.process_authentic_asr(audio_input, dialect)
+    summary = (
+        f"Transcription: {result['text']}\n"
+        f"Confidence: {result['confidence']:.0%}\n"
+        f"Duration: {result['audio_stats']['duration_seconds']} seconds\n"
+        f"Energy: {result['audio_stats']['energy']}\n"
+        f"Pitch band: {result['audio_stats']['pitch_band']}"
+    )
+    markers = [f"{key}: {', '.join(values)}" for key, values in result['cultural_markers'].items() if values]
+    return summary, result["cultural_markers"], "\n".join(result["pronunciation_notes"]), "\n".join(markers) if markers else "No cultural markers detected."
+
+
+def clone_voice(reference_audio, text: str, dialect: str, age_profile: str, style_profile: str):
+    if not text.strip():
+        raise gr.Error("Please provide target text for cloning.")
+
+    audio, sample_rate, features = processor.process_voice_cloning(
+        reference_audio,
+        text,
+        dialect,
+        {"age_profile": age_profile, "style_profile": style_profile},
+    )
+    feature_lines = "\n".join(f"{key}: {value}" for key, value in features.items())
+    return (sample_rate, audio), feature_lines, format_dialect_summary(dialect)
+
+
+def build_app() -> gr.Blocks:
+    with gr.Blocks(
+        title="🎙️ Afghan Pashto Voice Hub - د افغان پښتو غږيز مرکز",
+        theme=gr.themes.Soft(),
+        css="""
+        .pashto-text {
+            font-family: 'Noto Nastaliq Urdu', 'Jameel Noori Nastaleeq', 'Scheherazade New', serif;
+            direction: rtl;
+            text-align: right;
+        }
+        .afghan-flag {
+            background: linear-gradient(to bottom, #000000, #c81818, #0b8f3a);
+            height: 20px;
+            border-radius: 6px;
+            margin: 10px 0;
+        }
+        """,
+    ) as app:
+        gr.Markdown(
+            """
+            # 🎙️ Afghan Pashto Voice & Speech Processing Hub
+            ## د افغان پښتو غږيز پروسسنګ مرکز
+
+            **Pure Afghan Pashto - له اصل پښتو سره**
+
+            Supports: **Kandahari, Paktiawal, Peshawri, Mazari, Herati, Nangarhari, and traditional forms**
+            """
+        )
+        gr.HTML('<div class="afghan-flag"></div>')
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                dialect_preview = gr.Dropdown(
+                    choices=list(AFGHAN_PASHTO_DIALECTS.keys()),
+                    value="کندهاري (Kandahari)",
+                    label="Dialect overview - لهجو کتنه",
+                )
+                dialect_summary = gr.Textbox(
+                    value=format_dialect_summary("کندهاري (Kandahari)"),
+                    label="Dialect details",
+                    lines=7,
+                )
+            with gr.Column(scale=1):
+                gr.Markdown(f"### Runtime\n- Runtime device: {processor.device}\n- Models: lightweight placeholder stack")
+
+        dialect_preview.change(fn=format_dialect_summary, inputs=dialect_preview, outputs=dialect_summary)
+
+        with gr.Accordion("Traditional phoneme guide", open=False):
+            gr.Markdown(phoneme_markdown(), elem_classes="pashto-text")
+
+        with gr.Tabs():
+            with gr.TabItem("🔊 Authentic Voice"):
+                with gr.Row():
+                    with gr.Column():
+                        authentic_text = gr.Textbox(
+                            label="پښتو متن / Pashto Text",
+                            placeholder="دلته پښتو متن ولیکئ...",
+                            lines=5,
+                            elem_classes="pashto-text",
+                        )
+                        with gr.Row():
+                            authentic_dialect = gr.Dropdown(choices=list(AFGHAN_PASHTO_DIALECTS.keys()), value="کندهاري (Kandahari)", label="Dialect - لهجه")
+                            authentic_voice = gr.Dropdown(choices=list(VOICE_TYPE_MODEL_MAP.keys()), value="مشر (Elder Male)", label="Voice Type - غږ ډول")
+                        with gr.Row():
+                            authentic_context = gr.Dropdown(choices=list(CULTURAL_CONTEXTS.keys()), value="ملي (National)", label="Cultural Context - کلتني زمينه")
+                            authentic_emotion = gr.Dropdown(choices=list(EMOTION_MAP.keys()), value="طبيعي (Natural)", label="Emotion - احساس")
+                        authentic_speed = gr.Slider(0.6, 1.4, value=1.0, step=0.1, label="Speed - چټکتيا")
+                        authentic_generate = gr.Button("🎤 Generate Authentic Voice", variant="primary")
+                        gr.Examples(examples=available_examples(), inputs=[authentic_text, authentic_dialect, authentic_voice, authentic_context, authentic_emotion, authentic_speed])
+                    with gr.Column():
+                        authentic_output = gr.Audio(label="Generated Afghan Pashto Voice")
+                        authentic_info = gr.Textbox(label="Voice pipeline details", lines=7)
+                        authentic_dialect_info = gr.Textbox(label="Dialect knowledge", lines=7)
+                        authentic_context_info = gr.Textbox(label="Context knowledge", lines=4)
+                        authentic_markers = gr.Textbox(label="Cultural markers", lines=5)
+
+                authentic_generate.click(
+                    fn=generate_voice,
+                    inputs=[authentic_text, authentic_dialect, authentic_voice, authentic_context, authentic_emotion, authentic_speed],
+                    outputs=[authentic_output, authentic_info, authentic_dialect_info, authentic_context_info, authentic_markers],
+                )
+
+            with gr.TabItem("🎧 Speech Recognition"):
+                with gr.Row():
+                    with gr.Column():
+                        recognition_audio = gr.Audio(sources=["upload", "microphone"], type="numpy", label="Upload or record Pashto speech")
+                        recognition_dialect = gr.Dropdown(choices=list(AFGHAN_PASHTO_DIALECTS.keys()), value="پکتياوي (Paktiawal)", label="Target dialect")
+                        recognition_button = gr.Button("📝 Recognize Speech", variant="primary")
+                    with gr.Column():
+                        recognition_summary = gr.Textbox(label="Recognition summary", lines=6)
+                        recognition_context = gr.JSON(label="Cultural context analysis")
+                        recognition_pronunciation = gr.Textbox(label="Pronunciation notes", lines=4)
+                        recognition_markers = gr.Textbox(label="Detected markers", lines=4)
+
+                recognition_button.click(
+                    fn=recognize_speech,
+                    inputs=[recognition_audio, recognition_dialect],
+                    outputs=[recognition_summary, recognition_context, recognition_pronunciation, recognition_markers],
+                )
+
+            with gr.TabItem("🧬 Voice Cloning Demo"):
+                with gr.Row():
+                    with gr.Column():
+                        clone_audio = gr.Audio(sources=["upload", "microphone"], type="numpy", label="Reference Afghan voice")
+                        clone_text = gr.Textbox(label="Target text", lines=4, placeholder="هغه متن وليکئ چې د هماغه غږ په ډول واورئ...", elem_classes="pashto-text")
+                        clone_dialect = gr.Dropdown(choices=list(AFGHAN_PASHTO_DIALECTS.keys()), value="هراتۍ (Herati)", label="Dialect")
+                        with gr.Row():
+                            clone_age = gr.Dropdown(choices=["youthful", "mature", "elder"], value="mature", label="Age profile")
+                            clone_style = gr.Dropdown(choices=["formal", "storytelling", "poetic", "conversational"], value="storytelling", label="Speaking style")
+                        clone_button = gr.Button("🧪 Clone Voice Demo", variant="primary")
+                    with gr.Column():
+                        clone_output = gr.Audio(label="Cloned Afghan voice")
+                        clone_features = gr.Textbox(label="Extracted / merged voice features", lines=8)
+                        clone_dialect_info = gr.Textbox(label="Dialect profile", lines=7)
+
+                clone_button.click(
+                    fn=clone_voice,
+                    inputs=[clone_audio, clone_text, clone_dialect, clone_age, clone_style],
+                    outputs=[clone_output, clone_features, clone_dialect_info],
+                )
+
+        gr.Markdown(
+            """
+            ### Notes
+            - This app is a lightweight, deployable Gradio demo with authentic Afghan Pashto structure and metadata.
+            - TTS, ASR, and voice cloning are implemented with synthetic placeholder audio logic so the interface runs without large model files.
+            - You can later replace the placeholder methods with real Pashto TTS, ASR, and cloning checkpoints.
+            """
+        )
+
+    return app
+
+
+app = build_app()
+
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=5.0.0
+numpy>=1.24.0