bangla-multiscript 1.0.0__py3-none-any.whl

bangla_multiscript/__init__.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+"""
+BanglaMultiScript: High-Throughput Bengali to Natural Avro Banglish & Code-Mixed Alignment Engine.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Shahriar"
+
+from .engine import (
+    to_natural_banglish,
+    to_natural_codemixed,
+    clean_repetition_trash,
+    phonological_word_to_banglish,
+    MultiScriptConverter,
+    all_in_one
+)
+from .translator import IndicTrans2Translator, WebTranslator, CustomTranslator, get_translator
+from .detector import detect_script, get_script_stats
+from .normalizer import normalize_bangla, normalize_banglish, normalize_text
+from .exporter import export_to_sharegpt, export_to_alpaca, export_to_dpo
+from .ui import launch_ui
+
+__all__ = [
+    # Core Engine
+    "to_natural_banglish",
+    "to_natural_codemixed",
+    "clean_repetition_trash",
+    "phonological_word_to_banglish",
+    "MultiScriptConverter",
+    "all_in_one",
+    # Translation
+    "IndicTrans2Translator",
+    "WebTranslator",
+    "CustomTranslator",
+    "get_translator",
+    # Script Detection
+    "detect_script",
+    "get_script_stats",
+    # Text Normalization
+    "normalize_bangla",
+    "normalize_banglish",
+    "normalize_text",
+    # LLM Dataset Exporters
+    "export_to_sharegpt",
+    "export_to_alpaca",
+    "export_to_dpo",
+    # Web UI
+    "launch_ui",
+    # Metadata
+    "__version__",
+]
+

bangla_multiscript/cli.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+Command Line Interface for BanglaMultiScript
+"""
+
+import argparse
+import sys
+import os
+import json
+
+# Ensure UTF-8 output on Windows consoles
+if hasattr(sys.stdout, "reconfigure"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+from .engine import to_natural_banglish, to_natural_codemixed, MultiScriptConverter
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="BanglaMultiScript: Convert Bengali text to Natural Avro Banglish & Urban Code-Mixed."
+    )
+    parser.add_argument("input", nargs="?", help="Input string or path to a text/CSV/JSONL file.")
+    parser.add_argument(
+        "--mode", choices=["banglish", "codemixed", "all"], default="all",
+        help="Conversion mode (default: all)"
+    )
+    parser.add_argument("--output", "-o", help="Output file path (optional).")
+    parser.add_argument("--text-col", default="text", help="Text column name for CSV/JSONL input.")
+    parser.add_argument("--ui", action="store_true", help="Launch the interactive Web UI studio in browser.")
+    parser.add_argument("--port", type=int, default=7860, help="Port for the Web UI studio (default: 7860).")
+    parser.add_argument("--detect", action="store_true", help="Detect script/language (bengali, banglish, english, codemixed).")
+    parser.add_argument("--normalize", action="store_true", help="Normalize and clean text (remove ZWNJ, slang, letter stretching).")
+
+    args = parser.parse_args()
+
+    if args.ui:
+        from .ui import launch_ui
+        launch_ui(port=args.port)
+        return
+
+    if not args.input:
+        parser.print_help()
+        sys.exit(0)
+
+    if args.detect:
+        from .detector import detect_script
+        print(detect_script(args.input))
+        return
+
+    if args.normalize:
+        from .normalizer import normalize_text
+        print(normalize_text(args.input))
+        return
+
+    # Check if input is a file
+    if os.path.isfile(args.input):
+        ext = os.path.splitext(args.input)[1].lower()
+        if ext == '.csv':
+            import pandas as pd
+            df = pd.read_csv(args.input)
+            conv = MultiScriptConverter()
+            df = conv.convert_dataframe(df, text_column=args.text_col)
+            out_path = args.output or args.input.replace('.csv', '_multiscript.csv')
+            df.to_csv(out_path, index=False, encoding='utf-8')
+            print(f"Saved converted CSV ({len(df)} rows) to: {out_path}")
+        elif ext == '.jsonl':
+            out_path = args.output or args.input.replace('.jsonl', '_multiscript.jsonl')
+            count = 0
+            with open(args.input, 'r', encoding='utf-8') as fin, open(out_path, 'w', encoding='utf-8') as fout:
+                for line in fin:
+                    d = json.loads(line)
+                    raw_text = d.get(args.text_col, '')
+                    d[f'{args.text_col}_banglish'] = to_natural_banglish(raw_text)
+                    d[f'{args.text_col}_codemixed'] = to_natural_codemixed(raw_text)
+                    fout.write(json.dumps(d, ensure_ascii=False) + '\n')
+                    count += 1
+            print(f"Saved converted JSONL ({count} records) to: {out_path}")
+        else:
+            # Plain text file line by line
+            out_path = args.output or args.input + '.converted'
+            with open(args.input, 'r', encoding='utf-8') as fin, open(out_path, 'w', encoding='utf-8') as fout:
+                for line in fin:
+                    if args.mode == 'banglish':
+                        fout.write(to_natural_banglish(line.strip()) + '\n')
+                    elif args.mode == 'codemixed':
+                        fout.write(to_natural_codemixed(line.strip()) + '\n')
+                    else:
+                        res = {
+                            'bn': line.strip(),
+                            'banglish': to_natural_banglish(line.strip()),
+                            'codemixed': to_natural_codemixed(line.strip())
+                        }
+                        fout.write(json.dumps(res, ensure_ascii=False) + '\n')
+            print(f"Saved output to: {out_path}")
+    else:
+        # Input is a direct string
+        if args.mode == 'banglish':
+            print(to_natural_banglish(args.input))
+        elif args.mode == 'codemixed':
+            print(to_natural_codemixed(args.input))
+        else:
+            print("--- Original Bangla ---")
+            print(args.input)
+            print("\n--- Natural Avro Banglish ---")
+            print(to_natural_banglish(args.input))
+            print("\n--- Natural Code-Mixed ---")
+            print(to_natural_codemixed(args.input))
+
+if __name__ == "__main__":
+    main()

bangla_multiscript/detector.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+BanglaMultiScript Script & Language Identification (LID) Module
+Detects whether a given text is Bengali, Avro Banglish, English, or Code-Mixed.
+"""
+
+import re
+from typing import Dict, Union
+
+# Common Banglish grammatical particles and high-frequency phonetic markers
+BANGLISH_MARKERS = {
+    "ami", "tumi", "apni", "amra", "tomra", "apnara", "she", "tini", "tara",
+    "kemon", "achi", "achho", "achhen", "bhalo", "valo", "korcho", "korchhi",
+    "korben", "korte", "hobe", "hobena", "hoy", "hoyeche", "hoyechhe",
+    "keno", "kintu", "ebong", "ar", "aar", "aaroo", "aro", "kothay", "kokhon",
+    "kivabe", "ki", "kee", "shob", "sob", "thik", "ekhon", "tokhon",
+    "gotokal", "aaj", "ajke", "shathe", "sathe", "theke", "por", "pore",
+    "jani", "janina", "dekhi", "dekhun", "bolun", "bolte", "shunte",
+    "parbo", "parbena", "parbe", "uchit", "chilo", "chhilo", "achhe",
+    "eta", "ota", "ei", "oi", "ekta", "duita", "shunte", "bujhte",
+    "darao", "ashbo", "jabo", "korechi", "gesilam", "giyechilam"
+}
+
+# Common English stopwords
+ENGLISH_MARKERS = {
+    "the", "is", "are", "was", "were", "and", "or", "but", "if", "then",
+    "what", "why", "how", "when", "where", "who", "which", "this", "that",
+    "these", "those", "have", "has", "had", "will", "would", "shall",
+    "should", "can", "could", "may", "might", "must", "with", "from",
+    "about", "against", "between", "into", "through", "during", "before",
+    "after", "above", "below", "to", "of", "for", "in", "on", "at", "by"
+}
+
+def get_script_stats(text: str) -> Dict[str, float]:
+    """
+    Computes character-level distribution across scripts:
+    Returns percentages of Bengali, Latin, Digits, and Punctuation/Whitespace.
+    """
+    if not text or not isinstance(text, str):
+        return {"bengali": 0.0, "latin": 0.0, "digits": 0.0, "other": 0.0, "total_chars": 0}
+
+    total = len(text)
+    bn_count = len(re.findall(r'[\u0980-\u09FF]', text))
+    latin_count = len(re.findall(r'[a-zA-Z]', text))
+    digit_count = len(re.findall(r'[0-9\u09E6-\u09EF]', text))
+    other_count = total - (bn_count + latin_count + digit_count)
+
+    return {
+        "bengali": round(bn_count / total, 4),
+        "latin": round(latin_count / total, 4),
+        "digits": round(digit_count / total, 4),
+        "other": round(other_count / total, 4),
+        "total_chars": total
+    }
+
+def detect_script(text: str) -> str:
+    """
+    Detects the predominant script / language form of the text:
+    - 'bengali': Formal Bengali script (বাংলা)
+    - 'banglish': Bengali written using English / Latin letters (Avro Banglish)
+    - 'codemixed': Sentence containing significant blend of Bengali and English words
+    - 'english': Standard English text
+    - 'unknown': Empty or numeric/symbol-only text
+    """
+    if not text or not isinstance(text, str):
+        return "unknown"
+
+    stats = get_script_stats(text)
+    bn_ratio = stats["bengali"]
+    latin_ratio = stats["latin"]
+
+    # If virtually no alphabetic characters
+    if bn_ratio == 0 and latin_ratio == 0:
+        return "unknown"
+
+    # Both Bengali and Latin present in meaningful amounts -> Code-Mixed
+    if bn_ratio >= 0.15 and latin_ratio >= 0.15:
+        return "codemixed"
+
+    # Predominantly Bengali script
+    if bn_ratio > 0.40 and latin_ratio < 0.15:
+        return "bengali"
+
+    # Predominantly Latin characters -> Distinguish Banglish vs English
+    tokens = [re.sub(r'[^a-zA-Z]', '', w).lower() for w in text.split()]
+    tokens = [w for w in tokens if len(w) > 1]
+
+    if not tokens:
+        return "unknown"
+
+    banglish_score = sum(1 for t in tokens if t in BANGLISH_MARKERS)
+    english_score = sum(1 for t in tokens if t in ENGLISH_MARKERS)
+
+    # If Banglish marker hits exist and exceed English
+    if banglish_score > english_score:
+        return "banglish"
+    elif english_score > banglish_score:
+        return "english"
+
+    # Secondary heuristic: phonetic character combinations typical in Banglish
+    # (e.g. 'kh', 'gh', 'ch', 'jh', 'th', 'dh', 'bh', 'sh', 'ng', 'chho')
+    banglish_phonetic_pattern = re.compile(r'(chho|kkh|sh|bh|dh|th|jh|ch|gh|kh|ng|oy|ye)')
+    phonetic_hits = len(banglish_phonetic_pattern.findall(text.lower()))
+    word_count = len(tokens)
+
+    if word_count > 0 and (phonetic_hits / word_count) >= 0.6:
+        return "banglish"
+
+    # Fallback based on dominant character ratio
+    if bn_ratio > latin_ratio:
+        return "bengali"
+    return "english"

bangla_multiscript/engine.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+"""
+BanglaMultiScript Core Engine
+Provides high-throughput, linguistically sound conversion from standard Bengali
+to Natural Avro Banglish and Natural Code-Mixed text.
+"""
+
+import re
+import unicodedata
+from typing import List, Dict, Union, Optional
+
+from .lexicon import (
+    LOANWORDS_AND_ENTITIES,
+    COLLOQUIAL_LEXICON,
+    CODEMIXED_REPLACEMENTS,
+    VOWELS_INDEP,
+    VOWELS_DEP,
+    CONSONANTS,
+    CONJUNCT_MAP
+)
+
+def clean_repetition_trash(text: str) -> str:
+    """
+    Cleans up artificial repetition loops and trailing acronym spam
+    common in machine translation outputs (e.g. 'si. es. si. es...').
+    """
+    if not text or not isinstance(text, str):
+        return ""
+    # Match identical short token (e.g. 'si. ' or 'es. ') repeated 3+ times
+    cleaned = re.sub(r'(?:(\b[a-zA-Z\u0980-\u09FF]{1,4}\.?\s+)\1{2,})', r'\1', text)
+    # Match 2-token phrase repeated 3+ times (e.g. 'si. es. si. es. si. es.')
+    cleaned = re.sub(r'(?:(\b\w+\.?\s+\w+\.?\s+)\1{2,})', r'\1', cleaned)
+    # Match any word repeated consecutively 3+ times
+    cleaned = re.sub(r'\b(\w+)(?:\s+\1){2,}\b', r'\1', cleaned)
+    # Clean trailing acronym loops (e.g. trailing 'সি. এস. সি. এস.')
+    cleaned = re.sub(r'(?:[a-zA-Z\u0980-\u09FF]{1,3}\.\s*){4,}', ' ', cleaned)
+    cleaned = re.sub(r'[,.\s]+$', '.', cleaned)
+    return re.sub(r'\s+', ' ', cleaned).strip()
+
+def phonological_word_to_banglish(word: str) -> str:
+    """
+    Transliterates a single Bengali token into natural Avro Banglish
+    respecting inherent schwa vowel deletion, conjunct gemination, and common suffixes.
+    """
+    clean = re.sub(r'[^\w\u0980-\u09FF]', '', word)
+    if not clean:
+        return word
+    
+    # 1. Direct Colloquial Lexicon Lookup
+    if clean in COLLOQUIAL_LEXICON:
+        return COLLOQUIAL_LEXICON[clean]
+    
+    # 2. Suffix Decomposition
+    for suffix, rep in [
+        ('ের', 'er'), ('দের', 'der'), ('গুলো', 'gulo'), ('গুলি', 'guli'),
+        ('কে', 'ke'), ('তে', 'te'), ('টা', 'ta'), ('টি', 'ti'),
+        ('ভাবে', 'bhabe'), ('মূলক', 'mulok'), ('কারী', 'kari'), ('কারিদের', 'karider')
+    ]:
+        if clean.endswith(suffix) and len(clean) > len(suffix) + 1:
+            stem = clean[:-len(suffix)]
+            if stem in COLLOQUIAL_LEXICON:
+                return COLLOQUIAL_LEXICON[stem] + ('-' if suffix in ['টা', 'টি'] else '') + rep
+    
+    # 3. Conjunct Resolution
+    w = unicodedata.normalize('NFC', clean)
+    for cj, rep in CONJUNCT_MAP.items():
+        w = w.replace(cj, rep)
+    
+    # 4. Phonetic Traversal
+    res = []
+    i = 0
+    n = len(w)
+    while i < n:
+        c = w[i]
+        if i + 1 < n and w[i+1] == '়':
+            c = c + '়'
+            i += 1
+            
+        if c in VOWELS_INDEP:
+            res.append(VOWELS_INDEP[c])
+        elif c in CONSONANTS:
+            res.append(CONSONANTS[c])
+            if i + 1 < n:
+                nxt = w[i+1]
+                if nxt == '্':
+                    i += 1  # Skip hasanta
+                elif nxt in VOWELS_DEP:
+                    res.append(VOWELS_DEP[nxt])
+                    i += 1
+                elif nxt in CONSONANTS or nxt in VOWELS_INDEP:
+                    # Inherent vowel rule: insert 'o' between consonants
+                    res.append('o')
+        elif c in VOWELS_DEP:
+            res.append(VOWELS_DEP[c])
+        else:
+            res.append(c)
+        i += 1
+        
+    s = ''.join(res)
+    # Clean double 'o' or unnatural clusters
+    s = re.sub(r'oo+', 'o', s)
+    s = re.sub(r'yy+', 'y', s)
+    return s
+
+def to_natural_banglish(text: str) -> str:
+    """
+    Converts a standard Bengali sentence into colloquial Avro Banglish.
+    Preserves English loanwords, technical nomenclature, and entity names in proper Latin.
+    """
+    if not text or not isinstance(text, str):
+        return ""
+    
+    # 1. Map known loanwords and entities
+    res = text
+    for bn_term, eng_term in LOANWORDS_AND_ENTITIES:
+        pattern = re.escape(bn_term)
+        res = re.sub(pattern, eng_term, res)
+        
+    # 2. Tokenize and convert remaining Bengali script tokens
+    tokens = re.split(r'(\s+|[.,!?;:\"\'\(\)\[\]|।])', res)
+    out = []
+    for t in tokens:
+        if not t:
+            continue
+        if re.search(r'[\u0980-\u09FF]', t):
+            out.append(phonological_word_to_banglish(t))
+        elif t == '।':
+            out.append('.')
+        else:
+            out.append(t)
+            
+    final_text = ''.join(out)
+    final_text = clean_repetition_trash(final_text)
+    
+    # Common post-cleanup heuristics
+    final_text = re.sub(r'\bkno\b', 'keno', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bbaddhy\b', 'baddho', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bsmpork\b', 'shomporko', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bsmpourn\b', 'shompurno', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bchndrer\b', 'chondrer', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bchndro\b', 'chondro', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bkkhma\b', 'khoma', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bljjoa\b', 'lojja', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bodrishy\b', 'odrishyo', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bbouddhik\b', 'boudhik', final_text, flags=re.IGNORECASE)
+    final_text = re.sub(r'\bsmbhoabybhabe\b', 'shombhabobhabe', final_text, flags=re.IGNORECASE)
+    
+    return re.sub(r'\s+', ' ', final_text).strip()
+
+def to_natural_codemixed(text: str) -> str:
+    """
+    Transforms standard Bengali text into natural urban Code-Mixed Bengali-English.
+    Replaces technical, conversational, and security concepts with authentic English loanwords
+    while preserving Bengali morpho-syntax.
+    """
+    if not text or not isinstance(text, str):
+        return ""
+    res = text
+    for pattern, rep in CODEMIXED_REPLACEMENTS:
+        res = re.sub(pattern, rep, res)
+    return clean_repetition_trash(res)
+
+class MultiScriptConverter:
+    """
+    High-level class for converting Bengali text, batches, or DataFrames
+    into multiple parallel scripts.
+    """
+    def __init__(self, cache_size: int = 10000, translator=None):
+        self._cache = {}
+        self.cache_size = cache_size
+        self._translator = translator
+
+    def convert_sentence(self, text: str, mode: str = 'all', src_lang: str = 'bn') -> Union[str, Dict[str, str]]:
+        """
+        Converts a single sentence.
+        mode: 'banglish', 'codemixed', or 'all' (returns dict)
+        src_lang: 'bn' (Bengali, default) or 'en' (English, translated first)
+        """
+        if not text or not isinstance(text, str):
+            return "" if mode != 'all' else {'bangla': '', 'banglish': '', 'codemixed': ''}
+
+        bn_text = text
+        if src_lang == 'en':
+            if self._translator is None:
+                from .translator import get_translator
+                self._translator = get_translator("auto")
+            bn_text = self._translator.translate(text)
+
+        if mode == 'banglish':
+            return to_natural_banglish(bn_text)
+        elif mode == 'codemixed':
+            return to_natural_codemixed(bn_text)
+        else:
+            res = {
+                'bangla': bn_text,
+                'banglish': to_natural_banglish(bn_text),
+                'codemixed': to_natural_codemixed(bn_text)
+            }
+            if src_lang == 'en':
+                res['english'] = text
+            return res
+
+    def convert_batch(self, texts: List[str], mode: str = 'banglish', src_lang: str = 'bn') -> List[Union[str, Dict[str, str]]]:
+        """Converts a list of sentences."""
+        return [self.convert_sentence(t, mode=mode, src_lang=src_lang) for t in texts]
+
+    def convert_dataframe(self, df, text_column: str,
+                          banglish_col: str = 'text_banglish',
+                          codemixed_col: str = 'text_codemixed'):
+        """
+        Takes a pandas DataFrame and adds natural Banglish and Code-Mixed columns in-place.
+        """
+        df[banglish_col] = df[text_column].apply(to_natural_banglish)
+        df[codemixed_col] = df[text_column].apply(to_natural_codemixed)
+        return df
+
+def all_in_one(
+    text: str,
+    src_lang: str = "auto",
+    translator_backend: str = "auto",
+    translator_model_path: Optional[str] = None
+) -> Dict[str, str]:
+    """
+    All-in-one unified converter.
+    Accepts Bengali or English text and outputs all script representations:
+    - Bengali (বাংলা)
+    - Natural Avro Banglish
+    - Modern Urban Code-Mixed
+    - (English original if translated)
+
+    Parameters:
+        text (str): Input text in Bengali or English.
+        src_lang (str): 'auto', 'bn', or 'en'.
+        translator_backend (str): 'auto', 'web', 'indictrans2', or 'none'.
+        translator_model_path (str, optional): Custom path or HuggingFace ID for IndicTrans2.
+    """
+    if not text or not isinstance(text, str):
+        return {"bangla": "", "banglish": "", "codemixed": ""}
+
+    is_english = False
+    if src_lang == "en":
+        is_english = True
+    elif src_lang == "auto":
+        # Detect if text contains Bengali Unicode characters (U+0980 to U+09FF)
+        has_bengali = bool(re.search(r'[\u0980-\u09FF]', text))
+        if not has_bengali and any(c.isalpha() for c in text):
+            is_english = True
+
+    if is_english and translator_backend != "none":
+        from .translator import get_translator
+        tr = get_translator(backend=translator_backend, model_path=translator_model_path)
+        bn_text = tr.translate(text)
+        return {
+            "english": text,
+            "bangla": bn_text,
+            "banglish": to_natural_banglish(bn_text),
+            "codemixed": to_natural_codemixed(bn_text)
+        }
+    else:
+        return {
+            "bangla": text,
+            "banglish": to_natural_banglish(text),
+            "codemixed": to_natural_codemixed(text)
+        }
+

bangla_multiscript/exporter.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""
+BanglaMultiScript Dataset Exporter Module
+Exports parallel datasets into popular LLM fine-tuning schemas:
+- ShareGPT (Conversations schema used by Unsloth, LLaMA-Factory, FastChat)
+- Alpaca (Instruction, Input, Output)
+- DPO (Direct Preference Optimization: prompt, chosen, rejected)
+"""
+
+import json
+from typing import List, Dict, Union, Optional, Any
+
+def _to_records(data: Any) -> List[Dict]:
+    """Helper to convert pandas DataFrame or list of dicts to standard list of dicts."""
+    if hasattr(data, 'to_dict'):
+        return data.to_dict(orient='records')
+    elif isinstance(data, list):
+        return data
+    raise TypeError(f"Unsupported data type: {type(data)}. Expected list of dicts or pandas DataFrame.")
+
+def export_to_sharegpt(
+    data: Any,
+    output_file: Optional[str] = None,
+    prompt_col: str = "prompt",
+    response_col: str = "response",
+    system_prompt: Optional[str] = None
+) -> List[Dict]:
+    """
+    Exports dataset into ShareGPT / FastChat / LLaMA-Factory format:
+    [
+        {
+            "conversations": [
+                {"from": "system", "value": ...},  # Optional
+                {"from": "human", "value": ...},
+                {"from": "gpt", "value": ...}
+            ]
+        }
+    ]
+    """
+    records = _to_records(data)
+    sharegpt_list = []
+
+    for item in records:
+        human_msg = str(item.get(prompt_col, "")).strip()
+        gpt_msg = str(item.get(response_col, "")).strip()
+
+        convs = []
+        if system_prompt:
+            convs.append({"from": "system", "value": system_prompt})
+        convs.append({"from": "human", "value": human_msg})
+        convs.append({"from": "gpt", "value": gpt_msg})
+
+        sharegpt_list.append({"conversations": convs})
+
+    if output_file:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(sharegpt_list, f, ensure_ascii=False, indent=2)
+
+    return sharegpt_list
+
+def export_to_alpaca(
+    data: Any,
+    output_file: Optional[str] = None,
+    instruction_col: str = "prompt",
+    output_col: str = "response",
+    input_col: Optional[str] = None
+) -> List[Dict]:
+    """
+    Exports dataset into Stanford Alpaca format:
+    [
+        {
+            "instruction": ...,
+            "input": ...,
+            "output": ...
+        }
+    ]
+    """
+    records = _to_records(data)
+    alpaca_list = []
+
+    for item in records:
+        inst = str(item.get(instruction_col, "")).strip()
+        out = str(item.get(output_col, "")).strip()
+        inp = str(item.get(input_col, "")).strip() if input_col else ""
+
+        alpaca_list.append({
+            "instruction": inst,
+            "input": inp,
+            "output": out
+        })
+
+    if output_file:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(alpaca_list, f, ensure_ascii=False, indent=2)
+
+    return alpaca_list
+
+def export_to_dpo(
+    data: Any,
+    output_file: Optional[str] = None,
+    prompt_col: str = "prompt",
+    chosen_col: str = "chosen",
+    rejected_col: str = "rejected"
+) -> List[Dict]:
+    """
+    Exports dataset into DPO (Direct Preference Optimization) format (TRL / Hugging Face format):
+    [
+        {
+            "prompt": ...,
+            "chosen": ...,
+            "rejected": ...
+        }
+    ]
+    """
+    records = _to_records(data)
+    dpo_list = []
+
+    for item in records:
+        p = str(item.get(prompt_col, "")).strip()
+        c = str(item.get(chosen_col, "")).strip()
+        r = str(item.get(rejected_col, "")).strip()
+
+        dpo_list.append({
+            "prompt": p,
+            "chosen": c,
+            "rejected": r
+        })
+
+    if output_file:
+        is_jsonl = output_file.endswith('.jsonl')
+        with open(output_file, 'w', encoding='utf-8') as f:
+            if is_jsonl:
+                for row in dpo_list:
+                    f.write(json.dumps(row, ensure_ascii=False) + '\n')
+            else:
+                json.dump(dpo_list, f, ensure_ascii=False, indent=2)
+
+    return dpo_list