unstructured-ingest 0.0.19__tar.gz → 0.0.22__tar.gz

unstructured_ingest-0.0.22/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.1
+Name: unstructured-ingest
+Version: 0.0.22
+Summary: A library that prepares raw documents for downstream ML tasks.
+Home-page: https://github.com/Unstructured-IO/unstructured-ingest
+Author: Unstructured Technologies
+Author-email: devops@unstructuredai.io
+License: Apache-2.0
+Keywords: NLP PDF HTML CV XML parsing preprocessing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9.0,<3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pandas
+Requires-Dist: pydantic>=2.7
+Requires-Dist: click
+Requires-Dist: opentelemetry-sdk
+Requires-Dist: dataclasses_json
+Requires-Dist: tqdm
+Requires-Dist: python-dateutil
+Provides-Extra: remote
+Requires-Dist: unstructured-client>=0.25.8; extra == "remote"
+Provides-Extra: csv
+Requires-Dist: unstructured[tsv]; extra == "csv"
+Provides-Extra: doc
+Requires-Dist: unstructured[docx]; extra == "doc"
+Provides-Extra: docx
+Requires-Dist: unstructured[docx]; extra == "docx"
+Provides-Extra: epub
+Requires-Dist: unstructured[epub]; extra == "epub"
+Provides-Extra: md
+Requires-Dist: unstructured[md]; extra == "md"
+Provides-Extra: msg
+Requires-Dist: unstructured[msg]; extra == "msg"
+Provides-Extra: odt
+Requires-Dist: unstructured[odt]; extra == "odt"
+Provides-Extra: org
+Requires-Dist: unstructured[org]; extra == "org"
+Provides-Extra: pdf
+Requires-Dist: unstructured[pdf]; extra == "pdf"
+Provides-Extra: ppt
+Requires-Dist: unstructured[pptx]; extra == "ppt"
+Provides-Extra: pptx
+Requires-Dist: unstructured[pptx]; extra == "pptx"
+Provides-Extra: rtf
+Requires-Dist: unstructured[rtf]; extra == "rtf"
+Provides-Extra: rst
+Requires-Dist: unstructured[rst]; extra == "rst"
+Provides-Extra: tsv
+Requires-Dist: unstructured[tsv]; extra == "tsv"
+Provides-Extra: xlsx
+Requires-Dist: unstructured[xlsx]; extra == "xlsx"
+Provides-Extra: airtable
+Requires-Dist: pyairtable; extra == "airtable"
+Provides-Extra: astradb
+Requires-Dist: astrapy; extra == "astradb"
+Provides-Extra: azure
+Requires-Dist: adlfs; extra == "azure"
+Requires-Dist: fsspec; extra == "azure"
+Provides-Extra: azure-cognitive-search
+Requires-Dist: azure-search-documents; extra == "azure-cognitive-search"
+Provides-Extra: biomed
+Requires-Dist: requests; extra == "biomed"
+Requires-Dist: bs4; extra == "biomed"
+Provides-Extra: box
+Requires-Dist: fsspec; extra == "box"
+Requires-Dist: boxfs; extra == "box"
+Provides-Extra: chroma
+Requires-Dist: chromadb; extra == "chroma"
+Provides-Extra: clarifai
+Requires-Dist: clarifai; extra == "clarifai"
+Provides-Extra: confluence
+Requires-Dist: requests; extra == "confluence"
+Requires-Dist: atlassian-python-api; extra == "confluence"
+Provides-Extra: couchbase
+Requires-Dist: couchbase; extra == "couchbase"
+Provides-Extra: delta-table
+Requires-Dist: deltalake; extra == "delta-table"
+Requires-Dist: fsspec; extra == "delta-table"
+Provides-Extra: discord
+Requires-Dist: discord-py; extra == "discord"
+Provides-Extra: dropbox
+Requires-Dist: fsspec; extra == "dropbox"
+Requires-Dist: dropboxdrivefs; extra == "dropbox"
+Provides-Extra: elasticsearch
+Requires-Dist: elasticsearch[async]; extra == "elasticsearch"
+Provides-Extra: gcs
+Requires-Dist: gcsfs; extra == "gcs"
+Requires-Dist: fsspec; extra == "gcs"
+Requires-Dist: bs4; extra == "gcs"
+Provides-Extra: github
+Requires-Dist: requests; extra == "github"
+Requires-Dist: pygithub>1.58.0; extra == "github"
+Provides-Extra: gitlab
+Requires-Dist: python-gitlab; extra == "gitlab"
+Provides-Extra: google-drive
+Requires-Dist: google-api-python-client; extra == "google-drive"
+Provides-Extra: hubspot
+Requires-Dist: urllib3; extra == "hubspot"
+Requires-Dist: hubspot-api-client; extra == "hubspot"
+Provides-Extra: jira
+Requires-Dist: atlassian-python-api; extra == "jira"
+Provides-Extra: kafka
+Requires-Dist: confluent-kafka; extra == "kafka"
+Provides-Extra: kdbai
+Requires-Dist: kdbai-client; extra == "kdbai"
+Provides-Extra: milvus
+Requires-Dist: pymilvus; extra == "milvus"
+Provides-Extra: mongodb
+Requires-Dist: pymongo; extra == "mongodb"
+Provides-Extra: notion
+Requires-Dist: httpx; extra == "notion"
+Requires-Dist: htmlBuilder; extra == "notion"
+Requires-Dist: notion-client; extra == "notion"
+Requires-Dist: backoff; extra == "notion"
+Provides-Extra: onedrive
+Requires-Dist: Office365-REST-Python-Client; extra == "onedrive"
+Requires-Dist: msal; extra == "onedrive"
+Requires-Dist: bs4; extra == "onedrive"
+Provides-Extra: opensearch
+Requires-Dist: opensearch-py; extra == "opensearch"
+Provides-Extra: outlook
+Requires-Dist: Office365-REST-Python-Client; extra == "outlook"
+Requires-Dist: msal; extra == "outlook"
+Provides-Extra: pinecone
+Requires-Dist: pinecone-client>=3.7.1; extra == "pinecone"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary; extra == "postgres"
+Provides-Extra: qdrant
+Requires-Dist: qdrant-client; extra == "qdrant"
+Provides-Extra: reddit
+Requires-Dist: praw; extra == "reddit"
+Provides-Extra: s3
+Requires-Dist: s3fs; extra == "s3"
+Requires-Dist: fsspec; extra == "s3"
+Provides-Extra: sharepoint
+Requires-Dist: Office365-REST-Python-Client; extra == "sharepoint"
+Requires-Dist: msal; extra == "sharepoint"
+Provides-Extra: salesforce
+Requires-Dist: simple-salesforce; extra == "salesforce"
+Provides-Extra: sftp
+Requires-Dist: paramiko; extra == "sftp"
+Requires-Dist: fsspec; extra == "sftp"
+Provides-Extra: slack
+Requires-Dist: slack_sdk; extra == "slack"
+Provides-Extra: wikipedia
+Requires-Dist: wikipedia; extra == "wikipedia"
+Provides-Extra: weaviate
+Requires-Dist: weaviate-client; extra == "weaviate"
+Provides-Extra: databricks-volumes
+Requires-Dist: databricks-sdk; extra == "databricks-volumes"
+Provides-Extra: singlestore
+Requires-Dist: singlestoredb; extra == "singlestore"
+Provides-Extra: vectara
+Requires-Dist: requests; extra == "vectara"
+Provides-Extra: embed-huggingface
+Requires-Dist: sentence-transformers; extra == "embed-huggingface"
+Provides-Extra: embed-octoai
+Requires-Dist: tiktoken; extra == "embed-octoai"
+Requires-Dist: openai; extra == "embed-octoai"
+Provides-Extra: embed-vertexai
+Requires-Dist: vertexai; extra == "embed-vertexai"
+Provides-Extra: embed-voyageai
+Requires-Dist: voyageai; extra == "embed-voyageai"
+Provides-Extra: embed-mixedbreadai
+Requires-Dist: mixedbread-ai; extra == "embed-mixedbreadai"
+Provides-Extra: openai
+Requires-Dist: tiktoken; extra == "openai"
+Requires-Dist: openai; extra == "openai"
+Provides-Extra: bedrock
+Requires-Dist: boto3; extra == "bedrock"
+
+# Unstructured Ingest  
+
+For details, see the [Unstructured Ingest overview](https://docs.unstructured.io/ingestion/overview) in the Unstructured documentation.

{unstructured-ingest-0.0.19 → unstructured_ingest-0.0.22}/test/test_utils_v2.py

@@ -34,7 +34,7 @@ model = MockBaseModel(
 
 def test_serialize_base_model():
 
-    serialized_dict = model.dict()
+    serialized_dict = model.model_dump()
     assert isinstance(serialized_dict["secret_str"], _SecretBase)
     assert isinstance(serialized_dict["secret_child_base"], _SecretBase)
 
@@ -57,7 +57,7 @@ def test_serialize_base_model():
 
 
 def test_serialize_base_model_json():
-    serialized_json = model.json()
+    serialized_json = model.model_dump_json()
     serialized_dict = json.loads(serialized_json)
     expected_dict = {
         "secret_str": "**********",

unstructured_ingest-0.0.22/unstructured_ingest/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.22"  # pragma: no cover

{unstructured-ingest-0.0.19 → unstructured_ingest-0.0.22}/unstructured_ingest/cli/cmds/astradb.py

@@ -37,11 +37,11 @@ class AstraDBCliConfig(SimpleAstraDBConfig, CliConfig):
                 "numbers, and underscores.",
             ),
             click.Option(
-                ["--namespace"],
+                ["--keyspace"],
                 required=False,
                 default=None,
                 type=str,
-                help="The Astra DB connection namespace.",
+                help="The Astra DB connection keyspace.",
             ),
         ]
         return options

{unstructured-ingest-0.0.19 → unstructured_ingest-0.0.22}/unstructured_ingest/connector/astradb.py

@@ -24,7 +24,8 @@ from unstructured_ingest.utils.data_prep import batch_generator, flatten_dict
 from unstructured_ingest.utils.dep_check import requires_dependencies
 
 if t.TYPE_CHECKING:
-    from astrapy.db import AstraDB, AstraDBCollection
+    from astrapy import Collection as AstraDBCollection
+    from astrapy import Database as AstraDB
 
 NON_INDEXED_FIELDS = ["metadata._node_content", "content"]
 
@@ -39,6 +40,7 @@ class AstraDBAccessConfig(AccessConfig):
 class SimpleAstraDBConfig(BaseConnectorConfig):
     access_config: AstraDBAccessConfig
     collection_name: str
+    keyspace: t.Optional[str] = None
     namespace: t.Optional[str] = None
 
 
@@ -98,22 +100,30 @@ class AstraDBSourceConnector(SourceConnectorCleanupMixin, BaseSourceConnector):
     @requires_dependencies(["astrapy"], extras="astradb")
     def astra_db_collection(self) -> "AstraDBCollection":
         if self._astra_db_collection is None:
-            from astrapy.db import AstraDB
+            from astrapy import DataAPIClient as AstraDBClient
 
-            # Build the Astra DB object.
+            # Choose keyspace or deprecated namespace
+            keyspace_param = self.connector_config.keyspace or self.connector_config.namespace
+
+            # Create a client object to interact with the Astra DB
             # caller_name/version for Astra DB tracking
-            self._astra_db = AstraDB(
-                api_endpoint=self.connector_config.access_config.api_endpoint,
-                token=self.connector_config.access_config.token,
-                namespace=self.connector_config.namespace,
+            my_client = AstraDBClient(
                 caller_name=integration_name,
                 caller_version=integration_version,
             )
 
-            # Create and connect to the collection
-            self._astra_db_collection = self._astra_db.collection(
-                collection_name=self.connector_config.collection_name,
+            # Get the database object
+            self._astra_db = my_client.get_database(
+                api_endpoint=self.connector_config.access_config.api_endpoint,
+                token=self.connector_config.access_config.token,
+                keyspace=keyspace_param,
             )
+
+            # Create and connect to the newly created collection
+            self._astra_db_collection = self._astra_db.get_collection(
+                name=self.connector_config.collection_name,
+            )
+
         return self._astra_db_collection  # type: ignore
 
     @requires_dependencies(["astrapy"], extras="astradb")
@@ -132,8 +142,14 @@ class AstraDBSourceConnector(SourceConnectorCleanupMixin, BaseSourceConnector):
     @requires_dependencies(["astrapy"], extras="astradb")
     def get_ingest_docs(self):  # type: ignore
         # Perform the find operation
-        astra_db_docs = list(self.astra_db_collection.paginated_find())
+        astra_db_docs_cursor = self.astra_db_collection.find({})
 
+        # Iterate over the cursor
+        astra_db_docs = []
+        for result in astra_db_docs_cursor:
+            astra_db_docs.append(result)
+
+        # Create a list of AstraDBIngestDoc objects
         doc_list = []
         for record in astra_db_docs:
             doc = AstraDBIngestDoc(
@@ -182,30 +198,41 @@ class AstraDBDestinationConnector(BaseDestinationConnector):
     @requires_dependencies(["astrapy"], extras="astradb")
     def astra_db_collection(self) -> "AstraDBCollection":
         if self._astra_db_collection is None:
-            from astrapy.db import AstraDB
+            from astrapy import DataAPIClient as AstraDBClient
+            from astrapy.exceptions import CollectionAlreadyExistsException
+
+            # Choose keyspace or deprecated namespace
+            keyspace_param = self.connector_config.keyspace or self.connector_config.namespace
 
             collection_name = self.connector_config.collection_name
             embedding_dimension = self.write_config.embedding_dimension
-
-            # If the user has requested an indexing policy, pass it to the Astra DB
             requested_indexing_policy = self.write_config.requested_indexing_policy
-            options = {"indexing": requested_indexing_policy} if requested_indexing_policy else None
 
+            # Create a client object to interact with the Astra DB
             # caller_name/version for Astra DB tracking
-            self._astra_db = AstraDB(
-                api_endpoint=self.connector_config.access_config.api_endpoint,
-                token=self.connector_config.access_config.token,
-                namespace=self.connector_config.namespace,
+            my_client = AstraDBClient(
                 caller_name=integration_name,
                 caller_version=integration_version,
             )
 
-            # Create and connect to the newly created collection
-            self._astra_db_collection = self._astra_db.create_collection(
-                collection_name=collection_name,
-                dimension=embedding_dimension,
-                options=options,
+            # Get the database object
+            self._astra_db = my_client.get_database(
+                api_endpoint=self.connector_config.access_config.api_endpoint,
+                token=self.connector_config.access_config.token,
+                keyspace=keyspace_param,
             )
+
+            # Create and connect to the newly created collection
+            try:
+                self._astra_db_collection = self._astra_db.create_collection(
+                    name=collection_name,
+                    dimension=embedding_dimension,
+                    indexing=requested_indexing_policy,
+                )
+            except CollectionAlreadyExistsException as e:
+                logger.info(f"{e}", exc_info=True)
+                self._astra_db_collection = self._astra_db.get_collection(name=collection_name)
+
         return self._astra_db_collection
 
     @requires_dependencies(["astrapy"], extras="astradb")
@@ -224,6 +251,9 @@ class AstraDBDestinationConnector(BaseDestinationConnector):
     def write_dict(self, *args, elements_dict: t.List[t.Dict[str, t.Any]], **kwargs) -> None:
         logger.info(f"inserting / updating {len(elements_dict)} documents to Astra DB.")
 
+        if self._astra_db_collection is None:
+            raise DestinationConnectionError("Astra DB collection not available for insertion.")
+
         astra_db_batch_size = self.write_config.batch_size
 
         for batch in batch_generator(elements_dict, astra_db_batch_size):

unstructured_ingest-0.0.22/unstructured_ingest/embed/bedrock.py

@@ -0,0 +1,107 @@
+import json
+import os
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import numpy as np
+from pydantic import Field, SecretStr
+
+from unstructured_ingest.embed.interfaces import BaseEmbeddingEncoder, EmbeddingConfig
+from unstructured_ingest.utils.dep_check import requires_dependencies
+
+if TYPE_CHECKING:
+    from botocore.client import BaseClient
+
+    class BedrockClient(BaseClient):
+        def invoke_model(self, body: str, modelId: str, trace: str) -> dict:
+            pass
+
+
+class BedrockEmbeddingConfig(EmbeddingConfig):
+    aws_access_key_id: SecretStr
+    aws_secret_access_key: SecretStr
+    region_name: str = "us-west-2"
+    embed_model_name: str = Field(default="amazon.titan-embed-text-v1", alias="model_name")
+
+    @requires_dependencies(
+        ["boto3", "numpy", "botocore"],
+        extras="bedrock",
+    )
+    def get_client(self) -> "BedrockClient":
+        # delay import only when needed
+        import boto3
+
+        bedrock_client = boto3.client(
+            service_name="bedrock-runtime",
+            aws_access_key_id=self.aws_access_key_id.get_secret_value(),
+            aws_secret_access_key=self.aws_secret_access_key.get_secret_value(),
+            region_name=self.region_name,
+        )
+
+        return bedrock_client
+
+
+@dataclass
+class BedrockEmbeddingEncoder(BaseEmbeddingEncoder):
+    config: BedrockEmbeddingConfig
+
+    def get_exemplary_embedding(self) -> list[float]:
+        return self.embed_query(query="Q")
+
+    def num_of_dimensions(self) -> tuple[int, ...]:
+        exemplary_embedding = self.get_exemplary_embedding()
+        return np.shape(exemplary_embedding)
+
+    def is_unit_vector(self) -> bool:
+        exemplary_embedding = self.get_exemplary_embedding()
+        return np.isclose(np.linalg.norm(exemplary_embedding), 1.0)
+
+    def embed_query(self, query: str) -> list[float]:
+        """Call out to Bedrock embedding endpoint."""
+        # replace newlines, which can negatively affect performance.
+        text = query.replace(os.linesep, " ")
+
+        # format input body for provider
+        provider = self.config.embed_model_name.split(".")[0]
+        input_body = {}
+        if provider == "cohere":
+            if "input_type" not in input_body:
+                input_body["input_type"] = "search_document"
+            input_body["texts"] = [text]
+        else:
+            # includes common provider == "amazon"
+            input_body["inputText"] = text
+        body = json.dumps(input_body)
+
+        try:
+            bedrock_client = self.config.get_client()
+            # invoke bedrock API
+            response = bedrock_client.invoke_model(
+                body=body,
+                modelId=self.config.embed_model_name,
+                accept="application/json",
+                contentType="application/json",
+            )
+
+            # format output based on provider
+            response_body = json.loads(response.get("body").read())
+            if provider == "cohere":
+                return response_body.get("embeddings")[0]
+            else:
+                # includes common provider == "amazon"
+                return response_body.get("embedding")
+        except Exception as e:
+            raise ValueError(f"Error raised by inference endpoint: {e}")
+
+    def embed_documents(self, elements: list[dict]) -> list[dict]:
+        embeddings = [self.embed_query(query=e.get("text", "")) for e in elements]
+        elements_with_embeddings = self._add_embeddings_to_elements(elements, embeddings)
+        return elements_with_embeddings
+
+    def _add_embeddings_to_elements(self, elements, embeddings) -> list[dict]:
+        assert len(elements) == len(embeddings)
+        elements_w_embedding = []
+        for i, element in enumerate(elements):
+            element["embeddings"] = embeddings[i]
+            elements_w_embedding.append(element)
+        return elements

{unstructured-ingest-0.0.19 → unstructured_ingest-0.0.22}/unstructured_ingest/embed/huggingface.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 import numpy as np
 from pydantic import Field
@@ -8,7 +8,7 @@ from unstructured_ingest.embed.interfaces import BaseEmbeddingEncoder, Embedding
 from unstructured_ingest.utils.dep_check import requires_dependencies
 
 if TYPE_CHECKING:
-    from langchain_huggingface.embeddings import HuggingFaceEmbeddings
+    from sentence_transformers import SentenceTransformer
 
 
 class HuggingFaceEmbeddingConfig(EmbeddingConfig):
@@ -19,51 +19,51 @@ class HuggingFaceEmbeddingConfig(EmbeddingConfig):
         default_factory=lambda: {"device": "cpu"}, alias="model_kwargs"
     )
     encode_kwargs: Optional[dict] = Field(default_factory=lambda: {"normalize_embeddings": False})
-    cache_folder: Optional[dict] = Field(default=None)
+    cache_folder: Optional[str] = Field(default=None)
 
     @requires_dependencies(
-        ["langchain_huggingface"],
+        ["sentence_transformers"],
         extras="embed-huggingface",
     )
-    def get_client(self) -> "HuggingFaceEmbeddings":
-        """Creates a langchain Huggingface python client to embed elements."""
-        from langchain_huggingface.embeddings import HuggingFaceEmbeddings
-
-        client = HuggingFaceEmbeddings(
-            model_name=self.embedder_model_name,
-            model_kwargs=self.embedder_model_kwargs,
-            encode_kwargs=self.encode_kwargs,
+    def get_client(self) -> "SentenceTransformer":
+        from sentence_transformers import SentenceTransformer
+
+        return SentenceTransformer(
+            model_name_or_path=self.embedder_model_name,
             cache_folder=self.cache_folder,
+            **self.embedder_model_kwargs,
         )
-        return client
 
 
 @dataclass
 class HuggingFaceEmbeddingEncoder(BaseEmbeddingEncoder):
     config: HuggingFaceEmbeddingConfig
 
-    def get_exemplary_embedding(self) -> List[float]:
+    def get_exemplary_embedding(self) -> list[float]:
         return self.embed_query(query="Q")
 
-    def num_of_dimensions(self):
+    def num_of_dimensions(self) -> tuple[int, ...]:
         exemplary_embedding = self.get_exemplary_embedding()
         return np.shape(exemplary_embedding)
 
-    def is_unit_vector(self):
+    def is_unit_vector(self) -> bool:
         exemplary_embedding = self.get_exemplary_embedding()
         return np.isclose(np.linalg.norm(exemplary_embedding), 1.0)
 
-    def embed_query(self, query):
-        client = self.config.get_client()
-        return client.embed_query(str(query))
+    def embed_query(self, query: str) -> list[float]:
+        return self._embed_documents(texts=[query])[0]
 
-    def embed_documents(self, elements: List[dict]) -> List[dict]:
+    def _embed_documents(self, texts: list[str]) -> list[list[float]]:
         client = self.config.get_client()
-        embeddings = client.embed_documents([e.get("text", "") for e in elements])
+        embeddings = client.encode(texts, **self.config.encode_kwargs)
+        return embeddings.tolist()
+
+    def embed_documents(self, elements: list[dict]) -> list[dict]:
+        embeddings = self._embed_documents([e.get("text", "") for e in elements])
         elements_with_embeddings = self._add_embeddings_to_elements(elements, embeddings)
         return elements_with_embeddings
 
-    def _add_embeddings_to_elements(self, elements: list[dict], embeddings: list) -> List[dict]:
+    def _add_embeddings_to_elements(self, elements: list[dict], embeddings: list) -> list[dict]:
         assert len(elements) == len(embeddings)
         elements_w_embedding = []
 

{unstructured-ingest-0.0.19 → unstructured_ingest-0.0.22}/unstructured_ingest/embed/interfaces.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import List, Tuple
 
 from pydantic import BaseModel
 
@@ -19,7 +18,7 @@ class BaseEmbeddingEncoder(ABC):
 
     @property
     @abstractmethod
-    def num_of_dimensions(self) -> Tuple[int]:
+    def num_of_dimensions(self) -> tuple[int, ...]:
         """Number of dimensions for the embedding vector."""
 
     @property
@@ -28,9 +27,17 @@ class BaseEmbeddingEncoder(ABC):
         """Denotes if the embedding vector is a unit vector."""
 
     @abstractmethod
-    def embed_documents(self, elements: List[dict]) -> List[dict]:
+    def embed_documents(self, elements: list[dict]) -> list[dict]:
         pass
 
     @abstractmethod
-    def embed_query(self, query: str) -> List[float]:
+    def embed_query(self, query: str) -> list[float]:
         pass
+
+    def _embed_documents(self, elements: list[str]) -> list[list[float]]:
+        results = []
+        for text in elements:
+            response = self.embed_query(query=text)
+            results.append(response)
+
+        return results