Allow choosing custom versions of python for graders (#92)

## Motivation
* Sets us up for supporting Java (notably this DOES NOT add official
Java support)
* Allows us to offer higher versions of python, without breaking
backwards compatibility with graders relying on python 3.10 behavior

This PR also does not add a warning banner if an assignment is using a
deprecated version of a language, in order to reduce the already large
and complex diff. This would be better as a "good first issue".

## Implementation
This adds a new model, `Language`, which stores information about the
language, binary path, and more. The field `Assignment.language` has
been moved inside said model. All the information about the specific
language is stored in a dictionary called `info`.

The `info` dictionary must contain a `version` key that is sortable. For
the `python` grader language, it must also contain the key `python3`
which has the absolute path to a python executable.
The addition of another language to Tin can then consist of simply
adding other keys to the `info` dictionary as needed.

> [!IMPORTANT]
> Custom migrations were written in order to facilitate this transition
with minimal problems.

The rest is just some restructuring:
* Changes the `run_submission` task to use the assignments executable
* Filters the edit assignment/create venv to only show non-deprecated
language options.
* Changes the `create_venv` task to use the correct executable

Author: JasonGrace2282

tin/apps/assignments/admin.py

@@ -2,13 +2,15 @@
 
 import datetime
 
-from django.contrib import admin
+from django.contrib import admin, messages
+from django.utils.translation import ngettext
 
 from .models import (
     Assignment,
     CooldownPeriod,
     FileAction,
     Folder,
+    Language,
     MossResult,
     Quiz,
     QuizLogMessage,
@@ -34,7 +36,7 @@ def assignments(self, obj):
 class AssignmentAdmin(admin.ModelAdmin):
     date_hierarchy = "due"
     list_display = ("name", "course_name", "folder", "due", "visible", "quiz_icon")
-    list_filter = ("language", "course", "due")
+    list_filter = ("language_details", "course", "due")
     ordering = ("-due",)
     save_as = True
     search_fields = ("name",)
@@ -53,6 +55,36 @@ def quiz_icon(self, obj):
         return bool(obj.is_quiz)
 
 
+@admin.register(Language)
+class LanguageAdmin(admin.ModelAdmin):
+    list_display = ("name", "language", "info", "is_deprecated")
+    search_fields = ("name",)
+    ordering = ("-language", "is_deprecated", "name")
+    save_as = True
+    list_filter = ("language",)
+    actions = ["make_deprecated"]
+
+    @admin.action(description="Mark languages as deprecated")
+    def make_deprecated(self, request, queryset) -> None:
+        changed = 0
+        for language in queryset:
+            language.is_deprecated = True
+            language.name = f"{language.name} (Deprecated)"
+            language.save()
+            changed += 1
+
+        self.message_user(
+            request,
+            ngettext(
+                "Successfully marked %d language as deprecated.",
+                "Successfully marked %d languages as deprecated.",
+                changed,
+            )
+            % changed,
+            messages.SUCCESS,
+        )
+
+
 @admin.register(CooldownPeriod)
 class CooldownPeriodAdmin(admin.ModelAdmin):
     date_hierarchy = "start_time"

tin/apps/assignments/forms.py

@@ -6,9 +6,10 @@
 from django import forms
 from django.conf import settings
 from django.core.exceptions import ValidationError
+from django.db.models import Q
 
 from ..submissions.models import Submission
-from .models import Assignment, Folder, MossResult, SubmissionCap
+from .models import Assignment, Folder, Language, MossResult, SubmissionCap
 
 logger = getLogger(__name__)
 
@@ -23,19 +24,29 @@ def __init__(self, course, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.fields["folder"].queryset = Folder.objects.filter(course=course)
 
-        # Prevent changing the language of an assignment after it has been created
         instance = getattr(self, "instance", None)
         if instance and instance.pk:
-            self.fields["language"].help_text = (
-                "Changing this after uploading a grader script is not recommended and will cause "
-                "issues."
+            # allow them to change from a deprecated language to a non-deprecated one
+            # but it must be the same (e.g. python -> python, or java -> java)
+            self.fields["language_details"].queryset = Language.objects.filter(
+                Q(is_deprecated=False) & Q(language=instance.language_details.language)
+                # just nicer UI to show the deprecated language choice
+                | Q(id=instance.language_details.id)
             )
 
             cap = instance.submission_caps.filter(student__isnull=True).first()
             if cap is not None:
                 self.fields["submission_cap"].initial = cap.submission_cap
                 self.fields["submission_cap_after_due"].initial = cap.submission_cap_after_due
 
+        else:
+            self.fields["language_details"].queryset = Language.objects.filter(is_deprecated=False)
+        self.fields[
+            "language_details"
+        ].help_text = (
+            "Keep in mind you cannot swap between languages after the assignment has been created."
+        )
+
         # prevent description from getting too big
         self.fields["description"].widget.attrs.update({"id": "description"})
 
@@ -65,7 +76,7 @@ class Meta:
             "description",
             "markdown",
             "folder",
-            "language",
+            "language_details",
             "filename",
             "venv",
             "points_possible",
@@ -98,6 +109,7 @@ class Meta:
             "is_quiz": "Is this a quiz?",
             "quiz_autocomplete_enabled": "Enable code autocompletion?",
             "quiz_description_markdown": "Use markdown?",
+            "language_details": "Grader language",
         }
         sections = (
             {
@@ -116,7 +128,7 @@ class Meta:
                 "description": "",
                 "fields": (
                     "folder",
-                    "language",
+                    "language_details",
                     "filename",
                     "venv",
                 ),

tin/apps/assignments/migrations/0034_language.py

@@ -0,0 +1,81 @@
+# Generated by Django 4.2.16 on 2024-11-11 01:40
+
+from django.db import migrations, models
+
+
+def migrate_to_foreignkey(apps, schema_editor):
+    """Creates a default :class:`.Language` model for each assignment.
+
+    This converts the old language field to a foreign key to the new language model.
+    """
+
+    Language = apps.get_model("assignments", "Language")
+    db_alias = schema_editor.connection.alias
+    python_310, py_created = Language.objects.using(db_alias).get_or_create(
+        name="Python 3.10",
+        info={"python3": "/usr/bin/python3.10", "version": 3.10},
+        language="P",
+    )
+
+    Assignment = apps.get_model("assignments", "Assignment")
+    Assignment.objects.using(db_alias).update(language_details=python_310)
+
+    # avoid creating empty models
+    if py_created and not python_310.assignment_set.exists():
+        python_310.delete()
+
+
+def revert_default_language(apps, schema_editor):
+    """Converts the foreign key :class:`.Language` back to the old ``language`` field."""
+
+    Assignment = apps.get_model("assignments", "Assignment")
+    db_alias = schema_editor.connection.alias
+    Assignment.objects.using(db_alias).update(language="P")
+
+
+# fmt: off
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('assignments', '0033_submissioncap_submissioncap_unique_type_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Language',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_deprecated', models.BooleanField(default=False)),
+                ('language', models.CharField(choices=[('P', 'Python 3'), ('J', 'Java')], max_length=1)),
+                ('name', models.CharField(help_text='The name of the language', max_length=50)),
+                ('info', models.JSONField()),
+            ],
+            options={'ordering': ['-language', "-info__version"]},
+
+        ),
+        migrations.AddField(
+            model_name="assignment",
+            name="language_details",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=models.deletion.CASCADE,
+                related_name="assignment_set",
+                to="assignments.language",
+            ),
+        ),
+        migrations.RunPython(migrate_to_foreignkey, revert_default_language),
+        migrations.AlterField(
+            model_name="assignment",
+            name="language_details",
+            field=models.ForeignKey(
+                null=False,
+                on_delete=models.deletion.CASCADE,
+                related_name="assignment_set",
+                to="assignments.language",
+            ),
+        ),
+        migrations.RemoveField(
+            model_name='assignment',
+            name='language',
+        ),
+    ]

tin/apps/assignments/models.py

@@ -4,10 +4,12 @@
 import logging
 import os
 import subprocess
+from pathlib import Path
 from typing import Literal
 
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models, transaction
 from django.db.models import Q
@@ -95,10 +97,10 @@ def filter_editable(self, user):
 def upload_grader_file_path(assignment, _):  # pylint: disable=unused-argument
     """Get the location of the grader file for an assignment"""
     assert assignment.id is not None
-    if assignment.language == "P":
-        return f"assignment-{assignment.id}/grader.py"
-    else:
+    if assignment.grader_language == "J":
         return f"assignment-{assignment.id}/Grader.java"
+    else:
+        return f"assignment-{assignment.id}/grader.py"
 
 
 class Assignment(models.Model):
@@ -122,11 +124,12 @@ class Assignment(models.Model):
     description = models.CharField(max_length=4096)
     markdown = models.BooleanField(default=False)
 
-    LANGUAGES = (
-        ("P", "Python 3"),
-        ("J", "Java"),
+    language_details = models.ForeignKey(
+        "Language",
+        on_delete=models.CASCADE,
+        related_name="assignment_set",
+        null=False,
     )
-    language = models.CharField(max_length=1, choices=LANGUAGES, default="P")
 
     filename = models.CharField(max_length=50, default="main.py")
 
@@ -195,6 +198,11 @@ def __repr__(self):
     def get_absolute_url(self):
         return reverse("assignments:show", args=(self.id,))
 
+    @property
+    def grader_language(self) -> Literal["P", "J"]:
+        """The language of the assignment (Python or Java)"""
+        return self.language_details.language
+
     def within_submission_limit(self, student) -> bool:
         """Check if a student is within the submission limit for an assignment."""
         # teachers should have infinite submissions
@@ -262,6 +270,14 @@ def make_assignment_dir(self) -> None:
         assignment_path = os.path.join(settings.MEDIA_ROOT, f"assignment-{self.id}")
         os.makedirs(assignment_path, exist_ok=True)
 
+    def grader_exists(self) -> bool:
+        """Check if a grader file exists."""
+        if self.grader_file is None or self.grader_file.name is None:
+            return False
+
+        fpath = Path(settings.MEDIA_ROOT) / self.grader_file.name
+        return fpath.exists()
+
     def save_grader_file(self, grader_text: str) -> None:
         """Save the grader file to the correct location.
 
@@ -773,3 +789,37 @@ def run(self, assignment: Assignment):
 
         assignment.last_action_output = output
         assignment.save()
+
+
+class Language(models.Model):
+    """Which version of a language is used for an assignment."""
+
+    LANGUAGES = (
+        ("P", "Python 3"),
+        ("J", "Java"),
+    )
+
+    name = models.CharField(max_length=50, help_text="The name of the language")
+    info = models.JSONField()
+    language = models.CharField(max_length=1, choices=LANGUAGES)
+    is_deprecated = models.BooleanField(default=False)
+
+    class Meta:
+        ordering = ["-language", "-info__version"]
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__}: {self.name} ({self.language}) >"
+
+    def clean(self) -> None:
+        super().clean()
+        if not isinstance(self.info, dict):
+            raise ValidationError("Info must be a dictionary")
+        if self.language == "P" and (
+            "python3" not in self.info or not isinstance(self.info["version"], float)
+        ):
+            raise ValidationError(
+                "Python 3 language must have a 'python3' key and a (float) version key!"
+            )

tin/apps/assignments/tests/test_assignments.py

@@ -10,11 +10,10 @@
 
 
 @login("teacher")
-def test_create_assignment(client, course) -> None:
+def test_create_assignment(client, course, python) -> None:
     data = {
         "name": "Write a Vertex Shader",
         "description": "See https://learnopengl.com/Getting-started/Shaders",
-        "language": "P",
         "filename": "vertex.glsl",
         "points_possible": "300",
         "due": "04/16/2025",
@@ -24,6 +23,7 @@ def test_create_assignment(client, course) -> None:
         "submission_limit_cooldown": "30",
         "is_quiz": False,
         "quiz_action": "2",
+        "language_details": python.id,
     }
     response = client.post(
         reverse("assignments:add", args=[course.id]),

tin/apps/assignments/tests/test_grader.py

@@ -48,3 +48,8 @@ def test_download_grader(client, assignment):
 
     assert response.status_code == 200
     assert response.content.decode("utf-8") == code
+
+
+def test_grader_save_file(assignment):
+    assignment.save_grader_file("print('hello, world')")
+    assert assignment.grader_exists()

tin/apps/assignments/views.py

@@ -286,8 +286,9 @@ def edit_view(request, assignment_id):
     )
 
     course = assignment.course
+    initial = {"language_details": assignment.language_details}
 
-    assignment_form = AssignmentForm(course, instance=assignment)
+    assignment_form = AssignmentForm(course, instance=assignment, initial=initial)
     if request.method == "POST":
         assignment_form = AssignmentForm(course, data=request.POST, instance=assignment)
         if assignment_form.is_valid():

tin/apps/submissions/models.py

@@ -52,7 +52,7 @@ def filter_editable(self, user):
 def upload_submission_file_path(submission, _) -> str:  # pylint: disable=unused-argument
     """Get the path to a submission"""
     assert submission.assignment.id is not None
-    if submission.assignment.language == "P":
+    if submission.assignment.grader_language == "P":
         return "assignment-{}/{}/submission_{}.py".format(
             submission.assignment.id,
             slugify(submission.student.username),