refactor: Use new model instead of tags for Release Programming Languages

Author: Karthik99999

django/curator/models.py

@@ -15,7 +15,7 @@
 from nltk.tokenize import word_tokenize
 from taggit.models import Tag
 
-from library.models import ProgrammingLanguage, CodebaseReleasePlatformTag
+from library.models import ProgrammingLanguageTag, CodebaseReleasePlatformTag
 
 logger = logging.getLogger(__name__)
 
@@ -42,10 +42,10 @@ def get_through_tables():
 class TagCuratorProxyQuerySet(models.QuerySet):
     def with_comma(self):
         return self.filter(name__icontains=",")
-
-    def programming_languages(self):
+    
+    def programming_language_tags(self):
         return self.filter(
-            id__in=ProgrammingLanguage.objects.values_list("tag_id", flat=True)
+            id__in=ProgrammingLanguageTag.objects.values_list("tag_id", flat=True)
         )
 
     def platforms(self):

django/library/metadata.py

@@ -196,8 +196,8 @@ def _convert_release(cls, release) -> CodeMeta:
             ),
             programmingLanguage=[
                 # FIXME: this can include "version" when langs are refactored
-                {"@type": "ComputerLanguage", "name": pl.name}
-                for pl in release.programming_languages.all().order_by("name")
+                {"@type": "ComputerLanguage", "name": rl.programming_language.name}
+                for rl in release.release_languages.all().order_by("programming_language__name")
             ],
             runtimePlatform=[
                 tag.name for tag in release.platform_tags.all().order_by("name")

django/library/migrations/0033_alter_codebaserelease_programming_languages.py

@@ -0,0 +1,74 @@
+# Generated by Django 4.2.22 on 2025-09-29 23:02
+
+from django.db import migrations, models
+import django.db.models.deletion
+import modelcluster.contrib.taggit
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("taggit", "0005_auto_20220424_2025"),
+        ("library", "0032_license_text_codemeta_snapshot"),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name="ProgrammingLanguage",
+            new_name="ProgrammingLanguageTag",
+        ),
+        migrations.RenameField(
+            model_name="codebaserelease",
+            old_name="programming_languages",
+            new_name="programming_language_tags",
+        ),
+        migrations.CreateModel(
+            name="ProgrammingLanguage",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, unique=True)),
+                ("url", models.URLField(blank=True)),
+                ("is_pinned", models.BooleanField(default=False)),
+                ("is_user_defined", models.BooleanField(default=False)),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ReleaseLanguage",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("version", models.CharField(max_length=20)),
+                (
+                    "programming_language",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="release_languages",
+                        to="library.programminglanguage",
+                    ),
+                ),
+                (
+                    "release",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="release_languages",
+                        to="library.codebaserelease",
+                    ),
+                ),
+            ],
+        ),
+    ]

django/library/models.py

@@ -92,12 +92,34 @@ class CodebaseTag(TaggedItemBase):
     content_object = ParentalKey("library.Codebase", related_name="tagged_codebases")
 
 
-class ProgrammingLanguage(TaggedItemBase):
+class ProgrammingLanguageTag(TaggedItemBase):
     content_object = ParentalKey(
         "library.CodebaseRelease", related_name="tagged_release_languages"
     )
 
 
+@register_snippet
+class ProgrammingLanguage(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    url = models.URLField(blank=True)
+    is_pinned = models.BooleanField(default=False)
+    is_user_defined = models.BooleanField(default=False)
+
+
+class ReleaseLanguageQuerySet(models.QuerySet):
+    def for_release(self, release):
+        return self.select_related('programming_language').filter(release=release)
+
+class ReleaseLanguage(models.Model):
+    programming_language = models.ForeignKey(
+        "library.ProgrammingLanguage", related_name="release_languages", on_delete=models.CASCADE
+    )
+    release = models.ForeignKey(
+        "library.CodebaseRelease", related_name="release_languages", on_delete=models.CASCADE
+    )
+    version = models.CharField(max_length=20)
+
+
 class CodebaseReleasePlatformTag(TaggedItemBase):
     content_object = ParentalKey(
         "library.CodebaseRelease", related_name="tagged_release_platforms"
@@ -989,15 +1011,15 @@ def create_release_from_source(self, source_release, release_metadata):
         # cache these before removing source release id to copy it over
         contributors = ReleaseContributor.objects.filter(release_id=source_release.id)
         platform_tags = source_release.platform_tags.all()
-        programming_languages = source_release.programming_languages.all()
+        release_languages = source_release.release_languages.all()
         # set source_release.id to None to create a new release
         # see https://docs.djangoproject.com/en/4.2/topics/db/queries/#copying-model-instances
         source_release.id = None
         source_release._state.adding = True
         source_release.__dict__.update(**release_metadata)
         source_release.save()
         source_release.platform_tags.add(*platform_tags)
-        source_release.programming_languages.add(*programming_languages)
+        source_release.release_languages.add(*release_languages)
         contributors.copy_to(source_release)
         return source_release
 
@@ -1287,8 +1309,8 @@ class Status(models.TextChoices):
         through=CodebaseReleasePlatformTag, related_name="platform_codebase_releases"
     )
     platforms = models.ManyToManyField(Platform)
-    programming_languages = ClusterTaggableManager(
-        through=ProgrammingLanguage, related_name="pl_codebase_releases"
+    programming_language_tags = ClusterTaggableManager(
+        through=ProgrammingLanguageTag, related_name="pl_codebase_releases"
     )
     codebase = models.ForeignKey(
         Codebase, related_name="releases", on_delete=models.PROTECT
@@ -1462,7 +1484,7 @@ def validate_metadata(self):
         # naive check for metadata being present (i.e., None or false-y values)
         if not self.license:
             errors.append(ValidationError(_("Please specify a software license.")))
-        if not self.programming_languages.exists():
+        if not self.release_languages.exists():
             errors.append(
                 ValidationError(
                     _(
@@ -2725,7 +2747,7 @@ def __init__(self, release: CodebaseRelease):
         self.description = codebase.description.raw
         self.release_notes = release.release_notes.raw if release.release_notes else ""
         self.version = release.version_number
-        self.programming_languages = release.programming_languages.all()
+        self.release_languages = release.release_languages.all()
         self.os = release.os
         self.identifier = release.permanent_url
         self.url = release.permanent_url

django/library/serializers.py

@@ -37,6 +37,8 @@
     CodebaseReleaseDownload,
     Contributor,
     License,
+    ProgrammingLanguage,
+    ReleaseLanguage,
     CodebaseImage,
     PeerReviewerFeedback,
     PeerReviewInvitation,
@@ -63,6 +65,39 @@ class Meta:
         )
 
 
+class ProgrammingLanguageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ProgrammingLanguage
+        fields = (
+            "id",
+            "name",
+            "url",
+            "is_pinned",
+            "is_user_defined",
+        )
+
+class ReleaseLanguageSerializer(serializers.ModelSerializer):
+    programming_language = ProgrammingLanguageSerializer(read_only=True)
+    
+    # def create(self, validated_data):
+    #     programming_language_data = self.initial_data.pop("programming_language")
+    #     programming_language, created = ProgrammingLanguage.objects.get_or_create(
+    #         name=programming_language_data['name']
+    #     )
+    #     validated_data["programming_language"] = programming_language
+    #     instance = ReleaseLanguage(**validated_data)
+    #     instance.save()
+    #     return instance
+
+    class Meta:
+        model = ReleaseLanguage
+        fields = (
+            "programming_language",
+            "release",
+            "version",
+        )
+
+
 class ContributorSerializer(serializers.ModelSerializer):
     # Need an ID for Vue-Multiselect
     id = serializers.IntegerField(read_only=True)
@@ -563,7 +598,8 @@ class CodebaseReleaseSerializer(serializers.ModelSerializer):
     can_edit_originals = serializers.ReadOnlyField()
     os_display = serializers.ReadOnlyField(source="get_os_display")
     platforms = TagSerializer(many=True, source="platform_tags")
-    programming_languages = TagSerializer(many=True)
+    programming_language_tags = TagSerializer(many=True)
+    release_languages = ReleaseLanguageSerializer(read_only=True, many=True)
     submitter = RelatedUserSerializer(read_only=True, label="Submitter")
     version_number = serializers.ReadOnlyField()
     release_notes = MarkdownField(max_length=2048)
@@ -609,7 +645,7 @@ class Meta:
             "os_display",
             "peer_reviewed",
             "platforms",
-            "programming_languages",
+            "release_languages",
             "submitted_package",
             "submitter",
             "codebase",
@@ -634,17 +670,41 @@ def get_possible_licenses(self, instance):
         )
         return serialized.data
 
+    def resolve_language(self, language_name):
+        programming_language = ProgrammingLanguage.objects.filter(name__iexact=language_name).first()
+        if not programming_language:
+            programming_language = ProgrammingLanguage.objects.create(
+                name=language_name,
+                is_user_defined=True
+            )
+        return programming_language
+
     def update(self, instance, validated_data):
-        programming_languages = TagSerializer(
-            many=True, data=validated_data.pop("programming_languages")
-        )
         platform_tags = TagSerializer(
             many=True, data=validated_data.pop("platform_tags")
         )
 
-        set_tags(instance, programming_languages, "programming_languages")
         set_tags(instance, platform_tags, "platform_tags")
 
+        # Handle programming languages
+        release_languages_data = self.initial_data.pop("release_languages")
+        if release_languages_data:
+            # Clear existing programming languages
+            instance.release_languages.all().delete()
+
+
+            # Create new release languages
+            for release_language_data in release_languages_data:
+                language_data = release_language_data.get("programming_language")
+                if not language_data or "name" not in language_data:
+                    raise ValidationError("Malformed programming language data")
+                programming_language = self.resolve_language(language_data["name"])
+                ReleaseLanguage.objects.create(
+                    programming_language=programming_language,
+                    release=instance,
+                    version=release_language_data.get("version", ""),
+                )
+
         raw_license = validated_data.pop("license")
         existing_license = License.objects.get(name=raw_license["name"])
         instance.license = existing_license

django/library/tests/base.py

@@ -10,6 +10,8 @@
     CodebaseRelease,
     License,
     Role,
+    ProgrammingLanguage,
+    ReleaseLanguage,
     Contributor,
     PeerReviewInvitation,
     PeerReview,
@@ -183,7 +185,10 @@ def setUpPublishableDraftRelease(cls, codebase):
         )
         draft_release.license, created = License.objects.get_or_create(name="MIT")
         draft_release.os = "Any"
-        draft_release.programming_languages.add("Python")
+        ReleaseLanguage.objects.create(
+            programming_language=ProgrammingLanguage.objects.get_or_create(name="Python"),
+            release=draft_release,
+        )
         contributor_factory = ContributorFactory(user=draft_release.submitter)
         release_contributor_factory = ReleaseContributorFactory(draft_release)
         contributor = contributor_factory.create()

django/library/tests/test_models.py

@@ -14,7 +14,7 @@
     ReleaseContributorFactory,
     ReleaseSetup,
 )
-from ..models import Codebase, CodebaseRelease, License
+from ..models import ProgrammingLanguage, ReleaseLanguage, Codebase, CodebaseRelease, License
 
 logger = logging.getLogger(__name__)
 
@@ -248,7 +248,11 @@ def test_metadata_completeness(self):
             ValidationError, lambda: self.codebase_release.validate_publishable()
         )
 
-        self.codebase_release.programming_languages.add("Java")
+        ReleaseLanguage.objects.create(
+            programming_language=ProgrammingLanguage.objects.get_or_create(name="Java"),
+            release=self.codebase_release,
+            version="8"
+        )
         self.assertRaises(
             ValidationError, lambda: self.codebase_release.validate_publishable()
         )

django/library/tests/test_views.py

@@ -19,7 +19,7 @@
 )
 from library.forms import PeerReviewerFeedbackReviewerForm
 from library.fs import FileCategoryDirectories
-from library.models import Codebase, CodebaseRelease, License, PeerReview
+from library.models import ProgrammingLanguage, ReleaseLanguage, Codebase, CodebaseRelease, License, PeerReview
 from library.tests.base import ReviewSetup
 from .base import (
     CodebaseFactory,
@@ -561,7 +561,11 @@ def test_publish_codebaserelease(self):
         )
         self.assertRaises(ValidationError, lambda: self.codebase_release.publish())
 
-        self.codebase_release.programming_languages.add("Java")
+        ReleaseLanguage.objects.create(
+            programming_language=ProgrammingLanguage.objects.get_or_create(name="Java"),
+            release=self.codebase_release,
+            version="8"
+        )
         self.codebase_release.publish()
 
         download_response = self.client.get(

django/library/urls.py

@@ -15,6 +15,7 @@
     r"codebases/(?P<identifier>[\w\-.]+)/releases", views.CodebaseReleaseViewSet
 )
 router.register(r"reviewers", views.PeerReviewerViewSet),
+router.register(r"programming-languages", views.ProgrammingLanguageViewSet),
 router.register(
     r"reviews/(?P<slug>[\da-f\-]+)/editor/invitations",
     views.PeerReviewInvitationViewSet,