magic_hour 0.8.0__py3-none-any.whl

magic_hour/types/params/post_v1_face_swap_photo_body.py

@@ -0,0 +1,40 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_face_swap_photo_body_assets import (
+    PostV1FaceSwapPhotoBodyAssets,
+    _SerializerPostV1FaceSwapPhotoBodyAssets,
+)
+
+
+class PostV1FaceSwapPhotoBody(typing_extensions.TypedDict):
+    """
+    PostV1FaceSwapPhotoBody
+    """
+
+    assets: typing_extensions.Required[PostV1FaceSwapPhotoBodyAssets]
+    """
+    Provide the assets for face swap photo
+    """
+
+    name: typing_extensions.NotRequired[str]
+    """
+    The name of image
+    """
+
+
+class _SerializerPostV1FaceSwapPhotoBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1FaceSwapPhotoBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    assets: _SerializerPostV1FaceSwapPhotoBodyAssets = pydantic.Field(
+        alias="assets",
+    )
+    name: typing.Optional[str] = pydantic.Field(alias="name", default=None)

magic_hour/types/params/post_v1_face_swap_photo_body_assets.py

@@ -0,0 +1,36 @@
+import typing_extensions
+import pydantic
+
+
+class PostV1FaceSwapPhotoBodyAssets(typing_extensions.TypedDict):
+    """
+    Provide the assets for face swap photo
+    """
+
+    source_file_path: typing_extensions.Required[str]
+    """
+    This is the image from which the face is extracted. This value can be either the `file_path` field from the response of the [upload urls API](/docs/api/tag/files/post/v1/files/upload-urls), or the url of the file.
+    """
+
+    target_file_path: typing_extensions.Required[str]
+    """
+    This is the image where the face from the source image will be placed. This value can be either the `file_path` field from the response of the [upload urls API](/docs/api/tag/files/post/v1/files/upload-urls), or the url of the file.
+    """
+
+
+class _SerializerPostV1FaceSwapPhotoBodyAssets(pydantic.BaseModel):
+    """
+    Serializer for PostV1FaceSwapPhotoBodyAssets handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    source_file_path: str = pydantic.Field(
+        alias="source_file_path",
+    )
+    target_file_path: str = pydantic.Field(
+        alias="target_file_path",
+    )

magic_hour/types/params/post_v1_files_upload_urls_body.py

@@ -0,0 +1,31 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_files_upload_urls_body_items_item import (
+    PostV1FilesUploadUrlsBodyItemsItem,
+    _SerializerPostV1FilesUploadUrlsBodyItemsItem,
+)
+
+
+class PostV1FilesUploadUrlsBody(typing_extensions.TypedDict):
+    """
+    PostV1FilesUploadUrlsBody
+    """
+
+    items: typing_extensions.Required[typing.List[PostV1FilesUploadUrlsBodyItemsItem]]
+
+
+class _SerializerPostV1FilesUploadUrlsBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1FilesUploadUrlsBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    items: typing.List[_SerializerPostV1FilesUploadUrlsBodyItemsItem] = pydantic.Field(
+        alias="items",
+    )

magic_hour/types/params/post_v1_files_upload_urls_body_items_item.py

@@ -0,0 +1,38 @@
+import typing_extensions
+import pydantic
+
+
+class PostV1FilesUploadUrlsBodyItemsItem(typing_extensions.TypedDict):
+    """
+    PostV1FilesUploadUrlsBodyItemsItem
+    """
+
+    extension: typing_extensions.Required[str]
+    """
+    the extension of the file to upload. Do not include the dot (.) before the extension.
+    """
+
+    type_field: typing_extensions.Required[
+        typing_extensions.Literal["audio", "image", "video"]
+    ]
+    """
+    The type of asset to upload
+    """
+
+
+class _SerializerPostV1FilesUploadUrlsBodyItemsItem(pydantic.BaseModel):
+    """
+    Serializer for PostV1FilesUploadUrlsBodyItemsItem handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    extension: str = pydantic.Field(
+        alias="extension",
+    )
+    type_field: typing_extensions.Literal["audio", "image", "video"] = pydantic.Field(
+        alias="type",
+    )

magic_hour/types/params/post_v1_image_background_remover_body.py

@@ -0,0 +1,40 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_image_background_remover_body_assets import (
+    PostV1ImageBackgroundRemoverBodyAssets,
+    _SerializerPostV1ImageBackgroundRemoverBodyAssets,
+)
+
+
+class PostV1ImageBackgroundRemoverBody(typing_extensions.TypedDict):
+    """
+    PostV1ImageBackgroundRemoverBody
+    """
+
+    assets: typing_extensions.Required[PostV1ImageBackgroundRemoverBodyAssets]
+    """
+    Provide the assets for background removal
+    """
+
+    name: typing_extensions.NotRequired[str]
+    """
+    The name of image
+    """
+
+
+class _SerializerPostV1ImageBackgroundRemoverBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1ImageBackgroundRemoverBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    assets: _SerializerPostV1ImageBackgroundRemoverBodyAssets = pydantic.Field(
+        alias="assets",
+    )
+    name: typing.Optional[str] = pydantic.Field(alias="name", default=None)

magic_hour/types/params/post_v1_image_background_remover_body_assets.py

@@ -0,0 +1,28 @@
+import typing_extensions
+import pydantic
+
+
+class PostV1ImageBackgroundRemoverBodyAssets(typing_extensions.TypedDict):
+    """
+    Provide the assets for background removal
+    """
+
+    image_file_path: typing_extensions.Required[str]
+    """
+    The image used to generate the image. This is the `file_path` field from the response of the [upload urls API](/docs/api/tag/files/post/v1/files/upload-urls)
+    """
+
+
+class _SerializerPostV1ImageBackgroundRemoverBodyAssets(pydantic.BaseModel):
+    """
+    Serializer for PostV1ImageBackgroundRemoverBodyAssets handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    image_file_path: str = pydantic.Field(
+        alias="image_file_path",
+    )

magic_hour/types/params/post_v1_image_to_video_body.py

@@ -0,0 +1,73 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_image_to_video_body_assets import (
+    PostV1ImageToVideoBodyAssets,
+    _SerializerPostV1ImageToVideoBodyAssets,
+)
+from .post_v1_image_to_video_body_style import (
+    PostV1ImageToVideoBodyStyle,
+    _SerializerPostV1ImageToVideoBodyStyle,
+)
+
+
+class PostV1ImageToVideoBody(typing_extensions.TypedDict):
+    """
+    PostV1ImageToVideoBody
+    """
+
+    assets: typing_extensions.Required[PostV1ImageToVideoBodyAssets]
+    """
+    Provide the assets for image-to-video.
+    """
+
+    end_seconds: typing_extensions.Required[float]
+    """
+    The total duration of the output video in seconds.
+    """
+
+    height: typing_extensions.Required[int]
+    """
+    The height of the input video. This value will help determine the final orientation of the output video. The output video resolution may not match the input.
+    """
+
+    name: typing_extensions.NotRequired[str]
+    """
+    The name of video
+    """
+
+    style: typing_extensions.Required[PostV1ImageToVideoBodyStyle]
+
+    width: typing_extensions.Required[int]
+    """
+    The width of the input video. This value will help determine the final orientation of the output video. The output video resolution may not match the input.
+    """
+
+
+class _SerializerPostV1ImageToVideoBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1ImageToVideoBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    assets: _SerializerPostV1ImageToVideoBodyAssets = pydantic.Field(
+        alias="assets",
+    )
+    end_seconds: float = pydantic.Field(
+        alias="end_seconds",
+    )
+    height: int = pydantic.Field(
+        alias="height",
+    )
+    name: typing.Optional[str] = pydantic.Field(alias="name", default=None)
+    style: _SerializerPostV1ImageToVideoBodyStyle = pydantic.Field(
+        alias="style",
+    )
+    width: int = pydantic.Field(
+        alias="width",
+    )

magic_hour/types/params/post_v1_image_to_video_body_assets.py

@@ -0,0 +1,28 @@
+import typing_extensions
+import pydantic
+
+
+class PostV1ImageToVideoBodyAssets(typing_extensions.TypedDict):
+    """
+    Provide the assets for image-to-video.
+    """
+
+    image_file_path: typing_extensions.Required[str]
+    """
+    The path of the image file. This is the `file_path` field from the response of the [upload urls API](/docs/api/tag/files/post/v1/files/upload-urls)
+    """
+
+
+class _SerializerPostV1ImageToVideoBodyAssets(pydantic.BaseModel):
+    """
+    Serializer for PostV1ImageToVideoBodyAssets handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    image_file_path: str = pydantic.Field(
+        alias="image_file_path",
+    )

magic_hour/types/params/post_v1_image_to_video_body_style.py

@@ -0,0 +1,29 @@
+import typing
+import typing_extensions
+import pydantic
+
+
+class PostV1ImageToVideoBodyStyle(typing_extensions.TypedDict):
+    """
+    PostV1ImageToVideoBodyStyle
+    """
+
+    prompt: typing_extensions.Required[typing.Optional[str]]
+    """
+    The prompt used for the video.
+    """
+
+
+class _SerializerPostV1ImageToVideoBodyStyle(pydantic.BaseModel):
+    """
+    Serializer for PostV1ImageToVideoBodyStyle handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    prompt: typing.Optional[str] = pydantic.Field(
+        alias="prompt",
+    )

magic_hour/types/params/post_v1_lip_sync_body.py

@@ -0,0 +1,80 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_lip_sync_body_assets import (
+    PostV1LipSyncBodyAssets,
+    _SerializerPostV1LipSyncBodyAssets,
+)
+
+
+class PostV1LipSyncBody(typing_extensions.TypedDict):
+    """
+    PostV1LipSyncBody
+    """
+
+    assets: typing_extensions.Required[PostV1LipSyncBodyAssets]
+    """
+    Provide the assets for lip-sync. For video, The `video_source` field determines whether `video_file_path` or `youtube_url` field is used
+    """
+
+    end_seconds: typing_extensions.Required[float]
+    """
+    The end time of the input video in seconds
+    """
+
+    height: typing_extensions.Required[int]
+    """
+    The height of the final output video. The maximum height depends on your subscription. Please refer to our [pricing page](https://magichour.ai/pricing) for more details
+    """
+
+    max_fps_limit: typing_extensions.NotRequired[float]
+    """
+    Defines the maximum FPS (frames per second) for the output video. If the input video's FPS is lower than this limit, the output video will retain the input FPS. This is useful for reducing unnecessary frame usage in scenarios where high FPS is not required.
+    """
+
+    name: typing_extensions.NotRequired[str]
+    """
+    The name of video
+    """
+
+    start_seconds: typing_extensions.Required[float]
+    """
+    The start time of the input video in seconds
+    """
+
+    width: typing_extensions.Required[int]
+    """
+    The width of the final output video. The maximum width depends on your subscription. Please refer to our [pricing page](https://magichour.ai/pricing) for more details
+    """
+
+
+class _SerializerPostV1LipSyncBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1LipSyncBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    assets: _SerializerPostV1LipSyncBodyAssets = pydantic.Field(
+        alias="assets",
+    )
+    end_seconds: float = pydantic.Field(
+        alias="end_seconds",
+    )
+    height: int = pydantic.Field(
+        alias="height",
+    )
+    max_fps_limit: typing.Optional[float] = pydantic.Field(
+        alias="max_fps_limit", default=None
+    )
+    name: typing.Optional[str] = pydantic.Field(alias="name", default=None)
+    start_seconds: float = pydantic.Field(
+        alias="start_seconds",
+    )
+    width: int = pydantic.Field(
+        alias="width",
+    )

magic_hour/types/params/post_v1_lip_sync_body_assets.py

@@ -0,0 +1,52 @@
+import typing
+import typing_extensions
+import pydantic
+
+
+class PostV1LipSyncBodyAssets(typing_extensions.TypedDict):
+    """
+    Provide the assets for lip-sync. For video, The `video_source` field determines whether `video_file_path` or `youtube_url` field is used
+    """
+
+    audio_file_path: typing_extensions.Required[str]
+    """
+    The path of the audio file. This is the `file_path` field from the response of the [upload urls API](/docs/api/tag/files/post/v1/files/upload-urls)
+    """
+
+    video_file_path: typing_extensions.NotRequired[str]
+    """
+    The path of the input video. This is the `file_path` field from the response of the [upload urls API](/docs/api/tag/files/post/v1/files/upload-urls). This field is required if `video_source` is `file`
+    """
+
+    video_source: typing_extensions.Required[
+        typing_extensions.Literal["file", "youtube"]
+    ]
+
+    youtube_url: typing_extensions.NotRequired[str]
+    """
+    Using a youtube video as the input source. This field is required if `video_source` is `youtube`
+    """
+
+
+class _SerializerPostV1LipSyncBodyAssets(pydantic.BaseModel):
+    """
+    Serializer for PostV1LipSyncBodyAssets handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    audio_file_path: str = pydantic.Field(
+        alias="audio_file_path",
+    )
+    video_file_path: typing.Optional[str] = pydantic.Field(
+        alias="video_file_path", default=None
+    )
+    video_source: typing_extensions.Literal["file", "youtube"] = pydantic.Field(
+        alias="video_source",
+    )
+    youtube_url: typing.Optional[str] = pydantic.Field(
+        alias="youtube_url", default=None
+    )

magic_hour/types/params/post_v1_text_to_video_body.py

@@ -0,0 +1,57 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_text_to_video_body_style import (
+    PostV1TextToVideoBodyStyle,
+    _SerializerPostV1TextToVideoBodyStyle,
+)
+
+
+class PostV1TextToVideoBody(typing_extensions.TypedDict):
+    """
+    PostV1TextToVideoBody
+    """
+
+    end_seconds: typing_extensions.Required[float]
+    """
+    The total duration of the output video in seconds.
+    """
+
+    name: typing_extensions.NotRequired[str]
+    """
+    The name of video
+    """
+
+    orientation: typing_extensions.Required[
+        typing_extensions.Literal["landscape", "portrait", "square"]
+    ]
+    """
+    Determines the orientation of the output video
+    """
+
+    style: typing_extensions.Required[PostV1TextToVideoBodyStyle]
+
+
+class _SerializerPostV1TextToVideoBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1TextToVideoBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    end_seconds: float = pydantic.Field(
+        alias="end_seconds",
+    )
+    name: typing.Optional[str] = pydantic.Field(alias="name", default=None)
+    orientation: typing_extensions.Literal["landscape", "portrait", "square"] = (
+        pydantic.Field(
+            alias="orientation",
+        )
+    )
+    style: _SerializerPostV1TextToVideoBodyStyle = pydantic.Field(
+        alias="style",
+    )

magic_hour/types/params/post_v1_text_to_video_body_style.py

@@ -0,0 +1,28 @@
+import typing_extensions
+import pydantic
+
+
+class PostV1TextToVideoBodyStyle(typing_extensions.TypedDict):
+    """
+    PostV1TextToVideoBodyStyle
+    """
+
+    prompt: typing_extensions.Required[str]
+    """
+    The prompt used for the video.
+    """
+
+
+class _SerializerPostV1TextToVideoBodyStyle(pydantic.BaseModel):
+    """
+    Serializer for PostV1TextToVideoBodyStyle handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    prompt: str = pydantic.Field(
+        alias="prompt",
+    )

magic_hour/types/params/post_v1_video_to_video_body.py

@@ -0,0 +1,93 @@
+import typing
+import typing_extensions
+import pydantic
+
+from .post_v1_video_to_video_body_assets import (
+    PostV1VideoToVideoBodyAssets,
+    _SerializerPostV1VideoToVideoBodyAssets,
+)
+from .post_v1_video_to_video_body_style import (
+    PostV1VideoToVideoBodyStyle,
+    _SerializerPostV1VideoToVideoBodyStyle,
+)
+
+
+class PostV1VideoToVideoBody(typing_extensions.TypedDict):
+    """
+    PostV1VideoToVideoBody
+    """
+
+    assets: typing_extensions.Required[PostV1VideoToVideoBodyAssets]
+    """
+    Provide the assets for video-to-video. For video, The `video_source` field determines whether `video_file_path` or `youtube_url` field is used
+    """
+
+    end_seconds: typing_extensions.Required[float]
+    """
+    The end time of the input video in seconds
+    """
+
+    fps_resolution: typing_extensions.NotRequired[
+        typing_extensions.Literal["FULL", "HALF"]
+    ]
+    """
+    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
+    """
+
+    height: typing_extensions.Required[int]
+    """
+    The height of the final output video. Must be divisible by 64. The maximum height depends on your subscription. Please refer to our [pricing page](https://magichour.ai/pricing) for more details
+    """
+
+    name: typing_extensions.NotRequired[str]
+    """
+    The name of video
+    """
+
+    start_seconds: typing_extensions.Required[float]
+    """
+    The start time of the input video in seconds
+    """
+
+    style: typing_extensions.Required[PostV1VideoToVideoBodyStyle]
+
+    width: typing_extensions.Required[int]
+    """
+    The width of the final output video. Must be divisible by 64. The maximum width depends on your subscription. Please refer to our [pricing page](https://magichour.ai/pricing) for more details
+    """
+
+
+class _SerializerPostV1VideoToVideoBody(pydantic.BaseModel):
+    """
+    Serializer for PostV1VideoToVideoBody handling case conversions
+    and file omissions as dictated by the API
+    """
+
+    model_config = pydantic.ConfigDict(
+        populate_by_name=True,
+    )
+
+    assets: _SerializerPostV1VideoToVideoBodyAssets = pydantic.Field(
+        alias="assets",
+    )
+    end_seconds: float = pydantic.Field(
+        alias="end_seconds",
+    )
+    fps_resolution: typing.Optional[typing_extensions.Literal["FULL", "HALF"]] = (
+        pydantic.Field(alias="fps_resolution", default=None)
+    )
+    height: int = pydantic.Field(
+        alias="height",
+    )
+    name: typing.Optional[str] = pydantic.Field(alias="name", default=None)
+    start_seconds: float = pydantic.Field(
+        alias="start_seconds",
+    )
+    style: _SerializerPostV1VideoToVideoBodyStyle = pydantic.Field(
+        alias="style",
+    )
+    width: int = pydantic.Field(
+        alias="width",
+    )