magic_hour 0.9.5__py3-none-any.whl → 0.44.0__py3-none-any.whl

magic_hour/resources/v1/files/client_test.py

@@ -0,0 +1,414 @@
+import pytest
+import tempfile
+import os
+import io
+import pathlib
+from unittest import mock
+
+from magic_hour import AsyncClient, Client
+from magic_hour.environment import Environment
+
+
+def test_upload_file_local():
+    data = b"test data"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
+        tmp.write(data)
+        tmp_path = tmp.name
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        mock_put.return_value = mock.Mock(
+            status_code=200, raise_for_status=lambda: None
+        )
+        result = client.v1.files.upload_file(tmp_path)
+        assert result == "api-assets/id/video.mp4"
+        mock_put.assert_called_once_with(url=mock.ANY, content=data)
+
+    os.remove(tmp_path)
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_local():
+    data = b"test data"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+        tmp.write(data)
+        tmp_path = tmp.name
+
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.AsyncClient.put", new_callable=mock.AsyncMock) as mock_put:
+        mock_put.return_value = mock.Mock(
+            status_code=200, raise_for_status=lambda: None
+        )
+        result = await client.v1.files.upload_file(tmp_path)
+        assert result == "api-assets/id/video.mp4"
+        mock_put.assert_awaited_once_with(url=mock.ANY, content=data)
+
+    os.remove(tmp_path)
+
+
+def test_upload_file_with_binary_io():
+    data = b"test image data"
+    file_obj = io.BytesIO(data)
+    file_obj.name = "test.png"  # Required for extension detection
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        mock_put.return_value = mock.Mock(
+            status_code=200, raise_for_status=lambda: None
+        )
+        result = client.v1.files.upload_file(file_obj)
+        assert result == "api-assets/id/video.mp4"
+        mock_put.assert_called_once_with(
+            url=mock.ANY,
+            content=data,
+        )
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_binary_io():
+    data = b"test audio data"
+    file_obj = io.BytesIO(data)
+    file_obj.name = "test.wav"
+
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.AsyncClient.put", new_callable=mock.AsyncMock) as mock_put:
+        mock_put.return_value = mock.Mock(
+            status_code=200, raise_for_status=lambda: None
+        )
+        result = await client.v1.files.upload_file(file_obj)
+        assert result == "api-assets/id/video.mp4"
+        mock_put.assert_awaited_once_with(url=mock.ANY, content=data)
+
+
+# Test pathlib.Path input
+def test_upload_file_with_pathlib_path():
+    data = b"test data"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
+        tmp.write(data)
+        tmp_path = pathlib.Path(tmp.name)
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        mock_put.return_value = mock.Mock(
+            status_code=200, raise_for_status=lambda: None
+        )
+        result = client.v1.files.upload_file(tmp_path)
+        assert result == "api-assets/id/video.mp4"
+        mock_put.assert_called_once_with(url=mock.ANY, content=data)
+
+    os.remove(tmp_path)
+
+
+# Test error cases
+def test_upload_file_nonexistent_file():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with pytest.raises(
+        FileNotFoundError, match="File not found: /nonexistent/file.mp4"
+    ):
+        client.v1.files.upload_file("/nonexistent/file.mp4")
+
+
+def test_upload_file_unsupported_file_type():
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".txt") as tmp:
+        tmp.write(b"test data")
+        tmp_path = tmp.name
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with pytest.raises(ValueError, match="Could not determine file type"):
+        client.v1.files.upload_file(tmp_path)
+
+    os.remove(tmp_path)
+
+
+def test_upload_file_binary_io_without_name():
+    data = b"test data"
+    file_obj = io.BytesIO(data)
+    # Intentionally not setting name attribute
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with pytest.raises(
+        ValueError, match="File-like object must have a 'name' attribute"
+    ):
+        client.v1.files.upload_file(file_obj)
+
+
+def test_upload_file_binary_io_with_non_string_name():
+    data = b"test data"
+    file_obj = io.BytesIO(data)
+    file_obj.name = 123  # Non-string name
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with pytest.raises(
+        ValueError, match="File-like object must have a 'name' attribute of type str"
+    ):
+        client.v1.files.upload_file(file_obj)
+
+
+def test_upload_file_no_upload_url_returned():
+    data = b"test data"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
+        tmp.write(data)
+        tmp_path = tmp.name
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    # Mock the upload_urls.create to return empty items
+    with mock.patch.object(client.v1.files.upload_urls, "create") as mock_create:
+        mock_create.return_value = mock.Mock(items=[])
+
+        with pytest.raises(
+            ValueError, match="No upload URL was returned from the server"
+        ):
+            client.v1.files.upload_file(tmp_path)
+
+    os.remove(tmp_path)
+
+
+def test_upload_file_http_error():
+    data = b"test data"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
+        tmp.write(data)
+        tmp_path = tmp.name
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        # Mock HTTP error response
+        mock_response = mock.Mock()
+        mock_response.raise_for_status.side_effect = Exception("Upload failed")
+        mock_put.return_value = mock_response
+
+        with pytest.raises(Exception, match="Upload failed"):
+            client.v1.files.upload_file(tmp_path)
+
+    os.remove(tmp_path)
+
+
+# Test different file types to ensure proper type detection
+def test_upload_different_file_types():
+    test_cases = [
+        (".mp4", "video"),
+        (".mov", "video"),
+        (".webm", "video"),
+        (".mp3", "audio"),
+        (".wav", "audio"),
+        (".png", "image"),
+        (".jpg", "image"),
+        (".jpeg", "image"),
+    ]
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    for extension, expected_type in test_cases:
+        data = b"test data"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=extension) as tmp:
+            tmp.write(data)
+            tmp_path = tmp.name
+
+        with mock.patch("httpx.Client.put") as mock_put:
+            mock_put.return_value = mock.Mock(
+                status_code=200, raise_for_status=lambda: None
+            )
+
+            # Mock the upload_urls.create to verify correct type is passed
+            with mock.patch.object(
+                client.v1.files.upload_urls, "create"
+            ) as mock_create:
+                mock_create.return_value = mock.Mock(
+                    items=[
+                        mock.Mock(
+                            upload_url="https://test.com/upload",
+                            file_path="api-assets/id/video.mp4",
+                        )
+                    ]
+                )
+
+                result = client.v1.files.upload_file(tmp_path)
+                assert result == "api-assets/id/video.mp4"
+
+                # Verify the correct type and extension were passed
+                call_args = mock_create.call_args
+                items = call_args.kwargs["items"]
+                assert len(items) == 1
+                assert items[0]["type_"] == expected_type
+                assert items[0]["extension"] == extension[1:]  # without the dot
+
+        os.remove(tmp_path)
+
+
+# Test URL handling - should skip upload and return URL as is
+def test_upload_file_with_http_url():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    http_url = "http://example.com/image.jpg"
+    result = client.v1.files.upload_file(http_url)
+
+    assert result == http_url
+
+
+def test_upload_file_with_https_url():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    https_url = "https://example.com/video.mp4"
+    result = client.v1.files.upload_file(https_url)
+
+    assert result == https_url
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_http_url():
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    http_url = "http://example.com/audio.mp3"
+    result = await client.v1.files.upload_file(http_url)
+
+    assert result == http_url
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_https_url():
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    https_url = "https://example.com/document.pdf"
+    result = await client.v1.files.upload_file(https_url)
+
+    assert result == https_url
+
+
+# Test blob path handling - should skip upload and return blob path as is
+def test_upload_file_with_blob_path():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    blob_path = "api-assets/user123/image.jpg"
+    result = client.v1.files.upload_file(blob_path)
+
+    assert result == blob_path
+
+
+def test_upload_file_with_blob_path_different_format():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    blob_path = "api-assets/project456/video.mp4"
+    result = client.v1.files.upload_file(blob_path)
+
+    assert result == blob_path
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_blob_path():
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    blob_path = "api-assets/user789/audio.wav"
+    result = await client.v1.files.upload_file(blob_path)
+
+    assert result == blob_path
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_blob_path_different_format():
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    blob_path = "api-assets/session101/photo.png"
+    result = await client.v1.files.upload_file(blob_path)
+
+    assert result == blob_path
+
+
+# Test that URL and blob path handling doesn't make HTTP requests
+def test_upload_file_with_url_does_not_make_http_requests():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        with mock.patch.object(client.v1.files.upload_urls, "create") as mock_create:
+            result = client.v1.files.upload_file("https://example.com/file.jpg")
+
+            # Should not call upload_urls.create or make HTTP PUT request
+            mock_create.assert_not_called()
+            mock_put.assert_not_called()
+
+            assert result == "https://example.com/file.jpg"
+
+
+def test_upload_file_with_blob_path_does_not_make_http_requests():
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        with mock.patch.object(client.v1.files.upload_urls, "create") as mock_create:
+            result = client.v1.files.upload_file("api-assets/user123/file.mp4")
+
+            # Should not call upload_urls.create or make HTTP PUT request
+            mock_create.assert_not_called()
+            mock_put.assert_not_called()
+
+            assert result == "api-assets/user123/file.mp4"
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_url_does_not_make_http_requests():
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.AsyncClient.put", new_callable=mock.AsyncMock) as mock_put:
+        with mock.patch.object(
+            client.v1.files.upload_urls, "create", new_callable=mock.AsyncMock
+        ) as mock_create:
+            result = await client.v1.files.upload_file("http://example.com/file.mp3")
+
+            # Should not call upload_urls.create or make HTTP PUT request
+            mock_create.assert_not_awaited()
+            mock_put.assert_not_awaited()
+
+            assert result == "http://example.com/file.mp3"
+
+
+@pytest.mark.asyncio
+async def test_async_upload_file_with_blob_path_does_not_make_http_requests():
+    client = AsyncClient(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.AsyncClient.put", new_callable=mock.AsyncMock) as mock_put:
+        with mock.patch.object(
+            client.v1.files.upload_urls, "create", new_callable=mock.AsyncMock
+        ) as mock_create:
+            result = await client.v1.files.upload_file("api-assets/user456/file.wav")
+
+            # Should not call upload_urls.create or make HTTP PUT request
+            mock_create.assert_not_awaited()
+            mock_put.assert_not_awaited()
+
+            assert result == "api-assets/user456/file.wav"
+
+
+# Test file position preservation for file-like objects
+def test_upload_file_preserves_file_position():
+    data = b"test data for position preservation"
+    file_obj = io.BytesIO(data)
+    file_obj.name = "test.mp4"
+
+    # Move to middle of file
+    file_obj.seek(5)
+    original_position = file_obj.tell()
+
+    client = Client(token="API_TOKEN", environment=Environment.MOCK_SERVER)
+
+    with mock.patch("httpx.Client.put") as mock_put:
+        mock_put.return_value = mock.Mock(
+            status_code=200, raise_for_status=lambda: None
+        )
+        client.v1.files.upload_file(file_obj)
+
+        # Verify position was restored
+        assert file_obj.tell() == original_position
+
+        # Verify the full content was uploaded (not just from position 5)
+        mock_put.assert_called_once_with(
+            url=mock.ANY,
+            content=data,  # Full data, not data[5:]
+        )

magic_hour/resources/v1/files/upload_urls/README.md

@@ -1,30 +1,39 @@
+# v1.files.upload_urls
 
-### create <a name="create"></a>
-Generate asset upload urls
+## Module Functions
 
-Create a list of urls used to upload the assets needed to generate a video. Each video type has their own requirements on what assets are required. Please refer to the specific mode API for more details. The response array will be in the same order as the request body.
+### Generate asset upload urls <a name="create"></a>
 
-Below is the list of valid extensions for each asset type:
+Generates a list of pre-signed upload URLs for the assets required. This API is only necessary if you want to upload to Magic Hour's storage. Refer to the [Input Files Guide](/integration/input-files) for more details.
+
+The response array will match the order of items in the request body.
+
+**Valid file extensions per asset type**:
 
 - video: mp4, m4v, mov, webm
-- audio: mp3, mpeg, wav, aac, aiff, flac
-- image: png, jpg, jpeg, webp, avif, jp2, tiff, bmp
+- audio: mp3, wav, aac, flac, webm
+- image: png, jpg, jpeg, heic, webp, avif, jp2, tiff, bmp
+- gif: gif, webp, webm
 
-Note: `.gif` is supported for face swap API `video_file_path` field.
+> Note: `gif` is only supported for face swap API `video_file_path` field.
 
-After receiving the upload url, you can upload the file by sending a PUT request with the header `'Content-Type: application/octet-stream'`.
+Once you receive an upload URL, send a `PUT` request to upload the file directly.
 
-For example using curl
+Example:
 
 ```
-curl -X PUT -H 'Content-Type: application/octet-stream' \
-  --data '@/path/to/file/video.mp4' \
-  https://videos.magichour.ai/api-assets/id/video.mp4?auth-value=1234567890
+curl -X PUT --data '@/path/to/file/video.mp4' \
+  https://videos.magichour.ai/api-assets/id/video.mp4?<auth params from the API response>
 ```
 
-
 **API Endpoint**: `POST /v1/files/upload-urls`
 
+#### Parameters
+
+| Parameter | Required | Description                                                                                         | Example                                                                            |
+| --------- | :------: | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| `items`   |    ✓     | The list of assets to upload. The response array will match the order of items in the request body. | `[{"extension": "mp4", "type_": "video"}, {"extension": "mp3", "type_": "audio"}]` |
+
 #### Synchronous Client
 
 ```python
@@ -34,8 +43,8 @@ from os import getenv
 client = Client(token=getenv("API_TOKEN"))
 res = client.v1.files.upload_urls.create(
     items=[
-        {"extension": "mp4", "type_field": "video"},
-        {"extension": "mp3", "type_field": "audio"},
+        {"extension": "mp4", "type_": "video"},
+        {"extension": "mp3", "type_": "audio"},
     ]
 )
 ```
@@ -49,8 +58,20 @@ from os import getenv
 client = AsyncClient(token=getenv("API_TOKEN"))
 res = await client.v1.files.upload_urls.create(
     items=[
-        {"extension": "mp4", "type_field": "video"},
-        {"extension": "mp3", "type_field": "audio"},
+        {"extension": "mp4", "type_": "video"},
+        {"extension": "mp3", "type_": "audio"},
     ]
 )
 ```
+
+#### Response
+
+##### Type
+
+[V1FilesUploadUrlsCreateResponse](/magic_hour/types/models/v1_files_upload_urls_create_response.py)
+
+##### Example
+
+```python
+{"items": [{"expires_at": "2024-07-25T16:56:21.932Z", "file_path": "api-assets/id/video.mp4", "upload_url": "https://videos.magichour.ai/api-assets/id/video.mp4?auth-value=1234567890"}, {"expires_at": "2024-07-25T16:56:21.932Z", "file_path": "api-assets/id/audio.mp3", "upload_url": "https://videos.magichour.ai/api-assets/id/audio.mp3?auth-value=1234567890"}]}
+```

magic_hour/resources/v1/files/upload_urls/client.py

@@ -1,13 +1,13 @@
 import typing
 
-from magic_hour.core import (
+from magic_hour.types import models, params
+from make_api_request import (
     AsyncBaseClient,
     RequestOptions,
     SyncBaseClient,
     default_request_options,
     to_encodable,
 )
-from magic_hour.types import models, params
 
 
 class UploadUrlsClient:
@@ -17,37 +17,38 @@ class UploadUrlsClient:
     def create(
         self,
         *,
-        items: typing.List[params.PostV1FilesUploadUrlsBodyItemsItem],
+        items: typing.List[params.V1FilesUploadUrlsCreateBodyItemsItem],
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> models.PostV1FilesUploadUrlsResponse:
+    ) -> models.V1FilesUploadUrlsCreateResponse:
         """
         Generate asset upload urls
         
-        Create a list of urls used to upload the assets needed to generate a video. Each video type has their own requirements on what assets are required. Please refer to the specific mode API for more details. The response array will be in the same order as the request body.
+        Generates a list of pre-signed upload URLs for the assets required. This API is only necessary if you want to upload to Magic Hour's storage. Refer to the [Input Files Guide](/integration/input-files) for more details.
         
-        Below is the list of valid extensions for each asset type:
+        The response array will match the order of items in the request body.
         
+        **Valid file extensions per asset type**:
         - video: mp4, m4v, mov, webm
-        - audio: mp3, mpeg, wav, aac, aiff, flac
-        - image: png, jpg, jpeg, webp, avif, jp2, tiff, bmp
+        - audio: mp3, wav, aac, flac, webm
+        - image: png, jpg, jpeg, heic, webp, avif, jp2, tiff, bmp
+        - gif: gif, webp, webm
         
-        Note: `.gif` is supported for face swap API `video_file_path` field.
+        > Note: `gif` is only supported for face swap API `video_file_path` field.
         
-        After receiving the upload url, you can upload the file by sending a PUT request with the header `'Content-Type: application/octet-stream'`.
+        Once you receive an upload URL, send a `PUT` request to upload the file directly.
         
-        For example using curl
+        Example:
         
         ```
-        curl -X PUT -H 'Content-Type: application/octet-stream' \
-          --data '@/path/to/file/video.mp4' \
-          https://videos.magichour.ai/api-assets/id/video.mp4?auth-value=1234567890
+        curl -X PUT --data '@/path/to/file/video.mp4' \
+          https://videos.magichour.ai/api-assets/id/video.mp4?<auth params from the API response>
         ```
         
         
         POST /v1/files/upload-urls
         
         Args:
-            items: typing.List[PostV1FilesUploadUrlsBodyItemsItem]
+            items: The list of assets to upload. The response array will match the order of items in the request body.
             request_options: Additional options to customize the HTTP request
         
         Returns:
@@ -59,18 +60,19 @@ class UploadUrlsClient:
         
         Examples:
         ```py
-        client.v1.files.upload_urls.create(items=[{"extension": "mp4", "type_field": "video"}, {"extension": "mp3", "type_field": "audio"}])
+        client.v1.files.upload_urls.create(items=[{"extension": "mp4", "type_": "video"}, {"extension": "mp3", "type_": "audio"}])
         ```
         """
         _json = to_encodable(
-            item={"items": items}, dump_with=params._SerializerPostV1FilesUploadUrlsBody
+            item={"items": items},
+            dump_with=params._SerializerV1FilesUploadUrlsCreateBody,
         )
         return self._base_client.request(
             method="POST",
             path="/v1/files/upload-urls",
             auth_names=["bearerAuth"],
             json=_json,
-            cast_to=models.PostV1FilesUploadUrlsResponse,
+            cast_to=models.V1FilesUploadUrlsCreateResponse,
             request_options=request_options or default_request_options(),
         )
 
@@ -82,37 +84,38 @@ class AsyncUploadUrlsClient:
     async def create(
         self,
         *,
-        items: typing.List[params.PostV1FilesUploadUrlsBodyItemsItem],
+        items: typing.List[params.V1FilesUploadUrlsCreateBodyItemsItem],
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> models.PostV1FilesUploadUrlsResponse:
+    ) -> models.V1FilesUploadUrlsCreateResponse:
         """
         Generate asset upload urls
         
-        Create a list of urls used to upload the assets needed to generate a video. Each video type has their own requirements on what assets are required. Please refer to the specific mode API for more details. The response array will be in the same order as the request body.
+        Generates a list of pre-signed upload URLs for the assets required. This API is only necessary if you want to upload to Magic Hour's storage. Refer to the [Input Files Guide](/integration/input-files) for more details.
         
-        Below is the list of valid extensions for each asset type:
+        The response array will match the order of items in the request body.
         
+        **Valid file extensions per asset type**:
         - video: mp4, m4v, mov, webm
-        - audio: mp3, mpeg, wav, aac, aiff, flac
-        - image: png, jpg, jpeg, webp, avif, jp2, tiff, bmp
+        - audio: mp3, wav, aac, flac, webm
+        - image: png, jpg, jpeg, heic, webp, avif, jp2, tiff, bmp
+        - gif: gif, webp, webm
         
-        Note: `.gif` is supported for face swap API `video_file_path` field.
+        > Note: `gif` is only supported for face swap API `video_file_path` field.
         
-        After receiving the upload url, you can upload the file by sending a PUT request with the header `'Content-Type: application/octet-stream'`.
+        Once you receive an upload URL, send a `PUT` request to upload the file directly.
         
-        For example using curl
+        Example:
         
         ```
-        curl -X PUT -H 'Content-Type: application/octet-stream' \
-          --data '@/path/to/file/video.mp4' \
-          https://videos.magichour.ai/api-assets/id/video.mp4?auth-value=1234567890
+        curl -X PUT --data '@/path/to/file/video.mp4' \
+          https://videos.magichour.ai/api-assets/id/video.mp4?<auth params from the API response>
         ```
         
         
         POST /v1/files/upload-urls
         
         Args:
-            items: typing.List[PostV1FilesUploadUrlsBodyItemsItem]
+            items: The list of assets to upload. The response array will match the order of items in the request body.
             request_options: Additional options to customize the HTTP request
         
         Returns:
@@ -124,17 +127,18 @@ class AsyncUploadUrlsClient:
         
         Examples:
         ```py
-        await client.v1.files.upload_urls.create(items=[{"extension": "mp4", "type_field": "video"}, {"extension": "mp3", "type_field": "audio"}])
+        await client.v1.files.upload_urls.create(items=[{"extension": "mp4", "type_": "video"}, {"extension": "mp3", "type_": "audio"}])
         ```
         """
         _json = to_encodable(
-            item={"items": items}, dump_with=params._SerializerPostV1FilesUploadUrlsBody
+            item={"items": items},
+            dump_with=params._SerializerV1FilesUploadUrlsCreateBody,
         )
         return await self._base_client.request(
             method="POST",
             path="/v1/files/upload-urls",
             auth_names=["bearerAuth"],
             json=_json,
-            cast_to=models.PostV1FilesUploadUrlsResponse,
+            cast_to=models.V1FilesUploadUrlsCreateResponse,
             request_options=request_options or default_request_options(),
         )