superb-ai-onprem 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

tests/exports/test_integration.py

@@ -0,0 +1,191 @@
+"""
+Integration test for the exports module.
+This test demonstrates how to use the exports module in a real scenario.
+Note: This test is commented out as it requires actual API credentials and dataset.
+"""
+
+from spb_onprem.exports import ExportService, ExportFilterOptions
+from spb_onprem.exports.params import ExportFilter
+
+
+def test_export_service_integration():
+    """
+    Integration test for ExportService.
+    
+    This test demonstrates the complete workflow of:
+    1. Creating an export
+    2. Getting exports with filtering
+    3. Getting a specific export
+    4. Updating an export
+    5. Deleting an export
+    
+    Note: This test is commented out as it requires actual API connection.
+    """
+    # Uncomment the following lines to run with real API
+    
+    # # Initialize the service
+    # export_service = ExportService()
+    # dataset_id = "your_dataset_id_here"
+    
+    # # 1. Create an export
+    # new_export = export_service.create_export(
+    #     dataset_id=dataset_id,
+    #     name="Test Export from SDK",
+    #     data_filter={"must": {"keyContains": "validation"}},
+    #     meta={"created_by": "integration_test", "purpose": "testing"}
+    # )
+    # print(f"Created export: {new_export.id}")
+    
+    # # 2. Get exports with filtering
+    # export_filter = ExportFilter(
+    #     must_filter=ExportFilterOptions(name_contains="Test Export")
+    # )
+    # exports, next_cursor, total_count = export_service.get_exports(
+    #     dataset_id=dataset_id,
+    #     export_filter=export_filter,
+    #     length=10
+    # )
+    # print(f"Found {len(exports)} exports, total: {total_count}")
+    
+    # # 3. Get a specific export
+    # if exports:
+    #     export_detail = export_service.get_export(
+    #         dataset_id=dataset_id,
+    #         export_id=exports[0].id
+    #     )
+    #     print(f"Export details: {export_detail.name}")
+    
+    # # 4. Update the export
+    # updated_export = export_service.update_export(
+    #     dataset_id=dataset_id,
+    #     export_id=new_export.id,
+    #     name="Updated Test Export",
+    #     meta={"updated_by": "integration_test", "status": "updated"}
+    # )
+    # print(f"Updated export name: {updated_export.name}")
+    
+    # # 5. Delete the export
+    # delete_result = export_service.delete_export(
+    #     dataset_id=dataset_id,
+    #     export_id=new_export.id
+    # )
+    # print(f"Export deleted: {delete_result}")
+    
+    # For now, just pass the test
+    assert True
+
+
+def test_export_filtering_examples():
+    """
+    Examples of how to use export filtering.
+    """
+    # Example 1: Filter by name containing specific text
+    name_filter = ExportFilter(
+        must_filter=ExportFilterOptions(name_contains="validation")
+    )
+    
+    # Example 2: Filter by exact name match
+    exact_name_filter = ExportFilter(
+        must_filter=ExportFilterOptions(name="My Export")
+    )
+    
+    # Example 3: Filter by location containing specific text
+    location_filter = ExportFilter(
+        must_filter=ExportFilterOptions(location_contains="s3://my-bucket")
+    )
+    
+    # Example 4: Complex filter with must and must not conditions
+    complex_filter = ExportFilter(
+        must_filter=ExportFilterOptions(
+            name_contains="production",
+            location_contains="s3://"
+        ),
+        not_filter=ExportFilterOptions(
+            name_contains="test"
+        )
+    )
+    
+    # Example 5: Filter by multiple IDs
+    id_filter = ExportFilter(
+        must_filter=ExportFilterOptions(
+            id_in=["export_id_1", "export_id_2", "export_id_3"]
+        )
+    )
+    
+    # All filters should be valid - test the objects themselves
+    assert isinstance(name_filter.must_filter, ExportFilterOptions)
+    assert isinstance(exact_name_filter.must_filter, ExportFilterOptions)
+    assert isinstance(location_filter.must_filter, ExportFilterOptions)
+    assert isinstance(complex_filter.must_filter, ExportFilterOptions)
+    assert isinstance(complex_filter.not_filter, ExportFilterOptions)
+    assert isinstance(id_filter.must_filter, ExportFilterOptions)
+
+
+def test_export_service_usage_patterns():
+    """
+    Demonstrates common usage patterns for the export service.
+    """
+    # Pattern 1: Pagination through all exports
+    def get_all_exports(export_service, dataset_id):
+        all_exports = []
+        cursor = None
+        
+        while True:
+            exports, next_cursor, _ = export_service.get_exports(
+                dataset_id=dataset_id,
+                cursor=cursor,
+                length=50  # Fetch 50 at a time
+            )
+            all_exports.extend(exports)
+            
+            if next_cursor is None:
+                break
+            cursor = next_cursor
+        
+        return all_exports
+    
+    # Pattern 2: Find exports by criteria
+    def find_exports_by_name(export_service, dataset_id, name_pattern):
+        filter_options = ExportFilter(
+            must_filter=ExportFilterOptions(name_contains=name_pattern)
+        )
+        
+        exports, _, _ = export_service.get_exports(
+            dataset_id=dataset_id,
+            export_filter=filter_options,
+            length=100
+        )
+        
+        return exports
+    
+    # Pattern 3: Bulk operations
+    def cleanup_test_exports(export_service, dataset_id):
+        test_filter = ExportFilter(
+            must_filter=ExportFilterOptions(name_contains="test")
+        )
+        
+        exports, _, _ = export_service.get_exports(
+            dataset_id=dataset_id,
+            export_filter=test_filter,
+            length=100
+        )
+        
+        deleted_count = 0
+        for export in exports:
+            if export_service.delete_export(dataset_id, export.id):
+                deleted_count += 1
+        
+        return deleted_count
+    
+    # These are just example functions, so we'll just assert they exist
+    assert callable(get_all_exports)
+    assert callable(find_exports_by_name)
+    assert callable(cleanup_test_exports)
+
+
+if __name__ == "__main__":
+    # Run the integration test
+    test_export_service_integration()
+    test_export_filtering_examples()
+    test_export_service_usage_patterns()
+    print("All integration tests passed!") 

tests/exports/test_params.py

@@ -0,0 +1,332 @@
+import pytest
+from datetime import datetime
+
+from spb_onprem.exports.params.create_export import create_export_params
+from spb_onprem.exports.params.update_export import update_export_params
+from spb_onprem.exports.params.export import get_export_params
+from spb_onprem.exports.params.delete_export import delete_export_params
+from spb_onprem.exports.params.exports import get_exports_params, ExportFilter, ExportFilterOptions
+from spb_onprem.exceptions import BadParameterError
+from spb_onprem.base_types import Undefined
+
+
+class TestCreateExportParams:
+    def test_create_export_params_minimal(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        
+        # When
+        params = create_export_params(dataset_id=dataset_id)
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert "location" not in params
+        assert "name" not in params
+        assert "data_filter" not in params
+        assert "meta" not in params
+    
+    def test_create_export_params_full(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        location = "s3://test-bucket/exports/"
+        name = "test_export"
+        data_filter = {"must": {"keyContains": "test"}}
+        data_count = 100
+        frame_count = 50
+        annotation_count = 25
+        meta = {"created_by": "test_user"}
+        
+        # When
+        params = create_export_params(
+            dataset_id=dataset_id,
+            location=location,
+            name=name,
+            data_filter=data_filter,
+            data_count=data_count,
+            frame_count=frame_count,
+            annotation_count=annotation_count,
+            meta=meta
+        )
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["location"] == location
+        assert params["name"] == name
+        assert params["data_filter"] == data_filter
+        assert params["data_count"] == data_count
+        assert params["frame_count"] == frame_count
+        assert params["annotation_count"] == annotation_count
+        assert params["meta"] == meta
+    
+    def test_create_export_params_missing_dataset_id(self):
+        # Given
+        dataset_id = None
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            create_export_params(dataset_id=dataset_id)
+        assert str(exc_info.value) == "Dataset ID is required"
+
+
+class TestUpdateExportParams:
+    def test_update_export_params_minimal(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = "test_export_id"
+        
+        # When
+        params = update_export_params(
+            dataset_id=dataset_id,
+            export_id=export_id
+        )
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["export_id"] == export_id
+        assert "location" not in params
+        assert "name" not in params
+        assert "data_filter" not in params
+        assert "meta" not in params
+    
+    def test_update_export_params_full(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = "test_export_id"
+        location = "s3://test-bucket/updated/"
+        name = "updated_export"
+        data_filter = {"must": {"updated": True}}
+        data_count = 200
+        frame_count = 100
+        annotation_count = 50
+        meta = {"updated_by": "test_user"}
+        completed_at = datetime(2024, 1, 1, 12, 0, 0)
+        
+        # When
+        params = update_export_params(
+            dataset_id=dataset_id,
+            export_id=export_id,
+            location=location,
+            name=name,
+            data_filter=data_filter,
+            data_count=data_count,
+            frame_count=frame_count,
+            annotation_count=annotation_count,
+            meta=meta,
+            completed_at=completed_at
+        )
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["export_id"] == export_id
+        assert params["location"] == location
+        assert params["name"] == name
+        assert params["data_filter"] == data_filter
+        assert params["data_count"] == data_count
+        assert params["frame_count"] == frame_count
+        assert params["annotation_count"] == annotation_count
+        assert params["meta"] == meta
+        assert params["completed_at"] == completed_at
+    
+    def test_update_export_params_missing_dataset_id(self):
+        # Given
+        dataset_id = None
+        export_id = "test_export_id"
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            update_export_params(dataset_id=dataset_id, export_id=export_id)
+        assert str(exc_info.value) == "Dataset ID is required"
+    
+    def test_update_export_params_missing_export_id(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = None
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            update_export_params(dataset_id=dataset_id, export_id=export_id)
+        assert str(exc_info.value) == "Export ID is required"
+
+
+class TestGetExportParams:
+    def test_get_export_params(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = "test_export_id"
+        
+        # When
+        params = get_export_params(dataset_id=dataset_id, export_id=export_id)
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["export_id"] == export_id
+    
+    def test_get_export_params_missing_dataset_id(self):
+        # Given
+        dataset_id = None
+        export_id = "test_export_id"
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            get_export_params(dataset_id=dataset_id, export_id=export_id)
+        assert str(exc_info.value) == "Dataset ID is required"
+    
+    def test_get_export_params_missing_export_id(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = None
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            get_export_params(dataset_id=dataset_id, export_id=export_id)
+        assert str(exc_info.value) == "Export ID is required"
+
+
+class TestDeleteExportParams:
+    def test_delete_export_params(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = "test_export_id"
+        
+        # When
+        params = delete_export_params(dataset_id=dataset_id, export_id=export_id)
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["export_id"] == export_id
+    
+    def test_delete_export_params_missing_dataset_id(self):
+        # Given
+        dataset_id = None
+        export_id = "test_export_id"
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            delete_export_params(dataset_id=dataset_id, export_id=export_id)
+        assert str(exc_info.value) == "Dataset ID is required"
+    
+    def test_delete_export_params_missing_export_id(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_id = None
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            delete_export_params(dataset_id=dataset_id, export_id=export_id)
+        assert str(exc_info.value) == "Export ID is required"
+
+
+class TestGetExportsParams:
+    def test_get_exports_params_minimal(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        
+        # When
+        params = get_exports_params(dataset_id=dataset_id)
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["length"] == 10
+        assert "filter" not in params
+        assert "cursor" not in params
+    
+    def test_get_exports_params_with_filter(self):
+        # Given
+        dataset_id = "test_dataset_id"
+        export_filter = ExportFilter(
+            must_filter=ExportFilterOptions(name="test_export"),
+            not_filter=ExportFilterOptions(location_contains="temp")
+        )
+        cursor = "test_cursor"
+        length = 20
+        
+        # When
+        params = get_exports_params(
+            dataset_id=dataset_id,
+            export_filter=export_filter,
+            cursor=cursor,
+            length=length
+        )
+        
+        # Then
+        assert params["dataset_id"] == dataset_id
+        assert params["length"] == length
+        assert params["cursor"] == cursor
+        assert "filter" in params
+        assert params["filter"]["must"]["name"] == "test_export"
+        assert params["filter"]["not"]["locationContains"] == "temp"
+    
+    def test_get_exports_params_missing_dataset_id(self):
+        # Given
+        dataset_id = None
+        
+        # When/Then
+        with pytest.raises(BadParameterError) as exc_info:
+            get_exports_params(dataset_id=dataset_id)
+        assert str(exc_info.value) == "Dataset ID is required"
+
+
+class TestExportFilterOptions:
+    def test_export_filter_options_creation(self):
+        # Given/When
+        filter_options = ExportFilterOptions(
+            id_in=["id1", "id2"],
+            name_contains="test",
+            name="exact_name",
+            location_contains="bucket",
+            location="s3://test-bucket/"
+        )
+        
+        # Then
+        assert filter_options.id_in == ["id1", "id2"]
+        assert filter_options.name_contains == "test"
+        assert filter_options.name == "exact_name"
+        assert filter_options.location_contains == "bucket"
+        assert filter_options.location == "s3://test-bucket/"
+    
+    def test_export_filter_options_aliases(self):
+        # Given/When
+        filter_options = ExportFilterOptions(
+            id_in=["id1", "id2"],
+            name_contains="test"
+        )
+        
+        # Then
+        dumped = filter_options.model_dump(by_alias=True)
+        assert dumped["idIn"] == ["id1", "id2"]
+        assert dumped["nameContains"] == "test"
+
+
+class TestExportFilter:
+    def test_export_filter_creation(self):
+        # Given
+        must_filter = ExportFilterOptions(name="test_export")
+        not_filter = ExportFilterOptions(location_contains="temp")
+        
+        # When
+        export_filter = ExportFilter(
+            must_filter=must_filter,
+            not_filter=not_filter
+        )
+        
+        # Then
+        assert export_filter.must_filter == must_filter
+        assert export_filter.not_filter == not_filter
+    
+    def test_export_filter_aliases(self):
+        # Given
+        must_filter = ExportFilterOptions(name="test_export")
+        not_filter = ExportFilterOptions(location_contains="temp")
+        export_filter = ExportFilter(
+            must_filter=must_filter,
+            not_filter=not_filter
+        )
+        
+        # When
+        dumped = export_filter.model_dump(by_alias=True, exclude_unset=True)
+        
+        # Then
+        assert "must" in dumped
+        assert "not" in dumped
+        assert dumped["must"]["name"] == "test_export"
+        assert dumped["not"]["locationContains"] == "temp"