unstructured-ingest 0.5.10__py3-none-any.whl → 0.5.11__py3-none-any.whl

test/integration/connectors/test_astradb.py

@@ -31,6 +31,7 @@ from unstructured_ingest.v2.processes.connectors.astradb import (
     AstraDBUploader,
     AstraDBUploaderConfig,
     AstraDBUploadStager,
+    AstraDBUploadStagerConfig,
     DestinationConnectionError,
     SourceConnectionError,
 )
@@ -258,3 +259,23 @@ def test_astra_stager(
         stager=stager,
         tmp_dir=tmp_path,
     )
+
+
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, VECTOR_DB_TAG)
+@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
+def test_astra_stager_flatten_metadata(
+    request: TopRequest,
+    upload_file_str: str,
+    tmp_path: Path,
+):
+    stager_config = AstraDBUploadStagerConfig(flatten_metadata=True)
+    upload_file: Path = request.getfixturevalue(upload_file_str)
+    stager = AstraDBUploadStager(upload_stager_config=stager_config)
+    stager_validation(
+        configs=StagerValidationConfigs(
+            test_id=CONNECTOR_TYPE, expected_count=22, expected_folder="stager_flatten_metadata"
+        ),
+        input_file=upload_file,
+        stager=stager,
+        tmp_dir=tmp_path,
+    )

test/integration/connectors/test_zendesk.py

@@ -0,0 +1,142 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+import pytest
+
+from test.integration.connectors.utils.constants import SOURCE_TAG, UNCATEGORIZED_TAG
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
+    source_connector_validation,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.v2.errors import UserAuthError
+from unstructured_ingest.v2.processes.connectors.zendesk import (
+    CONNECTOR_TYPE,
+    ZendeskAccessConfig,
+    ZendeskConnectionConfig,
+    ZendeskDownloader,
+    ZendeskDownloaderConfig,
+    ZendeskIndexer,
+    ZendeskIndexerConfig,
+)
+
+
+async def zendesk_source_test(
+    tmp_path: Path,
+    token: Optional[str] = None,
+    email: Optional[str] = None,
+    subdomain: Optional[str] = None,
+):
+
+    access_config = ZendeskAccessConfig(api_token=token)
+    connection_config = ZendeskConnectionConfig(
+        subdomain=subdomain, email=email, access_config=access_config
+    )
+
+    index_config = ZendeskIndexerConfig(batch_size=2, item_type="tickets")
+
+    indexer = ZendeskIndexer(
+        connection_config=connection_config,
+        index_config=index_config,
+        connector_type=CONNECTOR_TYPE,
+    )
+
+    # handle downloader.
+    download_config = ZendeskDownloaderConfig(download_dir=tmp_path)
+
+    downloader = ZendeskDownloader(
+        connection_config=connection_config,
+        download_config=download_config,
+        connector_type=CONNECTOR_TYPE,
+    )
+
+    # Run the source connector validation
+    await source_connector_validation(
+        indexer=indexer,
+        downloader=downloader,
+        configs=SourceValidationConfigs(
+            test_id="zendesk-tickets",
+            expected_num_files=4,
+            validate_file_data=False,
+            validate_downloaded_files=True,
+        ),
+    )
+
+
+async def zendesk_source_articles_test(
+    tmp_path: Path,
+    token: Optional[str] = None,
+    email: Optional[str] = None,
+    subdomain: Optional[str] = None,
+):
+
+    access_config = ZendeskAccessConfig(api_token=token)
+    connection_config = ZendeskConnectionConfig(
+        subdomain=subdomain, email=email, access_config=access_config
+    )
+
+    index_config = ZendeskIndexerConfig(batch_size=2, item_type="articles")
+
+    indexer = ZendeskIndexer(
+        connection_config=connection_config,
+        index_config=index_config,
+        connector_type=CONNECTOR_TYPE,
+    )
+
+    # handle downloader.
+    download_config = ZendeskDownloaderConfig(download_dir=tmp_path, extract_images=True)
+
+    downloader = ZendeskDownloader(
+        connection_config=connection_config,
+        download_config=download_config,
+        connector_type=CONNECTOR_TYPE,
+    )
+
+    # Run the source connector validation
+    await source_connector_validation(
+        indexer=indexer,
+        downloader=downloader,
+        configs=SourceValidationConfigs(
+            test_id="zendesk-articles",
+            expected_num_files=4,
+            validate_file_data=False,
+            validate_downloaded_files=True,
+        ),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.tags(SOURCE_TAG, CONNECTOR_TYPE, UNCATEGORIZED_TAG)
+@requires_env("ZENDESK_TOKEN")
+async def test_zendesk_source(temp_dir):
+    await zendesk_source_test(
+        tmp_path=temp_dir,
+        token=os.environ["ZENDESK_TOKEN"],
+        email="test@unstructured.io",
+        subdomain="unstructuredhelp",
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.tags(SOURCE_TAG, CONNECTOR_TYPE, UNCATEGORIZED_TAG)
+@requires_env("ZENDESK_TOKEN")
+async def test_zendesk_source_articles(temp_dir):
+    await zendesk_source_articles_test(
+        tmp_path=temp_dir,
+        token=os.environ["ZENDESK_TOKEN"],
+        email="test@unstructured.io",
+        subdomain="unstructuredhelp",
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.tags(SOURCE_TAG, CONNECTOR_TYPE, UNCATEGORIZED_TAG)
+async def test_zendesk_source_articles_fail(temp_dir):
+    with pytest.raises(expected_exception=UserAuthError):
+        await zendesk_source_articles_test(
+            tmp_path=temp_dir,
+            token="FORCE_FAIL_TOKEN",
+            email="test@unstructured.io",
+            subdomain="unstructuredhelp",
+        )

test/integration/connectors/utils/validation/destination.py

@@ -9,9 +9,10 @@ from unstructured_ingest.v2.interfaces import FileData, SourceIdentifiers, Uploa
 
 class StagerValidationConfigs(ValidationConfig):
     expected_count: int
+    expected_folder: str = "stager"
 
     def stager_output_dir(self) -> Path:
-        dir = self.test_output_dir() / "stager"
+        dir = self.test_output_dir() / self.expected_folder
         dir.mkdir(exist_ok=True, parents=True)
         return dir
 

unstructured_ingest/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.10"  # pragma: no cover
+__version__ = "0.5.11"  # pragma: no cover

unstructured_ingest/v2/interfaces/downloader.py

@@ -1,5 +1,5 @@
 import os
-from abc import ABC, abstractmethod
+from abc import ABC
 from pathlib import Path
 from typing import Any, Optional, TypedDict, TypeVar, Union
 
@@ -81,9 +81,8 @@ class Downloader(BaseProcess, BaseConnector, ABC):
     def is_async(self) -> bool:
         return True
 
-    @abstractmethod
     def run(self, file_data: FileData, **kwargs: Any) -> download_responses:
-        pass
+        raise NotImplementedError()
 
     async def run_async(self, file_data: FileData, **kwargs: Any) -> download_responses:
         return self.run(file_data=file_data, **kwargs)

unstructured_ingest/v2/processes/connectors/astradb.py

@@ -144,10 +144,6 @@ async def get_async_astra_collection(
     return async_astra_db_collection
 
 
-class AstraDBUploadStagerConfig(UploadStagerConfig):
-    pass
-
-
 class AstraDBIndexerConfig(IndexerConfig):
     collection_name: str = Field(
         description="The name of the Astra DB collection. "
@@ -158,30 +154,6 @@ class AstraDBIndexerConfig(IndexerConfig):
     batch_size: int = Field(default=20, description="Number of records per batch")
 
 
-class AstraDBDownloaderConfig(DownloaderConfig):
-    fields: list[str] = field(default_factory=list)
-
-
-class AstraDBUploaderConfig(UploaderConfig):
-    collection_name: Optional[str] = Field(
-        description="The name of the Astra DB collection. "
-        "Note that the collection name must only include letters, "
-        "numbers, and underscores.",
-        default=None,
-    )
-    keyspace: Optional[str] = Field(default=None, description="The Astra DB connection keyspace.")
-    requested_indexing_policy: Optional[dict[str, Any]] = Field(
-        default=None,
-        description="The indexing policy to use for the collection.",
-        examples=['{"deny": ["metadata"]}'],
-    )
-    batch_size: int = Field(default=20, description="Number of records per batch")
-    record_id_key: str = Field(
-        default=RECORD_ID_LABEL,
-        description="searchable key to find entries for the same record on previous runs",
-    )
-
-
 @dataclass
 class AstraDBIndexer(Indexer):
     connection_config: AstraDBConnectionConfig
@@ -239,6 +211,10 @@ class AstraDBIndexer(Indexer):
             yield fd
 
 
+class AstraDBDownloaderConfig(DownloaderConfig):
+    fields: list[str] = field(default_factory=list)
+
+
 @dataclass
 class AstraDBDownloader(Downloader):
     connection_config: AstraDBConnectionConfig
@@ -315,6 +291,12 @@ class AstraDBDownloader(Downloader):
         return download_responses
 
 
+class AstraDBUploadStagerConfig(UploadStagerConfig):
+    flatten_metadata: Optional[bool] = Field(
+        default=False, description="Move metadata to top level of the record."
+    )
+
+
 @dataclass
 class AstraDBUploadStager(UploadStager):
     upload_stager_config: AstraDBUploadStagerConfig = field(
@@ -336,6 +318,12 @@ class AstraDBUploadStager(UploadStager):
 
     def conform_dict(self, element_dict: dict, file_data: FileData) -> dict:
         self.truncate_dict_elements(element_dict)
+        if self.upload_stager_config.flatten_metadata:
+            # move metadata to top level so it isn't nested in metadata column
+            metadata = element_dict.pop("metadata", None)
+            if metadata:
+                element_dict.update(metadata)
+
         return {
             "$vector": element_dict.pop("embeddings", None),
             "content": element_dict.pop("text", None),
@@ -344,6 +332,26 @@ class AstraDBUploadStager(UploadStager):
         }
 
 
+class AstraDBUploaderConfig(UploaderConfig):
+    collection_name: Optional[str] = Field(
+        description="The name of the Astra DB collection. "
+        "Note that the collection name must only include letters, "
+        "numbers, and underscores.",
+        default=None,
+    )
+    keyspace: Optional[str] = Field(default=None, description="The Astra DB connection keyspace.")
+    requested_indexing_policy: Optional[dict[str, Any]] = Field(
+        default=None,
+        description="The indexing policy to use for the collection.",
+        examples=['{"deny": ["metadata"]}'],
+    )
+    batch_size: int = Field(default=20, description="Number of records per batch")
+    record_id_key: str = Field(
+        default=RECORD_ID_LABEL,
+        description="searchable key to find entries for the same record on previous runs",
+    )
+
+
 @dataclass
 class AstraDBUploader(Uploader):
     connection_config: AstraDBConnectionConfig

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

@@ -0,0 +1,31 @@
+from unstructured_ingest.v2.processes.connector_registry import (
+    add_source_entry,
+)
+
+from .zendesk import (
+    CONNECTOR_TYPE,
+    ZendeskAccessConfig,
+    ZendeskClient,
+    ZendeskConnectionConfig,
+    ZendeskDownloader,
+    ZendeskDownloaderConfig,
+    ZendeskIndexer,
+    ZendeskIndexerConfig,
+    ZendeskTicket,
+    zendesk_source_entry,
+)
+
+__all__ = [
+    "add_source_entry",
+    "zendesk_source_entry",
+    "ZendeskAccessConfig",
+    "ZendeskClient",
+    "ZendeskConnectionConfig",
+    "ZendeskDownloader",
+    "ZendeskDownloaderConfig",
+    "ZendeskIndexer",
+    "ZendeskIndexerConfig",
+    "ZendeskTicket",
+]
+
+add_source_entry(source_type=CONNECTOR_TYPE, entry=zendesk_source_entry)

unstructured_ingest/v2/processes/connectors/zendesk/client.py

@@ -0,0 +1,225 @@
+import base64
+from dataclasses import dataclass
+from typing import Dict, List
+
+import httpx
+
+from unstructured_ingest.v2.errors import ProviderError, RateLimitError, UserAuthError, UserError
+from unstructured_ingest.v2.logger import logger
+
+
+@dataclass
+class Comment:
+    id: int
+    author_id: str
+    body: str
+    parent_ticket_id: str
+    metadata: dict
+
+
+@dataclass
+class ZendeskTicket:
+    id: int
+    subject: str
+    description: str
+    generated_ts: int
+    metadata: dict
+
+    def __lt__(self, other):
+        return int(self.id) < int(other.id)
+
+
+@dataclass
+class ZendeskArticle:
+    id: int
+    author_id: str
+    title: str
+    content: str
+
+    def __lt__(self, other):
+        return int(self.id) < int(other.id)
+
+
+class ZendeskClient:
+
+    def __init__(self, token: str, subdomain: str, email: str):
+        # should be okay to be blocking.
+        url_to_check = f"https://{subdomain}.zendesk.com/api/v2/groups.json"
+        auth = f"{email}/token", token
+
+        try:
+            _ = httpx.get(url_to_check, auth=auth)
+        except Exception as e:
+            raise self.wrap_error(e=e)
+
+        self._token = token
+        self._subdomain = subdomain
+        self._email = email
+        self._auth = auth
+
+    def wrap_error(self, e: Exception) -> Exception:
+        if not isinstance(e, httpx.HTTPStatusError):
+            logger.error(f"unhandled exception from Zendesk client: {e}", exc_info=True)
+            return e
+        url = e.request.url
+        response_code = e.response.status_code
+        if response_code == 401:
+            logger.error(
+                f"Failed to connect via auth,"
+                f"{url} using zendesk response, status code {response_code}"
+            )
+            return UserAuthError(e)
+        if response_code == 429:
+            logger.error(
+                f"Failed to connect via rate limits"
+                f"{url} using zendesk response, status code {response_code}"
+            )
+            return RateLimitError(e)
+        if 400 <= response_code < 500:
+            logger.error(
+                f"Failed to connect to {url} using zendesk response, status code {response_code}"
+            )
+            return UserError(e)
+        if response_code > 500:
+            logger.error(
+                f"Failed to connect to {url} using zendesk response, status code {response_code}"
+            )
+            return ProviderError(e)
+        logger.error(f"unhandled http status error from Zendesk client: {e}", exc_info=True)
+        return e
+
+    async def get_articles_async(self) -> List[ZendeskArticle]:
+        """
+        Retrieves article content from Zendesk asynchronously.
+        """
+
+        articles: List[ZendeskArticle] = []
+
+        article_url = f"https://{self._subdomain}.zendesk.com/api/v2/help_center/articles.json"
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(article_url, auth=self._auth)
+                response.raise_for_status()
+        except Exception as e:
+            raise self.wrap_error(e=e)
+
+        articles_in_response: List[dict] = response.json()["articles"]
+
+        articles = [
+            ZendeskArticle(
+                id=int(entry["id"]),
+                author_id=str(entry["author_id"]),
+                title=str(entry["title"]),
+                content=entry["body"],
+            )
+            for entry in articles_in_response
+        ]
+        return articles
+
+    async def get_comments_async(self, ticket_id: int) -> List["Comment"]:
+        comments_url = f"https://{self._subdomain}.zendesk.com/api/v2/tickets/{ticket_id}/comments"
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(comments_url, auth=self._auth)
+                response.raise_for_status()
+        except Exception as e:
+            raise self.wrap_error(e=e)
+
+        return [
+            Comment(
+                id=int(entry["id"]),
+                author_id=entry["author_id"],
+                body=entry["body"],
+                metadata=entry,
+                parent_ticket_id=ticket_id,
+            )
+            for entry in response.json()["comments"]
+        ]
+
+    def get_users(self) -> List[dict]:
+
+        users: List[dict] = []
+
+        users_url = f"https://{self._subdomain}.zendesk.com/api/v2/users"
+        try:
+            response = httpx.get(users_url, auth=self._auth)
+            response.raise_for_status()
+        except Exception as e:
+            raise self.wrap_error(e=e)
+
+        users_in_response: List[dict] = response.json()["users"]
+        users = users_in_response
+
+        return users
+
+    async def get_tickets_async(self) -> List["ZendeskTicket"]:
+        tickets: List["ZendeskTicket"] = []
+        tickets_url = f"https://{self._subdomain}.zendesk.com/api/v2/tickets"
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(tickets_url, auth=self._auth)
+                response.raise_for_status()
+        except Exception as e:
+            raise self.wrap_error(e=e)
+
+        tickets_in_response: List[dict] = response.json()["tickets"]
+
+        for entry in tickets_in_response:
+            ticket = ZendeskTicket(
+                id=int(entry["id"]),
+                subject=entry["subject"],
+                description=entry["description"],
+                generated_ts=entry["generated_timestamp"],
+                metadata=entry,
+            )
+            tickets.append(ticket)
+
+        return tickets
+
+    async def get_article_attachments_async(self, article_id: str):
+        """
+        Handles article attachments such as images and stores them as UTF-8 encoded bytes.
+        """
+        article_attachment_url = (
+            f"https://{self._subdomain}.zendesk.com/api/v2/help_center/"
+            f"articles/{article_id}/attachments"
+        )
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(article_attachment_url, auth=self._auth)
+                response.raise_for_status()
+        except Exception as e:
+            raise self.wrap_error(e=e)
+
+        attachments_in_response: List[Dict] = response.json().get("article_attachments", [])
+        attachments = []
+
+        for attachment in attachments_in_response:
+            attachment_data = {
+                "id": attachment["id"],
+                "file_name": attachment["file_name"],
+                "content_type": attachment["content_type"],
+                "size": attachment["size"],
+                "url": attachment["url"],
+                "content_url": attachment["content_url"],
+            }
+
+            try:
+                async with httpx.AsyncClient() as client:
+                    download_response = await client.get(attachment["content_url"], auth=self._auth)
+                    download_response.raise_for_status()
+            except Exception as e:
+                raise self.wrap_error(e=e)
+
+            encoded_content = base64.b64encode(download_response.content).decode("utf-8")
+            attachment_data["encoded_content"] = (
+                f"data:{attachment_data['content_type']};base64,{encoded_content}"
+            )
+
+            attachments.append(attachment_data)
+
+        return attachments

unstructured_ingest/v2/processes/connectors/zendesk/zendesk.py

@@ -0,0 +1,419 @@
+from __future__ import annotations
+
+import datetime
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+from time import time
+from typing import Any, AsyncGenerator, List, Literal
+
+import aiofiles
+import bs4
+from pydantic import BaseModel, Field, Secret
+
+from unstructured_ingest.utils.data_prep import batch_generator
+from unstructured_ingest.utils.html import HtmlMixin
+from unstructured_ingest.v2.errors import UserAuthError
+from unstructured_ingest.v2.interfaces import (
+    AccessConfig,
+    BatchFileData,
+    BatchItem,
+    ConnectionConfig,
+    Downloader,
+    DownloaderConfig,
+    DownloadResponse,
+    FileData,
+    FileDataSourceMetadata,
+    Indexer,
+    IndexerConfig,
+    SourceIdentifiers,
+)
+from unstructured_ingest.v2.logger import logger
+from unstructured_ingest.v2.processes.connector_registry import SourceRegistryEntry
+
+from .client import ZendeskArticle, ZendeskClient, ZendeskTicket
+
+CONNECTOR_TYPE = "zendesk"
+
+
+class ZendeskAdditionalMetadata(BaseModel):
+    item_type: str
+    leading_id: str  # is the same as id just being verbose.
+    tail_id: str  # last id in the batch.
+
+
+class ZendeskFileDataSourceMetadata(FileDataSourceMetadata):
+    """
+    inherits metadata object as tickets and articles
+    are treated in single batch, we need to denote indices ticket/article
+    as the source metadata.
+    """
+
+
+class ZendeskBatchFileData(BatchFileData):
+    additional_metadata: ZendeskAdditionalMetadata
+
+
+class ZendeskAccessConfig(AccessConfig):
+    api_token: str = Field(
+        description="API token for zendesk generated under Apps and Integrations"
+    )
+
+
+class ZendeskBatchItemTicket(BatchItem):
+    subject: str
+    description: str
+    item_type: str = "tickets"  # placeholder for downloader
+
+
+class ZendeskBatchItemArticle(BatchItem):
+    title: str
+    author_id: str
+    title: str
+    content: str
+
+
+class ZendeskConnectionConfig(ConnectionConfig):
+    subdomain: str = Field(description="Subdomain for zendesk site, <sub-domain>.company.com")
+    email: str = Field(description="Email for zendesk site registered at the subdomain")
+    access_config: Secret[ZendeskAccessConfig]
+
+    async def get_client_async(self) -> ZendeskClient:
+        """Provides an async manager for ZendeskClient."""
+        access_config = self.access_config.get_secret_value()
+
+        client = ZendeskClient(
+            email=self.email, subdomain=self.subdomain, token=access_config.api_token
+        )
+        return client
+
+    def get_client(self) -> ZendeskClient:
+
+        access_config = self.access_config.get_secret_value()
+
+        client = ZendeskClient(
+            email=self.email, subdomain=self.subdomain, token=access_config.api_token
+        )
+        return client
+
+
+class ZendeskIndexerConfig(IndexerConfig):
+    batch_size: int = Field(
+        default=2,
+        description="Number of tickets or articles.",
+    )
+    item_type: Literal["tickets", "articles", "all"] = Field(
+        default="tickets",
+        description="Type of item from zendesk to parse, can only be `tickets` or `articles`.",
+    )
+
+
+@dataclass
+class ZendeskIndexer(Indexer):
+    connection_config: ZendeskConnectionConfig
+    index_config: ZendeskIndexerConfig
+    connector_type: str = CONNECTOR_TYPE
+
+    def precheck(self) -> None:
+        """Validates connection to Zendesk API."""
+        try:
+            client = self.connection_config.get_client()
+            if not client.get_users():
+                subdomain_endpoint = f"{self.connection_config.subdomain}.zendesk.com"
+                raise UserAuthError(f"Users do not exist in subdomain {subdomain_endpoint}")
+        except UserAuthError as e:
+            logger.error(f"Source connection error: {e}", exc_info=True)
+            raise
+        except Exception as e:
+            logger.error(f"Failed to validate connection to Zendesk: {e}", exc_info=True)
+            raise UserAuthError(f"Failed to validate connection: {e}")
+
+    def is_async(self) -> bool:
+        return True
+
+    async def _list_articles_async(self) -> List[ZendeskArticle]:
+        client = await self.connection_config.get_client_async()
+        return await client.get_articles_async()
+
+    async def _list_tickets_async(self) -> List[ZendeskTicket]:
+        client = await self.connection_config.get_client_async()
+        return await client.get_tickets_async()
+
+    def _generate_fullpath(self, identifier: str) -> Path:
+        return Path(hashlib.sha256(identifier.encode("utf-8")).hexdigest()[:16] + ".txt")
+
+    async def handle_articles_async(
+        self, articles: List[ZendeskArticle], batch_size: int
+    ) -> AsyncGenerator[ZendeskBatchFileData, None]:
+        """Parses articles from a list and yields FileData objects asynchronously in batches."""
+        for article_batch in batch_generator(articles, batch_size=batch_size):
+
+            article_batch = sorted(article_batch)
+
+            additional_metadata = ZendeskAdditionalMetadata(
+                item_type="articles",
+                leading_id=str(article_batch[0].id),
+                tail_id=str(article_batch[-1].id),
+            )
+
+            metadata = ZendeskFileDataSourceMetadata(
+                date_processed=str(time()),
+                record_locator={
+                    "id": str(article_batch[0].id),
+                    "item_type": "articles",
+                },
+            )
+
+            batch_items: List[ZendeskBatchItemArticle] = [
+                ZendeskBatchItemArticle(
+                    identifier=str(article.id),
+                    author_id=str(article.author_id),
+                    title=str(article.title),
+                    content=str(article.content),
+                )
+                for article in article_batch
+            ]
+
+            full_path = self._generate_fullpath(str(article_batch[0].id))
+            full_path = Path(str(full_path).replace(".txt", ".html"))
+
+            source_identifiers = SourceIdentifiers(filename=full_path.name, fullpath=str(full_path))
+
+            batched_file_data = ZendeskBatchFileData(
+                identifier=str(article_batch[0].id),
+                connector_type=self.connector_type,
+                metadata=metadata,
+                batch_items=batch_items,
+                additional_metadata=additional_metadata,
+                source_identifiers=source_identifiers,
+            )
+
+            yield batched_file_data
+
+    async def handle_tickets_async(
+        self, tickets: List[ZendeskTicket], batch_size: int
+    ) -> AsyncGenerator[ZendeskBatchFileData, None]:
+        """Parses tickets from a list and yields FileData objects asynchronously in batches."""
+        for ticket_batch in batch_generator(tickets, batch_size=batch_size):
+
+            sorted_batch = sorted(ticket_batch)
+
+            additional_metadata = ZendeskAdditionalMetadata(
+                item_type="tickets",
+                leading_id=str(sorted_batch[0].id),
+                tail_id=str(sorted_batch[-1].id),
+            )
+
+            metadata = ZendeskFileDataSourceMetadata(
+                date_processed=str(time()),
+                record_locator={
+                    "id": str(sorted_batch[0].id),
+                    "item_type": "tickets",
+                },
+            )
+
+            batch_items: List[ZendeskBatchItemTicket] = [
+                ZendeskBatchItemTicket(
+                    identifier=str(ticket.id),
+                    subject=str(ticket.subject),
+                    description=str(ticket.description),
+                )
+                for ticket in sorted_batch
+            ]
+
+            full_path = self._generate_fullpath(str(sorted_batch[0].id))
+            source_identifiers = SourceIdentifiers(filename=full_path.name, fullpath=str(full_path))
+
+            batched_file_data = ZendeskBatchFileData(
+                connector_type=self.connector_type,
+                metadata=metadata,
+                batch_items=batch_items,
+                additional_metadata=additional_metadata,
+                source_identifiers=source_identifiers,
+            )
+
+            yield batched_file_data
+
+    async def run_async(self, **kwargs: Any) -> AsyncGenerator[FileData, None]:
+        """Determines item type and processes accordingly asynchronously."""
+        item_type = self.index_config.item_type
+        batch_size = self.index_config.batch_size
+
+        if item_type == "articles":
+            articles = await self._list_articles_async()
+            async for file_data in self.handle_articles_async(
+                articles, batch_size
+            ):  # Using async version
+                yield file_data
+
+        elif item_type == "tickets":
+            tickets = await self._list_tickets_async()
+            async for file_data in self.handle_tickets_async(
+                tickets, batch_size
+            ):  # Using async version
+                yield file_data
+
+
+class ZendeskDownloaderConfig(DownloaderConfig, HtmlMixin):
+    pass
+
+
+@dataclass
+class ZendeskDownloader(Downloader):
+    download_config: ZendeskDownloaderConfig
+    connection_config: ZendeskConnectionConfig
+    connector_type: str = CONNECTOR_TYPE
+
+    def is_async(self) -> bool:
+        return True
+
+    def download_embedded_files(
+        self, session, html: str, current_file_data: FileData
+    ) -> list[DownloadResponse]:
+        if not self.download_config.extract_files:
+            return []
+        url = current_file_data.metadata.url
+        if url is None:
+            logger.warning(
+                f"""Missing URL for file: {current_file_data.source_identifiers.filename}.
+                Skipping file extraction."""
+            )
+            return []
+        filepath = current_file_data.source_identifiers.relative_path
+        download_path = Path(self.download_dir) / filepath
+        download_dir = download_path.with_suffix("")
+        return self.download_config.extract_embedded_files(
+            url=url,
+            download_dir=download_dir,
+            original_filedata=current_file_data,
+            html=html,
+            session=session,
+        )
+
+    async def handle_articles_async(
+        self, client: ZendeskClient, batch_file_data: ZendeskBatchFileData
+    ):
+        """
+        Processes the article information, downloads the attachments for each article,
+        and updates the content accordingly.
+        """
+        # Determine the download path
+        download_path = self.get_download_path(batch_file_data)
+
+        if download_path is None:
+            raise ValueError("Download path could not be determined")
+
+        download_path.parent.mkdir(parents=True, exist_ok=True)
+
+        async with aiofiles.open(download_path, "a", encoding="utf8") as f:
+            for article in batch_file_data.batch_items:
+                html_data_str = article.content
+                soup = bs4.BeautifulSoup(html_data_str, "html.parser")
+
+                if self.download_config.extract_images:
+                    # Get article attachments asynchronously
+                    image_data_decoded: List = await client.get_article_attachments_async(
+                        article_id=article.identifier
+                    )
+                    img_tags = soup.find_all("img")
+
+                    # Ensure we don't exceed the available images
+                    for img_tag, img_data in zip(img_tags, image_data_decoded):
+                        img_tag["src"] = img_data.get("encoded_content", "")
+
+            await f.write(soup.prettify())
+
+        return super().generate_download_response(
+            file_data=batch_file_data, download_path=download_path
+        )
+
+    async def handle_tickets_async(
+        self, client: ZendeskClient, batch_file_data: ZendeskBatchFileData
+    ) -> DownloadResponse:
+        """
+        Processes a batch of tickets asynchronously, writing their details and comments to a file.
+        """
+        # Determine the download path
+        download_path = self.get_download_path(batch_file_data)
+        if download_path is None:
+            raise ValueError("Download path could not be determined")
+
+        download_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Process each ticket in the batch
+        async with aiofiles.open(download_path, "a", encoding="utf8") as f:
+            for batch_item in batch_file_data.batch_items:
+                ticket_identifier = batch_item.identifier
+                first_date = None
+                comments: List[dict] = []
+
+                # Fetch comments asynchronously
+                comments_list = await client.get_comments_async(ticket_id=int(ticket_identifier))
+
+                for comment in comments_list:  # Iterate over the resolved list
+                    date_created = (
+                        comment.metadata["created_at"].isoformat()
+                        if isinstance(comment.metadata["created_at"], datetime.datetime)
+                        else str(comment.metadata["created_at"])
+                    )
+
+                    if first_date is None:
+                        first_date = date_created
+
+                    comments.append(
+                        {
+                            "comment_id": comment.id,
+                            "author_id": comment.author_id,
+                            "body": comment.body,
+                            "date_created": date_created,
+                        }
+                    )
+
+                # Write ticket details to file
+                content = (
+                    "\nticket\n"
+                    f"{batch_item.identifier}\n"
+                    f"{batch_file_data.metadata.record_locator.get('subject', '')}\n"
+                    f"{batch_file_data.metadata.record_locator.get('description', '')}\n"
+                    f"{first_date}\n"
+                )
+
+                # Append comments
+                for comment in comments:
+                    content += (
+                        "comment\n"
+                        f"{comment.get('comment_id', '')}\n"
+                        f"{comment.get('author_id', '')}\n"
+                        f"{comment.get('body', '')}\n"
+                        f"{comment.get('date_created', '')}\n"
+                    )
+
+                await f.write(content)
+
+        return super().generate_download_response(
+            file_data=batch_file_data, download_path=download_path
+        )
+
+    async def run_async(self, file_data: ZendeskBatchFileData, **kwargs: Any) -> DownloadResponse:
+
+        zendesk_filedata: FileData = FileData.cast(file_data=file_data)
+
+        client = await self.connection_config.get_client_async()
+        item_type = zendesk_filedata.metadata.record_locator["item_type"]
+
+        if item_type == "articles":
+            return await self.handle_articles_async(client, file_data)
+        elif item_type == "tickets":
+            return await self.handle_tickets_async(client, file_data)
+        else:
+            raise RuntimeError(f"Item type {item_type} cannot be handled by the downloader")
+
+
+# create entry
+zendesk_source_entry = SourceRegistryEntry(
+    connection_config=ZendeskConnectionConfig,
+    indexer_config=ZendeskIndexerConfig,
+    indexer=ZendeskIndexer,
+    downloader=ZendeskDownloader,
+    downloader_config=ZendeskDownloaderConfig,
+)

{unstructured_ingest-0.5.10.dist-info → unstructured_ingest-0.5.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: unstructured-ingest
-Version: 0.5.10
+Version: 0.5.11
 Summary: A library that prepares raw documents for downstream ML tasks.
 Home-page: https://github.com/Unstructured-IO/unstructured-ingest
 Author: Unstructured Technologies
@@ -23,12 +23,12 @@ Requires-Python: >=3.9.0,<3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: tqdm
-Requires-Dist: dataclasses_json
-Requires-Dist: pydantic>=2.7
-Requires-Dist: pandas
 Requires-Dist: click
+Requires-Dist: pandas
+Requires-Dist: pydantic>=2.7
 Requires-Dist: opentelemetry-sdk
 Requires-Dist: python-dateutil
+Requires-Dist: dataclasses_json
 Provides-Extra: remote
 Requires-Dist: unstructured-client>=0.30.0; extra == "remote"
 Provides-Extra: csv
@@ -66,13 +66,13 @@ 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: biomed
-Requires-Dist: requests; extra == "biomed"
 Requires-Dist: bs4; extra == "biomed"
+Requires-Dist: requests; extra == "biomed"
 Provides-Extra: box
 Requires-Dist: fsspec; extra == "box"
 Requires-Dist: boxfs; extra == "box"
@@ -91,19 +91,19 @@ Requires-Dist: deltalake; extra == "delta-table"
 Provides-Extra: discord
 Requires-Dist: discord.py; extra == "discord"
 Provides-Extra: dropbox
-Requires-Dist: fsspec; extra == "dropbox"
 Requires-Dist: dropboxdrivefs; extra == "dropbox"
+Requires-Dist: fsspec; extra == "dropbox"
 Provides-Extra: duckdb
 Requires-Dist: duckdb; extra == "duckdb"
 Provides-Extra: elasticsearch
 Requires-Dist: elasticsearch[async]; extra == "elasticsearch"
 Provides-Extra: gcs
-Requires-Dist: fsspec; extra == "gcs"
 Requires-Dist: bs4; extra == "gcs"
+Requires-Dist: fsspec; extra == "gcs"
 Requires-Dist: gcsfs; extra == "gcs"
 Provides-Extra: github
-Requires-Dist: pygithub>1.58.0; extra == "github"
 Requires-Dist: requests; extra == "github"
+Requires-Dist: pygithub>1.58.0; extra == "github"
 Provides-Extra: gitlab
 Requires-Dist: python-gitlab; extra == "gitlab"
 Provides-Extra: google-drive
@@ -124,18 +124,18 @@ Requires-Dist: pymilvus; extra == "milvus"
 Provides-Extra: mongodb
 Requires-Dist: pymongo; extra == "mongodb"
 Provides-Extra: neo4j
-Requires-Dist: cymple; extra == "neo4j"
-Requires-Dist: neo4j-rust-ext; extra == "neo4j"
 Requires-Dist: networkx; extra == "neo4j"
+Requires-Dist: neo4j-rust-ext; extra == "neo4j"
+Requires-Dist: cymple; extra == "neo4j"
 Provides-Extra: notion
+Requires-Dist: htmlBuilder; extra == "notion"
+Requires-Dist: httpx; extra == "notion"
 Requires-Dist: notion-client; extra == "notion"
 Requires-Dist: backoff; extra == "notion"
-Requires-Dist: httpx; extra == "notion"
-Requires-Dist: htmlBuilder; extra == "notion"
 Provides-Extra: onedrive
 Requires-Dist: Office365-REST-Python-Client; extra == "onedrive"
-Requires-Dist: msal; extra == "onedrive"
 Requires-Dist: bs4; extra == "onedrive"
+Requires-Dist: msal; extra == "onedrive"
 Provides-Extra: opensearch
 Requires-Dist: opensearch-py; extra == "opensearch"
 Provides-Extra: outlook
@@ -178,18 +178,18 @@ Requires-Dist: databricks-sql-connector; extra == "databricks-delta-tables"
 Provides-Extra: singlestore
 Requires-Dist: singlestoredb; extra == "singlestore"
 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: vastdb
+Requires-Dist: vastdb; extra == "vastdb"
 Requires-Dist: ibis; extra == "vastdb"
 Requires-Dist: pyarrow; extra == "vastdb"
-Requires-Dist: vastdb; extra == "vastdb"
 Provides-Extra: embed-huggingface
 Requires-Dist: sentence-transformers; extra == "embed-huggingface"
 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
@@ -197,11 +197,11 @@ Requires-Dist: voyageai; extra == "embed-voyageai"
 Provides-Extra: embed-mixedbreadai
 Requires-Dist: mixedbread-ai; extra == "embed-mixedbreadai"
 Provides-Extra: openai
-Requires-Dist: openai; extra == "openai"
 Requires-Dist: tiktoken; extra == "openai"
+Requires-Dist: openai; extra == "openai"
 Provides-Extra: bedrock
-Requires-Dist: boto3; extra == "bedrock"
 Requires-Dist: aioboto3; extra == "bedrock"
+Requires-Dist: boto3; extra == "bedrock"
 Provides-Extra: togetherai
 Requires-Dist: together; extra == "togetherai"
 Dynamic: author

{unstructured_ingest-0.5.10.dist-info → unstructured_ingest-0.5.11.dist-info}/RECORD

@@ -5,7 +5,7 @@ test/integration/chunkers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 test/integration/chunkers/test_chunkers.py,sha256=USkltQN_mVVCxI0FkJsrS1gnLXlVr-fvsc0tPaK2sWI,1062
 test/integration/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/integration/connectors/conftest.py,sha256=vYs4WDlCuieAwwErkJxCk4a1lGvr3qpeiAm-YaDznSo,1018
-test/integration/connectors/test_astradb.py,sha256=pZmUItFzS91etJONk5HaX8ayarXmFH7RhKmtBxmCClQ,8995
+test/integration/connectors/test_astradb.py,sha256=c9Lk0dvJVVdzHcokvsc4XMNJ4SIO1k2vGtT5py0cFVM,9753
 test/integration/connectors/test_azure_ai_search.py,sha256=MxFwk84vI_HT4taQTGrNpJ8ewGPqHSGrx626j8hC_Pw,9695
 test/integration/connectors/test_chroma.py,sha256=NuQv0PWPM0_LQfdPeUd6IYKqaKKXWmVaHGWjq5aBfOY,3721
 test/integration/connectors/test_confluence.py,sha256=Ju0gRQbD2g9l9iRf2HDZKi7RyPnBGtFRWcGpsqhO3F8,3588
@@ -25,6 +25,7 @@ test/integration/connectors/test_redis.py,sha256=1aKwOb-K4zCxZwHmgW_WzGJwqLntbWT
 test/integration/connectors/test_s3.py,sha256=E1dypeag_E3OIfpQWIz3jb7ctRHRD63UtyTrzyvJzpc,7473
 test/integration/connectors/test_sharepoint.py,sha256=weGby5YD6se7R7KLEq96hxUZYPzwoqZqXXTPhtQWZsQ,7646
 test/integration/connectors/test_vectara.py,sha256=4kKOOTGUjeZw2jKRcgVDI7ifbRPRZfjjVO4d_7H5C6I,8710
+test/integration/connectors/test_zendesk.py,sha256=6Xsxxav9b1NBp_zd66S_sE4Nn5iO6Et4a5zgGR2-Y04,4159
 test/integration/connectors/databricks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/integration/connectors/databricks/test_volumes_native.py,sha256=KqiapQAV0s_Zv0CO8BwYoiCk30dwrSZzuigUWNRIem0,9559
 test/integration/connectors/discord/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -49,7 +50,7 @@ test/integration/connectors/utils/constants.py,sha256=JhTk6YNw7JVpkk-Pl8zn2YYkEx
 test/integration/connectors/utils/docker.py,sha256=4g1STiSbYN5qcmDTXyPxVJgwx97O6wk7n-DJ-zgzgag,4971
 test/integration/connectors/utils/docker_compose.py,sha256=GVTB6Cel05c0VQ2n4AwkQQx_cBfz13ZTs1HpbaYipNU,2223
 test/integration/connectors/utils/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-test/integration/connectors/utils/validation/destination.py,sha256=ZvMSvqz9in35xaoUJGx9rG8oWCU3FYlfLLQ6sfdI0pw,2649
+test/integration/connectors/utils/validation/destination.py,sha256=HUdwpvszGOuGnKZFawGdxRNptbbJDIghyi-roQjhEs4,2697
 test/integration/connectors/utils/validation/equality.py,sha256=R6d_1c-Si5518WJcBcshF_wBRnywnZ0ORQ-NL0xNmGo,2602
 test/integration/connectors/utils/validation/source.py,sha256=xnAZI26ILdeMhgrWAGrU2N2fqK58YNGkfyUhJekZ0Ho,13541
 test/integration/connectors/utils/validation/utils.py,sha256=xYYvAbqP6_lZyH09_JjB4w2Sf8aQPvDVT5vZTs05ILs,1428
@@ -110,7 +111,7 @@ test/unit/v2/partitioners/test_partitioner.py,sha256=iIYg7IpftV3LusoO4H8tr1IHY1U
 test/unit/v2/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/unit/v2/utils/data_generator.py,sha256=UoYVNjG4S4wlaA9gceQ82HIpF9_6I1UTHD1_GrQBHp0,973
 unstructured_ingest/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
-unstructured_ingest/__version__.py,sha256=zt01ptYEjMmXlL3j2UXGxQc1ECQ60nEk9hYEq2kojkc,43
+unstructured_ingest/__version__.py,sha256=jn_Macoo3VuCWr-9TnO28WPJsWO8fYuvd5mexbdfL3c,43
 unstructured_ingest/error.py,sha256=qDncnJgbf5ils956RcO2CGlAKYDT5OaEM9Clv1JVTNc,1448
 unstructured_ingest/interfaces.py,sha256=7DOnDpGvUNlCoFR7UPRGmOarqH5sFtuUOO5vf8X3oTM,31489
 unstructured_ingest/logger.py,sha256=S5nSqGcABoQyeicgRnBQFjDScCaTvFVivOCvbo-laL0,4479
@@ -397,7 +398,7 @@ unstructured_ingest/v2/cli/utils/click.py,sha256=1_eJgrwS2DFBl1jZPLsj1vgVgR7agFB
 unstructured_ingest/v2/cli/utils/model_conversion.py,sha256=7eEIkk1KU51-ZNiIfI1KRxlwITNW1xl1YxMAG8BcTk0,7604
 unstructured_ingest/v2/interfaces/__init__.py,sha256=Xp7-345QpM6MG7V7G4ZrVERjADAUBiPAY88PKaMRyqY,1005
 unstructured_ingest/v2/interfaces/connector.py,sha256=qUFFJ3qgDMenTCZMtVRjq1DIwsVak6pxNjQOH2eVkMw,1623
-unstructured_ingest/v2/interfaces/downloader.py,sha256=Lj3nTY1hPA71GfNeedFVCdHdZsHLle8qrx5RtXAy9GY,2940
+unstructured_ingest/v2/interfaces/downloader.py,sha256=Qi_wISgUACZKEPu5p1kUaG3uiCXcr3zWg9z9uRDwoOk,2927
 unstructured_ingest/v2/interfaces/file_data.py,sha256=7MyRlj5dijQsCR6W18wQ8fEgJigGKwoOYc10g9A6PSo,3834
 unstructured_ingest/v2/interfaces/indexer.py,sha256=i0oftyifXefxfKa4a3sCfSwkzWGSPE6EvC9sg6fwZgk,833
 unstructured_ingest/v2/interfaces/process.py,sha256=S3A_9gkwwGC-iQxvnpj3Er6IJAjAT5npzpSgxuFAzUM,449
@@ -427,7 +428,7 @@ unstructured_ingest/v2/processes/partitioner.py,sha256=HxopDSbovLh_1epeGeVtuWEX7
 unstructured_ingest/v2/processes/uncompress.py,sha256=Z_XfsITGdyaRwhtNUc7bMj5Y2jLuBge8KoK4nxhqKag,2425
 unstructured_ingest/v2/processes/connectors/__init__.py,sha256=rkEQVVgcHoY3jwgW_5PH_NzdXIEwtBLs9Dk4VzmTZMA,6387
 unstructured_ingest/v2/processes/connectors/airtable.py,sha256=eeZJe-bBNxt5Sa-XEFCdcGeJCguJU5WN2Mv9kLp5dVQ,8917
-unstructured_ingest/v2/processes/connectors/astradb.py,sha256=3WFJUNEjeuZFhsLW9KzOIOsiStCjpnqKokS1oIQLUR0,17816
+unstructured_ingest/v2/processes/connectors/astradb.py,sha256=E6fB4anCd_gtSzVUsZ5pDrfdxs5AWERQM_NEfeenfEs,18202
 unstructured_ingest/v2/processes/connectors/azure_ai_search.py,sha256=ngPDpU0oZ6m5sxIlB6u5ebQpqCS_SJ-_amCC1KQ03EQ,11529
 unstructured_ingest/v2/processes/connectors/chroma.py,sha256=VHCnM56qNXuHzovJihrNfJnZbWLJShOe8j12PJFrbL0,7219
 unstructured_ingest/v2/processes/connectors/confluence.py,sha256=wTZewdbmCHaQuEJZ7Wf0NBOo8fS_n1I0DDwlhN96woE,11243
@@ -571,9 +572,12 @@ unstructured_ingest/v2/processes/connectors/weaviate/cloud.py,sha256=bXtfEYLquR-
 unstructured_ingest/v2/processes/connectors/weaviate/embedded.py,sha256=S8Zg8StuZT-k7tCg1D5YShO1-vJYYk9-M1bE1fIqx64,3014
 unstructured_ingest/v2/processes/connectors/weaviate/local.py,sha256=LuTBKPseVewsz8VqxRPRLfGEm3BeI9nBZxpy7ZU5tOA,2201
 unstructured_ingest/v2/processes/connectors/weaviate/weaviate.py,sha256=UZ_s8dnVNx9BWFG2fPah4VbQbgEDF4nP78bQeU3jg08,12821
-unstructured_ingest-0.5.10.dist-info/LICENSE.md,sha256=SxkKP_62uIAKb9mb1eH7FH4Kn2aYT09fgjKpJt5PyTk,11360
-unstructured_ingest-0.5.10.dist-info/METADATA,sha256=uDnGDugbuWFqPuo9b-ZVLsuJ57ct-mfYQuAAvYIvE4c,8317
-unstructured_ingest-0.5.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-unstructured_ingest-0.5.10.dist-info/entry_points.txt,sha256=gUAAFnjFPnBgThJSEbw0N5ZjxtaKlT1s9e05_arQrNw,70
-unstructured_ingest-0.5.10.dist-info/top_level.txt,sha256=DMuDMHZRMdeay8v8Kdi855muIv92F0OkutvBCaBEW6M,25
-unstructured_ingest-0.5.10.dist-info/RECORD,,
+unstructured_ingest/v2/processes/connectors/zendesk/__init__.py,sha256=XMNocKJ3FHDfy36p_KHhH7ALi0-ji6NhGuQNCV2E4vY,699
+unstructured_ingest/v2/processes/connectors/zendesk/client.py,sha256=wK2x5t2h0qXSwCYgli8Zegg8bujdSrgnmiTO-bu7nN4,7297
+unstructured_ingest/v2/processes/connectors/zendesk/zendesk.py,sha256=97yikyb6EQ70pjU2ZXpYnJeC55vkeXaEXlawx5qS6Oo,15228
+unstructured_ingest-0.5.11.dist-info/LICENSE.md,sha256=SxkKP_62uIAKb9mb1eH7FH4Kn2aYT09fgjKpJt5PyTk,11360
+unstructured_ingest-0.5.11.dist-info/METADATA,sha256=5HEW821YxrURJHOb7OxOa8AggarvDctXU0V8p2z1gws,8317
+unstructured_ingest-0.5.11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+unstructured_ingest-0.5.11.dist-info/entry_points.txt,sha256=gUAAFnjFPnBgThJSEbw0N5ZjxtaKlT1s9e05_arQrNw,70
+unstructured_ingest-0.5.11.dist-info/top_level.txt,sha256=DMuDMHZRMdeay8v8Kdi855muIv92F0OkutvBCaBEW6M,25
+unstructured_ingest-0.5.11.dist-info/RECORD,,