# 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