Delete loading script

aes_enem_dataset.py

@@ -1,1234 +0,0 @@
-# Copyright 2023 Andre Barbosa, Igor Cataneo Silveira & The HuggingFace Datasets Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import csv
-import math
-import os
-import re
-from pathlib import Path
-
-import datasets
-import numpy as np
-import pandas as pd
-from multiprocessing import Pool, cpu_count
-from bs4 import BeautifulSoup
-from tqdm.auto import tqdm
-
-RANDOM_STATE = 42
-np.random.seed(RANDOM_STATE)  # Set the seed
-
-_CITATION = """
-@inproceedings{silveira-etal-2024-new,
-    title = "A New Benchmark for Automatic Essay Scoring in {P}ortuguese",
-    author = "Silveira, Igor Cataneo  and
-      Barbosa, Andr{\'e}  and
-      Mau{\'a}, Denis Deratani",
-    editor = "Gamallo, Pablo  and
-      Claro, Daniela  and
-      Teixeira, Ant{\'o}nio  and
-      Real, Livy  and
-      Garcia, Marcos  and
-      Oliveira, Hugo Goncalo  and
-      Amaro, Raquel",
-    booktitle = "Proceedings of the 16th International Conference on Computational Processing of Portuguese - Vol. 1",
-    month = mar,
-    year = "2024",
-    address = "Santiago de Compostela, Galicia/Spain",
-    publisher = "Association for Computational Lingustics",
-    url = "https://aclanthology.org/2024.propor-1.23/",
-    pages = "228--237"
-}
-"""
-
-_DESCRIPTION = """\
-This dataset was created as part of our work on advancing Automatic Essay Scoring for 
-Brazilian Portuguese. It comprises a large collection of publicly available essays 
-collected from websites simulating University Entrance Exams, with a subset expertly 
-annotated to provide reliable assessment indicators. The dataset includes both the raw 
-text and processed forms of the essays, along with supporting prompts and supplemental 
-texts.
-
-Key Features:
-    - A diverse corpus of essays with detailed annotations.
-    - A subset graded by expert annotators to evaluate essay quality and task difficulty.
-    - Comprehensive metadata providing provenance and context for each essay.
-    - An empirical analysis framework to support state-of-the-art predictive modeling.
-
-For further details, please refer to the paper “A New Benchmark for Automatic Essay 
-Scoring in Portuguese” available at https://aclanthology.org/2024.propor-1.23/.
-"""
-
-# TODO: Add a link to an official homepage for the dataset here
-_HOMEPAGE = ""
-
-# TODO: Add the licence for the dataset here if you can find it
-_LICENSE = ""
-
-
-_URLS = {
-    "sourceAOnly": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/sourceAWithGraders.tar.gz",
-    "sourceAWithGraders": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/sourceAWithGraders.tar.gz",
-    "sourceB": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/sourceB.tar.gz",
-    "PROPOR2024": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/propor2024.tar.gz",
-    "gradesThousand": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/scrapedGradesThousand.tar.gz",
-}
-
-
-PROMPTS_TO_IGNORE = [
-    "brasileiros-tem-pessima-educacao-argumentativa-segundo-cientista",
-    "carta-convite-discutir-discriminacao-na-escola",
-    "informacao-no-rotulo-de-produtos-transgenicos",
-]
-
-# Essays to Ignore
-ESSAY_TO_IGNORE = [
-    "direitos-em-conflito-liberdade-de-expressao-e-intimidade/2.html",
-    "terceirizacao-avanco-ou-retrocesso/2.html",
-    "artes-e-educacao-fisica-opcionais-ou-obrigatorias/2.html",
-    "violencia-e-drogas-o-papel-do-usuario/0.html",
-    "internacao-compulsoria-de-dependentes-de-crack/0.html",
-]
-
-CSV_HEADER = [
-    "id",
-    "id_prompt",
-    "prompt",
-    "supporting_text",
-    "title",
-    "essay",
-    "grades",
-    "general",
-    "specific",
-    "essay_year",
-    "reference",
-]
-
-CSV_HEADERPROPOR = [
-    "id",
-    "id_prompt",
-    "title",
-    "essay",
-    "grades",
-    "essay_year",
-    "reference",
-]
-
-CSV_HEADERTHOUSAND = [
-    "id",
-    "author",
-    "id_prompt",
-    "essay_year",
-    "grades",
-    "essay",
-    "source",
-    "supporting_text",
-    "prompt",
-]
-
-CSV_HEADER_JBCS25 = [
-    "id",
-    "id_prompt",
-    "essay_text",
-    "grades",
-    "essay_year",
-    "supporting_text",
-    "prompt",
-    "reference",
-]
-
-SOURCE_A_DESC = """
-SourceA have 860 essays available from August 2015 to March 2020.
-For each month of that period, a new prompt together with supporting texts were given, 
-and the graded essays from the previous month were made available.
-Of the 56 prompts, 12 had no associated essays available (at the time of download).
-Additionally, there were 3 prompts that asked for a text in the format of a letter. 
-We removed those 15 prompts and associated texts from the corpus.
-For an unknown reason, 414 of the essays were graded using a five-point scale of either 
-{0, 50, 100, 150, 200} or its scaled-down version going from 0 to 2.
-To avoid introducing bias, we also discarded such instances, resulting in a dataset of 
-386 annotated essays with prompts and supporting texts (with each component being clearly identified).
-Some of the essays used a six-point scale with 20 points instead of 40 points as the second class. 
-As we believe this introduces minimal bias, we kept such essays and relabeled class 20 as class 40.
-The original data contains comments from the annotators explaining their per-competence scores. 
-They are included in our dataset.
-"""
-
-SOURCE_A_WITH_GRADERS = """
-sourceAWithGraders includes the original dataset augmented with grades from additional reviewers.
-Each essay is replicated three times:
-1. The original essay with its grades from the website.
-2. The same essay with grades from the first human grader.
-3. The same essay with grades from the second human grader.
-"""
-
-SOURCE_B_DESC = """
-SourceB is very similar to Source A: a new prompt and supporting texts are made 
-available every month along with the graded essays submitted in the previous month.
-We downloaded HTML sources from 7,700 essays from May 2009 to May 2023. Essays released 
-prior to June 2016 were graded on a five-point scale and consequently discarded.
-This resulted in a corpus of approx. 3,200 graded essays on 83 different prompts.
-
-Although in principle, Source B also provides supporting texts for students, none were 
-available at the time the data was downloaded.
-To mitigate this, we extracted supporting texts from the Essay-Br corpus, whenever 
-possible, by manually matching prompts between the two corpora.
-We ended up with approx. 1,000 essays containing both prompt and supporting texts, and 
-approx. 2,200 essays containing only the respective prompt.
-"""
-
-PROPOR2024 = """
-This split corresponds to the results reported in the PROPOR 2024 paper. While reproducibility was 
-fixed in the sourceAWithGraders configuration, this split preserves the original 
-distribution of prompts and scores as used in the paper.
-"""
-
-GRADES_THOUSAND = """
-TODO
-"""
-
-JBCS2025 = """
-TODO
-"""
-
-
-class AesEnemDataset(datasets.GeneratorBasedBuilder):
-    """
-    AES Enem Dataset. For full explanation about generation process, please refer to: https://aclanthology.org/2024.propor-1.23/
-
-    We realized in our experiments that there was an issue in the determistic process regarding how the dataset is generated.
-    To reproduce results from PROPOR paper, please refer to "PROPOR2024" config. Other configs are reproducible now.
-    """
-
-    VERSION = datasets.Version("1.0.0")
-
-    # You will be able to load one or the other configurations in the following list with
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig(
-            name="sourceAOnly", version=VERSION, description=SOURCE_A_DESC
-        ),
-        datasets.BuilderConfig(
-            name="sourceAWithGraders",
-            version=VERSION,
-            description=SOURCE_A_WITH_GRADERS,
-        ),
-        datasets.BuilderConfig(
-            name="sourceB",
-            version=VERSION,
-            description=SOURCE_B_DESC,
-        ),
-        datasets.BuilderConfig(
-            name="PROPOR2024", version=VERSION, description=PROPOR2024
-        ),
-        datasets.BuilderConfig(
-            name="gradesThousand", version=VERSION, description=GRADES_THOUSAND
-        ),
-        datasets.BuilderConfig(name="JBCS2025", version=VERSION, description=JBCS2025),
-    ]
-
-    def _info(self):
-        if self.config.name == "PROPOR2024":
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("string"),
-                    "id_prompt": datasets.Value("string"),
-                    "essay_title": datasets.Value("string"),
-                    "essay_text": datasets.Value("string"),
-                    "grades": datasets.Sequence(datasets.Value("int16")),
-                    "essay_year": datasets.Value("int16"),
-                    "reference": datasets.Value("string"),
-                }
-            )
-        elif self.config.name == "gradesThousand":
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("string"),
-                    "id_prompt": datasets.Value("string"),
-                    "supporting_text": datasets.Value("string"),
-                    "prompt": datasets.Value("string"),
-                    "essay_text": datasets.Value("string"),
-                    "grades": datasets.Sequence(datasets.Value("int16")),
-                    "essay_year": datasets.Value("int16"),
-                    "source": datasets.Value("string"),
-                }
-            )
-        elif self.config.name == "JBCS2025":
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("string"),
-                    "id_prompt": datasets.Value("string"),
-                    "essay_text": datasets.Value("string"),
-                    "grades": datasets.Sequence(datasets.Value("int16")),
-                    "essay_year": datasets.Value("int16"),
-                    "supporting_text": datasets.Value("string"),
-                    "prompt": datasets.Value("string"),
-                    "reference": datasets.Value("string"),
-                }
-            )
-        else:
-            features = datasets.Features(
-                {
-                    "id": datasets.Value("string"),
-                    "id_prompt": datasets.Value("string"),
-                    "prompt": datasets.Value("string"),
-                    "supporting_text": datasets.Value("string"),
-                    "essay_title": datasets.Value("string"),
-                    "essay_text": datasets.Value("string"),
-                    "grades": datasets.Sequence(datasets.Value("int16")),
-                    "essay_year": datasets.Value("int16"),
-                    "general_comment": datasets.Value("string"),
-                    "specific_comment": datasets.Value("string"),
-                    "reference": datasets.Value("string"),
-                }
-            )
-
-        return datasets.DatasetInfo(
-            # This is the description that will appear on the datasets page.
-            description=_DESCRIPTION,
-            # This defines the different columns of the dataset and their types
-            features=features,  # Here we define them above because they are different between the two configurations
-            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
-            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
-            # supervised_keys=("sentence", "label"),
-            # Homepage of the dataset for documentation
-            homepage=_HOMEPAGE,
-            # License for the dataset if available
-            license=_LICENSE,
-            # Citation for the dataset
-            citation=_CITATION,
-        )
-
-    def _post_process_dataframe(self, filepath):
-        def map_year(year):
-            if year <= 2017:
-                return "<=2017"
-            return str(year)
-
-        def normalize_grades(grades):
-            grades = grades.strip("[]").split(", ")
-            grade_mapping = {"0.0": 0, "20": 40, "2.0": 2}
-
-            # We will remove the rows that match the criteria below
-            if any(
-                single_grade
-                in grades[:-1]  # we ignore the sum, and only check the concetps
-                for single_grade in ["50", "100", "150", "0.5", "1.0", "1.5"]
-            ):
-                return None
-            # Use the mapping to transform grades, ignoring the last grade
-            mapped_grades = [
-                int(grade_mapping.get(grade_concept, grade_concept))
-                for grade_concept in grades[:-1]
-            ]
-            # Calculate and append the sum of the mapped grades as the last element
-            mapped_grades.append(sum(mapped_grades))
-            return mapped_grades
-
-        df = pd.read_csv(filepath)
-        df["general"] = df["general"].fillna("")
-        df["essay_year"] = df["essay_year"].astype("int")
-        df["mapped_year"] = df["essay_year"].apply(map_year)
-        df["grades"] = df["grades"].apply(normalize_grades)
-        df = df.dropna(subset=["grades"])
-        df = df[
-            ~(df["id_prompt"] + "/" + df["id"]).isin(ESSAY_TO_IGNORE)
-        ]  # arbitrary removal of zero graded essays
-        df.to_csv(filepath, index=False)
-
-    def _preprocess_propor2024(self, base_path: str):
-        for split_case in ["train.csv", "validation.csv", "test.csv"]:
-            filepath = f"{base_path}/propor2024/{split_case}"
-            df = pd.read_csv(filepath)
-
-            # Dictionary to track how many times we've seen each (id, id_prompt) pair
-            counts = {}
-            # List to store the reference for each row
-            references = []
-
-            # Define the mapping for each occurrence
-            occurrence_to_reference = {
-                0: "crawled_from_web",
-                1: "grader_a",
-                2: "grader_b",
-            }
-
-            # Iterate through rows in the original order
-            for _, row in df.iterrows():
-                key = (row["id"], row["id_prompt"])
-                count = counts.get(key, 0)
-                # Assign the reference based on the count
-                ref = occurrence_to_reference.get(count, "unknown")
-                references.append(ref)
-                counts[key] = count + 1
-
-            # Add the reference column without changing the order of rows
-            df["reference"] = references
-            df.to_csv(filepath, index=False)
-
-    def _split_generators(self, dl_manager):
-        if self.config.name != "JBCS2025":
-            urls = _URLS[self.config.name]
-            extracted_files = dl_manager.download_and_extract({self.config.name: urls})
-        if "PROPOR2024" == self.config.name:
-            base_path = extracted_files["PROPOR2024"]
-            self._preprocess_propor2024(base_path)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": os.path.join(base_path, "propor2024/train.csv"),
-                        "split": "train",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": os.path.join(
-                            base_path, "propor2024/validation.csv"
-                        ),
-                        "split": "validation",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "filepath": os.path.join(base_path, "propor2024/test.csv"),
-                        "split": "test",
-                    },
-                ),
-            ]
-        if "gradesThousand" == self.config.name:
-            urls = _URLS[self.config.name]
-            extracted_files = dl_manager.download_and_extract({self.config.name: urls})
-            base_path = f"{extracted_files['gradesThousand']}/scrapedGradesThousand"
-            for split in ["train", "validation", "test"]:
-                split_filepath = os.path.join(base_path, f"{split}.csv")
-                grades_thousand = pd.read_csv(split_filepath)
-                grades_thousand[["supporting_text", "prompt"]] = grades_thousand[
-                    "supporting_text"
-                ].apply(
-                    lambda original_text: pd.Series(
-                        self._extract_prompt_and_clean(original_text)
-                    )
-                )
-                grades_thousand.to_csv(split_filepath, index=False)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": os.path.join(base_path, "train.csv"),
-                        "split": "train",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": os.path.join(base_path, "validation.csv"),
-                        "split": "validation",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "filepath": os.path.join(base_path, "test.csv"),
-                        "split": "test",
-                    },
-                ),
-            ]
-        if "sourceA" in self.config.name:
-            html_parser = self._process_html_files(extracted_files)
-            self._post_process_dataframe(html_parser.sourceA)
-            self._generate_splits(html_parser.sourceA)
-            folder_sourceA = Path(html_parser.sourceA).parent
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": folder_sourceA / "train.csv",
-                        "split": "train",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": folder_sourceA / "validation.csv",
-                        "split": "validation",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "filepath": folder_sourceA / "test.csv",
-                        "split": "test",
-                    },
-                ),
-            ]
-        elif self.config.name == "sourceB":
-            html_parser = self._process_html_files(extracted_files)
-            self._post_process_dataframe(html_parser.sourceB)
-            return [
-                datasets.SplitGenerator(
-                    name="full",
-                    gen_kwargs={
-                        "filepath": html_parser.sourceB,
-                        "split": "full",
-                    },
-                ),
-            ]
-        elif "JBCS2025" == self.config.name:
-            extracted_files = dl_manager.download_and_extract(
-                {
-                    "sourceA": _URLS["sourceAWithGraders"],
-                    "grades_thousand": _URLS["gradesThousand"],
-                }
-            )
-            config_name_source_a = "sourceAWithGraders"
-
-            html_parser = self._process_html_files(
-                paths_dict={config_name_source_a: extracted_files["sourceA"]},
-                config_name=config_name_source_a,
-            )
-            self._post_process_dataframe(html_parser.sourceA)
-            self._generate_splits(html_parser.sourceA, config_name=config_name_source_a)
-            folder_sourceA = Path(html_parser.sourceA).parent
-            for split in ["train", "validation", "test"]:
-                sourceA = pd.read_csv(folder_sourceA / f"{split}.csv")
-                common_columns = [
-                    "id",
-                    "id_prompt",
-                    "essay_text",
-                    "grades",
-                    "essay_year",
-                    "supporting_text",
-                    "prompt",
-                    "reference",
-                ]
-                combined_split = sourceA[
-                    sourceA.reference.isin(["grader_a", "grader_b"])
-                ]
-                combined_split = combined_split.rename(columns={"essay": "essay_text"})
-                combined_split["grades"] = combined_split["grades"].str.replace(",", "")
-                final_split = combined_split[common_columns].sample(
-                    frac=1, random_state=RANDOM_STATE
-                ).reset_index(drop=True)
-                # overwrites the sourceA data
-                final_split.to_csv(folder_sourceA / f"{split}.csv", index=False)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": folder_sourceA / "train.csv",
-                        "split": "train",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": folder_sourceA / "validation.csv",
-                        "split": "validation",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "filepath": folder_sourceA / "test.csv",
-                        "split": "test",
-                    },
-                ),
-            ]
-
-    def _extract_prompt_and_clean(self, text: str):
-        """
-        1) Find an uppercase block matching "PROPOSTA DE REDACAO/REDAÇÃO"
-        (with flexible spacing and accents) anywhere in 'text'.
-        2) Capture everything from there until the next heading that
-        starts a line (TEXTO..., TEXTOS..., INSTRUÇÕES...) or end-of-text.
-        3) Remove that captured block from the original, returning:
-            (supporting_text, prompt)
-        """
-
-        # Regex explanation:
-        # (?m)  => MULTILINE, so ^ can match start of lines
-        #  1) PROPOSTA\s+DE\s+REDA(?:C|Ç)(?:AO|ÃO)
-        #     - "PROPOSTA", then one-or-more spaces/newlines,
-        #       then "DE", then spaces, then "REDA(C|Ç)",
-        #       and either "AO" or "ÃO" (uppercase).
-        #     - This part may skip diacritic or accent variations in "REDAÇÃO" vs. "REDACAO".
-        #
-        #  2) (?:.*?\n?)*? => a non-greedy capture of subsequent lines
-        #       (including possible newlines). We use [\s\S]*? as an alternative.
-        #
-        #  3) Lookahead (?=^(?:TEXTO|TEXTOS|INSTRUÇÕES|\Z))
-        #       means: stop right before a line that starts with "TEXTO", "TEXTOS",
-        #       or "INSTRUÇÕES", OR the very end of the text (\Z).
-        #
-        # If found, that entire portion is group(1).
-        def force_newline_after_proposta(text: str) -> str:
-            """
-            If we see "PROPOSTA DE REDAÇÃO" immediately followed by some
-            non-whitespace character (like "A"), insert two newlines.
-            E.g., "PROPOSTA DE REDAÇÃOA partir..." becomes
-                "PROPOSTA DE REDAÇÃO\n\nA partir..."
-            """
-            # This pattern looks for:
-            #   (PROPOSTA DE REDAÇÃO)
-            #   (?=\S) meaning "immediately followed by a NON-whitespace character"
-            # then we replace that with "PROPOSTA DE REDAÇÃO\n\n"
-            pattern = re.compile(r"(?=\S)(PROPOSTA DE REDAÇÃO)(?=\S)")
-            return pattern.sub(r"\n\1\n\n", text)
-
-        text = force_newline_after_proposta(text)
-        pattern = re.compile(
-            r"(?m)"  # MULTILINE
-            r"("
-            r"PROPOSTA\s+DE\s+REDA(?:C|Ç)(?:AO|ÃO)"  # e.g. PROPOSTA DE REDACAO / REDAÇÃO
-            r"(?:[\s\S]*?)"  # lazily grab the subsequent text
-            r")"
-            r"(?=(?:TEXTO|TEXTOS|INSTRUÇÕES|TExTO|\Z))"
-        )
-
-        match = pattern.search(text)
-        if match:
-            prompt = match.group(1).strip()
-            # Remove that block from the original:
-            start, end = match.span(1)
-            main_text = text[:start] + text[end:]
-        else:
-            # No match => keep entire text in supporting_text, prompt empty
-            prompt = ""
-            main_text = text
-
-        return main_text.strip(), prompt.strip()
-
-    def _process_html_files(self, paths_dict, config_name=None):
-        html_parser = HTMLParser(paths_dict)
-        if config_name is None:
-            config_name = self.config.name
-        html_parser.parse(config_name)
-        return html_parser
-
-    def _parse_graders_data(self, dirname):
-        map_grades = {"0": 0, "1": 40, "2": 80, "3": 120, "4": 160, "5": 200}
-
-        def map_list(grades_list):
-            result = [map_grades.get(item, None) for item in grades_list]
-            sum_grades = sum(result)
-            result.append(sum_grades)
-            return result
-
-        grader_a = pd.read_csv(f"{dirname}/GraderA.csv")
-        grader_b = pd.read_csv(f"{dirname}/GraderB.csv")
-        for grader in [grader_a, grader_b]:
-            grader.grades = grader.grades.apply(lambda x: x.strip("[]").split(", "))
-            grader.grades = grader.grades.apply(map_list)
-        grader_a["reference"] = "grader_a"
-        grader_b["reference"] = "grader_b"
-        return grader_a, grader_b
-
-    def _generate_splits(self, filepath: str, train_size=0.7, config_name=None):
-        np.random.seed(RANDOM_STATE)
-        df = pd.read_csv(filepath)
-        train_set = []
-        val_set = []
-        test_set = []
-        df = df.sort_values(by=["essay_year", "id_prompt"]).reset_index(drop=True)
-        buckets = {}
-        for key, group in df.groupby("mapped_year"):
-            buckets[key] = sorted(group["id_prompt"].unique())
-        df.drop("mapped_year", axis=1, inplace=True)
-        for year in sorted(buckets.keys()):
-            prompts = buckets[year]
-            np.random.shuffle(prompts)
-            num_prompts = len(prompts)
-
-            # All prompts go to the test if less than 3
-            if num_prompts <= 3:
-                train_set.append(df[df["id_prompt"].isin([prompts[0]])])
-                val_set.append(df[df["id_prompt"].isin([prompts[1]])])
-                test_set.append(df[df["id_prompt"].isin([prompts[2]])])
-                continue
-
-            # Determine the number of prompts for each set based on train_size and remaining prompts
-            num_train = math.floor(num_prompts * train_size)
-            num_val_test = num_prompts - num_train
-            num_val = num_val_test // 2
-            num_test = num_val_test - num_val
-
-            # Assign prompts to each set
-            train_set.append(df[df["id_prompt"].isin(prompts[:num_train])])
-            val_set.append(
-                df[df["id_prompt"].isin(prompts[num_train : (num_train + num_val)])]
-            )
-            test_set.append(
-                df[
-                    df["id_prompt"].isin(
-                        prompts[
-                            (num_train + num_val) : (num_train + num_val + num_test)
-                        ]
-                    )
-                ]
-            )
-
-        # Convert lists of groups to DataFrames
-        train_df = pd.concat(train_set)
-        val_df = pd.concat(val_set)
-        test_df = pd.concat(test_set)
-        dirname = os.path.dirname(filepath)
-        if config_name is None:
-            config_name = self.config.name
-        if config_name == "sourceAWithGraders":
-            grader_a, grader_b = self._parse_graders_data(dirname)
-            grader_a_data = pd.merge(
-                train_df[["id", "id_prompt", "essay", "prompt", "supporting_text"]],
-                grader_a.drop(columns=["essay"]),
-                on=["id", "id_prompt"],
-                how="inner",
-            )
-            grader_b_data = pd.merge(
-                train_df[["id", "id_prompt", "essay", "prompt", "supporting_text"]],
-                grader_b.drop(columns=["essay"]),
-                on=["id", "id_prompt"],
-                how="inner",
-            )
-            train_df = pd.concat([train_df, grader_a_data, grader_b_data])
-            train_df = train_df.sort_values(by=["id", "id_prompt"]).reset_index(
-                drop=True
-            )
-
-            grader_a_data = pd.merge(
-                val_df[["id", "id_prompt", "essay", "prompt", "supporting_text"]],
-                grader_a.drop(columns=["essay"]),
-                on=["id", "id_prompt"],
-                how="inner",
-            )
-            grader_b_data = pd.merge(
-                val_df[["id", "id_prompt", "essay", "prompt", "supporting_text"]],
-                grader_b.drop(columns=["essay"]),
-                on=["id", "id_prompt"],
-                how="inner",
-            )
-            val_df = pd.concat([val_df, grader_a_data, grader_b_data])
-            val_df = val_df.sort_values(by=["id", "id_prompt"]).reset_index(drop=True)
-
-            grader_a_data = pd.merge(
-                test_df[["id", "id_prompt", "essay", "prompt", "supporting_text"]],
-                grader_a.drop(columns=["essay"]),
-                on=["id", "id_prompt"],
-                how="inner",
-            )
-            grader_b_data = pd.merge(
-                test_df[["id", "id_prompt", "essay", "prompt", "supporting_text"]],
-                grader_b.drop(columns=["essay"]),
-                on=["id", "id_prompt"],
-                how="inner",
-            )
-            test_df = pd.concat([test_df, grader_a_data, grader_b_data])
-            test_df = test_df.sort_values(by=["id", "id_prompt"]).reset_index(drop=True)
-
-            train_df = train_df.sample(frac=1, random_state=RANDOM_STATE).reset_index(
-                drop=True
-            )
-            val_df = val_df.sample(frac=1, random_state=RANDOM_STATE).reset_index(
-                drop=True
-            )
-            test_df = test_df.sample(frac=1, random_state=RANDOM_STATE).reset_index(
-                drop=True
-            )
-
-        # Data Validation Assertions
-        assert (
-            len(set(train_df["id_prompt"]).intersection(set(val_df["id_prompt"]))) == 0
-        ), "Overlap between train and val id_prompt"
-        assert (
-            len(set(train_df["id_prompt"]).intersection(set(test_df["id_prompt"]))) == 0
-        ), "Overlap between train and test id_prompt"
-        assert (
-            len(set(val_df["id_prompt"]).intersection(set(test_df["id_prompt"]))) == 0
-        ), "Overlap between val and test id_prompt"
-        train_df.to_csv(f"{dirname}/train.csv", index=False)
-        val_df.to_csv(f"{dirname}/validation.csv", index=False)
-        test_df.to_csv(f"{dirname}/test.csv", index=False)
-
-    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
-    def _generate_examples(self, filepath, split):
-        if self.config.name == "PROPOR2024":
-            with open(filepath, encoding="utf-8") as csvfile:
-                next(csvfile)
-                csv_reader = csv.DictReader(csvfile, fieldnames=CSV_HEADERPROPOR)
-                for i, row in enumerate(csv_reader):
-                    grades = row["grades"].strip("[]")
-                    grades = grades.split()
-                    yield (
-                        i,
-                        {
-                            "id": row["id"],
-                            "id_prompt": row["id_prompt"],
-                            "essay_title": row["title"],
-                            "essay_text": row["essay"],
-                            "grades": grades,
-                            "essay_year": row["essay_year"],
-                            "reference": row["reference"],
-                        },
-                    )
-        elif self.config.name == "gradesThousand":
-            with open(filepath, encoding="utf-8") as csvfile:
-                next(csvfile)
-                csv_reader = csv.DictReader(csvfile, fieldnames=CSV_HEADERTHOUSAND)
-                for i, row in enumerate(csv_reader):
-                    grades = row["grades"].strip("[]")
-                    grades = grades.split(", ")
-                    yield (
-                        i,
-                        {
-                            "id": row["id"],
-                            "id_prompt": row["id_prompt"],
-                            "supporting_text": row["supporting_text"],
-                            "prompt": row["prompt"],
-                            "essay_text": row["essay"],
-                            "grades": grades,
-                            "essay_year": row["essay_year"],
-                            "author": row["author"],
-                            "source": row["source"],
-                        },
-                    )
-        elif self.config.name == "JBCS2025":
-            with open(filepath, encoding="utf-8") as csvfile:
-                next(csvfile)
-                csv_reader = csv.DictReader(csvfile, fieldnames=CSV_HEADER_JBCS25)
-                for i, row in enumerate(csv_reader):
-                    grades = row["grades"].strip("[]")
-                    grades = grades.split()
-                    yield (
-                        i,
-                        {
-                            "id": row["id"],
-                            "id_prompt": row["id_prompt"],
-                            "essay_text": row["essay_text"],
-                            "grades": grades,
-                            "essay_year": row["essay_year"],
-                            "supporting_text": row["supporting_text"],
-                            "prompt": row["prompt"],
-                            "reference": row["reference"],
-                        },
-                    )
-        else:
-            with open(filepath, encoding="utf-8") as csvfile:
-                next(csvfile)
-                csv_reader = csv.DictReader(csvfile, fieldnames=CSV_HEADER)
-                for i, row in enumerate(csv_reader):
-                    grades = row["grades"].strip("[]")
-                    grades = grades.split(", ")
-                    yield (
-                        i,
-                        {
-                            "id": row["id"],
-                            "id_prompt": row["id_prompt"],
-                            "prompt": row["prompt"],
-                            "supporting_text": row["supporting_text"],
-                            "essay_title": row["title"],
-                            "essay_text": row["essay"],
-                            "grades": grades,
-                            "essay_year": row["essay_year"],
-                            "general_comment": row["general"],
-                            "specific_comment": row["specific"],
-                            "reference": row["reference"],
-                        },
-                    )
-
-
-class HTMLParser:
-    def __init__(self, paths_dict):
-        self.paths_dict = paths_dict
-        self.sourceA = None
-        self.sourceB = None
-
-    def apply_soup(self, filepath, num):
-        # recebe uma URL, salva o HTML dessa página e retorna o soup dela
-        file = open(os.path.join(filepath, num), "r", encoding="utf8")
-        conteudo = file.read()
-        soup = BeautifulSoup(conteudo, "html.parser")
-        return soup
-
-    def _get_title(self, soup):
-        if self.sourceA:
-            title = soup.find("div", class_="container-composition")
-            if title is None:
-                title = soup.find("h1", class_="pg-color10").get_text()
-            else:
-                title = title.h2.get_text()
-            title = title.replace("\xa0", "")
-            return title.replace(";", ",")
-        elif self.sourceB:
-            title = soup.find("h1", class_="titulo-conteudo").get_text()
-            return title.strip("- Banco de redações").strip()
-
-    def _get_grades(self, soup):
-        if self.sourceA:
-            grades = soup.find("section", class_="results-table")
-            final_grades = []
-            if grades is not None:
-                grades = grades.find_all("span", class_="points")
-                assert len(grades) == 6, f"Missing grades: {len(grades)}"
-                for single_grade in grades:
-                    grade = int(single_grade.get_text())
-                    final_grades.append(grade)
-                assert final_grades[-1] == sum(final_grades[:-1]), (
-                    "Grading sum is not making sense"
-                )
-            else:
-                grades = soup.find("div", class_="redacoes-corrigidas pg-bordercolor7")
-                grades_sum = float(
-                    soup.find("th", class_="noBorder-left").get_text().replace(",", ".")
-                )
-                grades = grades.find_all("td")[:10]
-                for idx in range(1, 10, 2):
-                    grade = float(grades[idx].get_text().replace(",", "."))
-                    final_grades.append(grade)
-                assert grades_sum == sum(final_grades), (
-                    "Grading sum is not making sense"
-                )
-                final_grades.append(grades_sum)
-            return final_grades
-        elif self.sourceB:
-            table = soup.find("table", {"id": "redacoes_corrigidas"})
-            grades = table.find_all("td", class_="simple-td")
-            grades = grades[3:]
-            result = []
-            for single_grade in grades:
-                result.append(int(single_grade.get_text()))
-            assert len(result) == 5, "We should have 5 Grades (one per concept) only"
-            result.append(
-                sum(result)
-            )  # Add sum as a sixt element to keep the same pattern
-            return result
-
-    def _get_general_comment(self, soup):
-        if self.sourceA:
-
-            def get_general_comment_aux(soup):
-                result = soup.find("article", class_="list-item c")
-                if result is not None:
-                    result = result.find("div", class_="description")
-                    return result.get_text()
-                else:
-                    result = soup.find("p", style="margin: 0px 0px 11px;")
-                    if result is not None:
-                        return result.get_text()
-                    else:
-                        result = soup.find("p", style="margin: 0px;")
-                        if result is not None:
-                            return result.get_text()
-                        else:
-                            result = soup.find(
-                                "p", style="margin: 0px; text-align: justify;"
-                            )
-                            if result is not None:
-                                return result.get_text()
-                            else:
-                                return ""
-
-            text = soup.find("div", class_="text")
-            if text is not None:
-                text = text.find("p")
-                if (text is None) or (len(text.get_text()) < 2):
-                    return get_general_comment_aux(soup)
-                return text.get_text()
-            else:
-                return get_general_comment_aux(soup)
-        elif self.sourceB:
-            return ""
-
-    def _get_specific_comment(self, soup, general_comment):
-        if self.sourceA:
-            result = soup.find("div", class_="text")
-            cms = []
-            if result is not None:
-                result = result.find_all("li")
-                if result != []:
-                    for item in result:
-                        text = item.get_text()
-                        if text != "\xa0":
-                            cms.append(text)
-                else:
-                    result = soup.find("div", class_="text").find_all("p")
-                    for item in result:
-                        text = item.get_text()
-                        if text != "\xa0":
-                            cms.append(text)
-            else:
-                result = soup.find_all("article", class_="list-item c")
-                if len(result) < 2:
-                    return ["First if"]
-                result = result[1].find_all("p")
-                for item in result:
-                    text = item.get_text()
-                    if text != "\xa0":
-                        cms.append(text)
-            specific_comment = cms.copy()
-            if general_comment in specific_comment:
-                specific_comment.remove(general_comment)
-                if (len(specific_comment) > 1) and (len(specific_comment[0]) < 2):
-                    specific_comment = specific_comment[1:]
-            return self._clean_list(specific_comment)
-        elif self.sourceB:
-            return ""
-
-    def _get_essay(self, soup):
-        if self.sourceA:
-            essay = soup.find("div", class_="text-composition")
-            result = []
-            if essay is not None:
-                essay = essay.find_all("p")
-                for f in essay:
-                    while f.find("span", style="color:#00b050") is not None:
-                        f.find("span", style="color:#00b050").decompose()
-                    while f.find("span", class_="certo") is not None:
-                        f.find("span", class_="certo").decompose()
-                for paragraph in essay:
-                    result.append(paragraph.get_text())
-            else:
-                essay = soup.find("div", {"id": "texto"})
-                essay.find("section", class_="list-items").decompose()
-                essay = essay.find_all("p")
-                for f in essay:
-                    while f.find("span", class_="certo") is not None:
-                        f.find("span", class_="certo").decompose()
-                for paragraph in essay:
-                    result.append(paragraph.get_text())
-            return "\n".join(self._clean_list(result))
-        elif self.sourceB:
-            table = soup.find("article", class_="texto-conteudo entire")
-            table = soup.find("div", class_="area-redacao-corrigida")
-            if table is None:
-                result = None
-            else:
-                for span in soup.find_all("span"):
-                    span.decompose()
-                result = table.find_all("p")
-                result = " ".join(
-                    [
-                        paragraph.get_text().replace("\xa0", "").strip()
-                        for paragraph in result
-                    ]
-                )
-            return result
-
-    def _get_essay_year(self, soup):
-        if self.sourceA:
-            pattern = r"redações corrigidas - \w+/\d+"
-            first_occurrence = re.search(pattern, soup.get_text().lower())
-            matched_url = first_occurrence.group(0) if first_occurrence else None
-            year_pattern = r"\d{4}"
-            return re.search(year_pattern, matched_url).group(0)
-        elif self.sourceB:
-            pattern = r"Enviou seu texto em.*?(\d{4})"
-            match = re.search(pattern, soup.get_text())
-            return match.group(1) if match else -1
-
-    def _clean_title(self, title):
-        if self.sourceA:
-            smaller_index = title.find("[")
-            if smaller_index == -1:
-                return title
-            else:
-                bigger_index = title.find("]")
-                new_title = title[:smaller_index] + title[bigger_index + 1 :]
-                return self._clean_title(new_title.replace("  ", " "))
-        elif self.sourceB:
-            return title
-
-    def _clean_list(self, list):
-        if list == []:
-            return []
-        else:
-            new_list = []
-            for phrase in list:
-                phrase = (
-                    phrase.replace("\xa0", "").replace(" ,", ",").replace(" .", ".")
-                )
-                while phrase.find("  ") != -1:
-                    phrase = phrase.replace("  ", " ")
-                if len(phrase) > 1:
-                    new_list.append(phrase)
-            return new_list
-
-    def _clean_string(self, sentence):
-        sentence = sentence.replace("\xa0", "").replace("\u200b", "")
-        sentence = (
-            sentence.replace(".", ". ")
-            .replace("?", "? ")
-            .replace("!", "! ")
-            .replace(")", ") ")
-            .replace(":", ": ")
-            .replace("”", "” ")
-        )
-        sentence = sentence.replace("  ", " ").replace(". . . ", "...")
-        sentence = sentence.replace("(editado)", "").replace("(Editado)", "")
-        sentence = sentence.replace("(editado e adaptado)", "").replace(
-            "(Editado e adaptado)", ""
-        )
-        sentence = sentence.replace(". com. br", ".com.br")
-        sentence = sentence.replace("[Veja o texto completo aqui]", "")
-        return sentence
-
-    def _get_supporting_text(self, soup):
-        if self.sourceA:
-            textos = soup.find_all("ul", class_="article-wording-item")
-            resposta = []
-            for t in textos[:-1]:
-                resposta.append(
-                    t.find("h3", class_="item-titulo").get_text().replace("\xa0", "")
-                )
-                resposta.append(
-                    self._clean_string(
-                        t.find("div", class_="item-descricao").get_text()
-                    )
-                )
-            return resposta
-        else:
-            return ""
-
-    def _get_prompt(self, soup):
-        if self.sourceA:
-            prompt = soup.find("div", class_="text").find_all("p")
-            if len(prompt[0].get_text()) < 2:
-                return [prompt[1].get_text().replace("\xa0", "")]
-            else:
-                return [prompt[0].get_text().replace("\xa0", "")]
-        else:
-            return ""
-
-    def _process_all_prompts(self, sub_folders, file_dir, reference, prompts_to_ignore):
-        """
-        Process all prompt folders in parallel and return all rows to write.
-
-        Args:
-            sub_folders (list): List of prompt folder names (or Paths).
-            file_dir (str): Base directory where prompts are located.
-            reference: Reference info to include in each row.
-            prompts_to_ignore (collection): Prompts to be ignored.
-
-        Returns:
-            list: A list of all rows to write to the CSV.
-        """
-
-        args_list = [
-            (prompt_folder, file_dir, reference, prompts_to_ignore, self)
-            for prompt_folder in sub_folders
-        ]
-
-        all_rows = []
-        # Use a Pool to parallelize processing.
-        with Pool(processes=cpu_count()) as pool:
-            # Using imap allows us to update the progress bar.
-            for rows in tqdm(
-                pool.imap(HTMLParser._process_prompt_folder, args_list),
-                total=len(args_list),
-                desc="Processing prompts",
-            ):
-                all_rows.extend(rows)
-        return all_rows
-
-    def parse(self, config_name: str):
-        for key, filepath in self.paths_dict.items():
-            if key != config_name:
-                continue  # TODO improve later, we will only support a single config at a time
-            if "sourceA" in config_name:
-                self.sourceA = f"{filepath}/sourceA/sourceA.csv"
-            elif config_name == "sourceB":
-                self.sourceB = f"{filepath}/sourceB/sourceB.csv"
-            file = self.sourceA if self.sourceA else self.sourceB
-            file_path = Path(file)
-            file_dir = file_path.parent
-            sorted_files = sorted(file_dir.iterdir(), key=lambda p: p.name)
-            sub_folders = [name for name in sorted_files if name.suffix != ".csv"]
-            reference = "crawled_from_web"
-            all_rows = self._process_all_prompts(
-                sub_folders, file_dir, reference, PROMPTS_TO_IGNORE
-            )
-            with open(file_path, "w", newline="", encoding="utf8") as final_file:
-                writer = csv.writer(final_file)
-                writer.writerow(CSV_HEADER)
-                for row in all_rows:
-                    writer.writerow(row)
-
-    @staticmethod
-    def _process_prompt_folder(args):
-        """
-        Process one prompt folder and return a list of rows to write to CSV.
-        Args:
-            args (tuple): Contains:
-                - prompt_folder: The folder name (or Path object) for the prompt.
-                - file_dir: The base directory.
-                - reference: Reference info to include in each row.
-                - prompts_to_ignore: A collection of prompts to skip.
-                - instance: An instance of the class that contains the parsing methods.
-        Returns:
-            list: A list of rows (each row is a list) to write to CSV.
-        """
-        prompt_folder, file_dir, reference, prompts_to_ignore, instance = args
-        rows = []
-        # Skip folders that should be ignored.
-        if prompt_folder in prompts_to_ignore:
-            return rows
-        # Build the full path for the prompt folder.
-        prompt = os.path.join(file_dir, prompt_folder)
-        # List and sort the HTML files.
-        try:
-            sorted_prompts = sorted(os.listdir(prompt))
-        except Exception as e:
-            print(f"Error listing directory {prompt}: {e}")
-            return rows
-        # Process the common "Prompt.html" once.
-        soup_prompt = instance.apply_soup(prompt, "Prompt.html")
-        essay_year = instance._get_essay_year(soup_prompt)
-        essay_supporting_text = "\n".join(instance._get_supporting_text(soup_prompt))
-        essay_prompt = "\n".join(instance._get_prompt(soup_prompt))
-        # Process each essay file except the prompt itself.
-        for essay_filename in sorted_prompts:
-            if essay_filename == "Prompt.html":
-                continue
-            soup_text = instance.apply_soup(prompt, essay_filename)
-            essay_title = instance._clean_title(instance._get_title(soup_text))
-            essay_grades = instance._get_grades(soup_text)
-            essay_text = instance._get_essay(soup_text)
-            general_comment = instance._get_general_comment(soup_text).strip()
-            specific_comment = instance._get_specific_comment(
-                soup_text, general_comment
-            )
-            # Create a row with all the information.
-            row = [
-                essay_filename,
-                prompt_folder
-                if not hasattr(prompt_folder, "name")
-                else prompt_folder.name,
-                essay_prompt,
-                essay_supporting_text,
-                essay_title,
-                essay_text,
-                essay_grades,
-                general_comment,
-                specific_comment,
-                essay_year,
-                reference,
-            ]
-            rows.append(row)
-        return rows