magic_hour 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

magic_hour/resources/v1/video_projects/client_test.py

@@ -0,0 +1,527 @@
+import datetime
+import pytest
+import httpx
+from pathlib import Path
+from typing import Any, Generator, Literal, Union, List
+from unittest.mock import Mock, AsyncMock
+
+from magic_hour.types import models
+from magic_hour.resources.v1.video_projects.client import (
+    VideoProjectsClient,
+    AsyncVideoProjectsClient,
+)
+
+
+class DummyResponse(models.V1VideoProjectsGetResponse):
+    """Helper response with defaults"""
+
+    def __init__(
+        self,
+        *,
+        status: Literal[
+            "complete", "queued", "rendering", "error", "canceled"
+        ] = "complete",
+        download_url: Union[str, None] = None,
+        error: Union[str, None] = None,
+    ):
+        # Create error object if error string is provided
+        error_obj = None
+        if error:
+            error_obj = models.V1VideoProjectsGetResponseError(
+                code="TEST_ERROR", message=error
+            )
+
+        super().__init__(
+            id="test-id",
+            created_at=datetime.datetime.now().isoformat(),
+            credits_charged=0,
+            download=None,
+            downloads=[
+                models.V1VideoProjectsGetResponseDownloadsItem(
+                    url=download_url, expires_at="2024-01-01T00:00:00Z"
+                )
+            ]
+            if download_url
+            else [],
+            enabled=True,
+            end_seconds=10.0,
+            error=error_obj,
+            fps=30.0,
+            height=1080,
+            name="test-name",
+            start_seconds=0.0,
+            status=status,
+            total_frame_cost=0,
+            type="test-type",
+            width=1920,
+        )
+
+
+@pytest.fixture
+def mock_base_client() -> Generator[Mock, None, None]:
+    yield Mock()
+
+
+@pytest.fixture
+def mock_async_base_client() -> Generator[AsyncMock, None, None]:
+    yield AsyncMock()
+
+
+def test_delete_calls_base_client(mock_base_client: Mock) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+    client.delete(id="123")
+
+    mock_base_client.request.assert_called_once()
+    call = mock_base_client.request.call_args[1]
+    assert call["method"] == "DELETE"
+    assert "/v1/video-projects/123" in call["path"]
+
+
+def test_get_calls_base_client(mock_base_client: Mock) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+    mock_base_client.request.return_value = DummyResponse()
+
+    resp = client.get(id="abc")
+
+    mock_base_client.request.assert_called_once()
+    assert isinstance(resp, models.V1VideoProjectsGetResponse)
+    assert resp.id == "test-id"
+
+
+def test_check_result_no_wait_no_download(mock_base_client: Mock) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+    mock_base_client.request.return_value = DummyResponse(status="queued")
+
+    resp = client.check_result(
+        id="xyz",
+        wait_for_completion=False,
+        download_outputs=False,
+    )
+
+    assert resp.downloaded_paths is None
+
+
+def test_check_result_wait_until_complete(
+    monkeypatch: Any, mock_base_client: Mock
+) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+
+    # First calls return queued, then complete
+    mock_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    monkeypatch.setattr("time.sleep", lambda _: None)  # type: ignore
+
+    resp = client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    assert resp.downloaded_paths is None
+
+
+def test_check_result_download_outputs(
+    tmp_path: Path, mock_base_client: Mock, monkeypatch: Any
+) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+
+    file_url = "https://example.com/file.mp4"
+    mock_base_client.request.return_value = DummyResponse(
+        status="complete",
+        download_url=file_url,
+    )
+
+    # Create a mock response for httpx
+    mock_request = httpx.Request("GET", "https://example.com/file.mp4")
+    mock_response = httpx.Response(200, content=b"fake mp4", request=mock_request)
+
+    # Mock the httpx.Client class
+    class MockClient:
+        def __init__(self):
+            pass
+
+        def __enter__(self) -> "MockClient":
+            return self
+
+        def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+            pass
+
+        def get(self, url: str) -> httpx.Response:
+            return mock_response
+
+    monkeypatch.setattr(httpx, "Client", MockClient)
+
+    resp = client.check_result(
+        id="xyz",
+        wait_for_completion=True,
+        download_outputs=True,
+        download_directory=str(tmp_path),
+    )
+
+    assert resp.status == "complete"
+    assert resp.downloaded_paths
+    saved_file = Path(resp.downloaded_paths[0])
+    assert saved_file.exists()
+    assert saved_file.read_bytes() == b"fake mp4"
+
+
+def test_check_result_error_status(mock_base_client: Mock) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+    mock_base_client.request.return_value = DummyResponse(status="error", error="Boom!")
+
+    resp = client.check_result(
+        id="err", wait_for_completion=True, download_outputs=False
+    )
+    assert resp.status == "error"
+    assert resp.error is not None
+    assert resp.error.message == "Boom!"
+    assert resp.downloaded_paths is None
+
+
+def test_check_result_canceled_status(mock_base_client: Mock) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+    mock_base_client.request.return_value = DummyResponse(status="canceled")
+
+    resp = client.check_result(
+        id="cancel", wait_for_completion=True, download_outputs=False
+    )
+    assert resp.status == "canceled"
+    assert resp.downloaded_paths is None
+
+
+def test_check_result_poll_interval_default(
+    mock_base_client: Mock, monkeypatch: Any
+) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+
+    # First calls return queued, then complete
+    mock_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    # Mock time.sleep to track calls
+    sleep_calls: List[float] = []
+
+    def mock_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    monkeypatch.setattr("time.sleep", mock_sleep)
+
+    resp = client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    # Should have slept once with default interval (0.5)
+    assert len(sleep_calls) == 1
+    assert sleep_calls[0] == 0.5
+
+
+def test_check_result_poll_interval_custom(
+    mock_base_client: Mock, monkeypatch: Any
+) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+
+    # Set custom poll interval
+    monkeypatch.setenv("MAGIC_HOUR_POLL_INTERVAL", "1.0")
+
+    # First calls return queued, then complete
+    mock_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    # Mock time.sleep to track calls
+    sleep_calls: List[float] = []
+
+    def mock_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    monkeypatch.setattr("time.sleep", mock_sleep)
+
+    resp = client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    # Should have slept once with custom interval (1.0)
+    assert len(sleep_calls) == 1
+    assert sleep_calls[0] == 1.0
+
+
+def test_check_result_poll_interval_multiple_polls(
+    mock_base_client: Mock, monkeypatch: Any
+) -> None:
+    client = VideoProjectsClient(base_client=mock_base_client)
+
+    # Set custom poll interval
+    monkeypatch.setenv("MAGIC_HOUR_POLL_INTERVAL", "0.1")
+
+    # Multiple calls return queued before complete
+    mock_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="queued"),
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    # Mock time.sleep to track calls
+    sleep_calls: List[float] = []
+
+    def mock_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    monkeypatch.setattr("time.sleep", mock_sleep)
+
+    resp = client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    # Should have slept 3 times with custom interval (0.1)
+    assert len(sleep_calls) == 3
+    assert all(sleep_time == 0.1 for sleep_time in sleep_calls)
+
+
+@pytest.mark.asyncio
+async def test_async_delete_calls_base_client(
+    mock_async_base_client: AsyncMock,
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+    await client.delete(id="456")
+
+    mock_async_base_client.request.assert_called_once()
+    call = mock_async_base_client.request.call_args[1]
+    assert call["method"] == "DELETE"
+    assert "/v1/video-projects/456" in call["path"]
+
+
+@pytest.mark.asyncio
+async def test_async_get_calls_base_client(mock_async_base_client: AsyncMock) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+    mock_async_base_client.request.return_value = DummyResponse()
+
+    resp = await client.get(id="zzz")
+
+    mock_async_base_client.request.assert_called_once()
+    assert isinstance(resp, models.V1VideoProjectsGetResponse)
+    assert resp.id == "test-id"
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_no_wait_no_download(
+    mock_async_base_client: AsyncMock,
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+    mock_async_base_client.request.return_value = DummyResponse(status="queued")
+
+    resp = await client.check_result(
+        id="xyz",
+        wait_for_completion=False,
+        download_outputs=False,
+    )
+
+    assert resp.downloaded_paths is None
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_wait_until_complete(
+    mock_async_base_client: AsyncMock, monkeypatch: Any
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+
+    # First calls return queued, then complete
+    mock_async_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    monkeypatch.setattr("time.sleep", lambda _: None)  # type: ignore
+
+    resp = await client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    assert resp.downloaded_paths is None
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_download_outputs(
+    tmp_path: Path, mock_async_base_client: AsyncMock, monkeypatch: Any
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+
+    file_url = "https://example.com/file.mp4"
+    mock_async_base_client.request.return_value = DummyResponse(
+        status="complete",
+        download_url=file_url,
+    )
+
+    # Create a mock response for httpx
+    mock_request = httpx.Request("GET", "https://example.com/file.mp4")
+    mock_response = httpx.Response(200, content=b"fake mp4", request=mock_request)
+
+    # Mock the httpx.AsyncClient class
+    class MockAsyncClient:
+        def __init__(self):
+            pass
+
+        async def __aenter__(self) -> "MockAsyncClient":
+            return self
+
+        async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+            pass
+
+        async def get(self, url: str) -> httpx.Response:
+            return mock_response
+
+    monkeypatch.setattr(httpx, "AsyncClient", MockAsyncClient)
+
+    resp = await client.check_result(
+        id="xyz",
+        wait_for_completion=True,
+        download_outputs=True,
+        download_directory=str(tmp_path),
+    )
+
+    assert resp.status == "complete"
+    assert resp.downloaded_paths
+    saved_file = Path(resp.downloaded_paths[0])
+    assert saved_file.exists()
+    assert saved_file.read_bytes() == b"fake mp4"
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_error_status(
+    mock_async_base_client: AsyncMock,
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+    mock_async_base_client.request.return_value = DummyResponse(
+        status="error", error="Boom!"
+    )
+
+    resp = await client.check_result(
+        id="err", wait_for_completion=True, download_outputs=False
+    )
+    assert resp.status == "error"
+    assert resp.error is not None
+    assert resp.error.message == "Boom!"
+    assert resp.downloaded_paths is None
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_canceled_status(
+    mock_async_base_client: AsyncMock,
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+    mock_async_base_client.request.return_value = DummyResponse(status="canceled")
+
+    resp = await client.check_result(
+        id="cancel", wait_for_completion=True, download_outputs=False
+    )
+    assert resp.status == "canceled"
+    assert resp.downloaded_paths is None
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_poll_interval_default(
+    mock_async_base_client: AsyncMock, monkeypatch: Any
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+
+    # First calls return queued, then complete
+    mock_async_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    # Mock time.sleep to track calls
+    sleep_calls: List[float] = []
+
+    def mock_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    monkeypatch.setattr("time.sleep", mock_sleep)
+
+    resp = await client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    # Should have slept once with default interval (0.5)
+    assert len(sleep_calls) == 1
+    assert sleep_calls[0] == 0.5
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_poll_interval_custom(
+    mock_async_base_client: AsyncMock, monkeypatch: Any
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+
+    # Set custom poll interval
+    monkeypatch.setenv("MAGIC_HOUR_POLL_INTERVAL", "2.0")
+
+    # First calls return queued, then complete
+    mock_async_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    # Mock time.sleep to track calls
+    sleep_calls: List[float] = []
+
+    def mock_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    monkeypatch.setattr("time.sleep", mock_sleep)
+
+    resp = await client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    # Should have slept once with custom interval (2.0)
+    assert len(sleep_calls) == 1
+    assert sleep_calls[0] == 2.0
+
+
+@pytest.mark.asyncio
+async def test_async_check_result_poll_interval_multiple_polls(
+    mock_async_base_client: AsyncMock, monkeypatch: Any
+) -> None:
+    client = AsyncVideoProjectsClient(base_client=mock_async_base_client)
+
+    # Set custom poll interval
+    monkeypatch.setenv("MAGIC_HOUR_POLL_INTERVAL", "0.3")
+
+    # Multiple calls return queued before complete
+    mock_async_base_client.request.side_effect = [
+        DummyResponse(status="queued"),
+        DummyResponse(status="queued"),
+        DummyResponse(status="queued"),
+        DummyResponse(status="complete"),
+    ]
+
+    # Mock time.sleep to track calls
+    sleep_calls: List[float] = []
+
+    def mock_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    monkeypatch.setattr("time.sleep", mock_sleep)
+
+    resp = await client.check_result(
+        id="xyz", wait_for_completion=True, download_outputs=False
+    )
+
+    assert resp.status == "complete"
+    # Should have slept 3 times with custom interval (0.3)
+    assert len(sleep_calls) == 3
+    assert all(sleep_time == 0.3 for sleep_time in sleep_calls)

magic_hour/resources/v1/video_to_video/README.md

@@ -1,3 +1,82 @@
+# v1_video_to_video
+
+## Module Functions
+
+<!-- CUSTOM DOCS START -->
+
+### Video To Video Generate Workflow <a name="generate"></a>
+
+The workflow performs the following action
+
+1. upload local assets to Magic Hour storage. So you can pass in a local path instead of having to upload files yourself
+2. trigger a generation
+3. poll for a completion status. This is configurable
+4. if success, download the output to local directory
+
+> [!TIP]
+> This is the recommended way to use the SDK unless you have specific needs where it is necessary to split up the actions.
+
+#### Parameters
+
+In Additional to the parameters listed in the `.create` section below, `.generate` introduces 3 new parameters:
+
+- `wait_for_completion` (bool, default True): Whether to wait for the project to complete.
+- `download_outputs` (bool, default True): Whether to download the generated files
+- `download_directory` (str, optional): Directory to save downloaded files (defaults to current directory)
+
+#### Synchronous Client
+
+```python
+from magic_hour import Client
+from os import getenv
+
+client = Client(token=getenv("API_TOKEN"))
+res = client.v1.video_to_video.generate(
+    assets={"video_file_path": "/path/to/1234.mp4", "video_source": "file"},
+    end_seconds=15.0,
+    start_seconds=0.0,
+    style={
+        "art_style": "3D Render",
+        "model": "default",
+        "prompt": "string",
+        "prompt_type": "default",
+        "version": "default",
+    },
+    fps_resolution="HALF",
+    name="Video To Video video",
+    wait_for_completion=True,
+    download_outputs=True,
+    download_directory="outputs"
+)
+```
+
+#### Asynchronous Client
+
+```python
+from magic_hour import AsyncClient
+from os import getenv
+
+client = AsyncClient(token=getenv("API_TOKEN"))
+res = await client.v1.video_to_video.generate(
+    assets={"video_file_path": "/path/to/1234.mp4", "video_source": "file"},
+    end_seconds=15.0,
+    start_seconds=0.0,
+    style={
+        "art_style": "3D Render",
+        "model": "default",
+        "prompt": "string",
+        "prompt_type": "default",
+        "version": "default",
+    },
+    fps_resolution="HALF",
+    name="Video To Video video",
+    wait_for_completion=True,
+    download_outputs=True,
+    download_directory="outputs"
+)
+```
+
+<!-- CUSTOM DOCS END -->
 
 ### Video-to-Video <a name="create"></a>
 
@@ -10,16 +89,24 @@ Get more information about this mode at our [product page](https://magichour.ai/
 
 #### Parameters
 
-| Parameter | Required | Description | Example |
-|-----------|:--------:|-------------|--------|
-| `assets` | ✓ | Provide the assets for video-to-video. For video, The `video_source` field determines whether `video_file_path` or `youtube_url` field is used | `{"video_file_path": "api-assets/id/1234.mp4", "video_source": "file"}` |
-| `end_seconds` | ✓ | The end time of the input video in seconds. This value is used to trim the input video. The value must be greater than 0.1, and more than the start_seconds. | `15.0` |
-| `start_seconds` | ✓ | The start time of the input video in seconds. This value is used to trim the input video. The value must be greater than 0. | `0.0` |
-| `style` | ✓ |  | `{"art_style": "3D Render", "model": "default", "prompt": "string", "prompt_type": "default", "version": "default"}` |
-| `fps_resolution` | ✗ | Determines whether the resulting video will have the same frame per second as the original video, or half.  * `FULL` - the result video will have the same FPS as the input video * `HALF` - the result video will have half the FPS as the input video | `"HALF"` |
-| `height` | ✗ | `height` is deprecated and no longer influences the output video's resolution.  Output resolution is determined by the **minimum** of: - The resolution of the input video - The maximum resolution allowed by your subscription tier. See our [pricing page](https://magichour.ai/pricing) for more details.  This field is retained only for backward compatibility and will be removed in a future release. | `123` |
-| `name` | ✗ | The name of video. This value is mainly used for your own identification of the video. | `"Video To Video video"` |
-| `width` | ✗ | `width` is deprecated and no longer influences the output video's resolution.  Output resolution is determined by the **minimum** of: - The resolution of the input video - The maximum resolution allowed by your subscription tier. See our [pricing page](https://magichour.ai/pricing) for more details.  This field is retained only for backward compatibility and will be removed in a future release. | `123` |
+| Parameter | Required | Deprecated | Description | Example |
+|-----------|:--------:|:----------:|-------------|--------|
+| `assets` | ✓ | ✗ | Provide the assets for video-to-video. For video, The `video_source` field determines whether `video_file_path` or `youtube_url` field is used | `{"video_file_path": "api-assets/id/1234.mp4", "video_source": "file"}` |
+| `└─ video_file_path` | ✗ | — | Required if `video_source` is `file`. This value is either - a direct URL to the video file - `file_path` field from the response of the [upload urls API](https://docs.magichour.ai/api-reference/files/generate-asset-upload-urls).  Please refer to the [Input File documentation](https://docs.magichour.ai/api-reference/files/generate-asset-upload-urls#input-file) to learn more.  | `"api-assets/id/1234.mp4"` |
+| `└─ video_source` | ✓ | — |  | `"file"` |
+| `└─ youtube_url` | ✗ | — | Using a youtube video as the input source. This field is required if `video_source` is `youtube` | `"http://www.example.com"` |
+| `end_seconds` | ✓ | ✗ | The end time of the input video in seconds. This value is used to trim the input video. The value must be greater than 0.1, and more than the start_seconds. | `15.0` |
+| `start_seconds` | ✓ | ✗ | The start time of the input video in seconds. This value is used to trim the input video. The value must be greater than 0. | `0.0` |
+| `style` | ✓ | ✗ |  | `{"art_style": "3D Render", "model": "default", "prompt": "string", "prompt_type": "default", "version": "default"}` |
+| `└─ art_style` | ✓ | — |  | `"3D Render"` |
+| `└─ model` | ✓ | — | * `Dreamshaper` - a good all-around model that works for both animations as well as realism.  * `Absolute Reality` - better at realism, but you'll often get similar results with Dreamshaper as well.  * `Flat 2D Anime` - best for a flat illustration style that's common in most anime. * `default` - use the default recommended model for the selected art style. | `"default"` |
+| `└─ prompt` | ✓ | — | The prompt used for the video. Prompt is required if `prompt_type` is `custom` or `append_default`. If `prompt_type` is `default`, then the `prompt` value passed will be ignored. | `"string"` |
+| `└─ prompt_type` | ✓ | — | * `default` - Use the default recommended prompt for the art style. * `custom` - Only use the prompt passed in the API. Note: for v1, lora prompt will still be auto added to apply the art style properly. * `append_default` - Add the default recommended prompt to the end of the prompt passed in the API. | `"default"` |
+| `└─ version` | ✓ | — | * `v1` - more detail, closer prompt adherence, and frame-by-frame previews. * `v2` - faster, more consistent, and less noisy. * `default` - use the default version for the selected art style. | `"default"` |
+| `fps_resolution` | ✗ | ✗ | Determines whether the resulting video will have the same frame per second as the original video, or half.  * `FULL` - the result video will have the same FPS as the input video * `HALF` - the result video will have half the FPS as the input video | `"HALF"` |
+| `height` | ✗ | ✓ | `height` is deprecated and no longer influences the output video's resolution.  Output resolution is determined by the **minimum** of: - The resolution of the input video - The maximum resolution allowed by your subscription tier. See our [pricing page](https://magichour.ai/pricing) for more details.  This field is retained only for backward compatibility and will be removed in a future release. | `123` |
+| `name` | ✗ | ✗ | The name of video. This value is mainly used for your own identification of the video. | `"Video To Video video"` |
+| `width` | ✗ | ✓ | `width` is deprecated and no longer influences the output video's resolution.  Output resolution is determined by the **minimum** of: - The resolution of the input video - The maximum resolution allowed by your subscription tier. See our [pricing page](https://magichour.ai/pricing) for more details.  This field is retained only for backward compatibility and will be removed in a future release. | `123` |
 
 #### Synchronous Client
 
@@ -76,3 +163,4 @@ res = await client.v1.video_to_video.create(
 
 ##### Example
 `{"credits_charged": 450, "estimated_frame_cost": 450, "id": "cuid-example"}`
+