together 2.0.0a16__py3-none-any.whl → 2.0.0a18__py3-none-any.whl

together/resources/{models.py → models/models.py}

@@ -6,25 +6,37 @@ from typing_extensions import Literal
 
 import httpx
 
-from ..types import model_list_params, model_upload_params
-from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+from ...types import model_list_params, model_upload_params
+from .uploads import (
+    UploadsResource,
+    AsyncUploadsResource,
+    UploadsResourceWithRawResponse,
+    AsyncUploadsResourceWithRawResponse,
+    UploadsResourceWithStreamingResponse,
+    AsyncUploadsResourceWithStreamingResponse,
+)
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
     to_raw_response_wrapper,
     to_streamed_response_wrapper,
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from .._base_client import make_request_options
-from ..types.model_list_response import ModelListResponse
-from ..types.model_upload_response import ModelUploadResponse
+from ..._base_client import make_request_options
+from ...types.model_list_response import ModelListResponse
+from ...types.model_upload_response import ModelUploadResponse
 
 __all__ = ["ModelsResource", "AsyncModelsResource"]
 
 
 class ModelsResource(SyncAPIResource):
+    @cached_property
+    def uploads(self) -> UploadsResource:
+        return UploadsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> ModelsResourceWithRawResponse:
         """
@@ -148,6 +160,10 @@ class ModelsResource(SyncAPIResource):
 
 
 class AsyncModelsResource(AsyncAPIResource):
+    @cached_property
+    def uploads(self) -> AsyncUploadsResource:
+        return AsyncUploadsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncModelsResourceWithRawResponse:
         """
@@ -281,6 +297,10 @@ class ModelsResourceWithRawResponse:
             models.upload,
         )
 
+    @cached_property
+    def uploads(self) -> UploadsResourceWithRawResponse:
+        return UploadsResourceWithRawResponse(self._models.uploads)
+
 
 class AsyncModelsResourceWithRawResponse:
     def __init__(self, models: AsyncModelsResource) -> None:
@@ -293,6 +313,10 @@ class AsyncModelsResourceWithRawResponse:
             models.upload,
         )
 
+    @cached_property
+    def uploads(self) -> AsyncUploadsResourceWithRawResponse:
+        return AsyncUploadsResourceWithRawResponse(self._models.uploads)
+
 
 class ModelsResourceWithStreamingResponse:
     def __init__(self, models: ModelsResource) -> None:
@@ -305,6 +329,10 @@ class ModelsResourceWithStreamingResponse:
             models.upload,
         )
 
+    @cached_property
+    def uploads(self) -> UploadsResourceWithStreamingResponse:
+        return UploadsResourceWithStreamingResponse(self._models.uploads)
+
 
 class AsyncModelsResourceWithStreamingResponse:
     def __init__(self, models: AsyncModelsResource) -> None:
@@ -316,3 +344,7 @@ class AsyncModelsResourceWithStreamingResponse:
         self.upload = async_to_streamed_response_wrapper(
             models.upload,
         )
+
+    @cached_property
+    def uploads(self) -> AsyncUploadsResourceWithStreamingResponse:
+        return AsyncUploadsResourceWithStreamingResponse(self._models.uploads)

together/resources/models/uploads.py

@@ -0,0 +1,163 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..._types import Body, Query, Headers, NotGiven, not_given
+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 ..._base_client import make_request_options
+from ...types.models.upload_status_response import UploadStatusResponse
+
+__all__ = ["UploadsResource", "AsyncUploadsResource"]
+
+
+class UploadsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> UploadsResourceWithRawResponse:
+        """
+        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/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return UploadsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> UploadsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return UploadsResourceWithStreamingResponse(self)
+
+    def status(
+        self,
+        job_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,
+    ) -> UploadStatusResponse:
+        """
+        Get the status of a specific job
+
+        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 job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return self._get(
+            f"/jobs/{job_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=UploadStatusResponse,
+        )
+
+
+class AsyncUploadsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncUploadsResourceWithRawResponse:
+        """
+        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/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncUploadsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncUploadsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return AsyncUploadsResourceWithStreamingResponse(self)
+
+    async def status(
+        self,
+        job_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,
+    ) -> UploadStatusResponse:
+        """
+        Get the status of a specific job
+
+        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 job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return await self._get(
+            f"/jobs/{job_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=UploadStatusResponse,
+        )
+
+
+class UploadsResourceWithRawResponse:
+    def __init__(self, uploads: UploadsResource) -> None:
+        self._uploads = uploads
+
+        self.status = to_raw_response_wrapper(
+            uploads.status,
+        )
+
+
+class AsyncUploadsResourceWithRawResponse:
+    def __init__(self, uploads: AsyncUploadsResource) -> None:
+        self._uploads = uploads
+
+        self.status = async_to_raw_response_wrapper(
+            uploads.status,
+        )
+
+
+class UploadsResourceWithStreamingResponse:
+    def __init__(self, uploads: UploadsResource) -> None:
+        self._uploads = uploads
+
+        self.status = to_streamed_response_wrapper(
+            uploads.status,
+        )
+
+
+class AsyncUploadsResourceWithStreamingResponse:
+    def __init__(self, uploads: AsyncUploadsResource) -> None:
+        self._uploads = uploads
+
+        self.status = async_to_streamed_response_wrapper(
+            uploads.status,
+        )

together/types/__init__.py

@@ -25,7 +25,6 @@ from .eval_list_params import EvalListParams as EvalListParams
 from .execute_response import ExecuteResponse as ExecuteResponse
 from .autoscaling_param import AutoscalingParam as AutoscalingParam
 from .finetune_response import FinetuneResponse as FinetuneResponse
-from .job_list_response import JobListResponse as JobListResponse
 from .model_list_params import ModelListParams as ModelListParams
 from .tool_choice_param import ToolChoiceParam as ToolChoiceParam
 from .dedicated_endpoint import DedicatedEndpoint as DedicatedEndpoint
@@ -45,7 +44,6 @@ from .hardware_list_params import HardwareListParams as HardwareListParams
 from .rerank_create_params import RerankCreateParams as RerankCreateParams
 from .batch_create_response import BatchCreateResponse as BatchCreateResponse
 from .image_generate_params import ImageGenerateParams as ImageGenerateParams
-from .job_retrieve_response import JobRetrieveResponse as JobRetrieveResponse
 from .model_upload_response import ModelUploadResponse as ModelUploadResponse
 from .endpoint_create_params import EndpointCreateParams as EndpointCreateParams
 from .endpoint_list_response import EndpointListResponse as EndpointListResponse

together/types/beta/__init__.py

@@ -3,8 +3,14 @@
 from __future__ import annotations
 
 from .cluster import Cluster as Cluster
+from .deployment import Deployment as Deployment
+from .deployment_logs import DeploymentLogs as DeploymentLogs
+from .jig_deploy_params import JigDeployParams as JigDeployParams
+from .jig_list_response import JigListResponse as JigListResponse
+from .jig_update_params import JigUpdateParams as JigUpdateParams
 from .cluster_create_params import ClusterCreateParams as ClusterCreateParams
 from .cluster_list_response import ClusterListResponse as ClusterListResponse
 from .cluster_update_params import ClusterUpdateParams as ClusterUpdateParams
 from .cluster_delete_response import ClusterDeleteResponse as ClusterDeleteResponse
+from .jig_retrieve_logs_params import JigRetrieveLogsParams as JigRetrieveLogsParams
 from .cluster_list_regions_response import ClusterListRegionsResponse as ClusterListRegionsResponse

together/types/beta/deployment.py

@@ -0,0 +1,261 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from ..._models import BaseModel
+
+__all__ = [
+    "Deployment",
+    "EnvironmentVariable",
+    "ReplicaEvents",
+    "ReplicaEventsContainerStatus",
+    "ReplicaEventsEvent",
+    "Volume",
+]
+
+
+class EnvironmentVariable(BaseModel):
+    name: str
+    """Name is the environment variable name (e.g., "DATABASE_URL").
+
+    Must start with a letter or underscore, followed by letters, numbers, or
+    underscores
+    """
+
+    value: Optional[str] = None
+    """Value is the plain text value for the environment variable.
+
+    Use this for non-sensitive values. Either Value or ValueFromSecret must be set,
+    but not both
+    """
+
+    value_from_secret: Optional[str] = None
+    """ValueFromSecret references a secret by name or ID to use as the value.
+
+    Use this for sensitive values like API keys or passwords. Either Value or
+    ValueFromSecret must be set, but not both
+    """
+
+
+class ReplicaEventsContainerStatus(BaseModel):
+    """
+    ContainerStatus provides detailed status information about the container within this replica
+    """
+
+    finished_at: Optional[str] = FieldInfo(alias="finishedAt", default=None)
+    """
+    FinishedAt is the timestamp when the container finished execution (if
+    terminated)
+    """
+
+    message: Optional[str] = None
+    """
+    Message provides a human-readable message with details about the container's
+    status
+    """
+
+    name: Optional[str] = None
+    """Name is the name of the container"""
+
+    reason: Optional[str] = None
+    """
+    Reason provides a brief machine-readable reason for the container's current
+    status
+    """
+
+    started_at: Optional[str] = FieldInfo(alias="startedAt", default=None)
+    """StartedAt is the timestamp when the container started execution"""
+
+    status: Optional[str] = None
+    """
+    Status is the current state of the container (e.g., "Running", "Terminated",
+    "Waiting")
+    """
+
+
+class ReplicaEventsEvent(BaseModel):
+    action: Optional[str] = None
+    """Action is the action taken or reported by this event"""
+
+    count: Optional[int] = None
+    """Count is the number of times this event has occurred"""
+
+    first_seen: Optional[str] = None
+    """FirstSeen is the timestamp when this event was first observed"""
+
+    last_seen: Optional[str] = None
+    """LastSeen is the timestamp when this event was last observed"""
+
+    message: Optional[str] = None
+    """Message is a human-readable description of the event"""
+
+    reason: Optional[str] = None
+    """
+    Reason is a brief machine-readable reason for this event (e.g., "Pulling",
+    "Started", "Failed")
+    """
+
+
+class ReplicaEvents(BaseModel):
+    container_status: Optional[ReplicaEventsContainerStatus] = None
+    """
+    ContainerStatus provides detailed status information about the container within
+    this replica
+    """
+
+    events: Optional[List[ReplicaEventsEvent]] = None
+    """
+    Events is a list of Kubernetes events related to this replica for
+    troubleshooting
+    """
+
+    replica_completed_at: Optional[str] = None
+    """ReplicaCompletedAt is the timestamp when the replica finished execution"""
+
+    replica_marked_for_termination_at: Optional[str] = None
+    """
+    ReplicaMarkedForTerminationAt is the timestamp when the replica was marked for
+    termination
+    """
+
+    replica_ready_since: Optional[str] = None
+    """
+    ReplicaReadySince is the timestamp when the replica became ready to serve
+    traffic
+    """
+
+    replica_running_since: Optional[str] = None
+    """ReplicaRunningSince is the timestamp when the replica entered the running state"""
+
+    replica_started_at: Optional[str] = None
+    """ReplicaStartedAt is the timestamp when the replica was created"""
+
+    replica_status: Optional[str] = None
+    """
+    ReplicaStatus is the current status of the replica (e.g., "Running", "Pending",
+    "Failed")
+    """
+
+    replica_status_message: Optional[str] = None
+    """
+    ReplicaStatusMessage provides a human-readable message explaining the replica's
+    status
+    """
+
+    replica_status_reason: Optional[str] = None
+    """
+    ReplicaStatusReason provides a brief machine-readable reason for the replica's
+    status
+    """
+
+    scheduled_on_cluster: Optional[str] = None
+    """ScheduledOnCluster identifies which cluster this replica is scheduled on"""
+
+
+class Volume(BaseModel):
+    mount_path: str
+    """
+    MountPath is the path in the container where the volume will be mounted (e.g.,
+    "/data")
+    """
+
+    name: str
+    """Name is the name of the volume to mount.
+
+    Must reference an existing volume by name or ID
+    """
+
+
+class Deployment(BaseModel):
+    id: Optional[str] = None
+    """ID is the unique identifier of the deployment"""
+
+    args: Optional[List[str]] = None
+    """Args are the arguments passed to the container's command"""
+
+    autoscaling: Optional[Dict[str, str]] = None
+    """Autoscaling contains autoscaling configuration parameters for this deployment"""
+
+    command: Optional[List[str]] = None
+    """Command is the entrypoint command run in the container"""
+
+    cpu: Optional[float] = None
+    """
+    CPU is the amount of CPU resource allocated to each replica in cores (fractional
+    value is allowed)
+    """
+
+    created_at: Optional[str] = None
+    """CreatedAt is the ISO8601 timestamp when this deployment was created"""
+
+    description: Optional[str] = None
+    """
+    Description provides a human-readable explanation of the deployment's purpose or
+    content
+    """
+
+    desired_replicas: Optional[int] = None
+    """DesiredReplicas is the number of replicas that the orchestrator is targeting"""
+
+    environment_variables: Optional[List[EnvironmentVariable]] = None
+    """EnvironmentVariables is a list of environment variables set in the container"""
+
+    gpu_count: Optional[int] = None
+    """GPUCount is the number of GPUs allocated to each replica in this deployment"""
+
+    gpu_type: Optional[Literal["h100-80gb", " a100-80gb"]] = None
+    """GPUType specifies the type of GPU requested (if any) for this deployment"""
+
+    health_check_path: Optional[str] = None
+    """HealthCheckPath is the HTTP path used for health checks of the application"""
+
+    image: Optional[str] = None
+    """Image specifies the container image used for this deployment"""
+
+    max_replicas: Optional[int] = None
+    """MaxReplicas is the maximum number of replicas to run for this deployment"""
+
+    memory: Optional[float] = None
+    """
+    Memory is the amount of memory allocated to each replica in GiB (fractional
+    value is allowed)
+    """
+
+    min_replicas: Optional[int] = None
+    """MinReplicas is the minimum number of replicas to run for this deployment"""
+
+    name: Optional[str] = None
+    """Name is the name of the deployment"""
+
+    object: Optional[str] = None
+    """Object is the type identifier for this response (always "deployment")"""
+
+    port: Optional[int] = None
+    """Port is the container port that the deployment exposes"""
+
+    ready_replicas: Optional[int] = None
+    """ReadyReplicas is the current number of replicas that are in the Ready state"""
+
+    replica_events: Optional[Dict[str, ReplicaEvents]] = None
+    """ReplicaEvents is a mapping of replica names or IDs to their status events"""
+
+    status: Optional[Literal["Updating", "Scaling", "Ready", "Failed"]] = None
+    """
+    Status represents the overall status of the deployment (e.g., Updating, Scaling,
+    Ready, Failed)
+    """
+
+    storage: Optional[int] = None
+    """
+    Storage is the amount of storage (in MB or units as defined by the platform)
+    allocated to each replica
+    """
+
+    updated_at: Optional[str] = None
+    """UpdatedAt is the ISO8601 timestamp when this deployment was last updated"""
+
+    volumes: Optional[List[Volume]] = None
+    """Volumes is a list of volume mounts for this deployment"""

together/types/beta/deployment_logs.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["DeploymentLogs"]
+
+
+class DeploymentLogs(BaseModel):
+    lines: Optional[List[str]] = None

together/types/beta/jig/__init__.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .secret import Secret as Secret
+from .volume import Volume as Volume
+from .queue_cancel_params import QueueCancelParams as QueueCancelParams
+from .queue_submit_params import QueueSubmitParams as QueueSubmitParams
+from .queue_metrics_params import QueueMetricsParams as QueueMetricsParams
+from .secret_create_params import SecretCreateParams as SecretCreateParams
+from .secret_list_response import SecretListResponse as SecretListResponse
+from .secret_update_params import SecretUpdateParams as SecretUpdateParams
+from .volume_create_params import VolumeCreateParams as VolumeCreateParams
+from .volume_list_response import VolumeListResponse as VolumeListResponse
+from .volume_update_params import VolumeUpdateParams as VolumeUpdateParams
+from .queue_cancel_response import QueueCancelResponse as QueueCancelResponse
+from .queue_retrieve_params import QueueRetrieveParams as QueueRetrieveParams
+from .queue_submit_response import QueueSubmitResponse as QueueSubmitResponse
+from .queue_metrics_response import QueueMetricsResponse as QueueMetricsResponse
+from .queue_retrieve_response import QueueRetrieveResponse as QueueRetrieveResponse

together/types/beta/jig/queue_cancel_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
+
+__all__ = ["QueueCancelParams"]
+
+
+class QueueCancelParams(TypedDict, total=False):
+    model: Required[str]
+
+    request_id: Required[str]

together/types/beta/jig/queue_cancel_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ...._models import BaseModel
+
+__all__ = ["QueueCancelResponse"]
+
+
+class QueueCancelResponse(BaseModel):
+    status: Optional[str] = None

together/types/beta/jig/queue_metrics_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["QueueMetricsParams"]
+
+
+class QueueMetricsParams(TypedDict, total=False):
+    model: Required[str]
+    """Model name to get metrics for"""

together/types/beta/jig/queue_metrics_response.py

@@ -0,0 +1,8 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict
+from typing_extensions import TypeAlias
+
+__all__ = ["QueueMetricsResponse"]
+
+QueueMetricsResponse: TypeAlias = Dict[str, object]

together/types/beta/jig/queue_retrieve_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["QueueRetrieveParams"]
+
+
+class QueueRetrieveParams(TypedDict, total=False):
+    model: Required[str]
+    """Model name"""
+
+    request_id: Required[str]
+    """Request ID"""