unstructured-ingest 0.3.13__py3-none-any.whl

test/integration/embedders/test_azure_openai.py

@@ -0,0 +1,59 @@
+import json
+import os
+from dataclasses import dataclass
+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.azure_openai import (
+    AzureOpenAIEmbeddingConfig,
+    AzureOpenAIEmbeddingEncoder,
+)
+from unstructured_ingest.v2.processes.embedder import Embedder, EmbedderConfig
+
+API_KEY = "AZURE_OPENAI_API_KEY"
+ENDPOINT = "AZURE_OPENAI_ENDPOINT"
+
+
+@dataclass(frozen=True)
+class AzureData:
+    api_key: str
+    endpoint: str
+
+
+def get_azure_data() -> AzureData:
+    api_key = os.getenv(API_KEY, None)
+    assert api_key
+    endpoint = os.getenv(ENDPOINT, None)
+    assert endpoint
+    return AzureData(api_key, endpoint)
+
+
+@requires_env(API_KEY, ENDPOINT)
+def test_azure_openai_embedder(embedder_file: Path):
+    azure_data = get_azure_data()
+    embedder_config = EmbedderConfig(
+        embedding_provider="azure-openai",
+        embedding_api_key=azure_data.api_key,
+        embedding_azure_endpoint=azure_data.endpoint,
+    )
+    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, ENDPOINT)
+def test_raw_azure_openai_embedder(embedder_file: Path):
+    azure_data = get_azure_data()
+    embedder = AzureOpenAIEmbeddingEncoder(
+        config=AzureOpenAIEmbeddingConfig(
+            api_key=azure_data.api_key,
+            azure_endpoint=azure_data.endpoint,
+        )
+    )
+    validate_raw_embedder(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1536,)
+    )

test/integration/embedders/test_bedrock.py

@@ -0,0 +1,103 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.bedrock import (
+    AsyncBedrockEmbeddingEncoder,
+    BedrockEmbeddingConfig,
+    BedrockEmbeddingEncoder,
+)
+from unstructured_ingest.v2.errors import UserAuthError, UserError
+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,
+    )
+
+
+def test_raw_bedrock_embedder_invalid_credentials(embedder_file: Path):
+    embedder = BedrockEmbeddingEncoder(
+        config=BedrockEmbeddingConfig(
+            aws_access_key_id="no_key",
+            aws_secret_access_key="no_secret",
+        )
+    )
+    with pytest.raises(UserAuthError):
+        embedder.get_exemplary_embedding()
+
+
+@requires_env("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY")
+def test_raw_bedrock_embedder_invalid_model(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"],
+            model_name="invalid_model",
+        )
+    )
+    with pytest.raises(UserError):
+        embedder.get_exemplary_embedding()
+
+
+@requires_env("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY")
+@pytest.mark.asyncio
+async def test_raw_async_bedrock_embedder(embedder_file: Path):
+    aws_credentials = get_aws_credentials()
+    embedder = AsyncBedrockEmbeddingEncoder(
+        config=BedrockEmbeddingConfig(
+            aws_access_key_id=aws_credentials["aws_access_key_id"],
+            aws_secret_access_key=aws_credentials["aws_secret_access_key"],
+        )
+    )
+    await validate_raw_embedder_async(
+        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,71 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.mixedbreadai import (
+    AsyncMixedbreadAIEmbeddingEncoder,
+    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,
+    )
+
+
+@requires_env(API_KEY)
+@pytest.mark.asyncio
+async def test_raw_async_mixedbread_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = AsyncMixedbreadAIEmbeddingEncoder(
+        config=MixedbreadAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    await validate_raw_embedder_async(
+        embedder=embedder,
+        embedder_file=embedder_file,
+        expected_dimensions=(1024,),
+        expected_is_unit_vector=False,
+    )

test/integration/embedders/test_octoai.py

@@ -0,0 +1,77 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.octoai import (
+    AsyncOctoAIEmbeddingEncoder,
+    OctoAiEmbeddingConfig,
+    OctoAIEmbeddingEncoder,
+)
+from unstructured_ingest.v2.errors import UserAuthError
+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,)
+    )
+
+
+@pytest.mark.skip(reason="Unexpected connection error at the moment")
+def test_raw_octoai_embedder_invalid_credentials():
+    embedder = OctoAIEmbeddingEncoder(
+        config=OctoAiEmbeddingConfig(
+            api_key="fake_api_key",
+        )
+    )
+    with pytest.raises(UserAuthError):
+        embedder.get_exemplary_embedding()
+
+
+@requires_env(API_KEY)
+@pytest.mark.asyncio
+async def test_raw_async_octoai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = AsyncOctoAIEmbeddingEncoder(
+        config=OctoAiEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    await validate_raw_embedder_async(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1024,)
+    )

test/integration/embedders/test_openai.py

@@ -0,0 +1,76 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.openai import (
+    AsyncOpenAIEmbeddingEncoder,
+    OpenAIEmbeddingConfig,
+    OpenAIEmbeddingEncoder,
+)
+from unstructured_ingest.v2.errors import UserAuthError
+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,)
+    )
+
+
+def test_raw_openai_embedder_invalid_credentials():
+    embedder = OpenAIEmbeddingEncoder(
+        config=OpenAIEmbeddingConfig(
+            api_key="fake_api_key",
+        )
+    )
+    with pytest.raises(UserAuthError):
+        embedder.get_exemplary_embedding()
+
+
+@requires_env(API_KEY)
+@pytest.mark.asyncio
+async def test_raw_async_openai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = AsyncOpenAIEmbeddingEncoder(
+        config=OpenAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    await validate_raw_embedder_async(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1536,)
+    )

test/integration/embedders/test_togetherai.py

@@ -0,0 +1,71 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.togetherai import (
+    AsyncTogetherAIEmbeddingEncoder,
+    TogetherAIEmbeddingConfig,
+    TogetherAIEmbeddingEncoder,
+)
+from unstructured_ingest.v2.errors import UserAuthError
+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,
+    )
+
+
+def test_raw_togetherai_embedder_invalid_credentials():
+    embedder = TogetherAIEmbeddingEncoder(config=TogetherAIEmbeddingConfig(api_key="fake_api_key"))
+
+    with pytest.raises(UserAuthError):
+        embedder.get_exemplary_embedding()
+
+
+@requires_env(API_KEY)
+@pytest.mark.asyncio
+async def test_raw_async_togetherai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = AsyncTogetherAIEmbeddingEncoder(config=TogetherAIEmbeddingConfig(api_key=api_key))
+    await validate_raw_embedder_async(
+        embedder=embedder,
+        embedder_file=embedder_file,
+        expected_dimensions=(768,),
+        expected_is_unit_vector=False,
+    )

test/integration/embedders/test_vertexai.py

@@ -0,0 +1,65 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.vertexai import (
+    AsyncVertexAIEmbeddingEncoder,
+    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,)
+    )
+
+
+@requires_env(API_KEY)
+@pytest.mark.asyncio
+async def test_raw_async_vertexai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = AsyncVertexAIEmbeddingEncoder(
+        config=VertexAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    await validate_raw_embedder_async(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(768,)
+    )

test/integration/embedders/test_voyageai.py

@@ -0,0 +1,65 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from test.integration.embedders.utils import (
+    validate_embedding_output,
+    validate_raw_embedder,
+    validate_raw_embedder_async,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.embed.voyageai import (
+    AsyncVoyageAIEmbeddingEncoder,
+    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,)
+    )
+
+
+@requires_env(API_KEY)
+@pytest.mark.asyncio
+async def test_raw_async_voyageai_embedder(embedder_file: Path):
+    api_key = get_api_key()
+    embedder = AsyncVoyageAIEmbeddingEncoder(
+        config=VoyageAIEmbeddingConfig(
+            api_key=api_key,
+        )
+    )
+    await validate_raw_embedder_async(
+        embedder=embedder, embedder_file=embedder_file, expected_dimensions=(1024,)
+    )

test/integration/embedders/utils.py

@@ -0,0 +1,68 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+from unstructured_ingest.embed.interfaces import AsyncBaseEmbeddingEncoder, 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)
+
+
+async def validate_raw_embedder_async(
+    embedder: AsyncBaseEmbeddingEncoder,
+    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 = await 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 = await embedder.is_unit_vector
+    assert is_unit_vector == expected_is_unit_vector
+    single_embedding = await embedder.embed_query(query=single_text)
+    expected_length = num_of_dimensions[0]
+    assert len(single_embedding) == expected_length
+    embedded_elements = await embedder.embed_documents(elements=elements)
+    validate_embedding_output(original_elements=elements, output_elements=embedded_elements)