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
 
+    parent_id_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:
+        # combine child filters with their parent in the same filter expression
+        parent_id = _filter.parent_id if _filter.parent_id is not None else _filter.id
+        filter_expressions = parent_id_to_filter_expressions[parent_id]
 
         # 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 parent_id_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 parent_id_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

@@ -57,10 +57,12 @@ def get_prepare_tasks_params(self, add_selected_items=False):
             for f in self.filter_group.filters.all():
                 items.append(
                     dict(
+                        id=f.id,
                         filter=f.column,
                         operator=f.operator,
                         type=f.type,
                         value=f.value,
+                        parent_id=f.parent.id if f.parent else None,
                     )
                 )
             filters = dict(conjunction=self.filter_group.conjunction, items=items)
@@ -86,7 +88,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

@@ -13,6 +13,9 @@ class FilterIn(BaseModel):
 
 
 class Filter(BaseModel):
+    id: Optional[int] = None  # Database ID of this filter (present in API responses)
+    parent_id: Optional[int] = None  # Parent filter DB ID (only for child filters)
+
     filter: str
     operator: str
     type: str

label_studio/data_manager/serializers.py

@@ -114,15 +114,41 @@ 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 two input formats:
+                # 1) "flat" list where potential children reference their parent via ``parent_index`` (legacy)
+                # 2) "nested" list where each root item may contain ``child_filters`` (new preferred format).
+
+                root_counter = 0  # keeps track of the current root filter index
+
+                def _append_filter(src_filter, parent_idx=None):
+                    """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', {}),
+                    }
+
+                    # Explicit parent reference by DB id (rare in create requests)
+                    if src_filter.get('parent') is not None:
+                        filter_payload['parent'] = src_filter.get('parent')
+
+                    data['filter_group']['filters'].append(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', {}),
-                        }
-                    )
+                    # Root filter itself
+                    _append_filter(f)
+
+                    # Process potential nested children
+                    child_filters = f.get('child_filters', []) or []
+                    for child in child_filters:
+                        _append_filter(child, parent_idx=root_counter)
+
+                    # Increment root index AFTER children have been processed so that
+                    # subsequent roots receive the proper index.
+                    root_counter += 1
 
         ordering = _data.pop('ordering', {})
         data['ordering'] = ordering
@@ -137,15 +163,28 @@ def to_representation(self, instance):
             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 = {
+                    'id': f.id,
+                    'filter': f.column,
+                    'operator': f.operator,
+                    'type': f.type,
+                    'value': f.value,
+                }
+
+                # Relationship hints
+                if f.parent_id:
+                    item['parent_id'] = f.parent_id
+                else:
+                    child_ids = list(f.children.all().values_list('id', flat=True))
+                    if child_ids:
+                        item['child_ids'] = child_ids
+
+                filters['items'].append(item)
             result['data']['filters'] = filters
 
         selected_items = result.pop('selected_items', {})
@@ -159,11 +198,41 @@ def to_representation(self, instance):
 
     @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) 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, '')
+
+            if not is_root:
+                continue
+
+            # Enumerate root filters for stable ordering
+            filter_data['index'] = next_index
+            next_index += 1
+
+            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, '')
+
+            if not has_parent_pk:
+                # Already processed as a root filter
+                continue
+
+            child_obj = Filter.objects.create(**filter_data)
+            filter_group.filters.add(child_obj)
 
     def create(self, validated_data):
         with transaction.atomic():

label_studio/tests/data_manager/test_views_api.py

@@ -149,7 +149,10 @@ def test_views_api_filters(business_client, project_id):
     )
 
     assert response.status_code == 200, response.content
-    assert response.json()['data'] == payload['data']
+    response_data = response.json()['data']
+    for item in response_data['filters']['items']:
+        item.pop('id')
+    assert response_data == payload['data']
 
     updated_payload = dict(
         project=project_id,
@@ -187,7 +190,10 @@ def test_views_api_filters(business_client, project_id):
     )
 
     assert response.status_code == 200, response.content
-    assert response.json()['data'] == updated_payload['data']
+    response_data = response.json()['data']
+    for item in response_data['filters']['items']:
+        item.pop('id')
+    assert response_data == updated_payload['data']
 
 
 def test_views_ordered_by_id(business_client, project_id):

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