llama-cloud 0.1.41__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

llama_cloud/resources/beta/batch/job_items.py

@@ -0,0 +1,348 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ....pagination import SyncPaginatedBatchItems, AsyncPaginatedBatchItems
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.batch import job_item_list_params, job_item_get_processing_results_params
+from ....types.beta.batch.job_item_list_response import JobItemListResponse
+from ....types.beta.batch.job_item_get_processing_results_response import JobItemGetProcessingResultsResponse
+
+__all__ = ["JobItemsResource", "AsyncJobItemsResource"]
+
+
+class JobItemsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> JobItemsResourceWithRawResponse:
+        """
+        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/run-llama/llama-cloud-py#accessing-raw-response-data-eg-headers
+        """
+        return JobItemsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> JobItemsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/run-llama/llama-cloud-py#with_streaming_response
+        """
+        return JobItemsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        job_id: str,
+        *,
+        limit: int | Omit = omit,
+        offset: int | Omit = omit,
+        organization_id: Optional[str] | Omit = omit,
+        project_id: Optional[str] | Omit = omit,
+        status: Optional[Literal["pending", "processing", "completed", "failed", "skipped", "cancelled"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPaginatedBatchItems[JobItemListResponse]:
+        """
+        List items in a batch job with optional status filtering.
+
+        Useful for finding failed items, viewing completed items, or debugging issues.
+        Results are paginated for performance with configurable limit and offset
+        parameters.
+
+        Args:
+          limit: Maximum number of items to return
+
+          offset: Number of items to skip
+
+          status: Status of an individual file in a batch job.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return self._get_api_list(
+            f"/api/v1/beta/batch-processing/{job_id}/items",
+            page=SyncPaginatedBatchItems[JobItemListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "offset": offset,
+                        "organization_id": organization_id,
+                        "project_id": project_id,
+                        "status": status,
+                    },
+                    job_item_list_params.JobItemListParams,
+                ),
+            ),
+            model=JobItemListResponse,
+        )
+
+    def get_processing_results(
+        self,
+        item_id: str,
+        *,
+        job_type: Optional[Literal["parse", "extract", "classify"]] | Omit = omit,
+        organization_id: Optional[str] | Omit = omit,
+        project_id: Optional[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> JobItemGetProcessingResultsResponse:
+        """
+        Get all processing results for a specific item (lineage query).
+
+        Shows complete processing history including what operations have been performed,
+        with what parameters, and where outputs are stored. Useful for understanding
+        what processing has already been done to avoid redundant work. Optionally filter
+        by job type to see only specific processing operations.
+
+        Args:
+          job_type: Type of batch processing operation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not item_id:
+            raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}")
+        return self._get(
+            f"/api/v1/beta/batch-processing/items/{item_id}/processing-results",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "job_type": job_type,
+                        "organization_id": organization_id,
+                        "project_id": project_id,
+                    },
+                    job_item_get_processing_results_params.JobItemGetProcessingResultsParams,
+                ),
+            ),
+            cast_to=JobItemGetProcessingResultsResponse,
+        )
+
+
+class AsyncJobItemsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncJobItemsResourceWithRawResponse:
+        """
+        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/run-llama/llama-cloud-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncJobItemsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncJobItemsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/run-llama/llama-cloud-py#with_streaming_response
+        """
+        return AsyncJobItemsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        job_id: str,
+        *,
+        limit: int | Omit = omit,
+        offset: int | Omit = omit,
+        organization_id: Optional[str] | Omit = omit,
+        project_id: Optional[str] | Omit = omit,
+        status: Optional[Literal["pending", "processing", "completed", "failed", "skipped", "cancelled"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[JobItemListResponse, AsyncPaginatedBatchItems[JobItemListResponse]]:
+        """
+        List items in a batch job with optional status filtering.
+
+        Useful for finding failed items, viewing completed items, or debugging issues.
+        Results are paginated for performance with configurable limit and offset
+        parameters.
+
+        Args:
+          limit: Maximum number of items to return
+
+          offset: Number of items to skip
+
+          status: Status of an individual file in a batch job.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return self._get_api_list(
+            f"/api/v1/beta/batch-processing/{job_id}/items",
+            page=AsyncPaginatedBatchItems[JobItemListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "offset": offset,
+                        "organization_id": organization_id,
+                        "project_id": project_id,
+                        "status": status,
+                    },
+                    job_item_list_params.JobItemListParams,
+                ),
+            ),
+            model=JobItemListResponse,
+        )
+
+    async def get_processing_results(
+        self,
+        item_id: str,
+        *,
+        job_type: Optional[Literal["parse", "extract", "classify"]] | Omit = omit,
+        organization_id: Optional[str] | Omit = omit,
+        project_id: Optional[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> JobItemGetProcessingResultsResponse:
+        """
+        Get all processing results for a specific item (lineage query).
+
+        Shows complete processing history including what operations have been performed,
+        with what parameters, and where outputs are stored. Useful for understanding
+        what processing has already been done to avoid redundant work. Optionally filter
+        by job type to see only specific processing operations.
+
+        Args:
+          job_type: Type of batch processing operation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not item_id:
+            raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}")
+        return await self._get(
+            f"/api/v1/beta/batch-processing/items/{item_id}/processing-results",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "job_type": job_type,
+                        "organization_id": organization_id,
+                        "project_id": project_id,
+                    },
+                    job_item_get_processing_results_params.JobItemGetProcessingResultsParams,
+                ),
+            ),
+            cast_to=JobItemGetProcessingResultsResponse,
+        )
+
+
+class JobItemsResourceWithRawResponse:
+    def __init__(self, job_items: JobItemsResource) -> None:
+        self._job_items = job_items
+
+        self.list = to_raw_response_wrapper(
+            job_items.list,
+        )
+        self.get_processing_results = to_raw_response_wrapper(
+            job_items.get_processing_results,
+        )
+
+
+class AsyncJobItemsResourceWithRawResponse:
+    def __init__(self, job_items: AsyncJobItemsResource) -> None:
+        self._job_items = job_items
+
+        self.list = async_to_raw_response_wrapper(
+            job_items.list,
+        )
+        self.get_processing_results = async_to_raw_response_wrapper(
+            job_items.get_processing_results,
+        )
+
+
+class JobItemsResourceWithStreamingResponse:
+    def __init__(self, job_items: JobItemsResource) -> None:
+        self._job_items = job_items
+
+        self.list = to_streamed_response_wrapper(
+            job_items.list,
+        )
+        self.get_processing_results = to_streamed_response_wrapper(
+            job_items.get_processing_results,
+        )
+
+
+class AsyncJobItemsResourceWithStreamingResponse:
+    def __init__(self, job_items: AsyncJobItemsResource) -> None:
+        self._job_items = job_items
+
+        self.list = async_to_streamed_response_wrapper(
+            job_items.list,
+        )
+        self.get_processing_results = async_to_streamed_response_wrapper(
+            job_items.get_processing_results,
+        )

llama_cloud/resources/beta/beta.py

@@ -0,0 +1,262 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .split import (
+    SplitResource,
+    AsyncSplitResource,
+    SplitResourceWithRawResponse,
+    AsyncSplitResourceWithRawResponse,
+    SplitResourceWithStreamingResponse,
+    AsyncSplitResourceWithStreamingResponse,
+)
+from .sheets import (
+    SheetsResource,
+    AsyncSheetsResource,
+    SheetsResourceWithRawResponse,
+    AsyncSheetsResourceWithRawResponse,
+    SheetsResourceWithStreamingResponse,
+    AsyncSheetsResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from .agent_data import (
+    AgentDataResource,
+    AsyncAgentDataResource,
+    AgentDataResourceWithRawResponse,
+    AsyncAgentDataResourceWithRawResponse,
+    AgentDataResourceWithStreamingResponse,
+    AsyncAgentDataResourceWithStreamingResponse,
+)
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .batch.batch import (
+    BatchResource,
+    AsyncBatchResource,
+    BatchResourceWithRawResponse,
+    AsyncBatchResourceWithRawResponse,
+    BatchResourceWithStreamingResponse,
+    AsyncBatchResourceWithStreamingResponse,
+)
+from .parse_configurations import (
+    ParseConfigurationsResource,
+    AsyncParseConfigurationsResource,
+    ParseConfigurationsResourceWithRawResponse,
+    AsyncParseConfigurationsResourceWithRawResponse,
+    ParseConfigurationsResourceWithStreamingResponse,
+    AsyncParseConfigurationsResourceWithStreamingResponse,
+)
+from .directories.directories import (
+    DirectoriesResource,
+    AsyncDirectoriesResource,
+    DirectoriesResourceWithRawResponse,
+    AsyncDirectoriesResourceWithRawResponse,
+    DirectoriesResourceWithStreamingResponse,
+    AsyncDirectoriesResourceWithStreamingResponse,
+)
+
+__all__ = ["BetaResource", "AsyncBetaResource"]
+
+
+class BetaResource(SyncAPIResource):
+    @cached_property
+    def agent_data(self) -> AgentDataResource:
+        return AgentDataResource(self._client)
+
+    @cached_property
+    def parse_configurations(self) -> ParseConfigurationsResource:
+        return ParseConfigurationsResource(self._client)
+
+    @cached_property
+    def sheets(self) -> SheetsResource:
+        return SheetsResource(self._client)
+
+    @cached_property
+    def directories(self) -> DirectoriesResource:
+        return DirectoriesResource(self._client)
+
+    @cached_property
+    def batch(self) -> BatchResource:
+        return BatchResource(self._client)
+
+    @cached_property
+    def split(self) -> SplitResource:
+        return SplitResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> BetaResourceWithRawResponse:
+        """
+        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/run-llama/llama-cloud-py#accessing-raw-response-data-eg-headers
+        """
+        return BetaResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BetaResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/run-llama/llama-cloud-py#with_streaming_response
+        """
+        return BetaResourceWithStreamingResponse(self)
+
+
+class AsyncBetaResource(AsyncAPIResource):
+    @cached_property
+    def agent_data(self) -> AsyncAgentDataResource:
+        return AsyncAgentDataResource(self._client)
+
+    @cached_property
+    def parse_configurations(self) -> AsyncParseConfigurationsResource:
+        return AsyncParseConfigurationsResource(self._client)
+
+    @cached_property
+    def sheets(self) -> AsyncSheetsResource:
+        return AsyncSheetsResource(self._client)
+
+    @cached_property
+    def directories(self) -> AsyncDirectoriesResource:
+        return AsyncDirectoriesResource(self._client)
+
+    @cached_property
+    def batch(self) -> AsyncBatchResource:
+        return AsyncBatchResource(self._client)
+
+    @cached_property
+    def split(self) -> AsyncSplitResource:
+        return AsyncSplitResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBetaResourceWithRawResponse:
+        """
+        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/run-llama/llama-cloud-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBetaResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBetaResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/run-llama/llama-cloud-py#with_streaming_response
+        """
+        return AsyncBetaResourceWithStreamingResponse(self)
+
+
+class BetaResourceWithRawResponse:
+    def __init__(self, beta: BetaResource) -> None:
+        self._beta = beta
+
+    @cached_property
+    def agent_data(self) -> AgentDataResourceWithRawResponse:
+        return AgentDataResourceWithRawResponse(self._beta.agent_data)
+
+    @cached_property
+    def parse_configurations(self) -> ParseConfigurationsResourceWithRawResponse:
+        return ParseConfigurationsResourceWithRawResponse(self._beta.parse_configurations)
+
+    @cached_property
+    def sheets(self) -> SheetsResourceWithRawResponse:
+        return SheetsResourceWithRawResponse(self._beta.sheets)
+
+    @cached_property
+    def directories(self) -> DirectoriesResourceWithRawResponse:
+        return DirectoriesResourceWithRawResponse(self._beta.directories)
+
+    @cached_property
+    def batch(self) -> BatchResourceWithRawResponse:
+        return BatchResourceWithRawResponse(self._beta.batch)
+
+    @cached_property
+    def split(self) -> SplitResourceWithRawResponse:
+        return SplitResourceWithRawResponse(self._beta.split)
+
+
+class AsyncBetaResourceWithRawResponse:
+    def __init__(self, beta: AsyncBetaResource) -> None:
+        self._beta = beta
+
+    @cached_property
+    def agent_data(self) -> AsyncAgentDataResourceWithRawResponse:
+        return AsyncAgentDataResourceWithRawResponse(self._beta.agent_data)
+
+    @cached_property
+    def parse_configurations(self) -> AsyncParseConfigurationsResourceWithRawResponse:
+        return AsyncParseConfigurationsResourceWithRawResponse(self._beta.parse_configurations)
+
+    @cached_property
+    def sheets(self) -> AsyncSheetsResourceWithRawResponse:
+        return AsyncSheetsResourceWithRawResponse(self._beta.sheets)
+
+    @cached_property
+    def directories(self) -> AsyncDirectoriesResourceWithRawResponse:
+        return AsyncDirectoriesResourceWithRawResponse(self._beta.directories)
+
+    @cached_property
+    def batch(self) -> AsyncBatchResourceWithRawResponse:
+        return AsyncBatchResourceWithRawResponse(self._beta.batch)
+
+    @cached_property
+    def split(self) -> AsyncSplitResourceWithRawResponse:
+        return AsyncSplitResourceWithRawResponse(self._beta.split)
+
+
+class BetaResourceWithStreamingResponse:
+    def __init__(self, beta: BetaResource) -> None:
+        self._beta = beta
+
+    @cached_property
+    def agent_data(self) -> AgentDataResourceWithStreamingResponse:
+        return AgentDataResourceWithStreamingResponse(self._beta.agent_data)
+
+    @cached_property
+    def parse_configurations(self) -> ParseConfigurationsResourceWithStreamingResponse:
+        return ParseConfigurationsResourceWithStreamingResponse(self._beta.parse_configurations)
+
+    @cached_property
+    def sheets(self) -> SheetsResourceWithStreamingResponse:
+        return SheetsResourceWithStreamingResponse(self._beta.sheets)
+
+    @cached_property
+    def directories(self) -> DirectoriesResourceWithStreamingResponse:
+        return DirectoriesResourceWithStreamingResponse(self._beta.directories)
+
+    @cached_property
+    def batch(self) -> BatchResourceWithStreamingResponse:
+        return BatchResourceWithStreamingResponse(self._beta.batch)
+
+    @cached_property
+    def split(self) -> SplitResourceWithStreamingResponse:
+        return SplitResourceWithStreamingResponse(self._beta.split)
+
+
+class AsyncBetaResourceWithStreamingResponse:
+    def __init__(self, beta: AsyncBetaResource) -> None:
+        self._beta = beta
+
+    @cached_property
+    def agent_data(self) -> AsyncAgentDataResourceWithStreamingResponse:
+        return AsyncAgentDataResourceWithStreamingResponse(self._beta.agent_data)
+
+    @cached_property
+    def parse_configurations(self) -> AsyncParseConfigurationsResourceWithStreamingResponse:
+        return AsyncParseConfigurationsResourceWithStreamingResponse(self._beta.parse_configurations)
+
+    @cached_property
+    def sheets(self) -> AsyncSheetsResourceWithStreamingResponse:
+        return AsyncSheetsResourceWithStreamingResponse(self._beta.sheets)
+
+    @cached_property
+    def directories(self) -> AsyncDirectoriesResourceWithStreamingResponse:
+        return AsyncDirectoriesResourceWithStreamingResponse(self._beta.directories)
+
+    @cached_property
+    def batch(self) -> AsyncBatchResourceWithStreamingResponse:
+        return AsyncBatchResourceWithStreamingResponse(self._beta.batch)
+
+    @cached_property
+    def split(self) -> AsyncSplitResourceWithStreamingResponse:
+        return AsyncSplitResourceWithStreamingResponse(self._beta.split)

llama_cloud/resources/beta/directories/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .files import (
+    FilesResource,
+    AsyncFilesResource,
+    FilesResourceWithRawResponse,
+    AsyncFilesResourceWithRawResponse,
+    FilesResourceWithStreamingResponse,
+    AsyncFilesResourceWithStreamingResponse,
+)
+from .directories import (
+    DirectoriesResource,
+    AsyncDirectoriesResource,
+    DirectoriesResourceWithRawResponse,
+    AsyncDirectoriesResourceWithRawResponse,
+    DirectoriesResourceWithStreamingResponse,
+    AsyncDirectoriesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "FilesResource",
+    "AsyncFilesResource",
+    "FilesResourceWithRawResponse",
+    "AsyncFilesResourceWithRawResponse",
+    "FilesResourceWithStreamingResponse",
+    "AsyncFilesResourceWithStreamingResponse",
+    "DirectoriesResource",
+    "AsyncDirectoriesResource",
+    "DirectoriesResourceWithRawResponse",
+    "AsyncDirectoriesResourceWithRawResponse",
+    "DirectoriesResourceWithStreamingResponse",
+    "AsyncDirectoriesResourceWithStreamingResponse",
+]