fix(SUP-2586): do not return annotations if not asked

FannyGaudin · FannyGaudin · commit ba6bc01edb5f · 2026-02-11T16:22:41.000+01:00
diff --git a/src/kili/adapters/kili_api_gateway/asset/operations.py b/src/kili/adapters/kili_api_gateway/asset/operations.py
@@ -30,9 +30,3 @@ def get_assets_query(fragment: str) -> str:
   external_ids: filterExistingAssets(projectID: $projectID, externalIDs: $externalIDs)
 }
 """
-
-GQL_COUNT_ASSET_ANNOTATIONS = """
-query countAssetAnnotations($where: AssetWhere!) {
-    data: countAssetAnnotations(where: $where)
-}
-"""
diff --git a/src/kili/adapters/kili_api_gateway/asset/operations_mixin.py b/src/kili/adapters/kili_api_gateway/asset/operations_mixin.py
@@ -2,16 +2,11 @@
 
 from collections.abc import Generator
 
-from kili_formats.tool.annotations_to_json_response import (
-    AnnotationsToJsonResponseConverter,
-)
-
 from kili.adapters.kili_api_gateway.asset.formatters import (
     load_asset_json_fields,
 )
 from kili.adapters.kili_api_gateway.asset.mappers import asset_where_mapper
 from kili.adapters.kili_api_gateway.asset.operations import (
-    GQL_COUNT_ASSET_ANNOTATIONS,
     GQL_COUNT_ASSETS,
     GQL_CREATE_UPLOAD_BUCKET_SIGNED_URLS,
     GQL_FILTER_EXISTING_ASSETS,
@@ -23,18 +18,11 @@
     QueryOptions,
     fragment_builder,
 )
-from kili.adapters.kili_api_gateway.label.common import get_annotation_fragment
 from kili.adapters.kili_api_gateway.project.common import get_project
 from kili.core.graphql.operations.asset.mutations import GQL_SET_ASSET_CONSENSUS
 from kili.domain.asset import AssetFilters
 from kili.domain.types import ListOrTuple
 
-# Threshold for batching based on number of annotations
-# This is used to determine whether to use a single batch or multiple batches
-# when fetching assets. If the number of annotations counted exceeds this threshold,
-# the asset fetch will be done in multiple smaller batches to avoid performance issues.
-THRESHOLD_FOR_BATCHING = 200
-
 
 class AssetOperationMixin(BaseOperationMixin):
     """Mixin extending Kili API Gateway class with Assets related operations."""
@@ -46,9 +34,6 @@ def list_assets(
         options: QueryOptions,
     ) -> Generator[dict, None, None]:
         """List assets with given options."""
-        has_labels_url = "labels.jsonResponseUrl" in fields
-        has_latest_label_url = "latestLabel.jsonResponseUrl" in fields
-
         if "labels.jsonResponse" in fields or "latestLabel.jsonResponse" in fields:
             # Check if we can get the jsonResponse of if we need to rebuild it.
             project_info = get_project(
@@ -61,10 +46,7 @@ def list_assets(
                 "LLM_STATIC",
                 "GEOSPATIAL",
             }:
-                fetch_annotations = not (has_labels_url or has_latest_label_url)
-                yield from self.list_assets_split(
-                    filters, fields, options, project_info, fetch_annotations
-                )
+                yield from self.list_assets_split(filters, fields, options, project_info)
                 return
 
         fragment = fragment_builder(fields)
@@ -90,35 +72,24 @@ def list_assets_split(
         fields: ListOrTuple[str],
         options: QueryOptions,
         project_info,
-        fetch_annotations: bool,
     ) -> Generator[dict, None, None]:
         """List assets with given options."""
-        nb_annotations = self.count_assets_annotations(filters)
         assets_batch_max_amount = 10 if project_info["inputType"] == "VIDEO" else 50
         batch_size_to_use = min(options.batch_size, assets_batch_max_amount)
-        batch_size = (
-            1 if nb_annotations / batch_size_to_use > THRESHOLD_FOR_BATCHING else batch_size_to_use
-        )
 
-        options = QueryOptions(options.disable_tqdm, options.first, options.skip, batch_size)
-
-        static_fragments = {}
-        if fetch_annotations:
-            inner_annotation_fragment = get_annotation_fragment()
-            annotation_fragment = f"""
-                annotations {{
-                    {inner_annotation_fragment}
-                }}
-            """
-            static_fragments = {"labels": annotation_fragment, "latestLabel": annotation_fragment}
-
-            required_fields = {"content", "jsonContent", "resolution.width", "resolution.height"}
-            fields = list(fields)
-            for field in required_fields:
-                if field not in fields:
-                    fields.append(field)
-
-        fragment = fragment_builder(fields, static_fragments if static_fragments else None)
+        options = QueryOptions(options.disable_tqdm, options.first, options.skip, batch_size_to_use)
+
+        required_fields = {"content", "jsonContent", "resolution.width", "resolution.height"}
+        if "labels.jsonResponse" in fields:
+            required_fields.add("labels.jsonResponseUrl")
+        if "latestLabel.jsonResponse" in fields:
+            required_fields.add("latestLabel.jsonResponseUrl")
+        fields = list(fields)
+        for field in required_fields:
+            if field not in fields:
+                fields.append(field)
+
+        fragment = fragment_builder(fields)
         query = get_assets_query(fragment)
         where = asset_where_mapper(filters)
         assets_gen = PaginatedGraphQLQuery(self.graphql_client).execute_query_from_paginated_call(
@@ -128,28 +99,7 @@ def list_assets_split(
             load_asset_json_fields(asset, fields, self.http_client) for asset in assets_gen
         )
 
-        if fetch_annotations:
-            converter = AnnotationsToJsonResponseConverter(
-                json_interface=project_info["jsonInterface"],
-                project_input_type=project_info["inputType"],
-            )
-            is_requesting_annotations = any("annotations." in element for element in fields)
-            for asset in assets_gen:
-                if "latestLabel.jsonResponse" in fields and asset.get("latestLabel"):
-                    converter.patch_label_json_response(
-                        asset, asset["latestLabel"], asset["latestLabel"]["annotations"]
-                    )
-                    if not is_requesting_annotations:
-                        asset["latestLabel"].pop("annotations")
-
-                if "labels.jsonResponse" in fields:
-                    for label in asset.get("labels", []):
-                        converter.patch_label_json_response(asset, label, label["annotations"])
-                        if not is_requesting_annotations:
-                            label.pop("annotations")
-                yield asset
-        else:
-            yield from assets_gen
+        yield from assets_gen
 
     def count_assets(self, filters: AssetFilters) -> int:
         """Send a GraphQL request calling countIssues resolver."""
@@ -176,14 +126,6 @@ def filter_existing_assets(self, project_id: str, assets_external_ids: ListOrTup
         external_id_response = self.graphql_client.execute(GQL_FILTER_EXISTING_ASSETS, payload)
         return external_id_response["external_ids"]
 
-    def count_assets_annotations(self, filters: AssetFilters) -> int:
-        """Count the number of annotations for assets matching the filters."""
-        where = asset_where_mapper(filters)
-        payload = {"where": where}
-        count_result = self.graphql_client.execute(GQL_COUNT_ASSET_ANNOTATIONS, payload)
-        count: int = count_result["data"]
-        return count
-
     def update_asset_consensus(
         self,
         project_id: str,
diff --git a/src/kili/adapters/kili_api_gateway/label/operations_mixin.py b/src/kili/adapters/kili_api_gateway/label/operations_mixin.py
@@ -4,8 +4,6 @@
 from collections.abc import Generator
 from typing import Optional
 
-from kili_formats.tool.annotations_to_json_response import AnnotationsToJsonResponseConverter
-
 from kili.adapters.kili_api_gateway.base import BaseOperationMixin
 from kili.adapters.kili_api_gateway.helpers.queries import (
     PaginatedGraphQLQuery,
@@ -21,7 +19,6 @@
 from kili.domain.types import ListOrTuple
 from kili.utils.tqdm import tqdm
 
-from .common import get_annotation_fragment, get_asset
 from .formatters import load_label_json_fields
 from .mappers import append_label_data_mapper, append_to_labels_data_mapper, label_where_mapper
 from .operations import (
@@ -52,11 +49,7 @@ def list_labels(
         options: QueryOptions,
     ) -> Generator[dict, None, None]:
         """List labels."""
-        has_json_response_url = "jsonResponseUrl" in fields
-
         if "jsonResponse" in fields:
-            if "labelOf" not in fields:
-                fields = [*list(fields), "assetId"]
             project_info = get_project(
                 self.graphql_client, filters.project_id, ("inputType", "jsonInterface")
             )
@@ -67,10 +60,7 @@ def list_labels(
                 "LLM_INSTR_FOLLOWING",
                 "LLM_STATIC",
             }:
-                fetch_annotations = not has_json_response_url
-                yield from self.list_labels_split(
-                    filters, fields, options, project_info, fetch_annotations
-                )
+                yield from self.list_labels_split(filters, fields, options, project_info)
                 return
 
         fragment = fragment_builder(fields)
@@ -90,57 +80,27 @@ def list_labels_split(
         fields: ListOrTuple[str],
         options: QueryOptions,
         project_info,
-        fetch_annotations: bool,
     ) -> Generator[dict, None, None]:
         """List labels."""
         if project_info["inputType"] == "VIDEO":
             options = QueryOptions(
                 options.disable_tqdm, options.first, options.skip, min(options.batch_size, 20)
             )
 
-        fragment = fragment_builder(fields)
+        fields = list(fields)
+        if "jsonResponse" in fields and "jsonResponseUrl" not in fields:
+            fields.append("jsonResponseUrl")
 
-        if fetch_annotations:
-            inner_annotation_fragment = get_annotation_fragment()
-            full_fragment = f"""
-                {fragment}
-                annotations {{
-                    {inner_annotation_fragment}
-                }}
-            """
-        else:
-            full_fragment = fragment
-
-        query = get_labels_query(full_fragment)
+        fragment = fragment_builder(fields)
+        query = get_labels_query(fragment)
         where = label_where_mapper(filters)
         labels_gen = PaginatedGraphQLQuery(self.graphql_client).execute_query_from_paginated_call(
             query, where, options, "Retrieving labels", GQL_COUNT_LABELS
         )
         labels_gen = (
             load_label_json_fields(label, fields, self.http_client) for label in labels_gen
         )
-
-        if "jsonResponse" in fields and fetch_annotations:
-            converter = AnnotationsToJsonResponseConverter(
-                json_interface=project_info["jsonInterface"],
-                project_input_type=project_info["inputType"],
-            )
-            for label in labels_gen:
-                asset = None
-                if project_info["inputType"] == "VIDEO":
-                    asset = get_asset(
-                        self.graphql_client,
-                        self.http_client,
-                        label["assetId"],
-                        ["content", "jsonContent", "resolution.width", "resolution.height"],
-                    )
-                converter.patch_label_json_response(asset, label, label["annotations"])
-                if not any("annotations." in element for element in fields):
-                    label.pop("annotations")
-                yield label
-
-        else:
-            yield from labels_gen
+        yield from labels_gen
 
     def delete_labels(
         self, ids: ListOrTuple[LabelId], disable_tqdm: Optional[bool]
diff --git a/src/kili/llm/services/export/__init__.py b/src/kili/llm/services/export/__init__.py
@@ -58,7 +58,6 @@
     "externalId",
     "jsonMetadata",
     "labels.jsonResponse",
-    "labels.jsonResponseUrl",
     "labels.author.id",
     "labels.author.email",
     "labels.author.firstname",
diff --git a/src/kili/services/export/tools.py b/src/kili/services/export/tools.py
@@ -35,7 +35,6 @@
 DEFAULT_FIELDS = [
     *COMMON_FIELDS,
     "labels.jsonResponse",
-    "labels.jsonResponseUrl",
     "labels.author.id",
     "labels.author.email",
     "labels.author.firstname",
@@ -49,7 +48,6 @@
 LATEST_LABEL_FIELDS = [
     *COMMON_FIELDS,
     "latestLabel.jsonResponse",
-    "latestLabel.jsonResponseUrl",
     "latestLabel.author.id",
     "latestLabel.author.email",
     "latestLabel.author.firstname",
diff --git a/tests/integration/adapters/kili_api_gateway/test_asset.py b/tests/integration/adapters/kili_api_gateway/test_asset.py
@@ -6,9 +6,90 @@
 from kili.domain.project import ProjectId
 
 
+def test_given_video_project_only_latest_label_json_response_requested_annotations_not_fetched_for_labels(
+    graphql_client, http_client
+):
+    """For VIDEO projects, when only latestLabel.jsonResponse is requested (not labels.jsonResponse).
+
+    The annotations fragment should only be injected into latestLabel in the GraphQL query,
+    not into labels.
+    """
+    captured_queries = []
+
+    def mock_graphql_execute(query, *_args, **_kwargs) -> dict:
+        captured_queries.append(query)
+
+        if "countAssetAnnotations" in query:
+            return {"data": 1}
+
+        if "query countAssets" in query:
+            return {"data": 1}
+
+        if "projects(" in query:
+            return {
+                "data": [
+                    {
+                        "id": "project_id",
+                        "inputType": "VIDEO",
+                        "jsonInterface": '{"jobs": {}}',
+                    }
+                ]
+            }
+
+        if "query assets" in query:
+            return {
+                "data": [
+                    {
+                        "id": "fake_asset_id",
+                        "labels": [{"id": "label_id"}],
+                        "latestLabel": {
+                            "jsonResponseUrl": "https://storage.example.com/label.json",
+                        },
+                        "content": "",
+                        "jsonContent": "",
+                        "resolution": {"width": 100, "height": 100},
+                    }
+                ]
+            }
+
+        return None
+
+    mock_http_response = http_client.get.return_value
+    mock_http_response.json.return_value = {"jobs": {"OBJECT_DETECTION_JOB": {}}}
+
+    graphql_client.execute.side_effect = mock_graphql_execute
+
+    asset_operations = AssetOperationMixin()
+    asset_operations.graphql_client = graphql_client
+    asset_operations.http_client = http_client
+    filters = AssetFilters(project_id=ProjectId("project_id"))
+    fields = ["id", "labels.id", "latestLabel.jsonResponse"]
+
+    # when
+    assets = list(
+        asset_operations.list_assets(filters, fields, options=QueryOptions(disable_tqdm=None))
+    )
+
+    # then
+    assert len(assets) == 1
+    assert assets[0]["id"] == "fake_asset_id"
+    # jsonResponse was downloaded from jsonResponseUrl and jsonResponseUrl was removed
+    assert assets[0]["latestLabel"]["jsonResponse"] == {"jobs": {"OBJECT_DETECTION_JOB": {}}}
+    assert "jsonResponseUrl" not in assets[0]["latestLabel"]
+    # annotations were never fetched: not in latestLabel, not in labels
+    assert "annotations" not in assets[0]["latestLabel"]
+    assert "annotations" not in assets[0]["labels"][0]
+
+    # then: the GraphQL query fetches jsonResponseUrl for latestLabel, not annotations
+    assets_query = next(q for q in captured_queries if "query assets" in q)
+    assert "jsonResponseUrl" in assets_query  # latestLabel has the jsonResponseUrl fragment
+    assert "annotations" not in assets_query  # annotations fragment was not added
+    assert "labels{ id}" in assets_query  # labels block only has id
+
+
 def test_given_a_query_returning_serialized_json_it_parses_json_fields(graphql_client, http_client):
     # mocking
-    def mock_graphql_execute(query, variables, **kwargs):
+    def mock_graphql_execute(query, variables, **kwargs) -> dict | None:
         if "query assets" in query:
             label = {"jsonResponse": "{}"}
             return {
diff --git a/tests/unit/services/export/test_export.py b/tests/unit/services/export/test_export.py
@@ -858,7 +858,6 @@ def test_export_with_asset_filter_kwargs(mocker):
         "resolution.height",
         "resolution.width",
         "latestLabel.jsonResponse",
-        "latestLabel.jsonResponseUrl",
         "latestLabel.author.id",
         "latestLabel.author.email",
         "latestLabel.author.firstname",
