feat(LAB-3719): add enrich_geojson_with_kili_properties

Author: paulruelle

src/kili/presentation/client/label.py

@@ -48,6 +48,7 @@
 from kili.use_cases.label.process_shapefiles import get_json_response_from_shapefiles
 from kili.use_cases.label.types import LabelToCreateUseCaseInput
 from kili.use_cases.project.project import ProjectUseCases
+from kili.utils.labels.geojson import enrich_geojson_with_kili_properties
 from kili.utils.labels.parsing import ParsedLabel
 from kili.utils.logcontext import for_all_methods, log_call
 
@@ -1413,23 +1414,29 @@ def append_labels_from_geojson_files(
 
         This method processes GeoJSON feature collections, converts them to the appropriate
         Kili annotation format, and appends them as labels to the specified asset.
-        The GeoJSON features must contain job names and category information in their properties.
+        The GeoJSON features can contain job names and category information in their properties,
+        or they will be automatically mapped based on geometry type and available jobs.
 
         Args:
             project_id: The ID of the Kili project to add the labels to.
             asset_external_id: The external ID of the asset to label.
             geojson_file_paths: List of file paths to the GeoJSON files to be processed.
-                Each file should contain a FeatureCollection with features that have
+                Each file should contain a FeatureCollection with features that optionally have
                 'kili' metadata in their properties, including 'job', 'type', and 'categories'.
 
         Note:
-            The GeoJSON features must contain a 'kili' property with the following structure:
+            The GeoJSON features can contain a 'kili' property with the following structure:
             - 'job': The name of the job in the Kili project
             - 'type': The annotation type ('marker', 'polyline', 'semantic', etc.)
             - 'categories': List of category objects with 'name' field
 
+            If 'kili' properties are missing, they will be automatically mapped based on:
+            - Point geometries → first 'marker' job
+            - LineString geometries → first 'polyline' job
+            - Polygon geometries → first 'polygon' job, or 'semantic' if no polygon job found
+            - MultiPolygon geometries → first job with 'semantic' tool
+
             Supported geometries: Point, LineString, Polygon, and MultiPolygon.
-            Polygon and MultiPolygon are always mapped to semantic segmentation jobs in Kili.
 
         Examples:
             >>> kili.append_labels_from_geojson_files(
@@ -1438,13 +1445,23 @@ def append_labels_from_geojson_files(
                     geojson_file_paths=["annotations.geojson"]
                 )
         """
+        json_interface = self.kili_api_gateway.get_project(
+            ProjectId(project_id), ("jsonInterface",)
+        )["jsonInterface"]
+
         merged_json_response = {}
 
         for file_path in geojson_file_paths:
             with open(file_path, encoding="utf-8") as f:
                 feature_collection = json.load(f)
 
-            json_response = geojson_feature_collection_to_kili_json_response(feature_collection)
+            enriched_feature_collection = enrich_geojson_with_kili_properties(
+                feature_collection, json_interface
+            )
+
+            json_response = geojson_feature_collection_to_kili_json_response(
+                enriched_feature_collection
+            )
 
             for job_name, job_data in json_response.items():
                 if job_name not in merged_json_response:

src/kili/utils/labels/geojson.py

@@ -0,0 +1,101 @@
+from typing import Dict
+
+
+def enrich_geojson_with_kili_properties(feature_collection: Dict, json_interface: Dict) -> Dict:
+    """Enrich GeoJSON features with kili properties when missing.
+
+    Args:
+        feature_collection: The GeoJSON feature collection to enrich
+        json_interface: The project's JSON interface containing job definitions
+
+    Returns:
+        The enriched feature collection with kili properties added where needed
+    """
+    object_detection_jobs = {}
+    if "jobs" in json_interface:
+        for job_name, job_config in json_interface["jobs"].items():
+            if job_config.get("mlTask") == "OBJECT_DETECTION":
+                object_detection_jobs[job_name] = job_config
+
+    marker_job = None
+    polyline_job = None
+    polygon_job = None
+    semantic_job = None
+
+    for job_name, job_config in object_detection_jobs.items():
+        tools = job_config.get("tools", [])
+        if "marker" in tools and marker_job is None:
+            marker_job = (job_name, job_config)
+        if "polyline" in tools and polyline_job is None:
+            polyline_job = (job_name, job_config)
+        if "polygon" in tools and polygon_job is None:
+            polygon_job = (job_name, job_config)
+        if "semantic" in tools and semantic_job is None:
+            semantic_job = (job_name, job_config)
+
+    def get_first_category_name(job_config):
+        categories = job_config.get("content", {}).get("categories", {})
+        if categories:
+            first_category_key = next(iter(categories.keys()))
+            return first_category_key
+        return None
+
+    def create_kili_property(job_name, job_config, annotation_type):
+        category_name = get_first_category_name(job_config)
+        if category_name:
+            return {
+                "kili": {
+                    "children": {},
+                    "categories": [{"name": category_name}],
+                    "type": annotation_type,
+                    "job": job_name,
+                }
+            }
+        return None
+
+    enriched_features = []
+
+    for feature in feature_collection.get("features", []):
+        # Skip if feature already has kili properties
+        if feature.get("properties", {}).get("kili") is not None:
+            enriched_features.append(feature)
+            continue
+
+        # Skip features with null geometry unless they have kili properties
+        if feature.get("geometry") is None:
+            continue
+
+        geometry_type = feature.get("geometry", {}).get("type")
+        kili_property = None
+
+        if geometry_type == "Point" and marker_job:
+            job_name, job_config = marker_job
+            kili_property = create_kili_property(job_name, job_config, "marker")
+
+        elif geometry_type == "LineString" and polyline_job:
+            job_name, job_config = polyline_job
+            kili_property = create_kili_property(job_name, job_config, "polyline")
+
+        elif geometry_type == "Polygon":
+            if polygon_job:
+                job_name, job_config = polygon_job
+                kili_property = create_kili_property(job_name, job_config, "polygon")
+            elif semantic_job:
+                job_name, job_config = semantic_job
+                kili_property = create_kili_property(job_name, job_config, "semantic")
+
+        elif geometry_type == "MultiPolygon" and semantic_job:
+            job_name, job_config = semantic_job
+            kili_property = create_kili_property(job_name, job_config, "semantic")
+
+        if kili_property:
+            if "properties" not in feature:
+                feature["properties"] = {}
+            feature["properties"].update(kili_property)
+            enriched_features.append(feature)
+        else:
+            continue
+
+    enriched_collection = feature_collection.copy()
+    enriched_collection["features"] = enriched_features
+    return enriched_collection