feat: ROOT-45: Filter by annotator prototype

label_studio/data_manager/managers.py

@@ -2,7 +2,9 @@
 """
 import logging
 import re
+from collections import defaultdict
 from datetime import datetime
+from functools import reduce
 from typing import ClassVar
 
 import ujson as json
@@ -261,11 +263,15 @@ def apply_filters(queryset, filters, project, request):
     if not filters:
         return queryset
 
+    index_to_filter_expressions: dict[int, list[Q]] = defaultdict(list)
+
     # convert conjunction to orm statement
-    filter_expressions = []
     custom_filter_expressions = load_func(settings.DATA_MANAGER_CUSTOM_FILTER_EXPRESSIONS)
 
-    for _filter in filters.items:
+    for index, _filter in enumerate(filters.items):
+        # combine child filters with their parent in the same filter expression
+        index = _filter.parent_index if _filter.parent_index is not None else index
+        filter_expressions = index_to_filter_expressions[index]
 
         # we can also have annotations filters
         if not _filter.filter.startswith('filter:tasks:') or _filter.value is None:
@@ -458,11 +464,13 @@ def apply_filters(queryset, filters, project, request):
     """
     if filters.conjunction == ConjunctionEnum.OR:
         result_filter = Q()
-        for filter_expression in filter_expressions:
+        for filter_expressions in index_to_filter_expressions.values():
+            filter_expression = reduce(lambda x, y: x & y, filter_expressions)
             result_filter.add(filter_expression, Q.OR)
         queryset = queryset.filter(result_filter)
     else:
-        for filter_expression in filter_expressions:
+        for filter_expressions in index_to_filter_expressions.values():
+            filter_expression = reduce(lambda x, y: x & y, filter_expressions)
             queryset = queryset.filter(filter_expression)
     return queryset
 

label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py

@@ -0,0 +1,38 @@
+# Generated by Django 5.1.10 on 2025-06-17 18:27
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("data_manager", "0012_alter_view_user"),
+    ]
+
+    operations = [
+        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",
+                db_index=False,
+            ),
+        ),
+        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/models.py

@@ -86,7 +86,25 @@ 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,
+        db_index=False,
+        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

@@ -17,6 +17,7 @@ class Filter(BaseModel):
     operator: str
     type: str
     value: Union[StrictInt, StrictFloat, StrictBool, StrictStr, FilterIn, list]
+    parent_index: Optional[int] = None
 
 
 class ConjunctionEnum(Enum):

label_studio/data_manager/serializers.py

@@ -22,6 +22,14 @@
 
 
 class FilterSerializer(serializers.ModelSerializer):
+    # Allow children filters to reference parent by root-filter index instead of DB id
+    parent_index = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        write_only=True,
+        help_text='Index of the parent filter inside the same FilterGroup (alternative to `parent` PK)',
+    )
+
     class Meta:
         model = Filter
         fields = '__all__'
@@ -121,6 +129,8 @@
                             'operator': f.get('operator', ''),
                             'type': f.get('type', ''),
                             'value': f.get('value', {}),
+                            'parent': f.get('parent'),
+                            'parent_index': f.get('parent_index'),
                         }
                     )
 
@@ -137,15 +147,19 @@
             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,
-                    }
-                )
+            # Root filters first (ordered by index), followed by child filters (any order)
+            roots = instance.filter_group.filters.filter(parent__isnull=True).order_by('index')
+            children = instance.filter_group.filters.filter(parent__isnull=False)
+            for f in list(roots) + list(children):
+                item = {
+                    'filter': f.column,
+                    'operator': f.operator,
+                    'type': f.type,
+                    'value': f.value,
+                }
+                if f.parent_id:
+                    item['parent'] = f.parent_id
+                filters['items'].append(item)
             result['data']['filters'] = filters
 
         selected_items = result.pop('selected_items', {})
@@ -159,11 +173,61 @@
 
     @staticmethod
     def _create_filters(filter_group, filters_data):
-        filter_index = 0
+        """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.
+        """
+
+        # Pass 1 — create root filters (no parent/parent_index) and build index→object map
+        index_to_filter = {}
+        next_index = 0
+        for filter_data in filters_data:
+            is_root = filter_data.get('parent') in (None, '') and filter_data.get('parent_index') in (None, '')
+
+            if not is_root:
+                continue
+
+            # Enumerate root filters for stable ordering
+            filter_data['index'] = next_index
+            next_index += 1
+
+            # Remove helper key before model instantiation
+            filter_data.pop('parent_index', None)
+
+            root_obj = Filter.objects.create(**filter_data)
+            filter_group.filters.add(root_obj)
+            index_to_filter[root_obj.index] = root_obj
+
+        # Pass 2 — create child filters, resolving parent via `parent` PK or `parent_index`
         for filter_data in filters_data:
-            filter_data['index'] = filter_index
-            filter_group.filters.add(Filter.objects.create(**filter_data))
-            filter_index += 1
+            has_parent_pk = filter_data.get('parent') not in (None, '')
+            has_parent_index = filter_data.get('parent_index') not in (None, '')
+
+            if not (has_parent_pk or has_parent_index):
+                # Already processed as a root filter
+                continue
+
+            fixed_data = filter_data.copy()
+
+            if has_parent_pk:
+                parent_obj = filter_group.filters.get(id=fixed_data['parent'])
+            else:
+                parent_idx = fixed_data.get('parent_index')
+                parent_obj = index_to_filter.get(parent_idx)
+                if parent_obj is None:
+                    raise serializers.ValidationError(
+                        f'parent_index={parent_idx} does not correspond to any root filter',
+                    )
+
+            fixed_data['parent'] = parent_obj
+            fixed_data['index'] = None  # Child filters do not participate in top-level ordering
+            fixed_data.pop('parent_index', None)
+
+            child_obj = Filter.objects.create(**fixed_data)
+            filter_group.filters.add(child_obj)
 
     def create(self, validated_data):
         with transaction.atomic():

web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx

@@ -31,6 +31,15 @@ const GroupWrapper = ({ children, wrap = false }) => {
 };
 
 export const FilterLine = observer(({ filter, availableFilters, index, view, sidebar, dropdownClassName }) => {
+  // Determine this filter's position in the master filters array; child filters store
+  // a reference to their parent via this absolute index, not the index within the
+  // (potentially filtered) list rendered in the sidebar. Using the absolute index
+  // guarantees that child filters are rendered inline with their correct parent
+  // even when the sidebar list omits them.
+  const parentIdx = filter.view.filters.indexOf(filter);
+
+  const childFilters = filter.view.filters.filter((f) => f.parent_index === parentIdx);
+
   return (
     <Block name="filter-line" tag={Fragment}>
       <GroupWrapper wrap={sidebar}>
@@ -72,6 +81,24 @@ export const FilterLine = observer(({ filter, availableFilters, index, view, sid
       </GroupWrapper>
       <GroupWrapper wrap={sidebar}>
         <FilterOperation filter={filter} value={filter.currentValue} operator={filter.operator} field={filter.field} />
+
+        {/* Render child filters (join filters) inline */}
+        {childFilters.map((child, idx) => {
+          console.debug("[DM] render child filter", { parent: filter, child });
+          return (
+            <Elem name="column" key={`child-${idx}`} mix="value">
+              <Tag size="small" className="filters-data-tag" color="#1d91e4" style={{ marginRight: 4 }}>
+                {child.field.title}
+              </Tag>
+              <FilterOperation
+                filter={child}
+                value={child.currentValue}
+                operator={child.operator}
+                field={child.field}
+              />
+            </Elem>
+          );
+        })}
       </GroupWrapper>
       <Elem name="remove">
         <Button