scale-gp-beta 0.1.0a2__py3-none-any.whl

scale_gp/resources/questions.py

@@ -0,0 +1,396 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import question_list_params, question_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.question import Question
+
+__all__ = ["QuestionsResource", "AsyncQuestionsResource"]
+
+
+class QuestionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> QuestionsResourceWithRawResponse:
+        """
+        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 QuestionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> QuestionsResourceWithStreamingResponse:
+        """
+        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 QuestionsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        prompt: str,
+        title: str,
+        type: Literal["categorical", "free_text", "rating", "number"],
+        choices: Iterable[question_create_params.Choice] | NotGiven = NOT_GIVEN,
+        conditions: Iterable[Dict[str, object]] | NotGiven = NOT_GIVEN,
+        dropdown: bool | NotGiven = NOT_GIVEN,
+        multi: bool | NotGiven = NOT_GIVEN,
+        number_options: question_create_params.NumberOptions | NotGiven = NOT_GIVEN,
+        rating_options: question_create_params.RatingOptions | NotGiven = NOT_GIVEN,
+        required: 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,
+    ) -> Question:
+        """
+        Create Question
+
+        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._post(
+            "/v5/questions",
+            body=maybe_transform(
+                {
+                    "prompt": prompt,
+                    "title": title,
+                    "type": type,
+                    "choices": choices,
+                    "conditions": conditions,
+                    "dropdown": dropdown,
+                    "multi": multi,
+                    "number_options": number_options,
+                    "rating_options": rating_options,
+                    "required": required,
+                },
+                question_create_params.QuestionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Question,
+        )
+
+    def retrieve(
+        self,
+        question_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,
+    ) -> Question:
+        """
+        Get Question
+
+        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 question_id:
+            raise ValueError(f"Expected a non-empty value for `question_id` but received {question_id!r}")
+        return self._get(
+            f"/v5/questions/{question_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Question,
+        )
+
+    def list(
+        self,
+        *,
+        ending_before: Optional[str] | 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[Question]:
+        """
+        List Questions
+
+        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/questions",
+            page=SyncCursorPage[Question],
+            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,
+                        "limit": limit,
+                        "starting_after": starting_after,
+                    },
+                    question_list_params.QuestionListParams,
+                ),
+            ),
+            model=Question,
+        )
+
+
+class AsyncQuestionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncQuestionsResourceWithRawResponse:
+        """
+        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 AsyncQuestionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncQuestionsResourceWithStreamingResponse:
+        """
+        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 AsyncQuestionsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        prompt: str,
+        title: str,
+        type: Literal["categorical", "free_text", "rating", "number"],
+        choices: Iterable[question_create_params.Choice] | NotGiven = NOT_GIVEN,
+        conditions: Iterable[Dict[str, object]] | NotGiven = NOT_GIVEN,
+        dropdown: bool | NotGiven = NOT_GIVEN,
+        multi: bool | NotGiven = NOT_GIVEN,
+        number_options: question_create_params.NumberOptions | NotGiven = NOT_GIVEN,
+        rating_options: question_create_params.RatingOptions | NotGiven = NOT_GIVEN,
+        required: 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,
+    ) -> Question:
+        """
+        Create Question
+
+        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 await self._post(
+            "/v5/questions",
+            body=await async_maybe_transform(
+                {
+                    "prompt": prompt,
+                    "title": title,
+                    "type": type,
+                    "choices": choices,
+                    "conditions": conditions,
+                    "dropdown": dropdown,
+                    "multi": multi,
+                    "number_options": number_options,
+                    "rating_options": rating_options,
+                    "required": required,
+                },
+                question_create_params.QuestionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Question,
+        )
+
+    async def retrieve(
+        self,
+        question_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,
+    ) -> Question:
+        """
+        Get Question
+
+        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 question_id:
+            raise ValueError(f"Expected a non-empty value for `question_id` but received {question_id!r}")
+        return await self._get(
+            f"/v5/questions/{question_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Question,
+        )
+
+    def list(
+        self,
+        *,
+        ending_before: Optional[str] | 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[Question, AsyncCursorPage[Question]]:
+        """
+        List Questions
+
+        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/questions",
+            page=AsyncCursorPage[Question],
+            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,
+                        "limit": limit,
+                        "starting_after": starting_after,
+                    },
+                    question_list_params.QuestionListParams,
+                ),
+            ),
+            model=Question,
+        )
+
+
+class QuestionsResourceWithRawResponse:
+    def __init__(self, questions: QuestionsResource) -> None:
+        self._questions = questions
+
+        self.create = to_raw_response_wrapper(
+            questions.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            questions.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            questions.list,
+        )
+
+
+class AsyncQuestionsResourceWithRawResponse:
+    def __init__(self, questions: AsyncQuestionsResource) -> None:
+        self._questions = questions
+
+        self.create = async_to_raw_response_wrapper(
+            questions.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            questions.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            questions.list,
+        )
+
+
+class QuestionsResourceWithStreamingResponse:
+    def __init__(self, questions: QuestionsResource) -> None:
+        self._questions = questions
+
+        self.create = to_streamed_response_wrapper(
+            questions.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            questions.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            questions.list,
+        )
+
+
+class AsyncQuestionsResourceWithStreamingResponse:
+    def __init__(self, questions: AsyncQuestionsResource) -> None:
+        self._questions = questions
+
+        self.create = async_to_streamed_response_wrapper(
+            questions.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            questions.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            questions.list,
+        )

scale_gp/types/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .file import File as File
+from .question import Question as Question
+from .file_list import FileList as FileList
+from .completion import Completion as Completion
+from .question_set import QuestionSet as QuestionSet
+from .question_list import QuestionList as QuestionList
+from .inference_model import InferenceModel as InferenceModel
+from .file_list_params import FileListParams as FileListParams
+from .model_list_params import ModelListParams as ModelListParams
+from .question_set_list import QuestionSetList as QuestionSetList
+from .file_create_params import FileCreateParams as FileCreateParams
+from .file_update_params import FileUpdateParams as FileUpdateParams
+from .inference_response import InferenceResponse as InferenceResponse
+from .model_create_params import ModelCreateParams as ModelCreateParams
+from .model_update_params import ModelUpdateParams as ModelUpdateParams
+from .file_delete_response import FileDeleteResponse as FileDeleteResponse
+from .inference_model_list import InferenceModelList as InferenceModelList
+from .question_list_params import QuestionListParams as QuestionListParams
+from .model_delete_response import ModelDeleteResponse as ModelDeleteResponse
+from .question_create_params import QuestionCreateParams as QuestionCreateParams
+from .inference_create_params import InferenceCreateParams as InferenceCreateParams
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .inference_response_chunk import InferenceResponseChunk as InferenceResponseChunk
+from .question_set_list_params import QuestionSetListParams as QuestionSetListParams
+from .inference_create_response import InferenceCreateResponse as InferenceCreateResponse
+from .question_set_create_params import QuestionSetCreateParams as QuestionSetCreateParams
+from .question_set_update_params import QuestionSetUpdateParams as QuestionSetUpdateParams
+from .question_set_delete_response import QuestionSetDeleteResponse as QuestionSetDeleteResponse
+from .question_set_retrieve_params import QuestionSetRetrieveParams as QuestionSetRetrieveParams

scale_gp/types/chat/__init__.py

@@ -0,0 +1,8 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .chat_completion import ChatCompletion as ChatCompletion
+from .chat_completion_chunk import ChatCompletionChunk as ChatCompletionChunk
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .completion_create_response import CompletionCreateResponse as CompletionCreateResponse

scale_gp/types/chat/chat_completion.py

@@ -0,0 +1,257 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import builtins
+from typing import TYPE_CHECKING, List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = [
+    "ChatCompletion",
+    "Choice",
+    "ChoiceMessage",
+    "ChoiceMessageAudio",
+    "ChoiceMessageFunctionCall",
+    "ChoiceMessageToolCall",
+    "ChoiceMessageToolCallFunction",
+    "ChoiceLogprobs",
+    "ChoiceLogprobsContent",
+    "ChoiceLogprobsContentTopLogprob",
+    "ChoiceLogprobsRefusal",
+    "ChoiceLogprobsRefusalTopLogprob",
+    "Usage",
+    "UsageCompletionTokensDetails",
+    "UsagePromptTokensDetails",
+]
+
+
+class ChoiceMessageAudio(BaseModel):
+    id: str
+
+    data: str
+
+    expires_at: int
+
+    transcript: str
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceMessageFunctionCall(BaseModel):
+    arguments: str
+
+    name: str
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceMessageToolCallFunction(BaseModel):
+    arguments: str
+
+    name: str
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceMessageToolCall(BaseModel):
+    id: str
+
+    function: ChoiceMessageToolCallFunction
+
+    type: Literal["function"]
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceMessage(BaseModel):
+    role: Literal["assistant"]
+
+    audio: Optional[ChoiceMessageAudio] = None
+
+    content: Optional[str] = None
+
+    function_call: Optional[ChoiceMessageFunctionCall] = None
+
+    refusal: Optional[str] = None
+
+    tool_calls: Optional[List[ChoiceMessageToolCall]] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceLogprobsContentTopLogprob(BaseModel):
+    token: str
+
+    logprob: float
+
+    bytes: Optional[List[int]] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceLogprobsContent(BaseModel):
+    token: str
+
+    logprob: float
+
+    top_logprobs: List[ChoiceLogprobsContentTopLogprob]
+
+    bytes: Optional[List[int]] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceLogprobsRefusalTopLogprob(BaseModel):
+    token: str
+
+    logprob: float
+
+    bytes: Optional[List[int]] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceLogprobsRefusal(BaseModel):
+    token: str
+
+    logprob: float
+
+    top_logprobs: List[ChoiceLogprobsRefusalTopLogprob]
+
+    bytes: Optional[List[int]] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChoiceLogprobs(BaseModel):
+    content: Optional[List[ChoiceLogprobsContent]] = None
+
+    refusal: Optional[List[ChoiceLogprobsRefusal]] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class Choice(BaseModel):
+    finish_reason: Literal["stop", "length", "tool_calls", "content_filter", "function_call"]
+
+    index: int
+
+    message: ChoiceMessage
+
+    logprobs: Optional[ChoiceLogprobs] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class UsageCompletionTokensDetails(BaseModel):
+    accepted_prediction_tokens: Optional[int] = None
+
+    audio_tokens: Optional[int] = None
+
+    reasoning_tokens: Optional[int] = None
+
+    rejected_prediction_tokens: Optional[int] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class UsagePromptTokensDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+
+    cached_tokens: Optional[int] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class Usage(BaseModel):
+    completion_tokens: int
+
+    prompt_tokens: int
+
+    total_tokens: int
+
+    completion_tokens_details: Optional[UsageCompletionTokensDetails] = None
+
+    prompt_tokens_details: Optional[UsagePromptTokensDetails] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+
+
+class ChatCompletion(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    model: str
+
+    object: Optional[Literal["chat.completion"]] = None
+
+    service_tier: Optional[Literal["scale", "default"]] = None
+
+    system_fingerprint: Optional[str] = None
+
+    usage: Optional[Usage] = None
+
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> builtins.object: ...