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

chunkr_ai/resources/{task → tasks}/__init__.py

@@ -1,13 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from .task import (
-    TaskResource,
-    AsyncTaskResource,
-    TaskResourceWithRawResponse,
-    AsyncTaskResourceWithRawResponse,
-    TaskResourceWithStreamingResponse,
-    AsyncTaskResourceWithStreamingResponse,
-)
 from .parse import (
     ParseResource,
     AsyncParseResource,
@@ -16,6 +8,14 @@ from .parse import (
     ParseResourceWithStreamingResponse,
     AsyncParseResourceWithStreamingResponse,
 )
+from .tasks import (
+    TasksResource,
+    AsyncTasksResource,
+    TasksResourceWithRawResponse,
+    AsyncTasksResourceWithRawResponse,
+    TasksResourceWithStreamingResponse,
+    AsyncTasksResourceWithStreamingResponse,
+)
 
 __all__ = [
     "ParseResource",
@@ -24,10 +24,10 @@ __all__ = [
     "AsyncParseResourceWithRawResponse",
     "ParseResourceWithStreamingResponse",
     "AsyncParseResourceWithStreamingResponse",
-    "TaskResource",
-    "AsyncTaskResource",
-    "TaskResourceWithRawResponse",
-    "AsyncTaskResourceWithRawResponse",
-    "TaskResourceWithStreamingResponse",
-    "AsyncTaskResourceWithStreamingResponse",
+    "TasksResource",
+    "AsyncTasksResource",
+    "TasksResourceWithRawResponse",
+    "AsyncTasksResourceWithRawResponse",
+    "TasksResourceWithStreamingResponse",
+    "AsyncTasksResourceWithStreamingResponse",
 ]

chunkr_ai/resources/{task → tasks}/parse.py

@@ -17,9 +17,9 @@ from ..._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from ...types.task import parse_create_params, parse_update_params
+from ...types.task import Task
+from ...types.tasks import parse_create_params, parse_update_params
 from ..._base_client import make_request_options
-from ...types.task.task import Task
 
 __all__ = ["ParseResource", "AsyncParseResource"]
 
@@ -75,10 +75,16 @@ class ParseResource(SyncAPIResource):
         - Presigned URLs for file access
 
         The returned task will typically be in a `Starting` or `Processing` state. Use
-        the `GET /task/{task_id}` endpoint to poll for completion.
+        the `GET /tasks/{task_id}` endpoint to poll for completion.
 
         Args:
-          file: The file to be uploaded. Can be a URL or a base64 encoded file.
+          file:
+              The file to be uploaded. Supported inputs:
+
+              - `ch://files/{file_id}`: References a previously uploaded file you own
+                (authorization enforced)
+              - `http(s)://...`: Remote URL to fetch
+              - `data:*;base64,...` or raw base64 string
 
           chunk_processing: Controls the setting for the chunking and post-processing of each chunk.
 
@@ -113,18 +119,14 @@ class ParseResource(SyncAPIResource):
               content is produced (rule-based vs. LLM). • The output format (`Html` or
               `Markdown`).
 
-              Optional flags such as image **cropping**, **extended context**, and **LLM
-              descriptions** further refine behaviour.
-
-              ---
+              Optional flags such as image **cropping**, **extended context**, and
+              **descriptions** further refine behaviour.
 
               **Default strategy per segment** • `Title`, `SectionHeader`, `Text`, `ListItem`,
-              `Caption`, `Footnote` → **Auto** (Markdown) • `Table` → **LLM** (HTML,
-              description on) • `Picture` → **LLM** (Markdown, description off, cropping
-              _All_) • `Formula`, `Page` → **LLM** (Markdown) • `PageHeader`, `PageFooter` →
-              **Ignore** (removed from output)
-
-              ---
+              `Caption`, `Footnote` → **Auto** (Markdown, description off) • `Table` → **LLM**
+              (HTML, description on) • `Picture` → **LLM** (Markdown, description off,
+              cropping _All_) • `Formula`, `Page` → **LLM** (Markdown, description off) •
+              `PageHeader`, `PageFooter` → **Ignore** (removed from output)
 
               **Strategy reference** • **Auto** – rule-based content generation. • **LLM** –
               generate content with an LLM. • **Ignore** – exclude the segment entirely.
@@ -147,7 +149,7 @@ class ParseResource(SyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return self._post(
-            "/task/parse",
+            "/tasks/parse",
             body=maybe_transform(
                 {
                     "file": file,
@@ -201,7 +203,7 @@ class ParseResource(SyncAPIResource):
         - New configuration must be different from the current one
 
         The returned task will typically be in a `Starting` or `Processing` state. Use
-        the `GET /task/{task_id}` endpoint to poll for completion.
+        the `GET /tasks/{task_id}` endpoint to poll for completion.
 
         Args:
           chunk_processing: Controls the setting for the chunking and post-processing of each chunk.
@@ -238,18 +240,14 @@ class ParseResource(SyncAPIResource):
               content is produced (rule-based vs. LLM). • The output format (`Html` or
               `Markdown`).
 
-              Optional flags such as image **cropping**, **extended context**, and **LLM
-              descriptions** further refine behaviour.
-
-              ---
+              Optional flags such as image **cropping**, **extended context**, and
+              **descriptions** further refine behaviour.
 
               **Default strategy per segment** • `Title`, `SectionHeader`, `Text`, `ListItem`,
-              `Caption`, `Footnote` → **Auto** (Markdown) • `Table` → **LLM** (HTML,
-              description on) • `Picture` → **LLM** (Markdown, description off, cropping
-              _All_) • `Formula`, `Page` → **LLM** (Markdown) • `PageHeader`, `PageFooter` →
-              **Ignore** (removed from output)
-
-              ---
+              `Caption`, `Footnote` → **Auto** (Markdown, description off) • `Table` → **LLM**
+              (HTML, description on) • `Picture` → **LLM** (Markdown, description off,
+              cropping _All_) • `Formula`, `Page` → **LLM** (Markdown, description off) •
+              `PageHeader`, `PageFooter` → **Ignore** (removed from output)
 
               **Strategy reference** • **Auto** – rule-based content generation. • **LLM** –
               generate content with an LLM. • **Ignore** – exclude the segment entirely.
@@ -274,7 +272,7 @@ class ParseResource(SyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return self._patch(
-            f"/task/{task_id}/parse",
+            f"/tasks/parse/{task_id}",
             body=maybe_transform(
                 {
                     "chunk_processing": chunk_processing,
@@ -347,10 +345,16 @@ class AsyncParseResource(AsyncAPIResource):
         - Presigned URLs for file access
 
         The returned task will typically be in a `Starting` or `Processing` state. Use
-        the `GET /task/{task_id}` endpoint to poll for completion.
+        the `GET /tasks/{task_id}` endpoint to poll for completion.
 
         Args:
-          file: The file to be uploaded. Can be a URL or a base64 encoded file.
+          file:
+              The file to be uploaded. Supported inputs:
+
+              - `ch://files/{file_id}`: References a previously uploaded file you own
+                (authorization enforced)
+              - `http(s)://...`: Remote URL to fetch
+              - `data:*;base64,...` or raw base64 string
 
           chunk_processing: Controls the setting for the chunking and post-processing of each chunk.
 
@@ -385,18 +389,14 @@ class AsyncParseResource(AsyncAPIResource):
               content is produced (rule-based vs. LLM). • The output format (`Html` or
               `Markdown`).
 
-              Optional flags such as image **cropping**, **extended context**, and **LLM
-              descriptions** further refine behaviour.
-
-              ---
+              Optional flags such as image **cropping**, **extended context**, and
+              **descriptions** further refine behaviour.
 
               **Default strategy per segment** • `Title`, `SectionHeader`, `Text`, `ListItem`,
-              `Caption`, `Footnote` → **Auto** (Markdown) • `Table` → **LLM** (HTML,
-              description on) • `Picture` → **LLM** (Markdown, description off, cropping
-              _All_) • `Formula`, `Page` → **LLM** (Markdown) • `PageHeader`, `PageFooter` →
-              **Ignore** (removed from output)
-
-              ---
+              `Caption`, `Footnote` → **Auto** (Markdown, description off) • `Table` → **LLM**
+              (HTML, description on) • `Picture` → **LLM** (Markdown, description off,
+              cropping _All_) • `Formula`, `Page` → **LLM** (Markdown, description off) •
+              `PageHeader`, `PageFooter` → **Ignore** (removed from output)
 
               **Strategy reference** • **Auto** – rule-based content generation. • **LLM** –
               generate content with an LLM. • **Ignore** – exclude the segment entirely.
@@ -419,7 +419,7 @@ class AsyncParseResource(AsyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return await self._post(
-            "/task/parse",
+            "/tasks/parse",
             body=await async_maybe_transform(
                 {
                     "file": file,
@@ -473,7 +473,7 @@ class AsyncParseResource(AsyncAPIResource):
         - New configuration must be different from the current one
 
         The returned task will typically be in a `Starting` or `Processing` state. Use
-        the `GET /task/{task_id}` endpoint to poll for completion.
+        the `GET /tasks/{task_id}` endpoint to poll for completion.
 
         Args:
           chunk_processing: Controls the setting for the chunking and post-processing of each chunk.
@@ -510,18 +510,14 @@ class AsyncParseResource(AsyncAPIResource):
               content is produced (rule-based vs. LLM). • The output format (`Html` or
               `Markdown`).
 
-              Optional flags such as image **cropping**, **extended context**, and **LLM
-              descriptions** further refine behaviour.
-
-              ---
+              Optional flags such as image **cropping**, **extended context**, and
+              **descriptions** further refine behaviour.
 
               **Default strategy per segment** • `Title`, `SectionHeader`, `Text`, `ListItem`,
-              `Caption`, `Footnote` → **Auto** (Markdown) • `Table` → **LLM** (HTML,
-              description on) • `Picture` → **LLM** (Markdown, description off, cropping
-              _All_) • `Formula`, `Page` → **LLM** (Markdown) • `PageHeader`, `PageFooter` →
-              **Ignore** (removed from output)
-
-              ---
+              `Caption`, `Footnote` → **Auto** (Markdown, description off) • `Table` → **LLM**
+              (HTML, description on) • `Picture` → **LLM** (Markdown, description off,
+              cropping _All_) • `Formula`, `Page` → **LLM** (Markdown, description off) •
+              `PageHeader`, `PageFooter` → **Ignore** (removed from output)
 
               **Strategy reference** • **Auto** – rule-based content generation. • **LLM** –
               generate content with an LLM. • **Ignore** – exclude the segment entirely.
@@ -546,7 +542,7 @@ class AsyncParseResource(AsyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return await self._patch(
-            f"/task/{task_id}/parse",
+            f"/tasks/parse/{task_id}",
             body=await async_maybe_transform(
                 {
                     "chunk_processing": chunk_processing,

chunkr_ai/resources/{task/task.py → tasks/tasks.py}

@@ -28,35 +28,35 @@ from ..._response import (
     async_to_streamed_response_wrapper,
 )
 from ...pagination import SyncTasksPage, AsyncTasksPage
+from ...types.task import Task
 from ..._base_client import AsyncPaginator, make_request_options
-from ...types.task.task import Task
 
-__all__ = ["TaskResource", "AsyncTaskResource"]
+__all__ = ["TasksResource", "AsyncTasksResource"]
 
 
-class TaskResource(SyncAPIResource):
+class TasksResource(SyncAPIResource):
     @cached_property
     def parse(self) -> ParseResource:
         return ParseResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> TaskResourceWithRawResponse:
+    def with_raw_response(self) -> TasksResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/lumina-ai-inc/chunkr-python#accessing-raw-response-data-eg-headers
         """
-        return TaskResourceWithRawResponse(self)
+        return TasksResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> TaskResourceWithStreamingResponse:
+    def with_streaming_response(self) -> TasksResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/lumina-ai-inc/chunkr-python#with_streaming_response
         """
-        return TaskResourceWithStreamingResponse(self)
+        return TasksResourceWithStreamingResponse(self)
 
     def list(
         self,
@@ -75,44 +75,10 @@ class TaskResource(SyncAPIResource):
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> SyncTasksPage[Task]:
-        """Retrieves a list of tasks with cursor-based pagination.
-
-        By default, tasks are
-        returned in descending order (newest first).
-
-        ## Default Behaviors:
-
-        - **limit**: Returns all tasks if not specified
-        - **start**: No start date filter (returns from beginning of time)
-        - **end**: No end date filter (returns up to current time)
-        - **cursor**: Starts from most recent tasks (no pagination offset)
-        - **sort**: 'desc' (descending order, newest first)
-        - **include_chunks**: false (excludes chunks for better performance)
-        - **base64_urls**: false (returns presigned URLs instead of base64)
-
-        ## Common Usage Patterns:
-
-        **Basic usage (get all tasks):** `GET /api/v1/tasks`
-
-        **Get first 10 tasks:** `GET /api/v1/tasks?limit=10`
-
-        **Paginate through results:**
-
-        1. First request: `GET /api/v1/tasks?limit=10`
-        2. Use next_cursor from response for subsequent pages:
-           `GET /api/v1/tasks?limit=10&cursor=<timestamp>`
-
-        **Filter by date range:**
-        `GET /api/v1/tasks?start=2025-01-01T00:00:00Z&end=2025-12-31T23:59:59Z`
-
-        **Get detailed results with chunks:** `GET /api/v1/tasks?include_chunks=true`
-
-        **Get base64 encoded content:** `GET /api/v1/tasks?base64_urls=true`
-
-        **Get tasks in ascending order (oldest first):** `GET /api/v1/tasks?sort=asc`
-
-        **Get tasks in descending order (newest first, default):**
-        `GET /api/v1/tasks?sort=desc`
+        """
+        Lists tasks for the authenticated user with cursor-based pagination and optional
+        filtering by date range. Supports ascending or descending sort order and
+        optional inclusion of chunks/base64 URLs.
 
         Args:
           base64_urls: Whether to return base64 encoded URLs. If false, the URLs will be returned as
@@ -193,7 +159,7 @@ class TaskResource(SyncAPIResource):
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/task/{task_id}",
+            f"/tasks/{task_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -234,7 +200,7 @@ class TaskResource(SyncAPIResource):
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._get(
-            f"/task/{task_id}/cancel",
+            f"/tasks/{task_id}/cancel",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -287,7 +253,7 @@ class TaskResource(SyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return self._get(
-            f"/task/{task_id}",
+            f"/tasks/{task_id}",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -305,29 +271,29 @@ class TaskResource(SyncAPIResource):
         )
 
 
-class AsyncTaskResource(AsyncAPIResource):
+class AsyncTasksResource(AsyncAPIResource):
     @cached_property
     def parse(self) -> AsyncParseResource:
         return AsyncParseResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> AsyncTaskResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncTasksResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/lumina-ai-inc/chunkr-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncTaskResourceWithRawResponse(self)
+        return AsyncTasksResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncTaskResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncTasksResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/lumina-ai-inc/chunkr-python#with_streaming_response
         """
-        return AsyncTaskResourceWithStreamingResponse(self)
+        return AsyncTasksResourceWithStreamingResponse(self)
 
     def list(
         self,
@@ -346,44 +312,10 @@ class AsyncTaskResource(AsyncAPIResource):
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> AsyncPaginator[Task, AsyncTasksPage[Task]]:
-        """Retrieves a list of tasks with cursor-based pagination.
-
-        By default, tasks are
-        returned in descending order (newest first).
-
-        ## Default Behaviors:
-
-        - **limit**: Returns all tasks if not specified
-        - **start**: No start date filter (returns from beginning of time)
-        - **end**: No end date filter (returns up to current time)
-        - **cursor**: Starts from most recent tasks (no pagination offset)
-        - **sort**: 'desc' (descending order, newest first)
-        - **include_chunks**: false (excludes chunks for better performance)
-        - **base64_urls**: false (returns presigned URLs instead of base64)
-
-        ## Common Usage Patterns:
-
-        **Basic usage (get all tasks):** `GET /api/v1/tasks`
-
-        **Get first 10 tasks:** `GET /api/v1/tasks?limit=10`
-
-        **Paginate through results:**
-
-        1. First request: `GET /api/v1/tasks?limit=10`
-        2. Use next_cursor from response for subsequent pages:
-           `GET /api/v1/tasks?limit=10&cursor=<timestamp>`
-
-        **Filter by date range:**
-        `GET /api/v1/tasks?start=2025-01-01T00:00:00Z&end=2025-12-31T23:59:59Z`
-
-        **Get detailed results with chunks:** `GET /api/v1/tasks?include_chunks=true`
-
-        **Get base64 encoded content:** `GET /api/v1/tasks?base64_urls=true`
-
-        **Get tasks in ascending order (oldest first):** `GET /api/v1/tasks?sort=asc`
-
-        **Get tasks in descending order (newest first, default):**
-        `GET /api/v1/tasks?sort=desc`
+        """
+        Lists tasks for the authenticated user with cursor-based pagination and optional
+        filtering by date range. Supports ascending or descending sort order and
+        optional inclusion of chunks/base64 URLs.
 
         Args:
           base64_urls: Whether to return base64 encoded URLs. If false, the URLs will be returned as
@@ -464,7 +396,7 @@ class AsyncTaskResource(AsyncAPIResource):
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/task/{task_id}",
+            f"/tasks/{task_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -505,7 +437,7 @@ class AsyncTaskResource(AsyncAPIResource):
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._get(
-            f"/task/{task_id}/cancel",
+            f"/tasks/{task_id}/cancel",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -558,7 +490,7 @@ class AsyncTaskResource(AsyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return await self._get(
-            f"/task/{task_id}",
+            f"/tasks/{task_id}",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -576,89 +508,89 @@ class AsyncTaskResource(AsyncAPIResource):
         )
 
 
-class TaskResourceWithRawResponse:
-    def __init__(self, task: TaskResource) -> None:
-        self._task = task
+class TasksResourceWithRawResponse:
+    def __init__(self, tasks: TasksResource) -> None:
+        self._tasks = tasks
 
         self.list = to_raw_response_wrapper(
-            task.list,
+            tasks.list,
         )
         self.delete = to_raw_response_wrapper(
-            task.delete,
+            tasks.delete,
         )
         self.cancel = to_raw_response_wrapper(
-            task.cancel,
+            tasks.cancel,
         )
         self.get = to_raw_response_wrapper(
-            task.get,
+            tasks.get,
         )
 
     @cached_property
     def parse(self) -> ParseResourceWithRawResponse:
-        return ParseResourceWithRawResponse(self._task.parse)
+        return ParseResourceWithRawResponse(self._tasks.parse)
 
 
-class AsyncTaskResourceWithRawResponse:
-    def __init__(self, task: AsyncTaskResource) -> None:
-        self._task = task
+class AsyncTasksResourceWithRawResponse:
+    def __init__(self, tasks: AsyncTasksResource) -> None:
+        self._tasks = tasks
 
         self.list = async_to_raw_response_wrapper(
-            task.list,
+            tasks.list,
         )
         self.delete = async_to_raw_response_wrapper(
-            task.delete,
+            tasks.delete,
         )
         self.cancel = async_to_raw_response_wrapper(
-            task.cancel,
+            tasks.cancel,
         )
         self.get = async_to_raw_response_wrapper(
-            task.get,
+            tasks.get,
         )
 
     @cached_property
     def parse(self) -> AsyncParseResourceWithRawResponse:
-        return AsyncParseResourceWithRawResponse(self._task.parse)
+        return AsyncParseResourceWithRawResponse(self._tasks.parse)
 
 
-class TaskResourceWithStreamingResponse:
-    def __init__(self, task: TaskResource) -> None:
-        self._task = task
+class TasksResourceWithStreamingResponse:
+    def __init__(self, tasks: TasksResource) -> None:
+        self._tasks = tasks
 
         self.list = to_streamed_response_wrapper(
-            task.list,
+            tasks.list,
         )
         self.delete = to_streamed_response_wrapper(
-            task.delete,
+            tasks.delete,
         )
         self.cancel = to_streamed_response_wrapper(
-            task.cancel,
+            tasks.cancel,
         )
         self.get = to_streamed_response_wrapper(
-            task.get,
+            tasks.get,
         )
 
     @cached_property
     def parse(self) -> ParseResourceWithStreamingResponse:
-        return ParseResourceWithStreamingResponse(self._task.parse)
+        return ParseResourceWithStreamingResponse(self._tasks.parse)
 
 
-class AsyncTaskResourceWithStreamingResponse:
-    def __init__(self, task: AsyncTaskResource) -> None:
-        self._task = task
+class AsyncTasksResourceWithStreamingResponse:
+    def __init__(self, tasks: AsyncTasksResource) -> None:
+        self._tasks = tasks
 
         self.list = async_to_streamed_response_wrapper(
-            task.list,
+            tasks.list,
         )
         self.delete = async_to_streamed_response_wrapper(
-            task.delete,
+            tasks.delete,
         )
         self.cancel = async_to_streamed_response_wrapper(
-            task.cancel,
+            tasks.cancel,
         )
         self.get = async_to_streamed_response_wrapper(
-            task.get,
+            tasks.get,
         )
 
     @cached_property
     def parse(self) -> AsyncParseResourceWithStreamingResponse:
-        return AsyncParseResourceWithStreamingResponse(self._task.parse)
+        return AsyncParseResourceWithStreamingResponse(self._tasks.parse)

chunkr_ai/types/__init__.py

@@ -2,7 +2,14 @@
 
 from __future__ import annotations
 
+from .file import File as File
 from .task import Task as Task
+from .delete import Delete as Delete
+from .file_url import FileURL as FileURL
+from .file_url_params import FileURLParams as FileURLParams
 from .task_get_params import TaskGetParams as TaskGetParams
+from .file_list_params import FileListParams as FileListParams
 from .task_list_params import TaskListParams as TaskListParams
+from .file_create_params import FileCreateParams as FileCreateParams
+from .files_list_response import FilesListResponse as FilesListResponse
 from .health_check_response import HealthCheckResponse as HealthCheckResponse

chunkr_ai/types/delete.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["Delete"]
+
+
+class Delete(BaseModel):
+    deleted: bool
+    """Whether the file was deleted"""

chunkr_ai/types/file.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["File"]
+
+
+class File(BaseModel):
+    content_type: str
+    """MIME type detected or provided for the file."""
+
+    created_at: datetime
+    """Timestamp when the file was created."""
+
+    file_id: str
+    """Unique identifier for the file."""
+
+    file_name: str
+    """The original filename supplied by the client."""
+
+    file_size: int
+    """Size of the stored file in bytes."""
+
+    metadata: object
+    """Arbitrary JSON metadata associated with the file."""
+
+    url: str
+    """Permanent Chunkr URL. Use directly with other chunkr API requests."""

chunkr_ai/types/file_create_params.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from .._types import FileTypes
+
+__all__ = ["FileCreateParams"]
+
+
+class FileCreateParams(TypedDict, total=False):
+    file: Required[FileTypes]
+    """The file to upload"""
+
+    file_metadata: Required[str]
+    """Arbitrary JSON metadata associated with the file."""