Upload 6 files

extract_wiki/1_extract_link.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+"""
+Wikipedia URLs Extractor:
+
+Script to download the Wikipedia dataset from Hugging Face, extract URLs,
+and save them to a text file for further processing.
+
+Required:
+pip install datasets
+
+Using MIN_LENGTH = 1400 results in approximately 1,100,000 URLs.
+Using MIN_LENGTH = 1000 results in approximately 1,800,000 URLs.
+
+Author     : Guillaume Eckendoerffer
+Date       : 14-09-23
+Repository : https://github.com/Eckendoerffer/TorchTrainerFlow/
+             https://huggingface.co/datasets/eckendoerffer/wikipedia_fr
+"""
+
+import os
+from datasets import load_dataset
+
+# Constants
+MIN_LENGTH           = 1400  # Minimum text length in number of characters to be added to the URL list.
+EXCLUDE_TITLES_START = ['Liste ', 'Abréviations ', '(homonymie)']
+
+# File path configurations
+PATH = os.path.dirname(os.path.abspath(__file__))
+URL_FILEPATH = os.path.join(PATH, "wiki_link.txt")
+
+# Resetting the output file
+with open(URL_FILEPATH, 'w', encoding="utf8") as url_file:
+    url_file.write("")
+
+# Loading the dataset
+dataset = load_dataset('wikipedia', '20220301.fr')
+subset  = dataset["train"]
+
+add = 0
+for i, row in enumerate(subset):
+    text  = row["text"]
+    title = row["title"]
+    url   = row["url"]
+
+    # Checking conditions to add the URL
+    if not any(title.startswith(e) for e in EXCLUDE_TITLES_START) and len(text) >= MIN_LENGTH:
+        add += 1
+        print(f"{add} : {len(text)} : {url} : {title}")
+        with open(URL_FILEPATH, 'a', encoding="utf8") as url_file:
+            url_file.write(f"{url.strip()} \n")
+        
+
+
+

extract_wiki/2_extract_content.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+"""
+Wikipedia Source Extractor:
+
+This script retrieves the source code of Wikipedia pages based on URLs found in a text file.
+Instead of saving the entire HTML of the page, it trims the content, focusing on the main article 
+section, thereby limiting the size of each record.
+
+Required:
+pip install aiohttp aiofiles
+
+Usage:
+- Ensure you have a file named "wiki_link.txt" in the same directory as the script.
+- The file should contain one Wikipedia URL per line.
+- Run the script.
+- Extracted content will be saved under the "sources/html_wiki" directory with the name format "{index}.txt".
+
+Author     : Guillaume Eckendoerffer
+Date       : 14-09-23
+Repository : https://github.com/Eckendoerffer/TorchTrainerFlow/
+             https://huggingface.co/datasets/eckendoerffer/wikipedia_fr
+"""
+
+import os
+import asyncio
+import aiohttp
+import aiofiles
+
+START_INDEX = 0
+path = os.path.dirname(os.path.abspath(__file__))
+
+async def fetch_page_content(session, link):
+    """Fetches the page content given a URL."""
+    try:
+        async with session.get(link) as response:
+            return await response.text()
+    except:
+        print(f"Error fetching content from {link}")
+        return None
+
+def extract_content(source):
+    """Extracts the main article section from the full page source."""
+    start_idx = source.find('<div id="siteSub"')
+    if start_idx == -1:
+        return None
+
+    source = source[start_idx:]
+    end_markers = ['id="Notes_et_références"', 'id="Articles_connexes"']
+    for marker in end_markers:
+        end_idx = source.find(marker)
+        if end_idx != -1:
+            source = source[:end_idx] + '>'
+            break
+    return source
+
+async def main():
+    """Main async function to process each link."""
+    async with aiohttp.ClientSession() as session:
+        with open(os.path.join(path, "wiki_link.txt"), "r") as f:
+            links = f.readlines()
+        
+        for i, link in enumerate(links[START_INDEX:], start=START_INDEX+1):
+            print(f"Processing link {i}/{len(links)}")
+            
+            html_content = await fetch_page_content(session, link.strip())
+            if not html_content:
+                continue
+
+            content = extract_content(html_content)
+            if not content:
+                print(f"Unable to extract content from {link}")
+                continue
+
+            output_file_path = os.path.join(path, f"sources/html_wiki/{i}.txt")
+            async with aiofiles.open(output_file_path, "w", encoding="utf-8") as out_file:
+                await out_file.write(content)
+
+loop = asyncio.get_event_loop()
+loop.run_until_complete(main())

extract_wiki/3_extract_txt.py

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+
+"""
+Wikipedia Text Extractor:
+
+This script consists of two main stages, transforming raw HTML source code to testing and filtering lines to retain.
+
+Required:
+pip install beautifulsoup4 langid
+
+Step 1: /html_wiki/ -> /txt_wiki/
+- Removal of undesired tags and classes.
+- Extraction of text content from the HTML code.
+
+Step 2: /txt_wiki/ -> /txt_wiki_lines/
+- Sentence-by-sentence testing to determine elements for exclusion based on criteria like count of special characters, language detection, etc.
+- Language testing is performed on each line and also for every element within parentheses.
+
+The two stages have been deliberately separated. Additionally, numerous log files are generated to aid in debugging, testing, and refining exclusion parameters.
+The goal here is to have a fruitful harvest for some quality text juice, not to hit the lottery jackpot numbers.
+
+Author     : Guillaume Eckendoerffer
+Date       : 22-09-23
+Repository : https://github.com/Eckendoerffer/TorchTrainerFlow/
+             https://huggingface.co/datasets/eckendoerffer/wikipedia_fr
+"""
+
+import os, re
+from bs4 import BeautifulSoup
+from langid.langid import LanguageIdentifier, model
+identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True)
+
+MAX_LENGTH             = int(330)       # nb words per line
+MAX_SENTENCE_LENGTH    = int(350)       # max words per sentence
+# LANG EXCLUDE
+ALLOWED_LANGUAGE       = ['fr']    
+# MATH EXCLUDE
+MAX_NUM_COUNT          = 26
+MAX_PLUS_SIGN_COUNT    = 5
+MAX_EQUALS_SIGN_COUNT  = 5
+# CHAR EXCLUDE
+MAX_DOUBLE_QUOTE_COUNT = 18
+MAX_PARENTHESIS_COUNT  = 14
+MAX_BRACKET_COUNT      = 12
+MAX_COMMA_COUNT        = 40
+MAX_DOLLAR_COUNT       = 5
+# LONG EXCLUDE
+LONG_WORD_CHARS        = 29             # LONG_WORD size in CHARS
+MAXIMUM_LONG_WORDS     = 3              # Remove line if LONG_WORDS count > MAXIMUM_LONG_WORDS
+# CLASS EXCLUDE
+CLASSES_TO_REMOVE      = ['bandeau-container', 'bandeau-section', 'metadata', 'bandeau-niveau-information', 'gallery', 'infobox_v3']
+# TAG EXCLUDE
+TAG_TO_REMOVE          = ['nav', 'menu', 'ul', 'ol', 'table', 'h1', 'h2', 'h3', 'h4', 'h5']
+# PATH
+PATH                   = os.path.dirname(os.path.abspath(__file__)).replace('\\', '/') 
+HTML_PATH              = PATH + '/sources/html_wiki/'
+TARGET_LONG            = PATH + "/excluded_long.txt"
+TARGET_LANG            = PATH + "/excluded_lang.txt"
+TARGET_MATH            = PATH + "/excluded_math.txt"
+TARGET_CHARS           = PATH + "/excluded_chars.txt"
+TARGET_PARENTH         = PATH + "/excluded_parentheses.txt"
+TARGET_LATEX           = PATH + "/excluded_latex.txt"
+FILES = [f for f in os.listdir(HTML_PATH) if os.path.isfile(os.path.join(HTML_PATH, f))]
+
+with open(TARGET_LONG, 'w', encoding="utf8") as f:
+    f.write("")
+with open(TARGET_LANG, 'w', encoding="utf8") as f:
+    f.write("")
+with open(TARGET_MATH, 'w', encoding="utf8") as f:
+    f.write("")
+with open(TARGET_CHARS, 'w', encoding="utf8") as f:
+    f.write("")
+with open(TARGET_PARENTH, 'w', encoding="utf8") as f:
+    f.write("")
+with open(TARGET_LATEX, 'w', encoding="utf8") as f:
+    f.write("")
+
+def extract_wikipedia_text(html_path, txt_path):
+    """ Step 1: Extraction of text content from the HTML code """
+    with open(html_path, "r", encoding="utf-8") as f:
+        wiki_content = f.read()
+    soup = BeautifulSoup(wiki_content, 'html.parser')
+
+    # Remove menus, sub-menus, lists, and tables
+    for tag in soup.find_all(TAG_TO_REMOVE):
+        tag.decompose()
+
+    # Find and remove the divs from classes to remove
+    for class_name in CLASSES_TO_REMOVE:
+        for div in soup.find_all("div", class_=class_name):
+            div.decompose()
+
+    # Retrieve only the text
+    text = soup.get_text()
+    text = text.replace(chr(8217), "'")
+    text = text.replace("`", "'")
+    text = text.replace("‘", "'")
+    text = re.sub(r'\[\d+\]', ' ', text)
+    text = re.sub(r'\{[^\}]*\}', ' ', text)
+    text = re.sub(r'\[[^\}]*\]', ' ', text)
+
+    with open(txt_path, "w", encoding="utf-8") as f:
+        f.write(text)
+    return len(text)
+
+def split_into_sentences(text):
+    sentences = re.split(r'([.;!?]\s*\u00BB|[.;!?\u00BB]\s*(?!\u00BB)|\s*--\s*)', text)
+    sentences = ["".join(i) for i in zip(sentences[0::2], sentences[1::2])]
+    return sentences
+
+def text_standardize(text):
+    text = text.replace('—', '-')
+    text = text.replace('–', '-')
+    text = text.replace('―', '-')
+    text = text.replace('…', '...')
+    text = re.sub('''(~+|!+|"+|;+|\?+|\++|,+|\)+|\(+|\\+|\/+|\*+|\[+|\]+|}+|{+|\|+|_+)''', r' \1 ', text)
+    text = re.sub('\s*\n\s*', ' \n ', text)
+    text = re.sub('[^\S\n]+', ' ', text)
+    text = re.sub(r"\s{2,}", " ", text)
+    return text.strip()
+
+def has_repeated_uniq_char(text):
+    pattern = r'([a-zA-Z0-9] ){5,}'
+    return bool(re.search(pattern, text))
+
+def countLongText(text):
+    nb_long = 0
+    t = text.split()
+    for w in t:
+        if len(w) > LONG_WORD_CHARS:
+            if w.count('-')!= 0:
+                nb_long += 1
+    return nb_long
+
+def remove_latex(text): 
+    sp_chars = 0
+    sp_chars += text.count('(')
+    sp_chars += text.count(')')
+    sp_chars += text.count('{')
+    sp_chars += text.count('}')
+    sp_chars += text.count('_')
+    sp_chars += text.count('/')
+    sp_chars += text.count(' ')
+    if sp_chars > (len(text)/2) and len(text) > 4:
+        text = ''
+    return text
+
+def extract_parentheses(text):
+    stack = []
+    results = []
+    for i, char in enumerate(text):
+        if char == '(':
+            stack.append(i)
+        elif char == ')' and stack:
+            start = stack.pop()
+            results.append((start, i))
+    return results
+
+def is_date_or_year_range(content):
+    return bool(re.match(r'^\d{4}(-\d{4})?$', content.strip()))
+
+def remove_language_in_parentheses(line, target_file_parentheses):
+    for start, end in reversed(extract_parentheses(line)):
+        match = line[start+1:end]
+        if is_date_or_year_range(match):
+            continue
+        lang = identifier.classify(match)
+        if lang[0] not in ALLOWED_LANGUAGE:
+            line = line[:start] + line[end+1:]
+            target_file_parentheses.write(f'({match})' + "\n")
+    return line
+
+def test_exclude(line_add, target_file_math, target_file_chars, target_file_lang, target_file_long, target_file, target_file_parentheses):
+    nb_words_line = len(line_add.split())
+    if countLongText(line_add.strip()) > MAXIMUM_LONG_WORDS \
+        or len( re.findall( r'\d+ ', line_add.strip() ) ) > MAX_NUM_COUNT \
+        or line_add.count('=') > MAX_EQUALS_SIGN_COUNT or line_add.count('+') > MAX_PLUS_SIGN_COUNT:
+        target_file_math.write(f"{line_add.strip()} \n")
+    elif line_add.count('"') > MAX_DOUBLE_QUOTE_COUNT or line_add.count('(') > MAX_PARENTHESIS_COUNT \
+        or line_add.count('[') > MAX_BRACKET_COUNT \
+        or line_add.count(',') > MAX_COMMA_COUNT \
+        or line_add.count('$') > MAX_DOLLAR_COUNT:
+        target_file_chars.write(f"{line_add.strip()} \n")
+    else:
+        lang = identifier.classify(line_add)
+        if lang[0] not in ALLOWED_LANGUAGE:
+            target_file_lang.write(f"[{lang[0]}] {line_add.strip()} \n")
+        else:
+            if len(line_add.split()) > MAX_SENTENCE_LENGTH or has_repeated_uniq_char(line_add.strip()):
+                target_file_long.write(f"[{nb_words_line}] {line_add.strip()} \n")
+            else:
+                line_add = re.sub(r"\s{2,}", " ",remove_language_in_parentheses(line_add.strip(), target_file_parentheses))
+                target_file.write(f"{line_add} \n")
+
+def test_line(full_path, full_target_path):
+    """ Step 2: Exclusion based on criteria """
+    nb_words_line = 0
+    line_add = ""
+
+    with open(full_target_path, 'w', encoding="utf8") as f:
+        f.write("")
+
+    with open(full_path, "r", encoding="utf8", errors="ignore") as source_file, \
+        open(full_target_path, "a", encoding="utf8") as target_file, \
+        open(TARGET_LONG, "a", encoding="utf8") as target_file_long, \
+        open(TARGET_LANG, "a", encoding="utf8") as target_file_lang, \
+        open(TARGET_MATH, "a", encoding="utf8") as target_file_math, \
+        open(TARGET_CHARS, "a", encoding="utf8") as target_file_chars, \
+        open(TARGET_PARENTH, "a", encoding="utf8") as target_file_parentheses, \
+        open(TARGET_LATEX, "a", encoding="utf8") as target_file_latex:
+
+        for line in source_file:
+            line = '' if line.count('Articles détaillés :') else line.strip() 
+            line = line.replace("Un article de Wikipédia, l'encyclopédie libre.", "")
+            if line.count('Ce document provient de') \
+            or line.count('https://') \
+            or line.count('wikipedia.') \
+            or line.count('index.') \
+            or line.count('php?') \
+            or line.count('title='): 
+                line=''
+         
+            line = re.sub(r',\s,', ' ', line)
+            line = re.sub(r'\.\s\.', '.', line)
+            line = re.sub(r',\s\.', '.', line)
+
+            sentences = split_into_sentences(re.sub(r"\s{2,}", " ", line))
+            for sentence in sentences:
+                if remove_latex(text_standardize(sentence)) =='':
+                    target_file_latex.write(f"{sentence.strip()} \n")
+                    sentence =''
+                words = len(sentence.split())
+                if len(line_add.split()) + words < MAX_LENGTH:
+                    nb_words_line += words
+                    line_add += f" {text_standardize(sentence)}" 
+                else:
+                    test_exclude(line_add, target_file_math, target_file_chars, target_file_lang, target_file_long, target_file, target_file_parentheses)
+                    nb_words_line = len(sentence.split())
+                    line_add = f" {text_standardize(sentence)}" 
+   
+        if nb_words_line:
+            test_exclude(line_add, target_file_math, target_file_chars, target_file_lang, target_file_long, target_file, target_file_parentheses)
+
+
+for i, file in enumerate(FILES):
+    html_path = HTML_PATH + file
+    txt_path = html_path.replace('html_wiki', 'txt_wiki')
+    txt_len = extract_wikipedia_text(html_path, txt_path)
+    txt_lines_path = html_path.replace('html_wiki', 'txt_wiki_lines')
+    test_line(txt_path, txt_lines_path)
+    print(f"({i+1}/{len(FILES)}) {file} {txt_len}")