Remote Education Grading Tool Comparison for Teachers Managing Large Online Classes 2026

import requests

CANVAS_API_URL = "https://<institution>.instructure.com/api/v1"
CANVAS_TOKEN = "your_api_token"

headers = {"Authorization": f"Bearer {CANVAS_TOKEN}"}

def get_pending_submissions(course_id, assignment_id):
    """Fetch all pending submissions for an assignment."""
    url = f"{CANVAS_API_URL}/courses/{course_id}/assignments/{assignment_id}/submissions"
    params = {"per_page": 100, "state": "submitted"}

    all_submissions = []
    while url:
        response = requests.get(url, headers=headers, params=params)
        all_submissions.extend(response.json())
        url = response.links.get("next", {}).get("url")

    return all_submissions

def bulk_grade_submissions(course_id, assignment_id, grades_dict):
    """Post grades for multiple students at once."""
    url = f"{CANVAS_API_URL}/courses/{course_id}/assignments/{assignment_id}/submissions/update_grades"

    submissions = [
        {"posted_grade": grade, "student_id": student_id}
        for student_id, grade in grades_dict.items()
    ]

    response = requests.post(url, headers=headers, json={"grade_entries": submissions})
    return response.json()

import requests
import time

GRADESCOPE_API_URL = "https://www.gradescope.com/api/v1"
GRADESCOPE_TOKEN = "your_access_token"

headers = {"Authorization": f"Token token={GRADESCOPE_TOKEN}"}

def process_assignment_submissions(course_id, assignment_id, grading_logic):
    """Fetch submissions and apply custom grading logic."""
    # Get all submissions
    submissions_url = f"{GRADESCOPE_API_URL}/courses/{course_id}/assignments/{assignment_id}/submissions"
    response = requests.get(submissions_url, headers=headers)

    if response.status_code != 200:
        raise Exception(f"API error: {response.text}")

    submissions = response.json()["submissions"]
    results = []

    for submission in submissions:
        # Apply custom grading function
        score, feedback = grading_logic(submission)

        # Submit grade via API
        grade_url = f"{GRADESCOPE_API_URL}/submissions/{submission['id']}"
        grade_data = {
            "score": score,
            "feedback": feedback,
            "published": True
        }

        post_response = requests.put(grade_url, headers=headers, json=grade_data)
        results.append({"student": submission["student"]["email"], "status": post_response.status_code})
        time.sleep(0.5)  # Rate limiting

    return results

def auto_grade_code_submission(submission):
    """Example grading logic for code submissions."""
    # Extract submission content
    code_files = submission.get("attachments", [])

    # Run automated tests (pseudocode)
    test_results = run_test_suite(code_files)

    score = test_results["passed_count"] / test_results["total_count"] * 100
    feedback = f"Tests passed: {test_results['passed_count']}/{test_results['total_count']}"

    return score, feedback

import github
import subprocess
import json

def clone_student_submission(org_name, repo_name, student_email):
    """Clone a student's repository for grading."""
    g = github.Github("your_github_token")
    org = g.get_organization(org_name)
    repo = org.get_repo(repo_name)

    # Get the latest commit hash
    commits = repo.get_commits()
    latest_commit = commits[0].sha

    # Clone URL for automated processing
    clone_url = f"https://{student_email}@github.com/{org_name}/{repo_name}.git"

    return {
        "repo_url": clone_url,
        "commit_sha": latest_commit,
        "clone_command": f"git clone {clone_url} /tmp/{student_email}"
    }

def automated_code_grading(repo_path, test_command, max_score=100):
    """Run automated tests and capture results."""
    try:
        # Run test command
        result = subprocess.run(
            test_command,
            shell=True,
            cwd=repo_path,
            capture_output=True,
            timeout=300
        )

        # Parse test output (example for pytest)
        if "pytest" in test_command:
            # Extract score from test results
            output = result.stdout.decode("utf-8")
            # Custom parsing logic based on test framework output
            score = parse_pytest_output(output, max_score)
        else:
            score = max_score if result.returncode == 0 else 0

        return {
            "score": score,
            "passed": result.returncode == 0,
            "output": result.stdout.decode("utf-8")[:1000]
        }

    except subprocess.TimeoutExpired:
        return {"score": 0, "passed": False, "output": "Timeout exceeded"}
    except Exception as e:
        return {"score": 0, "passed": False, "output": str(e)}

def post_grade_to_lms(student_id, assignment_id, score, feedback, lms_config):
    """Post grade to Canvas, Moodle, or other LMS."""
    # Implementation depends on your LMS
    pass