runwayml 1.0.0__py3-none-any.whl

runwayml/resources/tasks.py

@@ -0,0 +1,257 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+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.task_retrieve_response import TaskRetrieveResponse
+
+__all__ = ["TasksResource", "AsyncTasksResource"]
+
+
+class TasksResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TasksResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/runwayml/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return TasksResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TasksResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/runwayml/sdk-python#with_streaming_response
+        """
+        return TasksResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        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,
+    ) -> TaskRetrieveResponse:
+        """Return details about a task.
+
+        Consumers of this API should not expect updates
+        more frequent than once every five seconds for a given task.
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._get(
+            f"/v1/tasks/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TaskRetrieveResponse,
+        )
+
+    def delete(
+        self,
+        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,
+    ) -> None:
+        """
+        Tasks that are running, pending, or throttled can be canceled by invoking this
+        method. Invoking this method for other tasks will delete them.
+
+        The output data associated with a deleted task will be deleted from persistent
+        storage in accordance with our data retention policy. Aborted and deleted tasks
+        will not be able to be fetched again in the future.
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/v1/tasks/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncTasksResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTasksResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/runwayml/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncTasksResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTasksResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/runwayml/sdk-python#with_streaming_response
+        """
+        return AsyncTasksResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        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,
+    ) -> TaskRetrieveResponse:
+        """Return details about a task.
+
+        Consumers of this API should not expect updates
+        more frequent than once every five seconds for a given task.
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._get(
+            f"/v1/tasks/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TaskRetrieveResponse,
+        )
+
+    async def delete(
+        self,
+        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,
+    ) -> None:
+        """
+        Tasks that are running, pending, or throttled can be canceled by invoking this
+        method. Invoking this method for other tasks will delete them.
+
+        The output data associated with a deleted task will be deleted from persistent
+        storage in accordance with our data retention policy. Aborted and deleted tasks
+        will not be able to be fetched again in the future.
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/v1/tasks/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class TasksResourceWithRawResponse:
+    def __init__(self, tasks: TasksResource) -> None:
+        self._tasks = tasks
+
+        self.retrieve = to_raw_response_wrapper(
+            tasks.retrieve,
+        )
+        self.delete = to_raw_response_wrapper(
+            tasks.delete,
+        )
+
+
+class AsyncTasksResourceWithRawResponse:
+    def __init__(self, tasks: AsyncTasksResource) -> None:
+        self._tasks = tasks
+
+        self.retrieve = async_to_raw_response_wrapper(
+            tasks.retrieve,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            tasks.delete,
+        )
+
+
+class TasksResourceWithStreamingResponse:
+    def __init__(self, tasks: TasksResource) -> None:
+        self._tasks = tasks
+
+        self.retrieve = to_streamed_response_wrapper(
+            tasks.retrieve,
+        )
+        self.delete = to_streamed_response_wrapper(
+            tasks.delete,
+        )
+
+
+class AsyncTasksResourceWithStreamingResponse:
+    def __init__(self, tasks: AsyncTasksResource) -> None:
+        self._tasks = tasks
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            tasks.retrieve,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            tasks.delete,
+        )

runwayml/types/__init__.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .task_retrieve_response import TaskRetrieveResponse as TaskRetrieveResponse
+from .image_to_video_create_params import ImageToVideoCreateParams as ImageToVideoCreateParams
+from .image_to_video_create_response import ImageToVideoCreateResponse as ImageToVideoCreateResponse

runwayml/types/image_to_video_create_params.py

@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ImageToVideoCreateParams"]
+
+
+class ImageToVideoCreateParams(TypedDict, total=False):
+    model: Required[Literal["gen3a_turbo"]]
+    """The model variant to use."""
+
+    prompt_image: Required[Annotated[str, PropertyInfo(alias="promptImage")]]
+    """A HTTPS URL pointing to an image.
+
+    Images must be JPEG, PNG, or WebP and are limited to 16MB. Responses must
+    include a valid `Content-Length` header.
+    """
+
+    prompt_text: Annotated[str, PropertyInfo(alias="promptText")]
+
+    seed: int
+    """If unspecified, a random number is chosen.
+
+    Varying the seed integer is a way to get different results for the same other
+    request parameters. Using the same seed integer for an identical request will
+    produce similar results.
+    """
+
+    watermark: bool
+    """
+    A boolean indicating whether or not the output video will contain a Runway
+    watermark.
+    """

runwayml/types/image_to_video_create_response.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+
+
+from .._models import BaseModel
+
+__all__ = ["ImageToVideoCreateResponse"]
+
+
+class ImageToVideoCreateResponse(BaseModel):
+    id: str
+    """The ID of the newly created task."""

runwayml/types/task_retrieve_response.py

@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["TaskRetrieveResponse"]
+
+
+class TaskRetrieveResponse(BaseModel):
+    id: str
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """The timestamp that the task was submitted at."""
+
+    status: Literal["RUNNING", "SUCCEEDED", "FAILED", "PENDING", "CANCELLED", "THROTTLED"]
+    """
+    - `PENDING` tasks have been enqueued and are waiting to run.
+    - `THROTTLED` tasks are waiting to be enqueued until other jobs have finished
+      running.
+    - `RUNNING` tasks are currently being processed.
+    - `SUCCEEDED` tasks have completed successfully.
+    - `FAILED` tasks have failed.
+    - `CANCELLED` tasks have been aborted.
+    """
+
+    failure: Optional[str] = None
+    """
+    If the status is `FAILED`, this will contain a human-friendly reason for the
+    failure.
+    """
+
+    failure_code: Optional[str] = FieldInfo(alias="failureCode", default=None)
+    """
+    If the task has a status of `FAILED`, this contains a machine-readable error
+    code. This is a dot-separated string, with the leftmost segment being the most
+    generic and the rightmost segment being the most specific. For example,
+    `SAFETY.INPUT.TEXT` would indicate that the task failed due to a content
+    moderation error on the input text.
+    """
+
+    output: Optional[List[str]] = None
+    """If the status is `SUCCEEDED`, this will contain an array of strings.
+
+    Each string will be a URL that returns an output from the task. URLs expire
+    within 24-48 hours; fetch the task again to get fresh URLs. It is expected that
+    you download the assets at these URLs and store them in your own storage system.
+    """
+
+    progress: Optional[float] = None
+    """
+    If the task has a status of `RUNNING`, this will contain a floating point number
+    between 0 and 1 representing the progress of the generation.
+    """