Introduce JBCS split

aes_enem_dataset.py

@@ -15,16 +15,18 @@
 import csv
 import math
 import os
-from pathlib import Path
 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
 
-np.random.seed(42)  # Set the seed
+RANDOM_STATE = 42
+np.random.seed(RANDOM_STATE)  # Set the seed
 
 _CITATION = """
 @inproceedings{silveira-etal-2024-new,
@@ -79,7 +81,7 @@ _URLS = {
     "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"
+    "gradesThousand": "https://huggingface.co/datasets/kamel-usp/aes_enem_dataset/resolve/main/scrapedGradesThousand.tar.gz",
 }
 
 
@@ -109,7 +111,7 @@ CSV_HEADER = [
     "general",
     "specific",
     "essay_year",
-    "reference"
+    "reference",
 ]
 
 CSV_HEADERPROPOR = [
@@ -119,7 +121,7 @@ CSV_HEADERPROPOR = [
     "essay",
     "grades",
     "essay_year",
-    "reference"
+    "reference",
 ]
 
 CSV_HEADERTHOUSAND = [
@@ -131,6 +133,18 @@ CSV_HEADERTHOUSAND = [
     "essay",
     "source",
     "supporting_text",
+    "prompt",
+]
+
+CSV_HEADER_JBCS25 = [
+    "id",
+    "id_prompt",
+    "essay_text",
+    "grades",
+    "essay_year",
+    "supporting_text",
+    "prompt",
+    "reference",
 ]
 
 SOURCE_A_DESC = """
@@ -183,6 +197,10 @@ GRADES_THOUSAND = """
 TODO
 """
 
+JBCS2025 = """
+TODO
+"""
+
 
 class AesEnemDataset(datasets.GeneratorBasedBuilder):
     """
@@ -192,25 +210,34 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
     To reproduce results from PROPOR paper, please refer to "PROPOR2024" config. Other configs are reproducible now.
     """
 
-    VERSION = datasets.Version("0.2.0")
+    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
+            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="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":
+        if self.config.name == "PROPOR2024":
             features = datasets.Features(
                 {
                     "id": datasets.Value("string"),
@@ -222,18 +249,32 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                     "reference": datasets.Value("string"),
                 }
             )
-        elif self.config.name=="gradesThousand":
+        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(
                 {
@@ -275,7 +316,7 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
 
         def normalize_grades(grades):
             grades = grades.strip("[]").split(", ")
-            grade_mapping = {"0.0": 0, "20": 40}
+            grade_mapping = {"0.0": 0, "20": 40, "2.0": 2}
 
             # We will remove the rows that match the criteria below
             if any(
@@ -308,19 +349,19 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
         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"
+                2: "grader_b",
             }
-    
+
             # Iterate through rows in the original order
             for _, row in df.iterrows():
                 key = (row["id"], row["id_prompt"])
@@ -329,14 +370,15 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                 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):
-        urls = _URLS[self.config.name]
-        extracted_files = dl_manager.download_and_extract({self.config.name: urls})
+        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)
@@ -353,7 +395,9 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                     name=datasets.Split.VALIDATION,
                     # These kwargs will be passed to _generate_examples
                     gen_kwargs={
-                        "filepath": os.path.join(base_path, "propor2024/validation.csv"),
+                        "filepath": os.path.join(
+                            base_path, "propor2024/validation.csv"
+                        ),
                         "split": "validation",
                     },
                 ),
@@ -366,7 +410,20 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                 ),
             ]
         if "gradesThousand" == self.config.name:
-            base_path = f"{extracted_files["gradesThousand"]}/scrapedGradesThousand"
+            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,
@@ -392,17 +449,17 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                     },
                 ),
             ]
-        html_parser = self._process_html_files(extracted_files)
         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 = "/".join((html_parser.sourceA).split("/")[:-1])
+            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": os.path.join(folder_sourceA, "train.csv"),
+                        "filepath": folder_sourceA / "train.csv",
                         "split": "train",
                     },
                 ),
@@ -410,19 +467,20 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                     name=datasets.Split.VALIDATION,
                     # These kwargs will be passed to _generate_examples
                     gen_kwargs={
-                        "filepath": os.path.join(folder_sourceA, "validation.csv"),
+                        "filepath": folder_sourceA / "validation.csv",
                         "split": "validation",
                     },
                 ),
                 datasets.SplitGenerator(
                     name=datasets.Split.TEST,
                     gen_kwargs={
-                        "filepath": os.path.join(folder_sourceA, "test.csv"),
+                        "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(
@@ -433,10 +491,155 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                     },
                 ),
             ]
+        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,
+            )
+            grades_thousand_filedir = (
+                Path(extracted_files["grades_thousand"]) / "scrapedGradesThousand"
+            )
+            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"]:
+                grades_thousand_df = pd.read_csv(
+                    grades_thousand_filedir / f"{split}.csv"
+                )
+                grades_thousand_df["reference"] = "grade_thousand_website"
+                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"})
+                grades_thousand_df[["supporting_text", "prompt"]] = grades_thousand_df[
+                    "supporting_text"
+                ].apply(
+                    lambda original_text: pd.Series(
+                        self._extract_prompt_and_clean(original_text)
+                    )
+                )
+                final_split = pd.concat(
+                    [combined_split[common_columns], grades_thousand_df[common_columns]]
+                )
+                final_split["grades"] = final_split["grades"].str.replace(",", "")
+                final_split = final_split.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):
+    def _process_html_files(self, paths_dict, config_name=None):
         html_parser = HTMLParser(paths_dict)
-        html_parser.parse(self.config.name)
+        if config_name is None:
+            config_name = self.config.name
+        html_parser.parse(config_name)
         return html_parser
 
     def _parse_graders_data(self, dirname):
@@ -457,14 +660,19 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
         grader_b["reference"] = "grader_b"
         return grader_a, grader_b
 
-    def _generate_splits(self, filepath: str, train_size=0.7):
+    def _generate_splits(self, filepath: str, train_size=0.7, config_name=None):
+        np.random.seed(RANDOM_STATE)
         df = pd.read_csv(filepath)
-        buckets = df.groupby("mapped_year")["id_prompt"].unique().to_dict()
-        df.drop("mapped_year", axis=1, inplace=True)
         train_set = []
         val_set = []
         test_set = []
-        for year, prompts in buckets.items():
+        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)
 
@@ -501,52 +709,67 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
         val_df = pd.concat(val_set)
         test_df = pd.concat(test_set)
         dirname = os.path.dirname(filepath)
-        if self.config.name == "sourceAWithGraders":
+        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']),
+                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']),
+                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])
-            train_df = pd.concat([train_df, grader_b_data])
+            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']),
+                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']),
+                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])
-            val_df = pd.concat([val_df, grader_b_data])
+            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']),
+                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']),
+                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])
-            test_df = pd.concat([test_df, grader_b_data])
+            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
@@ -570,15 +793,18 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                 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"]
-                    }
+                    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)
@@ -586,16 +812,40 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                 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"],
-                        "essay_text": row["essay"],
-                        "grades": grades,
-                        "essay_year": row["essay_year"],
-                        "author": row["author"],
-                        "source": row["source"]
-                    }
+                    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)
@@ -603,20 +853,22 @@ class AesEnemDataset(datasets.GeneratorBasedBuilder):
                 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"]
-                    }
-            
+                    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:
@@ -655,9 +907,9 @@ class HTMLParser:
                 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"
+                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(
@@ -667,9 +919,9 @@ class HTMLParser:
                 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"
+                assert grades_sum == sum(final_grades), (
+                    "Grading sum is not making sense"
+                )
                 final_grades.append(grades_sum)
             return final_grades
         elif self.sourceB:
@@ -680,7 +932,9 @@ class HTMLParser:
             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
+            result.append(
+                sum(result)
+            )  # Add sum as a sixt element to keep the same pattern
             return result
 
     def _get_general_comment(self, soup):
@@ -787,7 +1041,10 @@ class HTMLParser:
                     span.decompose()
                 result = table.find_all("p")
                 result = " ".join(
-                    [paragraph.get_text().replace("\xa0","").strip() for paragraph in result]
+                    [
+                        paragraph.get_text().replace("\xa0", "").strip()
+                        for paragraph in result
+                    ]
                 )
             return result
 
@@ -831,37 +1088,83 @@ class HTMLParser:
             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("\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("(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 
+        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()))
+                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","")]
+                return [prompt[1].get_text().replace("\xa0", "")]
             else:
-                return [prompt[0].get_text().replace("\xa0","")]
-        else: 
+                return [prompt[0].get_text().replace("\xa0", "")]
+        else:
             return ""
 
-    def parse(self, config_name):
+    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
@@ -872,64 +1175,77 @@ class HTMLParser:
             file = self.sourceA if self.sourceA else self.sourceB
             file_path = Path(file)
             file_dir = file_path.parent
-            sorted_files = sorted(file_dir.iterdir())
+            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)
-                sub_folders = [
-                    name for name in sorted_files if name.suffix != ".csv"
-                ]
-                essay_id = 0
-                essay_title = None
-                essay_text = None
-                essay_grades = None
-                general_comment = None
-                specific_comment = None
-                essay_year = None
-                reference = "crawled_from_web"
-                for prompt_folder in tqdm(
-                    sub_folders,
-                    desc=f"Parsing HTML files from: {key}",
-                    total=len(sub_folders),
-                ):
-                    if prompt_folder in PROMPTS_TO_IGNORE:
-                        continue
-                    prompt = os.path.join(file_dir, prompt_folder)
-                    sorted_prompts = sorted(os.listdir(prompt))
-                    prompt_essays = [name for name in sorted_prompts]
-                    essay_year = self._get_essay_year(
-                        self.apply_soup(prompt, "Prompt.html")
-                    )
-                    essay_supporting_text = "\n".join(self._get_supporting_text(
-                        self.apply_soup(prompt, "Prompt.html")
-                    ))
-                    essay_prompt = "\n".join(self._get_prompt(
-                        self.apply_soup(prompt, "Prompt.html")
-                    ))
-                    for essay in prompt_essays:
-                        soup_text = self.apply_soup(prompt, essay)
-                        if essay == "Prompt.html":
-                            continue
-                        essay_title = self._clean_title(self._get_title(soup_text))
-                        essay_grades = self._get_grades(soup_text)
-                        essay_text = self._get_essay(soup_text)
-                        general_comment = self._get_general_comment(soup_text).strip()
-                        specific_comment = self._get_specific_comment(
-                            soup_text, general_comment
-                        )
-                        writer.writerow(
-                            [
-                                essay,
-                                prompt_folder,
-                                essay_prompt,
-                                essay_supporting_text,
-                                essay_title,
-                                essay_text,
-                                essay_grades,
-                                general_comment,
-                                specific_comment,
-                                essay_year,
-                                reference
-                            ]
-                        )
-                        essay_id += 1
+                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

pyproject.toml

@@ -9,5 +9,6 @@ dependencies = [
     "datasets>=3.2.0",
     "ipdb>=0.13.13",
     "pandas>=2.2.3",
+    "ruff>=0.9.4",
     "tqdm>=4.67.1",
 ]