unstructured-ingest 0.0.25__py3-none-any.whl → 0.1.0__py3-none-any.whl

test/integration/connectors/utils/validation.py

@@ -0,0 +1,198 @@
+import json
+import os
+import shutil
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import Callable, Optional
+
+from deepdiff import DeepDiff
+
+from test.integration.connectors.utils.constants import expected_results_path
+from unstructured_ingest.v2.interfaces import Downloader, FileData, Indexer
+
+
+@dataclass
+class ValidationConfigs:
+    test_id: str
+    expected_num_files: Optional[int] = None
+    predownload_file_data_check: Optional[Callable[[FileData], None]] = None
+    postdownload_file_data_check: Optional[Callable[[FileData], None]] = None
+    exclude_fields: list[str] = field(
+        default_factory=lambda: ["local_download_path", "metadata.date_processed"]
+    )
+    exclude_fields_extend: list[str] = field(default_factory=list)
+
+    def get_exclude_fields(self) -> list[str]:
+        exclude_fields = self.exclude_fields
+        exclude_fields.extend(self.exclude_fields_extend)
+        return exclude_fields
+
+    def run_file_data_validation(
+        self, predownload_file_data: FileData, postdownload_file_data: FileData
+    ):
+        if predownload_file_data_check := self.predownload_file_data_check:
+            predownload_file_data_check(predownload_file_data)
+        if postdownload_file_data_check := self.postdownload_file_data_check:
+            postdownload_file_data_check(postdownload_file_data)
+
+    def run_download_dir_validation(self, download_dir: Path):
+        if expected_num_files := self.expected_num_files:
+            downloaded_files = [p for p in download_dir.rglob("*") if p.is_file()]
+            assert len(downloaded_files) == expected_num_files
+
+    def test_output_dir(self) -> Path:
+        return expected_results_path / self.test_id
+
+    def omit_ignored_fields(self, data: dict) -> dict:
+        exclude_fields = self.get_exclude_fields()
+        # Ignore fields that dynamically change every time the tests run
+        copied_data = data.copy()
+        for exclude_field in exclude_fields:
+            exclude_field_vals = exclude_field.split(".")
+            if len(exclude_field_vals) == 1:
+                current_val = copied_data
+                drop_field = exclude_field_vals[0]
+                copied_data.pop(exclude_field_vals[0], None)
+            else:
+                current_val = copied_data
+                for val in exclude_field_vals[:-1]:
+                    current_val = current_val.get(val, {})
+                drop_field = exclude_field_vals[-1]
+            if drop_field == "*":
+                current_val.clear()
+            else:
+                current_val.pop(drop_field, None)
+        return copied_data
+
+
+def get_files(dir_path: Path) -> list[str]:
+    return [
+        str(f).replace(str(dir_path), "").lstrip("/") for f in dir_path.iterdir() if f.is_file()
+    ]
+
+
+def check_files(expected_output_dir: Path, all_file_data: list[FileData]):
+    expected_files = get_files(dir_path=expected_output_dir)
+    current_files = [f"{file_data.identifier}.json" for file_data in all_file_data]
+    diff = set(expected_files) ^ set(current_files)
+    assert not diff, "diff in files that exist: {}".format(", ".join(diff))
+
+
+def check_contents(
+    expected_output_dir: Path, all_file_data: list[FileData], configs: ValidationConfigs
+):
+    found_diff = False
+    for file_data in all_file_data:
+        file_data_path = expected_output_dir / f"{file_data.identifier}.json"
+        with file_data_path.open("r") as file:
+            expected_file_data_contents = json.load(file)
+        current_file_data_contents = file_data.to_dict()
+        expected_file_data_contents = configs.omit_ignored_fields(expected_file_data_contents)
+        current_file_data_contents = configs.omit_ignored_fields(current_file_data_contents)
+        diff = DeepDiff(expected_file_data_contents, current_file_data_contents)
+        if diff:
+            found_diff = True
+            print(diff.to_json(indent=2))
+    assert not found_diff, f"Diffs found between files: {found_diff}"
+
+
+def run_expected_results_validation(
+    expected_output_dir: Path, all_file_data: list[FileData], configs: ValidationConfigs
+):
+    check_files(expected_output_dir=expected_output_dir, all_file_data=all_file_data)
+    check_contents(
+        expected_output_dir=expected_output_dir, all_file_data=all_file_data, configs=configs
+    )
+
+
+def run_directory_structure_validation(expected_output_dir: Path, download_files: list[str]):
+    directory_record = expected_output_dir / "directory_structure.json"
+    with directory_record.open("r") as directory_file:
+        directory_file_contents = json.load(directory_file)
+    directory_structure = directory_file_contents["directory_structure"]
+    assert directory_structure == download_files
+
+
+def update_fixtures(output_dir: Path, download_dir: Path, all_file_data: list[FileData]):
+    # Delete current files
+    shutil.rmtree(path=output_dir, ignore_errors=True)
+    output_dir.mkdir(parents=True)
+    # Rewrite the current file data
+    file_data_output_path = output_dir / "file_data"
+    file_data_output_path.mkdir(parents=True)
+    for file_data in all_file_data:
+        file_data_path = file_data_output_path / f"{file_data.identifier}.json"
+        with file_data_path.open(mode="w") as f:
+            json.dump(file_data.to_dict(), f, indent=2)
+
+    # Record file structure of download directory
+    download_files = get_files(dir_path=download_dir)
+    download_files.sort()
+    download_dir_record = output_dir / "directory_structure.json"
+    with download_dir_record.open(mode="w") as f:
+        json.dump({"directory_structure": download_files}, f, indent=2)
+
+
+def run_all_validations(
+    configs: ValidationConfigs,
+    predownload_file_data: list[FileData],
+    postdownload_file_data: list[FileData],
+    download_dir: Path,
+    test_output_dir: Path,
+):
+    for pre_data, post_data in zip(predownload_file_data, postdownload_file_data):
+        configs.run_file_data_validation(
+            predownload_file_data=pre_data, postdownload_file_data=post_data
+        )
+    configs.run_download_dir_validation(download_dir=download_dir)
+    run_expected_results_validation(
+        expected_output_dir=test_output_dir / "file_data",
+        all_file_data=postdownload_file_data,
+        configs=configs,
+    )
+    download_files = get_files(dir_path=download_dir)
+    download_files.sort()
+    run_directory_structure_validation(
+        expected_output_dir=configs.test_output_dir(), download_files=download_files
+    )
+
+
+async def source_connector_validation(
+    indexer: Indexer,
+    downloader: Downloader,
+    configs: ValidationConfigs,
+    overwrite_fixtures: bool = os.getenv("OVERWRITE_FIXTURES", "False").lower() == "true",
+) -> None:
+    # Run common validations on the process of running a source connector, supporting dynamic
+    # validators that get passed in along with comparisons on the saved expected values.
+    # If overwrite_fixtures is st to True, will ignore all validators but instead overwrite the
+    # expected values with what gets generated by this test.
+    all_predownload_file_data = []
+    all_postdownload_file_data = []
+    indexer.precheck()
+    download_dir = downloader.download_config.download_dir
+    test_output_dir = configs.test_output_dir()
+    for file_data in indexer.run():
+        assert file_data
+        predownload_file_data = replace(file_data)
+        all_predownload_file_data.append(predownload_file_data)
+        if downloader.is_async():
+            resp = await downloader.run_async(file_data=file_data)
+        else:
+            resp = downloader.run(file_data=file_data)
+        postdownload_file_data = replace(resp["file_data"])
+        all_postdownload_file_data.append(postdownload_file_data)
+    if not overwrite_fixtures:
+        run_all_validations(
+            configs=configs,
+            predownload_file_data=all_predownload_file_data,
+            postdownload_file_data=all_postdownload_file_data,
+            download_dir=download_dir,
+            test_output_dir=test_output_dir,
+        )
+    else:
+        update_fixtures(
+            output_dir=test_output_dir,
+            download_dir=download_dir,
+            all_file_data=all_postdownload_file_data,
+        )

test/integration/embedders/conftest.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def embedder_file() -> Path:
+    int_test_dir = Path(__file__).parent
+    assets_dir = int_test_dir / "assets"
+    embedder_file = assets_dir / "DA-1p-with-duplicate-pages.pdf.json"
+    assert embedder_file.exists()
+    assert embedder_file.is_file()
+    return embedder_file

test/integration/embedders/test_bedrock.py

@@ -0,0 +1,49 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.bedrock import BedrockEmbeddingConfig, BedrockEmbeddingEncoder
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+
+def get_aws_credentials() -> dict:
+    access_key = os.getenv("AWS_ACCESS_KEY_ID", None)
+    assert access_key
+    secret_key = os.getenv("AWS_SECRET_ACCESS_KEY", None)
+    assert secret_key
+    return {"aws_access_key_id": access_key, "aws_secret_access_key": secret_key}
+
+
+@requires_env("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY")
+def test_bedrock_embedder(embedder_file: Path):
+    aws_credentials = get_aws_credentials()
+    embedder_config = EmbedderConfig(
+        embedding_provider="aws-bedrock",
+        embedding_aws_access_key_id=aws_credentials["aws_access_key_id"],
+        embedding_aws_secret_access_key=aws_credentials["aws_secret_access_key"],
+    )
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY")
+def test_raw_bedrock_embedder(embedder_file: Path):
+    aws_credentials = get_aws_credentials()
+    embedder = BedrockEmbeddingEncoder(
+        config=BedrockEmbeddingConfig(
+            aws_access_key_id=aws_credentials["aws_access_key_id"],
+            aws_secret_access_key=aws_credentials["aws_secret_access_key"],
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder,
+        embedder_file=embedder_file,
+        expected_dimensions=(1536,),
+        expected_is_unit_vector=False,
+    )

test/integration/embedders/test_huggingface.py

@@ -0,0 +1,26 @@
+import json
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from unstructured_ingest.embed.huggingface import (
+    HuggingFaceEmbeddingConfig,
+    HuggingFaceEmbeddingEncoder,
+)
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+
+def test_huggingface_embedder(embedder_file: Path):
+    embedder_config = EmbedderConfig(embedding_provider="huggingface")
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+def test_raw_hugginface_embedder(embedder_file: Path):
+    embedder = HuggingFaceEmbeddingEncoder(config=HuggingFaceEmbeddingConfig())
+    validate_raw_embedder(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(384,)
+    )

test/integration/embedders/test_mixedbread.py

@@ -0,0 +1,47 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.mixedbreadai import (
+    MixedbreadAIEmbeddingConfig,
+    MixedbreadAIEmbeddingEncoder,
+)
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "MXBAI_API_KEY"
+
+
+def get_api_key() -> str:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    return api_key
+
+
+@requires_env(API_KEY)
+def test_mixedbread_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder_config = EmbedderConfig(embedding_provider="mixedbread-ai", embedding_api_key=api_key)
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env(API_KEY)
+def test_raw_mixedbread_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = MixedbreadAIEmbeddingEncoder(
+        config=MixedbreadAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder,
+        embedder_file=embedder_file,
+        expected_dimensions=(1024,),
+        expected_is_unit_vector=False,
+    )

test/integration/embedders/test_octoai.py

@@ -0,0 +1,41 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.octoai import OctoAiEmbeddingConfig, OctoAIEmbeddingEncoder
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "OCTOAI_API_KEY"
+
+
+def get_api_key() -> str:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    return api_key
+
+
+@requires_env(API_KEY)
+def test_octoai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder_config = EmbedderConfig(embedding_provider="octoai", embedding_api_key=api_key)
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env(API_KEY)
+def test_raw_octoai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = OctoAIEmbeddingEncoder(
+        config=OctoAiEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1024,)
+    )

test/integration/embedders/test_openai.py

@@ -0,0 +1,41 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.openai import OpenAIEmbeddingConfig, OpenAIEmbeddingEncoder
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "OPENAI_API_KEY"
+
+
+def get_api_key() -> str:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    return api_key
+
+
+@requires_env(API_KEY)
+def test_openai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder_config = EmbedderConfig(embedding_provider="openai", embedding_api_key=api_key)
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env(API_KEY)
+def test_raw_openai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = OpenAIEmbeddingEncoder(
+        config=OpenAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1536,)
+    )

test/integration/embedders/test_vertexai.py

@@ -0,0 +1,41 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.vertexai import VertexAIEmbeddingConfig, VertexAIEmbeddingEncoder
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "VERTEXAI_API_KEY"
+
+
+def get_api_key() -> str:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    return api_key
+
+
+@requires_env(API_KEY)
+def test_vertexai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder_config = EmbedderConfig(embedding_provider="vertexai", embedding_api_key=api_key)
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env(API_KEY)
+def test_raw_vertexai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = VertexAIEmbeddingEncoder(
+        config=VertexAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(768,)
+    )

test/integration/embedders/test_voyageai.py

@@ -0,0 +1,41 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.voyageai import VoyageAIEmbeddingConfig, VoyageAIEmbeddingEncoder
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "VOYAGEAI_API_KEY"
+
+
+def get_api_key() -> str:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    return api_key
+
+
+@requires_env(API_KEY)
+def test_voyageai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder_config = EmbedderConfig(embedding_provider="voyageai", embedding_api_key=api_key)
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env(API_KEY)
+def test_raw_voyageai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = VoyageAIEmbeddingEncoder(
+        config=VoyageAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1024,)
+    )

test/integration/embedders/togetherai.py

@@ -0,0 +1,43 @@
+import json
+import os
+from pathlib import Path
+
+from test.integration.embedders.utils import validate_embedding_output, validate_raw_embedder
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.togetherai import (
+    TogetherAIEmbeddingConfig,
+    TogetherAIEmbeddingEncoder,
+)
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "TOGETHERAI_API_KEY"
+
+
+def get_api_key() -> str:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    return api_key
+
+
+@requires_env(API_KEY)
+def test_togetherai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder_config = EmbedderConfig(embedding_provider="togetherai", embedding_api_key=api_key)
+    embedder = Embedder(config=embedder_config)
+    results = embedder.run(elements_filepath=embedder_file)
+    assert results
+    with embedder_file.open("r") as f:
+        original_elements = json.load(f)
+    validate_embedding_output(original_elements=original_elements, output_elements=results)
+
+
+@requires_env(API_KEY)
+def test_raw_togetherai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = TogetherAIEmbeddingEncoder(config=TogetherAIEmbeddingConfig(api_key=api_key))
+    validate_raw_embedder(
+        embedder=embedder,
+        embedder_file=embedder_file,
+        expected_dimensions=(768,),
+        expected_is_unit_vector=False,
+    )

test/integration/embedders/utils.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+from unstructured_ingest.embed.interfaces import BaseEmbeddingEncoder
+
+
+def validate_embedding_output(original_elements: list[dict], output_elements: list[dict]):
+    """
+    Make sure the following characteristics are met:
+    * The same number of elements are returned
+    * For each element that had text, an embeddings entry was added in the output
+    * Other than the embedding, nothing about the element was changed
+    """
+    assert len(original_elements) == len(output_elements)
+    for original_element, output_element in zip(original_elements, output_elements):
+        if original_element.get("text"):
+            assert output_element.get("embeddings", None)
+        output_element.pop("embeddings", None)
+        assert original_element == output_element
+
+
+def validate_raw_embedder(
+    embedder: BaseEmbeddingEncoder,
+    embedder_file: Path,
+    expected_dimensions: Optional[tuple[int, ...]] = None,
+    expected_is_unit_vector: bool = True,
+):
+    with open(embedder_file) as f:
+        elements = json.load(f)
+    all_text = [element["text"] for element in elements]
+    single_text = all_text[0]
+    num_of_dimensions = embedder.num_of_dimensions
+    if expected_dimensions:
+        assert (
+            num_of_dimensions == expected_dimensions
+        ), f"number of dimensions {num_of_dimensions} didn't match expected: {expected_dimensions}"
+    is_unit_vector = embedder.is_unit_vector
+    assert is_unit_vector == expected_is_unit_vector
+    single_embedding = embedder.embed_query(query=single_text)
+    expected_length = num_of_dimensions[0]
+    assert len(single_embedding) == expected_length
+    embedded_elements = embedder.embed_documents(elements=elements)
+    validate_embedding_output(original_elements=elements, output_elements=embedded_elements)

test/integration/partitioners/test_partitioner.py

@@ -0,0 +1,75 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+from unstructured_client.models.errors.sdkerror import SDKError
+
+from test.integration.utils import requires_env
+from unstructured_ingest.v2.processes.partitioner import Partitioner, PartitionerConfig
+
+int_test_dir = Path(__file__).parent
+assets_dir = int_test_dir / "assets"
+
+all_partition_files = [path for path in assets_dir.iterdir() if path.is_file()]
+non_image_partition_files = [
+    path for path in all_partition_files if path.suffix not in [".jpg", ".png", ".tif"]
+]
+image_partition_files = [
+    path for path in all_partition_files if path not in non_image_partition_files
+]
+
+
+@pytest.mark.parametrize(
+    "partition_file", all_partition_files, ids=[path.name for path in all_partition_files]
+)
+@requires_env("UNSTRUCTURED_API_KEY", "UNSTRUCTURED_API_URL")
+@pytest.mark.asyncio
+async def test_partitioner_api_hi_res(partition_file: Path):
+    api_key = os.getenv("UNSTRUCTURED_API_KEY")
+    api_url = os.getenv("UNSTRUCTURED_API_URL")
+    partitioner_config = PartitionerConfig(
+        strategy="hi_res", partition_by_api=True, api_key=api_key, partition_endpoint=api_url
+    )
+    partitioner = Partitioner(config=partitioner_config)
+    results = await partitioner.run_async(filename=partition_file)
+    results_dir = int_test_dir / "results"
+    results_dir.mkdir(exist_ok=True)
+    results_path = results_dir / f"{partition_file.name}.json"
+    with results_path.open("w") as f:
+        json.dump(results, f, indent=2)
+    assert results
+
+
+@pytest.mark.parametrize(
+    "partition_file",
+    non_image_partition_files,
+    ids=[path.name for path in non_image_partition_files],
+)
+@requires_env("UNSTRUCTURED_API_KEY", "UNSTRUCTURED_API_URL")
+@pytest.mark.asyncio
+async def test_partitioner_api_fast(partition_file: Path):
+    api_key = os.getenv("UNSTRUCTURED_API_KEY")
+    api_url = os.getenv("UNSTRUCTURED_API_URL")
+    partitioner_config = PartitionerConfig(
+        strategy="fast", partition_by_api=True, api_key=api_key, partition_endpoint=api_url
+    )
+    partitioner = Partitioner(config=partitioner_config)
+    results = await partitioner.run_async(filename=partition_file)
+    assert results
+
+
+@pytest.mark.parametrize(
+    "partition_file", image_partition_files, ids=[path.name for path in image_partition_files]
+)
+@requires_env("UNSTRUCTURED_API_KEY", "UNSTRUCTURED_API_URL")
+@pytest.mark.asyncio
+async def test_partitioner_api_fast_error(partition_file: Path):
+    api_key = os.getenv("UNSTRUCTURED_API_KEY")
+    api_url = os.getenv("UNSTRUCTURED_API_URL")
+    partitioner_config = PartitionerConfig(
+        strategy="fast", partition_by_api=True, api_key=api_key, partition_endpoint=api_url
+    )
+    partitioner = Partitioner(config=partitioner_config)
+    with pytest.raises(SDKError):
+        await partitioner.run_async(filename=partition_file)