magic-hour 0.0.1__tar.gz

magic_hour-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Magic Hour AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

magic_hour-0.0.1/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: magic_hour
+Version: 0.0.1
+Summary: 
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: httpx (>=0.26.0,<0.27.0)
+Requires-Dist: pydantic (>=2.5.0,<3.0.0)
+Requires-Dist: typing_extensions (>=4.0.0)
+Description-Content-Type: text/markdown
+
+
+# Magic Hour API Python SDK
+
+
+## Overview
+
+# Introduction 
+
+Magic Hour provides an API (beta) that can be integrated into your own application to generate videos using AI. 
+
+Webhook documentation can be found [here](https://magichour.ai/docs/webhook).
+
+If you have any questions, please reach out to us via [discord](https://discord.gg/JX5rgsZaJp).
+
+# Authentication
+
+Every request requires an API key.
+
+To get started, first generate your API key [here](https://magichour.ai/settings/developer).
+
+Then, add the `Authorization` header to the request.
+
+| Key | Value |
+|-|-|
+| Authorization | Bearer mhk_live_apikey |
+
+> **Warning**: any API call that renders a video will utilize frames in your account.
+
+
+
+### Synchronous Client
+
+```python
+from magic_hour import Client
+from os import getenv
+
+client = Client(token=getenv("API_TOKEN"))
+```
+
+
+### Asynchronous Client
+
+```python
+from magic_hour import AsyncClient
+from os import getenv
+
+client = AsyncClient(token=getenv("API_TOKEN"))
+```
+
+### SDK Usage 
+ See [SDK Examples](SDK_EXAMPLES.md) for example usage of all SDK functionality

magic_hour-0.0.1/README.md

@@ -0,0 +1,51 @@
+
+# Magic Hour API Python SDK
+
+
+## Overview
+
+# Introduction 
+
+Magic Hour provides an API (beta) that can be integrated into your own application to generate videos using AI. 
+
+Webhook documentation can be found [here](https://magichour.ai/docs/webhook).
+
+If you have any questions, please reach out to us via [discord](https://discord.gg/JX5rgsZaJp).
+
+# Authentication
+
+Every request requires an API key.
+
+To get started, first generate your API key [here](https://magichour.ai/settings/developer).
+
+Then, add the `Authorization` header to the request.
+
+| Key | Value |
+|-|-|
+| Authorization | Bearer mhk_live_apikey |
+
+> **Warning**: any API call that renders a video will utilize frames in your account.
+
+
+
+### Synchronous Client
+
+```python
+from magic_hour import Client
+from os import getenv
+
+client = Client(token=getenv("API_TOKEN"))
+```
+
+
+### Asynchronous Client
+
+```python
+from magic_hour import AsyncClient
+from os import getenv
+
+client = AsyncClient(token=getenv("API_TOKEN"))
+```
+
+### SDK Usage 
+ See [SDK Examples](SDK_EXAMPLES.md) for example usage of all SDK functionality

magic_hour-0.0.1/magic_hour/__init__.py

@@ -0,0 +1,10 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+from .core import ApiError, BinaryResponse
+from .client import AsyncClient, Client
+from .environment import Environment
+
+
+__all__ = ["ApiError", "AsyncClient", "BinaryResponse", "Client", "Environment"]

magic_hour-0.0.1/magic_hour/client.py

@@ -0,0 +1,75 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+import httpx
+import typing
+
+from magic_hour.core import AsyncBaseClient, AuthBearer, SyncBaseClient
+from magic_hour.environment import Environment
+from magic_hour.resources.v1 import AsyncV1Client, V1Client
+
+
+class Client:
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.Client] = None,
+        environment: Environment = Environment.ENVIRONMENT,
+        token: typing.Optional[str] = None,
+    ):
+        self._base_client = SyncBaseClient(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            httpx_client=(
+                httpx.Client(timeout=timeout) if httpx_client is None else httpx_client
+            ),
+        )
+
+        # register auth methods (keep comment for code generation)
+        self._base_client.register_auth("bearerAuth", AuthBearer(val=token))
+
+        # register sync resources (keep comment for code generation)
+        self.v1 = V1Client(base_client=self._base_client)
+
+    # register sync api methods (keep comment for code generation)
+
+
+class AsyncClient:
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None,
+        environment: Environment = Environment.ENVIRONMENT,
+        token: typing.Optional[str] = None,
+    ):
+        self._base_client = AsyncBaseClient(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            httpx_client=(
+                httpx.AsyncClient(timeout=timeout)
+                if httpx_client is None
+                else httpx_client
+            ),
+        )
+
+        # register auth methods (keep comment for code generation)
+        self._base_client.register_auth("bearerAuth", AuthBearer(val=token))
+
+        # register async resources (keep comment for code generation)
+        self.v1 = AsyncV1Client(base_client=self._base_client)
+
+    # register async api methods (keep comment for code generation)
+
+
+def _get_base_url(
+    *, base_url: typing.Optional[str] = None, environment: Environment
+) -> str:
+    if base_url is not None:
+        return base_url
+    elif environment is not None:
+        return environment.value
+    else:
+        raise Exception("Must include a base_url or environment arguments")

magic_hour-0.0.1/magic_hour/core/__init__.py

@@ -0,0 +1,43 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+from .api_error import ApiError
+from .auth import (
+    AuthKeyQuery,
+    AuthBasic,
+    AuthBearer,
+    AuthProvider,
+    AuthKeyCookie,
+    AuthKeyHeader,
+)
+from .base_client import AsyncBaseClient, BaseClient, SyncBaseClient
+from .binary_response import BinaryResponse
+from .request import (
+    encode_param,
+    to_encodable,
+    RequestOptions,
+    default_request_options,
+    QueryParams,
+)
+from .response import from_encodable
+
+__all__ = [
+    "ApiError",
+    "AsyncBaseClient",
+    "BaseClient",
+    "BinaryResponse",
+    "RequestOptions",
+    "default_request_options",
+    "SyncBaseClient",
+    "AuthKeyQuery",
+    "AuthBasic",
+    "AuthBearer",
+    "AuthProvider",
+    "AuthKeyCookie",
+    "AuthKeyHeader",
+    "to_encodable",
+    "encode_param",
+    "from_encodable",
+    "QueryParams",
+]

magic_hour-0.0.1/magic_hour/core/api_error.py

@@ -0,0 +1,19 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+import typing
+
+
+class ApiError(Exception):
+    status_code: typing.Optional[int]
+    body: typing.Any
+
+    def __init__(
+        self, *, status_code: typing.Optional[int] = None, body: typing.Any = None
+    ):
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"status_code: {self.status_code}, body: {self.body}"

magic_hour-0.0.1/magic_hour/core/auth.py

@@ -0,0 +1,82 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+import abc
+import typing
+
+from pydantic import BaseModel
+
+from .request import RequestConfig
+
+
+class AuthProvider(abc.ABC):
+    @abc.abstractmethod
+    def add_to_request(self, cfg: RequestConfig) -> RequestConfig:
+        """Adds relevant auth to request kwargs"""
+
+
+class AuthBasic(BaseModel, AuthProvider):
+    username: typing.Optional[str]
+    password: typing.Optional[str]
+
+    def add_to_request(self, cfg: RequestConfig) -> RequestConfig:
+        if self.username is not None and self.password is not None:
+            cfg["auth"] = (self.username, self.password)
+
+        return cfg
+
+
+class AuthBearer(BaseModel, AuthProvider):
+    val: typing.Optional[str]
+
+    def add_to_request(self, cfg: RequestConfig) -> RequestConfig:
+        if self.val is not None:
+            # Add bearer header auth val
+            headers = cfg.get("headers", dict())
+            headers["Authorization"] = f"Bearer {self.val}"
+            cfg["headers"] = headers
+
+        return cfg
+
+
+class AuthKeyQuery(BaseModel, AuthProvider):
+    query_name: str
+    val: typing.Optional[str]
+
+    def add_to_request(self, cfg: RequestConfig) -> RequestConfig:
+        if self.val is not None:
+            # Add query auth value
+            params = cfg.get("params", dict())
+            params[self.query_name] = self.val
+            cfg["params"] = params
+
+        return cfg
+
+
+class AuthKeyHeader(BaseModel, AuthProvider):
+    header_name: str
+    val: typing.Optional[str]
+
+    def add_to_request(self, cfg: RequestConfig) -> RequestConfig:
+        if self.val is not None:
+            # Add header auth val
+            headers = cfg.get("headers", {})
+            headers[self.header_name] = self.val
+            cfg["headers"] = headers
+
+        return cfg
+
+
+class AuthKeyCookie(BaseModel, AuthProvider):
+    cookie_name: str
+    val: typing.Optional[str]
+
+    def add_to_request(self, cfg: RequestConfig) -> RequestConfig:
+        if self.val is not None:
+            # Add cookie auth val
+            cookies = cfg.get("cookies", dict())
+            cookies[self.cookie_name] = self.val
+            cfg["cookies"] = cookies
+
+        return cfg

magic_hour-0.0.1/magic_hour/core/base_client.py

@@ -0,0 +1,296 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+from json import JSONDecodeError
+from typing import Any, List, TypeVar, Dict, Optional, Type, Union, cast
+
+import httpx
+from pydantic import BaseModel
+
+from .api_error import ApiError
+from .auth import AuthProvider
+from .request import RequestConfig, RequestOptions, default_request_options, QueryParams
+from .response import from_encodable
+from .utils import is_binary_content_type, get_content_type
+from .binary_response import BinaryResponse
+
+NoneType = type(None)
+T = TypeVar(
+    "T",
+    bound=Union[object, None, str, "BaseModel", List[Any], Dict[str, Any], Any],
+)
+
+
+class BaseClient:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+    ):
+        self._base_url = base_url
+        self._auths: Dict[str, AuthProvider] = {}
+
+    def register_auth(self, auth_id: str, provider: AuthProvider):
+        self._auths[auth_id] = provider
+
+    def default_headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "x-sideko-sdk-language": "Python",
+        }
+        return headers
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+    def build_url(self, path: str) -> str:
+        base = self._base_url
+        if base.endswith("/"):
+            base = base[:-1]
+        if path.startswith("/"):
+            path = path[1:]
+
+        return f"{base}/{path}"
+
+    def _apply_auth(
+        self, *, cfg: RequestConfig, auth_names: List[str]
+    ) -> RequestConfig:
+        for auth_name in auth_names:
+            auth_provider = self._auths.get(auth_name)
+            if auth_provider is not None:
+                cfg = auth_provider.add_to_request(cfg)
+
+        return cfg
+
+    def _apply_headers(
+        self,
+        *,
+        cfg: RequestConfig,
+        opts: RequestOptions,
+        content_type: Optional[str] = None,
+        explicit_headers: Optional[Dict[str, str]] = None,
+    ) -> RequestConfig:
+        headers = cfg.get("headers", {})
+        headers.update(self.default_headers())
+
+        if content_type is not None:
+            headers["content-type"] = content_type
+
+        if explicit_headers is not None:
+            headers.update(explicit_headers)
+
+        additional_headers = opts.get("additional_headers", None)
+        if additional_headers is not None:
+            headers.update(additional_headers)
+
+        if len(headers) > 0:
+            cfg["headers"] = headers
+
+        return cfg
+
+    def _apply_query_params(
+        self,
+        *,
+        cfg: RequestConfig,
+        opts: RequestOptions,
+        query_params: Optional[QueryParams] = None,
+    ) -> RequestConfig:
+        params = cfg.get("params", {})
+
+        if query_params is not None:
+            params.update(query_params)
+
+        additional_params = opts.get("additional_params", None)
+        if additional_params is not None:
+            params.update(additional_params)
+
+        if len(params) > 0:
+            cfg["params"] = params
+
+        return cfg
+
+    def _apply_timeout(
+        self,
+        *,
+        cfg: RequestConfig,
+        opts: RequestOptions,
+    ) -> RequestConfig:
+        timeout = opts.get("timeout", None)
+
+        # TODO: timeout from base class
+        if timeout is not None:
+            cfg["timeout"] = timeout
+
+        return cfg
+
+    def _apply_body(
+        self,
+        *,
+        cfg: RequestConfig,
+        data: Optional[httpx._types.RequestData] = None,
+        files: Optional[httpx._types.RequestFiles] = None,
+        json: Optional[Any] = None,
+        content: Optional[httpx._types.RequestContent] = None,
+    ) -> RequestConfig:
+        if data is not None:
+            cfg["data"] = data
+
+        if files is not None:
+            cfg["files"] = files
+
+        if json is not None:
+            cfg["json"] = json
+
+        if content is not None:
+            cfg["content"] = content
+
+        return cfg
+
+    def build_request(
+        self,
+        *,
+        method: str,
+        path: str,
+        auth_names: Optional[List[str]] = None,
+        query_params: Optional[QueryParams] = None,
+        headers: Optional[Dict[str, str]] = None,
+        data: Optional[httpx._types.RequestData] = None,
+        files: Optional[httpx._types.RequestFiles] = None,
+        json: Optional[Any] = None,
+        content_type: Optional[str] = None,
+        content: Optional[httpx._types.RequestContent] = None,
+        request_options: Optional[RequestOptions] = None,
+    ) -> RequestConfig:
+        opts = request_options or default_request_options()
+        req_cfg: RequestConfig = {"method": method, "url": self.build_url(path)}
+        req_cfg = self._apply_auth(cfg=req_cfg, auth_names=auth_names or [])
+        req_cfg = self._apply_headers(
+            cfg=req_cfg, opts=opts, content_type=content_type, explicit_headers=headers
+        )
+        req_cfg = self._apply_query_params(
+            cfg=req_cfg, opts=opts, query_params=query_params
+        )
+        req_cfg = self._apply_body(
+            cfg=req_cfg, data=data, files=files, json=json, content=content
+        )
+        req_cfg = self._apply_timeout(cfg=req_cfg, opts=opts)
+
+        return req_cfg
+
+    def process_response(self, *, response=httpx.Response, cast_to: Type[T]) -> T:
+        if 200 <= response.status_code < 300:
+            content_type = get_content_type(response.headers)
+            if response.status_code == 204 or cast_to == NoneType:
+                return cast(T, None)
+            elif cast_to == BinaryResponse:
+                return cast(
+                    T,
+                    BinaryResponse(content=response.content, headers=response.headers),
+                )
+            else:
+                if "json" in content_type or "form" in content_type:
+                    return from_encodable(data=response.json(), load_with=cast_to)
+                elif is_binary_content_type(content_type):
+                    return cast(
+                        T,
+                        BinaryResponse(
+                            content=response.content, headers=response.headers
+                        ),
+                    )
+                else:
+                    return from_encodable(data=response.content, load_with=cast_to)
+        else:
+            try:
+                response_json = response.json()
+            except JSONDecodeError:
+                raise ApiError(status_code=response.status_code, body=response.text)
+            raise ApiError(status_code=response.status_code, body=response_json)
+
+
+class SyncBaseClient(BaseClient):
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        httpx_client: httpx.Client,
+    ):
+        super().__init__(base_url=base_url)
+        self.httpx_client = httpx_client
+
+    def request(
+        self,
+        *,
+        method: str,
+        path: str,
+        cast_to: Type[T],
+        auth_names: Optional[List[str]] = None,
+        query_params: Optional[QueryParams] = None,
+        headers: Optional[Dict[str, str]] = None,
+        data: Optional[httpx._types.RequestData] = None,
+        files: Optional[httpx._types.RequestFiles] = None,
+        json: Optional[Any] = None,
+        content_type: Optional[str] = None,
+        content: Optional[httpx._types.RequestContent] = None,
+        request_options: Optional[RequestOptions] = None,
+    ) -> T:
+        req_cfg = self.build_request(
+            method=method,
+            path=path,
+            auth_names=auth_names,
+            query_params=query_params,
+            headers=headers,
+            data=data,
+            files=files,
+            json=json,
+            content_type=content_type,
+            content=content,
+            request_options=request_options,
+        )
+
+        response = self.httpx_client.request(**req_cfg)
+
+        return self.process_response(response=response, cast_to=cast_to)
+
+
+class AsyncBaseClient(BaseClient):
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        httpx_client: httpx.AsyncClient,
+    ):
+        super().__init__(base_url=base_url)
+        self.httpx_client = httpx_client
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        cast_to: Type[T],
+        auth_names: Optional[List[str]] = None,
+        query_params: Optional[QueryParams] = None,
+        headers: Optional[Dict[str, str]] = None,
+        data: Optional[httpx._types.RequestData] = None,
+        files: Optional[httpx._types.RequestFiles] = None,
+        json: Optional[Any] = None,
+        content_type: Optional[str] = None,
+        content: Optional[httpx._types.RequestContent] = None,
+        request_options: Optional[RequestOptions] = None,
+    ) -> T:
+        req_cfg = self.build_request(
+            method=method,
+            path=path,
+            auth_names=auth_names,
+            query_params=query_params,
+            headers=headers,
+            data=data,
+            files=files,
+            json=json,
+            content_type=content_type,
+            content=content,
+            request_options=request_options,
+        )
+
+        response = await self.httpx_client.request(**req_cfg)
+
+        return self.process_response(response=response, cast_to=cast_to)

magic_hour-0.0.1/magic_hour/core/binary_response.py

@@ -0,0 +1,16 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+"""File Generated by Sideko (sideko.dev)"""
+
+from httpx._models import Headers
+
+
+class BinaryResponse:
+    content: bytes
+    headers: Headers
+
+    def __init__(self, content: bytes, headers: Headers) -> None:
+        self.content = content
+        self.headers = headers