unstructured-ingest 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

test/unit/v2/embedders/test_huggingface.py

@@ -0,0 +1,48 @@
+import random
+from typing import Any
+
+import faker
+import pytest
+
+from test.unit.v2.utils.data_generator import generate_random_dictionary
+from unstructured_ingest.embed.huggingface import (
+    HuggingFaceEmbeddingConfig,
+    HuggingFaceEmbeddingEncoder,
+)
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {}
+    if random.random() < 0.5:
+        params["embed_model_name"] = fake.word() if random.random() < 0.5 else None
+        params["embedder_model_kwargs"] = (
+            generate_random_dictionary(key_type=str, value_type=Any)
+            if random.random() < 0.5
+            else None
+        )
+        params["encode_kwargs"] = (
+            generate_random_dictionary(key_type=str, value_type=Any)
+            if random.random() < 0.5
+            else None
+        )
+        params["cache_folder"] = fake.file_path() if random.random() < 0.5 else None
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = HuggingFaceEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = HuggingFaceEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = HuggingFaceEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/embedders/test_mixedbread.py

@@ -0,0 +1,37 @@
+import random
+
+import faker
+import pytest
+
+from unstructured_ingest.embed.mixedbreadai import (
+    MixedbreadAIEmbeddingConfig,
+    MixedbreadAIEmbeddingEncoder,
+)
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {
+        "api_key": fake.password(),
+    }
+    if random.random() < 0.5:
+        params["embedder_model_name"] = fake.word()
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = MixedbreadAIEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = MixedbreadAIEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = MixedbreadAIEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/embedders/test_octoai.py

@@ -0,0 +1,35 @@
+import random
+
+import faker
+import pytest
+
+from unstructured_ingest.embed.octoai import OctoAiEmbeddingConfig, OctoAIEmbeddingEncoder
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {
+        "api_key": fake.password(),
+    }
+    if random.random() < 0.5:
+        params["embedder_model_name"] = fake.word()
+        params["base_url"] = fake.url()
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = OctoAiEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = OctoAiEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = OctoAIEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/embedders/test_openai.py

@@ -0,0 +1,35 @@
+import random
+
+import faker
+import pytest
+
+from unstructured_ingest.embed.openai import OpenAIEmbeddingConfig, OpenAIEmbeddingEncoder
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {
+        "api_key": fake.password(),
+    }
+    if random.random() < 0.5:
+        params["embedder_model_name"] = fake.word()
+        params["base_url"] = fake.url()
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = OpenAIEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = OpenAIEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = OpenAIEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/embedders/test_togetherai.py

@@ -0,0 +1,37 @@
+import random
+
+import faker
+import pytest
+
+from unstructured_ingest.embed.togetherai import (
+    TogetherAIEmbeddingConfig,
+    TogetherAIEmbeddingEncoder,
+)
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {
+        "api_key": fake.password(),
+    }
+    if random.random() < 0.5:
+        params["embedder_model_name"] = fake.word()
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = TogetherAIEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = TogetherAIEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = TogetherAIEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/embedders/test_vertexai.py

@@ -0,0 +1,37 @@
+import json
+import random
+from typing import Any
+
+import faker
+import pytest
+
+from test.unit.v2.utils.data_generator import generate_random_dictionary
+from unstructured_ingest.embed.vertexai import VertexAIEmbeddingConfig, VertexAIEmbeddingEncoder
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {
+        "api_key": json.dumps(generate_random_dictionary(key_type=str, value_type=Any)),
+    }
+    if random.random() < 0.5:
+        params["embedder_model_name"] = fake.word()
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = VertexAIEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = VertexAIEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = VertexAIEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/embedders/test_voyageai.py

@@ -0,0 +1,38 @@
+import random
+
+import faker
+import pytest
+
+from unstructured_ingest.embed.voyageai import VoyageAIEmbeddingConfig, VoyageAIEmbeddingEncoder
+
+fake = faker.Faker()
+
+
+def generate_embedder_config_params() -> dict:
+    params = {
+        "api_key": fake.password(),
+    }
+    if random.random() < 0.5:
+        params["embedder_model_name"] = fake.word()
+        params["batch_size"] = fake.random_int()
+        params["truncation"] = fake.boolean()
+        params["max_retries"] = fake.random_int()
+        params["timeout_in_seconds"] = fake.random_int()
+    return params
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder_config(embedder_config_params: dict):
+    embedder_config = VoyageAIEmbeddingConfig.model_validate(embedder_config_params)
+    assert embedder_config
+
+
+@pytest.mark.parametrize(
+    "embedder_config_params", [generate_embedder_config_params() for i in range(10)]
+)
+def test_embedder(embedder_config_params: dict):
+    embedder_config = VoyageAIEmbeddingConfig.model_validate(embedder_config_params)
+    embedder = VoyageAIEmbeddingEncoder(config=embedder_config)
+    assert embedder

test/unit/v2/partitioners/test_partitioner.py

@@ -0,0 +1,63 @@
+import random
+from typing import Any
+
+import faker
+import pytest
+
+from test.unit.v2.utils.data_generator import generate_random_dictionary
+from unstructured_ingest.v2.processes.partitioner import Partitioner, PartitionerConfig
+
+fake = faker.Faker()
+
+
+def generate_partitioner_config_params() -> dict:
+    params = {
+        "strategy": random.choice(["fast", "hi_res", "auto"]),
+        "ocr_languages": fake.words() if random.random() < 0.5 else None,
+        "encoding": fake.word() if random.random() < 0.5 else None,
+        "additional_partition_args": (
+            generate_random_dictionary(key_type=str, value_type=Any)
+            if random.random() < 0.5
+            else None
+        ),
+        "skip_infer_table_types": fake.words() if random.random() < 0.5 else None,
+        "flatten_metadata": fake.boolean(),
+        "hi_res_model_name": fake.word() if random.random() < 0.5 else None,
+    }
+    random_val = random.random()
+    # Randomly set the fields_include to a random list[str]
+    if random_val < 0.5:
+        params["fields_include"] = fake.words()
+
+    # Randomly set the metadata_exclude or metadata_include to a valid
+    # list[str] or don't set it at all
+    if random.random() < (1 / 3):
+        params["metadata_exclude"] = fake.words()
+    elif random_val < (2 / 3):
+        params["metadata_include"] = fake.words()
+
+    # Randomly set the values associated with calling the api, or not at all
+    if random.random() < 0.5:
+        params["partition_by_api"]: True
+        params["partition_endpoint"] = fake.url()
+        params["api_key"] = fake.password()
+    else:
+        params["partition_by_api"]: False
+    return params
+
+
+@pytest.mark.parametrize(
+    "partition_config_params", [generate_partitioner_config_params() for i in range(10)]
+)
+def test_partition_config(partition_config_params: dict):
+    partition_config = PartitionerConfig.model_validate(partition_config_params)
+    assert partition_config
+
+
+@pytest.mark.parametrize(
+    "partition_config_params", [generate_partitioner_config_params() for i in range(10)]
+)
+def test_partitioner(partition_config_params: dict):
+    partition_config = PartitionerConfig.model_validate(partition_config_params)
+    partitioner = Partitioner(config=partition_config)
+    assert partitioner

test/unit/v2/utils/data_generator.py

@@ -0,0 +1,32 @@
+import random
+from typing import Any, Type
+
+from faker import Faker
+
+fake = Faker()
+
+type_to_random_value_map = {
+    str: fake.sentence,
+    int: fake.random_int,
+    float: fake.random_digit,
+    bool: fake.boolean,
+}
+type_to_random_value_map_key = type_to_random_value_map.copy()
+type_to_random_value_map_key[str] = fake.word
+
+
+def generate_random_dictionary(key_type: Type = str, value_type: Type = str) -> dict:
+    d = {}
+    num_keys = random.randint(1, 3)
+    for i in range(num_keys):
+        key = type_to_random_value_map_key[key_type]()
+        current_value_type = value_type
+        if current_value_type == Any:
+            current_value_type = random.choice(list(type_to_random_value_map.keys()) + [dict])
+        value = (
+            generate_random_dictionary(key_type=key_type, value_type=value_type)
+            if current_value_type is dict
+            else type_to_random_value_map[current_value_type]()
+        )
+        d[key] = value
+    return d

unstructured_ingest/__version__.py

@@ -1 +1 @@
-__version__ = "0.2.2"  # pragma: no cover
+__version__ = "0.3.1"  # pragma: no cover

unstructured_ingest/cli/cmds/__init__.py

@@ -9,7 +9,7 @@ from unstructured_ingest.cli.cmds.fsspec.sftp import get_base_src_cmd as sftp_ba
 from .airtable import get_base_src_cmd as airtable_base_src_cmd
 from .astradb import get_base_dest_cmd as astradb_base_dest_cmd
 from .astradb import get_base_src_cmd as astradb_base_src_cmd
-from .azure_cognitive_search import get_base_dest_cmd as azure_cognitive_search_base_dest_cmd
+from .azure_ai_search import get_base_dest_cmd as azure_ai_search_base_dest_cmd
 from .biomed import get_base_src_cmd as biomed_base_src_cmd
 from .chroma import get_base_dest_cmd as chroma_base_dest_cmd
 from .clarifai import get_base_dest_cmd as clarifai_base_dest_cmd
@@ -118,7 +118,7 @@ base_dest_cmd_fns: t.List[t.Callable[[], "BaseDestCmd"]] = [
     gcs_base_dest_cmd,
     kafka_base_dest_cmd,
     s3_base_dest_cmd,
-    azure_cognitive_search_base_dest_cmd,
+    azure_ai_search_base_dest_cmd,
     delta_table_dest_cmd,
     sql_base_dest_cmd,
     weaviate_dest_cmd,

unstructured_ingest/cli/cmds/{azure_cognitive_search.py → azure_ai_search.py}

@@ -6,14 +6,14 @@ import click
 from unstructured_ingest.cli.interfaces import (
     CliConfig,
 )
-from unstructured_ingest.connector.azure_cognitive_search import (
-    AzureCognitiveSearchWriteConfig,
-    SimpleAzureCognitiveSearchStorageConfig,
+from unstructured_ingest.connector.azure_ai_search import (
+    AzureAISearchWriteConfig,
+    SimpleAzureAISearchStorageConfig,
 )
 
 
 @dataclass
-class AzureCognitiveSearchCliConfig(SimpleAzureCognitiveSearchStorageConfig, CliConfig):
+class AzureAISearchCliConfig(SimpleAzureAISearchStorageConfig, CliConfig):
     @staticmethod
     def get_cli_options() -> t.List[click.Option]:
         options = [
@@ -39,7 +39,7 @@ class AzureCognitiveSearchCliConfig(SimpleAzureCognitiveSearchStorageConfig, Cli
 
 
 @dataclass
-class AzureCognitiveSearchCliWriteConfig(AzureCognitiveSearchWriteConfig, CliConfig):
+class AzureAISearchCliWriteConfig(AzureAISearchWriteConfig, CliConfig):
     @staticmethod
     def get_cli_options() -> t.List[click.Option]:
         options = [
@@ -57,9 +57,9 @@ def get_base_dest_cmd():
     from unstructured_ingest.cli.base.dest import BaseDestCmd
 
     cmd_cls = BaseDestCmd(
-        cmd_name="azure-cognitive-search",
-        cli_config=AzureCognitiveSearchCliConfig,
-        additional_cli_options=[AzureCognitiveSearchCliWriteConfig],
-        write_config=AzureCognitiveSearchCliWriteConfig,
+        cmd_name="azure-ai-search",
+        cli_config=AzureAISearchCliConfig,
+        additional_cli_options=[AzureAISearchCliWriteConfig],
+        write_config=AzureAISearchCliWriteConfig,
     )
     return cmd_cls

unstructured_ingest/connector/{azure_cognitive_search.py → azure_ai_search.py}

@@ -19,28 +19,28 @@ if t.TYPE_CHECKING:
 
 
 @dataclass
-class AzureCognitiveSearchAccessConfig(AccessConfig):
+class AzureAiSearchAccessConfig(AccessConfig):
     key: str = enhanced_field(sensitive=True)
 
 
 @dataclass
-class SimpleAzureCognitiveSearchStorageConfig(BaseConnectorConfig):
+class SimpleAzureAISearchStorageConfig(BaseConnectorConfig):
     endpoint: str
-    access_config: AzureCognitiveSearchAccessConfig
+    access_config: AzureAiSearchAccessConfig
 
 
 @dataclass
-class AzureCognitiveSearchWriteConfig(WriteConfig):
+class AzureAISearchWriteConfig(WriteConfig):
     index: str
 
 
 @dataclass
-class AzureCognitiveSearchDestinationConnector(BaseDestinationConnector):
-    write_config: AzureCognitiveSearchWriteConfig
-    connector_config: SimpleAzureCognitiveSearchStorageConfig
+class AzureAISearchDestinationConnector(BaseDestinationConnector):
+    write_config: AzureAISearchWriteConfig
+    connector_config: SimpleAzureAISearchStorageConfig
     _client: t.Optional["SearchClient"] = field(init=False, default=None)
 
-    @requires_dependencies(["azure.search"], extras="azure-cognitive-search")
+    @requires_dependencies(["azure.search"], extras="azure-ai-search")
     def generate_client(self) -> "SearchClient":
         from azure.core.credentials import AzureKeyCredential
         from azure.search.documents import SearchClient
@@ -112,7 +112,7 @@ class AzureCognitiveSearchDestinationConnector(BaseDestinationConnector):
         if page_number := data.get("metadata", {}).get("page_number"):
             data["metadata"]["page_number"] = str(page_number)
 
-    @requires_dependencies(["azure"], extras="azure-cognitive-search")
+    @requires_dependencies(["azure"], extras="azure-ai-search")
     def write_dict(self, *args, elements_dict: t.List[t.Dict[str, t.Any]], **kwargs) -> None:
         import azure.core.exceptions
 

unstructured_ingest/pipeline/reformat/embedding.py

@@ -61,4 +61,4 @@ class Embedder(ReformatNode):
             return None
 
     def get_path(self) -> Path:
-        return (Path(self.pipeline_context.work_dir) / "embedded").resolve()
+        return (Path(self.pipeline_context.work_dir) / "embedded.py").resolve()

unstructured_ingest/runner/writers/__init__.py

@@ -1,7 +1,7 @@
 import typing as t
 
 from .astradb import AstraDBWriter
-from .azure_cognitive_search import AzureCognitiveSearchWriter
+from .azure_ai_search import AzureAiSearchWriter
 from .base_writer import Writer
 from .chroma import ChromaWriter
 from .clarifai import ClarifaiWriter
@@ -25,7 +25,7 @@ from .weaviate import WeaviateWriter
 writer_map: t.Dict[str, t.Type[Writer]] = {
     "astradb": AstraDBWriter,
     "azure": AzureWriter,
-    "azure_cognitive_search": AzureCognitiveSearchWriter,
+    "azure_ai_search": AzureAiSearchWriter,
     "box": BoxWriter,
     "chroma": ChromaWriter,
     "clarifai": ClarifaiWriter,

unstructured_ingest/runner/writers/azure_ai_search.py

@@ -0,0 +1,24 @@
+import typing as t
+from dataclasses import dataclass
+
+from unstructured_ingest.interfaces import BaseDestinationConnector
+from unstructured_ingest.runner.writers.base_writer import Writer
+
+if t.TYPE_CHECKING:
+    from unstructured_ingest.connector.azure_ai_search import (
+        AzureAISearchWriteConfig,
+        SimpleAzureAISearchStorageConfig,
+    )
+
+
+@dataclass
+class AzureAiSearchWriter(Writer):
+    connector_config: "SimpleAzureAISearchStorageConfig"
+    write_config: "AzureAISearchWriteConfig"
+
+    def get_connector_cls(self) -> t.Type[BaseDestinationConnector]:
+        from unstructured_ingest.connector.azure_ai_search import (
+            AzureAISearchDestinationConnector,
+        )
+
+        return AzureAISearchDestinationConnector

unstructured_ingest/utils/data_prep.py

@@ -1,7 +1,9 @@
 import itertools
 import json
 from datetime import datetime
-from typing import Any, Iterable, Optional, Sequence, TypeVar, cast
+from typing import Any, Generator, Iterable, Optional, Sequence, TypeVar, cast
+
+import pandas as pd
 
 DATE_FORMATS = ("%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d+%H:%M:%S", "%Y-%m-%dT%H:%M:%S%z")
 
@@ -9,6 +11,12 @@ T = TypeVar("T")
 IterableT = Iterable[T]
 
 
+def split_dataframe(df: pd.DataFrame, chunk_size: int = 100) -> Generator[pd.DataFrame, None, None]:
+    num_chunks = len(df) // chunk_size + 1
+    for i in range(num_chunks):
+        yield df[i * chunk_size : (i + 1) * chunk_size]
+
+
 def batch_generator(iterable: IterableT, batch_size: int = 100) -> IterableT:
     """A helper function to break an iterable into batches of size batch_size."""
     it = iter(iterable)

unstructured_ingest/v2/constants.py

@@ -0,0 +1,2 @@
+# Used to append to metadata for uploaders that store element-level data
+RECORD_ID_LABEL = "record_id"

unstructured_ingest/v2/processes/connectors/__init__.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 import unstructured_ingest.v2.processes.connectors.databricks  # noqa: F401
+import unstructured_ingest.v2.processes.connectors.elasticsearch  # noqa: F401
 import unstructured_ingest.v2.processes.connectors.fsspec  # noqa: F401
 import unstructured_ingest.v2.processes.connectors.kafka  # noqa: F401
+import unstructured_ingest.v2.processes.connectors.lancedb  # noqa: F401
 import unstructured_ingest.v2.processes.connectors.qdrant  # noqa: F401
 import unstructured_ingest.v2.processes.connectors.sql  # noqa: F401
+import unstructured_ingest.v2.processes.connectors.weaviate  # noqa: F401
 from unstructured_ingest.v2.processes.connector_registry import (
     add_destination_entry,
     add_source_entry,
@@ -14,8 +17,8 @@ from .airtable import CONNECTOR_TYPE as AIRTABLE_CONNECTOR_TYPE
 from .airtable import airtable_source_entry
 from .astradb import CONNECTOR_TYPE as ASTRA_DB_CONNECTOR_TYPE
 from .astradb import astra_db_destination_entry, astra_db_source_entry
-from .azure_cognitive_search import CONNECTOR_TYPE as AZURE_COGNTIVE_SEARCH_CONNECTOR_TYPE
-from .azure_cognitive_search import azure_cognitive_search_destination_entry
+from .azure_ai_search import CONNECTOR_TYPE as AZURE_AI_SEARCH_CONNECTOR_TYPE
+from .azure_ai_search import azure_ai_search_destination_entry
 from .chroma import CONNECTOR_TYPE as CHROMA_CONNECTOR_TYPE
 from .chroma import chroma_destination_entry
 from .confluence import CONNECTOR_TYPE as CONFLUENCE_CONNECTOR_TYPE
@@ -24,8 +27,6 @@ from .couchbase import CONNECTOR_TYPE as COUCHBASE_CONNECTOR_TYPE
 from .couchbase import couchbase_destination_entry, couchbase_source_entry
 from .delta_table import CONNECTOR_TYPE as DELTA_TABLE_CONNECTOR_TYPE
 from .delta_table import delta_table_destination_entry
-from .elasticsearch import CONNECTOR_TYPE as ELASTICSEARCH_CONNECTOR_TYPE
-from .elasticsearch import elasticsearch_destination_entry, elasticsearch_source_entry
 from .gitlab import CONNECTOR_TYPE as GITLAB_CONNECTOR_TYPE
 from .gitlab import gitlab_source_entry
 from .google_drive import CONNECTOR_TYPE as GOOGLE_DRIVE_CONNECTOR_TYPE
@@ -40,8 +41,6 @@ from .mongodb import CONNECTOR_TYPE as MONGODB_CONNECTOR_TYPE
 from .mongodb import mongodb_destination_entry, mongodb_source_entry
 from .onedrive import CONNECTOR_TYPE as ONEDRIVE_CONNECTOR_TYPE
 from .onedrive import onedrive_destination_entry, onedrive_source_entry
-from .opensearch import CONNECTOR_TYPE as OPENSEARCH_CONNECTOR_TYPE
-from .opensearch import opensearch_destination_entry, opensearch_source_entry
 from .outlook import CONNECTOR_TYPE as OUTLOOK_CONNECTOR_TYPE
 from .outlook import outlook_source_entry
 from .pinecone import CONNECTOR_TYPE as PINECONE_CONNECTOR_TYPE
@@ -52,8 +51,6 @@ from .sharepoint import CONNECTOR_TYPE as SHAREPOINT_CONNECTOR_TYPE
 from .sharepoint import sharepoint_source_entry
 from .slack import CONNECTOR_TYPE as SLACK_CONNECTOR_TYPE
 from .slack import slack_source_entry
-from .weaviate import CONNECTOR_TYPE as WEAVIATE_CONNECTOR_TYPE
-from .weaviate import weaviate_destination_entry
 
 add_source_entry(source_type=ASTRA_DB_CONNECTOR_TYPE, entry=astra_db_source_entry)
 add_destination_entry(destination_type=ASTRA_DB_CONNECTOR_TYPE, entry=astra_db_destination_entry)
@@ -67,10 +64,6 @@ add_destination_entry(
     destination_type=DELTA_TABLE_CONNECTOR_TYPE, entry=delta_table_destination_entry
 )
 
-add_source_entry(source_type=ELASTICSEARCH_CONNECTOR_TYPE, entry=elasticsearch_source_entry)
-add_destination_entry(
-    destination_type=ELASTICSEARCH_CONNECTOR_TYPE, entry=elasticsearch_destination_entry
-)
 
 add_source_entry(source_type=GOOGLE_DRIVE_CONNECTOR_TYPE, entry=google_drive_source_entry)
 
@@ -80,15 +73,9 @@ add_destination_entry(destination_type=LOCAL_CONNECTOR_TYPE, entry=local_destina
 add_source_entry(source_type=ONEDRIVE_CONNECTOR_TYPE, entry=onedrive_source_entry)
 add_destination_entry(destination_type=ONEDRIVE_CONNECTOR_TYPE, entry=onedrive_destination_entry)
 
-add_source_entry(source_type=OPENSEARCH_CONNECTOR_TYPE, entry=opensearch_source_entry)
-add_destination_entry(
-    destination_type=OPENSEARCH_CONNECTOR_TYPE, entry=opensearch_destination_entry
-)
 
 add_source_entry(source_type=SALESFORCE_CONNECTOR_TYPE, entry=salesforce_source_entry)
 
-add_destination_entry(destination_type=WEAVIATE_CONNECTOR_TYPE, entry=weaviate_destination_entry)
-
 add_destination_entry(destination_type=MONGODB_CONNECTOR_TYPE, entry=mongodb_destination_entry)
 add_source_entry(source_type=MONGODB_CONNECTOR_TYPE, entry=mongodb_source_entry)
 
@@ -97,8 +84,8 @@ add_source_entry(source_type=SHAREPOINT_CONNECTOR_TYPE, entry=sharepoint_source_
 
 add_destination_entry(destination_type=MILVUS_CONNECTOR_TYPE, entry=milvus_destination_entry)
 add_destination_entry(
-    destination_type=AZURE_COGNTIVE_SEARCH_CONNECTOR_TYPE,
-    entry=azure_cognitive_search_destination_entry,
+    destination_type=AZURE_AI_SEARCH_CONNECTOR_TYPE,
+    entry=azure_ai_search_destination_entry,
 )
 
 add_destination_entry(destination_type=KDBAI_CONNECTOR_TYPE, entry=kdbai_destination_entry)