Custom Grading Script Examples

<Rubric Criterion Name>,<Score>

Correctness, 5 Style, 3

#!/bin/bash SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" python3 "$SCRIPT_DIR/grade.py" "$vocareumGradeFile" "$vocareumReportFile"

import sys import importlib.util  grade_file = sys.argv[1] report_file = sys.argv[2]  # Load the student's module spec = importlib.util.spec_from_file_location("student", "submit.py") student = importlib.util.module_from_spec(spec)  try:     spec.loader.exec_module(student) except Exception as e:     # Student code fails to load — give 0 and report the error     with open(grade_file, "w") as f:         f.write("Score, 0\n")     with open(report_file, "w") as f:         f.write(f"ERROR: Could not load submit.py\n{e}\n")     sys.exit(0)  # Define test cases: (a, b, expected_result) test_cases = [     (1, 2, 3),     (0, 0, 0),     (-1, 1, 0),     (100, 200, 300),     (-5, -10, -15), ]  passed = 0 total = len(test_cases) report_lines = []  for i, (a, b, expected) in enumerate(test_cases, 1):     try:         result = student.add(a, b)         if result == expected:             passed += 1             report_lines.append(f"Test {i}: add({a}, {b}) = {result}  PASSED")         else:             report_lines.append(f"Test {i}: add({a}, {b}) = {result}, expected {expected}  FAILED")     except Exception as e:         report_lines.append(f"Test {i}: add({a}, {b}) raised {type(e).__name__}: {e}  ERROR")  score = round(passed / total * 10)  with open(grade_file, "w") as f:     f.write(f"Score, {score}\n")  with open(report_file, "w") as f:     f.write(f"Passed {passed}/{total} tests\n\n")     f.write("\n".join(report_lines))

#!/bin/bash SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" python3 "$SCRIPT_DIR/grade.py" "$vocareumGradeFile" "$vocareumReportFile"

import sys import importlib.util  grade_file = sys.argv[1] report_file = sys.argv[2]  # Load student module spec = importlib.util.spec_from_file_location("student", "submit.py") student = importlib.util.module_from_spec(spec)  try:     spec.loader.exec_module(student)     calc = student.Calculator() except Exception as e:     with open(grade_file, "w") as f:         f.write("Addition, 0\nSubtraction, 0\nMultiplication, 0\nDivision, 0\n")     with open(report_file, "w") as f:         f.write(f"ERROR: Could not create Calculator instance\n{e}\n")     sys.exit(0)   def run_tests(method_name, test_cases, max_score):     """Run tests for a single method. Returns (score, report_lines)."""     passed = 0     lines = [f"--- {method_name} ---"]     method = getattr(calc, method_name, None)      if method is None:         lines.append(f"  Method '{method_name}' not found")         return 0, lines      for args, expected in test_cases:         try:             result = method(*args)             if abs(result - expected) < 1e-9:                 passed += 1                 lines.append(f"  {method_name}{args} = {result}  PASSED")             else:                 lines.append(f"  {method_name}{args} = {result}, expected {expected}  FAILED")         except Exception as e:             lines.append(f"  {method_name}{args} raised {type(e).__name__}: {e}  ERROR")      score = round(passed / len(test_cases) * max_score)     lines.append(f"  Score: {score}/{max_score}")     return score, lines   # Define tests per method results = {} report = []  s, r = run_tests("add", [((2, 3), 5), ((0, 0), 0), ((-1, 1), 0)], max_score=3) results["Addition"] = s report.extend(r)  s, r = run_tests("subtract", [((5, 3), 2), ((0, 0), 0), ((1, 5), -4)], max_score=3) results["Subtraction"] = s report.extend(r)  s, r = run_tests("multiply", [((3, 4), 12), ((0, 5), 0)], max_score=2) results["Multiplication"] = s report.extend(r)  s, r = run_tests("divide", [((10, 2), 5), ((7, 3), 7/3)], max_score=2) results["Division"] = s report.extend(r)  # Write grades with open(grade_file, "w") as f:     for criterion, score in results.items():         f.write(f"{criterion}, {score}\n")  # Write report total = sum(results.values()) with open(report_file, "w") as f:     f.write(f"Total: {total}/10\n\n")     f.write("\n".join(report))

#!/bin/bash SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"  # Copy test file to student workspace so pytest can find the student module cp "$SCRIPT_DIR/test_solution.py" .  # Run pytest with JSON output python3 -m pytest test_solution.py -v --tb=short > /tmp/pytest_output.txt 2>&1 PYTEST_EXIT=$?  # Parse results and write grades python3 "$SCRIPT_DIR/parse_results.py" "$vocareumGradeFile" "$vocareumReportFile" /tmp/pytest_output.txt $PYTEST_EXIT

from submit import bubble_sort, merge_sort  class TestBubbleSort:     def test_basic(self):         assert bubble_sort([3, 1, 2]) == [1, 2, 3]      def test_empty(self):         assert bubble_sort([]) == []      def test_single(self):         assert bubble_sort([1]) == [1]      def test_duplicates(self):         assert bubble_sort([3, 1, 3, 2]) == [1, 2, 3, 3]      def test_already_sorted(self):         assert bubble_sort([1, 2, 3, 4]) == [1, 2, 3, 4]  class TestMergeSort:     def test_basic(self):         assert merge_sort([3, 1, 2]) == [1, 2, 3]      def test_empty(self):         assert merge_sort([]) == []      def test_large(self):         import random         data = list(range(100))         random.shuffle(data)         assert merge_sort(data) == sorted(data)      def test_negative(self):         assert merge_sort([-3, -1, -2]) == [-3, -2, -1]      def test_mixed(self):         assert merge_sort([5, -2, 0, 3, -1]) == [-2, -1, 0, 3, 5]

import sys import re  grade_file = sys.argv[1] report_file = sys.argv[2] output_file = sys.argv[3] exit_code = int(sys.argv[4])  with open(output_file) as f:     output = f.read()  # Count passed and failed tests from pytest verbose output passed = len(re.findall(r" PASSED", output)) failed = len(re.findall(r" FAILED", output)) errors = len(re.findall(r" ERROR", output)) total = passed + failed + errors  score = round(passed / total * 10) if total > 0 else 0  with open(grade_file, "w") as f:     f.write(f"Score, {score}\n")  with open(report_file, "w") as f:     f.write(f"Passed {passed}/{total} tests (Score: {score}/10)\n\n")     f.write(output)

#!/bin/bash SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" python3 "$SCRIPT_DIR/grade.py" "$vocareumGradeFile" "$vocareumReportFile"

You are an expert code grader. You will be given a student's Python code submission. Evaluate the code thoroughly based on the following criteria:  1. **Correctness**: Does the code produce the expected output? Does it handle edge cases? 2. **Code Quality**: Is the code well-structured, readable, and following Python best practices? 3. **Efficiency**: Is the solution reasonably efficient in terms of time and space complexity? 4. **Error Handling**: Does the code handle potential errors gracefully? 5. **Documentation**: Are there appropriate comments or docstrings where needed?  Provide a detailed evaluation report and assign a score from 0 to 10.  You MUST respond with a valid JSON object in exactly this format and nothing else: {"report": "<detailed evaluation text>", "score": <integer 0-10>}

import json import sys import os import anthropic  # Configuration # ANTHROPIC_API_KEY and ANTHROPIC_BASE_URL are set automatically by Vocareum # when GenAI is enabled for your course — no hardcoded key is needed. api_key = os.environ.get("ANTHROPIC_API_KEY") base_url = os.environ.get("ANTHROPIC_BASE_URL") MODEL = "claude-sonnet-4-5-20250514" RUBRIC_CRITERION = "Score"   def read_file(path):     with open(path, "r") as f:         return f.read()   def parse_json_response(text):     """Extract and parse a JSON object from model response text."""     try:         return json.loads(text)     except json.JSONDecodeError:         pass     start = text.find("{")     end = text.rfind("}") + 1     if start != -1 and end > start:         raw = text[start:end]         try:             return json.loads(raw)         except json.JSONDecodeError:             pass         fixed = raw.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")         try:             return json.loads(fixed)         except json.JSONDecodeError:             pass     raise ValueError(f"Could not parse JSON from response:\n{text}")   def main():     script_dir = os.path.dirname(os.path.abspath(__file__))     grade_file = sys.argv[1]     report_file = sys.argv[2]      student_code = read_file("submit.py")     grade_prompt = read_file(os.path.join(script_dir, "grade_prompt.txt"))      client = anthropic.Anthropic(api_key=api_key, base_url=base_url)     response = client.messages.create(         model=MODEL,         max_tokens=4096,         system=grade_prompt,         messages=[             {"role": "user", "content": f"Here is the student's code:\n\n{student_code}"}         ],     )     result = parse_json_response(response.content[0].text)      with open(grade_file, "w") as f:         f.write(f"{RUBRIC_CRITERION}, {result['score']}\n")      with open(report_file, "w") as f:         f.write(result["report"])   if __name__ == "__main__":     main()

#!/bin/bash SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" python3 "$SCRIPT_DIR/grade.py" "$vocareumGradeFile" "$vocareumReportFile"

You are an expert Python code reviewer. You will be given a student's Python code. Evaluate ONLY the code quality (not correctness — that is tested separately).  Assess these aspects: 1. **Readability**: Clear variable names, logical structure, appropriate whitespace 2. **Pythonic style**: Use of Python idioms, built-in functions, list comprehensions where appropriate 3. **Error handling**: Input validation, graceful handling of edge cases 4. **Documentation**: Docstrings, type hints, comments where needed  Assign a score from 0 to 4.  You MUST respond with a valid JSON object in exactly this format and nothing else: {"report": "<code quality evaluation>", "score": <integer 0-4>}

import json import sys import os import importlib.util import anthropic  # ANTHROPIC_API_KEY and ANTHROPIC_BASE_URL are set automatically by Vocareum # when GenAI is enabled for your course — no hardcoded key is needed. api_key = os.environ.get("ANTHROPIC_API_KEY") base_url = os.environ.get("ANTHROPIC_BASE_URL") MODEL = "claude-sonnet-4-5-20250514"   def read_file(path):     with open(path, "r") as f:         return f.read()   def parse_json_response(text):     try:         return json.loads(text)     except json.JSONDecodeError:         pass     start = text.find("{")     end = text.rfind("}") + 1     if start != -1 and end > start:         raw = text[start:end]         try:             return json.loads(raw)         except json.JSONDecodeError:             pass         fixed = raw.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")         try:             return json.loads(fixed)         except json.JSONDecodeError:             pass     raise ValueError(f"Could not parse JSON from response:\n{text}")   # ── Part 1: Test-Based Correctness Grading ────────────────────────────  def run_correctness_tests():     """Run functional tests on student code. Returns (score, report_lines)."""     spec = importlib.util.spec_from_file_location("student", "submit.py")     student = importlib.util.module_from_spec(spec)      try:         spec.loader.exec_module(student)     except Exception as e:         return 0, [f"ERROR: Could not load submit.py — {e}"]      func = getattr(student, "top_k_words", None)     if func is None:         return 0, ["ERROR: Function 'top_k_words' not found in submit.py"]      tests = [         {             "name": "Basic functionality",             "args": ("the cat sat on the mat the cat", 2),             "check": lambda r: r[0][0] == "the" and r[0][1] == 3 and len(r) == 2,         },         {             "name": "k larger than unique words",             "args": ("hello world", 5),             "check": lambda r: len(r) == 2,         },         {             "name": "Empty string",             "args": ("", 3),             "check": lambda r: r == [],         },         {             "name": "Single word repeated",             "args": ("go go go", 1),             "check": lambda r: r[0][0] == "go" and r[0][1] == 3,         },         {             "name": "Punctuation handling",             "args": ("Hello, hello! HELLO.", 1),             "check": lambda r: r[0][1] == 3,         },         {             "name": "k equals zero",             "args": ("some words here", 0),             "check": lambda r: r == [],         },     ]      passed = 0     lines = ["=== Correctness Tests ==="]      for t in tests:         try:             result = func(*t["args"])             if t["check"](result):                 passed += 1                 lines.append(f"  {t['name']}: PASSED")             else:                 lines.append(f"  {t['name']}: FAILED (got {result})")         except Exception as e:             lines.append(f"  {t['name']}: ERROR — {type(e).__name__}: {e}")      score = round(passed / len(tests) * 6)     lines.append(f"\n  Correctness score: {score}/6 ({passed}/{len(tests)} tests passed)")     return score, lines   # ── Part 2: AI-Based Code Quality Grading ─────────────────────────────  def run_quality_review(student_code, prompt):     """Send code to Claude for quality review. Returns (score, report_lines)."""     client = anthropic.Anthropic(api_key=api_key, base_url=base_url)     response = client.messages.create(         model=MODEL,         max_tokens=2048,         system=prompt,         messages=[             {"role": "user", "content": f"Here is the student's code:\n\n{student_code}"}         ],     )     result = parse_json_response(response.content[0].text)     lines = [         "\n=== Code Quality Review (AI) ===",         result["report"],         f"\n  Code quality score: {result['score']}/4",     ]     return result["score"], lines   # ── Main ──────────────────────────────────────────────────────────────  def main():     script_dir = os.path.dirname(os.path.abspath(__file__))     grade_file = sys.argv[1]     report_file = sys.argv[2]      student_code = read_file("submit.py")     quality_prompt = read_file(os.path.join(script_dir, "quality_prompt.txt"))      # Run tests     correctness_score, correctness_report = run_correctness_tests()      # Run AI review     quality_score, quality_report = run_quality_review(student_code, quality_prompt)      total = correctness_score + quality_score      # Write grades (two separate rubric criteria)     with open(grade_file, "w") as f:         f.write(f"Correctness, {correctness_score}\n")         f.write(f"Code Quality, {quality_score}\n")      # Write combined report     with open(report_file, "w") as f:         f.write(f"Total Score: {total}/10\n\n")         f.write("\n".join(correctness_report))         f.write("\n")         f.write("\n".join(quality_report))   if __name__ == "__main__":     main()

You are an expert code grader. You will be given a student's Python code submission. Evaluate the code based on correctness, code quality, and efficiency. Assign a score from 0 to 10.  You MUST respond with a valid JSON object in exactly this format and nothing else: {"report": "<detailed evaluation text>", "score": <integer 0-10>}

Evaluate the code and give a score.

Evaluate the code based on: 1. Correctness: Does it handle empty input, negative numbers, and    duplicate values? 2. Efficiency: Is it O(n log n) or better for sorting? 3. Style: Does it use descriptive variable names and avoid magic numbers?

The student was asked to implement a binary search function that: - Takes a sorted list and a target value - Returns the index if found, -1 otherwise - Must use iterative (not recursive) approach

Scoring guide: - 9-10: Fully correct, clean code, handles all edge cases, well documented - 7-8: Mostly correct with minor issues, reasonable code quality - 5-6: Partially correct, some edge cases missed, code works but has         quality issues - 3-4: Significant correctness problems, poor structure - 1-2: Barely functional, major errors - 0: No meaningful attempt or code does not run

You MUST respond with a valid JSON object in exactly this format and nothing else: {"report": "<detailed evaluation text>", "score": <integer 0-10>}

You are an expert code grading reconciler. You will be given three independent evaluation reports of a student's Python code submission. Each report includes a detailed evaluation and a score from 0 to 10.  Your task: 1. Review all three evaluations carefully. 2. Identify points of agreement and disagreement. 3. Produce a final consolidated report. 4. Assign a final score from 0 to 10 that fairly reflects the student's    work, considering all three evaluations.  If the scores differ significantly, explain your reasoning for the final score.  You MUST respond with a valid JSON object in exactly this format and nothing else: {"report": "<final consolidated evaluation text>", "score": <integer 0-10>}

cd /voc/work bash /voc/scripts/grade.sh

cat "$vocareumGradeFile"    # Should show: Score, 7  (or your criteria) cat "$vocareumReportFile"   # Should show the feedback report