KenTrans.py

"""Kenyan Languages to Swahili Translation Dataset"""

import os
import re
from pathlib import Path
from typing import Dict, List, Tuple

import datasets


_CITATION = """\
@misc{kenyan_translation,
  title={Kenyan Languages to Swahili Translation Dataset},
  author={Kenya NLP},
  year={2025}
}
"""

_DESCRIPTION = """\
This dataset contains parallel text translations from several Kenyan languages (Dholuo, Lubukusu, Lucheka, Lulogooli)
into Swahili. Each file contains sentence pairs in the format:
- O: <source_sentence> (Original)
- T: <target_sentence> (Translation/Target)

The dataset is organized by source language and can be loaded by specifying the language code.
"""

_HOMEPAGE = "https://github.com/yourusername/kenyan-translation"

_LICENSE = "CC-BY-4.0"

_LANGUAGES = ["dho", "lbk", "lch", "llg"]
_LANG_NAMES = {
    "dho": "Dholuo",
    "lbk": "Lubukusu",
    "lch": "Lucheka",
    "llg": "Lulogooli"
}

_TARGET_LANGUAGE = "swa"  # Swahili


class KenyanTranslationConfig(datasets.BuilderConfig):
    """BuilderConfig for Kenyan Translation Dataset."""

    def __init__(self, lang: str = None, **kwargs):
        """
        Args:
            lang: Language code (dho, lbk, lch, or llg)
            **kwargs: keyword arguments forwarded to super.
        """
        super().__init__(**kwargs)
        self.lang = lang


class KenyanTranslation(datasets.GeneratorBasedBuilder):
    """Kenyan Languages to Swahili Translation Dataset"""

    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIG_CLASS = KenyanTranslationConfig

    def _info(self):
        features = datasets.Features(
            {
                "id": datasets.Value("string"),
                "source": datasets.Value("string"),
                "target": datasets.Value("string"),
                "src_lang": datasets.Value("string"),
                "tgt_lang": datasets.Value("string"),
                "pair": datasets.Value("string"),
                "filename": datasets.Value("string"),
            }
        )

        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""

        # Validate that lang was provided
        if not self.config.lang:
            raise ValueError(
                "Please specify a language code using lang parameter. "
                f"Available languages: {', '.join(_LANGUAGES)}\n"
                f"Example: load_dataset('USERNAME/REPO_NAME', lang='dho')"
            )

        if self.config.lang not in _LANGUAGES:
            raise ValueError(
                f"Language '{self.config.lang}' not supported. "
                f"Available languages: {', '.join(_LANGUAGES)}"
            )

        # Get data files - either from config or by listing from the data directory
        if self.config.data_files:
            # Get all files for this language from provided data_files
            if isinstance(self.config.data_files, dict):
                all_files = []
                for split_files in self.config.data_files.values():
                    if isinstance(split_files, list):
                        all_files.extend(split_files)
                    else:
                        all_files.append(split_files)
            else:
                all_files = self.config.data_files if isinstance(self.config.data_files, list) else [self.config.data_files]

            # Filter files that belong to the selected language
            lang_files = [f for f in all_files if f"data/{self.config.lang}/" in str(f)]
        else:
            # No data_files provided - need to list files from the repository
            # Use dl_manager's dataset_name to construct paths
            import datasets
            from datasets.data_files import DataFilesDict, get_data_patterns

            # Get base path - this works for both local and Hub loading
            base_path = dl_manager._base_path if hasattr(dl_manager, '_base_path') and dl_manager._base_path else ""

            # Construct the pattern for the language data directory
            data_pattern = f"{base_path}/data/{self.config.lang}/*.txt" if base_path else f"data/{self.config.lang}/*.txt"

            # List files using the data files pattern
            from datasets.data_files import DataFilesList
            lang_files = DataFilesList.from_patterns([data_pattern], base_path=base_path)

        if not lang_files:
            raise ValueError(
                f"No data files found for language '{self.config.lang}'. "
                f"Expected files in data/{self.config.lang}/"
            )

        # Download all files
        downloaded_files = dl_manager.download(lang_files)

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "files": downloaded_files,
                    "lang": self.config.lang,
                },
            ),
        ]

    def _parse_ot_format(self, content: str) -> List[Tuple[str, str]]:
        """Parse O:/T: format from file content."""
        pairs = []
        lines = content.split('\n')

        current_source = ""
        current_target = ""

        for line in lines:
            line = line.strip()

            # Remove line numbers (e.g., "1→O:" becomes "O:")
            line = re.sub(r'^\s*\d+→', '', line)

            if line.startswith('O:'):
                # Save previous pair if exists
                if current_source and current_target:
                    pairs.append((current_source.strip(), current_target.strip()))
                    current_target = ""

                # Start new source
                current_source = line[2:].strip()

            elif line.startswith('T:'):
                # Add to target (might span multiple T: lines)
                target_text = line[2:].strip()
                if current_target:
                    current_target += " " + target_text
                else:
                    current_target = target_text

        # Add last pair
        if current_source and current_target:
            pairs.append((current_source.strip(), current_target.strip()))

        return pairs

    def _parse_tab_format(self, content: str) -> List[Tuple[str, str]]:
        """Parse tab-separated format."""
        pairs = []
        for line in content.split('\n'):
            line = line.strip()
            if not line:
                continue
            parts = line.split('\t')
            if len(parts) >= 2:
                pairs.append((parts[0].strip(), parts[1].strip()))
        return pairs

    def _parse_pipe_format(self, content: str) -> List[Tuple[str, str]]:
        """Parse ||| separated format."""
        pairs = []
        for line in content.split('\n'):
            line = line.strip()
            if not line:
                continue
            parts = line.split('|||')
            if len(parts) >= 2:
                pairs.append((parts[0].strip(), parts[1].strip()))
        return pairs

    def _parse_content(self, content: str) -> List[Tuple[str, str]]:
        """Parse content string and return list of (source, target) pairs."""
        # Try O:/T: format first
        if 'O:' in content and 'T:' in content:
            pairs = self._parse_ot_format(content)
            if pairs:
                return pairs

        # Fall back to tab-separated
        if '\t' in content:
            pairs = self._parse_tab_format(content)
            if pairs:
                return pairs

        # Fall back to pipe-separated
        if '|||' in content:
            pairs = self._parse_pipe_format(content)
            if pairs:
                return pairs

        return []

    def _parse_file(self, filepath: Path) -> List[Tuple[str, str]]:
        """Parse a file and return list of (source, target) pairs."""
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                content = f.read()
        except UnicodeDecodeError:
            # Try with different encoding
            with open(filepath, 'r', encoding='latin-1') as f:
                content = f.read()

        return self._parse_content(content)

    def _generate_examples(self, files, lang: str):
        """Yields examples."""

        idx = 0

        from pathlib import Path

        # Ensure files is a list
        if isinstance(files, str):
            files = [files]

        # Sort files for consistent ordering
        for filepath in sorted(files):
            filepath = Path(filepath)
            filename = filepath.name

            # Read and parse the file
            try:
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()
            except UnicodeDecodeError:
                with open(filepath, 'r', encoding='latin-1') as f:
                    content = f.read()

            # Parse content
            pairs = self._parse_content(content)

            # Yield each pair as an example
            for pair_idx, (source, target) in enumerate(pairs):
                # Skip empty pairs
                if not source or not target:
                    continue

                example_id = f"{lang}_{filename}_{pair_idx}"

                yield idx, {
                    "id": example_id,
                    "source": source,
                    "target": target,
                    "src_lang": lang,
                    "tgt_lang": _TARGET_LANGUAGE,
                    "pair": f"{lang}-{_TARGET_LANGUAGE}",
                    "filename": filename,
                }

                idx += 1