Update README.md

README.md

@@ -1,274 +1,136 @@
 ---
 license: cc-by-sa-4.0
+pretty_name: Tigre Wikipedia Corpus
 tags:
-- wikipedia
-- tigre
-- tig
-- corpus
-- machine learning
-- low-resource
+  - wikipedia
+  - tigre
+  - tig
+  - corpus
+  - machine learning
+  - low-resource
 language:
-- tig
+  - tig
 ---
 
-# 🇪🇷 Tigre Wikipedia (tigwiki) Corpus
+# Tigre Wikipedia Corpus (tigwiki)
 
-The **Tigre Wikipedia Corpus** is a foundational resource containing all non-template articles from **tig.wikipedia.org**. This dataset is essential for developing Natural Language Processing (NLP) models, such as language models, machine translation systems, and text generation tools for the **Tigre language (ISO 639-3: tig)**.
+### Overview
 
-This project represents the dedicated effort of the Tigre diaspora community to build a comprehensive digital knowledge base.
+This repository houses the **Tigre Wikipedia Corpus**, a foundational linguistic resource containing all non-template articles from **https://tig.wikipedia.org**.
 
-## 🌟 Background and Scope
+**Tigre** is an under-resourced South Semitic language within the Afro-Asiatic family. This dataset serves as a critical component for bridging the digital divide, facilitating the development of Natural Language Processing (NLP) models—including Language Models (LMs), Machine Translation (MT) systems, and text generation tools—specifically tailored for the Tigre community.
 
-The Tigre language Wikipedia was **approved and went live in December 2024**, marking a significant milestone for the digital presence of the language. This initial corpus is the result of a collaboration of more than **twenty diaspora volunteers** who continue to actively contribute content.
+### Background & Scope
 
-### Primary Sections Covered
+The Tigre language Wikipedia was officially **approved and launched in December 2024**, marking a significant milestone for the language's digital presence. This corpus represents the collective effort of the **Tigre diaspora community**, with contributions from over twenty dedicated volunteers who actively build and maintain this comprehensive digital knowledge base.
 
-The portal currently organizes its content into the following key sections:
+---
 
-* Let's explore our country
-* Tourism
-* Art and Culture
-* Politics
-* Books
-* Science and Technology
-* History
-* Health
-* Biography
-* Miscellaneous
-* Sport
-* Fun
-* Reference
-* Tigre Language
-* Food and Drinks
-* Pictures
+## Included Data & Coverage
 
-## 📖 Dataset Structure
+### **Data Modalities**
 
-The corpus is provided as a single, compressed JSON Lines file (`tigre_wikipedia.jsonl.gz`). Each line represents one cleaned Wikipedia article.
+This repository contains **Monolingual Text** extracted directly from Wikipedia articles.
 
-### Data Fields
+### **Domain Coverage**
 
-| Feature | Type | Description |
-| :--- | :--- | :--- |
-| **id** | `string` | The unique ID of the Wikipedia article. |
-| **title** | `string` | The title of the article (e.g., "History of Eritrea"). |
-| **text** | `string` | The **cleaned, plain text content** of the article (Wikitext and metadata removed). |
+The corpus encompasses a diverse range of topics, reflecting the broad scope of the encyclopedia. Key sections include:
 
-## 🚀 Usage
+- **Culture & Heritage:** Art, Culture, Food, and Drinks
+- **Geography & Travel:** "Let's explore our country," Tourism
+- **STEM:** Science, Technology, Health
+- **Humanities:** History, Politics, Biography, Literature (Books)
+- **General Interest:** Sport, Entertainment ("Fun"), Miscellaneous
 
-You can load this dataset directly using the Hugging Face `datasets` library.
+---
 
-```python
-from datasets import load_dataset
+## Dataset Structure
+
+The corpus is provided as a single, compressed JSON Lines file (`tigre_wikipedia.jsonl.gz`). This format is efficient for streaming and compatibility with standard NLP libraries.
+
+```
+tigre-data-wikipedia/
+├── README.md
+├── build_corpus.py             
+└── tigre_wikipedia.jsonl.gz    
+```
+
+### **Data Fields**
+
+| Field | Type | Description |
+|-------|--------|-------------|
+| id | string | Unique ID of the article |
+| title | string | Article title |
+| text | string | Cleaned plain-text content |
 
-# Replace 'your_username' with your Hugging Face username
-dataset = load_dataset("your_username/tigre_wikipedia")
+---
+
+## Data Provenance & Methodology
+
+### **Data Generation Pipeline**
+
+The data is generated from official Wikimedia XML dumps using a custom SAX-based streaming parser. Steps include:
 
-# Example: Accessing the first article
-print(dataset['train'][0]['title'])
-print(dataset['train'][0]['text'][:500] + "...")
+1. **Source:** Downloads raw XML dumps.  
+2. **Extraction:** Processes compressed files efficiently.  
+3. **Filtering:** Removes non-main namespaces (User:, Talk:, Template:).  
+4. **Output:** Serializes clean text into JSONL format.
 
+---
 
-## ⚙️ Data Generation Pipeline (Reproducibility)
+## Bias, Risks & Known Limitations
 
-The data in this repository is generated automatically from the raw Wikimedia dumps to ensure it is always the latest, cleanest version. This process is built using **standard Python libraries** to maximize stability and compatibility across different environments.
+- **Community Bias:** Overrepresentation of diaspora-relevant topics.  
+- **Domain Bias:** Overemphasis on formal encyclopedic style.  
+- **Size Limitations:** As a newer Wikipedia (Dec 2024), content volume is still growing.
 
-### Processing Method
+---
 
-The corpus is created using a custom Python script that follows a resource-efficient **streaming (SAX) approach**:
+## How to Use
 
-1.  **Source:** The raw XML dump (`tigwiki-*-pages-articles-multistream.xml.bz2`) is downloaded from the official Wikimedia dumps repository.
-2.  **Extraction:** A **SAX (Streaming API for XML) parser** is used to read the highly compressed BZ2 file chunk-by-chunk. This is crucial for handling large files efficiently without requiring the entire dataset to be loaded into memory.
-3.  **Cleaning/Filtering:** The custom parser extracts the article ID, title, and text content. Articles belonging to non-main namespaces (e.g., "User:", "Talk:", "Template:") are automatically filtered out using the presence of a colon (`:`) in the title.
-4.  **Output:** The clean text is written directly into the final compressed **JSON Lines (`.jsonl.gz`)** file.
+### **Loading via Hugging Face**
 
-### Obtain the Latest Corpus (Automation Script)
+```python
+from datasets import load_dataset
 
-Volunteers are continuously adding new content to tig.wikipedia.org. If you need to obtain the latest version of the corpus as a single `jsonl.gz` file containing the entire content, you can run the script provided below.
+dataset = load_dataset("BeitTigreAI/tigre-data-wikipedia", split="train")
+
+print(dataset[0]["title"])
+print(dataset[0]["text"][:200])
+```
+
+---
+
+## Reproducibility: Build Latest Version
+
+### 1. Install Requirements
 
-**1. Install Prerequisites:**
 ```bash
 pip install requests beautifulsoup4
+```
 
-```python
-import requests
-from bs4 import BeautifulSoup
-import os
-import gzip
-import shutil
-import logging
-import json
-import bz2
-import xml.sax
-
-# --- Configuration (Tigre - tigwiki) ---
-WIKI_CODE = 'tigwiki'
-BASE_URL = f'[https://dumps.wikimedia.org/](https://dumps.wikimedia.org/){WIKI_CODE}/'
-FILE_PATTERN = f'{WIKI_CODE}-*-pages-articles-multistream.xml.bz2'
-OUTPUT_DIR = 'tigre_raw_dump'
-FINAL_FILENAME = 'tigre_wikipedia.jsonl.gz'
-# ---------------------
-
-logging.basicConfig(level=logging.INFO,
-                    format='%(asctime)s - %(levelname)s - %(message)s')
-
-# --- 1. XML Handler Class ---
-
-class WikiDumpHandler(xml.sax.ContentHandler):
-    """
-    SAX handler to parse Wikipedia XML and extract title and text.
-    SAX is used because it's a streaming parser, ideal for huge files.
-    """
-    def __init__(self, output_file):
-        super().__init__()
-        self.output_file = output_file
-        self.current_tag = ""
-        self.in_page = False
-        self.in_revision = False
-        self.in_text = False
-        self.in_title = False
-        self.current_title = ""
-        self.current_text = ""
-        self.current_id = ""
-        self.article_count = 0
-        self.logging_interval = 500  # Log every 500 articles
-
-    def startElement(self, name, attrs):
-        self.current_tag = name
-        if name == "page":
-            self.in_page = True
-            self.current_title = ""
-            self.current_id = ""
-        elif name == "revision":
-            self.in_revision = True
-        elif name == "text":
-            self.in_text = True
-            self.current_text = ""
-        elif name == "title":
-            self.in_title = True
-        
-    def characters(self, content):
-        if self.in_page:
-            if self.in_title:
-                self.current_title += content
-            elif self.current_tag == "id" and not self.current_id:
-                self.current_id = content
-            elif self.in_revision and self.in_text:
-                self.current_text += content
-
-    def endElement(self, name):
-        if name == "text":
-            self.in_text = False
-        elif name == "title":
-            self.in_title = False
-        elif name == "revision":
-            self.in_revision = False
-        elif name == "page":
-            self.in_page = False
-            # Filter: Check for text existence and skip non-main namespaces (e.g., Talk:, User:)
-            if self.current_text and ":" not in self.current_title: 
-                self.write_article()
-            
-            self.current_title = ""
-            self.current_text = ""
-            self.current_id = ""
-
-    def write_article(self):
-        cleaned_text = self.current_text.strip()
-        
-        data = {
-            "id": self.current_id.strip(),
-            "title": self.current_title.strip(),
-            "text": cleaned_text
-        }
-        
-        self.output_file.write(json.dumps(data, ensure_ascii=False) + '\n')
-        self.article_count += 1
-        
-        if self.article_count % self.logging_interval == 0:
-            logging.info(f"Processed {self.article_count} articles...")
-
-# --- 2. Downloader and URL Finder ---
-
-def get_latest_dump_url():
-    logging.info(f"Checking for latest dump date at: {BASE_URL}")
-    
-    try:
-        response = requests.get(BASE_URL)
-        response.raise_for_status() 
-    except requests.exceptions.RequestException as e:
-        logging.error(f"Failed to access Wikimedia dumps: {e}")
-        return None
-
-    soup = BeautifulSoup(response.content, 'html.parser')
-    date_links = []
-    
-    for link in soup.find_all('a'):
-        href = link.get('href')
-        if href and href.endswith('/') and href.strip('/').isdigit() and len(href.strip('/')) == 8:
-            date_links.append(href.strip('/'))
-
-    if not date_links:
-        logging.error("Could not find any date folders. Aborting.")
-        return None
-
-    latest_date = max(date_links)
-    logging.info(f"Latest dump date found: {latest_date}")
-
-    latest_file_url = f'{BASE_URL}{latest_date}/{FILE_PATTERN.replace("*", latest_date)}'
-    logging.info(f"Final dump URL: {latest_file_url}")
-    return latest_file_url
-
-def download_file(url, target_path):
-    logging.info(f"Starting download to {target_path}...")
-    try:
-        with requests.get(url, stream=True) as r:
-            r.raise_for_status()
-            with open(target_path, 'wb') as f:
-                shutil.copyfileobj(r.raw, f)
-            logging.info("Download complete.")
-            return True
-    except requests.exceptions.RequestException as e:
-        logging.error(f"Download failed: {e}")
-        return False
-
-# --- 3. Main Processing Function ---
-
-def process_and_package_sax(dump_path):
-    logging.info("Starting SAX parsing and packaging...")
-    
-    try:
-        with gzip.open(FINAL_FILENAME, 'wt', encoding='utf-8') as outfile:
-            with bz2.open(dump_path, 'rt', encoding='utf-8') as infile:
-                
-                parser = xml.sax.make_parser()
-                handler = WikiDumpHandler(outfile)
-                parser.setContentHandler(handler)
-                
-                parser.parse(infile)
-        
-        logging.info(f"Successfully created final package: **{FINAL_FILENAME}** containing {handler.article_count} articles.")
-        return True
-    except Exception as e:
-        logging.error(f"Error during SAX processing: {e}")
-        return False
-
-
-def main():
-    dump_url = get_latest_dump_url()
-    if not dump_url:
-        return
-
-    raw_dump_path = os.path.join(OUTPUT_DIR, os.path.basename(dump_url))
-
-    if not download_file(dump_url, raw_dump_path):
-        return
-
-    if not process_and_package_sax(raw_dump_path):
-        return
-
-    shutil.rmtree(OUTPUT_DIR, ignore_errors=True) 
-    logging.info("--- ✅ Process finished successfully! ---")
-
-if __name__ == '__main__':
-    main()
+### 2. Run Script
+
+```bash
+python build_corpus.py
+```
+
+---
+
+## Licensing
+
+Licensed under **CC BY-SA 4.0**.
+
+---
+
+## Citation
+
+```
+@misc{tigre-wikipedia-corpus,
+  author = {BeitTigreAI},
+  title = {Tigre Wikipedia (tigwiki) Corpus},
+  year = {2025},
+  publisher = {Hugging Face},
+  howpublished = {https://huggingface.co/datasets/BeitTigreAI/tigre-data-wikipedia}
+}
+```