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

tests/exports/test_entities.py

@@ -0,0 +1,236 @@
+import pytest
+from spb_onprem.exports.entities import Export
+from spb_onprem.data.params import DataListFilter, DataFilterOptions
+
+
+class TestExport:
+    def test_export_creation_minimal(self):
+        # Given
+        export_data = {
+            "id": "test_export_id",
+            "datasetId": "test_dataset_id"
+        }
+        
+        # When
+        export = Export.model_validate(export_data)
+        
+        # Then
+        assert export.id == "test_export_id"
+        assert export.dataset_id == "test_dataset_id"
+        assert export.name is None
+        assert export.data_filter is None
+        assert export.location is None
+        assert export.data_count is None
+        assert export.annotation_count is None
+        assert export.frame_count is None
+        assert export.meta is None
+        assert export.created_at is None
+        assert export.created_by is None
+        assert export.updated_at is None
+        assert export.updated_by is None
+        assert export.completed_at is None
+    
+    def test_export_creation_full(self):
+        # Given
+        export_data = {
+            "id": "test_export_id",
+            "datasetId": "test_dataset_id",
+            "name": "test_export_name",
+            "dataFilter": {"must": {"keyContains": "test"}},
+            "location": "s3://test-bucket/exports/",
+            "dataCount": 100,
+            "annotationCount": 50,
+            "frameCount": 25,
+            "meta": {"created_by": "test_user", "version": 1},
+            "createdAt": "2024-01-01T00:00:00Z",
+            "createdBy": "test_user",
+            "updatedAt": "2024-01-01T12:00:00Z",
+            "updatedBy": "test_user",
+            "completedAt": "2024-01-01T13:00:00Z"
+        }
+        
+        # When
+        export = Export.model_validate(export_data)
+        
+        # Then
+        assert export.id == "test_export_id"
+        assert export.dataset_id == "test_dataset_id"
+        assert export.name == "test_export_name"
+        assert isinstance(export.data_filter, DataListFilter)
+        assert export.data_filter.must_filter.key_contains == "test"
+        assert export.location == "s3://test-bucket/exports/"
+        assert export.data_count == 100
+        assert export.annotation_count == 50
+        assert export.frame_count == 25
+        assert export.meta == {"created_by": "test_user", "version": 1}
+        assert export.created_at == "2024-01-01T00:00:00Z"
+        assert export.created_by == "test_user"
+        assert export.updated_at == "2024-01-01T12:00:00Z"
+        assert export.updated_by == "test_user"
+        assert export.completed_at == "2024-01-01T13:00:00Z"
+    
+    def test_export_field_aliases(self):
+        # Given
+        export_data = {
+            "id": "test_export_id",
+            "datasetId": "test_dataset_id",
+            "dataFilter": {"must": {"keyContains": "filter"}},
+            "dataCount": 100,
+            "annotationCount": 50,
+            "frameCount": 25,
+            "createdAt": "2024-01-01T00:00:00Z",
+            "createdBy": "test_user",
+            "updatedAt": "2024-01-01T12:00:00Z",
+            "updatedBy": "test_user",
+            "completedAt": "2024-01-01T13:00:00Z"
+        }
+        
+        # When
+        export = Export.model_validate(export_data)
+        
+        # Then - Test that aliases work correctly
+        assert export.dataset_id == "test_dataset_id"  # datasetId -> dataset_id
+        assert isinstance(export.data_filter, DataListFilter)
+        assert export.data_filter.must_filter.key_contains == "filter"
+        assert export.data_count == 100  # dataCount -> data_count
+        assert export.annotation_count == 50  # annotationCount -> annotation_count
+        assert export.frame_count == 25  # frameCount -> frame_count
+        assert export.created_at == "2024-01-01T00:00:00Z"  # createdAt -> created_at
+        assert export.created_by == "test_user"  # createdBy -> created_by
+        assert export.updated_at == "2024-01-01T12:00:00Z"  # updatedAt -> updated_at
+        assert export.updated_by == "test_user"  # updatedBy -> updated_by
+        assert export.completed_at == "2024-01-01T13:00:00Z"  # completedAt -> completed_at
+    
+    def test_export_model_dump_with_aliases(self):
+        # Given - Create export with DataListFilter
+        data_filter = DataListFilter(
+            must_filter=DataFilterOptions(key_contains="filter")
+        )
+        
+        export = Export(
+            id="test_export_id",
+            dataset_id="test_dataset_id",
+            name="test_export",
+            data_filter=data_filter,
+            location="s3://test-bucket/",
+            data_count=100,
+            annotation_count=50,
+            frame_count=25,
+            meta={"test": "meta"},
+            created_at="2024-01-01T00:00:00Z",
+            created_by="test_user",
+            updated_at="2024-01-01T12:00:00Z",
+            updated_by="test_user",
+            completed_at="2024-01-01T13:00:00Z"
+        )
+        
+        # When
+        dumped = export.model_dump(by_alias=True, exclude_unset=True)
+        
+        # Then - Test that field names are properly aliased in output
+        assert dumped["id"] == "test_export_id"
+        assert dumped["datasetId"] == "test_dataset_id"
+        assert dumped["name"] == "test_export"
+        assert "dataFilter" in dumped
+        assert dumped["dataFilter"]["must"]["keyContains"] == "filter"
+        assert dumped["location"] == "s3://test-bucket/"
+        assert dumped["dataCount"] == 100
+        assert dumped["annotationCount"] == 50
+        assert dumped["frameCount"] == 25
+        assert dumped["meta"] == {"test": "meta"}
+        assert dumped["createdAt"] == "2024-01-01T00:00:00Z"
+        assert dumped["createdBy"] == "test_user"
+        assert dumped["updatedAt"] == "2024-01-01T12:00:00Z"
+        assert dumped["updatedBy"] == "test_user"
+        assert dumped["completedAt"] == "2024-01-01T13:00:00Z"
+    
+    def test_export_required_fields_validation(self):
+        # Given - Missing required fields
+        export_data = {}
+        
+        # When/Then - Should raise validation error for missing required fields
+        with pytest.raises(Exception):  # ValidationError from pydantic
+            Export.model_validate(export_data)
+    
+    def test_export_required_dataset_id_validation(self):
+        # Given - Missing dataset_id
+        export_data = {
+            "id": "test_export_id"
+        }
+        
+        # When/Then - Should raise validation error for missing dataset_id
+        with pytest.raises(Exception):  # ValidationError from pydantic
+            Export.model_validate(export_data)
+    
+    def test_export_optional_fields_none(self):
+        # Given
+        export_data = {
+            "id": "test_export_id",
+            "datasetId": "test_dataset_id",
+            "name": None,
+            "dataFilter": None,
+            "location": None,
+            "dataCount": None,
+            "annotationCount": None,
+            "frameCount": None,
+            "meta": None,
+            "createdAt": None,
+            "createdBy": None,
+            "updatedAt": None,
+            "updatedBy": None,
+            "completedAt": None
+        }
+        
+        # When
+        export = Export.model_validate(export_data)
+        
+        # Then - All optional fields should be None
+        assert export.name is None
+        assert export.data_filter is None
+        assert export.location is None
+        assert export.data_count is None
+        assert export.annotation_count is None
+        assert export.frame_count is None
+        assert export.meta is None
+        assert export.created_at is None
+        assert export.created_by is None
+        assert export.updated_at is None
+        assert export.updated_by is None
+        assert export.completed_at is None
+    
+    def test_export_equality(self):
+        # Given
+        export1 = Export(
+            id="test_export_id",
+            dataset_id="test_dataset_id",
+            name="test_export"
+        )
+        export2 = Export(
+            id="test_export_id",
+            dataset_id="test_dataset_id",
+            name="test_export"
+        )
+        export3 = Export(
+            id="different_export_id",
+            dataset_id="test_dataset_id",
+            name="test_export"
+        )
+        
+        # When/Then
+        assert export1 == export2  # Same data should be equal
+        assert export1 != export3  # Different data should not be equal
+    
+    def test_export_string_representation(self):
+        # Given
+        export = Export(
+            id="test_export_id",
+            dataset_id="test_dataset_id",
+            name="test_export"
+        )
+        
+        # When
+        str_repr = str(export)
+        
+        # Then
+        assert "test_export_id" in str_repr
+        assert "test_dataset_id" in str_repr 

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!")