scale-gp-beta 0.1.0a5__py3-none-any.whl → 0.1.0a6__py3-none-any.whl

scale_gp_beta/_client.py

@@ -24,7 +24,7 @@ from ._utils import (
     get_async_library,
 )
 from ._version import __version__
-from .resources import models, datasets, inference, completions, evaluations
+from .resources import models, datasets, inference, completions, evaluations, dataset_items, evaluation_items
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, SGPClientError
 from ._base_client import (
@@ -61,6 +61,8 @@ class SGPClient(SyncAPIClient):
     models: models.ModelsResource
     datasets: datasets.DatasetsResource
     evaluations: evaluations.EvaluationsResource
+    dataset_items: dataset_items.DatasetItemsResource
+    evaluation_items: evaluation_items.EvaluationItemsResource
     with_raw_response: SGPClientWithRawResponse
     with_streaming_response: SGPClientWithStreamedResponse
 
@@ -161,6 +163,8 @@ class SGPClient(SyncAPIClient):
         self.models = models.ModelsResource(self)
         self.datasets = datasets.DatasetsResource(self)
         self.evaluations = evaluations.EvaluationsResource(self)
+        self.dataset_items = dataset_items.DatasetItemsResource(self)
+        self.evaluation_items = evaluation_items.EvaluationItemsResource(self)
         self.with_raw_response = SGPClientWithRawResponse(self)
         self.with_streaming_response = SGPClientWithStreamedResponse(self)
 
@@ -282,6 +286,8 @@ class AsyncSGPClient(AsyncAPIClient):
     models: models.AsyncModelsResource
     datasets: datasets.AsyncDatasetsResource
     evaluations: evaluations.AsyncEvaluationsResource
+    dataset_items: dataset_items.AsyncDatasetItemsResource
+    evaluation_items: evaluation_items.AsyncEvaluationItemsResource
     with_raw_response: AsyncSGPClientWithRawResponse
     with_streaming_response: AsyncSGPClientWithStreamedResponse
 
@@ -382,6 +388,8 @@ class AsyncSGPClient(AsyncAPIClient):
         self.models = models.AsyncModelsResource(self)
         self.datasets = datasets.AsyncDatasetsResource(self)
         self.evaluations = evaluations.AsyncEvaluationsResource(self)
+        self.dataset_items = dataset_items.AsyncDatasetItemsResource(self)
+        self.evaluation_items = evaluation_items.AsyncEvaluationItemsResource(self)
         self.with_raw_response = AsyncSGPClientWithRawResponse(self)
         self.with_streaming_response = AsyncSGPClientWithStreamedResponse(self)
 
@@ -504,6 +512,8 @@ class SGPClientWithRawResponse:
         self.models = models.ModelsResourceWithRawResponse(client.models)
         self.datasets = datasets.DatasetsResourceWithRawResponse(client.datasets)
         self.evaluations = evaluations.EvaluationsResourceWithRawResponse(client.evaluations)
+        self.dataset_items = dataset_items.DatasetItemsResourceWithRawResponse(client.dataset_items)
+        self.evaluation_items = evaluation_items.EvaluationItemsResourceWithRawResponse(client.evaluation_items)
 
 
 class AsyncSGPClientWithRawResponse:
@@ -515,6 +525,8 @@ class AsyncSGPClientWithRawResponse:
         self.models = models.AsyncModelsResourceWithRawResponse(client.models)
         self.datasets = datasets.AsyncDatasetsResourceWithRawResponse(client.datasets)
         self.evaluations = evaluations.AsyncEvaluationsResourceWithRawResponse(client.evaluations)
+        self.dataset_items = dataset_items.AsyncDatasetItemsResourceWithRawResponse(client.dataset_items)
+        self.evaluation_items = evaluation_items.AsyncEvaluationItemsResourceWithRawResponse(client.evaluation_items)
 
 
 class SGPClientWithStreamedResponse:
@@ -526,6 +538,8 @@ class SGPClientWithStreamedResponse:
         self.models = models.ModelsResourceWithStreamingResponse(client.models)
         self.datasets = datasets.DatasetsResourceWithStreamingResponse(client.datasets)
         self.evaluations = evaluations.EvaluationsResourceWithStreamingResponse(client.evaluations)
+        self.dataset_items = dataset_items.DatasetItemsResourceWithStreamingResponse(client.dataset_items)
+        self.evaluation_items = evaluation_items.EvaluationItemsResourceWithStreamingResponse(client.evaluation_items)
 
 
 class AsyncSGPClientWithStreamedResponse:
@@ -537,6 +551,10 @@ class AsyncSGPClientWithStreamedResponse:
         self.models = models.AsyncModelsResourceWithStreamingResponse(client.models)
         self.datasets = datasets.AsyncDatasetsResourceWithStreamingResponse(client.datasets)
         self.evaluations = evaluations.AsyncEvaluationsResourceWithStreamingResponse(client.evaluations)
+        self.dataset_items = dataset_items.AsyncDatasetItemsResourceWithStreamingResponse(client.dataset_items)
+        self.evaluation_items = evaluation_items.AsyncEvaluationItemsResourceWithStreamingResponse(
+            client.evaluation_items
+        )
 
 
 Client = SGPClient

scale_gp_beta/_version.py

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

scale_gp_beta/resources/__init__.py

@@ -56,6 +56,22 @@ from .evaluations import (
     EvaluationsResourceWithStreamingResponse,
     AsyncEvaluationsResourceWithStreamingResponse,
 )
+from .dataset_items import (
+    DatasetItemsResource,
+    AsyncDatasetItemsResource,
+    DatasetItemsResourceWithRawResponse,
+    AsyncDatasetItemsResourceWithRawResponse,
+    DatasetItemsResourceWithStreamingResponse,
+    AsyncDatasetItemsResourceWithStreamingResponse,
+)
+from .evaluation_items import (
+    EvaluationItemsResource,
+    AsyncEvaluationItemsResource,
+    EvaluationItemsResourceWithRawResponse,
+    AsyncEvaluationItemsResourceWithRawResponse,
+    EvaluationItemsResourceWithStreamingResponse,
+    AsyncEvaluationItemsResourceWithStreamingResponse,
+)
 
 __all__ = [
     "CompletionsResource",
@@ -100,4 +116,16 @@ __all__ = [
     "AsyncEvaluationsResourceWithRawResponse",
     "EvaluationsResourceWithStreamingResponse",
     "AsyncEvaluationsResourceWithStreamingResponse",
+    "DatasetItemsResource",
+    "AsyncDatasetItemsResource",
+    "DatasetItemsResourceWithRawResponse",
+    "AsyncDatasetItemsResourceWithRawResponse",
+    "DatasetItemsResourceWithStreamingResponse",
+    "AsyncDatasetItemsResourceWithStreamingResponse",
+    "EvaluationItemsResource",
+    "AsyncEvaluationItemsResource",
+    "EvaluationItemsResourceWithRawResponse",
+    "AsyncEvaluationItemsResourceWithRawResponse",
+    "EvaluationItemsResourceWithStreamingResponse",
+    "AsyncEvaluationItemsResourceWithStreamingResponse",
 ]

scale_gp_beta/resources/dataset_items.py

@@ -0,0 +1,586 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+
+import httpx
+
+from ..types import (
+    dataset_item_list_params,
+    dataset_item_update_params,
+    dataset_item_retrieve_params,
+    dataset_item_batch_create_params,
+)
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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 SyncCursorPage, AsyncCursorPage
+from .._base_client import AsyncPaginator, make_request_options
+from ..types.dataset_item import DatasetItem
+from ..types.dataset_item_delete_response import DatasetItemDeleteResponse
+from ..types.dataset_item_batch_create_response import DatasetItemBatchCreateResponse
+
+__all__ = ["DatasetItemsResource", "AsyncDatasetItemsResource"]
+
+
+class DatasetItemsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> DatasetItemsResourceWithRawResponse:
+        """
+        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/scaleapi/sgp-python-beta#accessing-raw-response-data-eg-headers
+        """
+        return DatasetItemsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DatasetItemsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/sgp-python-beta#with_streaming_response
+        """
+        return DatasetItemsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        dataset_item_id: str,
+        *,
+        version: Optional[int] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> DatasetItem:
+        """Get Dataset Item
+
+        Args:
+          version: Optional dataset version.
+
+        When unset, returns the latest version.
+
+          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 dataset_item_id:
+            raise ValueError(f"Expected a non-empty value for `dataset_item_id` but received {dataset_item_id!r}")
+        return self._get(
+            f"/v5/dataset-items/{dataset_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"version": version}, dataset_item_retrieve_params.DatasetItemRetrieveParams),
+            ),
+            cast_to=DatasetItem,
+        )
+
+    def update(
+        self,
+        dataset_item_id: str,
+        *,
+        data: Dict[str, object],
+        # 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,
+    ) -> DatasetItem:
+        """
+        Update Dataset Item
+
+        Args:
+          data: Updated dataset item data
+
+          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 dataset_item_id:
+            raise ValueError(f"Expected a non-empty value for `dataset_item_id` but received {dataset_item_id!r}")
+        return self._patch(
+            f"/v5/dataset-items/{dataset_item_id}",
+            body=maybe_transform({"data": data}, dataset_item_update_params.DatasetItemUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DatasetItem,
+        )
+
+    def list(
+        self,
+        *,
+        dataset_id: Optional[str] | NotGiven = NOT_GIVEN,
+        ending_before: Optional[str] | NotGiven = NOT_GIVEN,
+        include_archived: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        starting_after: Optional[str] | NotGiven = NOT_GIVEN,
+        version: Optional[int] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SyncCursorPage[DatasetItem]:
+        """List Dataset Items
+
+        Args:
+          dataset_id: Optional dataset identifier.
+
+        Must be provided if a specific version is
+              requested.
+
+          version: Optional dataset version. When unset, returns the latest version. Requires a
+              valid dataset_id when set.
+
+          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
+        """
+        return self._get_api_list(
+            "/v5/dataset-items",
+            page=SyncCursorPage[DatasetItem],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "dataset_id": dataset_id,
+                        "ending_before": ending_before,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "starting_after": starting_after,
+                        "version": version,
+                    },
+                    dataset_item_list_params.DatasetItemListParams,
+                ),
+            ),
+            model=DatasetItem,
+        )
+
+    def delete(
+        self,
+        dataset_item_id: str,
+        *,
+        # 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,
+    ) -> DatasetItemDeleteResponse:
+        """
+        Delete Dataset Item
+
+        Args:
+          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 dataset_item_id:
+            raise ValueError(f"Expected a non-empty value for `dataset_item_id` but received {dataset_item_id!r}")
+        return self._delete(
+            f"/v5/dataset-items/{dataset_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DatasetItemDeleteResponse,
+        )
+
+    def batch_create(
+        self,
+        *,
+        data: Iterable[Dict[str, object]],
+        dataset_id: str,
+        # 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,
+    ) -> DatasetItemBatchCreateResponse:
+        """
+        Batch Create Dataset Items
+
+        Args:
+          data: Items to be added to the dataset
+
+          dataset_id: Identifier of the target dataset
+
+          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
+        """
+        return self._post(
+            "/v5/dataset-items/batch",
+            body=maybe_transform(
+                {
+                    "data": data,
+                    "dataset_id": dataset_id,
+                },
+                dataset_item_batch_create_params.DatasetItemBatchCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DatasetItemBatchCreateResponse,
+        )
+
+
+class AsyncDatasetItemsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncDatasetItemsResourceWithRawResponse:
+        """
+        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/scaleapi/sgp-python-beta#accessing-raw-response-data-eg-headers
+        """
+        return AsyncDatasetItemsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDatasetItemsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/sgp-python-beta#with_streaming_response
+        """
+        return AsyncDatasetItemsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        dataset_item_id: str,
+        *,
+        version: Optional[int] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> DatasetItem:
+        """Get Dataset Item
+
+        Args:
+          version: Optional dataset version.
+
+        When unset, returns the latest version.
+
+          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 dataset_item_id:
+            raise ValueError(f"Expected a non-empty value for `dataset_item_id` but received {dataset_item_id!r}")
+        return await self._get(
+            f"/v5/dataset-items/{dataset_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"version": version}, dataset_item_retrieve_params.DatasetItemRetrieveParams
+                ),
+            ),
+            cast_to=DatasetItem,
+        )
+
+    async def update(
+        self,
+        dataset_item_id: str,
+        *,
+        data: Dict[str, object],
+        # 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,
+    ) -> DatasetItem:
+        """
+        Update Dataset Item
+
+        Args:
+          data: Updated dataset item data
+
+          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 dataset_item_id:
+            raise ValueError(f"Expected a non-empty value for `dataset_item_id` but received {dataset_item_id!r}")
+        return await self._patch(
+            f"/v5/dataset-items/{dataset_item_id}",
+            body=await async_maybe_transform({"data": data}, dataset_item_update_params.DatasetItemUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DatasetItem,
+        )
+
+    def list(
+        self,
+        *,
+        dataset_id: Optional[str] | NotGiven = NOT_GIVEN,
+        ending_before: Optional[str] | NotGiven = NOT_GIVEN,
+        include_archived: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        starting_after: Optional[str] | NotGiven = NOT_GIVEN,
+        version: Optional[int] | NotGiven = NOT_GIVEN,
+        # 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[DatasetItem, AsyncCursorPage[DatasetItem]]:
+        """List Dataset Items
+
+        Args:
+          dataset_id: Optional dataset identifier.
+
+        Must be provided if a specific version is
+              requested.
+
+          version: Optional dataset version. When unset, returns the latest version. Requires a
+              valid dataset_id when set.
+
+          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
+        """
+        return self._get_api_list(
+            "/v5/dataset-items",
+            page=AsyncCursorPage[DatasetItem],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "dataset_id": dataset_id,
+                        "ending_before": ending_before,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "starting_after": starting_after,
+                        "version": version,
+                    },
+                    dataset_item_list_params.DatasetItemListParams,
+                ),
+            ),
+            model=DatasetItem,
+        )
+
+    async def delete(
+        self,
+        dataset_item_id: str,
+        *,
+        # 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,
+    ) -> DatasetItemDeleteResponse:
+        """
+        Delete Dataset Item
+
+        Args:
+          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 dataset_item_id:
+            raise ValueError(f"Expected a non-empty value for `dataset_item_id` but received {dataset_item_id!r}")
+        return await self._delete(
+            f"/v5/dataset-items/{dataset_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DatasetItemDeleteResponse,
+        )
+
+    async def batch_create(
+        self,
+        *,
+        data: Iterable[Dict[str, object]],
+        dataset_id: str,
+        # 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,
+    ) -> DatasetItemBatchCreateResponse:
+        """
+        Batch Create Dataset Items
+
+        Args:
+          data: Items to be added to the dataset
+
+          dataset_id: Identifier of the target dataset
+
+          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
+        """
+        return await self._post(
+            "/v5/dataset-items/batch",
+            body=await async_maybe_transform(
+                {
+                    "data": data,
+                    "dataset_id": dataset_id,
+                },
+                dataset_item_batch_create_params.DatasetItemBatchCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DatasetItemBatchCreateResponse,
+        )
+
+
+class DatasetItemsResourceWithRawResponse:
+    def __init__(self, dataset_items: DatasetItemsResource) -> None:
+        self._dataset_items = dataset_items
+
+        self.retrieve = to_raw_response_wrapper(
+            dataset_items.retrieve,
+        )
+        self.update = to_raw_response_wrapper(
+            dataset_items.update,
+        )
+        self.list = to_raw_response_wrapper(
+            dataset_items.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            dataset_items.delete,
+        )
+        self.batch_create = to_raw_response_wrapper(
+            dataset_items.batch_create,
+        )
+
+
+class AsyncDatasetItemsResourceWithRawResponse:
+    def __init__(self, dataset_items: AsyncDatasetItemsResource) -> None:
+        self._dataset_items = dataset_items
+
+        self.retrieve = async_to_raw_response_wrapper(
+            dataset_items.retrieve,
+        )
+        self.update = async_to_raw_response_wrapper(
+            dataset_items.update,
+        )
+        self.list = async_to_raw_response_wrapper(
+            dataset_items.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            dataset_items.delete,
+        )
+        self.batch_create = async_to_raw_response_wrapper(
+            dataset_items.batch_create,
+        )
+
+
+class DatasetItemsResourceWithStreamingResponse:
+    def __init__(self, dataset_items: DatasetItemsResource) -> None:
+        self._dataset_items = dataset_items
+
+        self.retrieve = to_streamed_response_wrapper(
+            dataset_items.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            dataset_items.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            dataset_items.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            dataset_items.delete,
+        )
+        self.batch_create = to_streamed_response_wrapper(
+            dataset_items.batch_create,
+        )
+
+
+class AsyncDatasetItemsResourceWithStreamingResponse:
+    def __init__(self, dataset_items: AsyncDatasetItemsResource) -> None:
+        self._dataset_items = dataset_items
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            dataset_items.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            dataset_items.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            dataset_items.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            dataset_items.delete,
+        )
+        self.batch_create = async_to_streamed_response_wrapper(
+            dataset_items.batch_create,
+        )

scale_gp_beta/resources/evaluation_items.py

@@ -0,0 +1,295 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..types import evaluation_item_list_params, evaluation_item_retrieve_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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 SyncCursorPage, AsyncCursorPage
+from .._base_client import AsyncPaginator, make_request_options
+from ..types.evaluation_item import EvaluationItem
+
+__all__ = ["EvaluationItemsResource", "AsyncEvaluationItemsResource"]
+
+
+class EvaluationItemsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> EvaluationItemsResourceWithRawResponse:
+        """
+        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/scaleapi/sgp-python-beta#accessing-raw-response-data-eg-headers
+        """
+        return EvaluationItemsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EvaluationItemsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/sgp-python-beta#with_streaming_response
+        """
+        return EvaluationItemsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        evaluation_item_id: str,
+        *,
+        include_archived: bool | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> EvaluationItem:
+        """
+        Get Evaluation Item
+
+        Args:
+          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 evaluation_item_id:
+            raise ValueError(f"Expected a non-empty value for `evaluation_item_id` but received {evaluation_item_id!r}")
+        return self._get(
+            f"/v5/evaluation-items/{evaluation_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {"include_archived": include_archived}, evaluation_item_retrieve_params.EvaluationItemRetrieveParams
+                ),
+            ),
+            cast_to=EvaluationItem,
+        )
+
+    def list(
+        self,
+        *,
+        ending_before: Optional[str] | NotGiven = NOT_GIVEN,
+        evaluation_id: Optional[str] | NotGiven = NOT_GIVEN,
+        include_archived: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        starting_after: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SyncCursorPage[EvaluationItem]:
+        """
+        List Evaluation Items
+
+        Args:
+          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
+        """
+        return self._get_api_list(
+            "/v5/evaluation-items",
+            page=SyncCursorPage[EvaluationItem],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "ending_before": ending_before,
+                        "evaluation_id": evaluation_id,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "starting_after": starting_after,
+                    },
+                    evaluation_item_list_params.EvaluationItemListParams,
+                ),
+            ),
+            model=EvaluationItem,
+        )
+
+
+class AsyncEvaluationItemsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncEvaluationItemsResourceWithRawResponse:
+        """
+        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/scaleapi/sgp-python-beta#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEvaluationItemsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEvaluationItemsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/sgp-python-beta#with_streaming_response
+        """
+        return AsyncEvaluationItemsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        evaluation_item_id: str,
+        *,
+        include_archived: bool | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> EvaluationItem:
+        """
+        Get Evaluation Item
+
+        Args:
+          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 evaluation_item_id:
+            raise ValueError(f"Expected a non-empty value for `evaluation_item_id` but received {evaluation_item_id!r}")
+        return await self._get(
+            f"/v5/evaluation-items/{evaluation_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"include_archived": include_archived}, evaluation_item_retrieve_params.EvaluationItemRetrieveParams
+                ),
+            ),
+            cast_to=EvaluationItem,
+        )
+
+    def list(
+        self,
+        *,
+        ending_before: Optional[str] | NotGiven = NOT_GIVEN,
+        evaluation_id: Optional[str] | NotGiven = NOT_GIVEN,
+        include_archived: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        starting_after: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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[EvaluationItem, AsyncCursorPage[EvaluationItem]]:
+        """
+        List Evaluation Items
+
+        Args:
+          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
+        """
+        return self._get_api_list(
+            "/v5/evaluation-items",
+            page=AsyncCursorPage[EvaluationItem],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "ending_before": ending_before,
+                        "evaluation_id": evaluation_id,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "starting_after": starting_after,
+                    },
+                    evaluation_item_list_params.EvaluationItemListParams,
+                ),
+            ),
+            model=EvaluationItem,
+        )
+
+
+class EvaluationItemsResourceWithRawResponse:
+    def __init__(self, evaluation_items: EvaluationItemsResource) -> None:
+        self._evaluation_items = evaluation_items
+
+        self.retrieve = to_raw_response_wrapper(
+            evaluation_items.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            evaluation_items.list,
+        )
+
+
+class AsyncEvaluationItemsResourceWithRawResponse:
+    def __init__(self, evaluation_items: AsyncEvaluationItemsResource) -> None:
+        self._evaluation_items = evaluation_items
+
+        self.retrieve = async_to_raw_response_wrapper(
+            evaluation_items.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            evaluation_items.list,
+        )
+
+
+class EvaluationItemsResourceWithStreamingResponse:
+    def __init__(self, evaluation_items: EvaluationItemsResource) -> None:
+        self._evaluation_items = evaluation_items
+
+        self.retrieve = to_streamed_response_wrapper(
+            evaluation_items.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            evaluation_items.list,
+        )
+
+
+class AsyncEvaluationItemsResourceWithStreamingResponse:
+    def __init__(self, evaluation_items: AsyncEvaluationItemsResource) -> None:
+        self._evaluation_items = evaluation_items
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            evaluation_items.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            evaluation_items.list,
+        )

scale_gp_beta/types/__init__.py

@@ -7,6 +7,8 @@ from .dataset import Dataset as Dataset
 from .file_list import FileList as FileList
 from .completion import Completion as Completion
 from .evaluation import Evaluation as Evaluation
+from .dataset_item import DatasetItem as DatasetItem
+from .evaluation_item import EvaluationItem as EvaluationItem
 from .inference_model import InferenceModel as InferenceModel
 from .file_list_params import FileListParams as FileListParams
 from .model_list_params import ModelListParams as ModelListParams
@@ -26,8 +28,16 @@ from .dataset_delete_response import DatasetDeleteResponse as DatasetDeleteRespo
 from .dataset_retrieve_params import DatasetRetrieveParams as DatasetRetrieveParams
 from .inference_create_params import InferenceCreateParams as InferenceCreateParams
 from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .dataset_item_list_params import DatasetItemListParams as DatasetItemListParams
 from .evaluation_create_params import EvaluationCreateParams as EvaluationCreateParams
 from .inference_response_chunk import InferenceResponseChunk as InferenceResponseChunk
 from .inference_create_response import InferenceCreateResponse as InferenceCreateResponse
+from .dataset_item_update_params import DatasetItemUpdateParams as DatasetItemUpdateParams
 from .evaluation_retrieve_params import EvaluationRetrieveParams as EvaluationRetrieveParams
 from .evaluation_archive_response import EvaluationArchiveResponse as EvaluationArchiveResponse
+from .evaluation_item_list_params import EvaluationItemListParams as EvaluationItemListParams
+from .dataset_item_delete_response import DatasetItemDeleteResponse as DatasetItemDeleteResponse
+from .dataset_item_retrieve_params import DatasetItemRetrieveParams as DatasetItemRetrieveParams
+from .evaluation_item_retrieve_params import EvaluationItemRetrieveParams as EvaluationItemRetrieveParams
+from .dataset_item_batch_create_params import DatasetItemBatchCreateParams as DatasetItemBatchCreateParams
+from .dataset_item_batch_create_response import DatasetItemBatchCreateResponse as DatasetItemBatchCreateResponse

scale_gp_beta/types/dataset_item.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["DatasetItem"]
+
+
+class DatasetItem(BaseModel):
+    id: str
+
+    content_hash: str
+
+    created_at: datetime
+
+    created_by_user_id: str
+
+    data: object
+
+    archived_at: Optional[datetime] = None
+
+    dataset_id: Optional[str] = None
+
+    object: Optional[Literal["dataset.item"]] = None

scale_gp_beta/types/dataset_item_batch_create_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable
+from typing_extensions import Required, TypedDict
+
+__all__ = ["DatasetItemBatchCreateParams"]
+
+
+class DatasetItemBatchCreateParams(TypedDict, total=False):
+    data: Required[Iterable[Dict[str, object]]]
+    """Items to be added to the dataset"""
+
+    dataset_id: Required[str]
+    """Identifier of the target dataset"""

scale_gp_beta/types/dataset_item_batch_create_response.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .dataset_item import DatasetItem
+
+__all__ = ["DatasetItemBatchCreateResponse"]
+
+
+class DatasetItemBatchCreateResponse(BaseModel):
+    items: List[DatasetItem]
+
+    object: Optional[Literal["list"]] = None

scale_gp_beta/types/dataset_item_delete_response.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["DatasetItemDeleteResponse"]
+
+
+class DatasetItemDeleteResponse(BaseModel):
+    id: str
+
+    deleted: bool
+
+    object: Optional[Literal["dataset.item"]] = None

scale_gp_beta/types/dataset_item_list_params.py

@@ -0,0 +1,30 @@
+# 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 TypedDict
+
+__all__ = ["DatasetItemListParams"]
+
+
+class DatasetItemListParams(TypedDict, total=False):
+    dataset_id: Optional[str]
+    """Optional dataset identifier.
+
+    Must be provided if a specific version is requested.
+    """
+
+    ending_before: Optional[str]
+
+    include_archived: bool
+
+    limit: int
+
+    starting_after: Optional[str]
+
+    version: Optional[int]
+    """Optional dataset version.
+
+    When unset, returns the latest version. Requires a valid dataset_id when set.
+    """

scale_gp_beta/types/dataset_item_retrieve_params.py

@@ -0,0 +1,13 @@
+# 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 TypedDict
+
+__all__ = ["DatasetItemRetrieveParams"]
+
+
+class DatasetItemRetrieveParams(TypedDict, total=False):
+    version: Optional[int]
+    """Optional dataset version. When unset, returns the latest version."""

scale_gp_beta/types/dataset_item_update_params.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+from typing_extensions import Required, TypedDict
+
+__all__ = ["DatasetItemUpdateParams"]
+
+
+class DatasetItemUpdateParams(TypedDict, total=False):
+    data: Required[Dict[str, object]]
+    """Updated dataset item data"""

scale_gp_beta/types/evaluation_item.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["EvaluationItem"]
+
+
+class EvaluationItem(BaseModel):
+    id: str
+
+    created_at: datetime
+
+    created_by_user_id: str
+
+    data: Dict[str, object]
+
+    evaluation_id: str
+
+    archived_at: Optional[datetime] = None
+
+    dataset_item_id: Optional[str] = None
+
+    dataset_item_version_num: Optional[int] = None
+
+    object: Optional[Literal["evaluation.item"]] = None

scale_gp_beta/types/evaluation_item_list_params.py

@@ -0,0 +1,20 @@
+# 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 TypedDict
+
+__all__ = ["EvaluationItemListParams"]
+
+
+class EvaluationItemListParams(TypedDict, total=False):
+    ending_before: Optional[str]
+
+    evaluation_id: Optional[str]
+
+    include_archived: bool
+
+    limit: int
+
+    starting_after: Optional[str]

scale_gp_beta/types/evaluation_item_retrieve_params.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["EvaluationItemRetrieveParams"]
+
+
+class EvaluationItemRetrieveParams(TypedDict, total=False):
+    include_archived: bool

{scale_gp_beta-0.1.0a5.dist-info → scale_gp_beta-0.1.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scale-gp-beta
-Version: 0.1.0a5
+Version: 0.1.0a6
 Summary: The official Python library for the Scale GP API
 Project-URL: Homepage, https://github.com/scaleapi/sgp-python-beta
 Project-URL: Repository, https://github.com/scaleapi/sgp-python-beta

{scale_gp_beta-0.1.0a5.dist-info → scale_gp_beta-0.1.0a6.dist-info}/RECORD

@@ -1,6 +1,6 @@
 scale_gp_beta/__init__.py,sha256=XmzYbUteZA7f7EPIFNKcPSnSgFpK6ovSlHY57Xk-WGo,2535
 scale_gp_beta/_base_client.py,sha256=gMRzeMNQ9Z7kaex2ofZ7U0pd-E-7M754bDa7cVhQXvo,64964
-scale_gp_beta/_client.py,sha256=6asGfvGJmCgTz9HEECs5pZoufPGvSmqB50D0Mvnk7QQ,22522
+scale_gp_beta/_client.py,sha256=WH_GKR0FzRkvcJ4JqsqEOHT40JDJPI_uXN1bUo8UsXQ,24029
 scale_gp_beta/_compat.py,sha256=VWemUKbj6DDkQ-O4baSpHVLJafotzeXmCQGJugfVTIw,6580
 scale_gp_beta/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 scale_gp_beta/_exceptions.py,sha256=95GM5CLFtP-QMjjmzsr5ajjZOyEZvyaETfGmqNPR8YM,3226
@@ -11,7 +11,7 @@ scale_gp_beta/_resource.py,sha256=siZly_U6D0AOVLAzaOsqUdEFFzVMbWRj-ml30nvRp7E,11
 scale_gp_beta/_response.py,sha256=ATtij8CjXVjmhdOWozU9Y0SP4Q_uxCYGFUHroxFnSc4,28853
 scale_gp_beta/_streaming.py,sha256=fcCSGXslmi2SmmkM05g2SACXHk2Mj7k1X5uMBu6U5s8,10112
 scale_gp_beta/_types.py,sha256=ScQhVBaKbtJrER3NkXbjokWE9DqSqREMIw9LE0NrFfA,6150
-scale_gp_beta/_version.py,sha256=LsIGgvN7B9kghhD-GMMkkGdleY9x2u2i-hCcZVdxIwc,173
+scale_gp_beta/_version.py,sha256=tBulsXt5NWpm7sumLsQGrulDcZ8nJyHBl3-3Y5NjBwQ,173
 scale_gp_beta/pagination.py,sha256=6AAa8_V0wARlMd1MIXijugYbG1mILGc2tHVKbUQbZyQ,2595
 scale_gp_beta/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scale_gp_beta/_utils/__init__.py,sha256=PNZ_QJuzZEgyYXqkO1HVhGkj5IU9bglVUcw7H-Knjzw,2062
@@ -24,9 +24,11 @@ scale_gp_beta/_utils/_transform.py,sha256=tsSFOIZ7iczaUsMSGBD_iSFOOdUyT2xtkcq1xy
 scale_gp_beta/_utils/_typing.py,sha256=nTJz0jcrQbEgxwy4TtAkNxuU0QHHlmc6mQtA6vIR8tg,4501
 scale_gp_beta/_utils/_utils.py,sha256=8UmbPOy_AAr2uUjjFui-VZSrVBHRj6bfNEKRp5YZP2A,12004
 scale_gp_beta/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-scale_gp_beta/resources/__init__.py,sha256=Aox7fBbozdmVvq6gu4pTSCcr5E7hg_yPthF1a7xLa34,3408
+scale_gp_beta/resources/__init__.py,sha256=NiCRW8_9HIIv6qZVCu0INsQm3oM50kEX5bLFRmor1bI,4505
 scale_gp_beta/resources/completions.py,sha256=dk7Uvl8dnnieRWTJr2fhzJMZwOzGIjsYSw2GjaMWlCs,31653
+scale_gp_beta/resources/dataset_items.py,sha256=BOx6ddLcDvL5L9HweCY62QnxflAs1jQJC-Ni-xzMUf0,22361
 scale_gp_beta/resources/datasets.py,sha256=tE2JKxlHc48Sm-SpySH4f265CxCBlaHWT68jKiJKJc8,20717
+scale_gp_beta/resources/evaluation_items.py,sha256=iD-srR9ZQQ3WAutxA98_MMj4_1h-B1_lZ_Ujb9F6Ino,11460
 scale_gp_beta/resources/evaluations.py,sha256=61sMyGqrH-gztzhY82UmXyV0Ip-s9LQvBiuFEzQgHsQ,25855
 scale_gp_beta/resources/inference.py,sha256=_20eN0x0PZBPNLx2VrozQrJgRVjtlXPjeTpTcnuP0bU,7576
 scale_gp_beta/resources/models.py,sha256=85F8qPJN9lBPbfNm9F8bHpdJSsyekS9B3GDPJtCXaMA,32658
@@ -36,18 +38,28 @@ scale_gp_beta/resources/chat/completions.py,sha256=ZPa4-9RNKTXldq2VjWahNrlXeO_jY
 scale_gp_beta/resources/files/__init__.py,sha256=VgAtqUimN5Kf_-lmEaNBnu_ApGegKsJQ1zNf-42MXFA,1002
 scale_gp_beta/resources/files/content.py,sha256=oJxb-28ZOUBgzE_MiAaJOcKFmtlB-N5APdhfZBNJna8,5762
 scale_gp_beta/resources/files/files.py,sha256=M8OdZoIi3fFjJL7oIn8w9TD6TVcASCMy1Ze1YZRbPMo,20530
-scale_gp_beta/types/__init__.py,sha256=5KRwCU53Hx-wFv78yza-DCfdWyD8kKclXoE5AJNmrpE,2209
+scale_gp_beta/types/__init__.py,sha256=lmW3hfEjdEqRS2iSpGQ_YC8IYtVnbYMyoHR6zWEgQZE,3114
 scale_gp_beta/types/completion.py,sha256=5eewo25sdqL4vutqvE8wmugE0Cw6YLzZ0_AD6yjP9NM,3259
 scale_gp_beta/types/completion_create_params.py,sha256=LE9vna29Kbh7E8qUq7EhQbcu7YuCF_h663maKtzOnhk,3063
 scale_gp_beta/types/dataset.py,sha256=uTlOPgxkzpiAFOr_NOOYqhTsrqOKkOyXvxzczIe9gaE,511
 scale_gp_beta/types/dataset_create_params.py,sha256=k-JIiwO_4rSM3jzOpgq5d_7i7VSt3tik-kvAt1PXzfI,436
 scale_gp_beta/types/dataset_delete_response.py,sha256=Lc4K761LM__hosWI3gYjYnEl5JXL-cg4DU3lXKhtQoo,345
+scale_gp_beta/types/dataset_item.py,sha256=b4w5G099vEVyj8GNVnjNn-3SkZoFHvlmCXxfQS7I_nM,519
+scale_gp_beta/types/dataset_item_batch_create_params.py,sha256=ORwWuIFKilxhuVhzcF32HD68E0-n5dnRlbyxUk4H3Ko,478
+scale_gp_beta/types/dataset_item_batch_create_response.py,sha256=tUVLQ7igWxp4Dn0pvi1K6YEf7m8XnsrlyHbBkVq9i6k,402
+scale_gp_beta/types/dataset_item_delete_response.py,sha256=EffQRHJgGvew_n6XYVdojlC5Ec1oHg91xncrKWkyjGA,358
+scale_gp_beta/types/dataset_item_list_params.py,sha256=MR7erZZuxXf56Dhfne29HB9cTYlkeMHBhO4sFXgKFrw,680
+scale_gp_beta/types/dataset_item_retrieve_params.py,sha256=VuTBMASWQdWYKmpY06olXXyY5wfJea0XYxppOUJ0VJw,394
+scale_gp_beta/types/dataset_item_update_params.py,sha256=4voEG9nKbxREiFRLzWqXZAWsw3wIm4EU1cnvOmsvGRA,367
 scale_gp_beta/types/dataset_list_params.py,sha256=4rITQ1avOcQObS17cT0NDikOmF7Fd_rxkSlRIfzzfF4,387
 scale_gp_beta/types/dataset_retrieve_params.py,sha256=5tpzuzX6y1WKKxP2AbjYwwcATpB1eZCv4wZABG3baIQ,282
 scale_gp_beta/types/dataset_update_params.py,sha256=Aw7m-jat5P82qJGJgsuz6xx6nu96jYdfJnM_TR94PAE,287
 scale_gp_beta/types/evaluation.py,sha256=U8m8P0dX290Pv-jG2ZiiV9djQ1dUkyLI1tv0SGgIH8c,609
 scale_gp_beta/types/evaluation_archive_response.py,sha256=SkGy3GourPaQRPt84smBd1XhwZqeDTDINK7PtyEEpSY,356
 scale_gp_beta/types/evaluation_create_params.py,sha256=nmbi633xCnOY28cnvH595s2hlk7xKU0surVyYAbeSlQ,25504
+scale_gp_beta/types/evaluation_item.py,sha256=KENQ19JXAEGD0q82HwQ6GDx69giPmzP0h0Uo8ehWF8w,603
+scale_gp_beta/types/evaluation_item_list_params.py,sha256=LquF3dWIU6b7O_Sy_b0R2FMk5XC-Jm6mEHLJGUOKLuk,435
+scale_gp_beta/types/evaluation_item_retrieve_params.py,sha256=UYEKIAQ4dy92ZOSV1tWDZcvXG7_0BSpOND5Ehzs7QM4,296
 scale_gp_beta/types/evaluation_list_params.py,sha256=3e8fR1LCDhODoRrvgriRvgLhpIp0HXEZdjQ6P9p-eD4,393
 scale_gp_beta/types/evaluation_retrieve_params.py,sha256=tqzzbcD-hEcUcGFrfIhH3fG1cXuLvQGHZlyS-e3Zsx4,288
 scale_gp_beta/types/file.py,sha256=Xkha0eSr1q6hkwjE9e2XNgk8kuHNoTEe1LXNhz6o-1k,528
@@ -72,7 +84,7 @@ scale_gp_beta/types/chat/chat_completion_chunk.py,sha256=6anUxR5cLdhEhhSgjh3tFbH
 scale_gp_beta/types/chat/completion_create_params.py,sha256=Y7vJNvNM4Sov77l55aS5YtyRnrf7isediu3nKr6YE-A,4505
 scale_gp_beta/types/chat/completion_create_response.py,sha256=0OhfoJW8azVRrZdXRRMuiJ7kEEeMDnKScxrr3sayzDo,374
 scale_gp_beta/types/files/__init__.py,sha256=OKfJYcKb4NObdiRObqJV_dOyDQ8feXekDUge2o_4pXQ,122
-scale_gp_beta-0.1.0a5.dist-info/METADATA,sha256=hlWX2f9t_Y4QL_5txpmQJOKTCuW-cWkqackYx6deku0,16938
-scale_gp_beta-0.1.0a5.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-scale_gp_beta-0.1.0a5.dist-info/licenses/LICENSE,sha256=x49Bj8r_ZpqfzThbmfHyZ_bE88XvHdIMI_ANyLHFFRE,11338
-scale_gp_beta-0.1.0a5.dist-info/RECORD,,
+scale_gp_beta-0.1.0a6.dist-info/METADATA,sha256=XeDXaHh4XorBJB9SDAdZMVRVee4JthB20lmhahQqPm0,16938
+scale_gp_beta-0.1.0a6.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+scale_gp_beta-0.1.0a6.dist-info/licenses/LICENSE,sha256=x49Bj8r_ZpqfzThbmfHyZ_bE88XvHdIMI_ANyLHFFRE,11338
+scale_gp_beta-0.1.0a6.dist-info/RECORD,,