Create generation_script.py

generation_script.py

@@ -0,0 +1,342 @@
+!pip install PyPDF2 google google-genai requests python-dotenv datasets huggingface_hub
+
+"""# Libraries"""
+
+import os
+import requests
+import json
+from bs4 import BeautifulSoup
+import PyPDF2
+from google import genai
+from google.genai import types
+from dotenv import load_dotenv
+import pandas as pd
+from datasets import Dataset
+from huggingface_hub import login
+
+"""# Get files"""
+
+# Main page URL
+main_url = 'https://www.sspa.juntadeandalucia.es/servicioandaluzdesalud/profesionales/ofertas-de-empleo/oferta-de-empleo-publico-puestos-base/oep-extraordinaria-decreto-ley-122022-centros-sas/cuadro-de-evolucion-concurso-oposicion-centros-sas'
+
+# Main folder where exams will be saved
+exams_folder = "exams"
+os.makedirs(exams_folder, exist_ok=True)
+
+# Perform an HTTP GET request to the main page
+main_response = requests.get(main_url)
+
+if main_response.status_code == 200:
+    main_soup = BeautifulSoup(main_response.content, 'html.parser')
+
+    # Find all tables on the main page
+    tables = main_soup.find_all('table')
+
+    for table in tables:
+        links = table.find_all('a', href=True)
+        for link in links:
+            secondary_url = link['href']
+            if secondary_url.startswith('/'):
+                secondary_url = 'https://www.sspa.juntadeandalucia.es' + secondary_url
+
+            folder_name = link.text.strip().replace("/", "-")  # Replace invalid characters
+            folder_path = os.path.join(exams_folder, folder_name)
+            os.makedirs(folder_path, exist_ok=True)
+
+            secondary_response = requests.get(secondary_url)
+            if secondary_response.status_code == 200:
+                secondary_soup = BeautifulSoup(secondary_response.content, 'html.parser')
+                secondary_tables = secondary_soup.find_all('table')
+
+                for secondary_table in secondary_tables:
+                    exam_booklet_links = secondary_table.find_all('a', title='Cuadernillo de Examen', href=True)
+                    answer_sheet_links = secondary_table.find_all('a', title='Plantilla de respuestas', href=True)
+
+                    for exam_booklet_link in exam_booklet_links:
+                        pdf_url = exam_booklet_link['href']
+                        if pdf_url.startswith('/'):
+                            pdf_url = 'https://www.sspa.juntadeandalucia.es' + pdf_url
+                        pdf_response = requests.get(pdf_url)
+                        if pdf_response.status_code == 200:
+                            file_path = os.path.join(folder_path, 'Exam_Booklet.pdf')
+                            with open(file_path, 'wb') as pdf_file:
+                                pdf_file.write(pdf_response.content)
+                            print(f'Exam Booklet saved at: {file_path}')
+
+                    for answer_sheet_link in answer_sheet_links:
+                        pdf_url = answer_sheet_link['href']
+                        if pdf_url.startswith('/'):
+                            pdf_url = 'https://www.sspa.juntadeandalucia.es' + pdf_url
+                        pdf_response = requests.get(pdf_url)
+                        if pdf_response.status_code == 200:
+                            file_path = os.path.join(folder_path, 'Answer_Sheet.pdf')
+                            with open(file_path, 'wb') as pdf_file:
+                                pdf_file.write(pdf_response.content)
+                            print(f'Answer Sheet saved at: {file_path}')
+
+else:
+    print(f'Error accessing the main page: {main_response.status_code}')
+
+"""# Configure apikey"""
+
+load_dotenv()
+GEMINI_API_KEY = "AIzaSyB46xwQbdXC_TK3Wnl3kt-oXtqKN8dRYfI"
+# TODO: PONER AQUI EL TOKEN
+HF_TOKEN= ""
+HF_DATASET_NAME="RafaelJaime/sas_opposition_exam_data"
+
+"""# PDF processing
+
+## Extract text
+"""
+
+def extract_text_from_pdf(pdf_path: str) -> str:
+    with open(pdf_path, "rb") as file:
+        reader = PyPDF2.PdfReader(file)
+        text = ""
+        for page in reader.pages:
+            text += page.extract_text()
+    return text
+
+"""## Number of questions"""
+
+import base64
+import os
+from google import genai
+from google.genai import types
+
+
+def generate_number_questions(text):
+    client = genai.Client(
+        api_key=GEMINI_API_KEY,
+    )
+
+    model = "gemini-2.0-flash"
+    contents = [
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_text(text=f"""tell me how many questions you have in format {{"number": "numberofquestionsinteger"}} in the following text: {text}"""),
+            ],
+        ),
+    ]
+    generate_content_config = types.GenerateContentConfig(
+        temperature=1,
+        top_p=0.95,
+        top_k=40,
+        max_output_tokens=8192,
+        response_mime_type="application/json",
+    )
+    response = client.models.generate_content(
+        model=model,
+        contents=contents,
+        config=generate_content_config,
+    )
+
+    return response.candidates[0].content.parts[0].text
+
+"""## Process with llm"""
+
+import json
+import os
+from google import genai
+from google.genai import types
+
+def process_with_gemini(text: str, start: int, end: int):
+    client = genai.Client(
+        api_key=GEMINI_API_KEY
+    )
+
+    model = "gemini-2.0-flash"
+    contents = [
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_text(text=f"""
+Given the following text of an exam with questions and answers, extract each question and its possible answers.
+Format the output as a list of JSON with the following format, I want you to extract questions from {start} to {end}:
+
+
+{{{{"question number in integer format": {{"statement": "question text", "answers": ["option A", "option B", ...]}}}}}}
+
+Exam text:
+{text}
+                """),
+            ],
+        ),
+    ]
+
+    generate_content_config = types.GenerateContentConfig(
+        temperature=1,
+        top_p=0.95,
+        top_k=40,
+        max_output_tokens=32768,
+        response_mime_type="application/json",
+    )
+
+    # Use generate_content() instead of streaming
+    response = client.models.generate_content(
+        model=model,
+        contents=contents,
+        config=generate_content_config,
+    )
+
+    return response.text  # Return the response instead of printing it
+
+"""# Collect the questions"""
+
+import json
+import os
+from google import genai
+from google.genai import types
+
+def process_answers_with_gemini(text: str):
+    client = genai.Client(
+        api_key=GEMINI_API_KEY
+    )
+
+    model = "gemini-2.0-flash"
+    contents = [
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_text(text=f"""
+Please return the question number and the correct answers in format ['question number': 'answer letter','question number': 'answer letter'] from the following text
+{text}
+                """),
+            ],
+        ),
+    ]
+
+    generate_content_config = types.GenerateContentConfig(
+        temperature=1,
+        top_p=0.95,
+        top_k=40,
+        max_output_tokens=32768,
+        response_mime_type="application/json",
+    )
+
+    # Use generate_content() instead of streaming
+    response = client.models.generate_content(
+        model=model,
+        contents=contents,
+        config=generate_content_config,
+    )
+
+    return response.text  # Return the response instead of printing it
+
+def process_pdf_file(pdf_path: str, answers_pdf_path: str, theme: str) -> pd.DataFrame:
+    pdf_text = extract_text_from_pdf(pdf_path)
+    result = generate_number_questions(pdf_text)
+    question_text = extract_text_from_pdf(answers_pdf_path)
+
+    # Process number of questions
+    try:
+        result_dict = json.loads(result)
+    except json.JSONDecodeError:
+        print("Error: The question count response is not valid JSON.")
+        return pd.DataFrame()
+
+    question_count = result_dict.get("number", "unknown")
+    print(f"The exam {pdf_path} contains {question_count} questions.")
+
+    try:
+        question_count = int(result_dict.get("number", 0))
+    except ValueError:
+        print(f"Error: Could not convert question count '{question_count}' to integer.")
+        return pd.DataFrame()
+
+    # Process questions in batches
+    questions = []
+    batch_size = 50
+    for start in range(1, question_count + 1, batch_size):
+        end = min(start + batch_size - 1, question_count)
+        print(f"Processing questions from {pdf_path} {start}-{end}...")
+        questions_subset = process_with_gemini(pdf_text, start, end)
+        questions.append(questions_subset)
+
+
+    # Combine all processed question batches
+    all_questions = []
+    for question_set in questions:
+        try:
+            question_list = json.loads(question_set)
+            all_questions.extend(question_list)
+        except json.JSONDecodeError:
+            print(f"Error: A question batch response is not valid JSON.")
+            continue
+
+    # If no valid questions were processed, return empty DataFrame
+    if not all_questions:
+        print("Error: No valid questions were processed.")
+        return pd.DataFrame()
+
+    # Process questions answers
+    questions_answer = process_answers_with_gemini(question_text)
+    try:
+        json_questions_answers = json.loads(questions_answer)
+    except json.JSONDecodeError:
+        print("Error: The response is not a valid JSON.")
+
+    # Format the data for the DataFrame
+    processed_data = []
+    for item in all_questions:
+        for key, value in item.items():
+            try:
+              real_answer = json_questions_answers[0].get(str(key), "Not available")
+              processed_data.append({
+                  'id': key,
+                  'statement': value['statement'],
+                  'answers': value['answers'],
+                  'real_answer': real_answer,
+                  'theme': theme
+              })
+            except KeyError as e:
+                print(f"Error: Missing key in question data: {e}")
+                # Skip this question but continue with others
+                continue
+
+    # Create DataFrame from dictionary list
+    df = pd.DataFrame(processed_data)
+    if not df.empty:
+        df.set_index('id', inplace=True)
+
+    return df
+
+
+all_df_array = []
+# Verify that the folder exists
+if os.path.exists(exams_folder):
+    for folder_name in os.listdir(exams_folder):
+        folder_path = os.path.join(exams_folder, folder_name)
+
+        # Verify that it's a folder
+        if os.path.isdir(folder_path):
+            print(f"Processing: {folder_name}")
+
+            files = os.listdir(folder_path)
+
+            # Initialize question and answer paths
+            questions_path = None
+            answers_path = None
+
+            # Look for files that start with the desired prefixes
+            for file in files:
+                if file.startswith('Exam_Booklet') and not questions_path:
+                    questions_path = os.path.join(folder_path, file)
+                elif file.startswith('Answer_Sheet') and not answers_path:
+                    answers_path = os.path.join(folder_path, file)
+            exam_df = process_pdf_file(questions_path, answers_path, folder_name)
+            if not exam_df.empty:
+                all_df_array.append(exam_df)
+
+if all_df_array:
+    df = pd.concat(all_df_array, ignore_index=True)  # `ignore_index=True` to avoid duplicates in the index
+    print(f"Final DataFrame with all questions and answers:\n{df}")
+else:
+    print("No valid DataFrames were generated.")
+
+"""# Upload to huggingface"""
+
+login(HF_TOKEN)
+Dataset.from_pandas(df).push_to_hub(HF_DATASET_NAME)