Schema markers

from typing import Annotated, Optional

from pydantic import BaseModel
from charter import Body, Case, Format, Mode, Path, Query


class SendMessage(BaseModel):
    user_id: Annotated[str, Path()]
    notify: Annotated[Optional[bool], Query()] = None
    raw: Annotated[str, Body(), Format("base64url")]
    thread_id: Annotated[Optional[str], Body(), Case("snake")] = None
    message_id: Annotated[Optional[str], Mode("response_only")] = None

class Path:
    def __init__(self, allow_slash: bool = False) -> None: ...

class Query:
    def __init__(self) -> None: ...

class Body:
    def __init__(self, envelop: bool = False, media_type: Optional[str] = None) -> None: ...

class Header:
    def __init__(self, name: str, template: Optional[str] = None) -> None: ...

from typing import Annotated, Optional

from pydantic import BaseModel, Field
from charter import Header, Path


class MessagesDelta(BaseModel):
    folder_id: Annotated[str, Path()]
    max_page_size: Annotated[
        Optional[int],
        Field(None, ge=1, description="The maximum number of messages in each page."),
        Header("Prefer", template="odata.maxpagesize={}"),
    ] = None

class FromContext:
    def __init__(self, key: Optional[str] = None) -> None: ...

import asyncio
from typing import Annotated

from pydantic import BaseModel, model_validator
from charter import FromContext, Path, ToolValidationError, api_key_tool_factory

OWNERS = {"ord_1": "cus_a", "ord_2": "cus_b"}


class GetOrder(BaseModel):
    order_id: Annotated[str, Path()]
    customer_id: Annotated[str, FromContext()]

    @model_validator(mode="after")
    def _own_order(self) -> "GetOrder":
        if OWNERS.get(self.order_id) != self.customer_id:
            raise ValueError("That order belongs to another customer.")
        return self


shop = api_key_tool_factory(
    pack="shop",
    base_url="https://shop.example.com/",
    api_key_headers={"X-Key": "k"},
)
get_order = shop(
    name="orders_get",
    description="Get an order.",
    method="GET",
    url_template="v1/orders/{order_id}",
    args_schema=GetOrder,
)


async def main():
    await get_order.ainvoke({"order_id": "ord_1"}, context={"customer_id": "cus_a"})
    try:
        await get_order.ainvoke({"order_id": "ord_2"}, context={"customer_id": "cus_a"})
    except ToolValidationError as refused:
        print(refused)  # That order belongs to another customer.


asyncio.run(main())

class Format:
    def __init__(self, transform: str) -> None: ...

class Mode:
    def __init__(self, modes: str) -> None: ...

def partial_of(
    model: type[BaseModel],
    *,
    name: str | None = None,
    doc: str | None = None,
) -> type[BaseModel]: ...

from typing import Optional

from pydantic import BaseModel, Field

from charter import partial_of


class Label(BaseModel):
    name: str = Field(..., description="The display name of the label.")
    color: Optional[str] = Field(None, description="Hex colour to assign.")


PatchLabelRequest = partial_of(Label, name="PatchLabelRequest")

assert not PatchLabelRequest.model_fields["name"].is_required()
assert PatchLabelRequest.model_fields["name"].description == Label.model_fields["name"].description

class Case:
    def __init__(self, case: KeyCase) -> None: ...

from typing import Annotated

from pydantic import BaseModel
from charter import Body, Case


class Place(BaseModel):
    display_name: Annotated[str, Case("pascal"), Body()]  # DisplayName

class ConflictsWith:
    def __init__(self, *fields: str, reason: str = "") -> None: ...

from typing import Annotated, Optional

from pydantic import BaseModel, Field
from charter import ConflictsWith, Query, WireName


class ListEvents(BaseModel):
    sync_token: Annotated[Optional[str], Field(None), Query()]
    i_cal_uid: Annotated[
        Optional[str],
        Field(None),
        Query(),
        WireName("iCalUID"),
        ConflictsWith("sync_token", reason="Drop syncToken to run a fresh query."),
    ]

iCalUID, q, timeMin cannot be combined with syncToken. Drop syncToken to run a
fresh query.

class WireName:
    def __init__(self, name: str) -> None: ...

from typing import Annotated
from typing import Optional

from pydantic import BaseModel, Field
from charter import Query, WireName


class ListEvents(BaseModel):
    i_cal_uid: Annotated[Optional[str], Field(None), Query(), WireName("iCalUID")]

class Gloss:
    def __init__(self, text: str) -> None: ...

from typing import Annotated, Optional

from pydantic import BaseModel, Field
from charter import Body, Gloss


class CreateRefund(BaseModel):
    amount: Annotated[
        Optional[int],
        Field(
            None,
            ge=1,
            description=(
                "A positive integer in the smallest currency unit representing "
                "how much to refund."
            ),
        ),
        Body(),
        Gloss("Cents, not dollars: $15.00 is 1500. Multiply a decimal amount by 100."),
    ]

A positive integer in the smallest currency unit representing how much to
refund. Cents, not dollars: $15.00 is 1500. Multiply a decimal amount by 100.

KeyCase = Literal["camel", "snake", "pascal", "kebab"]

class TransportOverride(TypedDict, total=False):
    path: Dict[str, Any]
    query: Dict[str, Any]
    body: Any
    headers: Dict[str, str]

from pydantic import BaseModel
from charter import TransportOverride


class ForecastRequest(BaseModel):
    metric: bool = True
    language: str = "en"


def build_forecast_request(tool_input: ForecastRequest) -> TransportOverride:
    return {
        "query": {
            "metric": str(tool_input.metric).lower(),
            "language": tool_input.language,
            "details": "true",
        }
    }