unstructured-ingest 0.3.13__py3-none-any.whl → 0.3.15__py3-none-any.whl

test/integration/connectors/test_s3.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import pytest
 
 from test.integration.connectors.utils.constants import (
+    BLOB_STORAGE_TAG,
     DESTINATION_TAG,
     SOURCE_TAG,
     env_setup_path,
@@ -47,7 +48,7 @@ def anon_connection_config() -> S3ConnectionConfig:
 
 
 @pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG)
+@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, BLOB_STORAGE_TAG)
 async def test_s3_source(anon_connection_config: S3ConnectionConfig):
     indexer_config = S3IndexerConfig(remote_url="s3://utic-dev-tech-fixtures/small-pdf-set/")
     with tempfile.TemporaryDirectory() as tempdir:
@@ -70,7 +71,7 @@ async def test_s3_source(anon_connection_config: S3ConnectionConfig):
 
 
 @pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG)
+@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, BLOB_STORAGE_TAG)
 async def test_s3_source_special_char(anon_connection_config: S3ConnectionConfig):
     indexer_config = S3IndexerConfig(remote_url="s3://utic-dev-tech-fixtures/special-characters/")
     with tempfile.TemporaryDirectory() as tempdir:
@@ -92,7 +93,7 @@ async def test_s3_source_special_char(anon_connection_config: S3ConnectionConfig
         )
 
 
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG)
+@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, BLOB_STORAGE_TAG)
 def test_s3_source_no_access(anon_connection_config: S3ConnectionConfig):
     indexer_config = S3IndexerConfig(remote_url="s3://utic-ingest-test-fixtures/destination/")
     indexer = S3Indexer(connection_config=anon_connection_config, index_config=indexer_config)
@@ -100,7 +101,7 @@ def test_s3_source_no_access(anon_connection_config: S3ConnectionConfig):
         indexer.precheck()
 
 
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG)
+@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, BLOB_STORAGE_TAG)
 def test_s3_source_no_bucket(anon_connection_config: S3ConnectionConfig):
     indexer_config = S3IndexerConfig(remote_url="s3://fake-bucket")
     indexer = S3Indexer(connection_config=anon_connection_config, index_config=indexer_config)
@@ -109,7 +110,7 @@ def test_s3_source_no_bucket(anon_connection_config: S3ConnectionConfig):
 
 
 @pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, "minio")
+@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, "minio", BLOB_STORAGE_TAG)
 async def test_s3_minio_source(anon_connection_config: S3ConnectionConfig):
     anon_connection_config.endpoint_url = "http://localhost:9000"
     indexer_config = S3IndexerConfig(remote_url="s3://utic-dev-tech-fixtures/")
@@ -149,7 +150,7 @@ def get_aws_credentials() -> dict:
 
 
 @pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG)
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, BLOB_STORAGE_TAG)
 @requires_env("S3_INGEST_TEST_ACCESS_KEY", "S3_INGEST_TEST_SECRET_KEY")
 async def test_s3_destination(upload_file: Path):
     aws_credentials = get_aws_credentials()

test/integration/connectors/test_vectara.py

@@ -8,7 +8,7 @@ from uuid import uuid4
 import pytest
 import requests
 
-from test.integration.connectors.utils.constants import DESTINATION_TAG
+from test.integration.connectors.utils.constants import DESTINATION_TAG, NOSQL_TAG
 from test.integration.utils import requires_env
 from unstructured_ingest.v2.interfaces.file_data import FileData, SourceIdentifiers
 from unstructured_ingest.v2.logger import logger
@@ -211,7 +211,7 @@ def corpora_util() -> Generator[str, None, None]:
 
 
 @pytest.mark.asyncio
-@pytest.mark.tags(VECTARA_CONNECTOR_TYPE, DESTINATION_TAG, "vectara")
+@pytest.mark.tags(VECTARA_CONNECTOR_TYPE, DESTINATION_TAG, "vectara", NOSQL_TAG)
 @requires_env("VECTARA_OAUTH_CLIENT_ID", "VECTARA_OAUTH_SECRET", "VECTARA_CUSTOMER_ID")
 async def test_vectara_destination(
     upload_file: Path, tmp_path: Path, corpora_util: str, retries=30, interval=10

test/integration/connectors/utils/constants.py

@@ -2,6 +2,12 @@ from pathlib import Path
 
 SOURCE_TAG = "source"
 DESTINATION_TAG = "destination"
+BLOB_STORAGE_TAG = "blob_storage"
+SQL_TAG = "sql"
+NOSQL_TAG = "nosql"
+VECTOR_DB_TAG = "vector_db"
+GRAPH_DB_TAG = "graph_db"
+UNCATEGORIZED_TAG = "uncategorized"
 
 env_setup_path = Path(__file__).parents[1] / "env_setup"
 expected_results_path = Path(__file__).parents[1] / "expected_results"

test/integration/connectors/utils/docker.py

@@ -44,7 +44,7 @@ def get_container(
     docker_client: docker.DockerClient,
     image: str,
     ports: dict,
-    name: Optional[str] = "connector_test",
+    name: Optional[str] = None,
     environment: Optional[dict] = None,
     volumes: Optional[dict] = None,
     healthcheck: Optional[HealthCheck] = None,
@@ -115,7 +115,7 @@ def container_context(
     healthcheck: Optional[HealthCheck] = None,
     healthcheck_retries: int = 30,
     docker_client: Optional[docker.DockerClient] = None,
-    name: Optional[str] = "connector_test",
+    name: Optional[str] = None,
 ):
     docker_client = docker_client or docker.from_env()
     print(f"pulling image {image}")

test/integration/connectors/weaviate/test_cloud.py

@@ -1,12 +1,15 @@
 import pytest
 from pydantic import ValidationError
 
+from test.integration.connectors.utils.constants import DESTINATION_TAG, VECTOR_DB_TAG
 from unstructured_ingest.v2.processes.connectors.weaviate.cloud import (
+    CONNECTOR_TYPE,
     CloudWeaviateAccessConfig,
     CloudWeaviateConnectionConfig,
 )
 
 
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
 def test_weaviate_failing_connection_config():
     with pytest.raises(ValidationError):
         CloudWeaviateConnectionConfig(
@@ -16,6 +19,7 @@ def test_weaviate_failing_connection_config():
         )
 
 
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
 def test_weaviate_connection_config_happy_path():
     CloudWeaviateConnectionConfig(
         access_config=CloudWeaviateAccessConfig(
@@ -25,6 +29,7 @@ def test_weaviate_connection_config_happy_path():
     )
 
 
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
 def test_weaviate_connection_config_anonymous():
     CloudWeaviateConnectionConfig(
         access_config=CloudWeaviateAccessConfig(api_key="my key", password="password"),

test/integration/connectors/weaviate/test_local.py

@@ -7,7 +7,7 @@ import requests
 import weaviate
 from weaviate.client import WeaviateClient
 
-from test.integration.connectors.utils.constants import DESTINATION_TAG
+from test.integration.connectors.utils.constants import DESTINATION_TAG, VECTOR_DB_TAG
 from test.integration.connectors.utils.docker import container_context
 from unstructured_ingest.v2.interfaces import FileData, SourceIdentifiers
 from unstructured_ingest.v2.processes.connectors.weaviate.local import (
@@ -74,7 +74,7 @@ def run_uploader_and_validate(
 
 
 @pytest.mark.asyncio
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG)
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
 def test_weaviate_local_destination(upload_file: Path, collection: str, tmp_path: Path):
     file_data = FileData(
         source_identifiers=SourceIdentifiers(fullpath=upload_file.name, filename=upload_file.name),

unstructured_ingest/__version__.py

@@ -1 +1 @@
-__version__ = "0.3.13"  # pragma: no cover
+__version__ = "0.3.15"  # pragma: no cover

unstructured_ingest/v2/interfaces/upload_stager.py

@@ -2,7 +2,7 @@ import json
 from abc import ABC
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, TypeVar
+from typing import Any, Optional, TypeVar
 
 import ndjson
 from pydantic import BaseModel
@@ -22,10 +22,10 @@ UploadStagerConfigT = TypeVar("UploadStagerConfigT", bound=UploadStagerConfig)
 class UploadStager(BaseProcess, ABC):
     upload_stager_config: UploadStagerConfigT
 
-    def write_output(self, output_path: Path, data: list[dict]) -> None:
+    def write_output(self, output_path: Path, data: list[dict], indent: Optional[int] = 2) -> None:
         if output_path.suffix == ".json":
             with output_path.open("w") as f:
-                json.dump(data, f, indent=2)
+                json.dump(data, f, indent=indent)
         elif output_path.suffix == ".ndjson":
             with output_path.open("w") as f:
                 ndjson.dump(data, f)

unstructured_ingest/v2/processes/connectors/databricks/__init__.py

@@ -25,6 +25,8 @@ from .volumes_native import (
     databricks_native_volumes_destination_entry,
     databricks_native_volumes_source_entry,
 )
+from .volumes_table import CONNECTOR_TYPE as VOLUMES_TABLE_CONNECTOR_TYPE
+from .volumes_table import databricks_volumes_delta_tables_destination_entry
 
 add_source_entry(source_type=VOLUMES_AWS_CONNECTOR_TYPE, entry=databricks_aws_volumes_source_entry)
 add_destination_entry(
@@ -50,3 +52,7 @@ add_source_entry(
 add_destination_entry(
     destination_type=VOLUMES_AZURE_CONNECTOR_TYPE, entry=databricks_azure_volumes_destination_entry
 )
+add_destination_entry(
+    destination_type=VOLUMES_TABLE_CONNECTOR_TYPE,
+    entry=databricks_volumes_delta_tables_destination_entry,
+)

unstructured_ingest/v2/processes/connectors/databricks/volumes.py

@@ -187,6 +187,11 @@ class DatabricksVolumesUploader(Uploader, ABC):
     upload_config: DatabricksVolumesUploaderConfig
     connection_config: DatabricksVolumesConnectionConfig
 
+    def get_output_path(self, file_data: FileData) -> str:
+        return os.path.join(
+            self.upload_config.path, f"{file_data.source_identifiers.filename}.json"
+        )
+
     def precheck(self) -> None:
         try:
             assert self.connection_config.get_client().current_user.me().active
@@ -194,9 +199,7 @@ class DatabricksVolumesUploader(Uploader, ABC):
             raise self.connection_config.wrap_error(e=e)
 
     def run(self, path: Path, file_data: FileData, **kwargs: Any) -> None:
-        output_path = os.path.join(
-            self.upload_config.path, f"{file_data.source_identifiers.filename}.json"
-        )
+        output_path = self.get_output_path(file_data=file_data)
         with open(path, "rb") as elements_file:
             try:
                 self.connection_config.get_client().files.upload(

unstructured_ingest/v2/processes/connectors/databricks/volumes_table.py

@@ -0,0 +1,106 @@
+import json
+import os
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Generator, Optional
+
+from pydantic import Field
+
+from unstructured_ingest.v2.interfaces import FileData, Uploader, UploaderConfig
+from unstructured_ingest.v2.logger import logger
+from unstructured_ingest.v2.processes.connector_registry import (
+    DestinationRegistryEntry,
+)
+from unstructured_ingest.v2.processes.connectors.databricks.volumes import DatabricksPathMixin
+from unstructured_ingest.v2.processes.connectors.sql.databricks_delta_tables import (
+    DatabrickDeltaTablesConnectionConfig,
+    DatabrickDeltaTablesUploadStager,
+    DatabrickDeltaTablesUploadStagerConfig,
+)
+
+CONNECTOR_TYPE = "databricks_volume_delta_tables"
+
+
+class DatabricksVolumeDeltaTableUploaderConfig(UploaderConfig, DatabricksPathMixin):
+    database: str = Field(description="Database name", default="default")
+    table_name: str = Field(description="Table name")
+
+
+@dataclass
+class DatabricksVolumeDeltaTableStager(DatabrickDeltaTablesUploadStager):
+    def write_output(self, output_path: Path, data: list[dict], indent: Optional[int] = 2) -> None:
+        # To avoid new line issues when migrating from volumes into delta tables, omit indenting
+        # and always write it as a json file
+        with output_path.with_suffix(".json").open("w") as f:
+            json.dump(data, f)
+
+
+@dataclass
+class DatabricksVolumeDeltaTableUploader(Uploader):
+    connection_config: DatabrickDeltaTablesConnectionConfig
+    upload_config: DatabricksVolumeDeltaTableUploaderConfig
+    connector_type: str = CONNECTOR_TYPE
+
+    def precheck(self) -> None:
+        with self.connection_config.get_cursor() as cursor:
+            cursor.execute("SHOW CATALOGS")
+            catalogs = [r[0] for r in cursor.fetchall()]
+            if self.upload_config.catalog not in catalogs:
+                raise ValueError(
+                    "Catalog {} not found in {}".format(
+                        self.upload_config.catalog, ", ".join(catalogs)
+                    )
+                )
+            cursor.execute(f"USE CATALOG '{self.upload_config.catalog}'")
+            cursor.execute("SHOW DATABASES")
+            databases = [r[0] for r in cursor.fetchall()]
+            if self.upload_config.database not in databases:
+                raise ValueError(
+                    "Database {} not found in {}".format(
+                        self.upload_config.database, ", ".join(databases)
+                    )
+                )
+            cursor.execute("SHOW TABLES")
+            table_names = [r[1] for r in cursor.fetchall()]
+            if self.upload_config.table_name not in table_names:
+                raise ValueError(
+                    "Table {} not found in {}".format(
+                        self.upload_config.table_name, ", ".join(table_names)
+                    )
+                )
+
+    def get_output_path(self, file_data: FileData, suffix: str = ".json") -> str:
+        filename = Path(file_data.source_identifiers.filename)
+        adjusted_filename = filename if filename.suffix == suffix else f"{filename}{suffix}"
+        return os.path.join(self.upload_config.path, f"{adjusted_filename}")
+
+    @contextmanager
+    def get_cursor(self, **connect_kwargs) -> Generator[Any, None, None]:
+        with self.connection_config.get_cursor(**connect_kwargs) as cursor:
+            cursor.execute(f"USE CATALOG '{self.upload_config.catalog}'")
+            yield cursor
+
+    def run(self, path: Path, file_data: FileData, **kwargs: Any) -> None:
+        with self.get_cursor(staging_allowed_local_path=str(path.parent)) as cursor:
+            catalog_path = self.get_output_path(file_data=file_data)
+            logger.debug(f"uploading {path.as_posix()} to {catalog_path}")
+            cursor.execute(f"PUT '{path.as_posix()}' INTO '{catalog_path}' OVERWRITE")
+            logger.debug(
+                f"migrating content from {catalog_path} to table {self.upload_config.table_name}"
+            )
+            with path.open() as f:
+                data = json.load(f)
+                columns = data[0].keys()
+            column_str = ", ".join(columns)
+            sql_statment = f"INSERT INTO `{self.upload_config.table_name}` ({column_str}) SELECT {column_str} FROM json.`{catalog_path}`"  # noqa: E501
+            cursor.execute(sql_statment)
+
+
+databricks_volumes_delta_tables_destination_entry = DestinationRegistryEntry(
+    connection_config=DatabrickDeltaTablesConnectionConfig,
+    uploader=DatabricksVolumeDeltaTableUploader,
+    uploader_config=DatabricksVolumeDeltaTableUploaderConfig,
+    upload_stager=DatabricksVolumeDeltaTableStager,
+    upload_stager_config=DatabrickDeltaTablesUploadStagerConfig,
+)

unstructured_ingest/v2/processes/connectors/neo4j.py

@@ -105,7 +105,7 @@ class Neo4jUploadStager(UploadStager):
         output_filepath.parent.mkdir(parents=True, exist_ok=True)
 
         with open(output_filepath, "w") as file:
-            json.dump(_GraphData.from_nx(nx_graph).model_dump(), file, indent=4)
+            file.write(_GraphData.from_nx(nx_graph).model_dump_json())
 
         return output_filepath
 
@@ -196,7 +196,7 @@ class _GraphData(BaseModel):
 
 
 class _Node(BaseModel):
-    model_config = ConfigDict(use_enum_values=True)
+    model_config = ConfigDict()
 
     id_: str = Field(default_factory=lambda: str(uuid.uuid4()))
     labels: list[Label] = Field(default_factory=list)
@@ -207,20 +207,20 @@ class _Node(BaseModel):
 
 
 class _Edge(BaseModel):
-    model_config = ConfigDict(use_enum_values=True)
+    model_config = ConfigDict()
 
     source_id: str
     destination_id: str
     relationship: Relationship
 
 
-class Label(str, Enum):
+class Label(Enum):
     UNSTRUCTURED_ELEMENT = "UnstructuredElement"
     CHUNK = "Chunk"
     DOCUMENT = "Document"
 
 
-class Relationship(str, Enum):
+class Relationship(Enum):
     PART_OF_DOCUMENT = "PART_OF_DOCUMENT"
     PART_OF_CHUNK = "PART_OF_CHUNK"
     NEXT_CHUNK = "NEXT_CHUNK"
@@ -263,14 +263,14 @@ class Neo4jUploader(Uploader):
     async def _create_uniqueness_constraints(self, client: AsyncDriver) -> None:
         for label in Label:
             logger.info(
-                f"Adding id uniqueness constraint for nodes labeled '{label}'"
+                f"Adding id uniqueness constraint for nodes labeled '{label.value}'"
                 " if it does not already exist."
             )
-            constraint_name = f"{label.lower()}_id"
+            constraint_name = f"{label.value.lower()}_id"
             await client.execute_query(
                 f"""
                 CREATE CONSTRAINT {constraint_name} IF NOT EXISTS
-                FOR (n: {label}) REQUIRE n.id IS UNIQUE
+                FOR (n: {label.value}) REQUIRE n.id IS UNIQUE
                 """
             )
 
@@ -278,8 +278,8 @@ class Neo4jUploader(Uploader):
         logger.info(f"Deleting old data for the record '{file_data.identifier}' (if present).")
         _, summary, _ = await client.execute_query(
             f"""
-            MATCH (n: {Label.DOCUMENT} {{id: $identifier}})
-            MATCH (n)--(m: {Label.CHUNK}|{Label.UNSTRUCTURED_ELEMENT})
+            MATCH (n: {Label.DOCUMENT.value} {{id: $identifier}})
+            MATCH (n)--(m: {Label.CHUNK.value}|{Label.UNSTRUCTURED_ELEMENT.value})
             DETACH DELETE m""",
             identifier=file_data.identifier,
         )
@@ -349,7 +349,7 @@ class Neo4jUploader(Uploader):
 
     @staticmethod
     def _create_nodes_query(nodes: list[_Node], labels: tuple[Label, ...]) -> tuple[str, dict]:
-        labels_string = ", ".join(labels)
+        labels_string = ", ".join([label.value for label in labels])
         logger.info(f"Preparing MERGE query for {len(nodes)} nodes labeled '{labels_string}'.")
         query_string = f"""
             UNWIND $nodes AS node
@@ -366,7 +366,7 @@ class Neo4jUploader(Uploader):
             UNWIND $edges AS edge
             MATCH (u {{id: edge.source}})
             MATCH (v {{id: edge.destination}})
-            MERGE (u)-[:{relationship}]->(v)
+            MERGE (u)-[:{relationship.value}]->(v)
             """
         parameters = {
             "edges": [

unstructured_ingest/v2/processes/connectors/pinecone.py

@@ -5,12 +5,10 @@ from typing import TYPE_CHECKING, Any, Optional
 from pydantic import Field, Secret
 
 from unstructured_ingest.error import DestinationConnectionError
-from unstructured_ingest.utils.data_prep import (
-    flatten_dict,
-    generator_batching_wbytes,
-)
+from unstructured_ingest.utils.data_prep import flatten_dict, generator_batching_wbytes
 from unstructured_ingest.utils.dep_check import requires_dependencies
 from unstructured_ingest.v2.constants import RECORD_ID_LABEL
+from unstructured_ingest.v2.errors import UserError
 from unstructured_ingest.v2.interfaces import (
     AccessConfig,
     ConnectionConfig,
@@ -63,6 +61,7 @@ class PineconeConnectionConfig(ConnectionConfig):
         pc = self.get_client()
 
         index = pc.Index(name=self.index_name, **index_kwargs)
+
         logger.debug(f"connected to index: {pc.describe_index(self.index_name)}")
         return index
 
@@ -182,14 +181,18 @@ class PineconeUploader(Uploader):
         delete_kwargs = {
             "filter": {self.upload_config.record_id_key: {"$eq": file_data.identifier}}
         }
+
         if namespace := self.upload_config.namespace:
             delete_kwargs["namespace"] = namespace
+            try:
+                index.delete(**delete_kwargs)
+            except UserError as e:
+                logger.error(f"failed to delete batch of ids: {delete_kwargs} {e}")
 
-        resp = index.delete(**delete_kwargs)
         logger.debug(
             f"deleted any content with metadata "
             f"{self.upload_config.record_id_key}={file_data.identifier} "
-            f"from pinecone index: {resp}"
+            f"from pinecone index: {delete_kwargs}"
         )
 
     def serverless_delete_by_record_id(self, file_data: FileData) -> None:
@@ -203,15 +206,19 @@ class PineconeUploader(Uploader):
         deleted_ids = 0
         if namespace := self.upload_config.namespace:
             list_kwargs["namespace"] = namespace
+
         for ids in index.list(**list_kwargs):
             deleted_ids += len(ids)
             delete_kwargs = {"ids": ids}
+
             if namespace := self.upload_config.namespace:
-                delete_resp = delete_kwargs["namespace"] = namespace
-                # delete_resp should be an empty dict if there were no errors
-                if delete_resp:
-                    logger.error(f"failed to delete batch of ids: {delete_resp}")
-            index.delete(**delete_kwargs)
+                delete_kwargs["namespace"] = namespace
+
+            try:
+                index.delete(**delete_kwargs)
+            except UserError as e:
+                logger.error(f"failed to delete batch of ids: {delete_kwargs} {e}")
+
         logger.info(
             f"deleted {deleted_ids} records with metadata "
             f"{self.upload_config.record_id_key}={file_data.identifier} "

unstructured_ingest/v2/processes/connectors/sql/__init__.py

@@ -5,6 +5,8 @@ from unstructured_ingest.v2.processes.connector_registry import (
     add_source_entry,
 )
 
+from .databricks_delta_tables import CONNECTOR_TYPE as DATABRICKS_DELTA_TABLES_CONNECTOR_TYPE
+from .databricks_delta_tables import databricks_delta_tables_destination_entry
 from .postgres import CONNECTOR_TYPE as POSTGRES_CONNECTOR_TYPE
 from .postgres import postgres_destination_entry, postgres_source_entry
 from .singlestore import CONNECTOR_TYPE as SINGLESTORE_CONNECTOR_TYPE
@@ -25,3 +27,7 @@ add_destination_entry(destination_type=SNOWFLAKE_CONNECTOR_TYPE, entry=snowflake
 add_destination_entry(
     destination_type=SINGLESTORE_CONNECTOR_TYPE, entry=singlestore_destination_entry
 )
+add_destination_entry(
+    destination_type=DATABRICKS_DELTA_TABLES_CONNECTOR_TYPE,
+    entry=databricks_delta_tables_destination_entry,
+)