chunkr-ai 0.1.0a2__py3-none-any.whl → 0.1.0a4__py3-none-any.whl

chunkr_ai/__init__.py

@@ -72,6 +72,9 @@ __all__ = [
 ]
 
 if not _t.TYPE_CHECKING:
+    # Load custom helpers that monkey-patch generated types.
+    # This keeps custom code separate from generated files, per Stainless guidance.
+    from .lib import tasks_poll as _tasks_poll  # noqa: F401
     from ._utils._resources_proxy import resources as resources
 
 _setup_logging()

chunkr_ai/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import health
+from .resources import files, health
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import ChunkrError, APIStatusError
 from ._base_client import (
@@ -29,13 +29,14 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.task import task
+from .resources.tasks import tasks
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Chunkr", "AsyncChunkr", "Client", "AsyncClient"]
 
 
 class Chunkr(SyncAPIClient):
-    task: task.TaskResource
+    tasks: tasks.TasksResource
+    files: files.FilesResource
     health: health.HealthResource
     with_raw_response: ChunkrWithRawResponse
     with_streaming_response: ChunkrWithStreamedResponse
@@ -94,7 +95,8 @@ class Chunkr(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.task = task.TaskResource(self)
+        self.tasks = tasks.TasksResource(self)
+        self.files = files.FilesResource(self)
         self.health = health.HealthResource(self)
         self.with_raw_response = ChunkrWithRawResponse(self)
         self.with_streaming_response = ChunkrWithStreamedResponse(self)
@@ -205,7 +207,8 @@ class Chunkr(SyncAPIClient):
 
 
 class AsyncChunkr(AsyncAPIClient):
-    task: task.AsyncTaskResource
+    tasks: tasks.AsyncTasksResource
+    files: files.AsyncFilesResource
     health: health.AsyncHealthResource
     with_raw_response: AsyncChunkrWithRawResponse
     with_streaming_response: AsyncChunkrWithStreamedResponse
@@ -264,7 +267,8 @@ class AsyncChunkr(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.task = task.AsyncTaskResource(self)
+        self.tasks = tasks.AsyncTasksResource(self)
+        self.files = files.AsyncFilesResource(self)
         self.health = health.AsyncHealthResource(self)
         self.with_raw_response = AsyncChunkrWithRawResponse(self)
         self.with_streaming_response = AsyncChunkrWithStreamedResponse(self)
@@ -376,25 +380,29 @@ class AsyncChunkr(AsyncAPIClient):
 
 class ChunkrWithRawResponse:
     def __init__(self, client: Chunkr) -> None:
-        self.task = task.TaskResourceWithRawResponse(client.task)
+        self.tasks = tasks.TasksResourceWithRawResponse(client.tasks)
+        self.files = files.FilesResourceWithRawResponse(client.files)
         self.health = health.HealthResourceWithRawResponse(client.health)
 
 
 class AsyncChunkrWithRawResponse:
     def __init__(self, client: AsyncChunkr) -> None:
-        self.task = task.AsyncTaskResourceWithRawResponse(client.task)
+        self.tasks = tasks.AsyncTasksResourceWithRawResponse(client.tasks)
+        self.files = files.AsyncFilesResourceWithRawResponse(client.files)
         self.health = health.AsyncHealthResourceWithRawResponse(client.health)
 
 
 class ChunkrWithStreamedResponse:
     def __init__(self, client: Chunkr) -> None:
-        self.task = task.TaskResourceWithStreamingResponse(client.task)
+        self.tasks = tasks.TasksResourceWithStreamingResponse(client.tasks)
+        self.files = files.FilesResourceWithStreamingResponse(client.files)
         self.health = health.HealthResourceWithStreamingResponse(client.health)
 
 
 class AsyncChunkrWithStreamedResponse:
     def __init__(self, client: AsyncChunkr) -> None:
-        self.task = task.AsyncTaskResourceWithStreamingResponse(client.task)
+        self.tasks = tasks.AsyncTasksResourceWithStreamingResponse(client.tasks)
+        self.files = files.AsyncFilesResourceWithStreamingResponse(client.files)
         self.health = health.AsyncHealthResourceWithStreamingResponse(client.health)
 
 

chunkr_ai/_files.py

@@ -34,7 +34,7 @@ def assert_is_file_content(obj: object, *, key: str | None = None) -> None:
     if not is_file_content(obj):
         prefix = f"Expected entry at `{key}`" if key is not None else f"Expected file input `{obj!r}`"
         raise RuntimeError(
-            f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead."
+            f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead. See https://github.com/lumina-ai-inc/chunkr-python/tree/main#file-uploads"
         ) from None
 
 

chunkr_ai/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "chunkr_ai"
-__version__ = "0.1.0-alpha.2"  # x-release-please-version
+__version__ = "0.1.0-alpha.4"  # x-release-please-version

chunkr_ai/lib/tasks_poll.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+"""
+Custom helpers for task polling.
+
+This module adds `Task.poll()` and `Task.apoll()` methods at runtime to the
+generated `Task` model, without modifying generated code directly.
+
+Usage:
+    task = client.tasks.get(task_id)
+    task = task.poll(client)  # blocks until terminal state
+
+    # async
+    task = await async_client.tasks.get(task_id)
+    task = await task.apoll(async_client)
+"""
+
+import time
+import asyncio
+from typing import Protocol, cast
+
+from .._types import NOT_GIVEN, NotGiven
+from .._client import Chunkr, AsyncChunkr
+from ..types.task import Task as _Task
+from .._exceptions import ChunkrError
+
+TERMINAL_STATUSES = {"Succeeded", "Failed", "Cancelled"}
+
+
+def _task_poll(
+    self: _Task,
+    client: Chunkr,
+    *,
+    interval: float = 0.5,
+    timeout: float = 600.0,
+    include_chunks: bool | NotGiven = NOT_GIVEN,
+    base64_urls: bool | NotGiven = NOT_GIVEN,
+) -> _Task:
+    """Poll the task until it reaches a terminal status.
+
+    Args:
+        client: Synchronous Chunkr client instance.
+        interval: Seconds to sleep between polls.
+        timeout: Maximum total seconds to wait before raising an error.
+        include_chunks: Whether to include chunks in the output response for each poll.
+        base64_urls: Whether to return base64 encoded URLs.
+    """
+    start_time = time.monotonic()
+    current: _Task = self
+
+    class _TasksGetProtocol(Protocol):
+        def get(
+            self,
+            task_id: str,
+            *,
+            base64_urls: bool | NotGiven = NOT_GIVEN,
+            include_chunks: bool | NotGiven = NOT_GIVEN,
+        ) -> _Task: ...
+
+    resource = cast(_TasksGetProtocol, client.tasks)
+
+    while current.status not in TERMINAL_STATUSES:
+        if time.monotonic() - start_time > timeout:
+            raise ChunkrError("Task polling timed out.")
+
+        if interval > 0:
+            time.sleep(interval)
+
+        current = resource.get(
+            current.task_id,
+            include_chunks=include_chunks,
+            base64_urls=base64_urls,
+        )
+
+    return current
+
+
+async def _task_apoll(
+    self: _Task,
+    client: AsyncChunkr,
+    *,
+    interval: float = 0.5,
+    timeout: float = 600.0,
+    include_chunks: bool | NotGiven = NOT_GIVEN,
+    base64_urls: bool | NotGiven = NOT_GIVEN,
+) -> _Task:
+    """Async poll the task until it reaches a terminal status."""
+    start_time = time.monotonic()
+    current: _Task = self
+
+    class _AsyncTasksGetProtocol(Protocol):
+        async def get(
+            self,
+            task_id: str,
+            *,
+            base64_urls: bool | NotGiven = NOT_GIVEN,
+            include_chunks: bool | NotGiven = NOT_GIVEN,
+        ) -> _Task: ...
+
+    aresource = cast(_AsyncTasksGetProtocol, client.tasks)
+
+    while current.status not in TERMINAL_STATUSES:
+        if time.monotonic() - start_time > timeout:
+            raise ChunkrError("Task polling timed out.")
+
+        if interval > 0:
+            await asyncio.sleep(interval)
+
+        current = await aresource.get(
+            current.task_id,
+            include_chunks=include_chunks,
+            base64_urls=base64_urls,
+        )
+
+    return current
+
+
+# Attach methods to the generated Task model
+_Task.poll = _task_poll  # type: ignore[attr-defined]
+_Task.apoll = _task_apoll  # type: ignore[attr-defined]
+
+

chunkr_ai/pagination.py

@@ -6,7 +6,7 @@ from typing_extensions import override
 
 from ._base_client import BasePage, PageInfo, BaseSyncPage, BaseAsyncPage
 
-__all__ = ["SyncTasksPage", "AsyncTasksPage"]
+__all__ = ["SyncTasksPage", "AsyncTasksPage", "SyncFilesPage", "AsyncFilesPage"]
 
 _T = TypeVar("_T")
 
@@ -69,3 +69,63 @@ class AsyncTasksPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
             return None
 
         return PageInfo(params={"cursor": next_cursor})
+
+
+class SyncFilesPage(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    files: List[_T]
+    next_cursor: Optional[datetime] = None
+    has_more: Optional[bool] = None
+    """Whether there are more pages available"""
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        files = self.files
+        if not files:
+            return []
+        return files
+
+    @override
+    def has_next_page(self) -> bool:
+        has_more = self.has_more
+        if has_more is not None and has_more is False:
+            return False
+
+        return super().has_next_page()
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        next_cursor = self.next_cursor
+        if not next_cursor:
+            return None
+
+        return PageInfo(params={"cursor": next_cursor})
+
+
+class AsyncFilesPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    files: List[_T]
+    next_cursor: Optional[datetime] = None
+    has_more: Optional[bool] = None
+    """Whether there are more pages available"""
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        files = self.files
+        if not files:
+            return []
+        return files
+
+    @override
+    def has_next_page(self) -> bool:
+        has_more = self.has_more
+        if has_more is not None and has_more is False:
+            return False
+
+        return super().has_next_page()
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        next_cursor = self.next_cursor
+        if not next_cursor:
+            return None
+
+        return PageInfo(params={"cursor": next_cursor})

chunkr_ai/resources/__init__.py

@@ -1,12 +1,20 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from .task import (
-    TaskResource,
-    AsyncTaskResource,
-    TaskResourceWithRawResponse,
-    AsyncTaskResourceWithRawResponse,
-    TaskResourceWithStreamingResponse,
-    AsyncTaskResourceWithStreamingResponse,
+from .files import (
+    FilesResource,
+    AsyncFilesResource,
+    FilesResourceWithRawResponse,
+    AsyncFilesResourceWithRawResponse,
+    FilesResourceWithStreamingResponse,
+    AsyncFilesResourceWithStreamingResponse,
+)
+from .tasks import (
+    TasksResource,
+    AsyncTasksResource,
+    TasksResourceWithRawResponse,
+    AsyncTasksResourceWithRawResponse,
+    TasksResourceWithStreamingResponse,
+    AsyncTasksResourceWithStreamingResponse,
 )
 from .health import (
     HealthResource,
@@ -18,12 +26,18 @@ from .health import (
 )
 
 __all__ = [
-    "TaskResource",
-    "AsyncTaskResource",
-    "TaskResourceWithRawResponse",
-    "AsyncTaskResourceWithRawResponse",
-    "TaskResourceWithStreamingResponse",
-    "AsyncTaskResourceWithStreamingResponse",
+    "TasksResource",
+    "AsyncTasksResource",
+    "TasksResourceWithRawResponse",
+    "AsyncTasksResourceWithRawResponse",
+    "TasksResourceWithStreamingResponse",
+    "AsyncTasksResourceWithStreamingResponse",
+    "FilesResource",
+    "AsyncFilesResource",
+    "FilesResourceWithRawResponse",
+    "AsyncFilesResourceWithRawResponse",
+    "FilesResourceWithStreamingResponse",
+    "AsyncFilesResourceWithStreamingResponse",
     "HealthResource",
     "AsyncHealthResource",
     "HealthResourceWithRawResponse",