--question-ids working and force redownloading

README.md

@@ -58,13 +58,13 @@ column_info:
     description: Unique identifier for the question.
     data_type: string
   exam_name:
-    description: Name of the exam (e.g., "NEET", "JEE Main").
+    description: Name of the exam (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED").
     data_type: string
   exam_year:
     description: Year of the exam.
     data_type: int32
   exam_code:
-    description: Specific paper code/session (e.g., "T3", "S1").
+    description: Specific paper code/session (e.g., "T3", "45").
     data_type: string
   subject:
     description: Subject (e.g., "Physics", "Chemistry", "Biology", "Mathematics").
@@ -73,8 +73,8 @@ column_info:
     description: Type of question (e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER").
     data_type: string
   correct_answer:
-    description: List containing the correct answer index/indices (e.g., [2], [1, 3]) or a single integer for INTEGER type.
-    data_type: list[int32] # or sequence of int32
+    description: List containing the correct answer strings (e.g., ["A"], ["B", "C"]) or a single string for INTEGER type.
+    data_type: list[string] # Updated to reflect string format
 
 # More Information
 # ----------------
@@ -113,7 +113,7 @@ personal_sensitive_information: false # Does the dataset contain PII?
 ---
 # JEE/NEET LLM Benchmark Dataset
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) <!-- Choose your license -->
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 ## Dataset Description
 
@@ -123,10 +123,20 @@ This repository contains a benchmark dataset designed for evaluating the capabil
 
 The questions are presented in image format (`.png`) as they appear in the original papers. The dataset includes metadata linking each image to its corresponding exam details (name, year, subject, question type), and correct answer(s). The benchmark framework supports various question types including Single Correct MCQs, Multiple Correct MCQs (with partial marking for JEE Advanced), and Integer type questions.
 
-**Current Data (Examples):**
-*   NEET 2024 (Code T3)
-*   NEET 2025 (Code 45)
-*   (Support for JEE Main & Advanced questions can be added by updating `data/metadata.jsonl` and the `images/` directory accordingly.)
+**Current Data:**
+*   **NEET 2024** (Code T3): 200 questions across Physics, Chemistry, Botany, and Zoology
+*   **NEET 2025** (Code 45): 180 questions across Physics, Chemistry, Botany, and Zoology  
+*   **JEE Advanced 2024** (Paper 1 & 2): 102 questions across Physics, Chemistry, and Mathematics
+*   **Total:** 380+ questions with comprehensive metadata
+
+## Key Features
+
+*   **🖼️ Multimodal Reasoning:** Uses images of questions directly, testing the multimodal reasoning capability of models
+*   **📊 Exam-Specific Scoring:** Implements authentic scoring rules for different exams and question types, including partial marking for JEE Advanced
+*   **🔄 Robust API Handling:** Built-in retry mechanism and re-prompting for failed API calls or parsing errors
+*   **🎯 Flexible Filtering:** Filter by exam name, year, or specific question IDs for targeted evaluation
+*   **📈 Comprehensive Results:** Generates detailed JSON and human-readable Markdown summaries with section-wise breakdowns
+*   **🔧 Easy Configuration:** Simple YAML-based configuration for models and parameters
 
 ## How to Use
 
@@ -160,96 +170,215 @@ This repository contains scripts to run the benchmark evaluation directly:
 
 1.  **Clone the repository:**
     ```bash
-    # Replace with your actual Hugging Face repository URL
-    git clone https://huggingface.co/datasets/Reja1/jee-neet-benchmark
-    cd your-repo-name
+    # Replace with your actual repository URL
+    git clone https://github.com/your-username/jee-neet-benchmark
+    cd jee-neet-benchmark
     # Ensure Git LFS is installed and pull large files if necessary
     # git lfs pull
     ```
+
 2.  **Install dependencies:**
     ```bash
     # It's recommended to use a virtual environment
     python -m venv venv
-    # source venv/bin/activate # or .\venv\Scripts\activate on Windows
+    source venv/bin/activate  # On Windows: venv\Scripts\activate
     pip install -r requirements.txt
     ```
+
 3.  **Configure API Key:**
-    *   Create a file named `.env` in the root directory of the project (`your-repo-name/`).
+    *   Create a file named `.env` in the root directory of the project.
     *   Add your OpenRouter API key to this file:
         ```dotenv
-        OPENROUTER_API_KEY=your_actual_openrouter_api_key
+        OPENROUTER_API_KEY=your_actual_openrouter_api_key_here
         ```
     *   **Important:** The `.gitignore` file is already configured to prevent committing the `.env` file. Never commit your API keys directly.
+
 4.  **Configure Models:**
     *   Edit the `configs/benchmark_config.yaml` file.
-    *   Modify the `openrouter_models` list to include the specific model identifiers (e.g., `"openai/gpt-4o"`, `"google/gemini-2.5-pro-preview-03-25"`) you want to evaluate. Ensure these models support vision input on OpenRouter.
+    *   Modify the `openrouter_models` list to include the specific model identifiers you want to evaluate:
+        ```yaml
+        openrouter_models:
+          - "google/gemini-2.5-pro-preview-03-25"
+          - "openai/gpt-4o"
+          - "anthropic/claude-3-5-sonnet-20241022"
+        ```
+    *   Ensure these models support vision input on OpenRouter.
     *   You can also adjust other parameters like `max_tokens` and `request_timeout` if needed.
+
 5.  **Run the benchmark:**
-    *   Execute the runner script from the root directory:
-        ```bash
-        python src/benchmark_runner.py --config configs/benchmark_config.yaml
-        ```
-    *   You can override the models list from the command line:
-        ```bash
-        python src/benchmark_runner.py --config configs/benchmark_config.yaml --models "openai/gpt-4o" "google/gemini-2.5-pro-preview-03-25"
-        ```
-    *   You can specify a different output directory:
-        ```bash
-        python src/benchmark_runner.py --config configs/benchmark_config.yaml --output_dir my_custom_results
-        ```
-    *   To run the benchmark on a specific exam paper, use the `--exam_name` and `--exam_year` arguments. Both must be provided. The `exam_name` should match the values in your `metadata.jsonl` (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED").
-        ```bash
-        # Example: Run only NEET 2024 questions
-        python src/benchmark_runner.py --config configs/benchmark_config.yaml --exam_name NEET --exam_year 2024
-        
-        # Example: Run only JEE_MAIN 2023 questions (assuming data exists)
-        python src/benchmark_runner.py --config configs/benchmark_config.yaml --exam_name JEE_MAIN --exam_year 2023
-        ```
-        Note: If using exam names with spaces (though not recommended in metadata), enclose them in quotes.
+
+    **Basic usage (run all available models on all questions):**
+    ```bash
+    python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-2.5-pro-preview-03-25"
+    ```
+
+    **Filter by exam and year:**
+    ```bash
+    # Run only NEET 2024 questions
+    python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "openai/gpt-4o" --exam_name NEET --exam_year 2024
+    
+    # Run only JEE Advanced 2024 questions
+    python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "anthropic/claude-3-5-sonnet-20241022" --exam_name JEE_ADVANCED --exam_year 2024
+    ```
+
+    **Run specific questions:**
+    ```bash
+    # Run specific question IDs
+    python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-2.5-pro-preview-03-25" --question_ids "NEET_2024_T3_001,NEET_2024_T3_002,JEE_ADVANCE_2024_P1_MATH_01"
+    ```
+
+    **Custom output directory:**
+    ```bash
+    python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "openai/gpt-4o" --output_dir my_custom_results
+    ```
+
+    **Available filtering options:**
+    - `--exam_name`: Choose from `NEET`, `JEE_MAIN`, `JEE_ADVANCED`, or `all` (default)
+    - `--exam_year`: Choose from available years (`2024`, `2025`, etc.) or `all` (default)
+    - `--question_ids`: Comma-separated list of specific question IDs to evaluate (e.g., "NEET_2024_T3_001,JEE_ADVANCE_2024_P1_MATH_01")
+
 6.  **Check Results:**
-    *   Results for each model will be saved in subdirectories within the `results/` folder (or your custom output directory).
-    *   Each model's folder (e.g., `results/openai_gpt-4o_NEET_2024_YYYYMMDD_HHMMSS`) will contain:
-        *   `predictions.jsonl`: Detailed results for each question (prediction, ground truth, raw response, evaluation status, marks awarded).
-        *   `summary.json`: Overall scores and statistics for that model run.
-        *   `summary.md`: A human-readable Markdown version of the summary.
-    *   Sample benchmark results for some models can be found in the `results/` folder (these may be outdated).
-
-## Pros
-
-*   **Multimodal Reasoning:** Uses images of questions directly, testing the multimodal reasoning capability of the model.
-*   **Flexible Exam Support:** Designed to support multiple exams (NEET, JEE Main, JEE Advanced) and various question types (MCQ Single Correct, MCQ Multiple Correct, Integer).
-*   **Detailed Scoring:** Implements specific scoring rules for different exams and question types, including partial marking for JEE Advanced multiple correct questions.
-*   **Reattempt Mechanism:** Implements a reattempt mechanism to encourage the model to provide the final answer within `<answer>` tags, adapted for different question types.
-*   **Reproducibility:** Easily reproducible with simple commands and an OpenRouter API key.
-*   **Model Flexibility:** Allows testing of various models available through OpenRouter.
+    *   Results for each model run will be saved in timestamped subdirectories within the `results/` folder.
+    *   Each run's folder (e.g., `results/google_gemini-2.5-pro-preview-03-25_NEET_2024_20250524_141230/`) contains:
+        *   **`predictions.jsonl`**: Detailed results for each question including:
+            - Model predictions and ground truth
+            - Raw LLM responses
+            - Evaluation status and marks awarded
+            - API call success/failure information
+        *   **`summary.json`**: Overall scores and statistics in JSON format
+        *   **`summary.md`**: Human-readable Markdown summary with:
+            - Overall exam scores
+            - Section-wise breakdown (by subject)
+            - Detailed statistics on correct/incorrect/skipped questions
+
+## Scoring System
+
+The benchmark implements authentic scoring systems for each exam type:
+
+### NEET Scoring
+- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped
+
+### JEE Main Scoring  
+- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped
+- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped
+
+### JEE Advanced Scoring
+- **Single Correct MCQ**: +3 for correct, -1 for incorrect, 0 for skipped
+- **Multiple Correct MCQ**: Complex partial marking system:
+  - +4 for all correct options selected
+  - +3 for 3 out of 4 correct options (when 4 are correct)
+  - +2 for 2 out of 3+ correct options
+  - +1 for 1 out of 2+ correct options
+  - -2 for any incorrect option selected
+  - 0 for skipped
+- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped
+
+## Advanced Features
+
+### Retry Mechanism
+- Automatic retry for failed API calls (up to 3 attempts with exponential backoff)
+- Separate retry pass for questions that failed initially
+- Comprehensive error tracking and reporting
+
+### Re-prompting System
+- If initial response parsing fails, the system automatically re-prompts the model
+- Uses the previous response to ask for properly formatted answers
+- Adapts prompts based on question type (MCQ vs Integer)
+
+### Comprehensive Evaluation
+- Tracks multiple metrics: correct answers, partial credit, skipped questions, API failures
+- Section-wise breakdown by subject
+- Detailed logging with color-coded progress indicators
 
 ## Dataset Structure
 
-*   **`data/metadata.jsonl`**: Contains metadata for each question image. Each line is a JSON object with fields like `image_path`, `question_id`, `exam_name` (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED"), `exam_year`, `subject`, `question_type` (e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER"), `correct_answer`.
-*   **`images/`**: Contains subdirectories for each exam set (e.g., `images/NEET_2024_T3/`, `images/JEE_MAIN_2023_Example/`), holding the `.png` question images.
-*   **`src/`**: Python source code for running the benchmark (data loading, LLM interaction, evaluation).
-*   **`configs/`**: Configuration files for the benchmark.
-*   **`results/`**: Directory where benchmark results (LLM outputs) will be stored.
-*   **`jee_neet_benchmark_dataset.py`**: Hugging Face `datasets` loading script (defines how to load `metadata.jsonl` and images).
-*   **`requirements.txt`**: Python dependencies.
-*   **`README.md`**: This file.
+*   **`data/metadata.jsonl`**: Contains metadata for each question image with fields:
+    - `image_path`: Path to the question image
+    - `question_id`: Unique identifier (e.g., "NEET_2024_T3_001")
+    - `exam_name`: Exam type ("NEET", "JEE_MAIN", "JEE_ADVANCED")
+    - `exam_year`: Year of the exam (integer)
+    - `exam_code`: Paper/session code (e.g., "T3", "P1")
+    - `subject`: Subject name (e.g., "Physics", "Chemistry", "Mathematics")
+    - `question_type`: Question format ("MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER")
+    - `correct_answer`: List of correct answer strings (e.g., ["A"], ["B", "C"], ["42"])
 
-## Data Fields
+*   **`images/`**: Contains subdirectories for each exam set:
+    - `images/NEET_2024_T3/`: NEET 2024 question images
+    - `images/NEET_2025_45/`: NEET 2025 question images  
+    - `images/JEE_ADVANCE_2024/`: JEE Advanced 2024 question images
 
-The dataset contains the following fields (accessible via `datasets`):
+*   **`src/`**: Python source code for the benchmark system:
+    - `benchmark_runner.py`: Main benchmark execution script
+    - `llm_interface.py`: OpenRouter API interface with retry logic
+    - `evaluation.py`: Scoring and evaluation functions
+    - `prompts.py`: LLM prompts for different question types
+    - `utils.py`: Utility functions for parsing and configuration
+
+*   **`configs/`**: Configuration files:
+    - `benchmark_config.yaml`: Model selection and API parameters
 
-*   `image`: The question image (`datasets.Image`).
-*   `question_id`: Unique identifier for the question (string).
-*   `exam_name`: Name of the exam (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED") (string).
-*   `exam_year`: Year of the exam (int).
-*   `subject`: Subject (e.g., "Physics", "Chemistry", "Botany", "Zoology", "Mathematics") (string).
-*   `question_type`: Type of question (e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER") (string).
-*   `correct_answer`: List containing the correct answer index/indices (e.g., `[2]`, `[1, 3]`) or a single integer for INTEGER type questions (list of int, or int).
+*   **`results/`**: Directory where benchmark results are stored (timestamped subdirectories)
 
-## Cons / Current Limitations
+*   **`jee-neet-benchmark.py`**: Hugging Face `datasets` loading script
+
+## Data Fields
+
+The dataset contains the following fields (accessible via `datasets`):
 
-*   **Data Expansion:** While the framework supports various exams and question types, the current `metadata.jsonl` primarily contains NEET data. More diverse data (especially for JEE Main and Advanced with varied question types) needs to be added to make the benchmark more comprehensive.
-*   **Max Score in Summary:** The overall maximum score in the generated Markdown summary is currently marked as "N/A (variable per question)" due to the complexity of calculating it accurately across mixed question types in a single run. Each question's max score depends on its type and exam.
+*   `image`: The question image (`datasets.Image`)
+*   `question_id`: Unique identifier for the question (string)
+*   `exam_name`: Name of the exam (e.g., "NEET", "JEE_ADVANCED") (string)
+*   `exam_year`: Year of the exam (int)
+*   `exam_code`: Paper/session code (e.g., "T3", "P1") (string)
+*   `subject`: Subject (e.g., "Physics", "Chemistry", "Mathematics") (string)
+*   `question_type`: Type of question (e.g., "MCQ_SINGLE_CORRECT", "INTEGER") (string)
+*   `correct_answer`: List containing the correct answer strings.
+    - For MCQs, these are option identifiers (e.g., `["1"]`, `["A"]`, `["B", "C"]`). The LLM should output the identifier as it appears in the question.
+    - For INTEGER type, this is the numerical answer as a string (e.g., `["42"]`, `["12.75"]`). The LLM should output the number.
+    - For some `MCQ_SINGLE_CORRECT` questions, multiple answers in this list are considered correct if the LLM prediction matches any one of them.
+    (list of strings)
+
+## LLM Answer Format
+
+The LLM is expected to return its answer enclosed in `<answer>` tags. For example:
+- MCQ Single Correct (Option A): `<answer>A</answer>`
+- MCQ Single Correct (Option 2): `<answer>2</answer>`
+- MCQ Multiple Correct (Options B and D): `<answer>B,D</answer>`
+- Integer Answer: `<answer>42</answer>`
+- Decimal Answer: `<answer>12.75</answer>`
+- Skipped Question: `<answer>SKIP</answer>
+
+The system parses these formats. Prompts are designed to guide the LLM accordingly.
+
+## Troubleshooting
+
+### Common Issues
+
+**API Key Issues:**
+- Ensure your `.env` file is in the root directory
+- Verify your OpenRouter API key is valid and has sufficient credits
+- Check that the key has access to vision-capable models
+
+**Model Not Found:**
+- Verify the model identifier exists on OpenRouter
+- Ensure the model supports vision input
+- Check your OpenRouter account has access to the specific model
+
+**Memory Issues:**
+- Reduce `max_tokens` in the config file
+- Process smaller subsets using `--question_ids` filter
+- Use models with smaller context windows
+
+**Parsing Failures:**
+- The system automatically attempts re-prompting for parsing failures
+- Check the raw responses in `predictions.jsonl` to debug prompt issues
+- Consider adjusting prompts in `src/prompts.py` for specific models
+
+## Current Limitations
+
+*   **Dataset Size:** While comprehensive, the dataset could benefit from more JEE Main questions and additional years
+*   **Language Support:** Currently only supports English questions
+*   **Model Dependencies:** Requires models with vision capabilities available through OpenRouter
 
 ## Citation
 
@@ -260,7 +389,7 @@ If you use this dataset or benchmark code, please cite:
   title={JEE/NEET LLM Benchmark},
   author={Md Rejaullah},
   year={2025},
-  howpublished={\\url{https://huggingface.co/datasets/Reja1/jee-neet-benchmark}},
+  howpublished={\url{https://huggingface.co/datasets/Reja1/jee-neet-benchmark}},
 }
 ```
 

jee-neet-benchmark.py

@@ -60,7 +60,7 @@ class JeeNeetBenchmark(datasets.GeneratorBasedBuilder):
                 "question_id": datasets.Value("string"),
                 "exam_name": datasets.Value("string"),
                 "exam_year": datasets.Value("int32"),
-                "exam_code": datasets.Value("string"),
+                "exam_code": datasets.Value("string"), # Will provide default if missing in source
                 "subject": datasets.Value("string"),
                 "question_type": datasets.Value("string"),
                 "correct_answer": datasets.Sequence(datasets.Value("string")), # List of strings
@@ -81,6 +81,11 @@ class JeeNeetBenchmark(datasets.GeneratorBasedBuilder):
         repo_metadata_path = os.path.join("data", "metadata.jsonl")
         repo_images_archive_path = "images.tar.gz" # At the root of the repository
 
+        # Ensure force download and extract for the current run
+        # dl_manager.download_config is an instance of datasets.DownloadConfig
+        dl_manager.download_config.force_download = True
+        dl_manager.download_config.force_extract = True # If redownloading, re-extraction is also desired
+
         try:
             # Download and extract metadata and images archive
             downloaded_files = dl_manager.download_and_extract({
@@ -155,7 +160,7 @@ class JeeNeetBenchmark(datasets.GeneratorBasedBuilder):
                     "question_id": row.get("question_id", ""),
                     "exam_name": row.get("exam_name", ""),
                     "exam_year": row.get("exam_year", -1), # Use a default if missing
-                    "exam_code": row.get("exam_code", ""),
+                    "exam_code": row.get("exam_code", "N/A"), # Provide "N/A" if exam_code is missing
                     "subject": row.get("subject", ""),
                     "question_type": row.get("question_type", ""),
                     "correct_answer": row.get("correct_answer", []),

requirements.txt

@@ -19,4 +19,7 @@ python-dotenv>=0.19.0
 # For handling retries during API calls
 tenacity>=8.0.0
 
+# For progress bars in benchmark execution
+tqdm>=4.60.0
+
 # Add other dependencies as needed for your benchmark scripts (e.g., numpy, scikit-learn for evaluation)

src/benchmark_runner.py

@@ -236,7 +236,7 @@ def run_benchmark(
         # Explicitly specify data_files and data_dir for local loading.
         # data_dir should be the project root ('.') when loading a local script,
         # as the script is copied to a cache and needs to know where the actual data is.
-        dataset = load_dataset(dataset_path, split='test', data_files={'test': 'data/metadata.jsonl'}, data_dir='.', trust_remote_code=True)
+        dataset = load_dataset(dataset_path, split='test', data_files={'test': 'data/metadata.jsonl'}, data_dir=os.getcwd(), trust_remote_code=True)
         dataset = dataset.cast_column("image", HFImage(decode=True)) # Ensure images are loaded as PIL
         logging.info(f"Dataset loaded successfully from path: {dataset_path}. Original number of questions: {len(dataset)}")
     except Exception as e:

src/evaluation.py

@@ -96,17 +96,23 @@ def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict
     current_score_change = 0
     evaluation_status = "unknown"
 
-    # Ensure truth is a set of uppercase strings for consistent processing
+    # Ensure truth is a set of uppercase strings for consistent processing.
+    # Ground truth from metadata.jsonl is expected to be a list of strings.
+    # e.g., ["1"], ["A"], ["12.75"], ["A", "C"]
     truth_set: set
-    if isinstance(truth, str): # e.g. for single integer answer like "14" or single option "A"
+    if isinstance(truth, str): 
+        # This case might occur if metadata had a single string instead of list for some reason,
+        # or if an old format slips through. Convert to a set of one uppercase string.
+        logging.warning(f"Ground truth for {question_id} is a single string: '{truth}'. Converting to set.")
         truth_set = {truth.upper()}
-    elif isinstance(truth, list) and all(isinstance(t, str) for t in truth): # e.g. ["A", "C"] or ["14"]
+    elif isinstance(truth, list) and all(isinstance(t, str) for t in truth): 
         truth_set = {s.upper() for s in truth}
-    elif isinstance(truth, list) and all(isinstance(t, int) for t in truth): # Handle old integer list format if it slips through
-        logging.warning(f"Ground truth for {question_id} is List[int]: {truth}. Converting to List[str].")
+    # Deprecated int/List[int] handling, as metadata should now be List[str]
+    elif isinstance(truth, list) and any(isinstance(t, int) for t in truth): 
+        logging.warning(f"Ground truth for {question_id} contains integers: {truth}. Converting all to strings.")
         truth_set = {str(s).upper() for s in truth}
-    elif isinstance(truth, int): # Handle old integer format if it slips through
-        logging.warning(f"Ground truth for {question_id} is int: {truth}. Converting to str.")
+    elif isinstance(truth, int): 
+        logging.warning(f"Ground truth for {question_id} is int: {truth}. Converting to string set.")
         truth_set = {str(truth).upper()}
     else:
         logging.error(f"Invalid ground_truth format for {question_id}: {truth} (type: {type(truth)}). Assigning 0 marks.")
@@ -124,29 +130,41 @@ def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict
         evaluation_status = "skipped"
     elif isinstance(pred, list) and all(isinstance(p, str) for p in pred):
         pred_set = {p.upper() for p in pred} # Convert to uppercase strings
-        if exam_name == "NEET" and question_type == "MCQ_SINGLE_CORRECT":
-            if pred_set == truth_set and len(pred_set) == 1:
+        
+        # Handle MCQ_SINGLE_CORRECT first, as it has special logic for multiple truths.
+        # The parser (`parse_llm_answer`) returns `pred` as `list[str]` with one element for valid single answers.
+        if question_type == "MCQ_SINGLE_CORRECT":
+            # A prediction is correct if its single element is present in the truth_set.
+            # This accommodates metadata entries where `correct_answer` for an MCQ_SINGLE_CORRECT
+            # might list multiple acceptable options (e.g., if a question had two official correct answers).
+            is_correct = False
+            if len(pred_set) == 1: # Ensure prediction is indeed a single option
+                single_pred_answer = list(pred_set)[0] # Get the single predicted option
+                if single_pred_answer in truth_set: # Check if this predicted option is in the set of true answers
+                    is_correct = True
+            
+            if is_correct:
+                evaluation_status = "correct"
+                if exam_name == "NEET": current_score_change = 4
+                elif exam_name == "JEE_MAIN": current_score_change = 4
+                elif exam_name == "JEE_ADVANCED": current_score_change = 3
+                else: current_score_change = 1 # Default positive score for unknown exam
+            else:
+                evaluation_status = "incorrect"
+                if exam_name == "NEET": current_score_change = -1
+                elif exam_name == "JEE_MAIN": current_score_change = -1
+                elif exam_name == "JEE_ADVANCED": current_score_change = -1
+                else: current_score_change = 0 # Default no penalty
+
+        elif exam_name == "JEE_MAIN" and question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["14"]
+            if len(pred_set) == 1 and list(pred_set)[0] in truth_set: # Compare the single string prediction
                 current_score_change = 4; evaluation_status = "correct"
             else:
-                current_score_change = -1; evaluation_status = "incorrect"
-        elif exam_name == "JEE_MAIN":
-            if question_type == "MCQ_SINGLE_CORRECT":
-                if pred_set == truth_set and len(pred_set) == 1:
-                    current_score_change = 4; evaluation_status = "correct"
-                else:
-                    current_score_change = -1; evaluation_status = "incorrect"
-            elif question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["14"]
-                if len(pred_set) == 1 and list(pred_set)[0] in truth_set: # Compare the single string prediction
-                    current_score_change = 4; evaluation_status = "correct"
-                else:
-                    current_score_change = 0; evaluation_status = "incorrect"
+                current_score_change = 0; evaluation_status = "incorrect"
+        
         elif exam_name == "JEE_ADVANCED":
-            if question_type == "MCQ_SINGLE_CORRECT":
-                if pred_set == truth_set and len(pred_set) == 1:
-                    current_score_change = 3; evaluation_status = "correct"
-                else:
-                    current_score_change = -1; evaluation_status = "incorrect"
-            elif question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["12"]
+            # Note: MCQ_SINGLE_CORRECT for JEE_ADVANCED is handled by the common block above
+            if question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["12"]
                 if len(pred_set) == 1 and list(pred_set)[0] in truth_set: # Compare the single string prediction
                     current_score_change = 4; evaluation_status = "correct"
                 else:

src/prompts.py

@@ -3,41 +3,41 @@
 # --- Initial Prompt Components ---
 
 ANSWER_FORMAT_INSTRUCTIONS = {
-    "MCQ_SINGLE_CORRECT": "determine the single correct integer number corresponding to the correct option.",
-    "INTEGER": "determine the single non-negative integer that is the answer.",
-    "MCQ_MULTIPLE_CORRECT": "determine all correct integer option(s). If multiple options are correct, list them separated by commas.",
-    "DEFAULT": "determine the correct answer."
+    "MCQ_SINGLE_CORRECT": "determine the single correct option identifier (e.g., 1, 2, A, B) as it appears in the question.",
+    "INTEGER": "determine the single numerical answer. This can be an integer or a decimal value. Provide the number as accurately as possible.",
+    "MCQ_MULTIPLE_CORRECT": "determine all correct option identifier(s) (e.g., 1, 2, A, B) as they appear in the question. If multiple options are correct, list their identifiers separated by commas.",
+    "DEFAULT": "determine the correct answer based on the question's format."
 }
 
 EXAMPLE_INSTRUCTIONS = {
-    "MCQ_SINGLE_CORRECT": "- If the correct option is 2: <answer>2</answer>",
-    "INTEGER": "- If the answer is 5: <answer>5</answer>",
-    "MCQ_MULTIPLE_CORRECT": "- If options A and B are correct: <answer>A,B</answer>\n- If only option B is correct: <answer>B</answer>",
+    "MCQ_SINGLE_CORRECT": "- If the correct option is labeled '2' in the question: <answer>2</answer>\n- If the correct option is labeled 'A' in the question: <answer>A</answer>",
+    "INTEGER": "- If the answer is 5: <answer>5</answer>\n- If the answer is 12.75: <answer>12.75</answer>\n- If the answer is 0.5: <answer>0.5</answer>",
+    "MCQ_MULTIPLE_CORRECT": "- If options labeled 'A' and 'C' are correct: <answer>A,C</answer>\n- If options labeled '1' and '3' are correct: <answer>1,3</answer>\n- If only option 'B' is correct: <answer>B</answer>\n- If only option '2' is correct: <answer>2</answer>",
     "DEFAULT": "- Example: <answer>Your Answer</answer>"
 }
 
-INITIAL_PROMPT_TEMPLATE = """You are an expert at analyzing exam questions from the {exam_name} {exam_year} exam ({question_type}) and extracting the correct answer option(s).
+INITIAL_PROMPT_TEMPLATE = """You are an expert at analyzing exam questions from the {exam_name} {exam_year} exam ({question_type}) and extracting the correct answer option(s)/value.
 This exam uses specific marking schemes, so accuracy and correct formatting are crucial.
 
 Please think step-by-step to solve the problem.
 Examine the provided image of the question carefully.
 1. Analyze the question and the provided options (if any).
 2. Reason through the problem to {answer_format_instruction}
-3. Format your final answer by enclosing ONLY the determined integer(s) within <answer> tags.
+3. Format your final answer by enclosing ONLY the determined identifier(s) or numerical value(s) within <answer> tags.
 
 Examples:
 {example_instruction}
 - If you are unsure or cannot determine the answer: <answer>SKIP</answer>
 
-It is crucial that your response contains ONLY the <answer> tag with the correct integer(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
+It is crucial that your response contains ONLY the <answer> tag with the correct option identifier(s), numerical value(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
 
 
 # --- Reprompt Components ---
 
 SPECIFIC_INSTRUCTIONS_REPROMPT = {
-    "MCQ_SINGLE_CORRECT": "provide ONLY the single integer or correct option(A, B, C, D) corresponding to the correct answer choice",
-    "INTEGER": "provide ONLY the single non-negative integer that is the answer",
-    "MCQ_MULTIPLE_CORRECT": "provide ALL correct integer option(s) separated by commas (e.g., <answer>A,B</answer> or <answer>B</answer> if only one is correct)",
+    "MCQ_SINGLE_CORRECT": "provide ONLY the single correct option identifier (e.g., 1, A) as it appears in the question",
+    "INTEGER": "provide ONLY the single numerical answer (integer or decimal)",
+    "MCQ_MULTIPLE_CORRECT": "provide ALL correct option identifier(s) (e.g., A,C or 1,3) as they appear in the question, separated by commas if multiple. If only one is correct, provide just that one (e.g., <answer>B</answer> or <answer>2</answer>)",
     "DEFAULT": "provide the answer according to the question format"
 }
 
@@ -50,11 +50,14 @@ Your previous response did not correctly format the final answer within <answer>
 
 Please re-examine your previous reasoning and {specific_instructions}, enclosed in <answer> tags.
 
-Example for single correct integer: <answer>2</answer>
-Example for multiple correct integers: <answer>A,C</answer>
+Example for single correct MCQ option 'A': <answer>A</answer>
+Example for single correct MCQ option '2': <answer>2</answer>
+Example for multiple correct MCQ options 'A' and 'C': <answer>A,C</answer>
+Example for integer answer: <answer>42</answer>
+Example for decimal answer: <answer>12.75</answer>
 If you are unsure or cannot determine the answer: <answer>SKIP</answer>
 
-It is crucial that your response contains ONLY the <answer> tag with the correct integer(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
+It is crucial that your response contains ONLY the <answer> tag with the correct option identifier(s), numerical value(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
 
 # --- Helper functions to get instructions ---
 

src/utils.py

@@ -28,16 +28,17 @@ def load_api_key(key_name="OPENROUTER_API_KEY"):
     return api_key
 
 
-def parse_llm_answer(response_text: str, question_type: str = "MCQ_SINGLE_CORRECT") -> list[int] | str | None:
+def parse_llm_answer(response_text: str, question_type: str = "MCQ_SINGLE_CORRECT") -> list[str] | str | None:
     """
     Parses the LLM response text to extract answers within <answer> tags.
     The parsing logic adapts based on the question_type.
 
     Handles:
-    - Single integer answers (for MCQ_SINGLE_CORRECT, INTEGER).
-    - Multiple integer answers (comma-separated for MCQ_MULTIPLE_CORRECT).
-    - The specific string "SKIP" for skipped questions.
-    - Potential newlines within the tags.
+    - MCQ_SINGLE_CORRECT: Single option identifier (integer like "1", "2" or letter like "A", "B").
+    - INTEGER: Single numerical value, which can be an integer or a decimal (e.g., "5", "12.75", "0.5").
+    - MCQ_MULTIPLE_CORRECT: Multiple option identifiers (integers or letters), comma-separated.
+    - The specific string "SKIP" for skipped questions (case-insensitive content within tags).
+    - Potential newlines and varied spacing within the tags.
 
     Args:
         response_text (str): The raw text response from the LLM.
@@ -46,24 +47,26 @@ def parse_llm_answer(response_text: str, question_type: str = "MCQ_SINGLE_CORREC
                              Defaults to "MCQ_SINGLE_CORRECT".
 
     Returns:
-        list[int] | str | None:
-            - A list containing integer answer(s) if found and valid.
-              (single element for MCQ_SINGLE_CORRECT/INTEGER, potentially multiple for MCQ_MULTIPLE_CORRECT)
+        list[str] | str | None:
+            - A list containing string answer(s) if found and valid.
+              (e.g., ["1"], ["A"], ["12.75"], ["A", "C"])
             - The string "SKIP" if the response indicates a skip.
             - None if parsing fails (no tag, invalid content, type mismatch, etc.).
     """
     if not response_text:
         return None
 
-    # Check for exact SKIP response first (case-insensitive)
-    if response_text.strip().upper() == "<ANSWER>SKIP</ANSWER>":
+    # Check for exact SKIP response first (case-insensitive for the tag and content)
+    # Using regex to be more flexible with whitespace around SKIP
+    skip_match = re.search(r"<answer>\s*SKIP\s*</answer>", response_text, re.IGNORECASE)
+    if skip_match:
         logging.info(f"Parsed answer as SKIP for question_type: {question_type}.")
         return "SKIP"
 
     match = re.search(r"<answer>(.*?)</answer>", response_text, re.DOTALL | re.IGNORECASE)
 
     if not match:
-        logging.warning(f"Could not find <answer> tag in response for question_type: {question_type}.")
+        logging.warning(f"Could not find <answer> tag in response for question_type: {question_type} in response: '{response_text[:200]}...'")
         return None
 
     extracted_content = match.group(1).strip()
@@ -71,76 +74,127 @@ def parse_llm_answer(response_text: str, question_type: str = "MCQ_SINGLE_CORREC
         logging.warning(f"Found <answer> tag but content is empty for question_type: {question_type}.")
         return None
 
-    potential_answers_str = [item.strip() for item in extracted_content.split(',')]
-    parsed_numbers = []
-    all_valid_numbers = True
+    potential_answers_str_list = [item.strip() for item in extracted_content.split(',')]
+    parsed_answers_final = []
+
+    for ans_str_raw in potential_answers_str_list:
+        ans_str = ans_str_raw.strip()
+        if not ans_str: # Skip empty strings that might result from "1, ,2" or trailing commas
+            continue
+
+        if question_type == "INTEGER":
+            try:
+                # Try to parse as float to validate it's a number (integer or decimal).
+                # The value is kept as a string to preserve original formatting (e.g., "0.50", "5.0")
+                # for exact string comparison with ground truth if needed, and for consistent type handling.
+                float(ans_str) 
+                parsed_answers_final.append(ans_str)
+            except ValueError:
+                logging.warning(f"Could not parse '{ans_str}' as a valid number (integer or decimal) for INTEGER type. Full content: '{extracted_content}'")
+                return None # If any part is not a valid number for INTEGER type, fail parsing.
+        
+        elif question_type in ["MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT"]:
+            # For MCQs, the answer can be an integer (option number like 1, 2, 3, 4)
+            # or a letter (option identifier like A, B, C, D).
+            # The parser accepts these and returns them as strings.
+            # Numerical options are typically single digits 1-4.
+            # Letter options are single letters A-D (case-insensitive, converted to uppercase).
+            if re.fullmatch(r"[1-4]", ans_str): # Typical integer options
+                parsed_answers_final.append(ans_str)
+            elif re.fullmatch(r"[a-dA-D]", ans_str): # Typical letter options (A,B,C,D or a,b,c,d)
+                parsed_answers_final.append(ans_str.upper()) # Standardize to uppercase
+            elif re.fullmatch(r"[1-9]\d*", ans_str): # Accept other integers if questions use them as options
+                logging.debug(f"Accepting non-standard integer option '{ans_str}' for MCQ. Full content: '{extracted_content}'")
+                parsed_answers_final.append(ans_str)
+            elif re.fullmatch(r"[a-zA-Z]", ans_str): # Accept other single letters if questions use them
+                logging.debug(f"Accepting non-standard letter option '{ans_str}' for MCQ. Full content: '{extracted_content}'")
+                parsed_answers_final.append(ans_str.upper())
+            else:
+                logging.warning(f"Could not parse '{ans_str}' as a valid MCQ option (expected 1-4, A-D, or other single int/letter). Full content: '{extracted_content}'")
+                return None # If any part is not a valid MCQ option, fail parsing.
+        else: # Should not happen if question_type is validated before calling
+            logging.error(f"Unknown question_type '{question_type}' encountered in parse_llm_answer logic.")
+            return None
 
-    for ans_str in potential_answers_str:
-        if not ans_str: continue # Skip empty strings (e.g., from "1," or ",2")
-        try:
-            parsed_numbers.append(int(ans_str))
-        except ValueError:
-            logging.warning(f"Could not parse '{ans_str}' as an integer within <answer> tag for question_type: {question_type}.")
-            all_valid_numbers = False
-            break
 
-    if not all_valid_numbers or not parsed_numbers: # If any part was not a number or if list is empty after parsing
+    if not parsed_answers_final: # If list is empty after processing (e.g. content was just commas)
+        logging.warning(f"No valid answer items found after parsing content: '{extracted_content}' for question_type: {question_type}.")
         return None
 
-    # Apply rules based on question_type
+    # Apply rules based on question_type for number of answers
     if question_type in ["MCQ_SINGLE_CORRECT", "INTEGER"]:
-        if len(parsed_numbers) == 1:
-            return parsed_numbers # Returns [integer]
+        if len(parsed_answers_final) == 1:
+            return parsed_answers_final # Returns list[str] with one element
         else:
-            logging.warning(f"Expected single answer for {question_type}, but found {len(parsed_numbers)} numbers: {parsed_numbers}. Treating as parse failure.")
+            logging.warning(f"Expected single answer for {question_type}, but found {len(parsed_answers_final)} items: {parsed_answers_final}. Content: '{extracted_content}'")
             return None
     elif question_type == "MCQ_MULTIPLE_CORRECT":
-        # For multiple correct, any number of valid integers is acceptable.
+        # For multiple correct, any number of valid items is acceptable.
         # Return them sorted and unique.
-        return sorted(list(set(parsed_numbers)))
+        return sorted(list(set(parsed_answers_final)))
     else:
-        logging.error(f"Unknown question_type '{question_type}' provided to parse_llm_answer.")
+        # This case should ideally be caught by earlier checks or input validation.
+        logging.error(f"Unknown question_type '{question_type}' provided to parse_llm_answer at final stage.")
         return None
 
 # Example Usage (for testing)
 if __name__ == '__main__':
     test_cases = [
-        # MCQ_SINGLE_CORRECT / INTEGER
-        {"resp": "Some text before <answer>2</answer> and after.", "type": "MCQ_SINGLE_CORRECT", "expected": [2]},
-        {"resp": "Blah blah <answer> 1 </answer> blah", "type": "INTEGER", "expected": [1]},
-        {"resp": "<answer>\n 3 \n</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": [3]},
+        # MCQ_SINGLE_CORRECT (can be number or letter)
+        {"resp": "<answer>2</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": ["2"]},
+        {"resp": "<answer>B</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": ["B"]},
+        {"resp": "<answer> c </answer>", "type": "MCQ_SINGLE_CORRECT", "expected": ["C"]},
         {"resp": "<answer>1,3</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None}, # Fail: multiple for single
-        {"resp": "<answer>1,3</answer>", "type": "INTEGER", "expected": None}, # Fail: multiple for single
+        {"resp": "<answer>A,C</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None}, # Fail: multiple for single
+        {"resp": "<answer>X</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None}, # Fail: invalid letter
+        {"resp": "<answer>5</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": ["5"]}, # Allow other numbers for now
+
+        # INTEGER (can be int or decimal string)
+        {"resp": "<answer>42</answer>", "type": "INTEGER", "expected": ["42"]},
+        {"resp": "<answer>0</answer>", "type": "INTEGER", "expected": ["0"]},
+        {"resp": "<answer>12.75</answer>", "type": "INTEGER", "expected": ["12.75"]},
+        {"resp": "<answer>0.5</answer>", "type": "INTEGER", "expected": ["0.5"]},
+        {"resp": "<answer>-5</answer>", "type": "INTEGER", "expected": ["-5"]}, # Assuming negative integers are valid if problem allows
+        {"resp": "<answer>5.00</answer>", "type": "INTEGER", "expected": ["5.00"]},
+        {"resp": "<answer>abc</answer>", "type": "INTEGER", "expected": None}, # Fail: not a number
+        {"resp": "<answer>1,2</answer>", "type": "INTEGER", "expected": None}, # Fail: multiple for single int
+
+        # MCQ_MULTIPLE_CORRECT (can be numbers or letters, mixed is not typical but parser allows if items are valid individually)
+        {"resp": "<answer>1,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["1", "3"]},
+        {"resp": "<answer>A,C</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["A", "C"]},
+        {"resp": "<answer> b , d </answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["B", "D"]},
+        {"resp": "<answer>2</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["2"]}, # Single is valid
+        {"resp": "<answer>D</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["D"]}, # Single is valid
+        {"resp": "<answer>1,C,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["1", "3", "C"]}, # Mixed, sorted
+        {"resp": "<answer>C,1,A,1</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["1", "A", "C"]}, # Unique and sorted
+        {"resp": "<answer>1,X,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": None}, # Invalid item "X"
+
+        # SKIP and general failures
+        {"resp": "<ANSWER>SKIP</ANSWER>", "type": "MCQ_SINGLE_CORRECT", "expected": "SKIP"},
+        {"resp": "  <answer>  SKIP  </answer>  ", "type": "INTEGER", "expected": "SKIP"},
         {"resp": "No answer tag here.", "type": "MCQ_SINGLE_CORRECT", "expected": None},
         {"resp": "<answer></answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
         {"resp": "<answer>  </answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
-        {"resp": "<answer>abc</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
-        {"resp": "<answer>1, abc</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
-        {"resp": "<ANSWER>SKIP</ANSWER>", "type": "MCQ_SINGLE_CORRECT", "expected": "SKIP"},
-        {"resp": " <ANSWER>SKIP</ANSWER> ", "type": "INTEGER", "expected": "SKIP"},
-
-        # MCQ_MULTIPLE_CORRECT
-        {"resp": "<answer>1,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1, 3]},
-        {"resp": "<answer> 4 , 2 </answer> end", "type": "MCQ_MULTIPLE_CORRECT", "expected": [2, 4]},
-        {"resp": "<answer>\n 1,\n 4 \n</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1, 4]},
-        {"resp": "<answer>3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [3]}, # Single is valid for multi
-        {"resp": "<answer>3,1,4,1</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1, 3, 4]}, # Unique and sorted
-        {"resp": "<answer>1, </answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1]}, # Handles trailing comma
-        {"resp": "<answer>,2</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [2]}, # Handles leading comma
-        {"resp": "<answer>1,abc,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": None}, # Invalid content
-        {"resp": "<ANSWER>SKIP</ANSWER>", "type": "MCQ_MULTIPLE_CORRECT", "expected": "SKIP"},
-
-        # General / Edge cases
         {"resp": None, "type": "MCQ_SINGLE_CORRECT", "expected": None},
         {"resp": "", "type": "MCQ_SINGLE_CORRECT", "expected": None},
         {"resp": "<answer>5</answer>", "type": "UNKNOWN_TYPE", "expected": None}, # Unknown type
+        {"resp": "<answer>1,,2</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": ["1", "2"]}, # Handles empty item from double comma
     ]
 
-    print("\n--- Testing parse_llm_answer (with question_type) ---")
-    for case in test_cases:
+    print("\n--- Testing parse_llm_answer (revised) ---")
+    all_passed = True
+    for i, case in enumerate(test_cases):
         parsed = parse_llm_answer(case["resp"], case["type"])
-        print(f"Response: '{str(case['resp'])[:50]}...', Type: {case['type']} -> Parsed: {parsed} (Expected: {case['expected']})")
-        assert parsed == case["expected"], f"Mismatch for {case['resp']} with type {case['type']}"
+        if parsed == case["expected"]:
+            print(f"Test {i+1} PASSED: Response: '{str(case['resp'])[:50]}...', Type: {case['type']} -> Parsed: {parsed}")
+        else:
+            print(f"Test {i+1} FAILED: Response: '{str(case['resp'])[:50]}...', Type: {case['type']} -> Parsed: {parsed} (Expected: {case['expected']})")
+            all_passed = False
+    
+    if all_passed:
+        print("\nAll revised parse_llm_answer tests passed!")
+    else:
+        print("\nSome revised parse_llm_answer tests FAILED.")
 
     # Test API key loading (will raise error if .env or env var not set)
     # try: