Update README.md

README.md

@@ -66,4 +66,209 @@ dataset = load_dataset("your_username/tigre_wikipedia")
 
 # Example: Accessing the first article
 print(dataset['train'][0]['title'])
-print(dataset['train'][0]['text'][:500] + "...")
+print(dataset['train'][0]['text'][:500] + "...")
+
+
+## ⚙️ Data Generation Pipeline (Reproducibility)
+
+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.
+
+### Processing Method
+
+The corpus is created using a custom Python script that follows a resource-efficient **streaming (SAX) approach**:
+
+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.
+
+### Obtain the Latest Corpus (Automation Script)
+
+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.
+
+**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()