unstructured-ingest 0.3.14__py3-none-any.whl → 0.4.0__py3-none-any.whl

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,
+)

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

@@ -0,0 +1,213 @@
+import json
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Generator, Optional
+
+import numpy as np
+import pandas as pd
+from pydantic import Field, Secret
+
+from unstructured_ingest.utils.data_prep import split_dataframe
+from unstructured_ingest.utils.dep_check import requires_dependencies
+from unstructured_ingest.v2.interfaces import FileData
+from unstructured_ingest.v2.logger import logger
+from unstructured_ingest.v2.processes.connector_registry import (
+    DestinationRegistryEntry,
+)
+from unstructured_ingest.v2.processes.connectors.sql.sql import (
+    SQLAccessConfig,
+    SQLConnectionConfig,
+    SQLUploader,
+    SQLUploaderConfig,
+    SQLUploadStager,
+    SQLUploadStagerConfig,
+)
+
+if TYPE_CHECKING:
+    from databricks.sdk.core import oauth_service_principal
+    from databricks.sql.client import Connection as DeltaTableConnection
+    from databricks.sql.client import Cursor as DeltaTableCursor
+
+CONNECTOR_TYPE = "databricks_delta_tables"
+
+
+class DatabrickDeltaTablesAccessConfig(SQLAccessConfig):
+    token: Optional[str] = Field(default=None, description="Databricks Personal Access Token")
+    client_id: Optional[str] = Field(default=None, description="Client ID of the OAuth app.")
+    client_secret: Optional[str] = Field(
+        default=None, description="Client Secret of the OAuth app."
+    )
+
+
+class DatabrickDeltaTablesConnectionConfig(SQLConnectionConfig):
+    access_config: Secret[DatabrickDeltaTablesAccessConfig]
+    server_hostname: str = Field(description="server hostname connection config value")
+    http_path: str = Field(description="http path connection config value")
+    user_agent: str = "unstructuredio_oss"
+
+    @requires_dependencies(["databricks"], extras="databricks-delta-tables")
+    def get_credentials_provider(self) -> "oauth_service_principal":
+        from databricks.sdk.core import Config, oauth_service_principal
+
+        host = f"https://{self.server_hostname}"
+        access_configs = self.access_config.get_secret_value()
+        if (client_id := access_configs.client_id) and (
+            client_secret := access_configs.client_secret
+        ):
+            return oauth_service_principal(
+                Config(
+                    host=host,
+                    client_id=client_id,
+                    client_secret=client_secret,
+                )
+            )
+        return False
+
+    def model_post_init(self, __context: Any) -> None:
+        access_config = self.access_config.get_secret_value()
+        if access_config.token and access_config.client_secret and access_config.client_id:
+            raise ValueError(
+                "One one for of auth can be provided, either token or client id and secret"
+            )
+        if not access_config.token and not (
+            access_config.client_secret and access_config.client_id
+        ):
+            raise ValueError(
+                "One form of auth must be provided, either token or client id and secret"
+            )
+
+    @contextmanager
+    @requires_dependencies(["databricks"], extras="databricks-delta-tables")
+    def get_connection(self, **connect_kwargs) -> Generator["DeltaTableConnection", None, None]:
+        from databricks.sql import connect
+
+        connect_kwargs = connect_kwargs or {}
+        connect_kwargs["_user_agent_entry"] = self.user_agent
+        connect_kwargs["server_hostname"] = connect_kwargs.get(
+            "server_hostname", self.server_hostname
+        )
+        connect_kwargs["http_path"] = connect_kwargs.get("http_path", self.http_path)
+
+        if credential_provider := self.get_credentials_provider():
+            connect_kwargs["credentials_provider"] = credential_provider
+        else:
+            connect_kwargs["access_token"] = self.access_config.get_secret_value().token
+        with connect(**connect_kwargs) as connection:
+            yield connection
+
+    @contextmanager
+    def get_cursor(self, **connect_kwargs) -> Generator["DeltaTableCursor", None, None]:
+        with self.get_connection(**connect_kwargs) as connection:
+            cursor = connection.cursor()
+            yield cursor
+
+
+class DatabrickDeltaTablesUploadStagerConfig(SQLUploadStagerConfig):
+    pass
+
+
+class DatabrickDeltaTablesUploadStager(SQLUploadStager):
+    upload_stager_config: DatabrickDeltaTablesUploadStagerConfig
+
+
+class DatabrickDeltaTablesUploaderConfig(SQLUploaderConfig):
+    catalog: str = Field(description="Name of the catalog in the Databricks Unity Catalog service")
+    database: str = Field(description="Database name", default="default")
+    table_name: str = Field(description="Table name")
+
+
+@dataclass
+class DatabrickDeltaTablesUploader(SQLUploader):
+    upload_config: DatabrickDeltaTablesUploaderConfig
+    connection_config: DatabrickDeltaTablesConnectionConfig
+    connector_type: str = CONNECTOR_TYPE
+
+    @contextmanager
+    def get_cursor(self) -> Generator[Any, None, None]:
+        with self.connection_config.get_cursor() as cursor:
+            cursor.execute(f"USE CATALOG '{self.upload_config.catalog}'")
+            yield cursor
+
+    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 create_statement(self, columns: list[str], values: tuple[Any, ...]) -> str:
+        values_list = []
+        for v in values:
+            if isinstance(v, dict):
+                values_list.append(json.dumps(v))
+            elif isinstance(v, list):
+                if v and isinstance(v[0], (int, float)):
+                    values_list.append("ARRAY({})".format(", ".join([str(val) for val in v])))
+                else:
+                    values_list.append("ARRAY({})".format(", ".join([f"'{val}'" for val in v])))
+            else:
+                values_list.append(f"'{v}'")
+        statement = "INSERT INTO {table_name} ({columns}) VALUES({values})".format(
+            table_name=self.upload_config.table_name,
+            columns=", ".join(columns),
+            values=", ".join(values_list),
+        )
+        return statement
+
+    def upload_dataframe(self, df: pd.DataFrame, file_data: FileData) -> None:
+        if self.can_delete():
+            self.delete_by_record_id(file_data=file_data)
+        else:
+            logger.warning(
+                f"table doesn't contain expected "
+                f"record id column "
+                f"{self.upload_config.record_id_key}, skipping delete"
+            )
+        df.replace({np.nan: None}, inplace=True)
+        self._fit_to_schema(df=df)
+
+        columns = list(df.columns)
+        logger.info(
+            f"writing a total of {len(df)} elements via"
+            f" document batches to destination"
+            f" table named {self.upload_config.table_name}"
+            # f" with batch size {self.upload_config.batch_size}"
+        )
+        # TODO: currently variable binding not supporting for list types,
+        #  update once that gets resolved in SDK
+        for rows in split_dataframe(df=df, chunk_size=self.upload_config.batch_size):
+            with self.get_cursor() as cursor:
+                values = self.prepare_data(columns, tuple(rows.itertuples(index=False, name=None)))
+                for v in values:
+                    stmt = self.create_statement(columns=columns, values=v)
+                    cursor.execute(stmt)
+
+
+databricks_delta_tables_destination_entry = DestinationRegistryEntry(
+    connection_config=DatabrickDeltaTablesConnectionConfig,
+    uploader=DatabrickDeltaTablesUploader,
+    uploader_config=DatabrickDeltaTablesUploaderConfig,
+    upload_stager=DatabrickDeltaTablesUploadStager,
+    upload_stager_config=DatabrickDeltaTablesUploadStagerConfig,
+)

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

@@ -170,7 +170,7 @@ class SnowflakeUploader(SQLUploader):
                 f"{self.upload_config.record_id_key}, skipping delete"
             )
         df.replace({np.nan: None}, inplace=True)
-        self._fit_to_schema(df=df, columns=self.get_table_columns())
+        self._fit_to_schema(df=df)
 
         columns = list(df.columns)
         stmt = "INSERT INTO {table_name} ({columns}) VALUES({values})".format(

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

@@ -129,8 +129,13 @@ class SQLIndexer(Indexer, ABC):
     connection_config: SQLConnectionConfig
     index_config: SQLIndexerConfig
 
-    def _get_doc_ids(self) -> list[str]:
+    @contextmanager
+    def get_cursor(self) -> Generator[Any, None, None]:
         with self.connection_config.get_cursor() as cursor:
+            yield cursor
+
+    def _get_doc_ids(self) -> list[str]:
+        with self.get_cursor() as cursor:
             cursor.execute(
                 f"SELECT {self.index_config.id_column} FROM {self.index_config.table_name}"
             )
@@ -140,7 +145,7 @@ class SQLIndexer(Indexer, ABC):
 
     def precheck(self) -> None:
         try:
-            with self.connection_config.get_cursor() as cursor:
+            with self.get_cursor() as cursor:
                 cursor.execute("SELECT 1;")
         except Exception as e:
             logger.error(f"failed to validate connection: {e}", exc_info=True)
@@ -182,6 +187,11 @@ class SQLDownloader(Downloader, ABC):
     connection_config: SQLConnectionConfig
     download_config: SQLDownloaderConfig
 
+    @contextmanager
+    def get_cursor(self) -> Generator[Any, None, None]:
+        with self.connection_config.get_cursor() as cursor:
+            yield cursor
+
     @abstractmethod
     def query_db(self, file_data: SqlBatchFileData) -> tuple[list[tuple], list[str]]:
         pass
@@ -300,6 +310,8 @@ class SQLUploadStager(UploadStager):
         )
         df = self.conform_dataframe(df=df)
 
+        output_filename_suffix = Path(elements_filepath).suffix
+        output_filename = f"{Path(output_filename).stem}{output_filename_suffix}"
         output_path = self.get_output_path(output_filename=output_filename, output_dir=output_dir)
 
         self.write_output(output_path=output_path, data=df.to_dict(orient="records"))
@@ -323,12 +335,17 @@ class SQLUploader(Uploader):
 
     def precheck(self) -> None:
         try:
-            with self.connection_config.get_cursor() as cursor:
+            with self.get_cursor() as cursor:
                 cursor.execute("SELECT 1;")
         except Exception as e:
             logger.error(f"failed to validate connection: {e}", exc_info=True)
             raise DestinationConnectionError(f"failed to validate connection: {e}")
 
+    @contextmanager
+    def get_cursor(self) -> Generator[Any, None, None]:
+        with self.connection_config.get_cursor() as cursor:
+            yield cursor
+
     def prepare_data(
         self, columns: list[str], data: tuple[tuple[Any, ...], ...]
     ) -> list[tuple[Any, ...]]:
@@ -346,7 +363,7 @@ class SQLUploader(Uploader):
             output.append(tuple(parsed))
         return output
 
-    def _fit_to_schema(self, df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
+    def _fit_to_schema(self, df: pd.DataFrame) -> pd.DataFrame:
         columns = set(df.columns)
         schema_fields = set(columns)
         columns_to_drop = columns - schema_fields
@@ -367,6 +384,7 @@ class SQLUploader(Uploader):
 
         for column in missing_columns:
             df[column] = pd.Series()
+        return df
 
     def upload_dataframe(self, df: pd.DataFrame, file_data: FileData) -> None:
         if self.can_delete():
@@ -378,7 +396,7 @@ class SQLUploader(Uploader):
                 f"{self.upload_config.record_id_key}, skipping delete"
             )
         df.replace({np.nan: None}, inplace=True)
-        self._fit_to_schema(df=df, columns=self.get_table_columns())
+        self._fit_to_schema(df=df)
 
         columns = list(df.columns)
         stmt = "INSERT INTO {table_name} ({columns}) VALUES({values})".format(
@@ -393,7 +411,7 @@ class SQLUploader(Uploader):
             f" with batch size {self.upload_config.batch_size}"
         )
         for rows in split_dataframe(df=df, chunk_size=self.upload_config.batch_size):
-            with self.connection_config.get_cursor() as cursor:
+            with self.get_cursor() as cursor:
                 values = self.prepare_data(columns, tuple(rows.itertuples(index=False, name=None)))
                 # For debugging purposes:
                 # for val in values:
@@ -406,7 +424,7 @@ class SQLUploader(Uploader):
                 cursor.executemany(stmt, values)
 
     def get_table_columns(self) -> list[str]:
-        with self.connection_config.get_cursor() as cursor:
+        with self.get_cursor() as cursor:
             cursor.execute(f"SELECT * from {self.upload_config.table_name}")
             return [desc[0] for desc in cursor.description]
 
@@ -420,10 +438,11 @@ class SQLUploader(Uploader):
             f"from table {self.upload_config.table_name}"
         )
         stmt = f"DELETE FROM {self.upload_config.table_name} WHERE {self.upload_config.record_id_key} = {self.values_delimiter}"  # noqa: E501
-        with self.connection_config.get_cursor() as cursor:
+        with self.get_cursor() as cursor:
             cursor.execute(stmt, [file_data.identifier])
             rowcount = cursor.rowcount
-            logger.info(f"deleted {rowcount} rows from table {self.upload_config.table_name}")
+            if rowcount > 0:
+                logger.info(f"deleted {rowcount} rows from table {self.upload_config.table_name}")
 
     def run_data(self, data: list[dict], file_data: FileData, **kwargs: Any) -> None:
         df = pd.DataFrame(data)

{unstructured_ingest-0.3.14.dist-info → unstructured_ingest-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unstructured-ingest
-Version: 0.3.14
+Version: 0.4.0
 Summary: A library that prepares raw documents for downstream ML tasks.
 Home-page: https://github.com/Unstructured-IO/unstructured-ingest
 Author: Unstructured Technologies
@@ -22,43 +22,45 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9.0,<3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: python-dateutil
+Requires-Dist: click
+Requires-Dist: pydantic>=2.7
 Requires-Dist: pandas
+Requires-Dist: ndjson
+Requires-Dist: opentelemetry-sdk
+Requires-Dist: python-dateutil
 Requires-Dist: tqdm
 Requires-Dist: dataclasses-json
-Requires-Dist: opentelemetry-sdk
-Requires-Dist: click
-Requires-Dist: ndjson
-Requires-Dist: pydantic>=2.7
 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"
+Requires-Dist: adlfs; extra == "azure"
 Provides-Extra: azure-ai-search
 Requires-Dist: azure-search-documents; extra == "azure-ai-search"
 Provides-Extra: bedrock
 Requires-Dist: boto3; extra == "bedrock"
 Requires-Dist: aioboto3; extra == "bedrock"
 Provides-Extra: biomed
-Requires-Dist: requests; extra == "biomed"
 Requires-Dist: bs4; extra == "biomed"
+Requires-Dist: requests; extra == "biomed"
 Provides-Extra: box
-Requires-Dist: boxfs; 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"
+Requires-Dist: requests; extra == "confluence"
 Provides-Extra: couchbase
 Requires-Dist: couchbase; extra == "couchbase"
 Provides-Extra: csv
 Requires-Dist: unstructured[tsv]; extra == "csv"
+Provides-Extra: databricks-delta-tables
+Requires-Dist: databricks-sql-connector; extra == "databricks-delta-tables"
 Provides-Extra: databricks-volumes
 Requires-Dist: databricks-sdk; extra == "databricks-volumes"
 Provides-Extra: delta-table
@@ -82,8 +84,8 @@ Requires-Dist: sentence-transformers; extra == "embed-huggingface"
 Provides-Extra: embed-mixedbreadai
 Requires-Dist: mixedbread-ai; extra == "embed-mixedbreadai"
 Provides-Extra: embed-octoai
-Requires-Dist: openai; 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
@@ -91,8 +93,8 @@ Requires-Dist: voyageai; extra == "embed-voyageai"
 Provides-Extra: epub
 Requires-Dist: unstructured[epub]; extra == "epub"
 Provides-Extra: gcs
-Requires-Dist: bs4; extra == "gcs"
 Requires-Dist: fsspec; extra == "gcs"
+Requires-Dist: bs4; extra == "gcs"
 Requires-Dist: gcsfs; extra == "gcs"
 Provides-Extra: github
 Requires-Dist: pygithub>1.58.0; extra == "github"
@@ -102,8 +104,8 @@ 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"
+Requires-Dist: urllib3; extra == "hubspot"
 Provides-Extra: jira
 Requires-Dist: atlassian-python-api; extra == "jira"
 Provides-Extra: kafka
@@ -122,12 +124,12 @@ Provides-Extra: msg
 Requires-Dist: unstructured[msg]; extra == "msg"
 Provides-Extra: neo4j
 Requires-Dist: cymple; extra == "neo4j"
-Requires-Dist: networkx; extra == "neo4j"
 Requires-Dist: neo4j; extra == "neo4j"
+Requires-Dist: networkx; extra == "neo4j"
 Provides-Extra: notion
-Requires-Dist: backoff; extra == "notion"
 Requires-Dist: notion-client; extra == "notion"
 Requires-Dist: htmlBuilder; extra == "notion"
+Requires-Dist: backoff; extra == "notion"
 Requires-Dist: httpx; extra == "notion"
 Provides-Extra: odt
 Requires-Dist: unstructured[odt]; extra == "odt"
@@ -136,8 +138,8 @@ Requires-Dist: bs4; extra == "onedrive"
 Requires-Dist: Office365-REST-Python-Client; extra == "onedrive"
 Requires-Dist: msal; extra == "onedrive"
 Provides-Extra: openai
-Requires-Dist: openai; extra == "openai"
 Requires-Dist: tiktoken; extra == "openai"
+Requires-Dist: openai; extra == "openai"
 Provides-Extra: opensearch
 Requires-Dist: opensearch-py; extra == "opensearch"
 Provides-Extra: org
@@ -168,13 +170,13 @@ Requires-Dist: unstructured[rst]; extra == "rst"
 Provides-Extra: rtf
 Requires-Dist: unstructured[rtf]; extra == "rtf"
 Provides-Extra: s3
-Requires-Dist: s3fs; extra == "s3"
 Requires-Dist: fsspec; extra == "s3"
+Requires-Dist: s3fs; extra == "s3"
 Provides-Extra: salesforce
 Requires-Dist: simple-salesforce; extra == "salesforce"
 Provides-Extra: sftp
-Requires-Dist: paramiko; extra == "sftp"
 Requires-Dist: fsspec; extra == "sftp"
+Requires-Dist: paramiko; extra == "sftp"
 Provides-Extra: sharepoint
 Requires-Dist: Office365-REST-Python-Client; extra == "sharepoint"
 Requires-Dist: msal; extra == "sharepoint"
@@ -183,16 +185,16 @@ Requires-Dist: singlestoredb; extra == "singlestore"
 Provides-Extra: slack
 Requires-Dist: slack-sdk[optional]; extra == "slack"
 Provides-Extra: snowflake
-Requires-Dist: psycopg2-binary; extra == "snowflake"
 Requires-Dist: snowflake-connector-python; extra == "snowflake"
+Requires-Dist: psycopg2-binary; extra == "snowflake"
 Provides-Extra: togetherai
 Requires-Dist: together; extra == "togetherai"
 Provides-Extra: tsv
 Requires-Dist: unstructured[tsv]; extra == "tsv"
 Provides-Extra: vectara
+Requires-Dist: httpx; extra == "vectara"
 Requires-Dist: requests; extra == "vectara"
 Requires-Dist: aiofiles; extra == "vectara"
-Requires-Dist: httpx; extra == "vectara"
 Provides-Extra: weaviate
 Requires-Dist: weaviate-client; extra == "weaviate"
 Provides-Extra: wikipedia