magic-hour 0.0.1__py3-none-any.whl

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/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/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/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/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/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/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

magic_hour/core/request.py

@@ -0,0 +1,77 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+from typing import Any, Dict, Type, Union, Sequence
+from urllib.parse import quote_plus
+
+
+import httpx
+from typing_extensions import TypedDict, Required, NotRequired
+from pydantic import TypeAdapter, BaseModel
+
+QueryParams = Dict[
+    str, Union[httpx._types.PrimitiveData, Sequence[httpx._types.PrimitiveData]]
+]
+
+
+class RequestConfig(TypedDict):
+    method: Required[str]
+    url: Required[httpx._types.URLTypes]
+    content: NotRequired[httpx._types.RequestContent]
+    data: NotRequired[httpx._types.RequestData]
+    files: NotRequired[httpx._types.RequestFiles]
+    json: NotRequired[Any]
+    params: NotRequired[QueryParams]
+    headers: NotRequired[Dict[str, str]]
+    cookies: NotRequired[Dict[str, str]]
+    auth: NotRequired[httpx._types.AuthTypes]
+    follow_redirects: NotRequired[bool]
+    timeout: NotRequired[httpx._types.TimeoutTypes]
+    extensions: NotRequired[httpx._types.RequestExtensions]
+
+
+class RequestOptions(TypedDict):
+    """
+    Attributes:
+        - timeout: int. The number of seconds to await an API call before timing out.
+
+        - additional_headers: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's header dict
+
+        - additional_params: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's query parameters dict
+
+    """
+
+    timeout: NotRequired[int]
+    additional_headers: NotRequired[Dict[str, str]]
+    additional_params: NotRequired[QueryParams]
+
+
+def default_request_options() -> RequestOptions:
+    """Returns default request options"""
+    return {}
+
+
+def model_dump(item: Any) -> Any:
+    if isinstance(item, list):
+        return [model_dump(i) for i in item]
+
+    if isinstance(item, BaseModel):
+        return item.model_dump(exclude_unset=True, by_alias=True)
+    else:
+        return item
+
+
+def to_encodable(*, item: Any, dump_with: Type) -> Any:
+    adapter = TypeAdapter(dump_with)
+    validated_item = adapter.validate_python(item)
+    return model_dump(validated_item)
+
+
+def encode_param(
+    value: Any, explode: bool
+) -> Union[httpx._types.PrimitiveData, Sequence[httpx._types.PrimitiveData]]:
+    if isinstance(value, (list, dict)) and not explode:
+        return quote_plus(",".join(map(str, value)))
+    else:
+        return value

magic_hour/core/response.py

@@ -0,0 +1,27 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+from typing import Any, Union, Dict, Type, TypeVar, List
+from pydantic import BaseModel
+
+EncodableT = TypeVar(
+    "EncodableT",
+    bound=Union[
+        object,
+        str,
+        int,
+        float,
+        None,
+        BaseModel,
+        List[Any],
+        Dict[str, Any],
+    ],
+)
+
+
+def from_encodable(*, data: Any, load_with: Type[EncodableT]) -> Any:
+    class Caster(BaseModel):
+        data: load_with  # type: ignore
+
+    return Caster(data=data).data

magic_hour/core/utils.py

@@ -0,0 +1,42 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+import typing
+import httpx
+
+
+def remove_none_from_dict(
+    original: typing.Dict[str, typing.Optional[typing.Any]],
+) -> typing.Dict[str, typing.Any]:
+    new: typing.Dict[str, typing.Any] = {}
+    for key, value in original.items():
+        if value is not None:
+            new[key] = value
+    return new
+
+
+def is_binary_content_type(content_type: str) -> bool:
+    """Check if the content type indicates binary data."""
+    binary_types = [
+        "application/octet-stream",
+        "application/pdf",
+        "application/zip",
+        "image/",
+        "audio/",
+        "video/",
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument",
+        "application/x-binary",
+        "application/vnd.ms-excel",
+        "application/vnd.ms-powerpoint",
+    ]
+    return any(binary_type in content_type for binary_type in binary_types)
+
+
+def get_content_type(headers: httpx.Headers) -> str:
+    """Get content type in a case-insensitive manner."""
+    for key, value in headers.items():
+        if key.lower() == "content-type":
+            return value.lower()
+    return ""

magic_hour/environment.py

@@ -0,0 +1,9 @@
+"""
+Generated by Sideko (sideko.dev)
+"""
+
+import enum
+
+
+class Environment(enum.Enum):
+    ENVIRONMENT = "https://api.magichour.ai"