assignment-codeval 0.0.15__tar.gz → 0.0.16__tar.gz

{assignment_codeval-0.0.15 → assignment_codeval-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assignment-codeval
-Version: 0.0.15
+Version: 0.0.16
 Summary: CodEval for evaluating programming assignments
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{assignment_codeval-0.0.15 → assignment_codeval-0.0.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "assignment-codeval"
-version = "0.0.15"
+version = "0.0.16"
 description = "CodEval for evaluating programming assignments"
 readme = "README.md"
 requires-python = ">=3.12"

{assignment_codeval-0.0.15 → assignment_codeval-0.0.16}/src/assignment_codeval/cli.py

@@ -4,6 +4,7 @@ from assignment_codeval.ai_benchmark import get_benchmark_command
 from assignment_codeval.create_assignment import create_assignment
 from assignment_codeval.evaluate import run_evaluation
 from assignment_codeval.github_connect import github_setup_repo
+from assignment_codeval.install_assignment import install_assignment
 from assignment_codeval.submissions import download_submissions, upload_submission_comments, evaluate_submissions, list_codeval_assignments
 
 
@@ -18,6 +19,7 @@ cli.add_command(github_setup_repo)
 cli.add_command(evaluate_submissions)
 cli.add_command(create_assignment)
 cli.add_command(list_codeval_assignments)
+cli.add_command(install_assignment)
 cli.add_command(get_benchmark_command())
 
 if __name__ == "__main__":

assignment_codeval-0.0.16/src/assignment_codeval/install_assignment.py

@@ -0,0 +1,143 @@
+#! /usr/bin/python3
+"""Install a codeval assignment file and its referenced zip files to a destination."""
+
+import os
+import re
+import shutil
+import subprocess
+
+import click
+
+
+def parse_z_tags(codeval_path: str) -> list[str]:
+    """Parse a codeval file and return a list of zip files referenced by Z tags.
+
+    Arguments:
+        codeval_path: Path to the codeval file
+
+    Returns:
+        List of zip file paths referenced by Z tags
+    """
+    zip_files = []
+    with open(codeval_path, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith('Z '):
+                zip_file = line[2:].strip()
+                if zip_file:
+                    zip_files.append(zip_file)
+    return zip_files
+
+
+def is_remote_destination(destination: str) -> bool:
+    """Check if destination is a remote path (host:path format).
+
+    Arguments:
+        destination: The destination path
+
+    Returns:
+        True if destination is remote (contains : but not a Windows drive letter)
+    """
+    # Match host:path pattern but not Windows drive letters like C:\
+    if ':' not in destination:
+        return False
+    # Windows drive letter check (e.g., C:\path)
+    if re.match(r'^[A-Za-z]:\\', destination):
+        return False
+    return True
+
+
+def copy_file(source: str, destination: str, verbose: bool = False) -> None:
+    """Copy a file to a local or remote destination.
+
+    Arguments:
+        source: Path to the source file
+        destination: Destination path (local or host:path for remote)
+        verbose: Print verbose output
+
+    Raises:
+        click.ClickException: If copy fails
+    """
+    if is_remote_destination(destination):
+        # Use scp for remote destinations
+        cmd = ['scp', source, destination]
+        if verbose:
+            click.echo(f"Running: {' '.join(cmd)}")
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise click.ClickException(f"scp failed: {result.stderr}")
+    else:
+        # Local copy
+        if verbose:
+            click.echo(f"Copying {source} to {destination}")
+        os.makedirs(destination, exist_ok=True)
+        shutil.copy2(source, destination)
+
+
+@click.command()
+@click.argument('codeval_file', type=click.Path(exists=True))
+@click.argument('destination')
+@click.option('--verbose', '-v', is_flag=True, help='Show detailed output')
+def install_assignment(codeval_file: str, destination: str, verbose: bool):
+    """Install a codeval file and its referenced zip files to a destination.
+
+    CODEVAL_FILE is the path to the codeval specification file.
+
+    DESTINATION is either a local path or a remote path in host:path format.
+    If remote, scp will be used to copy files.
+
+    \b
+    Examples:
+        # Local install
+        assignment-codeval install-assignment myassign.codeval /path/to/dest
+
+        # Remote install
+        assignment-codeval install-assignment myassign.codeval server:/home/user/assignments
+    """
+    codeval_path = os.path.abspath(codeval_file)
+    codeval_dir = os.path.dirname(codeval_path)
+    codeval_name = os.path.basename(codeval_path)
+
+    # Parse Z tags to find referenced zip files
+    zip_files = parse_z_tags(codeval_path)
+
+    # Build list of files to copy
+    files_to_copy = [codeval_path]
+
+    for zip_file in zip_files:
+        # Zip files are relative to the codeval file's directory
+        zip_path = os.path.join(codeval_dir, zip_file)
+        if os.path.exists(zip_path):
+            files_to_copy.append(zip_path)
+        else:
+            click.echo(f"Warning: Referenced zip file not found: {zip_path}", err=True)
+
+    # Show summary
+    click.echo(f"Codeval file: {codeval_name}")
+    if zip_files:
+        click.echo(f"Referenced zip files: {', '.join(zip_files)}")
+    else:
+        click.echo("No zip files referenced")
+    click.echo(f"Destination: {destination}")
+
+    if is_remote_destination(destination):
+        click.echo("Using scp for remote copy")
+
+    # Copy files
+    for source_path in files_to_copy:
+        filename = os.path.basename(source_path)
+        if is_remote_destination(destination):
+            # For remote, append filename to destination
+            dest_path = f"{destination}/{filename}"
+        else:
+            dest_path = destination
+
+        try:
+            copy_file(source_path, dest_path, verbose)
+            click.echo(f"Copied: {filename}")
+        except click.ClickException as e:
+            raise e
+        except Exception as e:
+            raise click.ClickException(f"Failed to copy {filename}: {e}")
+
+    click.echo("Done")

{assignment_codeval-0.0.15 → assignment_codeval-0.0.16}/src/assignment_codeval/submissions.py

@@ -90,9 +90,11 @@ def evaluate_submissions(codeval_dir, submissions_dir):
             warn(f"no codeval file found for {assignment_name} in {codeval_file}")
             continue
 
-        # get the zipfiles (Z tag) and timeout (CTO tag)
+        # First pass: get CTO, CD tags, and collect Z files (don't extract yet)
         compile_timeout = 20
         assignment_working_dir = "."
+        has_cd_tag = False
+        zip_files = []
         move_to_next_submission = False
         with open(codeval_file, "r") as fd:
             for line in fd:
@@ -103,6 +105,7 @@ def evaluate_submissions(codeval_dir, submissions_dir):
                     except Exception:
                         warn(f"could not parse compile timeout from {line}, using default {compile_timeout}")
                 if line.startswith("CD"):
+                    has_cd_tag = True
                     assignment_working_dir = os.path.normpath(
                         os.path.join(assignment_working_dir, line.split()[1].strip()))
                     if not os.path.isdir(os.path.join(submission_dir, assignment_working_dir)):
@@ -110,16 +113,26 @@ def evaluate_submissions(codeval_dir, submissions_dir):
                         move_to_next_submission = True
                         break
                 if line.startswith("Z"):
-                    zipfile = line.split(None, 1)[1]
-                    # unzip into the submission directory
-                    with ZipFile(os.path.join(codeval_dir, zipfile)) as zf:
-                        for f in zf.infolist():
-                            dest_dir = os.path.join(submission_dir, assignment_working_dir)
-                            zf.extract(f, dest_dir)
-                            if not f.is_dir():
-                                perms = f.external_attr >> 16
-                                if perms:
-                                    os.chmod(os.path.join(dest_dir, f.filename), perms)
+                    zip_files.append(line.split(None, 1)[1])
+
+        # If no CD tag and this is a GitHub submission (has .git), use assignment name as working dir
+        if not has_cd_tag and os.path.exists(os.path.join(submission_dir, assignment_name, ".git")):
+            assignment_working_dir = assignment_name
+            if not os.path.isdir(os.path.join(submission_dir, assignment_working_dir)):
+                out = f"{assignment_working_dir} does not exist or is not a directory\n".encode('utf-8')
+                move_to_next_submission = True
+
+        # Now extract zip files to the correct working directory
+        if not move_to_next_submission:
+            for zf_name in zip_files:
+                with ZipFile(os.path.join(codeval_dir, zf_name)) as zf:
+                    for f in zf.infolist():
+                        dest_dir = os.path.join(submission_dir, assignment_working_dir)
+                        zf.extract(f, dest_dir)
+                        if not f.is_dir():
+                            perms = f.external_attr >> 16
+                            if perms:
+                                os.chmod(os.path.join(dest_dir, f.filename), perms)
 
         if not move_to_next_submission:
             command = raw_command.replace("EVALUATE", "cd /submissions; assignment-codeval run-evaluation codeval.txt")

{assignment_codeval-0.0.15 → assignment_codeval-0.0.16}/src/assignment_codeval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assignment-codeval
-Version: 0.0.15
+Version: 0.0.16
 Summary: CodEval for evaluating programming assignments
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{assignment_codeval-0.0.15 → assignment_codeval-0.0.16}/src/assignment_codeval.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/assignment_codeval/create_assignment.py
 src/assignment_codeval/evaluate.py
 src/assignment_codeval/file_utils.py
 src/assignment_codeval/github_connect.py
+src/assignment_codeval/install_assignment.py
 src/assignment_codeval/submissions.py
 src/assignment_codeval.egg-info/PKG-INFO
 src/assignment_codeval.egg-info/SOURCES.txt
@@ -18,4 +19,6 @@ src/assignment_codeval.egg-info/entry_points.txt
 src/assignment_codeval.egg-info/requires.txt
 src/assignment_codeval.egg-info/top_level.txt
 tests/test_codeval.py
-tests/test_create_assignment.py
+tests/test_create_assignment.py
+tests/test_evaluate_submissions.py
+tests/test_install_assignment.py

assignment_codeval-0.0.16/tests/test_evaluate_submissions.py

@@ -0,0 +1,158 @@
+"""Tests for evaluate_submissions command."""
+
+import os
+import tempfile
+import zipfile
+
+import pytest
+
+
+class TestGitHubSubmissionWorkingDir:
+    """Tests for GitHub submission working directory detection."""
+
+    def test_zip_extracted_to_assignment_dir_for_github(self):
+        """Verify zip files are extracted to assignment directory for GitHub submissions.
+
+        When a GitHub submission exists (has .git directory) and no CD tag is specified,
+        zip files should be extracted to the assignment_name subdirectory, not the root.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Setup directory structure:
+            # tmpdir/
+            #   codeval/
+            #     TestAssignment.codeval
+            #     support.zip
+            #   submissions/
+            #     Course/
+            #       TestAssignment/
+            #         12345/
+            #           submission/
+            #             TestAssignment/
+            #               .git/
+            #               main.py
+
+            codeval_dir = os.path.join(tmpdir, "codeval")
+            submissions_dir = os.path.join(tmpdir, "submissions")
+            os.makedirs(codeval_dir)
+
+            assignment_name = "TestAssignment"
+            student_dir = os.path.join(submissions_dir, "Course", assignment_name, "12345")
+            submission_dir = os.path.join(student_dir, "submission")
+            git_repo_dir = os.path.join(submission_dir, assignment_name)
+            os.makedirs(os.path.join(git_repo_dir, ".git"))
+
+            # Create a dummy file in the git repo
+            with open(os.path.join(git_repo_dir, "main.py"), "w") as f:
+                f.write("print('hello')\n")
+
+            # Create a zip file with a helper file
+            zip_path = os.path.join(codeval_dir, "support.zip")
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                zf.writestr("helper.txt", "helper content")
+
+            # Create codeval file with Z tag but NO CD tag
+            codeval_path = os.path.join(codeval_dir, f"{assignment_name}.codeval")
+            with open(codeval_path, "w") as f:
+                f.write("Z support.zip\n")
+                f.write("T echo test\n")
+                f.write("O test\n")
+
+            # Parse the codeval file and check where zip would be extracted
+            # This simulates what evaluate_submissions does
+            from assignment_codeval.submissions import evaluate_submissions
+            from zipfile import ZipFile
+
+            # Manually trace through the logic to verify the bug
+            assignment_working_dir = "."
+            has_cd_tag = False
+            zip_files = []
+
+            with open(codeval_path, "r") as fd:
+                for line in fd:
+                    line = line.strip()
+                    if line.startswith("CD"):
+                        has_cd_tag = True
+                    if line.startswith("Z"):
+                        zip_files.append(line.split(None, 1)[1])
+
+            # Check for GitHub submission BEFORE extracting
+            is_github = os.path.exists(os.path.join(submission_dir, assignment_name, ".git"))
+            assert is_github, "Test setup: .git directory should exist"
+
+            if not has_cd_tag and is_github:
+                assignment_working_dir = assignment_name
+
+            # Now extract zip files to the correct location
+            for zf_name in zip_files:
+                with ZipFile(os.path.join(codeval_dir, zf_name)) as zf:
+                    dest_dir = os.path.join(submission_dir, assignment_working_dir)
+                    zf.extractall(dest_dir)
+
+            # Verify helper.txt was extracted to the assignment directory, not root
+            correct_path = os.path.join(submission_dir, assignment_name, "helper.txt")
+            wrong_path = os.path.join(submission_dir, "helper.txt")
+
+            assert os.path.exists(correct_path), \
+                f"helper.txt should be at {correct_path}"
+            assert not os.path.exists(wrong_path), \
+                f"helper.txt should NOT be at {wrong_path} (root of submission_dir)"
+
+    def test_zip_extracted_to_root_when_cd_tag_present(self):
+        """Verify zip files respect CD tag even for GitHub submissions."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            codeval_dir = os.path.join(tmpdir, "codeval")
+            submissions_dir = os.path.join(tmpdir, "submissions")
+            os.makedirs(codeval_dir)
+
+            assignment_name = "TestAssignment"
+            student_dir = os.path.join(submissions_dir, "Course", assignment_name, "12345")
+            submission_dir = os.path.join(student_dir, "submission")
+
+            # Create custom directory specified by CD tag
+            custom_dir = os.path.join(submission_dir, "custom_dir")
+            os.makedirs(os.path.join(custom_dir, ".git"))
+
+            # Create codeval file WITH CD tag
+            codeval_path = os.path.join(codeval_dir, f"{assignment_name}.codeval")
+            with open(codeval_path, "w") as f:
+                f.write("CD custom_dir\n")
+                f.write("Z support.zip\n")
+                f.write("T echo test\n")
+                f.write("O test\n")
+
+            # Create zip file
+            zip_path = os.path.join(codeval_dir, "support.zip")
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                zf.writestr("helper.txt", "helper content")
+
+            # Trace through logic
+            from zipfile import ZipFile
+
+            assignment_working_dir = "."
+            has_cd_tag = False
+            zip_files = []
+
+            with open(codeval_path, "r") as fd:
+                for line in fd:
+                    line = line.strip()
+                    if line.startswith("CD"):
+                        has_cd_tag = True
+                        assignment_working_dir = os.path.normpath(
+                            os.path.join(assignment_working_dir, line.split()[1].strip()))
+                    if line.startswith("Z"):
+                        zip_files.append(line.split(None, 1)[1])
+
+            # CD tag should take precedence
+            assert has_cd_tag
+            assert assignment_working_dir == "custom_dir"
+
+            # Extract zip files
+            for zf_name in zip_files:
+                with ZipFile(os.path.join(codeval_dir, zf_name)) as zf:
+                    dest_dir = os.path.join(submission_dir, assignment_working_dir)
+                    zf.extractall(dest_dir)
+
+            # Verify helper.txt was extracted to custom_dir
+            correct_path = os.path.join(submission_dir, "custom_dir", "helper.txt")
+            assert os.path.exists(correct_path), \
+                f"helper.txt should be at {correct_path}"

assignment_codeval-0.0.16/tests/test_install_assignment.py

@@ -0,0 +1,183 @@
+"""Tests for install_assignment command."""
+
+import os
+import tempfile
+import zipfile
+from unittest.mock import patch, MagicMock
+
+import pytest
+from click.testing import CliRunner
+
+from assignment_codeval.install_assignment import (
+    install_assignment,
+    is_remote_destination,
+    parse_z_tags,
+)
+
+
+class TestIsRemoteDestination:
+    """Tests for is_remote_destination function."""
+
+    def test_local_path(self):
+        assert is_remote_destination('/home/user/path') is False
+
+    def test_relative_path(self):
+        assert is_remote_destination('relative/path') is False
+
+    def test_remote_path(self):
+        assert is_remote_destination('server:/home/user/path') is True
+
+    def test_remote_path_with_user(self):
+        assert is_remote_destination('user@server:/path') is True
+
+    def test_windows_drive_letter(self):
+        assert is_remote_destination('C:\\Users\\path') is False
+
+    def test_windows_drive_lowercase(self):
+        assert is_remote_destination('c:\\Users\\path') is False
+
+
+class TestParseZTags:
+    """Tests for parse_z_tags function."""
+
+    def test_no_z_tags(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('C gcc -o test test.c\n')
+            f.write('T ./test\n')
+            f.name
+        try:
+            result = parse_z_tags(f.name)
+            assert result == []
+        finally:
+            os.unlink(f.name)
+
+    def test_single_z_tag(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('Z support.zip\n')
+            f.write('C gcc -o test test.c\n')
+        try:
+            result = parse_z_tags(f.name)
+            assert result == ['support.zip']
+        finally:
+            os.unlink(f.name)
+
+    def test_multiple_z_tags(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('Z first.zip\n')
+            f.write('Z second.zip\n')
+            f.write('C gcc -o test test.c\n')
+        try:
+            result = parse_z_tags(f.name)
+            assert result == ['first.zip', 'second.zip']
+        finally:
+            os.unlink(f.name)
+
+    def test_z_tag_with_whitespace(self):
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.codeval', delete=False) as f:
+            f.write('Z   support.zip  \n')
+        try:
+            result = parse_z_tags(f.name)
+            assert result == ['support.zip']
+        finally:
+            os.unlink(f.name)
+
+
+class TestInstallAssignmentCommand:
+    """Tests for the install_assignment CLI command."""
+
+    def test_local_install_codeval_only(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a codeval file
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('C gcc -o test test.c\n')
+                f.write('T ./test\n')
+
+            # Create destination directory
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir])
+            assert result.exit_code == 0
+            assert 'No zip files referenced' in result.output
+            assert 'Done' in result.output
+            assert os.path.exists(os.path.join(dest_dir, 'test.codeval'))
+
+    def test_local_install_with_zip(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a zip file
+            zip_path = os.path.join(tmpdir, 'support.zip')
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                zf.writestr('helper.txt', 'test content')
+
+            # Create a codeval file referencing the zip
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('Z support.zip\n')
+                f.write('C gcc -o test test.c\n')
+
+            # Create destination directory
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir])
+            assert result.exit_code == 0
+            assert 'support.zip' in result.output
+            assert 'Done' in result.output
+            assert os.path.exists(os.path.join(dest_dir, 'test.codeval'))
+            assert os.path.exists(os.path.join(dest_dir, 'support.zip'))
+
+    def test_missing_zip_warning(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a codeval file referencing a non-existent zip
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('Z missing.zip\n')
+                f.write('C gcc -o test test.c\n')
+
+            # Create destination directory
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir])
+            assert result.exit_code == 0
+            assert 'Warning: Referenced zip file not found' in result.output
+
+    def test_verbose_output(self):
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('C gcc -o test test.c\n')
+
+            dest_dir = os.path.join(tmpdir, 'dest')
+            os.makedirs(dest_dir)
+
+            result = runner.invoke(install_assignment, [codeval_path, dest_dir, '--verbose'])
+            assert result.exit_code == 0
+            assert 'Copying' in result.output
+
+    @patch('assignment_codeval.install_assignment.subprocess.run')
+    def test_remote_destination_detected(self, mock_run):
+        # Mock successful scp
+        mock_run.return_value = MagicMock(returncode=0)
+
+        runner = CliRunner()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            codeval_path = os.path.join(tmpdir, 'test.codeval')
+            with open(codeval_path, 'w') as f:
+                f.write('C gcc -o test test.c\n')
+
+            result = runner.invoke(install_assignment, [codeval_path, 'server:/path'])
+            assert result.exit_code == 0
+            assert 'Using scp for remote copy' in result.output
+            # Verify scp was called
+            mock_run.assert_called()
+
+    def test_nonexistent_codeval_file(self):
+        runner = CliRunner()
+        result = runner.invoke(install_assignment, ['/nonexistent/file.codeval', '/dest'])
+        assert result.exit_code != 0