fix(predictions): allow deleting predictions imported without model_version

Issue #9717 — imported predictions whose model_version was missing could
not be deleted via DELETE /api/projects/<pk>/model-versions. Three legacy
import paths defaulted the field to the literal string 'undefined' while
other paths stored NULL, and the FE echoed those values back to a delete
endpoint that rejected anything falsy.

Backend
- Three import sites (data_import/api.py × 2, tasks/serializers.py) now
  store None instead of 'undefined' when the field is missing from input.
- DELETE /api/projects/<pk>/model-versions accepts JSON null, empty
  string, and the legacy 'undefined' string as "no model version" and
  routes them through a single isnull-aware delete path.
- Project.delete_predictions(None) sweeps NULL / '' / 'undefined' together
  so callers do not have to know about the pre-migration data layout.
- Migration tasks/0062 backfills 'undefined' rows to NULL.

Frontend
- PredictionsList renders "No model version" with an explanatory tooltip
  for falsy and legacy-'undefined' values; the stale === "undefined"
  comparison is gone.

Tests
- projects/tests/test_api.py adds TestDeletePredictionsAPI covering
  specific version, JSON null, empty string, legacy 'undefined', mixed
  null-ish sweep, and missing-key 400.

Related: review of upstream PR #9735.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: kcw2034

label_studio/data_import/api.py

@@ -549,7 +549,7 @@ def _create_memory_efficient(self, project):
                         project_id=project.id,
                         result=Prediction.prepare_prediction_result(item.get('result'), project),
                         score=item.get('score'),
-                        model_version=item.get('model_version', 'undefined'),
+                        model_version=item.get('model_version') or None,
                     )
                 )
                 all_task_ids.add(task_id)
@@ -623,7 +623,7 @@ def _create_legacy(self, project):
                         project_id=project.id,
                         result=Prediction.prepare_prediction_result(item.get('result'), project),
                         score=item.get('score'),
-                        model_version=item.get('model_version', 'undefined'),
+                        model_version=item.get('model_version') or None,
                     )
                 )
             except Exception as e:

label_studio/projects/api.py

@@ -881,13 +881,19 @@ def get(self, request, *args, **kwargs):
 
     def delete(self, request, *args, **kwargs):
         project = self.get_object()
-        model_version = request.data.get('model_version', None)
 
-        if not model_version:
+        if 'model_version' not in request.data:
             raise RestValidationError('model_version param is required')
+        model_version = request.data.get('model_version')
 
-        count = project.delete_predictions(model_version=model_version)
+        # Normalize representations of "no model version" to None. JSON null
+        # already arrives as None; the empty string is the model field default,
+        # and the literal string 'undefined' is legacy data from older imports
+        # (see migration that backfills it to NULL).
+        if model_version in (None, '', 'undefined'):
+            model_version = None
 
+        count = project.delete_predictions(model_version=model_version)
         return Response(data=count)
 
 

label_studio/projects/models.py

@@ -797,20 +797,24 @@ def should_none_model_version(self, model_version):
 
     def delete_predictions(self, model_version=None):
         """
-        Deletes the predictions based on the provided model version.
-        If no model version is provided, it deletes all the predictions for this project.
+        Deletes predictions for this project filtered by model version.
 
-        :param model_version: Identifier of the model version (default is None)
+        :param model_version: If None, deletes predictions whose model_version
+            is NULL, empty, or the legacy placeholder 'undefined' (predictions
+            imported without a version label — see the data migration that
+            backfills 'undefined' to NULL). Otherwise filters by exact match.
         :type model_version: str, optional
         :return: Dictionary with count of deleted predictions
         :rtype: dict
         """
-        params = {'project': self}
-
-        if model_version:
-            params.update({'model_version': model_version})
-
-        predictions = Prediction.objects.filter(**params)
+        if model_version is None:
+            predictions = Prediction.objects.filter(project=self).filter(
+                Q(model_version__isnull=True)
+                | Q(model_version='')
+                | Q(model_version='undefined')
+            )
+        else:
+            predictions = Prediction.objects.filter(project=self, model_version=model_version)
 
         with transaction.atomic():
             # If we are deleting specific model_version then we need

label_studio/projects/tests/test_api.py

@@ -90,3 +90,91 @@ def test_extended(self):
         assert response.json()['static'][1]['count'] == 1
         assert response.json()['static'][2]['model_version'] == 'model_1'
         assert response.json()['static'][2]['count'] == 2
+
+
+class TestDeletePredictionsAPI(APITestCase):
+    """Covers the DELETE /api/projects/<pk>/model-versions endpoint.
+
+    Regression coverage for issue #9717: predictions imported without a
+    model_version (stored as NULL, empty string, or the legacy 'undefined'
+    placeholder) must be deletable.
+    """
+
+    def setUp(self):
+        self.project = ProjectFactory()
+        self.user = self.project.created_by
+        self.task = TaskFactory(project=self.project)
+        self.client.force_authenticate(user=self.user)
+        self.url = f'/api/projects/{self.project.id}/model-versions'
+
+    def _prediction_count(self, **filters):
+        return self.task.predictions.filter(**filters).count()
+
+    def test_delete_by_specific_version(self):
+        PredictionFactory(task=self.task, model_version='v1')
+        PredictionFactory(task=self.task, model_version='v1')
+        PredictionFactory(task=self.task, model_version='v2')
+
+        response = self.client.delete(self.url, data={'model_version': 'v1'}, format='json')
+
+        assert response.status_code == 200
+        assert self._prediction_count(model_version='v1') == 0
+        assert self._prediction_count(model_version='v2') == 1
+
+    def test_delete_null_version_via_json_null(self):
+        PredictionFactory(task=self.task, model_version=None)
+        PredictionFactory(task=self.task, model_version='v1')
+
+        response = self.client.delete(self.url, data={'model_version': None}, format='json')
+
+        assert response.status_code == 200
+        assert self._prediction_count(model_version__isnull=True) == 0
+        assert self._prediction_count(model_version='v1') == 1
+
+    def test_delete_null_version_via_empty_string(self):
+        PredictionFactory(task=self.task, model_version='')
+        PredictionFactory(task=self.task, model_version='v1')
+
+        response = self.client.delete(self.url, data={'model_version': ''}, format='json')
+
+        assert response.status_code == 200
+        assert self._prediction_count(model_version='') == 0
+        assert self._prediction_count(model_version='v1') == 1
+
+    def test_delete_legacy_undefined_string(self):
+        """Pre-migration rows have model_version='undefined'. Migration 0062
+        backfills these to NULL, but the API still accepts the legacy string
+        so it works during a rolling deployment.
+        """
+        PredictionFactory(task=self.task, model_version='undefined')
+        PredictionFactory(task=self.task, model_version='v1')
+
+        response = self.client.delete(self.url, data={'model_version': 'undefined'}, format='json')
+
+        assert response.status_code == 200
+        assert self._prediction_count(model_version='undefined') == 0
+        assert self._prediction_count(model_version='v1') == 1
+
+    def test_delete_null_version_groups_legacy_representations(self):
+        """A single null-version delete request should sweep NULL, empty, and
+        the legacy 'undefined' placeholder together so callers don't need to
+        know about the pre-migration data layout.
+        """
+        PredictionFactory(task=self.task, model_version=None)
+        PredictionFactory(task=self.task, model_version='')
+        PredictionFactory(task=self.task, model_version='undefined')
+        PredictionFactory(task=self.task, model_version='v1')
+
+        response = self.client.delete(self.url, data={'model_version': None}, format='json')
+
+        assert response.status_code == 200
+        assert self.task.predictions.exclude(model_version='v1').count() == 0
+        assert self._prediction_count(model_version='v1') == 1
+
+    def test_delete_requires_model_version_key(self):
+        PredictionFactory(task=self.task, model_version='v1')
+
+        response = self.client.delete(self.url, data={}, format='json')
+
+        assert response.status_code == 400
+        assert self._prediction_count(model_version='v1') == 1

label_studio/tasks/migrations/0062_backfill_undefined_model_version.py

@@ -0,0 +1,31 @@
+"""Backfill legacy `Prediction.model_version='undefined'` rows to NULL.
+
+Older code paths (`data_import/api.py`, `tasks/serializers.py`) defaulted the
+`model_version` field to the literal string `'undefined'` when an imported
+prediction did not specify one. That created two distinct "no version"
+representations (NULL and the string 'undefined') and caused the predictions
+delete endpoint to fail. The application layer now uses NULL as the canonical
+representation, and this migration normalizes existing rows.
+
+The reverse migration is intentionally a no-op: we cannot tell migrated rows
+apart from genuinely-NULL rows after the fact.
+"""
+
+from django.db import migrations
+
+
+def backfill_undefined_to_null(apps, schema_editor):
+    Prediction = apps.get_model('tasks', 'Prediction')
+    Prediction.objects.filter(model_version='undefined').update(model_version=None)
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('tasks', '0061_task_project_file_upload_idx_async'),
+    ]
+    operations = [
+        migrations.RunPython(
+            backfill_undefined_to_null,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]

label_studio/tasks/serializers.py

@@ -620,7 +620,7 @@ def add_predictions(self, task_predictions):
                             )
                             prediction_score = None
 
-                    last_model_version = prediction.get('model_version', 'undefined')
+                    last_model_version = prediction.get('model_version') or None
                     db_predictions.append(
                         Prediction(
                             task=self.db_tasks[i],

web/apps/labelstudio/src/pages/Settings/PredictionsSettings/PredictionsList.jsx

@@ -55,13 +55,15 @@ const VersionCard = ({ version, selected, onSelect, editable, onDelete }) => {
     [version, onDelete],
   );
 
+  const hasNoVersion = !version.model_version || version.model_version === "undefined";
+
   return (
     <div className={rootClass.toClassName()}>
       <div>
         <div className={rootClass.elem("title").toClassName()}>
-          {version.model_version}
-          {version.model_version === "undefined" && (
-            <Tooltip title="Model version is undefined. Likely means that model_version field was missing when predictions were imported.">
+          {hasNoVersion ? "No model version" : version.model_version}
+          {hasNoVersion && (
+            <Tooltip title="No model version on these predictions. Usually means the model_version field was missing when predictions were imported.">
               <IconInfoOutline className={cn("help-icon").toClassName()} width="14" height="14" />
             </Tooltip>
           )}