ygrader 2.5.2__tar.gz → 2.6.0__tar.gz

{ygrader-2.5.2/ygrader.egg-info → ygrader-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.5.2
+Version: 2.6.0
 Summary: Grading scripts used in BYU's Electrical and Computer Engineering Department
 Home-page: https://github.com/byu-cpe/ygrader
 Author: Jeff Goeders

{ygrader-2.5.2 → ygrader-2.6.0}/setup.py

@@ -4,7 +4,7 @@ setup(
     name="ygrader",
     packages=["ygrader"],
     package_data={"ygrader": ["*.ahk"]},
-    version="2.5.2",
+    version="2.6.0",
     description="Grading scripts used in BYU's Electrical and Computer Engineering Department",
     author="Jeff Goeders",
     author_email="jeff.goeders@gmail.com",

{ygrader-2.5.2 → ygrader-2.6.0}/ygrader/__init__.py

@@ -8,3 +8,4 @@ from .grading_item_config import (
     LearningSuiteColumnParseError,
 )
 from .feedback import assemble_grades
+from .remote import run_remote_build, RemoteBuildError

{ygrader-2.5.2 → ygrader-2.6.0}/ygrader/grader.py

@@ -1,14 +1,20 @@
 """Main ygrader module"""
 
+# pylint: disable=too-many-lines
+
 import enum
 import inspect
 import os
 import pathlib
 import re
 import shutil
+import sys
+import tempfile
+import threading
 import time
 import zipfile
 from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Callable
 
 import pandas
@@ -173,7 +179,10 @@ class Grader:
             fcn_args_dict=grading_fcn_args_dict,
         )
         _verify_callback_fcn(
-            grading_fcn, item, fcn_extra_args_dict=grading_fcn_args_dict
+            grading_fcn,
+            item,
+            fcn_extra_args_dict=grading_fcn_args_dict,
+            github_configured=(self.code_source == CodeSource.GITHUB),
         )
         self.items.append(item)
 
@@ -332,6 +341,7 @@ class Grader:
         dry_run_first=False,
         dry_run_all=False,
         workflow_hash=None,
+        parallel_workers=None,
     ):
         """
         This can be used to set other options for the grader.
@@ -371,6 +381,10 @@ class Grader:
             (Optional) Expected hash of the GitHub workflow file. If provided, the workflow file will be verified
             before grading each student. If the hash doesn't match, a warning will be displayed indicating
             the student may have modified the workflow system.
+        parallel_workers: int or None
+            If set to an integer, process students in parallel using that many workers.
+            Only works with build_only mode since interactive grading cannot be parallelized.
+            Default is None (sequential processing).
         """
         self.format_code = format_code
         self.build_only = build_only
@@ -378,11 +392,16 @@ class Grader:
         self.allow_rebuild = allow_rebuild
         self.allow_rerun = allow_rerun
         self.workflow_hash = workflow_hash
+        self.parallel_workers = parallel_workers
         if prep_fcn and not isinstance(prep_fcn, Callable):
             error("The 'prep_fcn' argument must provide a callable function pointer")
         self.prep_fcn = prep_fcn
         if prep_fcn:
-            _verify_callback_fcn(prep_fcn, item=None)
+            _verify_callback_fcn(
+                prep_fcn,
+                item=None,
+                github_configured=(self.code_source == CodeSource.GITHUB),
+            )
 
         if not (self.allow_rebuild or self.allow_rerun):
             error("At least one of allow_rebuild and allow_rerun needs to be True.")
@@ -392,6 +411,9 @@ class Grader:
         self.dry_run_first = dry_run_first
         self.dry_run_all = dry_run_all
 
+        if parallel_workers is not None and not build_only:
+            error("parallel_workers is only supported when build_only=True")
+
     def _validate_config(self):
         """Check that everything has been configured before running"""
         # Check that callback function has been set up
@@ -422,30 +444,32 @@ class Grader:
         # Print starting message
         print_color(TermColors.BLUE, "Running grader for", self.lab_name)
 
-        # Read in CSV and validate.  Print # students who need a grade
+        # Read in CSV and validate.
         student_grades_df = grades_csv.parse_and_check(
             self.class_list_csv_path, self._get_all_csv_cols_to_grade()
         )
 
-        # Filter by students who need a grade
-        grades_needed_df = grades_csv.filter_need_grade(
-            student_grades_df, self._get_all_csv_cols_to_grade()
-        )
-        print_color(
-            TermColors.BLUE,
-            str(
-                grades_csv.filter_need_grade(
-                    grades_needed_df, self._get_all_csv_cols_to_grade()
-                ).shape[0]
-            ),
-            "students need to be graded.",
-        )
-
         # Add column for group name to DataFrame.
         # For github, students are grouped by their Github repo URL.
         # For learning suite, if set_groups() was never called, then  students are placed in groups by Net ID (so every student in their own group)
         grouped_df = self._group_students(student_grades_df)
 
+        # Count students who need grading based on deductions file
+        students_need_grading = 0
+        for _, row in grouped_df.iterrows():
+            net_ids = grades_csv.get_net_ids(row)
+            num_need_grade = sum(
+                item.num_grades_needed_deductions(net_ids) for item in self.items
+            )
+            if num_need_grade > 0:
+                students_need_grading += 1
+
+        print_color(
+            TermColors.BLUE,
+            str(students_need_grading),
+            "students need to be graded.",
+        )
+
         # Create working path directory
         self._create_work_path()
 
@@ -456,9 +480,19 @@ class Grader:
             # sys.exit(0)
             # grouped_df = self._add_submitted_zip_path_column(grouped_df)
 
-        self._run_grading(student_grades_df, grouped_df)
+        if self.parallel_workers is not None:
+            self._run_grading_parallel(student_grades_df, grouped_df)
+        else:
+            self._run_grading_sequential(student_grades_df, grouped_df)
 
     def _run_grading(self, student_grades_df, grouped_df):
+        """Alias for backwards compatibility."""
+        if self.parallel_workers is not None:
+            self._run_grading_parallel(student_grades_df, grouped_df)
+        else:
+            self._run_grading_sequential(student_grades_df, grouped_df)
+
+    def _run_grading_sequential(self, student_grades_df, grouped_df):
         # Sort by last name for consistent grading order
         # After groupby().agg(list), "Last Name" is a list, so we sort by the first element
         sorted_df = grouped_df.sort_values(
@@ -519,6 +553,10 @@ class Grader:
             callback_args["first_names"] = first_names
             callback_args["last_names"] = last_names
             callback_args["net_ids"] = net_ids
+            callback_args["output"] = sys.stdout  # Default to stdout in sequential mode
+            if self.code_source == CodeSource.GITHUB:
+                callback_args["repo_url"] = row["github_url"]
+                callback_args["tag"] = self.github_tag
             if "Section Number" in row:
                 callback_args["section"] = row["Section Number"]
             if "Course Homework ID" in row:
@@ -561,6 +599,193 @@ class Grader:
             prev_idx = idx
             idx += 1
 
+    def _process_single_student_build(self, row):
+        """Process a single student for parallel build mode. Returns (net_ids, success, message, log_path)."""
+        first_names = grades_csv.get_first_names(row)
+        last_names = grades_csv.get_last_names(row)
+        net_ids = grades_csv.get_net_ids(row)
+
+        # Check if student/group needs grading
+        num_group_members_need_grade_per_item = [
+            item.num_grades_needed_deductions(net_ids) for item in self.items
+        ]
+
+        if sum(num_group_members_need_grade_per_item) == 0:
+            return (net_ids, None, "Already graded", None)  # None indicates skip
+
+        # Create a temp file to capture output early so all messages go to it
+        # pylint: disable-next=consider-using-with
+        log_file = tempfile.NamedTemporaryFile(
+            mode="w", delete=False, suffix=".log", prefix=f"ygrader_{net_ids[0]}_"
+        )
+        log_path = log_file.name
+
+        student_work_path = self.work_path / utils.names_to_dir(
+            first_names, last_names, net_ids
+        )
+
+        # Build student info dict to pass to helper
+        student_info = {
+            "row": row,
+            "net_ids": net_ids,
+            "first_names": first_names,
+            "last_names": last_names,
+            "student_work_path": student_work_path,
+        }
+
+        # Run the build steps and capture any failure
+        success, message = self._run_build_steps(student_info, log_file)
+
+        log_file.close()
+        return (net_ids, success, message, log_path)
+
+    def _run_build_steps(  # pylint: disable=too-many-return-statements
+        self, student_info, log_file
+    ):
+        """Run the build steps for a single student. Returns (success, message)."""
+        row = student_info["row"]
+        student_work_path = student_info["student_work_path"]
+
+        # Get student code
+        try:
+            success = self._get_student_code(row, student_work_path, output=log_file)
+            if not success:
+                return (False, "Failed to get student code")
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            return (False, f"Error getting code: {e}")
+
+        # Format student code
+        if self.format_code:
+            try:
+                utils.clang_format_code(student_work_path)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                return (False, f"Error formatting code: {e}")
+
+        callback_args = {}
+        callback_args["lab_name"] = self.lab_name
+        callback_args["student_code_path"] = student_work_path
+        callback_args["run"] = False  # build_only mode
+        callback_args["first_names"] = student_info["first_names"]
+        callback_args["last_names"] = student_info["last_names"]
+        callback_args["net_ids"] = student_info["net_ids"]
+        if self.code_source == CodeSource.GITHUB:
+            callback_args["repo_url"] = row["github_url"]
+            callback_args["tag"] = self.github_tag
+        if "Section Number" in row:
+            callback_args["section"] = row["Section Number"]
+        if "Course Homework ID" in row:
+            callback_args["homework_id"] = row["Course Homework ID"]
+
+        if self.prep_fcn is not None:
+            try:
+                self.prep_fcn(
+                    **callback_args,
+                    build=True,
+                )
+            except CallbackFailed as e:
+                return (False, f"Prep failed: {e}")
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                return (False, f"Prep error: {e}")
+
+        # Call the grading callback for each item (with build=True, run=False for build_only mode)
+        for item in self.items:
+            # Add item-specific args
+            item_callback_args = callback_args.copy()
+            item_callback_args["item_name"] = item.item_name
+            if item.fcn_args_dict:
+                item_callback_args.update(item.fcn_args_dict)
+
+            try:
+                item.fcn(
+                    **item_callback_args,
+                    points=item.max_points,
+                    build=True,
+                    output=log_file,  # Redirect output to temp file
+                )
+            except CallbackFailed as e:
+                return (False, f"Grading callback failed: {e}")
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                return (False, f"Grading callback error: {e}")
+
+        return (True, "Success")
+
+    def _run_grading_parallel(self, _student_grades_df, grouped_df):
+        """Run grading in parallel for build_only mode."""
+        # Sort by last name for consistent ordering
+        sorted_df = grouped_df.sort_values(
+            by="Last Name", key=lambda x: x.apply(lambda names: names[0].lower())
+        )
+
+        rows_list = list(sorted_df.iterrows())
+        total = len(rows_list)
+
+        print_color(
+            TermColors.BLUE,
+            f"Running parallel build with {self.parallel_workers} workers for {total} students...\n",
+        )
+
+        success_count = 0
+        fail_count = 0
+        skip_count = 0
+
+        # Use a lock for thread-safe printing
+        print_lock = threading.Lock()
+
+        def process_and_report(row):
+            nonlocal success_count, fail_count, skip_count
+            net_ids, success, message, log_path = self._process_single_student_build(
+                row
+            )
+            net_id_str = (
+                ", ".join(net_ids) if isinstance(net_ids, list) else str(net_ids)
+            )
+
+            with print_lock:
+                if success is None:
+                    skip_count += 1
+                    # Don't print skipped students
+                elif success:
+                    success_count += 1
+                    if log_path:
+                        print_color(
+                            TermColors.GREEN,
+                            f"[DONE] {net_id_str} - {message} (see {log_path})",
+                        )
+                    else:
+                        print_color(
+                            TermColors.GREEN, f"[DONE] {net_id_str} - {message}"
+                        )
+                else:
+                    fail_count += 1
+                    if log_path:
+                        print_color(
+                            TermColors.RED,
+                            f"[FAIL] {net_id_str} - {message} (see {log_path})",
+                        )
+                    else:
+                        print_color(TermColors.RED, f"[FAIL] {net_id_str} - {message}")
+
+        with ThreadPoolExecutor(max_workers=self.parallel_workers) as executor:
+            futures = []
+            for i, (_, row) in enumerate(rows_list):
+                futures.append(executor.submit(process_and_report, row))
+                # Stagger thread starts to avoid overwhelming SSH servers
+                if i < self.parallel_workers:
+                    time.sleep(0.5)
+
+            # Wait for all to complete
+            for future in as_completed(futures):
+                try:
+                    future.result()
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    with print_lock:
+                        print_color(TermColors.RED, f"[ERROR] Unexpected error: {e}")
+
+        print_color(
+            TermColors.BLUE,
+            f"\nCompleted: {success_count} success, {fail_count} failed, {skip_count} skipped",
+        )
+
     def _unzip_submissions(self):
         with zipfile.ZipFile(self.learning_suite_submissions_zip_path, "r") as f:
             for zip_info in f.infolist():
@@ -638,31 +863,38 @@ class Grader:
         # Group students into their groups
         return df.groupby(groupby_column).agg(list).reset_index()
 
-    def _get_student_code(self, row, student_work_path):
+    def _get_student_code(self, row, student_work_path, output=None):
         if self.code_source == CodeSource.GITHUB:
-            return self._get_student_code_github(row, student_work_path)
+            return self._get_student_code_github(row, student_work_path, output=output)
 
         # else:
-        return self._get_student_code_learning_suite(row, student_work_path)
+        return self._get_student_code_learning_suite(
+            row, student_work_path, output=output
+        )
 
-    def _get_student_code_github(self, row, student_work_path):
+    def _get_student_code_github(self, row, student_work_path, output=None):
+        if output is None:
+            output = sys.stdout
         student_work_path.mkdir(parents=True, exist_ok=True)
 
         # Clone student repo
-        print("Student repo url: " + row["github_url"])
+        print("Student repo url: " + row["github_url"], file=output)
         if not student_repos.clone_repo(
-            row["github_url"], self.github_tag, student_work_path
+            row["github_url"], self.github_tag, student_work_path, output=output
         ):
             return False
         return True
 
-    def _get_student_code_learning_suite(self, row, student_work_path):
+    def _get_student_code_learning_suite(self, row, student_work_path, output=None):
+        if output is None:
+            output = sys.stdout
         print(
-            "Extracting submitted files for", grades_csv.get_concated_names(row), "..."
+            f"Extracting submitted files for {grades_csv.get_concated_names(row)}...",
+            file=output,
         )
         if student_work_path.is_dir() and not directory_is_empty(student_work_path):
             # Code already extracted from Zip, return
-            print("  Files already extracted previously.")
+            print("  Files already extracted previously.", file=output)
             return True
 
         student_work_path.mkdir(parents=True, exist_ok=True)
@@ -769,7 +1001,7 @@ class Grader:
             self.work_path.mkdir(exist_ok=True, parents=True)
 
 
-def _verify_callback_fcn(fcn, item, fcn_extra_args_dict=None):
+def _verify_callback_fcn(fcn, item, fcn_extra_args_dict=None, github_configured=False):
     callback_args = [
         "lab_name",
         "item_name",
@@ -783,6 +1015,12 @@ def _verify_callback_fcn(fcn, item, fcn_extra_args_dict=None):
     if item:
         if item.max_points:
             callback_args.append("max_points")
+    if github_configured:
+        callback_args.append("repo_url")
+        callback_args.append("tag")
+
+    # output is always provided (sys.stdout in sequential, temp file in parallel)
+    callback_args.append("output")
 
     callback_args_optional = [
         "section",

ygrader-2.6.0/ygrader/remote.py

@@ -0,0 +1,257 @@
+"""Module for running builds on remote machines via SSH."""
+
+import pathlib
+import subprocess
+import sys
+from typing import List, Optional, TextIO, Tuple
+
+
+class RemoteBuildError(Exception):
+    """Exception raised when a remote build operation fails."""
+
+    def __init__(self, message: str, command_output: str = ""):
+        self.message = message
+        self.command_output = command_output
+        super().__init__(self.message)
+
+    def __str__(self):
+        if self.command_output:
+            return f"{self.message}\n\nCommand output:\n{self.command_output}"
+        return self.message
+
+
+def run_remote_build(  # pylint: disable=too-many-positional-arguments
+    remote_host: str,
+    remote_work_path: str,
+    repo_url: str,
+    tag: str,
+    commands: List[Tuple[str, List[str]]],
+    files_to_copy: List[str],
+    student_code_path: pathlib.Path,
+    cleanup: bool = True,
+    use_username_subdir: bool = True,
+    env_setup: str = "",
+    output: Optional[TextIO] = None,
+) -> List[str]:
+    """Run a build on a remote machine and copy files back.
+
+    This function:
+    1. Connects to the remote host via SSH
+    2. Clones the student repo at the specified tag
+    3. Runs the provided commands in sequence
+    4. Copies the specified files back to the local machine
+    5. Optionally cleans up the remote clone
+
+    Args:
+        remote_host: SSH hostname (e.g., "server.example.com" or "user@server")
+        remote_work_path: Base path on remote machine where repo will be cloned
+            (e.g., "/tmp/grading"). By default, a subdirectory named after the
+            remote username will be created under this path.
+        repo_url: Git repository URL to clone
+        tag: Git tag to checkout after cloning
+        commands: List of (relative_path, command_list) tuples. Each command
+            will be run from the specified path relative to the repo root.
+            Example: [("lab_tools/adder", ["make", "sim"])]
+        files_to_copy: List of file paths relative to repo root to copy back
+        student_code_path: Local student code directory to copy files into
+        cleanup: If True (default), delete the remote clone after completion
+        use_username_subdir: If True (default), create a subdirectory under
+            remote_work_path named after the remote user's username. This helps
+            avoid conflicts when multiple users share the same work path.
+        env_setup: Optional shell command(s) to run before each command to set up
+            the environment (e.g., "source /path/to/settings.sh"). This is prepended
+            to each command with "&&".
+        output: Optional file object to write command output to. If None, uses
+            sys.stdout.
+
+    Returns:
+        List of command output strings (stdout + stderr combined) for each command
+
+    Raises:
+        RemoteBuildError: If SSH connection fails, clone fails, any command fails,
+            or file copy fails
+    """
+    if output is None:
+        output = sys.stdout
+
+    # Extract repo name from URL for the clone directory
+    # Handle both https://github.com/org/repo.git and git@github.com:org/repo.git
+    repo_name = repo_url.rstrip("/").rstrip(".git").split("/")[-1]
+    if ":" in repo_name:
+        repo_name = repo_name.split(":")[-1].split("/")[-1]
+
+    command_outputs = []
+    remote_repo_path = None  # Initialize to None for cleanup check
+
+    try:
+        # Test SSH connection and get username if needed
+        _run_ssh_command(remote_host, ["echo", "SSH connection successful"])
+
+        # Determine the actual work path (with optional username subdirectory)
+        if use_username_subdir:
+            username = _run_ssh_command(remote_host, ["whoami"]).strip()
+            actual_work_path = f"{remote_work_path}/{username}"
+        else:
+            actual_work_path = remote_work_path
+
+        remote_repo_path = f"{actual_work_path}/{repo_name}"
+
+        # Create work directory and clone repo
+        clone_commands = [
+            f"mkdir -p {actual_work_path}",
+            f"rm -rf {remote_repo_path}",  # Clean any previous clone
+            f"git clone --depth 1 --branch {tag} {repo_url} {remote_repo_path}",
+        ]
+        for cmd in clone_commands:
+            print(f"[SSH] {cmd}", file=output)
+            cmd_output = _run_ssh_command(remote_host, [cmd])
+            if cmd_output.strip():
+                print(cmd_output, file=output)
+
+        # Run each command in sequence
+        for relative_path, cmd_list in commands:
+            work_dir = (
+                f"{remote_repo_path}/{relative_path}"
+                if relative_path
+                else remote_repo_path
+            )
+            # Build the full command with cd and optional env setup
+            cmd_str = " ".join(cmd_list)
+            if env_setup:
+                full_cmd = f"{env_setup} && cd {work_dir} && {cmd_str}"
+            else:
+                full_cmd = f"cd {work_dir} && {cmd_str}"
+            print(f"[SSH] cd {work_dir} && {cmd_str}", file=output)
+            cmd_output = _run_ssh_command(remote_host, [full_cmd])
+            if cmd_output.strip():
+                print(cmd_output, file=output)
+            command_outputs.append(cmd_output)
+
+        # Copy files back using scp
+        for file_path in files_to_copy:
+            remote_file = f"{remote_repo_path}/{file_path}"
+            local_file = student_code_path / file_path
+
+            # Create local directory if needed
+            local_file.parent.mkdir(parents=True, exist_ok=True)
+
+            print(f"[SCP] {remote_file} -> {local_file}", file=output)
+            _run_scp_command(remote_host, remote_file, local_file)
+
+    finally:
+        # Cleanup remote directory if requested
+        if cleanup and remote_repo_path is not None:
+            try:
+                _run_ssh_command(remote_host, [f"rm -rf {remote_repo_path}"])
+            except RemoteBuildError:
+                pass  # Ignore cleanup errors
+
+    return command_outputs
+
+
+def _run_ssh_command(remote_host: str, command: List[str]) -> str:
+    """Run a command on the remote host via SSH.
+
+    Args:
+        remote_host: SSH hostname
+        command: Command and arguments to run
+
+    Returns:
+        Combined stdout and stderr output
+
+    Raises:
+        RemoteBuildError: If the SSH command fails
+    """
+    ssh_cmd = [
+        "ssh",
+        "-x",  # Disable X11 forwarding
+        "-o",
+        "BatchMode=yes",  # Fail if password is required
+        "-o",
+        "StrictHostKeyChecking=accept-new",  # Accept new host keys
+        "-o",
+        "ConnectTimeout=10",
+        remote_host,
+    ] + command
+
+    try:
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=300,  # 5 minute timeout per command
+        )
+    except subprocess.TimeoutExpired as e:
+        raise RemoteBuildError(
+            f"SSH command timed out: {' '.join(command)}",
+            e.stdout or "",
+        ) from e
+    except FileNotFoundError as e:
+        raise RemoteBuildError(
+            "SSH client not found. Is OpenSSH installed?",
+        ) from e
+
+    output = result.stdout + result.stderr
+
+    if result.returncode != 0:
+        raise RemoteBuildError(
+            f"SSH command failed with exit code {result.returncode}: {' '.join(command)}",
+            output,
+        )
+
+    return output
+
+
+def _run_scp_command(
+    remote_host: str, remote_path: str, local_path: pathlib.Path
+) -> None:
+    """Copy a file or directory from the remote host via SCP.
+
+    Args:
+        remote_host: SSH hostname
+        remote_path: Path to file or directory on remote host
+        local_path: Local path to copy to
+
+    Raises:
+        RemoteBuildError: If the SCP command fails
+    """
+    scp_cmd = [
+        "scp",
+        "-r",  # Recursive copy (works for both files and directories)
+        "-o",
+        "BatchMode=yes",
+        "-o",
+        "StrictHostKeyChecking=accept-new",
+        "-o",
+        "ConnectTimeout=10",
+        "-o",
+        "ForwardX11=no",
+        f"{remote_host}:{remote_path}",
+        str(local_path),
+    ]
+
+    try:
+        result = subprocess.run(
+            scp_cmd,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=300,  # 5 minute timeout for potentially large directory copies
+        )
+    except subprocess.TimeoutExpired as e:
+        raise RemoteBuildError(
+            f"SCP timed out copying: {remote_path}",
+            e.stdout or "",
+        ) from e
+    except FileNotFoundError as e:
+        raise RemoteBuildError(
+            "SCP client not found. Is OpenSSH installed?",
+        ) from e
+
+    if result.returncode != 0:
+        output = result.stdout + result.stderr
+        raise RemoteBuildError(
+            f"Failed to copy: {remote_path}",
+            output,
+        )

ygrader-2.6.0/ygrader/student_repos.py

@@ -0,0 +1,239 @@
+"""Manages student repositories when using Github sumission system"""
+
+import shutil
+import subprocess
+import sys
+import re
+import tempfile
+
+from .utils import print_color, TermColors
+
+
+def clone_repo(git_path, tag, student_repo_path, output=None):
+    """Clone the student repository
+
+    Args:
+        git_path: URL to the git repository
+        tag: Tag or branch to checkout
+        student_repo_path: Path to clone into
+        output: File handle to write output to (defaults to sys.stdout)
+
+    Returns:
+        True if successful, False otherwise
+    """
+    if output is None:
+        output = sys.stdout
+
+    # Track whether we're outputting to stdout (vs a log file)
+    output_to_stdout = output is sys.stdout
+
+    if student_repo_path.is_dir() and list(student_repo_path.iterdir()):
+        return _fetch_and_checkout(student_repo_path, tag, output, output_to_stdout)
+
+    return _clone_fresh(git_path, tag, student_repo_path, output, output_to_stdout)
+
+
+def _fetch_and_checkout(student_repo_path, tag, output, output_to_stdout):
+    """Fetch and checkout when repo already exists."""
+    msg = f"Student repo {student_repo_path.name} already cloned. Re-fetching tag"
+    if output_to_stdout:
+        print_color(TermColors.BLUE, msg)
+    else:
+        print(msg, file=output)
+
+    # Fetch
+    cmd = ["git", "fetch", "--tags", "-f"]
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=student_repo_path,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        if result.stdout:
+            print(result.stdout, file=output, end="")
+        if result.stderr:
+            print(result.stderr, file=output, end="")
+    except subprocess.CalledProcessError as e:
+        msg = f"git fetch failed: {e}"
+        if output_to_stdout:
+            print_color(TermColors.RED, msg)
+        else:
+            print(msg, file=output)
+        if e.stdout:
+            print(e.stdout, file=output, end="")
+        if e.stderr:
+            print(e.stderr, file=output, end="")
+        return False
+
+    # Checkout tag
+    if tag is None:
+        # Get the default branch
+        stdout = subprocess.run(
+            ["git", "symbolic-ref", "refs/remotes/origin/HEAD", "--short"],
+            cwd=student_repo_path,
+            check=True,
+            capture_output=True,
+            universal_newlines=True,
+        ).stdout
+        tag = stdout.split("/")[1].strip()
+
+    if tag not in ("master", "main"):
+        tag = "tags/" + tag
+    cmd = ["git", "checkout", tag, "-f"]
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=student_repo_path,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        if result.stdout:
+            print(result.stdout, file=output, end="")
+        if result.stderr:
+            print(result.stderr, file=output, end="")
+    except subprocess.CalledProcessError as e:
+        msg = f"git checkout of tag failed: {e}"
+        if output_to_stdout:
+            print_color(TermColors.RED, msg)
+        else:
+            print(msg, file=output)
+        if e.stdout:
+            print(e.stdout, file=output, end="")
+        if e.stderr:
+            print(e.stderr, file=output, end="")
+        return False
+
+    return True
+
+
+def _clone_fresh(git_path, tag, student_repo_path, output, output_to_stdout):
+    """Clone a fresh copy of the repo."""
+    msg = f"Cloning repo, tag = {tag}"
+    if output_to_stdout:
+        print_color(TermColors.BLUE, msg)
+    else:
+        print(msg, file=output)
+
+    if tag:
+        cmd = [
+            "git",
+            "clone",
+            "--branch",
+            tag,
+            git_path,
+            str(student_repo_path.absolute()),
+        ]
+    else:
+        cmd = ["git", "clone", git_path, str(student_repo_path.absolute())]
+
+    # If output was explicitly provided (e.g., a log file), write directly to it.
+    # Otherwise (stdout), redirect clone output to a temporary log file to keep terminal clean.
+    if not output_to_stdout:
+        return _clone_to_output(cmd, student_repo_path, output)
+
+    return _clone_to_temp_log(cmd, student_repo_path)
+
+
+def _clone_to_output(cmd, student_repo_path, output):
+    """Clone and write output to the provided file handle."""
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        if result.stdout:
+            print(result.stdout, file=output, end="")
+        if result.stderr:
+            print(result.stderr, file=output, end="")
+    except KeyboardInterrupt:
+        shutil.rmtree(str(student_repo_path))
+        sys.exit(-1)
+    except subprocess.CalledProcessError as e:
+        print("Clone failed", file=output)
+        if e.stdout:
+            print(e.stdout, file=output, end="")
+        if e.stderr:
+            print(e.stderr, file=output, end="")
+        return False
+    return True
+
+
+def _clone_to_temp_log(cmd, student_repo_path):
+    """Clone and write output to a temporary log file."""
+    log_path = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            delete=False, dir="/tmp", prefix="ygrader_clone_", suffix=".log"
+        ) as tmp_log:
+            log_path = tmp_log.name
+            subprocess.run(cmd, check=True, stdout=tmp_log, stderr=subprocess.STDOUT)
+        # Inform user where the clone output was written
+        if log_path:
+            print(f"git clone output logged to {log_path}")
+    except KeyboardInterrupt:
+        shutil.rmtree(str(student_repo_path))
+        sys.exit(-1)
+    except subprocess.CalledProcessError:
+        print_color(TermColors.RED, "Clone failed")
+        if log_path:
+            print_color(TermColors.YELLOW, "See log:", log_path)
+        return False
+    return True
+
+
+def convert_github_url_format(url, to_https):
+    """ " Convert a github URL to either HTTPS or SSH format
+
+    If to_https is True, URLs will be converted to https://github.com/org/repo format:
+
+    >>> convert_github_url_format("git@github.com:byu-ecen123-classroom/123-labs-username01.git", True)
+    'https://github.com/byu-ecen123-classroom/123-labs-username01'
+
+    If to_https is False then SSH format is assumed, and URLs will be converted to git@github.com:org/repo format:
+
+    >>> convert_github_url_format("https://github.com/byu-ecen123-classroom/123-labs-username01", False)
+    'git@github.com:byu-ecen123-classroom/123-labs-username01.git'
+
+    It also works if the student provides the repo with ".git" extension
+
+    >>> convert_github_url_format("https://github.com/byu-ecen123-classroom/123-labs-username01.git", True)
+    'https://github.com/byu-ecen123-classroom/123-labs-username01'
+
+    Any invalid format is returned with modification:
+
+    >>> convert_github_url_format("invalid format", True)
+    'invalid format'
+
+    """
+    org = repo = None
+
+    match = re.search(r"git@github\.com:(.*?)/(.*?).git", url)
+    if match:
+        org = match.group(1)
+        repo = match.group(2)
+    match = re.search(r"github\.com/(.*?)/(.*)", url)
+    if match:
+        org = match.group(1)
+        repo = match.group(2)
+
+    # Remove .git
+    if repo is not None and repo.endswith(".git"):
+        repo = repo[:-4]
+
+    if org is not None:
+        if to_https:
+            return "https://github.com/" + org + "/" + repo
+        return "git@github.com:" + org + "/" + repo + ".git"
+    return url
+
+
+def print_date(student_repo_path):
+    """Print the last commit date to the repo"""
+    print("Last commit: ")
+    cmd = ["git", "log", "-1", r"--format=%cd"]
+    subprocess.run(cmd, cwd=str(student_repo_path), check=False)

{ygrader-2.5.2 → ygrader-2.6.0/ygrader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.5.2
+Version: 2.6.0
 Summary: Grading scripts used in BYU's Electrical and Computer Engineering Department
 Home-page: https://github.com/byu-cpe/ygrader
 Author: Jeff Goeders

{ygrader-2.5.2 → ygrader-2.6.0}/ygrader.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ ygrader/grader.py
 ygrader/grades_csv.py
 ygrader/grading_item.py
 ygrader/grading_item_config.py
+ygrader/remote.py
 ygrader/score_input.py
 ygrader/send_ctrl_backtick.ahk
 ygrader/student_repos.py

ygrader-2.5.2/ygrader/student_repos.py

@@ -1,138 +0,0 @@
-"""Manages student repositories when using Github sumission system"""
-
-import shutil
-import subprocess
-import sys
-import re
-import tempfile
-
-from .utils import print_color, TermColors
-
-
-def clone_repo(git_path, tag, student_repo_path):
-    """Clone the student repository"""
-
-    if student_repo_path.is_dir() and list(student_repo_path.iterdir()):
-        print_color(
-            TermColors.BLUE,
-            "Student repo",
-            student_repo_path.name,
-            "already cloned. Re-fetching tag",
-        )
-
-        # Fetch
-        cmd = ["git", "fetch", "--tags", "-f"]
-        try:
-            subprocess.run(cmd, cwd=student_repo_path, check=True)
-        except subprocess.CalledProcessError:
-            print_color(TermColors.RED, "git fetch failed")
-            return False
-
-        # Checkout tag
-        if tag is None:
-            # Get the default branch
-            stdout = subprocess.run(
-                ["git", "symbolic-ref", "refs/remotes/origin/HEAD", "--short"],
-                cwd=student_repo_path,
-                check=True,
-                capture_output=True,
-                universal_newlines=True,
-            ).stdout
-            tag = stdout.split("/")[1].strip()
-
-        if tag not in ("master", "main"):
-            tag = "tags/" + tag
-        cmd = ["git", "checkout", tag, "-f"]
-        try:
-            subprocess.run(cmd, cwd=student_repo_path, check=True)
-        except subprocess.CalledProcessError:
-            print_color(TermColors.RED, "git checkout of tag failed")
-            return False
-        return True
-
-    print_color(TermColors.BLUE, "Cloning repo, tag =", tag)
-    if tag:
-        cmd = [
-            "git",
-            "clone",
-            "--branch",
-            tag,
-            git_path,
-            str(student_repo_path.absolute()),
-        ]
-    else:
-        cmd = ["git", "clone", git_path, str(student_repo_path.absolute())]
-
-    # Redirect clone output to a temporary log file in /tmp
-    log_path = None
-    try:
-        with tempfile.NamedTemporaryFile(
-            delete=False, dir="/tmp", prefix="ygrader_clone_", suffix=".log"
-        ) as tmp_log:
-            log_path = tmp_log.name
-            subprocess.run(cmd, check=True, stdout=tmp_log, stderr=subprocess.STDOUT)
-        # Inform user where the clone output was written
-        if log_path:
-            print(f"git clone output logged to {log_path}")
-    except KeyboardInterrupt:
-        shutil.rmtree(str(student_repo_path))
-        sys.exit(-1)
-    except subprocess.CalledProcessError:
-        print_color(TermColors.RED, "Clone failed")
-        if log_path:
-            print_color(TermColors.YELLOW, "See log:", log_path)
-        return False
-    return True
-
-
-def convert_github_url_format(url, to_https):
-    """ " Convert a github URL to either HTTPS or SSH format
-
-    If to_https is True, URLs will be converted to https://github.com/org/repo format:
-
-    >>> convert_github_url_format("git@github.com:byu-ecen123-classroom/123-labs-username01.git", True)
-    'https://github.com/byu-ecen123-classroom/123-labs-username01'
-
-    If to_https is False then SSH format is assumed, and URLs will be converted to git@github.com:org/repo format:
-
-    >>> convert_github_url_format("https://github.com/byu-ecen123-classroom/123-labs-username01", False)
-    'git@github.com:byu-ecen123-classroom/123-labs-username01.git'
-
-    It also works if the student provides the repo with ".git" extension
-
-    >>> convert_github_url_format("https://github.com/byu-ecen123-classroom/123-labs-username01.git", True)
-    'https://github.com/byu-ecen123-classroom/123-labs-username01'
-
-    Any invalid format is returned with modification:
-
-    >>> convert_github_url_format("invalid format", True)
-    'invalid format'
-
-    """
-    org = repo = None
-
-    match = re.search(r"git@github\.com:(.*?)/(.*?).git", url)
-    if match:
-        org = match.group(1)
-        repo = match.group(2)
-    match = re.search(r"github\.com/(.*?)/(.*)", url)
-    if match:
-        org = match.group(1)
-        repo = match.group(2)
-
-    # Remove .git
-    if repo is not None and repo.endswith(".git"):
-        repo = repo[:-4]
-
-    if org is not None:
-        if to_https:
-            return "https://github.com/" + org + "/" + repo
-        return "git@github.com:" + org + "/" + repo + ".git"
-    return url
-
-
-def print_date(student_repo_path):
-    """Print the last commit date to the repo"""
-    print("Last commit: ")
-    cmd = ["git", "log", "-1", r"--format=%cd"]
-    subprocess.run(cmd, cwd=str(student_repo_path), check=False)