runwayml 3.8.0__tar.gz → 3.9.0__tar.gz

runwayml-3.9.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "3.9.0"
+}

{runwayml-3.8.0 → runwayml-3.9.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 3.9.0 (2025-08-01)
+
+Full Changelog: [v3.8.0...v3.9.0](https://github.com/runwayml/sdk-python/compare/v3.8.0...v3.9.0)
+
+### Features
+
+* **api:** Gen-4 Aleph ([b1cf4db](https://github.com/runwayml/sdk-python/commit/b1cf4db0265fa866abf31ac0ffaf6b1ee0b9140c))
+
 ## 3.8.0 (2025-07-31)
 
 Full Changelog: [v3.7.2...v3.8.0](https://github.com/runwayml/sdk-python/compare/v3.7.2...v3.8.0)

{runwayml-3.8.0 → runwayml-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: runwayml
-Version: 3.8.0
+Version: 3.9.0
 Summary: The official Python library for the runwayml API
 Project-URL: Homepage, https://github.com/runwayml/sdk-python
 Project-URL: Repository, https://github.com/runwayml/sdk-python

{runwayml-3.8.0 → runwayml-3.9.0}/api.md

@@ -23,6 +23,18 @@ Methods:
 
 - <code title="post /v1/image_to_video">client.image_to_video.<a href="./src/runwayml/resources/image_to_video.py">create</a>(\*\*<a href="src/runwayml/types/image_to_video_create_params.py">params</a>) -> <a href="./src/runwayml/types/image_to_video_create_response.py">ImageToVideoCreateResponse</a></code>
 
+# VideoToVideo
+
+Types:
+
+```python
+from runwayml.types import VideoToVideoCreateResponse
+```
+
+Methods:
+
+- <code title="post /v1/video_to_video">client.video_to_video.<a href="./src/runwayml/resources/video_to_video.py">create</a>(\*\*<a href="src/runwayml/types/video_to_video_create_params.py">params</a>) -> <a href="./src/runwayml/types/video_to_video_create_response.py">VideoToVideoCreateResponse</a></code>
+
 # TextToImage
 
 Types:

{runwayml-3.8.0 → runwayml-3.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runwayml"
-version = "3.8.0"
+version = "3.9.0"
 description = "The official Python library for the runwayml API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/_client.py

@@ -21,7 +21,15 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import tasks, organization, text_to_image, video_upscale, image_to_video, character_performance
+from .resources import (
+    tasks,
+    organization,
+    text_to_image,
+    video_upscale,
+    image_to_video,
+    video_to_video,
+    character_performance,
+)
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import RunwayMLError, APIStatusError
 from ._base_client import (
@@ -45,6 +53,7 @@ __all__ = [
 class RunwayML(SyncAPIClient):
     tasks: tasks.TasksResource
     image_to_video: image_to_video.ImageToVideoResource
+    video_to_video: video_to_video.VideoToVideoResource
     text_to_image: text_to_image.TextToImageResource
     video_upscale: video_upscale.VideoUpscaleResource
     character_performance: character_performance.CharacterPerformanceResource
@@ -114,6 +123,7 @@ class RunwayML(SyncAPIClient):
 
         self.tasks = tasks.TasksResource(self)
         self.image_to_video = image_to_video.ImageToVideoResource(self)
+        self.video_to_video = video_to_video.VideoToVideoResource(self)
         self.text_to_image = text_to_image.TextToImageResource(self)
         self.video_upscale = video_upscale.VideoUpscaleResource(self)
         self.character_performance = character_performance.CharacterPerformanceResource(self)
@@ -232,6 +242,7 @@ class RunwayML(SyncAPIClient):
 class AsyncRunwayML(AsyncAPIClient):
     tasks: tasks.AsyncTasksResource
     image_to_video: image_to_video.AsyncImageToVideoResource
+    video_to_video: video_to_video.AsyncVideoToVideoResource
     text_to_image: text_to_image.AsyncTextToImageResource
     video_upscale: video_upscale.AsyncVideoUpscaleResource
     character_performance: character_performance.AsyncCharacterPerformanceResource
@@ -301,6 +312,7 @@ class AsyncRunwayML(AsyncAPIClient):
 
         self.tasks = tasks.AsyncTasksResource(self)
         self.image_to_video = image_to_video.AsyncImageToVideoResource(self)
+        self.video_to_video = video_to_video.AsyncVideoToVideoResource(self)
         self.text_to_image = text_to_image.AsyncTextToImageResource(self)
         self.video_upscale = video_upscale.AsyncVideoUpscaleResource(self)
         self.character_performance = character_performance.AsyncCharacterPerformanceResource(self)
@@ -420,6 +432,7 @@ class RunwayMLWithRawResponse:
     def __init__(self, client: RunwayML) -> None:
         self.tasks = tasks.TasksResourceWithRawResponse(client.tasks)
         self.image_to_video = image_to_video.ImageToVideoResourceWithRawResponse(client.image_to_video)
+        self.video_to_video = video_to_video.VideoToVideoResourceWithRawResponse(client.video_to_video)
         self.text_to_image = text_to_image.TextToImageResourceWithRawResponse(client.text_to_image)
         self.video_upscale = video_upscale.VideoUpscaleResourceWithRawResponse(client.video_upscale)
         self.character_performance = character_performance.CharacterPerformanceResourceWithRawResponse(
@@ -432,6 +445,7 @@ class AsyncRunwayMLWithRawResponse:
     def __init__(self, client: AsyncRunwayML) -> None:
         self.tasks = tasks.AsyncTasksResourceWithRawResponse(client.tasks)
         self.image_to_video = image_to_video.AsyncImageToVideoResourceWithRawResponse(client.image_to_video)
+        self.video_to_video = video_to_video.AsyncVideoToVideoResourceWithRawResponse(client.video_to_video)
         self.text_to_image = text_to_image.AsyncTextToImageResourceWithRawResponse(client.text_to_image)
         self.video_upscale = video_upscale.AsyncVideoUpscaleResourceWithRawResponse(client.video_upscale)
         self.character_performance = character_performance.AsyncCharacterPerformanceResourceWithRawResponse(
@@ -444,6 +458,7 @@ class RunwayMLWithStreamedResponse:
     def __init__(self, client: RunwayML) -> None:
         self.tasks = tasks.TasksResourceWithStreamingResponse(client.tasks)
         self.image_to_video = image_to_video.ImageToVideoResourceWithStreamingResponse(client.image_to_video)
+        self.video_to_video = video_to_video.VideoToVideoResourceWithStreamingResponse(client.video_to_video)
         self.text_to_image = text_to_image.TextToImageResourceWithStreamingResponse(client.text_to_image)
         self.video_upscale = video_upscale.VideoUpscaleResourceWithStreamingResponse(client.video_upscale)
         self.character_performance = character_performance.CharacterPerformanceResourceWithStreamingResponse(
@@ -456,6 +471,7 @@ class AsyncRunwayMLWithStreamedResponse:
     def __init__(self, client: AsyncRunwayML) -> None:
         self.tasks = tasks.AsyncTasksResourceWithStreamingResponse(client.tasks)
         self.image_to_video = image_to_video.AsyncImageToVideoResourceWithStreamingResponse(client.image_to_video)
+        self.video_to_video = video_to_video.AsyncVideoToVideoResourceWithStreamingResponse(client.video_to_video)
         self.text_to_image = text_to_image.AsyncTextToImageResourceWithStreamingResponse(client.text_to_image)
         self.video_upscale = video_upscale.AsyncVideoUpscaleResourceWithStreamingResponse(client.video_upscale)
         self.character_performance = character_performance.AsyncCharacterPerformanceResourceWithStreamingResponse(

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "runwayml"
-__version__ = "3.8.0"  # x-release-please-version
+__version__ = "3.9.0"  # x-release-please-version

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/resources/__init__.py

@@ -40,6 +40,14 @@ from .image_to_video import (
     ImageToVideoResourceWithStreamingResponse,
     AsyncImageToVideoResourceWithStreamingResponse,
 )
+from .video_to_video import (
+    VideoToVideoResource,
+    AsyncVideoToVideoResource,
+    VideoToVideoResourceWithRawResponse,
+    AsyncVideoToVideoResourceWithRawResponse,
+    VideoToVideoResourceWithStreamingResponse,
+    AsyncVideoToVideoResourceWithStreamingResponse,
+)
 from .character_performance import (
     CharacterPerformanceResource,
     AsyncCharacterPerformanceResource,
@@ -62,6 +70,12 @@ __all__ = [
     "AsyncImageToVideoResourceWithRawResponse",
     "ImageToVideoResourceWithStreamingResponse",
     "AsyncImageToVideoResourceWithStreamingResponse",
+    "VideoToVideoResource",
+    "AsyncVideoToVideoResource",
+    "VideoToVideoResourceWithRawResponse",
+    "AsyncVideoToVideoResourceWithRawResponse",
+    "VideoToVideoResourceWithStreamingResponse",
+    "AsyncVideoToVideoResourceWithStreamingResponse",
     "TextToImageResource",
     "AsyncTextToImageResource",
     "TextToImageResourceWithRawResponse",

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/resources/text_to_image.py

@@ -97,7 +97,7 @@ class TextToImageResource(SyncAPIResource):
           content_moderation: Settings that affect the behavior of the content moderation system.
 
           reference_images: An array of images to be used as references for the generated image output. Up
-              to three reference images can be provided.
+              to three reference images can be provided for `gen4_image`.
 
           seed: 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
@@ -198,7 +198,7 @@ class AsyncTextToImageResource(AsyncAPIResource):
           content_moderation: Settings that affect the behavior of the content moderation system.
 
           reference_images: An array of images to be used as references for the generated image output. Up
-              to three reference images can be provided.
+              to three reference images can be provided for `gen4_image`.
 
           seed: 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

runwayml-3.9.0/src/runwayml/resources/video_to_video.py

@@ -0,0 +1,244 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import video_to_video_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 ..lib.polling import (
+    NewTaskCreatedResponse,
+    AsyncNewTaskCreatedResponse,
+    create_waitable_resource,
+    create_async_waitable_resource,
+)
+from .._base_client import make_request_options
+from ..types.video_to_video_create_response import VideoToVideoCreateResponse
+
+__all__ = ["VideoToVideoResource", "AsyncVideoToVideoResource"]
+
+
+class VideoToVideoResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> VideoToVideoResourceWithRawResponse:
+        """
+        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/runwayml/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return VideoToVideoResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VideoToVideoResourceWithStreamingResponse:
+        """
+        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 VideoToVideoResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        model: Literal["gen4_aleph"],
+        prompt_text: str,
+        ratio: Literal["1280:720", "720:1280", "1104:832", "960:960", "832:1104", "1584:672", "848:480", "640:480"],
+        video_uri: str,
+        content_moderation: video_to_video_create_params.ContentModeration | NotGiven = NOT_GIVEN,
+        references: Iterable[video_to_video_create_params.Reference] | NotGiven = NOT_GIVEN,
+        seed: 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,
+    ) -> NewTaskCreatedResponse:
+        """
+        This endpoint will start a new task to generate a video from a video.
+
+        Args:
+          model: The model variant to use.
+
+          prompt_text: A non-empty string up to 1000 characters (measured in UTF-16 code units). This
+              should describe in detail what should appear in the output.
+
+          ratio: The resolution of the output video.
+
+          video_uri: A HTTPS URL pointing to a video or a data URI containing a video. See
+              [our docs](/assets/inputs#videos) on video inputs for more information.
+
+          content_moderation: Settings that affect the behavior of the content moderation system.
+
+          references: An array of references. Currently up to one reference is supported. See
+              [our docs](/assets/inputs#images) on image inputs for more information.
+
+          seed: 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.
+
+          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(
+            "/v1/video_to_video",
+            body=maybe_transform(
+                {
+                    "model": model,
+                    "prompt_text": prompt_text,
+                    "ratio": ratio,
+                    "video_uri": video_uri,
+                    "content_moderation": content_moderation,
+                    "references": references,
+                    "seed": seed,
+                },
+                video_to_video_create_params.VideoToVideoCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=create_waitable_resource(VideoToVideoCreateResponse, self._client),
+        )
+
+
+class AsyncVideoToVideoResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncVideoToVideoResourceWithRawResponse:
+        """
+        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/runwayml/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncVideoToVideoResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVideoToVideoResourceWithStreamingResponse:
+        """
+        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 AsyncVideoToVideoResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        model: Literal["gen4_aleph"],
+        prompt_text: str,
+        ratio: Literal["1280:720", "720:1280", "1104:832", "960:960", "832:1104", "1584:672", "848:480", "640:480"],
+        video_uri: str,
+        content_moderation: video_to_video_create_params.ContentModeration | NotGiven = NOT_GIVEN,
+        references: Iterable[video_to_video_create_params.Reference] | NotGiven = NOT_GIVEN,
+        seed: 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,
+    ) -> AsyncNewTaskCreatedResponse:
+        """
+        This endpoint will start a new task to generate a video from a video.
+
+        Args:
+          model: The model variant to use.
+
+          prompt_text: A non-empty string up to 1000 characters (measured in UTF-16 code units). This
+              should describe in detail what should appear in the output.
+
+          ratio: The resolution of the output video.
+
+          video_uri: A HTTPS URL pointing to a video or a data URI containing a video. See
+              [our docs](/assets/inputs#videos) on video inputs for more information.
+
+          content_moderation: Settings that affect the behavior of the content moderation system.
+
+          references: An array of references. Currently up to one reference is supported. See
+              [our docs](/assets/inputs#images) on image inputs for more information.
+
+          seed: 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.
+
+          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(
+            "/v1/video_to_video",
+            body=await async_maybe_transform(
+                {
+                    "model": model,
+                    "prompt_text": prompt_text,
+                    "ratio": ratio,
+                    "video_uri": video_uri,
+                    "content_moderation": content_moderation,
+                    "references": references,
+                    "seed": seed,
+                },
+                video_to_video_create_params.VideoToVideoCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=create_async_waitable_resource(VideoToVideoCreateResponse, self._client),
+        )
+
+
+class VideoToVideoResourceWithRawResponse:
+    def __init__(self, video_to_video: VideoToVideoResource) -> None:
+        self._video_to_video = video_to_video
+
+        self.create = to_raw_response_wrapper(
+            video_to_video.create,
+        )
+
+
+class AsyncVideoToVideoResourceWithRawResponse:
+    def __init__(self, video_to_video: AsyncVideoToVideoResource) -> None:
+        self._video_to_video = video_to_video
+
+        self.create = async_to_raw_response_wrapper(
+            video_to_video.create,
+        )
+
+
+class VideoToVideoResourceWithStreamingResponse:
+    def __init__(self, video_to_video: VideoToVideoResource) -> None:
+        self._video_to_video = video_to_video
+
+        self.create = to_streamed_response_wrapper(
+            video_to_video.create,
+        )
+
+
+class AsyncVideoToVideoResourceWithStreamingResponse:
+    def __init__(self, video_to_video: AsyncVideoToVideoResource) -> None:
+        self._video_to_video = video_to_video
+
+        self.create = async_to_streamed_response_wrapper(
+            video_to_video.create,
+        )

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/types/__init__.py

@@ -6,10 +6,12 @@ from .task_retrieve_response import TaskRetrieveResponse as TaskRetrieveResponse
 from .text_to_image_create_params import TextToImageCreateParams as TextToImageCreateParams
 from .video_upscale_create_params import VideoUpscaleCreateParams as VideoUpscaleCreateParams
 from .image_to_video_create_params import ImageToVideoCreateParams as ImageToVideoCreateParams
+from .video_to_video_create_params import VideoToVideoCreateParams as VideoToVideoCreateParams
 from .text_to_image_create_response import TextToImageCreateResponse as TextToImageCreateResponse
 from .video_upscale_create_response import VideoUpscaleCreateResponse as VideoUpscaleCreateResponse
 from .image_to_video_create_response import ImageToVideoCreateResponse as ImageToVideoCreateResponse
 from .organization_retrieve_response import OrganizationRetrieveResponse as OrganizationRetrieveResponse
+from .video_to_video_create_response import VideoToVideoCreateResponse as VideoToVideoCreateResponse
 from .organization_retrieve_usage_params import OrganizationRetrieveUsageParams as OrganizationRetrieveUsageParams
 from .character_performance_create_params import CharacterPerformanceCreateParams as CharacterPerformanceCreateParams
 from .organization_retrieve_usage_response import OrganizationRetrieveUsageResponse as OrganizationRetrieveUsageResponse

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/types/organization_retrieve_response.py

@@ -12,6 +12,7 @@ __all__ = [
     "TierModels",
     "TierModelsActTwo",
     "TierModelsGen3aTurbo",
+    "TierModelsGen4Aleph",
     "TierModelsGen4Image",
     "TierModelsGen4Turbo",
     "TierModelsUpscaleV1",
@@ -19,6 +20,7 @@ __all__ = [
     "UsageModels",
     "UsageModelsActTwo",
     "UsageModelsGen3aTurbo",
+    "UsageModelsGen4Aleph",
     "UsageModelsGen4Image",
     "UsageModelsGen4Turbo",
     "UsageModelsUpscaleV1",
@@ -41,6 +43,14 @@ class TierModelsGen3aTurbo(BaseModel):
     """The maximum number of generations that can be created each day for this model."""
 
 
+class TierModelsGen4Aleph(BaseModel):
+    max_concurrent_generations: int = FieldInfo(alias="maxConcurrentGenerations")
+    """The maximum number of generations that can be run concurrently for this model."""
+
+    max_daily_generations: int = FieldInfo(alias="maxDailyGenerations")
+    """The maximum number of generations that can be created each day for this model."""
+
+
 class TierModelsGen4Image(BaseModel):
     max_concurrent_generations: int = FieldInfo(alias="maxConcurrentGenerations")
     """The maximum number of generations that can be run concurrently for this model."""
@@ -72,6 +82,9 @@ class TierModels(BaseModel):
     gen3a_turbo: Optional[TierModelsGen3aTurbo] = None
     """Limits associated with the gen3a_turbo model."""
 
+    gen4_aleph: Optional[TierModelsGen4Aleph] = None
+    """Limits associated with the gen4_aleph model."""
+
     gen4_image: Optional[TierModelsGen4Image] = None
     """Limits associated with the gen4_image model."""
 
@@ -100,6 +113,11 @@ class UsageModelsGen3aTurbo(BaseModel):
     """The number of generations that have been run for this model in the past day."""
 
 
+class UsageModelsGen4Aleph(BaseModel):
+    daily_generations: int = FieldInfo(alias="dailyGenerations")
+    """The number of generations that have been run for this model in the past day."""
+
+
 class UsageModelsGen4Image(BaseModel):
     daily_generations: int = FieldInfo(alias="dailyGenerations")
     """The number of generations that have been run for this model in the past day."""
@@ -122,6 +140,9 @@ class UsageModels(BaseModel):
     gen3a_turbo: Optional[UsageModelsGen3aTurbo] = None
     """Usage data for the gen3a_turbo model."""
 
+    gen4_aleph: Optional[UsageModelsGen4Aleph] = None
+    """Usage data for the gen4_aleph model."""
+
     gen4_image: Optional[UsageModelsGen4Image] = None
     """Usage data for the gen4_image model."""
 

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/types/organization_retrieve_usage_response.py

@@ -15,7 +15,7 @@ class ResultUsedCredit(BaseModel):
     amount: int
     """The number of credits used for the model."""
 
-    model: Literal["upscale_v1", "act_two", "gen4_image", "gen3a_turbo", "gen4_turbo"]
+    model: Literal["upscale_v1", "act_two", "gen4_image", "gen3a_turbo", "gen4_turbo", "gen4_aleph"]
     """The model whose usage resulted in the credit usage."""
 
 
@@ -31,7 +31,7 @@ class Result(BaseModel):
 
 
 class OrganizationRetrieveUsageResponse(BaseModel):
-    models: List[Literal["upscale_v1", "act_two", "gen4_image", "gen3a_turbo", "gen4_turbo"]]
+    models: List[Literal["upscale_v1", "act_two", "gen4_image", "gen3a_turbo", "gen4_turbo", "gen4_aleph"]]
     """The list of models with usage during the queried time range."""
 
     results: List[Result]

{runwayml-3.8.0 → runwayml-3.9.0}/src/runwayml/types/text_to_image_create_params.py

@@ -48,7 +48,7 @@ class TextToImageCreateParams(TypedDict, total=False):
     reference_images: Annotated[Iterable[ReferenceImage], PropertyInfo(alias="referenceImages")]
     """An array of images to be used as references for the generated image output.
 
-    Up to three reference images can be provided.
+    Up to three reference images can be provided for `gen4_image`.
     """
 
     seed: int

runwayml-3.9.0/src/runwayml/types/video_to_video_create_params.py

@@ -0,0 +1,68 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["VideoToVideoCreateParams", "ContentModeration", "Reference"]
+
+
+class VideoToVideoCreateParams(TypedDict, total=False):
+    model: Required[Literal["gen4_aleph"]]
+    """The model variant to use."""
+
+    prompt_text: Required[Annotated[str, PropertyInfo(alias="promptText")]]
+    """A non-empty string up to 1000 characters (measured in UTF-16 code units).
+
+    This should describe in detail what should appear in the output.
+    """
+
+    ratio: Required[
+        Literal["1280:720", "720:1280", "1104:832", "960:960", "832:1104", "1584:672", "848:480", "640:480"]
+    ]
+    """The resolution of the output video."""
+
+    video_uri: Required[Annotated[str, PropertyInfo(alias="videoUri")]]
+    """A HTTPS URL pointing to a video or a data URI containing a video.
+
+    See [our docs](/assets/inputs#videos) on video inputs for more information.
+    """
+
+    content_moderation: Annotated[ContentModeration, PropertyInfo(alias="contentModeration")]
+    """Settings that affect the behavior of the content moderation system."""
+
+    references: Iterable[Reference]
+    """An array of references.
+
+    Currently up to one reference is supported. See
+    [our docs](/assets/inputs#images) on image inputs for more information.
+    """
+
+    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.
+    """
+
+
+class ContentModeration(TypedDict, total=False):
+    public_figure_threshold: Annotated[Literal["auto", "low"], PropertyInfo(alias="publicFigureThreshold")]
+    """
+    When set to `low`, the content moderation system will be less strict about
+    preventing generations that include recognizable public figures.
+    """
+
+
+class Reference(TypedDict, total=False):
+    type: Required[Literal["image"]]
+
+    uri: Required[str]
+    """A HTTPS URL pointing to an image or a data URI containing an image.
+
+    See [our docs](/assets/inputs#images) on image inputs for more information.
+    """

runwayml-3.9.0/src/runwayml/types/video_to_video_create_response.py

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

runwayml-3.9.0/tests/api_resources/test_video_to_video.py

@@ -0,0 +1,140 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from runwayml import RunwayML, AsyncRunwayML
+from tests.utils import assert_matches_type
+from runwayml.types import VideoToVideoCreateResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestVideoToVideo:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: RunwayML) -> None:
+        video_to_video = client.video_to_video.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+        )
+        assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: RunwayML) -> None:
+        video_to_video = client.video_to_video.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+            content_moderation={"public_figure_threshold": "auto"},
+            references=[
+                {
+                    "type": "image",
+                    "uri": "https://example.com",
+                }
+            ],
+            seed=0,
+        )
+        assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: RunwayML) -> None:
+        response = client.video_to_video.with_raw_response.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video_to_video = response.parse()
+        assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: RunwayML) -> None:
+        with client.video_to_video.with_streaming_response.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video_to_video = response.parse()
+            assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+
+class TestAsyncVideoToVideo:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncRunwayML) -> None:
+        video_to_video = await async_client.video_to_video.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+        )
+        assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncRunwayML) -> None:
+        video_to_video = await async_client.video_to_video.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+            content_moderation={"public_figure_threshold": "auto"},
+            references=[
+                {
+                    "type": "image",
+                    "uri": "https://example.com",
+                }
+            ],
+            seed=0,
+        )
+        assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncRunwayML) -> None:
+        response = await async_client.video_to_video.with_raw_response.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video_to_video = await response.parse()
+        assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncRunwayML) -> None:
+        async with async_client.video_to_video.with_streaming_response.create(
+            model="gen4_aleph",
+            prompt_text="promptText",
+            ratio="1280:720",
+            video_uri="https://example.com",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video_to_video = await response.parse()
+            assert_matches_type(VideoToVideoCreateResponse, video_to_video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True

runwayml-3.8.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "3.8.0"
-}