feat: ROOT-45: filter by annotator

label_studio/core/settings/base.py

@@ -776,7 +776,10 @@ def collect_versions_dummy(**kwargs):
 # By default, we disallow filters with foreign keys in data manager for security reasons.
 # Add to this list (either here in code, or via the env) to allow specific filters that rely on foreign keys.
 DATA_MANAGER_FILTER_ALLOWLIST = list(
-    set(get_env_list('DATA_MANAGER_FILTER_ALLOWLIST') + ['updated_by__active_organization'])
+    set(
+        get_env_list('DATA_MANAGER_FILTER_ALLOWLIST')
+        + ['updated_by__active_organization', 'annotations__completed_by']
+    )
 )
 
 if ENABLE_CSP := get_bool_env('ENABLE_CSP', True):

label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py

@@ -0,0 +1,39 @@
+# Generated by Django 5.1.10 on 2025-06-24 03:22
+
+import django.db.models.deletion
+import django_migration_linter as linter
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("data_manager", "0012_alter_view_user"),
+    ]
+
+    operations = [
+        linter.IgnoreMigration(),
+        migrations.AddField(
+            model_name="filter",
+            name="parent",
+            field=models.ForeignKey(
+                blank=True,
+                help_text="Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)",
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="children",
+                to="data_manager.filter",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="filter",
+            name="index",
+            field=models.IntegerField(
+                blank=True,
+                default=None,
+                help_text="Display order among root filters only",
+                null=True,
+                verbose_name="index",
+            ),
+        ),
+    ]

label_studio/data_manager/migrations/0014_merge_20250701_2259.py

@@ -0,0 +1,13 @@
+# Generated by Django 5.1.10 on 2025-07-01 22:59
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("data_manager", "0013_cleanup_inconsistent_filtergroup_20250624_2119"),
+        ("data_manager", "0013_filter_parent_alter_filter_index"),
+    ]
+
+    operations = []

label_studio/data_manager/models.py

@@ -50,20 +50,14 @@ class Meta:
 
 class View(ViewBaseModel, ProjectViewMixin):
     def get_prepare_tasks_params(self, add_selected_items=False):
+        # Import here to avoid circular imports
+        from data_manager.serializers import FilterGroupSerializer
+
         # convert filters to PrepareParams structure
         filters = None
         if self.filter_group:
-            items = []
-            for f in self.filter_group.filters.all():
-                items.append(
-                    dict(
-                        filter=f.column,
-                        operator=f.operator,
-                        type=f.type,
-                        value=f.value,
-                    )
-                )
-            filters = dict(conjunction=self.filter_group.conjunction, items=items)
+            serializer = FilterGroupSerializer()
+            filters = serializer.to_representation(self.filter_group)
 
         ordering = self.ordering
         if not ordering:
@@ -86,7 +80,24 @@ class FilterGroup(models.Model):
 
 
 class Filter(models.Model):
-    index = models.IntegerField(_('index'), default=0, help_text='To keep filter order')
+    # Optional reference to a parent filter. We only allow **one** level of nesting.
+    parent = models.ForeignKey(
+        'self',
+        on_delete=models.CASCADE,
+        related_name='children',
+        null=True,
+        blank=True,
+        help_text='Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)',
+    )
+
+    # `index` is now only meaningful for **root** filters (parent is NULL)
+    index = models.IntegerField(
+        _('index'),
+        null=True,
+        blank=True,
+        default=None,
+        help_text='Display order among root filters only',
+    )
     column = models.CharField(_('column'), max_length=1024, help_text='Field name')
     type = models.CharField(_('type'), max_length=1024, help_text='Field type')
     operator = models.CharField(_('operator'), max_length=1024, help_text='Filter operator')

label_studio/data_manager/prepare_params.py

@@ -12,6 +12,8 @@ class FilterIn(BaseModel):
 
 
 class Filter(BaseModel):
+    child_filter: Optional['Filter'] = None
+
     filter: str
     operator: str
     type: str

label_studio/data_manager/serializers.py

@@ -21,7 +21,35 @@
 from label_studio.core.utils.common import round_floats
 
 
+class ChildFilterSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Filter
+        fields = '__all__'
+
+    def to_representation(self, value):
+        parent = self.parent  # the owning FilterSerializer instance
+        serializer = parent.__class__(instance=value, context=self.context)
+        return serializer.data
+
+    def to_internal_value(self, data):
+        """Allow ChildFilterSerializer to be writable.
+
+        We instantiate the *parent* serializer class (which in this case is
+        ``FilterSerializer``) to validate the nested payload. The validated
+        data produced by that serializer is returned so that the enclosing
+        serializer (``FilterSerializer``) can include it in its own
+        ``validated_data`` structure.
+        """
+
+        parent_cls = self.parent.__class__  # FilterSerializer
+        serializer = parent_cls(data=data, context=self.context)
+        serializer.is_valid(raise_exception=True)
+        return serializer.validated_data
+
+
 class FilterSerializer(serializers.ModelSerializer):
+    child_filter = ChildFilterSerializer(required=False)
+
     class Meta:
         model = Filter
         fields = '__all__'
@@ -73,6 +101,35 @@ def validate_column(self, column: str) -> str:
 class FilterGroupSerializer(serializers.ModelSerializer):
     filters = FilterSerializer(many=True)
 
+    def to_representation(self, instance):
+        def _build_filter_tree(filter_obj):
+            """Build hierarchical filter representation."""
+            item = {
+                'filter': filter_obj.column,
+                'operator': filter_obj.operator,
+                'type': filter_obj.type,
+                'value': filter_obj.value,
+            }
+
+            # Add child filter if exists (only one level of nesting)
+            child_filters = filter_obj.children.all()
+            if child_filters:
+                child = child_filters[0]   # Only support one child
+                child_item = {
+                    'filter': child.column,
+                    'operator': child.operator,
+                    'type': child.type,
+                    'value': child.value,
+                }
+                item['child_filter'] = child_item
+
+            return item
+
+        # Only process root filters (ordered by index)
+        roots = instance.filters.filter(parent__isnull=True).prefetch_related('children').order_by('index')
+
+        return {'conjunction': instance.conjunction, 'items': [_build_filter_tree(f) for f in roots]}
+
     class Meta:
         model = FilterGroup
         fields = '__all__'
@@ -114,15 +171,26 @@ def to_internal_value(self, data):
         if 'filter_group' not in data and conjunction:
             data['filter_group'] = {'conjunction': conjunction, 'filters': []}
             if 'items' in filters:
+                # Support "nested" list where each root item may contain ``child_filters``
+
+                def _convert_filter(src_filter):
+                    """Convert a single filter JSON object into internal representation."""
+
+                    filter_payload = {
+                        'column': src_filter.get('filter', ''),
+                        'operator': src_filter.get('operator', ''),
+                        'type': src_filter.get('type', ''),
+                        'value': src_filter.get('value', {}),
+                    }
+
+                    if child_filter := src_filter.get('child_filter'):
+                        filter_payload['child_filter'] = _convert_filter(child_filter)
+
+                    return filter_payload
+
+                # Iterate over top-level items (roots)
                 for f in filters['items']:
-                    data['filter_group']['filters'].append(
-                        {
-                            'column': f.get('filter', ''),
-                            'operator': f.get('operator', ''),
-                            'type': f.get('type', ''),
-                            'value': f.get('value', {}),
-                        }
-                    )
+                    data['filter_group']['filters'].append(_convert_filter(f))
 
         ordering = _data.pop('ordering', {})
         data['ordering'] = ordering
@@ -131,21 +199,10 @@ def to_internal_value(self, data):
 
     def to_representation(self, instance):
         result = super().to_representation(instance)
+
+        # Handle filter_group serialization
         filters = result.pop('filter_group', {})
         if filters:
-            filters['items'] = []
-            filters.pop('filters', [])
-            filters.pop('id', None)
-
-            for f in instance.filter_group.filters.order_by('index'):
-                filters['items'].append(
-                    {
-                        'filter': f.column,
-                        'operator': f.operator,
-                        'type': f.type,
-                        'value': f.value,
-                    }
-                )
             result['data']['filters'] = filters
 
         selected_items = result.pop('selected_items', {})
@@ -159,11 +216,38 @@ def to_representation(self, instance):
 
     @staticmethod
     def _create_filters(filter_group, filters_data):
-        filter_index = 0
-        for filter_data in filters_data:
-            filter_data['index'] = filter_index
-            filter_group.filters.add(Filter.objects.create(**filter_data))
-            filter_index += 1
+        """Create Filter objects inside the provided ``filter_group``.
+
+        * For **root** filters (``parent`` is ``None``) we enumerate the
+          ``index`` so that the UI can preserve left-to-right order.
+        * For **child** filters we leave ``index`` as ``None`` – they are not
+          shown in the top-level ordering bar.
+        """
+
+        def _create_recursive(data, parent=None, index=None):
+
+            # Extract nested children early (if any) and remove them from payload
+            child_filter = data.pop('child_filter', None)
+
+            # Handle explicit parent reference present in the JSON payload only
+            # for root elements. For nested structures we rely on the actual
+            # ``parent`` FK object instead of its primary key.
+            if parent is not None:
+                data.pop('parent', None)
+
+            # Assign display order for root filters
+            if parent is None:
+                data['index'] = index
+
+            # Persist the filter
+            obj = Filter.objects.create(parent=parent, **data)
+            filter_group.filters.add(obj)
+
+            if child_filter:
+                _create_recursive(child_filter, parent=obj)
+
+        for index, data in enumerate(filters_data):
+            _create_recursive(data, index=index)
 
     def create(self, validated_data):
         with transaction.atomic():
@@ -190,6 +274,8 @@ def update(self, instance, validated_data):
                 filter_group = instance.filter_group
                 if filter_group is None:
                     filter_group = FilterGroup.objects.create(**filter_group_data)
+                    instance.filter_group = filter_group
+                    instance.save(update_fields=['filter_group'])
 
                 conjunction = filter_group_data.get('conjunction')
                 if conjunction and filter_group.conjunction != conjunction: