chore: update tests

Author: rishisurana-labelbox

libs/labelbox/tests/data/annotation_import/conftest.py

@@ -1630,82 +1630,6 @@ def video_checklist_inference(prediction_id_mapping):
     return checklists
 
 
-@pytest.fixture
-def audio_checklist_inference(prediction_id_mapping):
-    """Audio temporal checklist inference with frame-based timing"""
-    checklists = []
-    for feature in prediction_id_mapping:
-        if "checklist" not in feature:
-            continue
-        checklist = feature["checklist"].copy()
-        checklist.update(
-            {
-                "answers": [
-                    {"name": "first_checklist_answer"},
-                    {"name": "second_checklist_answer"},
-                ],
-                "frame": 2500,  # 2.5 seconds in milliseconds
-            }
-        )
-        del checklist["tool"]
-        checklists.append(checklist)
-    return checklists
-
-
-@pytest.fixture
-def audio_text_inference(prediction_id_mapping):
-    """Audio temporal text inference with frame-based timing"""
-    texts = []
-    for feature in prediction_id_mapping:
-        if "text" not in feature:
-            continue
-        text = feature["text"].copy()
-        text.update({
-            "answer": "free form text...",
-            "frame": 5000,  # 5.0 seconds in milliseconds
-        })
-        del text["tool"]
-        texts.append(text)
-    return texts
-
-
-@pytest.fixture
-def audio_radio_inference(prediction_id_mapping):
-    """Audio temporal radio inference with frame-based timing"""
-    radios = []
-    for feature in prediction_id_mapping:
-        if "radio" not in feature:
-            continue
-        radio = feature["radio"].copy()
-        radio.update({
-            "answer": {"name": "first_radio_answer"},
-            "frame": 7500,  # 7.5 seconds in milliseconds
-        })
-        del radio["tool"]
-        radios.append(radio)
-    return radios
-
-
-@pytest.fixture
-def audio_text_entity_inference(prediction_id_mapping):
-    """Audio temporal text entity inference with frame-based timing"""
-    entities = []
-    for feature in prediction_id_mapping:
-        if "text" not in feature:
-            continue
-        entity = feature["text"].copy()
-        entity.update({
-            "frame": 3000,  # 3.0 seconds in milliseconds
-            "location": {
-                "start": 0,
-                "end": 11,
-            }
-        })
-        del entity["tool"]
-        entities.append(entity)
-    return entities
-
-
 @pytest.fixture
 def message_single_selection_inference(
     prediction_id_mapping, mmc_example_data_row_message_ids
@@ -1843,18 +1767,9 @@ def annotations_by_media_type(
     radio_inference,
     radio_inference_index_mmc,
     text_inference_index_mmc,
-    audio_checklist_inference,
-    audio_text_inference,
-    audio_radio_inference,
-    audio_text_entity_inference,
 ):
     return {
-        MediaType.Audio: [
-            audio_checklist_inference, 
-            audio_text_inference, 
-            audio_radio_inference,
-            audio_text_entity_inference
-        ],
+        MediaType.Audio: [checklist_inference, text_inference],
         MediaType.Conversational: [
             checklist_inference_index,
             text_inference_index,
@@ -2094,7 +2009,7 @@ def _convert_to_plain_object(obj):
 
 @pytest.fixture
 def annotation_import_test_helpers() -> Type[AnnotationImportTestHelpers]:
-    return AnnotationImportTestHelpers
+    return AnnotationImportTestHelpers()
 
 
 @pytest.fixture()
@@ -2176,7 +2091,6 @@ def expected_export_v2_audio():
             {
                 "name": "checklist",
                 "value": "checklist",
-                "frame": 2500,
                 "checklist_answers": [
                     {
                         "name": "first_checklist_answer",
@@ -2193,34 +2107,11 @@ def expected_export_v2_audio():
             {
                 "name": "text",
                 "value": "text",
-                "frame": 5000,
                 "text_answer": {
                     "content": "free form text...",
                     "classifications": [],
                 },
             },
-            {
-                "name": "radio",
-                "value": "radio",
-                "frame": 7500,
-                "radio_answer": {
-                    "name": "first_radio_answer",
-                    "classifications": [],
-                },
-            },
-        ],
-        "objects": [
-            {
-                "name": "text",
-                "value": "text",
-                "frame": 3000,
-                "annotation_kind": "TextEntity",
-                "classifications": [],
-                "location": {
-                    "start": 0,
-                    "end": 11,
-                },
-            }
         ],
         "segments": {},
         "timestamp": {},

libs/labelbox/tests/data/annotation_import/test_generic_data_types.py

@@ -268,94 +268,6 @@ def test_import_mal_annotations(
     # MAL Labels cannot be exported and compared to input labels
 
 
-def test_audio_temporal_annotations_fixtures():
-    """Test that audio temporal annotation fixtures are properly structured"""
-    # This test verifies our fixtures work without requiring the full integration environment
-
-    # Mock prediction_id_mapping structure that our fixtures expect
-    mock_prediction_id_mapping = [
-        {
-            "checklist": {
-                "tool": "checklist_tool",
-                "name": "checklist",
-                "value": "checklist",
-            },
-            "text": {"tool": "text_tool", "name": "text", "value": "text"},
-            "radio": {"tool": "radio_tool", "name": "radio", "value": "radio"},
-        }
-    ]
-
-    # Test that our fixtures can process the mock data
-    # Note: We can't actually call the fixtures directly in a unit test,
-    # but we can verify the structure is correct by checking the fixture definitions
-
-    # Verify that our fixtures are properly defined and accessible
-    from .conftest import (
-        audio_checklist_inference,
-        audio_text_inference,
-        audio_radio_inference,
-        audio_text_entity_inference,
-    )
-
-    # Check that all required fixtures exist
-    assert audio_checklist_inference is not None
-    assert audio_text_inference is not None
-    assert audio_radio_inference is not None
-    assert audio_text_entity_inference is not None
-
-    # Verify the fixtures are callable (they should be functions)
-    assert callable(audio_checklist_inference)
-    assert callable(audio_text_inference)
-    assert callable(audio_radio_inference)
-    assert callable(audio_text_entity_inference)
-
-
-def test_audio_temporal_annotations_integration(
-    client: Client,
-    configured_project: Project,
-    annotations_by_media_type,
-    media_type=MediaType.Audio,
-):
-    """Test that audio temporal annotations work correctly in the integration framework"""
-    # Filter to only audio annotations
-    audio_annotations = annotations_by_media_type[MediaType.Audio]
-
-    # Verify we have the expected audio temporal annotations
-    assert len(audio_annotations) == 4  # checklist, text, radio, text_entity
-
-    # Check that temporal annotations have frame information
-    for annotation in audio_annotations:
-        if "frame" in annotation:
-            assert isinstance(annotation["frame"], int)
-            assert annotation["frame"] >= 0
-            # Verify frame values are in milliseconds (reasonable range for audio)
-            assert annotation["frame"] <= 600000  # 10 minutes max
-
-    # Test import with audio temporal annotations
-    label_import = lb.LabelImport.create_from_objects(
-        client,
-        configured_project.uid,
-        f"test-import-audio-temporal-{uuid.uuid4()}",
-        audio_annotations,
-    )
-    label_import.wait_until_done()
-
-    # Verify import was successful
-    assert label_import.state == AnnotationImportState.FINISHED
-    assert len(label_import.errors) == 0
-
-    # Verify all annotations were imported successfully
-    all_annotations = sorted([a["uuid"] for a in audio_annotations])
-    successful_annotations = sorted(
-        [
-            status["uuid"]
-            for status in label_import.statuses
-            if status["status"] == "SUCCESS"
-        ]
-    )
-    assert successful_annotations == all_annotations
-
-
 @pytest.mark.parametrize(
     "configured_project_by_global_key, media_type",
     [