unstructured-ingest 0.7.1__py3-none-any.whl → 1.0.1__py3-none-any.whl

test/integration/connectors/test_astradb.py

@@ -1,287 +0,0 @@
-import contextlib
-import json
-import os
-from dataclasses import dataclass
-from pathlib import Path
-from uuid import uuid4
-
-import pytest
-from _pytest.fixtures import TopRequest
-from astrapy import Collection
-from astrapy import DataAPIClient as AstraDBClient
-
-from test.integration.connectors.utils.constants import DESTINATION_TAG, SOURCE_TAG, VECTOR_DB_TAG
-from test.integration.connectors.utils.validation.destination import (
-    StagerValidationConfigs,
-    stager_validation,
-)
-from test.integration.connectors.utils.validation.source import (
-    SourceValidationConfigs,
-    source_connector_validation,
-)
-from test.integration.utils import requires_env
-from unstructured_ingest.data_types.file_data import FileData, SourceIdentifiers
-from unstructured_ingest.processes.connectors.astradb import (
-    CONNECTOR_TYPE,
-    AstraDBAccessConfig,
-    AstraDBConnectionConfig,
-    AstraDBDownloader,
-    AstraDBDownloaderConfig,
-    AstraDBIndexer,
-    AstraDBIndexerConfig,
-    AstraDBUploader,
-    AstraDBUploaderConfig,
-    AstraDBUploadStager,
-    AstraDBUploadStagerConfig,
-    DestinationConnectionError,
-    SourceConnectionError,
-)
-
-EXISTENT_COLLECTION_NAME = "ingest_test_src"
-NONEXISTENT_COLLECTION_NAME = "nonexistant"
-
-
-@pytest.fixture
-def connection_config() -> AstraDBConnectionConfig:
-    return AstraDBConnectionConfig(
-        access_config=AstraDBAccessConfig(
-            token=os.environ["ASTRA_DB_APPLICATION_TOKEN"],
-            api_endpoint=os.environ["ASTRA_DB_API_ENDPOINT"],
-        )
-    )
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_APPLICATION_TOKEN", "ASTRA_DB_API_ENDPOINT")
-def test_precheck_succeeds_indexer(connection_config: AstraDBConnectionConfig):
-    indexer = AstraDBIndexer(
-        connection_config=connection_config,
-        index_config=AstraDBIndexerConfig(collection_name=EXISTENT_COLLECTION_NAME),
-    )
-    indexer.precheck()
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_APPLICATION_TOKEN", "ASTRA_DB_API_ENDPOINT")
-def test_precheck_succeeds_uploader(connection_config: AstraDBConnectionConfig):
-    uploader = AstraDBUploader(
-        connection_config=connection_config,
-        upload_config=AstraDBUploaderConfig(collection_name=EXISTENT_COLLECTION_NAME),
-    )
-    uploader.precheck()
-
-    uploader2 = AstraDBUploader(
-        connection_config=connection_config,
-        upload_config=AstraDBUploaderConfig(),
-    )
-    uploader2.precheck()
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_APPLICATION_TOKEN", "ASTRA_DB_API_ENDPOINT")
-def test_precheck_fails_indexer(connection_config: AstraDBConnectionConfig):
-    indexer = AstraDBIndexer(
-        connection_config=connection_config,
-        index_config=AstraDBIndexerConfig(collection_name=NONEXISTENT_COLLECTION_NAME),
-    )
-    with pytest.raises(expected_exception=SourceConnectionError):
-        indexer.precheck()
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_APPLICATION_TOKEN", "ASTRA_DB_API_ENDPOINT")
-def test_precheck_fails_uploader(connection_config: AstraDBConnectionConfig):
-    uploader = AstraDBUploader(
-        connection_config=connection_config,
-        upload_config=AstraDBUploaderConfig(collection_name=NONEXISTENT_COLLECTION_NAME),
-    )
-    with pytest.raises(expected_exception=DestinationConnectionError):
-        uploader.precheck()
-
-
-@dataclass(frozen=True)
-class EnvData:
-    api_endpoint: str
-    token: str
-
-
-def get_env_data() -> EnvData:
-    return EnvData(
-        api_endpoint=os.environ["ASTRA_DB_API_ENDPOINT"],
-        token=os.environ["ASTRA_DB_APPLICATION_TOKEN"],
-    )
-
-
-@pytest.fixture
-def collection(upload_file: Path) -> Collection:
-    random_id = str(uuid4())[:8]
-    collection_name = f"utic_test_{random_id}"
-    with upload_file.open("r") as upload_fp:
-        upload_data = json.load(upload_fp)
-    first_content = upload_data[0]
-    embeddings = first_content["embeddings"]
-    embedding_dimension = len(embeddings)
-    my_client = AstraDBClient()
-    env_data = get_env_data()
-    astra_db = my_client.get_database(
-        api_endpoint=env_data.api_endpoint,
-        token=env_data.token,
-    )
-    collection = astra_db.create_collection(collection_name, dimension=embedding_dimension)
-    try:
-        yield collection
-    finally:
-        astra_db.drop_collection(collection)
-
-
-@pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_API_ENDPOINT", "ASTRA_DB_APPLICATION_TOKEN")
-async def test_astra_search_source(
-    tmp_path: Path,
-):
-    env_data = get_env_data()
-    collection_name = "ingest_test_src"
-    connection_config = AstraDBConnectionConfig(
-        access_config=AstraDBAccessConfig(token=env_data.token, api_endpoint=env_data.api_endpoint)
-    )
-    indexer = AstraDBIndexer(
-        index_config=AstraDBIndexerConfig(
-            collection_name=collection_name,
-        ),
-        connection_config=connection_config,
-    )
-    downloader = AstraDBDownloader(
-        connection_config=connection_config,
-        download_config=AstraDBDownloaderConfig(download_dir=tmp_path),
-    )
-
-    await source_connector_validation(
-        indexer=indexer,
-        downloader=downloader,
-        configs=SourceValidationConfigs(
-            test_id=CONNECTOR_TYPE,
-            expected_num_files=5,
-            expected_number_indexed_file_data=1,
-            validate_downloaded_files=True,
-        ),
-    )
-
-
-@pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_API_ENDPOINT", "ASTRA_DB_APPLICATION_TOKEN")
-async def test_astra_search_destination(
-    upload_file: Path,
-    collection: Collection,
-    tmp_path: Path,
-):
-    file_data = FileData(
-        source_identifiers=SourceIdentifiers(fullpath=upload_file.name, filename=upload_file.name),
-        connector_type=CONNECTOR_TYPE,
-        identifier="mock file data",
-    )
-    stager = AstraDBUploadStager()
-    env_data = get_env_data()
-    uploader = AstraDBUploader(
-        connection_config=AstraDBConnectionConfig(
-            access_config=AstraDBAccessConfig(
-                api_endpoint=env_data.api_endpoint, token=env_data.token
-            ),
-        ),
-        upload_config=AstraDBUploaderConfig(collection_name=collection.name),
-    )
-    staged_filepath = stager.run(
-        elements_filepath=upload_file,
-        file_data=file_data,
-        output_dir=tmp_path,
-        output_filename=upload_file.name,
-    )
-    uploader.precheck()
-    uploader.run(path=staged_filepath, file_data=file_data)
-
-    # Run validation
-    with staged_filepath.open() as f:
-        staged_elements = json.load(f)
-    expected_count = len(staged_elements)
-    current_count = collection.count_documents(filter={}, upper_bound=expected_count * 2)
-    assert current_count == expected_count, (
-        f"Expected count ({expected_count}) doesn't match how "
-        f"much came back from collection: {current_count}"
-    )
-
-    # Rerun and make sure the same documents get updated
-    uploader.run(path=staged_filepath, file_data=file_data)
-    current_count = collection.count_documents(filter={}, upper_bound=expected_count * 2)
-    assert current_count == expected_count, (
-        f"Expected count ({expected_count}) doesn't match how "
-        f"much came back from collection: {current_count}"
-    )
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@requires_env("ASTRA_DB_API_ENDPOINT", "ASTRA_DB_APPLICATION_TOKEN")
-def test_astra_create_destination():
-    env_data = get_env_data()
-    connection_config = AstraDBConnectionConfig(
-        access_config=AstraDBAccessConfig(api_endpoint=env_data.api_endpoint, token=env_data.token),
-    )
-    uploader = AstraDBUploader(
-        connection_config=connection_config,
-        upload_config=AstraDBUploaderConfig(),
-    )
-    collection_name = "system_created-123"
-    formatted_collection_name = "system_created_123"
-
-    client = AstraDBClient()
-    db = client.get_database(api_endpoint=env_data.api_endpoint, token=env_data.token)
-    with contextlib.suppress(Exception):
-        # drop collection before trying to create it
-        db.drop_collection(formatted_collection_name)
-
-    created = uploader.create_destination(destination_name=collection_name, vector_length=3072)
-    assert created
-    assert uploader.upload_config.collection_name == formatted_collection_name
-
-    created = uploader.create_destination(destination_name=collection_name, vector_length=3072)
-    assert not created
-
-    # cleanup
-    db.drop_collection(formatted_collection_name)
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
-def test_astra_stager(
-    request: TopRequest,
-    upload_file_str: str,
-    tmp_path: Path,
-):
-    upload_file: Path = request.getfixturevalue(upload_file_str)
-    stager = AstraDBUploadStager()
-    stager_validation(
-        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
-        input_file=upload_file,
-        stager=stager,
-        tmp_dir=tmp_path,
-    )
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
-def test_astra_stager_flatten_metadata(
-    request: TopRequest,
-    upload_file_str: str,
-    tmp_path: Path,
-):
-    stager_config = AstraDBUploadStagerConfig(flatten_metadata=True)
-    upload_file: Path = request.getfixturevalue(upload_file_str)
-    stager = AstraDBUploadStager(upload_stager_config=stager_config)
-    stager_validation(
-        configs=StagerValidationConfigs(
-            test_id=CONNECTOR_TYPE, expected_count=22, expected_folder="stager_flatten_metadata"
-        ),
-        input_file=upload_file,
-        stager=stager,
-        tmp_dir=tmp_path,
-    )

test/integration/connectors/test_azure_ai_search.py

@@ -1,254 +0,0 @@
-import json
-import os
-import time
-from pathlib import Path
-from uuid import uuid4
-
-import pytest
-from _pytest.fixtures import TopRequest
-from azure.core.credentials import AzureKeyCredential
-from azure.search.documents import SearchClient
-from azure.search.documents.indexes import SearchIndexClient
-from azure.search.documents.indexes.models import (
-    ComplexField,
-    CorsOptions,
-    HnswAlgorithmConfiguration,
-    HnswParameters,
-    SearchField,
-    SearchFieldDataType,
-    SearchIndex,
-    SimpleField,
-    VectorSearch,
-    VectorSearchAlgorithmMetric,
-    VectorSearchProfile,
-)
-
-from test.integration.connectors.utils.constants import DESTINATION_TAG, VECTOR_DB_TAG
-from test.integration.connectors.utils.validation.destination import (
-    StagerValidationConfigs,
-    stager_validation,
-)
-from test.integration.utils import requires_env
-from unstructured_ingest.data_types.file_data import FileData, SourceIdentifiers
-from unstructured_ingest.processes.connectors.azure_ai_search import (
-    CONNECTOR_TYPE,
-    RECORD_ID_LABEL,
-    AzureAISearchAccessConfig,
-    AzureAISearchConnectionConfig,
-    AzureAISearchUploader,
-    AzureAISearchUploaderConfig,
-    AzureAISearchUploadStager,
-    AzureAISearchUploadStagerConfig,
-)
-
-repo_path = Path(__file__).parent.resolve()
-
-API_KEY = "AZURE_SEARCH_API_KEY"
-ENDPOINT = "https://ingest-test-azure-cognitive-search.search.windows.net"
-
-
-def get_api_key() -> str:
-    key = os.environ[API_KEY]
-    return key
-
-
-def get_fields() -> list:
-    data_source_fields = [
-        SimpleField(name="url", type=SearchFieldDataType.String),
-        SimpleField(name="version", type=SearchFieldDataType.String),
-        SimpleField(name="date_created", type=SearchFieldDataType.DateTimeOffset),
-        SimpleField(name="date_modified", type=SearchFieldDataType.DateTimeOffset),
-        SimpleField(name="date_processed", type=SearchFieldDataType.DateTimeOffset),
-        SimpleField(name="permissions_data", type=SearchFieldDataType.String),
-        SimpleField(name="record_locator", type=SearchFieldDataType.String),
-    ]
-    coordinates_fields = [
-        SimpleField(name="system", type=SearchFieldDataType.String),
-        SimpleField(name="layout_width", type=SearchFieldDataType.Double),
-        SimpleField(name="layout_height", type=SearchFieldDataType.Double),
-        SimpleField(name="points", type=SearchFieldDataType.String),
-    ]
-    metadata_fields = [
-        SimpleField(name="orig_elements", type=SearchFieldDataType.String),
-        SimpleField(name="category_depth", type=SearchFieldDataType.Int32),
-        SimpleField(name="parent_id", type=SearchFieldDataType.String),
-        SimpleField(name="attached_to_filename", type=SearchFieldDataType.String),
-        SimpleField(name="filetype", type=SearchFieldDataType.String),
-        SimpleField(name="last_modified", type=SearchFieldDataType.DateTimeOffset),
-        SimpleField(name="is_continuation", type=SearchFieldDataType.Boolean),
-        SimpleField(name="file_directory", type=SearchFieldDataType.String),
-        SimpleField(name="filename", type=SearchFieldDataType.String),
-        ComplexField(name="data_source", fields=data_source_fields),
-        ComplexField(name="coordinates", fields=coordinates_fields),
-        SimpleField(
-            name="languages", type=SearchFieldDataType.Collection(SearchFieldDataType.String)
-        ),
-        SimpleField(name="page_number", type=SearchFieldDataType.String),
-        SimpleField(name="links", type=SearchFieldDataType.Collection(SearchFieldDataType.String)),
-        SimpleField(name="page_name", type=SearchFieldDataType.String),
-        SimpleField(name="url", type=SearchFieldDataType.String),
-        SimpleField(
-            name="link_urls", type=SearchFieldDataType.Collection(SearchFieldDataType.String)
-        ),
-        SimpleField(
-            name="link_texts", type=SearchFieldDataType.Collection(SearchFieldDataType.String)
-        ),
-        SimpleField(
-            name="sent_from", type=SearchFieldDataType.Collection(SearchFieldDataType.String)
-        ),
-        SimpleField(
-            name="sent_to", type=SearchFieldDataType.Collection(SearchFieldDataType.String)
-        ),
-        SimpleField(name="subject", type=SearchFieldDataType.String),
-        SimpleField(name="section", type=SearchFieldDataType.String),
-        SimpleField(name="header_footer_type", type=SearchFieldDataType.String),
-        SimpleField(
-            name="emphasized_text_contents",
-            type=SearchFieldDataType.Collection(SearchFieldDataType.String),
-        ),
-        SimpleField(
-            name="emphasized_text_tags",
-            type=SearchFieldDataType.Collection(SearchFieldDataType.String),
-        ),
-        SimpleField(name="text_as_html", type=SearchFieldDataType.String),
-        SimpleField(name="regex_metadata", type=SearchFieldDataType.String),
-        SimpleField(name="detection_class_prob", type=SearchFieldDataType.Double),
-    ]
-    fields = [
-        SimpleField(name="id", type=SearchFieldDataType.String, key=True),
-        SimpleField(name=RECORD_ID_LABEL, type=SearchFieldDataType.String, filterable=True),
-        SimpleField(name="element_id", type=SearchFieldDataType.String),
-        SimpleField(name="text", type=SearchFieldDataType.String),
-        SimpleField(name="type", type=SearchFieldDataType.String),
-        ComplexField(name="metadata", fields=metadata_fields),
-        SearchField(
-            name="embeddings",
-            type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
-            vector_search_dimensions=384,
-            vector_search_profile_name="embeddings-config-profile",
-        ),
-    ]
-    return fields
-
-
-def get_vector_search() -> VectorSearch:
-    return VectorSearch(
-        algorithms=[
-            HnswAlgorithmConfiguration(
-                name="hnsw-config",
-                parameters=HnswParameters(
-                    metric=VectorSearchAlgorithmMetric.COSINE,
-                ),
-            )
-        ],
-        profiles=[
-            VectorSearchProfile(
-                name="embeddings-config-profile", algorithm_configuration_name="hnsw-config"
-            )
-        ],
-    )
-
-
-def get_search_index_client() -> SearchIndexClient:
-    api_key = get_api_key()
-    return SearchIndexClient(ENDPOINT, AzureKeyCredential(api_key))
-
-
-@pytest.fixture
-def index() -> str:
-    random_id = str(uuid4())[:8]
-    index_name = f"utic-test-{random_id}"
-    client = get_search_index_client()
-    index = SearchIndex(
-        name=index_name,
-        fields=get_fields(),
-        vector_search=get_vector_search(),
-        cors_options=CorsOptions(allowed_origins=["*"], max_age_in_seconds=60),
-    )
-    print(f"creating index: {index_name}")
-    client.create_index(index=index)
-    try:
-        yield index_name
-    finally:
-        print(f"deleting index: {index_name}")
-        client.delete_index(index)
-
-
-def validate_count(
-    search_client: SearchClient, expected_count: int, retries: int = 10, interval: int = 1
-) -> None:
-    index_count = search_client.get_document_count()
-    if index_count == expected_count:
-        return
-    tries = 0
-    while tries < retries:
-        time.sleep(interval)
-        index_count = search_client.get_document_count()
-        if index_count == expected_count:
-            break
-    assert index_count == expected_count, (
-        f"Expected count ({expected_count}) doesn't match how "
-        f"much came back from index: {index_count}"
-    )
-
-
-@pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@requires_env("AZURE_SEARCH_API_KEY")
-async def test_azure_ai_search_destination(
-    upload_file: Path,
-    index: str,
-    tmp_path: Path,
-):
-    file_data = FileData(
-        source_identifiers=SourceIdentifiers(fullpath=upload_file.name, filename=upload_file.name),
-        connector_type=CONNECTOR_TYPE,
-        identifier="mock file data",
-    )
-    stager = AzureAISearchUploadStager(upload_stager_config=AzureAISearchUploadStagerConfig())
-
-    uploader = AzureAISearchUploader(
-        connection_config=AzureAISearchConnectionConfig(
-            access_config=AzureAISearchAccessConfig(key=get_api_key()),
-            endpoint=ENDPOINT,
-            index=index,
-        ),
-        upload_config=AzureAISearchUploaderConfig(),
-    )
-    staged_filepath = stager.run(
-        elements_filepath=upload_file,
-        file_data=file_data,
-        output_dir=tmp_path,
-        output_filename=upload_file.name,
-    )
-    uploader.precheck()
-    uploader.run(path=staged_filepath, file_data=file_data)
-
-    # Run validation
-    with staged_filepath.open() as f:
-        staged_elements = json.load(f)
-    expected_count = len(staged_elements)
-    with uploader.connection_config.get_search_client() as search_client:
-        validate_count(search_client=search_client, expected_count=expected_count)
-
-    # Rerun and make sure the same documents get updated
-    uploader.run(path=staged_filepath, file_data=file_data)
-    with uploader.connection_config.get_search_client() as search_client:
-        validate_count(search_client=search_client, expected_count=expected_count)
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
-def test_azure_ai_search_stager(
-    request: TopRequest,
-    upload_file_str: str,
-    tmp_path: Path,
-):
-    upload_file: Path = request.getfixturevalue(upload_file_str)
-    stager = AzureAISearchUploadStager()
-    stager_validation(
-        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
-        input_file=upload_file,
-        stager=stager,
-        tmp_dir=tmp_path,
-    )

test/integration/connectors/test_chroma.py

@@ -1,136 +0,0 @@
-# add this back in when figure out why it's failing since NOTHING changed when it started failing
-
-# ==================================== ERRORS ====================================
-# _________ ERROR collecting test/integration/connectors/test_chroma.py __________
-# ImportError while importing test module '/home/runner/work/unstructured-ingest/
-# unstructured-ingest/test/integration/connectors/test_chroma.py'.
-# Hint: make sure your test modules/packages have valid Python names.
-# Traceback:
-# /opt/hostedtoolcache/Python/3.10.16/x64/lib/python3.10/importlib/__init__.py:126: in import_module
-#     return _bootstrap._gcd_import(name[level:], package, level)
-# test/integration/connectors/test_chroma.py:4: in <module>
-#     import chromadb
-# E   ModuleNotFoundError: No module named 'chromadb'
-
-
-"""
-import json
-from pathlib import Path
-
-import chromadb
-import pytest
-from _pytest.fixtures import TopRequest
-
-from test.integration.connectors.utils.constants import DESTINATION_TAG, VECTOR_DB_TAG
-from test.integration.connectors.utils.docker import HealthCheck, container_context
-from test.integration.connectors.utils.validation.destination import (
-    StagerValidationConfigs,
-    stager_validation,
-)
-from unstructured_ingest.data_types.file_data import FileData, SourceIdentifiers
-from unstructured_ingest.processes.connectors.chroma import (
-    CONNECTOR_TYPE,
-    ChromaConnectionConfig,
-    ChromaUploader,
-    ChromaUploaderConfig,
-    ChromaUploadStager,
-    ChromaUploadStagerConfig,
-)
-
-
-@pytest.fixture
-def chroma_instance():
-    with container_context(
-        image="chromadb/chroma:0.6.2",
-        ports={8000: 8000},
-        name="chroma_int_test",
-        healthcheck=HealthCheck(
-            interval=5,
-            timeout=10,
-            retries=3,
-            test="timeout 10s bash -c ':> /dev/tcp/127.0.0.1/8000' || exit 1",
-        ),
-    ) as ctx:
-        yield ctx
-
-
-def validate_collection(collection_name: str, num_embeddings: int):
-    print(f"Checking contents of Chroma collection: {collection_name}")
-
-    chroma_client = chromadb.HttpClient(
-        host="localhost",
-        port="8000",
-        tenant="default_tenant",
-        database="default_database",
-    )
-
-    collection = chroma_client.get_or_create_collection(name=collection_name)
-
-    number_of_embeddings = collection.count()
-    expected_embeddings = num_embeddings
-    print(
-        f"# of embeddings in collection vs expected: {number_of_embeddings}/{expected_embeddings}"
-    )
-
-    assert number_of_embeddings == expected_embeddings, (
-        f"Number of rows in generated table ({number_of_embeddings}) "
-        f"doesn't match expected value: {expected_embeddings}"
-    )
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
-def test_chroma_destination(
-    upload_file: Path,
-    chroma_instance,
-    tmp_path: Path,
-):
-    collection_name = "test_collection"
-    file_data = FileData(
-        source_identifiers=SourceIdentifiers(fullpath=upload_file.name, filename=upload_file.name),
-        connector_type=CONNECTOR_TYPE,
-        identifier="mock file data",
-    )
-    stager = ChromaUploadStager(upload_stager_config=ChromaUploadStagerConfig())
-
-    uploader = ChromaUploader(
-        connection_config=ChromaConnectionConfig(
-            host="localhost",
-            port=8000,
-            tenant="default_tenant",
-            database="default_database",
-        ),
-        upload_config=ChromaUploaderConfig(collection_name=collection_name),
-    )
-    staged_filepath = stager.run(
-        elements_filepath=upload_file,
-        file_data=file_data,
-        output_dir=tmp_path,
-        output_filename=upload_file.name,
-    )
-    uploader.precheck()
-    uploader.run(path=staged_filepath, file_data=file_data)
-
-    # Run validation
-    with staged_filepath.open() as f:
-        staged_elements = json.load(f)
-    expected_count = len(staged_elements)
-    validate_collection(collection_name=collection_name, num_embeddings=expected_count)
-
-
-@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, "stager", VECTOR_DB_TAG)
-def test_chroma_stager(
-    request: TopRequest,
-    upload_file_str: str,
-    tmp_path: Path,
-):
-    upload_file: Path = request.getfixturevalue(upload_file_str)
-    stager = ChromaUploadStager()
-    stager_validation(
-        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
-        input_file=upload_file,
-        stager=stager,
-        tmp_dir=tmp_path,
-    )
-
-"""