mcqpy-core 0.2.2__tar.gz → 0.2.4__tar.gz

{mcqpy_core-0.2.2 → mcqpy_core-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mcqpy-core
-Version: 0.2.2
+Version: 0.2.4
 Summary: Core question, manifest, grading, analysis, and browser-safe runtime logic for MCQPy
 Author: Mads-Peter
 Author-email: Mads-Peter <machri@phys.au.dk>

{mcqpy_core-0.2.2 → mcqpy_core-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcqpy-core"
-version = "0.2.2"
+version = "0.2.4"
 description = "Core question, manifest, grading, analysis, and browser-safe runtime logic for MCQPy"
 readme = "README.md"
 authors = [

{mcqpy_core-0.2.2 → mcqpy_core-0.2.4}/src/mcqpy_core/cli/config.py

@@ -1,6 +1,7 @@
 """Quiz configuration management using Pydantic and YAML."""
 
 from pathlib import Path
+from sys import path
 from typing import Any, Literal
 
 from pydantic import BaseModel, Field, ConfigDict, field_validator, model_validator
@@ -142,6 +143,28 @@ class QuizConfig(BaseModel):
                 raise FileNotFoundError(f"Questions path does not exist: {resolved_path}")
 
         return data
+    
+    @model_validator(mode="before")
+    def selection_path_make_absolute(cls, data):
+        """Ensure that selection paths are relative to the config file's directory"""
+        selection = data.get("selection", None)
+        if selection is None:
+            return data
+
+        filters = selection.get("filters", None)
+
+        if filters is None:
+            return data
+
+        config_path = data.get("path")
+        for filter_name, filter_params in filters.items():
+            for name, param in filter_params.items():
+                if name.endswith("_path") and isinstance(param, str) and config_path is not None:
+                    absolute_path = (Path(config_path).parent / param).resolve()
+                    filter_params[name] = str(absolute_path)
+
+        return data
+
 
     def yaml_dump(self) -> str:
         """Dump the current configuration to a YAML string"""

{mcqpy_core-0.2.2 → mcqpy_core-0.2.4}/src/mcqpy_core/grading/__init__.py

@@ -7,9 +7,14 @@ from .types import (
     GradedSet,
     ParsedQuestion,
     ParsedSet,
-    get_grade_dataframe,
+    GradeResult,
+    GradeState,
+    ParseResult,
+    ParseState,
 )
 
+from .helpers import get_grade_dataframe
+
 __all__ = [
     "MCQGrader",
     "Rubric",
@@ -18,6 +23,10 @@ __all__ = [
     "ParsedSet",
     "GradedQuestion",
     "GradedSet",
+    "GradeResult",
+    "GradeState",
+    "ParseResult",
+    "ParseState",
     "get_grade_dataframe",
     "grade_parsed_set",
 ]

{mcqpy_core-0.2.2 → mcqpy_core-0.2.4}/src/mcqpy_core/grading/analysis/overall_analysis.py

@@ -8,8 +8,13 @@ from mcqpy_core.grading.types import GradedSet
 from scipy.stats import pearsonr
 from mcqpy_core.grading.analysis.utils import AnalysisFigure
 
+COLROMAP = plt.cm.plasma
+
 def get_points_array(graded_sets: list[GradedSet]):
-    point_arrays = np.zeros((len(graded_sets), len(graded_sets[0].graded_questions)))
+
+    n_questions = max(len(graded_set.graded_questions) for graded_set in graded_sets)
+
+    point_arrays = np.zeros((len(graded_sets), n_questions))
     for i, graded_set in enumerate(graded_sets):
         for j, question in enumerate(graded_set.graded_questions):
             point_arrays[i, j] = question.point_value
@@ -34,11 +39,15 @@ def correlation_analysis(graded_sets: list[GradedSet], output_dir: str | Path):
         correlations[qidx] = correlation
         p_values[qidx] = p_value
 
+
+    # Colors based on correlation
+    colors = COLROMAP((correlations - np.min(correlations)) / (np.max(correlations) - np.min(correlations)))
+
     fig, ax = plt.subplots(figsize=(8, 5))
     ax.bar(
         np.arange(1, n_questions + 1),
         correlations,
-        color="mediumpurple",
+        color=colors,
         alpha=0.7,
         edgecolor="black",
     )
@@ -108,11 +117,15 @@ def discrimination_index_analysis(graded_sets: list[GradedSet], output_dir: str
         D = (np.mean(q_points[high_group]) - np.mean(q_points[low_group])) / max_score
         discrimination_indices[qidx] = D
 
+
+    # Colors based on discrimination index
+    colors = COLROMAP((discrimination_indices - np.min(discrimination_indices)) / (np.max(discrimination_indices) - np.min(discrimination_indices)))
+
     fig, ax = plt.subplots(figsize=(8, 5))
     ax.bar(
         np.arange(1, n_questions + 1),
         discrimination_indices,
-        color="mediumpurple",
+        color=colors,
         alpha=0.7,
         edgecolor="black",
     )
@@ -135,6 +148,42 @@ def discrimination_index_analysis(graded_sets: list[GradedSet], output_dir: str
     )
 
 
+def quesstion_point_average_analysis(graded_sets: list[GradedSet], output_dir: str | Path):
+    point_array = get_points_array(graded_sets)
+
+    n_questions = point_array.shape[1]
+
+    average_points = np.mean(point_array, axis=0)
+
+    # Colors based on average points
+    colors = COLROMAP(average_points / np.max(point_array))
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    ax.bar(
+        np.arange(1, n_questions + 1),
+        average_points,
+        color=colors,
+        alpha=0.7,
+        edgecolor="black",
+    )
+    plt.xlabel("Question Number")
+    plt.ylabel("Average Points")
+    plt.title("Average Points per Question")
+
+    ax.set_xticks(np.arange(1, n_questions + 1))
+
+    plt.tight_layout()
+
+    name = "quiz_question_point_average_analysis.pdf"
+    output_path = output_dir / name
+
+    plt.savefig(output_path)
+    plt.close()
+    return AnalysisFigure(
+        name=name,
+        caption=r"\textbf{Average points per question}: Shows the average points earned on each question across all students.",
+    )
+
 def make_quiz_analysis(graded_sets: list[GradedSet], out_directory: str | Path):
     out_directory = Path(out_directory)
     out_directory.mkdir(parents=True, exist_ok=True)
@@ -144,10 +193,14 @@ def make_quiz_analysis(graded_sets: list[GradedSet], out_directory: str | Path):
     pd_fig = point_distribution_analysis(graded_sets, out_directory)
     figures.append(pd_fig)
 
+    avg_fig = quesstion_point_average_analysis(graded_sets, out_directory)
+    figures.append(avg_fig)
+
     corr_fig = correlation_analysis(graded_sets, out_directory)
     figures.append(corr_fig)
 
     di_fig = discrimination_index_analysis(graded_sets, out_directory)
     figures.append(di_fig)
 
+
     return figures

{mcqpy_core-0.2.2 → mcqpy_core-0.2.4}/src/mcqpy_core/grading/grader.py

@@ -1,13 +1,14 @@
 from pathlib import Path
 
 from mcqpy_core.manifest import Manifest
-from mcqpy_core.grading.types import GradedQuestion, GradedSet, ParsedSet
+from mcqpy_core.grading.types import GradedQuestion, GradedSet, ParsedSet, GradeResult, GradeState
 from mcqpy_core.grading.rubric import Rubric
 
 
-def grade_parsed_set(manifest: Manifest, rubric: Rubric, parsed_set: ParsedSet) -> GradedSet:
+def grade_parsed_set(manifest: Manifest, rubric: Rubric, parsed_set: ParsedSet) -> GradeResult:
     graded_set = GradedSet(student_info=parsed_set.student_info, graded_questions=[])
 
+    other_info = {}
     for parsed_question in parsed_set.questions:
         manifest_item = manifest.get_item_by_qid(parsed_question.qid)
 
@@ -19,17 +20,20 @@ def grade_parsed_set(manifest: Manifest, rubric: Rubric, parsed_set: ParsedSet)
             max_point_value=manifest_item.point_value,
         )
 
-        if sum(graded_question.student_answers) == 0:
-            raise Warning(
-                f"No answers provided for question {graded_question.qid} ({graded_question.slug})"
-            )
+        if sum(parsed_question.onehot) == 0:
+            message = f"No answers provided for question {parsed_question.qid} ({parsed_question.slug})."
+            other_info[parsed_question.qid] = message
 
         graded_question.point_value = rubric.score_question(graded_question)
         graded_set.graded_questions.append(graded_question)
 
     graded_set.points = sum(q.point_value for q in graded_set.graded_questions)
     graded_set.max_points = sum(q.max_point_value for q in graded_set.graded_questions)
-    return graded_set
+    return GradeResult(
+        state=GradeState.SUCCESS,
+        graded_set=graded_set,
+        other_info=other_info if other_info else None,
+    )
 
 
 class MCQGrader:
@@ -38,7 +42,7 @@ class MCQGrader:
         self.rubric = rubric
         self.regex_pattern = regex_pattern
 
-    def grade(self, parsed_set: ParsedSet | None = None, student_answer: str | Path = None) -> GradedSet:
+    def grade(self, parsed_set: ParsedSet | None = None, student_answer: str | Path = None) -> GradeResult:
         if parsed_set is None:
             raise ValueError("MCQGrader.grade requires a ParsedSet in mcqpy-core")
         return grade_parsed_set(self.manifest, self.rubric, parsed_set)

mcqpy_core-0.2.2/src/mcqpy_core/grading/types.py → mcqpy_core-0.2.4/src/mcqpy_core/grading/helpers.py

@@ -1,38 +1,4 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class ParsedQuestion:
-    qid: str
-    slug: str
-    answers: list[int]
-    onehot: list[int]
-
-
-@dataclass
-class ParsedSet:
-    student_info: dict[str, str]
-    questions: list[ParsedQuestion]
-    file: str | None = None
-
-
-@dataclass
-class GradedQuestion:
-    qid: str
-    slug: str
-    student_answers: list[int]
-    correct_answers: list[int]
-    max_point_value: int
-    point_value: int = 0
-
-
-@dataclass
-class GradedSet:
-    student_info: dict[str, str]
-    graded_questions: list[GradedQuestion]
-    points: int = 0
-    max_points: int = 0
-
+from mcqpy_core.grading.types import GradedSet
 
 def get_grade_dataframe(
     graded_sets: list[GradedSet], sort_key: str | None = None
@@ -47,12 +13,17 @@ def get_grade_dataframe(
 
     records = []
     for graded_set in graded_sets:
+
+        # Determine the number of questions the student gave an answer to
+        answered_questions = sum(1 in q.student_answers for q in graded_set.graded_questions)
+
         record = {}
         record.update(graded_set.student_info)
         record.update(
             {
                 "total_points": graded_set.points,
                 "max_points": graded_set.max_points,
+                "answered_questions": answered_questions,
             }
         )
 

mcqpy_core-0.2.4/src/mcqpy_core/grading/types.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from enum import Enum
+
+@dataclass
+class ParsedQuestion:
+    qid: str
+    slug: str
+    answers: list[int]
+    onehot: list[int]
+
+
+@dataclass
+class ParsedSet:
+    student_info: dict[str, str]
+    questions: list[ParsedQuestion]
+    file: str | None = None
+
+
+@dataclass
+class GradedQuestion:
+    qid: str
+    slug: str
+    student_answers: list[int]
+    correct_answers: list[int]
+    max_point_value: int
+    point_value: int = 0
+
+
+@dataclass
+class GradedSet:
+    student_info: dict[str, str]
+    graded_questions: list[GradedQuestion]
+    points: int = 0
+    max_points: int = 0
+
+class ParseState(Enum):
+    READER_ERROR = "Error reading PDF file. The file may be corrupted or not a valid PDF."
+    SUCCESS = "Successfully parsed PDF file."
+
+class GradeState(Enum):
+    READER_ERROR = ParseState.READER_ERROR.value
+    SUCCESS = "Successfully graded the parsed set."
+
+@dataclass
+class ParseResult:
+    state: ParseState
+    parsed_set: ParsedSet | None = None
+    error_message: str | None = None
+    other_info: dict | None = None
+
+@dataclass
+class GradeResult:
+    state: GradeState
+    graded_set: GradedSet | None = None
+    error_message: str | None = None
+    other_info: dict | None = None

mcqpy_core-0.2.2/src/mcqpy_core/cli/build.py

@@ -1,89 +0,0 @@
-"""
-CLI Build Command
-"""
-
-from pathlib import Path
-
-import rich_click as click
-from rich.pretty import Pretty
-from rich.console import Console
-
-from mcqpy_core.cli._selection import select_questions, _build_filter, build_filters
-from mcqpy_core.cli.config import QuizConfig
-from mcqpy_core.cli.main import main
-from mcqpy_pdf.compile import MultipleChoiceQuiz
-from mcqpy_core.manifest import Manifest
-from mcqpy_core.question import QuestionBank
-
-
-# Backward-compatible private alias kept for older tests/importers.
-_select_questions = select_questions
-
-
-def build_solution(questions, manifest, output_path: Path):
-    from mcqpy_pdf.compile.solution_pdf import SolutionPDF
-
-    solution_pdf = SolutionPDF(file=output_path, questions=questions, manifest=manifest)
-    solution_pdf.build(generate_pdf=True)
-
-@main.command(
-    name="build",
-    help="""Build the quiz PDF from question files based on the provided configuration.
-    This command reads the quiz configuration, selects questions from the question bank,
-    and generates the quiz PDF along with a solution PDF.
-""",
-)
-@click.option(
-    "-c",
-    "--config",
-    type=click.Path(exists=True, path_type=Path),
-    default="config.yaml",
-    help="Path to the config file",
-    show_default=True,
-)
-def build_command(config):
-    """ 
-    Build the quiz PDF from question files based on the provided configuration.
-    This command reads the quiz configuration, selects questions from the question bank,
-    and generates the quiz PDF along with a solution PDF.
-
-    ```
-    mcqpy build --config config.yaml
-    ```
-    """
-
-    config = QuizConfig.read_yaml(config)
-    question_bank = QuestionBank.from_directories(
-        config.questions_paths, seed=config.selection.seed
-    )
-    questions = select_questions(question_bank, config.selection)
-
-    console = Console()
-    console.print("[bold green]Quiz Configuration:[/bold green]")
-    console.print(Pretty(config))
-    console.print(
-        f"[bold green]Total questions in bank:[/bold green] {len(question_bank)}"
-    )
-    console.print(f"[bold green]Selected questions:[/bold green] {len(questions)}")
-
-    ## Paths:
-    for path in [config.root_directory, config.output_directory, config.submission_directory]:
-        if path and not path.exists():
-            path.mkdir(parents=True, exist_ok=True)  # pragma: no cover
-
-    mcq = MultipleChoiceQuiz(
-        file=config.file_path,
-        questions=questions,
-        front_matter=config.front_matter,
-        header_footer=config.header,
-    )
-
-    mcq.build(generate_pdf=True)
-
-    # Build solution PDF
-    manifest_path = mcq.get_manifest_path()
-    manifest = Manifest.load_from_file(manifest_path)
-    solution_output_path = (
-        config.output_directory / f"{config.file_name.replace('.pdf', '')}_solution.pdf"
-    )
-    build_solution(questions, manifest, solution_output_path)

mcqpy_core-0.2.2/src/mcqpy_core/cli/check_latex.py

@@ -1,31 +0,0 @@
-"""
-CLI command to check LaTeX installation and configuration.
-"""
-
-from mcqpy_core.cli import main
-
-@main.command('check-latex', help="Check LaTeX installation and configuration.")
-def check_latex_command():
-    """
-    Check if LaTeX is installed and properly configured. 
-    Provides the CLI command:
-    ```
-    mcqpy check-latex
-    ```
-    This command verifies the presence of LaTeX tools such as `pdflatex` and `latexmk`,
-    and attempts to compile a simple LaTeX document to ensure everything is functioning correctly.
-    """
-
-    from mcqpy_pdf.utils.check_latex import check_latex_installation
-    from rich.console import Console
-    
-    console = Console()    
-    success, details = check_latex_installation()
-    
-    if success:
-        console.print("[bold green]✓ LaTeX is properly installed![/bold green]")
-        console.print(f"[green]pdflatex version[/green]: {details['pdflatex'].version}")
-        console.print(f"[green]latexmk version[/green]: {details['latexmk'].version}")
-        console.print("[green]Compilation test passed successfully.[/green]")
-    else:
-        console.print(f"[bold red]✗ LaTeX installation issue: {details['error_message']}[/bold red]")

mcqpy_core-0.2.2/src/mcqpy_core/cli/grade.py

@@ -1,100 +0,0 @@
-"""Grade student submissions from a quiz."""
-
-import rich_click as click
-from mcqpy_core.cli.main import main
-from mcqpy_core.cli.config import QuizConfig
-from pathlib import Path
-
-from mcqpy_core.grading import MCQGrader, get_grade_dataframe
-from mcqpy_core.manifest import Manifest
-from mcqpy_core.grading.rubric import StrictRubric
-from rich.progress import track
-
-from mcqpy_core.question.question_bank import QuestionBank
-
-
-@main.command(
-    name="grade",
-    help="""Grade student submissions.
-Generates a grade report in the specified format (Excel or CSV).
-Students submissions are expected to be in submission directory specified in the config file.                            
-              """,
-)
-@click.option(
-    "-c",
-    "--config",
-    type=click.Path(exists=True, path_type=Path),
-    default="config.yaml",
-    help="Path to the config file",
-    show_default=True,
-)
-@click.option("-v", "--verbose", is_flag=True, help="Enable verbose output")
-@click.option(
-    "-f",
-    "--file-format",
-    type=click.Choice(["xlsx", "csv"]),
-    default="xlsx",
-    help="Output format for the grades",
-    show_default=True,
-)
-@click.option(
-    "-a",
-    "--analysis",
-    is_flag=True,
-    help="Generate question analysis reports",
-    default=False,
-)
-def grade_command(config, verbose: bool, file_format: str, analysis: bool):
-    """
-    Grade student submissions based on the provided configuration file.
-    Generates a grade report in the specified format (Excel or CSV).
-    Students submissions are expected to be in submission directory specified in the config file.
-
-    Provides the CLI command:
-    ```
-    mcqpy grade --config config.yaml --file-format xlsx --analysis
-    ```
-    """
-    # Load config
-    config = QuizConfig.read_yaml(config)
-    manifest_path = config.output_directory / f"{config.file_path.stem}_manifest.json"
-    manifest = Manifest.load_from_file(manifest_path)
-
-    # Read & Grade submissions
-    graded_sets = []
-    grader = MCQGrader(
-        manifest, StrictRubric(), regex_pattern=config.grading.anonymous_pattern
-    )
-    submissions = list(config.submission_directory.glob("*.pdf"))
-    for submission in track(
-        submissions,
-        description=f"Grading submissions ({len(submissions)})",
-        total=len(submissions),
-    ):
-        graded_set = grader.grade(submission)
-        graded_sets.append(graded_set)
-
-    # Export grades to dataframe
-    df = get_grade_dataframe(graded_sets, sort_key=config.grading.output_sort_key)
-    output_path = (config.root_directory / f"{config.file_path.stem}_grades.{file_format}")
-    if file_format == "xlsx":
-        df.to_excel(output_path, index=False)
-    elif file_format == "csv":
-        df.to_csv(output_path, index=False)
-
-    if analysis:
-        from mcqpy_pdf.analysis.report import QuizAnalysis
-
-        analysis_directory = config.root_directory / "analysis/"
-        analysis_directory.mkdir(exist_ok=True)
-
-        question_bank = QuestionBank.from_directories(config.questions_paths)
-        print(f"Question bank loaded for analysis - {len(question_bank)}")
-
-        quiz_analysis = QuizAnalysis(
-            graded_sets,
-            question_bank=question_bank,
-            output_dir=analysis_directory,
-            grading_config=config.grading,
-        )
-        quiz_analysis.build()