magic_hour 0.36.2__py3-none-any.whl → 0.37.0__py3-none-any.whl

magic_hour/core/query.py

@@ -1,124 +0,0 @@
-import json
-
-from typing import Any, Dict, Union
-from typing_extensions import Literal, Sequence
-
-import httpx
-
-
-# Type alias for query parameters that can handle both primitive data and sequences
-QueryParams = Dict[
-    str, Union[httpx._types.PrimitiveData, Sequence[httpx._types.PrimitiveData]]
-]
-QueryParamStyle = Literal["form", "spaceDelimited", "pipeDelimited", "deepObject"]
-
-
-def encode_query_param(
-    params: QueryParams,
-    name: str,
-    value: Any,
-    style: QueryParamStyle = "form",
-    explode: bool = True,
-) -> None:
-    if style == "form":
-        _encode_form(params, name, value, explode)
-    elif style == "spaceDelimited":
-        _encode_spaced_delimited(params, name, value, explode)
-    elif style == "pipeDelimited":
-        _encode_pipe_delimited(params, name, value, explode)
-    elif style == "deepObject":
-        _encode_deep_object(params, name, value, explode)
-    else:
-        raise NotImplementedError(f"query param style '{style}' not implemented")
-
-
-def _query_str(val: Any) -> str:
-    """jsonify value without wrapping quotes for strings"""
-    if isinstance(val, str):
-        return val
-    return json.dumps(val)
-
-
-def _encode_form(params: QueryParams, name: str, value: Any, explode: bool) -> None:
-    """
-    Encodes query params in the `form` style as defined by OpenAPI with both explode and non-explode
-    variants.
-    """
-    if isinstance(value, list) and not explode:
-        # non-explode form lists should be encoded like /users?id=3,4,5
-        params[name] = ",".join(map(_query_str, value))
-    elif isinstance(value, dict):
-        if explode:
-            # explode form objects should be encoded like /users?key0=val0&key1=val1
-            # the input param name will be omitted
-            for k, v in value.items():
-                params[k] = _query_str(v)
-        else:
-            # non-explode form objects should be encoded like /users?id=key0,val0,key1,val1
-            encoded_chunks = []
-            for k, v in value.items():
-                encoded_chunks.extend([str(k), _query_str(v)])
-            params[name] = ",".join(encoded_chunks)
-    else:
-        params[name] = value
-
-
-def _encode_spaced_delimited(
-    params: QueryParams, name: str, value: Any, explode: bool
-) -> None:
-    """
-    Encodes query params in the `spaceDelimited` style as defined by OpenAPI with both explode and non-explode
-    variants.
-    """
-    if isinstance(value, list) and not explode:
-        # non-explode spaceDelimited lists should be encoded like /users?id=3%204%205
-        params[name] = " ".join(map(_query_str, value))
-    else:
-        # according to the docs, spaceDelimited + explode=false only effects lists,
-        # all other encodings are marked as n/a or are the same as `form` style
-        # fall back on form style as it is the default for query params
-        _encode_form(params, name, value, explode)
-
-
-def _encode_pipe_delimited(
-    params: QueryParams, name: str, value: Any, explode: bool
-) -> None:
-    """
-    Encodes query params in the `pipeDelimited` style as defined by OpenAPI with both explode and non-explode
-    variants.
-    """
-    if isinstance(value, list) and not explode:
-        # non-explode pipeDelimited lists should be encoded like /users?id=3|4|5
-        params[name] = "|".join(map(_query_str, value))
-    else:
-        # according to the docs, pipeDelimited + explode=false only effects lists,
-        # all other encodings are marked as n/a or are the same as `form` style
-        # fall back on form style as it is the default for query params
-        _encode_form(params, name, value, explode)
-
-
-def _encode_deep_object(
-    params: QueryParams, name: str, value: Any, explode: bool
-) -> None:
-    """
-    Encodes query params in the `deepObject` style as defined by with both explode and non-explode
-    variants.
-    """
-    if isinstance(value, (dict, list)):
-        _encode_deep_object_key(params, name, value)
-    else:
-        # according to the docs, deepObject style only applies to
-        # object encodes, encodings for primitives are listed as n/a,
-        # fall back on form style as it is the default for query params
-        _encode_form(params, name, value, explode)
-
-
-def _encode_deep_object_key(params: QueryParams, key: str, value: Any) -> None:
-    if isinstance(value, dict):
-        for k, v in value.items():
-            _encode_deep_object_key(params, f"{key}[{k}]", v)
-    elif isinstance(value, list):
-        for i, v in enumerate(value):
-            _encode_deep_object_key(params, f"{key}[{i}]", v)
-    else:
-        params[key] = _query_str(value)

magic_hour/core/request.py

@@ -1,162 +0,0 @@
-from typing import Any, Dict, Type, Union, List, Mapping
-
-import httpx
-from typing_extensions import TypedDict, Required, NotRequired
-from pydantic import TypeAdapter, BaseModel
-
-from .type_utils import NotGiven
-from .query import QueryParams, QueryParamStyle, encode_query_param
-
-"""
-Request configuration and utility functions for handling HTTP requests.
-This module provides type definitions and helper functions for building
-and processing HTTP requests in a type-safe manner.
-"""
-
-
-class RequestConfig(TypedDict):
-    """
-    Configuration for HTTP requests.
-
-    Defines all possible parameters that can be passed to an HTTP request,
-    including required method and URL, as well as optional parameters like
-    content, headers, authentication, etc.
-    """
-
-    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):
-    """
-    Additional options for customizing request behavior.
-
-    Provides configuration for timeouts and additional headers/parameters
-    that should be included with requests.
-
-    Attributes:
-        timeout: Number of seconds to await an API call before timing out
-        additional_headers: Extra headers to include in the request
-        additional_params: Extra query parameters to include in the request
-    """
-
-    timeout: NotRequired[int]
-    additional_headers: NotRequired[Dict[str, str]]
-    additional_params: NotRequired[QueryParams]
-
-
-def default_request_options() -> RequestOptions:
-    """
-    Provides default request options.
-
-    Returns an empty dictionary as the base configuration, allowing defaults
-    to be handled by the underlying HTTP client.
-    """
-    return {}
-
-
-def model_dump(item: Any) -> Any:
-    """
-    Recursively converts Pydantic models to dictionaries.
-
-    Handles nested structures including lists and individual models,
-    preserving alias information and excluding unset values.
-    """
-    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: Union[Type[Any], Union[Type[Any], Any], List[Type[Any]]]
-) -> Any:
-    """
-    Validates and converts an item to an encodable format using a specified type.
-    Uses Pydantic's TypeAdapter for validation and converts the result
-    to a format suitable for encoding in requests.
-    """
-    filtered_item = filter_not_given(item)
-    adapter: TypeAdapter[Any] = TypeAdapter(dump_with)
-    validated_item = adapter.validate_python(filtered_item)
-    return model_dump(validated_item)
-
-
-def to_form_urlencoded(
-    *,
-    item: Any,
-    dump_with: Union[Type[Any], Union[Type[Any], Any]],
-    style: Mapping[str, QueryParamStyle],
-    explode: Mapping[str, bool],
-) -> Mapping[str, Any]:
-    """
-    Encodes object as x-www-form-urlencoded according to style and explode options
-    """
-    encoded = to_encodable(item=item, dump_with=dump_with)
-
-    if not isinstance(encoded, dict):
-        raise TypeError("x-www-form-urlencoded data must be an object at the top level")
-
-    form_data: QueryParams = {}
-
-    for key, val in encoded.items():
-        key_style = style.get(key, "form")
-        key_explode = explode.get(key, key_style == "form")
-        encode_query_param(form_data, key, val, style=key_style, explode=key_explode)
-
-    return form_data
-
-
-def to_content(*, file: httpx._types.FileTypes) -> httpx._types.RequestContent:
-    """
-    Converts the various ways files can be provided to something that is accepted by
-    the httpx.request content kwarg
-    """
-    if isinstance(file, tuple):
-        file_content: httpx._types.FileContent = file[1]
-    else:
-        file_content = file
-
-    if hasattr(file_content, "read") and callable(file_content.read):
-        return file_content.read()
-    else:
-        return file_content
-
-
-def filter_not_given(value: Any) -> Any:
-    """Helper function to recursively filter out NotGiven values"""
-    if isinstance(value, NotGiven):
-        return None  # This will trigger filtering at the container level
-    elif isinstance(value, dict):
-        return {
-            k: filter_not_given(v)
-            for k, v in value.items()
-            if not isinstance(v, NotGiven)
-        }
-    elif isinstance(value, (list, tuple)):
-        return type(value)(
-            filter_not_given(item) for item in value if not isinstance(item, NotGiven)
-        )
-    return value
-
-
-def _get_default_for_type(value_type: Any) -> Any:
-    """Helper to provide appropriate default values for required fields"""
-    if value_type is dict or isinstance(value_type, dict):
-        return {}
-    elif value_type is list or isinstance(value_type, list):
-        return []
-    return None

magic_hour/core/response.py

@@ -1,297 +0,0 @@
-import json
-from typing import Any, Union, Dict, Type, TypeVar, List, Generic, Optional
-from pydantic import BaseModel
-import httpx
-
-"""
-Provides functionality for handling Server-Sent Events (SSE) streams and response data encoding.
-Includes utilities for both synchronous and asynchronous stream processing.
-"""
-
-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:
-    """
-    Converts raw data into a specified type using Pydantic validation.
-
-    Uses a dynamic Pydantic model to validate and convert incoming data
-    into the specified target type.
-    """
-
-    class Caster(BaseModel):
-        data: load_with  # type: ignore
-
-    return Caster(data=data).data
-
-
-T = TypeVar("T")
-
-
-class StreamResponse(Generic[T]):
-    """
-    Handles synchronous streaming of Server-Sent Events (SSE).
-
-    Processes a streaming HTTP response by buffering chunks of data
-    and parsing them according to SSE format, converting each event
-    into the specified type.
-    """
-
-    def __init__(
-        self, response: httpx.Response, stream_context: Any, cast_to: Type[T]
-    ) -> None:
-        """
-        Initialize the stream processor with response and conversion settings.
-
-        Args:
-            response: The HTTP response containing the SSE stream
-            stream_context: Context manager for the stream
-            cast_to: Target type for converting parsed events
-        """
-        self.response = response
-        self._context = stream_context
-        self.cast_to = cast_to
-        self.iterator = response.iter_bytes()
-        self.buffer = bytearray()
-        self.position = 0
-
-    def __iter__(self) -> "StreamResponse[T]":
-        """Enables iteration over the stream events."""
-        return self
-
-    def __next__(self) -> T:
-        """
-        Retrieves and processes the next event from the stream.
-
-        Buffers incoming data and processes it according to SSE format,
-        converting each complete event into the specified type.
-
-        Raises:
-            StopIteration: When the stream is exhausted
-        """
-        try:
-            while True:
-                event = self._process_buffer()
-                if event:
-                    return event
-
-                chunk = next(self.iterator)
-                self.buffer += chunk
-
-        except StopIteration:
-            event = self._process_buffer(final=True)
-            if event:
-                return event
-            self._context.__exit__(None, None, None)
-            raise
-
-    def _process_buffer(self, final: bool = False) -> Optional[T]:
-        """
-        Processes the current buffer to extract complete SSE events.
-
-        Searches for event boundaries and parses complete events,
-        handling both JSON and non-JSON payloads.
-
-        Args:
-            final: Whether this is the final processing of the buffer
-        """
-        while self.position < len(self.buffer):
-            for boundary in [b"\r\n\r\n", b"\n\n", b"\r\r"]:
-                if (self.position + len(boundary)) <= len(self.buffer):
-                    if (
-                        self.buffer[self.position : self.position + len(boundary)]
-                        == boundary
-                    ):
-                        message = self.buffer[: self.position].decode()
-                        self.buffer = self.buffer[self.position + len(boundary) :]
-                        self.position = 0
-
-                        data = self._parse_sse(message)
-                        if data:
-                            try:
-                                parsed_data = json.loads(data)
-                                if (
-                                    not isinstance(parsed_data, dict)
-                                    or "data" not in parsed_data
-                                ):
-                                    parsed_data = {"data": parsed_data}
-                                return from_encodable(  # type: ignore[no-any-return]
-                                    data=parsed_data, load_with=self.cast_to
-                                )
-                            except json.JSONDecodeError:
-                                return from_encodable(  # type: ignore[no-any-return]
-                                    data={"data": data}, load_with=self.cast_to
-                                )
-                        return None
-
-            self.position += 1
-
-        if final and self.buffer:
-            message = self.buffer.decode()
-            data = self._parse_sse(message)
-            if data:
-                try:
-                    parsed_data = json.loads(data)
-                    if not isinstance(parsed_data, dict) or "data" not in parsed_data:
-                        parsed_data = {"data": parsed_data}
-                    return from_encodable(data=parsed_data, load_with=self.cast_to)  # type: ignore[no-any-return]
-                except json.JSONDecodeError:
-                    return from_encodable(data={"data": data}, load_with=self.cast_to)  # type: ignore[no-any-return]
-
-        return None
-
-    def _parse_sse(self, message: str) -> Optional[str]:
-        """
-        Parses an SSE message to extract the data field.
-
-        Handles multi-line data fields and empty data fields according
-        to the SSE specification.
-        """
-        data = []
-        for line in message.split("\n"):
-            if line.startswith("data:"):
-                data.append(line[5:].strip())
-            elif line.strip() == "data:":  # Handle empty data field
-                data.append("")
-
-        if data:
-            return "\n".join(data)
-        return None
-
-
-class AsyncStreamResponse(Generic[T]):
-    """
-    Handles asynchronous streaming of Server-Sent Events (SSE).
-
-    Asynchronous version of StreamResponse, providing the same functionality
-    but compatible with async/await syntax.
-    """
-
-    def __init__(
-        self, response: httpx.Response, stream_context: Any, cast_to: Type[T]
-    ) -> None:
-        """
-        Initialize the async stream processor.
-
-        Args:
-            response: The HTTP response containing the SSE stream
-            stream_context: Async context manager for the stream
-            cast_to: Target type for converting parsed events
-        """
-        self.response = response
-        self._context = stream_context
-        self.cast_to = cast_to
-        self.iterator = response.aiter_bytes()
-        self.buffer = bytearray()
-        self.position = 0
-
-    def __aiter__(self) -> "AsyncStreamResponse[T]":
-        """Enables async iteration over the stream events."""
-        return self
-
-    async def __anext__(self) -> T:
-        """
-        Asynchronously retrieves and processes the next event from the stream.
-
-        Similar to synchronous version but uses async/await syntax for
-        iteration and context management.
-
-        Raises:
-            StopAsyncIteration: When the stream is exhausted
-        """
-        try:
-            while True:
-                event = self._process_buffer()
-                if event:
-                    return event
-
-                chunk = await self.iterator.__anext__()
-                self.buffer += chunk
-
-        except StopAsyncIteration:
-            event = self._process_buffer(final=True)
-            if event:
-                return event
-            await self._context.__aexit__(None, None, None)
-            raise
-
-    def _process_buffer(self, final: bool = False) -> Optional[T]:
-        """
-        Processes the current buffer to extract complete SSE events.
-
-        Identical to the synchronous version's buffer processing.
-        """
-        while self.position < len(self.buffer):
-            for boundary in [b"\r\n\r\n", b"\n\n", b"\r\r"]:
-                if (self.position + len(boundary)) <= len(self.buffer):
-                    if (
-                        self.buffer[self.position : self.position + len(boundary)]
-                        == boundary
-                    ):
-                        message = self.buffer[: self.position].decode()
-                        self.buffer = self.buffer[self.position + len(boundary) :]
-                        self.position = 0
-
-                        data = self._parse_sse(message)
-                        if data:
-                            try:
-                                parsed_data = json.loads(data)
-                                if (
-                                    not isinstance(parsed_data, dict)
-                                    or "data" not in parsed_data
-                                ):
-                                    parsed_data = {"data": parsed_data}
-                                return from_encodable(  # type: ignore[no-any-return]
-                                    data=parsed_data, load_with=self.cast_to
-                                )
-                            except json.JSONDecodeError:
-                                return from_encodable(  # type: ignore[no-any-return]
-                                    data={"data": data}, load_with=self.cast_to
-                                )
-                        return None
-
-            self.position += 1
-
-        if final and self.buffer:
-            message = self.buffer.decode()
-            data = self._parse_sse(message)
-            if data:
-                try:
-                    parsed_data = json.loads(data)
-                    if not isinstance(parsed_data, dict) or "data" not in parsed_data:
-                        parsed_data = {"data": parsed_data}
-                    return from_encodable(data=parsed_data, load_with=self.cast_to)  # type: ignore[no-any-return]
-                except json.JSONDecodeError:
-                    return from_encodable(data={"data": data}, load_with=self.cast_to)  # type: ignore[no-any-return]
-
-        return None
-
-    def _parse_sse(self, message: str) -> Optional[str]:
-        """
-        Parses an SSE message to extract the data field.
-
-        Identical to the synchronous version's SSE parsing.
-        """
-        data = []
-        for line in message.split("\n"):
-            line = line.strip()
-            if line.startswith("data:"):
-                data.append(line[5:].strip())
-            elif line == "data:":  # Handle empty data field
-                data.append("")
-
-        if data:
-            return "\n".join(data)
-        return None

magic_hour/core/type_utils.py

@@ -1,28 +0,0 @@
-from typing import (
-    Union,
-)
-from typing_extensions import (
-    Literal,
-    TypeVar,
-    override,
-)
-
-_T = TypeVar("_T")
-
-
-class NotGiven:
-    """
-    Used to distinguish omitted keyword arguments from those passed explicitly
-    with the value None.
-    """
-
-    def __bool__(self) -> Literal[False]:
-        return False
-
-    @override
-    def __repr__(self) -> str:
-        return "NOT_GIVEN"
-
-
-NotGivenOr = Union[_T, NotGiven]
-NOT_GIVEN = NotGiven()

magic_hour/core/utils.py

@@ -1,55 +0,0 @@
-import typing
-import re
-from typing_extensions import Literal
-
-import httpx
-
-from .binary_response import BinaryResponse
-
-
-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 get_response_type(headers: httpx.Headers) -> Literal["json", "text", "binary"]:
-    """Check response type based on content type"""
-    content_type = headers.get("content-type")
-
-    if re.search("^application/(.+[+])?json", content_type):
-        return "json"
-    elif re.search("^text/(.+)", content_type):
-        return "text"
-    else:
-        return "binary"
-
-
-def is_union_type(type_hint: typing.Any) -> bool:
-    """Check if a type hint is a Union type."""
-    return hasattr(type_hint, "__origin__") and type_hint.__origin__ is typing.Union
-
-
-def filter_binary_response(cast_to: typing.Type[typing.Any]) -> typing.Type[typing.Any]:
-    """
-    Filters out BinaryResponse from a Union type.
-    If cast_to is not a Union, returns it unchanged.
-    """
-    if not is_union_type(cast_to):
-        return cast_to
-
-    types = typing.get_args(cast_to)
-    filtered = tuple(t for t in types if t != BinaryResponse)
-
-    # If everything was filtered out, return original type
-    if not filtered:
-        return cast_to
-    # If only one type remains, return it directly
-    if len(filtered) == 1:
-        return typing.cast(typing.Type[typing.Any], filtered[0])
-    # Otherwise return new Union with filtered types
-    return typing.cast(typing.Type[typing.Any], typing.Union[filtered])