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

scale_gp/types/chat/chat_completion_chunk.py

@@ -0,0 +1,240 @@
+# 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__ = [
+    "ChatCompletionChunk",
+    "Choice",
+    "ChoiceDelta",
+    "ChoiceDeltaFunctionCall",
+    "ChoiceDeltaToolCall",
+    "ChoiceDeltaToolCallFunction",
+    "ChoiceLogprobs",
+    "ChoiceLogprobsContent",
+    "ChoiceLogprobsContentTopLogprob",
+    "ChoiceLogprobsRefusal",
+    "ChoiceLogprobsRefusalTopLogprob",
+    "Usage",
+    "UsageCompletionTokensDetails",
+    "UsagePromptTokensDetails",
+]
+
+
+class ChoiceDeltaFunctionCall(BaseModel):
+    arguments: Optional[str] = None
+
+    name: Optional[str] = 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 ChoiceDeltaToolCallFunction(BaseModel):
+    arguments: Optional[str] = None
+
+    name: Optional[str] = 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 ChoiceDeltaToolCall(BaseModel):
+    index: int
+
+    id: Optional[str] = None
+
+    function: Optional[ChoiceDeltaToolCallFunction] = None
+
+    type: Optional[Literal["function"]] = 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 ChoiceDelta(BaseModel):
+    content: Optional[str] = None
+
+    function_call: Optional[ChoiceDeltaFunctionCall] = None
+
+    refusal: Optional[str] = None
+
+    role: Optional[Literal["system", "user", "assistant", "tool"]] = None
+
+    tool_calls: Optional[List[ChoiceDeltaToolCall]] = 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):
+    delta: ChoiceDelta
+
+    index: int
+
+    finish_reason: Optional[Literal["stop", "length", "tool_calls", "content_filter", "function_call"]] = None
+
+    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 ChatCompletionChunk(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    model: str
+
+    object: Optional[Literal["chat.completion.chunk"]] = 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: ...

scale_gp/types/chat/completion_create_params.py

@@ -0,0 +1,156 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["CompletionCreateParamsBase", "CompletionCreateParamsNonStreaming", "CompletionCreateParamsStreaming"]
+
+
+class CompletionCreateParamsBase(TypedDict, total=False):
+    messages: Required[Iterable[Dict[str, object]]]
+    """openai standard message format"""
+
+    model: Required[str]
+    """model specified as `model_vendor/model`, for example `openai/gpt-4o`"""
+
+    audio: Dict[str, object]
+    """Parameters for audio output.
+
+    Required when audio output is requested with modalities: ['audio'].
+    """
+
+    frequency_penalty: float
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on their existing frequency in the
+    text so far.
+    """
+
+    function_call: Dict[str, object]
+    """Deprecated in favor of tool_choice.
+
+    Controls which function is called by the model.
+    """
+
+    functions: Iterable[Dict[str, object]]
+    """Deprecated in favor of tools.
+
+    A list of functions the model may generate JSON inputs for.
+    """
+
+    logit_bias: Dict[str, int]
+    """Modify the likelihood of specified tokens appearing in the completion.
+
+    Maps tokens to bias values from -100 to 100.
+    """
+
+    logprobs: bool
+    """Whether to return log probabilities of the output tokens or not."""
+
+    max_completion_tokens: int
+    """
+    An upper bound for the number of tokens that can be generated, including visible
+    output tokens and reasoning tokens.
+    """
+
+    max_tokens: int
+    """Deprecated in favor of max_completion_tokens.
+
+    The maximum number of tokens to generate.
+    """
+
+    metadata: Dict[str, str]
+    """
+    Developer-defined tags and values used for filtering completions in the
+    dashboard.
+    """
+
+    modalities: List[str]
+    """Output types that you would like the model to generate for this request."""
+
+    n: int
+    """How many chat completion choices to generate for each input message."""
+
+    parallel_tool_calls: bool
+    """Whether to enable parallel function calling during tool use."""
+
+    prediction: Dict[str, object]
+    """
+    Static predicted output content, such as the content of a text file being
+    regenerated.
+    """
+
+    presence_penalty: float
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize tokens based on whether they appear in the text so far.
+    """
+
+    reasoning_effort: str
+    """For o1 models only. Constrains effort on reasoning. Values: low, medium, high."""
+
+    response_format: Dict[str, object]
+    """An object specifying the format that the model must output."""
+
+    seed: int
+    """
+    If specified, system will attempt to sample deterministically for repeated
+    requests with same seed.
+    """
+
+    stop: Union[str, List[str]]
+    """Up to 4 sequences where the API will stop generating further tokens."""
+
+    store: bool
+    """Whether to store the output for use in model distillation or evals products."""
+
+    stream_options: Dict[str, object]
+    """Options for streaming response. Only set this when stream is true."""
+
+    temperature: float
+    """What sampling temperature to use.
+
+    Higher values make output more random, lower more focused.
+    """
+
+    tool_choice: Union[str, Dict[str, object]]
+    """Controls which tool is called by the model.
+
+    Values: none, auto, required, or specific tool.
+    """
+
+    tools: Iterable[Dict[str, object]]
+    """A list of tools the model may call.
+
+    Currently, only functions are supported. Max 128 functions.
+    """
+
+    top_k: int
+    """Only sample from the top K options for each subsequent token"""
+
+    top_logprobs: int
+    """
+    Number of most likely tokens to return at each position, with associated log
+    probability.
+    """
+
+    top_p: float
+    """Alternative to temperature.
+
+    Only tokens comprising top_p probability mass are considered.
+    """
+
+
+class CompletionCreateParamsNonStreaming(CompletionCreateParamsBase, total=False):
+    stream: Literal[False]
+    """If true, partial message deltas will be sent as server-sent events."""
+
+
+class CompletionCreateParamsStreaming(CompletionCreateParamsBase):
+    stream: Required[Literal[True]]
+    """If true, partial message deltas will be sent as server-sent events."""
+
+
+CompletionCreateParams = Union[CompletionCreateParamsNonStreaming, CompletionCreateParamsStreaming]

scale_gp/types/chat/completion_create_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .chat_completion import ChatCompletion
+from .chat_completion_chunk import ChatCompletionChunk
+
+__all__ = ["CompletionCreateResponse"]
+
+CompletionCreateResponse: TypeAlias = Union[ChatCompletion, ChatCompletionChunk]

scale_gp/types/completion.py

@@ -0,0 +1,116 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import builtins
+from typing import TYPE_CHECKING, Dict, List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = [
+    "Completion",
+    "Choice",
+    "ChoiceLogprobs",
+    "Usage",
+    "UsageCompletionTokensDetails",
+    "UsagePromptTokensDetails",
+]
+
+
+class ChoiceLogprobs(BaseModel):
+    text_offset: Optional[List[int]] = None
+
+    token_logprobs: Optional[List[float]] = None
+
+    tokens: Optional[List[str]] = None
+
+    top_logprobs: Optional[List[Dict[str, float]]] = 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", "content_filter"]
+
+    index: int
+
+    text: str
+
+    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 Completion(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    model: str
+
+    object: Optional[Literal["text_completion"]] = 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: ...

scale_gp/types/completion_create_params.py

@@ -0,0 +1,108 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["CompletionCreateParamsBase", "CompletionCreateParamsNonStreaming", "CompletionCreateParamsStreaming"]
+
+
+class CompletionCreateParamsBase(TypedDict, total=False):
+    model: Required[str]
+    """model specified as `model_vendor/model`, for example `openai/gpt-4o`"""
+
+    prompt: Required[Union[str, List[str]]]
+    """The prompt to generate completions for, encoded as a string"""
+
+    best_of: int
+    """Generates best_of completions server-side and returns the best one.
+
+    Must be greater than n when used together.
+    """
+
+    echo: bool
+    """Echo back the prompt in addition to the completion"""
+
+    frequency_penalty: float
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on their existing frequency in the
+    text.
+    """
+
+    logit_bias: Dict[str, int]
+    """Modify the likelihood of specified tokens appearing in the completion.
+
+    Maps tokens to bias values from -100 to 100.
+    """
+
+    logprobs: int
+    """Include log probabilities of the most likely tokens. Maximum value is 5."""
+
+    max_tokens: int
+    """The maximum number of tokens that can be generated in the completion."""
+
+    n: int
+    """How many completions to generate for each prompt."""
+
+    presence_penalty: float
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on their presence in the text so far.
+    """
+
+    seed: int
+    """If specified, attempts to generate deterministic samples.
+
+    Determinism is not guaranteed.
+    """
+
+    stop: Union[str, List[str]]
+    """Up to 4 sequences where the API will stop generating further tokens."""
+
+    stream_options: Dict[str, object]
+    """Options for streaming response. Only set this when stream is True."""
+
+    suffix: str
+    """The suffix that comes after a completion of inserted text.
+
+    Only supported for gpt-3.5-turbo-instruct.
+    """
+
+    temperature: float
+    """Sampling temperature between 0 and 2.
+
+    Higher values make output more random, lower more focused.
+    """
+
+    top_p: float
+    """Alternative to temperature.
+
+    Consider only tokens with top_p probability mass. Range 0-1.
+    """
+
+    user: str
+    """
+    A unique identifier representing your end-user, which can help OpenAI monitor
+    and detect abuse.
+    """
+
+
+class CompletionCreateParamsNonStreaming(CompletionCreateParamsBase, total=False):
+    stream: Literal[False]
+    """Whether to stream back partial progress.
+
+    If set, tokens will be sent as data-only server-sent events.
+    """
+
+
+class CompletionCreateParamsStreaming(CompletionCreateParamsBase):
+    stream: Required[Literal[True]]
+    """Whether to stream back partial progress.
+
+    If set, tokens will be sent as data-only server-sent events.
+    """
+
+
+CompletionCreateParams = Union[CompletionCreateParamsNonStreaming, CompletionCreateParamsStreaming]

scale_gp/types/file.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import builtins
+from typing import Dict, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["File"]
+
+
+class File(BaseModel):
+    id: str
+
+    created_at: datetime
+
+    created_by_user_id: str
+
+    filename: str
+
+    md5_checksum: str
+
+    mime_type: str
+
+    size: int
+
+    object: Optional[Literal["file"]] = None
+
+    tags: Optional[Dict[str, builtins.object]] = None

scale_gp/types/file_create_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_extensions import Required, TypedDict
+
+from .._types import FileTypes
+
+__all__ = ["FileCreateParams"]
+
+
+class FileCreateParams(TypedDict, total=False):
+    file: Required[FileTypes]

scale_gp/types/file_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__ = ["FileDeleteResponse"]
+
+
+class FileDeleteResponse(BaseModel):
+    id: str
+
+    deleted: bool
+
+    object: Optional[Literal["file"]] = None