unstructured-ingest 1.2.32__py3-none-any.whl

unstructured_ingest/processes/connectors/vectara.py

@@ -0,0 +1,348 @@
+import asyncio
+import json
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Mapping, Optional
+
+from pydantic import Field, Secret
+
+from unstructured_ingest.data_types.file_data import FileData
+from unstructured_ingest.error import DestinationConnectionError, ValueError
+from unstructured_ingest.interfaces import (
+    AccessConfig,
+    ConnectionConfig,
+    Uploader,
+    UploaderConfig,
+    UploadStager,
+    UploadStagerConfig,
+)
+from unstructured_ingest.logger import logger
+from unstructured_ingest.processes.connector_registry import DestinationRegistryEntry
+from unstructured_ingest.utils.data_prep import flatten_dict
+from unstructured_ingest.utils.dep_check import requires_dependencies
+
+BASE_URL = "https://api.vectara.io/v2"
+
+CONNECTOR_TYPE = "vectara"
+
+
+class VectaraAccessConfig(AccessConfig):
+    oauth_client_id: str = Field(description="Client ID")
+    oauth_secret: str = Field(description="Client Secret")
+
+
+class VectaraConnectionConfig(ConnectionConfig):
+    access_config: Secret[VectaraAccessConfig]
+    customer_id: str
+    corpus_name: Optional[str] = None
+    corpus_key: Optional[str] = None
+    token_url: str = "https://vectara-prod-{}.auth.us-west-2.amazoncognito.com/oauth2/token"
+
+
+class VectaraUploadStagerConfig(UploadStagerConfig):
+    pass
+
+
+@dataclass
+class VectaraUploadStager(UploadStager):
+    upload_stager_config: VectaraUploadStagerConfig = field(
+        default_factory=lambda: VectaraUploadStagerConfig()
+    )
+
+    @staticmethod
+    def conform_dict(data: dict) -> dict:
+        """
+        Prepares dictionary in the format that Vectara requires.
+        See more detail in https://docs.vectara.com/docs/rest-api/create-corpus-document
+
+        Select which meta-data fields to include and optionally map them to a new format.
+        remove the "metadata-" prefix from the keys
+        """
+        metadata_map = {
+            "page_number": "page_number",
+            "data_source-url": "url",
+            "filename": "filename",
+            "filetype": "filetype",
+            "last_modified": "last_modified",
+            "element_id": "element_id",
+        }
+        md = flatten_dict(data, separator="-", flatten_lists=True)
+        md = {k.replace("metadata-", ""): v for k, v in md.items()}
+        md = {metadata_map[k]: v for k, v in md.items() if k in metadata_map}
+        return md
+
+    def process_whole(self, input_file: Path, output_file: Path, file_data: FileData) -> None:
+        with input_file.open() as in_f:
+            elements_contents = json.load(in_f)
+
+        logger.info(
+            f"Extending {len(elements_contents)} json elements from content in {input_file}"
+        )
+
+        conformed_elements = [
+            {
+                "id": str(uuid.uuid4()),
+                "type": "core",
+                "metadata": {
+                    "title": file_data.identifier,
+                },
+                "document_parts": [
+                    {
+                        "text": element.pop("text", None),
+                        "metadata": self.conform_dict(data=element),
+                    }
+                    for element in elements_contents
+                ],
+            }
+        ]
+
+        with open(output_file, "w") as out_f:
+            json.dump(conformed_elements, out_f, indent=2)
+
+
+class VectaraUploaderConfig(UploaderConfig):
+    pass
+
+
+@dataclass
+class VectaraUploader(Uploader):
+    connector_type: str = CONNECTOR_TYPE
+    upload_config: VectaraUploaderConfig
+    connection_config: VectaraConnectionConfig
+    _jwt_token: Optional[str] = field(init=False, default=None)
+    _jwt_token_expires_ts: Optional[float] = field(init=False, default=None)
+
+    def is_async(self) -> bool:
+        return True
+
+    def precheck(self) -> None:
+        try:
+            self._check_connection_and_corpora()
+        except Exception as e:
+            logger.error(f"Failed to validate connection {e}", exc_info=True)
+            raise DestinationConnectionError(f"failed to validate connection: {e}")
+
+    @property
+    async def jwt_token_async(self) -> str:
+        if not self._jwt_token or self._jwt_token_expires_ts - datetime.now().timestamp() <= 60:
+            self._jwt_token = await self._get_jwt_token_async()
+        return self._jwt_token
+
+    @property
+    def jwt_token(self) -> str:
+        if not self._jwt_token or self._jwt_token_expires_ts - datetime.now().timestamp() <= 60:
+            self._jwt_token = self._get_jwt_token()
+        return self._jwt_token
+
+    # Get Oauth2 JWT token
+    @requires_dependencies(["httpx"], extras="vectara")
+    async def _get_jwt_token_async(self) -> str:
+        import httpx
+
+        """Connect to the server and get a JWT token."""
+        token_endpoint = self.connection_config.token_url.format(self.connection_config.customer_id)
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.connection_config.access_config.get_secret_value().oauth_client_id,
+            "client_secret": self.connection_config.access_config.get_secret_value().oauth_secret,
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(token_endpoint, headers=headers, data=data)
+            response.raise_for_status()
+            response_json = response.json()
+
+        request_time = datetime.now().timestamp()
+        self._jwt_token_expires_ts = request_time + response_json.get("expires_in")
+
+        return response_json.get("access_token")
+
+    # Get Oauth2 JWT token
+    @requires_dependencies(["httpx"], extras="vectara")
+    def _get_jwt_token(self) -> str:
+        import httpx
+
+        """Connect to the server and get a JWT token."""
+        token_endpoint = self.connection_config.token_url.format(self.connection_config.customer_id)
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.connection_config.access_config.get_secret_value().oauth_client_id,
+            "client_secret": self.connection_config.access_config.get_secret_value().oauth_secret,
+        }
+
+        with httpx.Client() as client:
+            response = client.post(token_endpoint, headers=headers, data=data)
+            response.raise_for_status()
+            response_json = response.json()
+
+        request_time = datetime.now().timestamp()
+        self._jwt_token_expires_ts = request_time + response_json.get("expires_in")
+
+        return response_json.get("access_token")
+
+    @DestinationConnectionError.wrap
+    def _check_connection_and_corpora(self) -> None:
+        """
+        Check the connection for Vectara and validate corpus exists.
+        - If more than one corpus with the same name exists - raise error
+        - If exactly one corpus exists with this name - use it.
+        - If does not exist - raise error.
+        """
+        # Get token if not already set
+        self.jwt_token
+
+        _, list_corpora_response = self._request(
+            http_method="GET",
+            endpoint="corpora",
+        )
+
+        if self.connection_config.corpus_name:
+            possible_corpora_keys_names_map = {
+                corpus.get("key"): corpus.get("name")
+                for corpus in list_corpora_response.get("corpora")
+                if corpus.get("name") == self.connection_config.corpus_name
+            }
+
+            if len(possible_corpora_keys_names_map) > 1:
+                raise ValueError(
+                    f"Multiple Corpus exist with name {self.connection_config.corpus_name} in dest."
+                )
+            if len(possible_corpora_keys_names_map) == 1:
+                if not self.connection_config.corpus_key:
+                    self.connection_config.corpus_key = list(
+                        possible_corpora_keys_names_map.keys()
+                    )[0]
+                elif (
+                    self.connection_config.corpus_key
+                    != list(possible_corpora_keys_names_map.keys())[0]
+                ):
+                    raise ValueError("Corpus key does not match provided corpus name.")
+            else:
+                raise ValueError(
+                    f"No Corpora exist with name {self.connection_config.corpus_name} in dest."
+                )
+
+    @requires_dependencies(["httpx"], extras="vectara")
+    async def _async_request(
+        self,
+        endpoint: str,
+        http_method: str = "POST",
+        params: Mapping[str, Any] = None,
+        data: Mapping[str, Any] = None,
+    ) -> tuple[bool, dict]:
+        import httpx
+
+        url = f"{BASE_URL}/{endpoint}"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {await self.jwt_token_async}",
+            "X-source": "unstructured",
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.request(
+                method=http_method, url=url, headers=headers, params=params, json=data
+            )
+            response.raise_for_status()
+            return response.json()
+
+    @requires_dependencies(["httpx"], extras="vectara")
+    def _request(
+        self,
+        endpoint: str,
+        http_method: str = "POST",
+        params: Mapping[str, Any] = None,
+        data: Mapping[str, Any] = None,
+    ) -> tuple[bool, dict]:
+        import httpx
+
+        url = f"{BASE_URL}/{endpoint}"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.jwt_token}",
+            "X-source": "unstructured",
+        }
+
+        with httpx.Client() as client:
+            response = client.request(
+                method=http_method, url=url, headers=headers, params=params, json=data
+            )
+            response.raise_for_status()
+            return response.json()
+
+    async def _delete_doc(self, doc_id: str) -> tuple[bool, dict]:
+        """
+        Delete a document from the Vectara corpus.
+        """
+
+        return await self._async_request(
+            endpoint=f"corpora/{self.connection_config.corpus_key}/documents/{doc_id}",
+            http_method="DELETE",
+        )
+
+    async def _index_document(self, document: Dict[str, Any]) -> None:
+        """
+        Index a document (by uploading it to the Vectara corpus) from the document dictionary
+        """
+
+        logger.debug(
+            f"Indexing document {document['id']} to corpus key {self.connection_config.corpus_key}"
+        )
+
+        try:
+            result = await self._async_request(
+                endpoint=f"corpora/{self.connection_config.corpus_key}/documents", data=document
+            )
+        except Exception as e:
+            logger.error(f"exception {e} while indexing document {document['id']}")
+            return
+
+        if (
+            "messages" in result
+            and result["messages"]
+            and (
+                "ALREADY_EXISTS" in result["messages"]
+                or (
+                    "CONFLICT: Indexing doesn't support updating documents."
+                    in result["messages"][0]
+                )
+            )
+        ):
+            logger.info(f"document {document['id']} already exists, re-indexing")
+            await self._delete_doc(document["id"])
+            await self._async_request(
+                endpoint=f"corpora/{self.connection_config.corpus_key}/documents", data=document
+            )
+            return
+
+        logger.info(f"indexing document {document['id']} succeeded")
+
+    async def run_data_async(
+        self,
+        data: list[dict],
+        file_data: FileData,
+        **kwargs: Any,
+    ) -> None:
+        logger.info(f"inserting / updating {len(data)} documents to Vectara ")
+        await asyncio.gather(*(self._index_document(vdoc) for vdoc in data))
+
+
+vectara_destination_entry = DestinationRegistryEntry(
+    connection_config=VectaraConnectionConfig,
+    uploader=VectaraUploader,
+    uploader_config=VectaraUploaderConfig,
+    upload_stager=VectaraUploadStager,
+    upload_stager_config=VectaraUploadStagerConfig,
+)

unstructured_ingest/processes/connectors/weaviate/__init__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from unstructured_ingest.processes.connector_registry import (
+    add_destination_entry,
+)
+
+from .cloud import CONNECTOR_TYPE as CLOUD_WEAVIATE_CONNECTOR_TYPE
+from .cloud import weaviate_cloud_destination_entry
+from .embedded import CONNECTOR_TYPE as EMBEDDED_WEAVIATE_CONNECTOR_TYPE
+from .embedded import weaviate_embedded_destination_entry
+from .local import CONNECTOR_TYPE as LOCAL_WEAVIATE_CONNECTOR_TYPE
+from .local import weaviate_local_destination_entry
+
+add_destination_entry(
+    destination_type=LOCAL_WEAVIATE_CONNECTOR_TYPE, entry=weaviate_local_destination_entry
+)
+add_destination_entry(
+    destination_type=CLOUD_WEAVIATE_CONNECTOR_TYPE, entry=weaviate_cloud_destination_entry
+)
+add_destination_entry(
+    destination_type=EMBEDDED_WEAVIATE_CONNECTOR_TYPE, entry=weaviate_embedded_destination_entry
+)

unstructured_ingest/processes/connectors/weaviate/cloud.py

@@ -0,0 +1,166 @@
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Generator, Optional
+
+from pydantic import Field, Secret
+
+from unstructured_ingest.error import ValueError
+from unstructured_ingest.processes.connector_registry import DestinationRegistryEntry
+from unstructured_ingest.processes.connectors.weaviate.weaviate import (
+    WeaviateAccessConfig,
+    WeaviateConnectionConfig,
+    WeaviateUploader,
+    WeaviateUploaderConfig,
+    WeaviateUploadStager,
+    WeaviateUploadStagerConfig,
+)
+from unstructured_ingest.utils.dep_check import requires_dependencies
+
+if TYPE_CHECKING:
+    from weaviate.auth import AuthCredentials
+    from weaviate.client import WeaviateClient
+
+CONNECTOR_TYPE = "weaviate-cloud"
+
+
+class CloudWeaviateAccessConfig(WeaviateAccessConfig):
+    access_token: Optional[str] = Field(
+        default=None, description="Used to create the bearer token."
+    )
+    api_key: Optional[str] = None
+    client_secret: Optional[str] = None
+    password: Optional[str] = None
+
+
+class CloudWeaviateConnectionConfig(WeaviateConnectionConfig):
+    cluster_url: str = Field(
+        description="The WCD cluster URL or hostname to connect to. "
+        "Usually in the form: rAnD0mD1g1t5.something.weaviate.cloud"
+    )
+    username: Optional[str] = None
+    anonymous: bool = Field(default=False, description="if set, all auth values will be ignored")
+    refresh_token: Optional[str] = Field(
+        default=None,
+        description="Will tie this value to the bearer token. If not provided, "
+        "the authentication will expire once the lifetime of the access token is up.",
+    )
+    access_config: Secret[CloudWeaviateAccessConfig]
+
+    def model_post_init(self, __context: Any) -> None:
+        if self.anonymous:
+            return
+        access_config = self.access_config.get_secret_value()
+        auths = {
+            "api_key": access_config.api_key is not None,
+            "bearer_token": access_config.access_token is not None,
+            "client_secret": access_config.client_secret is not None,
+            "client_password": access_config.password is not None and self.username is not None,
+        }
+        existing_auths = [auth_method for auth_method, flag in auths.items() if flag]
+
+        if len(existing_auths) == 0:
+            raise ValueError("No auth values provided and anonymous is False")
+        if len(existing_auths) > 1:
+            raise ValueError(
+                "Multiple auth values provided, only one approach can be used: {}".format(
+                    ", ".join(existing_auths)
+                )
+            )
+
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_api_key_auth(self) -> Optional["AuthCredentials"]:
+        from weaviate.classes.init import Auth
+
+        if api_key := self.access_config.get_secret_value().api_key:
+            return Auth.api_key(api_key=api_key)
+        return None
+
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_bearer_token_auth(self) -> Optional["AuthCredentials"]:
+        from weaviate.classes.init import Auth
+
+        if access_token := self.access_config.get_secret_value().access_token:
+            return Auth.bearer_token(access_token=access_token, refresh_token=self.refresh_token)
+        return None
+
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_client_secret_auth(self) -> Optional["AuthCredentials"]:
+        from weaviate.classes.init import Auth
+
+        if client_secret := self.access_config.get_secret_value().client_secret:
+            return Auth.client_credentials(client_secret=client_secret)
+        return None
+
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_client_password_auth(self) -> Optional["AuthCredentials"]:
+        from weaviate.classes.init import Auth
+
+        if (username := self.username) and (
+            password := self.access_config.get_secret_value().password
+        ):
+            return Auth.client_password(username=username, password=password)
+        return None
+
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_auth(self) -> "AuthCredentials":
+        auths = [
+            self.get_api_key_auth(),
+            self.get_client_secret_auth(),
+            self.get_bearer_token_auth(),
+            self.get_client_password_auth(),
+        ]
+        auths = [auth for auth in auths if auth]
+        if len(auths) == 0:
+            raise ValueError("No auth values provided and anonymous is False")
+        if len(auths) > 1:
+            raise ValueError("Multiple auth values provided, only one approach can be used")
+        return auths[0]
+
+    @contextmanager
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_client(self) -> Generator["WeaviateClient", None, None]:
+        from weaviate import connect_to_weaviate_cloud
+        from weaviate.classes.init import AdditionalConfig
+
+        auth_credentials = None if self.anonymous else self.get_auth()
+        with connect_to_weaviate_cloud(
+            cluster_url=self.cluster_url,
+            auth_credentials=auth_credentials,
+            additional_config=AdditionalConfig(timeout=self.get_timeout()),
+        ) as weaviate_client:
+            yield weaviate_client
+
+
+class CloudWeaviateUploadStagerConfig(WeaviateUploadStagerConfig):
+    pass
+
+
+@dataclass
+class CloudWeaviateUploadStager(WeaviateUploadStager):
+    upload_stager_config: CloudWeaviateUploadStagerConfig = field(
+        default_factory=lambda: WeaviateUploadStagerConfig()
+    )
+
+
+class CloudWeaviateUploaderConfig(WeaviateUploaderConfig):
+    pass
+
+
+@dataclass
+class CloudWeaviateUploader(WeaviateUploader):
+    connection_config: CloudWeaviateConnectionConfig = field(
+        default_factory=lambda: CloudWeaviateConnectionConfig()
+    )
+    upload_config: CloudWeaviateUploaderConfig = field(
+        default_factory=lambda: CloudWeaviateUploaderConfig()
+    )
+    connector_type: str = CONNECTOR_TYPE
+
+
+weaviate_cloud_destination_entry = DestinationRegistryEntry(
+    connection_config=CloudWeaviateConnectionConfig,
+    uploader=CloudWeaviateUploader,
+    uploader_config=CloudWeaviateUploaderConfig,
+    upload_stager=CloudWeaviateUploadStager,
+    upload_stager_config=CloudWeaviateUploadStagerConfig,
+)

unstructured_ingest/processes/connectors/weaviate/embedded.py

@@ -0,0 +1,90 @@
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Generator, Optional
+
+from pydantic import Field, Secret
+
+from unstructured_ingest.processes.connector_registry import DestinationRegistryEntry
+from unstructured_ingest.processes.connectors.weaviate.weaviate import (
+    WeaviateAccessConfig,
+    WeaviateConnectionConfig,
+    WeaviateUploader,
+    WeaviateUploaderConfig,
+    WeaviateUploadStager,
+    WeaviateUploadStagerConfig,
+)
+from unstructured_ingest.utils.dep_check import requires_dependencies
+
+if TYPE_CHECKING:
+    from weaviate.client import WeaviateClient
+
+CONNECTOR_TYPE = "weaviate-embedded"
+
+
+class EmbeddedWeaviateAccessConfig(WeaviateAccessConfig):
+    pass
+
+
+class EmbeddedWeaviateConnectionConfig(WeaviateConnectionConfig):
+    hostname: str = Field(default="127.0.0.1", description="hostname")
+    port: int = Field(default=8079, description="http port")
+    grpc_port: int = Field(default=50050, description="grpc port")
+    data_path: Optional[str] = Field(
+        default=None,
+        description="directory where the files making up the "
+        "database are stored. If not provided, will "
+        "default to underlying SDK implementation",
+    )
+    access_config: Secret[WeaviateAccessConfig] = Field(
+        default=WeaviateAccessConfig(), validate_default=True
+    )
+
+    @contextmanager
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_client(self) -> Generator["WeaviateClient", None, None]:
+        from weaviate import connect_to_embedded
+        from weaviate.classes.init import AdditionalConfig
+
+        with connect_to_embedded(
+            hostname=self.hostname,
+            port=self.port,
+            grpc_port=self.grpc_port,
+            persistence_data_path=self.data_path,
+            additional_config=AdditionalConfig(timeout=self.get_timeout()),
+        ) as weaviate_client:
+            yield weaviate_client
+
+
+class EmbeddedWeaviateUploadStagerConfig(WeaviateUploadStagerConfig):
+    pass
+
+
+@dataclass
+class EmbeddedWeaviateUploadStager(WeaviateUploadStager):
+    upload_stager_config: EmbeddedWeaviateUploadStagerConfig = field(
+        default_factory=lambda: WeaviateUploadStagerConfig()
+    )
+
+
+class EmbeddedWeaviateUploaderConfig(WeaviateUploaderConfig):
+    pass
+
+
+@dataclass
+class EmbeddedWeaviateUploader(WeaviateUploader):
+    connection_config: EmbeddedWeaviateConnectionConfig = field(
+        default_factory=lambda: EmbeddedWeaviateConnectionConfig()
+    )
+    upload_config: EmbeddedWeaviateUploaderConfig = field(
+        default_factory=lambda: EmbeddedWeaviateUploaderConfig()
+    )
+    connector_type: str = CONNECTOR_TYPE
+
+
+weaviate_embedded_destination_entry = DestinationRegistryEntry(
+    connection_config=EmbeddedWeaviateConnectionConfig,
+    uploader=EmbeddedWeaviateUploader,
+    uploader_config=EmbeddedWeaviateUploaderConfig,
+    upload_stager=EmbeddedWeaviateUploadStager,
+    upload_stager_config=EmbeddedWeaviateUploadStagerConfig,
+)

unstructured_ingest/processes/connectors/weaviate/local.py

@@ -0,0 +1,73 @@
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Generator
+
+from pydantic import Field, Secret
+
+from unstructured_ingest.processes.connector_registry import DestinationRegistryEntry
+from unstructured_ingest.processes.connectors.weaviate.weaviate import (
+    WeaviateAccessConfig,
+    WeaviateConnectionConfig,
+    WeaviateUploader,
+    WeaviateUploaderConfig,
+    WeaviateUploadStager,
+    WeaviateUploadStagerConfig,
+)
+from unstructured_ingest.utils.dep_check import requires_dependencies
+
+if TYPE_CHECKING:
+    from weaviate.client import WeaviateClient
+
+CONNECTOR_TYPE = "weaviate-local"
+
+
+class LocalWeaviateAccessConfig(WeaviateAccessConfig):
+    pass
+
+
+class LocalWeaviateConnectionConfig(WeaviateConnectionConfig):
+    access_config: Secret[WeaviateAccessConfig] = Field(
+        default=WeaviateAccessConfig(), validate_default=True
+    )
+
+    @contextmanager
+    @requires_dependencies(["weaviate"], extras="weaviate")
+    def get_client(self) -> Generator["WeaviateClient", None, None]:
+        from weaviate import connect_to_local
+        from weaviate.classes.init import AdditionalConfig
+
+        with connect_to_local(
+            additional_config=AdditionalConfig(timeout=self.get_timeout())
+        ) as weaviate_client:
+            yield weaviate_client
+
+
+class LocalWeaviateUploadStagerConfig(WeaviateUploadStagerConfig):
+    pass
+
+
+@dataclass
+class LocalWeaviateUploadStager(WeaviateUploadStager):
+    upload_stager_config: LocalWeaviateUploadStagerConfig = field(
+        default_factory=lambda: WeaviateUploadStagerConfig()
+    )
+
+
+class LocalWeaviateUploaderConfig(WeaviateUploaderConfig):
+    pass
+
+
+@dataclass
+class LocalWeaviateUploader(WeaviateUploader):
+    upload_config: LocalWeaviateUploaderConfig
+    connector_type: str = CONNECTOR_TYPE
+    connection_config: LocalWeaviateConnectionConfig
+
+
+weaviate_local_destination_entry = DestinationRegistryEntry(
+    connection_config=LocalWeaviateConnectionConfig,
+    uploader=LocalWeaviateUploader,
+    uploader_config=LocalWeaviateUploaderConfig,
+    upload_stager=LocalWeaviateUploadStager,
+    upload_stager_config=LocalWeaviateUploadStagerConfig,
+)