msgspec-fastapi 0.0.1__py3-none-any.whl

msgspec_fastapi/__init__.py

@@ -0,0 +1,4 @@
+from .responses import MsgspecJSONResponse
+from .router import MsgspecRouter, install_openapi
+
+__all__ = ['MsgspecJSONResponse', 'MsgspecRouter', 'install_openapi']

msgspec_fastapi/responses.py

@@ -0,0 +1,10 @@
+from typing import Any
+import msgspec
+from starlette.responses import JSONResponse
+
+_JSON_ENCODER = msgspec.json.Encoder()
+
+class MsgspecJSONResponse(JSONResponse):
+    """Encode JSON with msgspec; use MsgspecRouter for output validation."""
+    def render(self, content: Any) -> bytes:
+        return _JSON_ENCODER.encode(content)

msgspec_fastapi/router.py

@@ -0,0 +1,406 @@
+from __future__ import annotations
+
+import inspect
+from copy import deepcopy
+from functools import partial, wraps
+from hashlib import sha256
+from typing import Annotated, get_args, get_origin, get_type_hints
+
+import msgspec
+from pydantic import BaseModel
+from fastapi import APIRouter, FastAPI, HTTPException, Request, Response
+from fastapi.datastructures import DefaultPlaceholder
+from fastapi.exceptions import RequestValidationError, ResponseValidationError
+from fastapi.openapi.utils import validation_error_definition, validation_error_response_definition
+from fastapi.params import Body, Depends, Param
+from fastapi.routing import APIRoute, _effective_route_context_var, iter_route_contexts
+from starlette.concurrency import run_in_threadpool
+
+from .responses import MsgspecJSONResponse
+from .validation import base_type, constrained_type, prepare_parameters, structured_type, uses_pydantic
+
+
+def _untyped_encode_hook(value):
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode='json', by_alias=True)
+    raise TypeError(f'Encoding objects of type {type(value).__name__} is unsupported')
+
+
+def _contains_struct(annotation):
+    value = base_type(annotation)
+    return (isinstance(value, type) and issubclass(value, msgspec.Struct)) or any(
+        _contains_struct(arg) for arg in get_args(value)
+    )
+
+
+def _body_type(annotation):
+    value = base_type(annotation)
+    if structured_type(value):
+        return True
+    if get_origin(value) in (list, dict, tuple, set, frozenset):
+        return True
+    return any(_body_type(arg) for arg in get_args(value))
+
+
+def _metadata(parameter, annotation):
+    items = list(get_args(annotation)[1:]) if get_origin(annotation) is Annotated else []
+    return [*items, parameter.default]
+
+
+def _merge_components(target, incoming):
+    for name, schema in incoming.items():
+        if name in target and target[name] != schema:
+            raise ValueError(f'Conflicting OpenAPI component: {name}')
+        target[name] = deepcopy(schema)
+
+
+def _schema(annotation, components):
+    (schema,), definitions = msgspec.json.schema_components(
+        [annotation], ref_template='#/components/schemas/{name}'
+    )
+    _merge_components(components, definitions)
+    return schema
+
+
+def _json_type(annotation):
+    if annotation in (inspect.Signature.empty, None) or uses_pydantic(annotation):
+        return False
+    value = base_type(annotation)
+    if isinstance(value, type) and issubclass(value, Response):
+        return False
+    try:
+        msgspec.json.Decoder(type=annotation)
+        msgspec.json.schema(annotation)
+    except (TypeError, ValueError):
+        return False
+    return True
+
+
+def _hints(endpoint):
+    target = endpoint
+    while isinstance(target, partial):
+        target = target.func
+    if not inspect.isfunction(target) and not inspect.ismethod(target):
+        target = target.__call__
+    return get_type_hints(target, include_extras=True)
+
+
+def _parse_body(request, raw, config):
+    decoder, default, embedded = config
+    if not raw:
+        if default is inspect.Signature.empty:
+            raise RequestValidationError([{'loc': ('body',), 'msg': 'Field required', 'type': 'missing'}])
+        return deepcopy(default)
+    media_type = request.headers.get('content-type', '').split(';')[0].strip().lower()
+    if media_type and media_type != 'application/json' and not (
+        media_type.startswith('application/') and media_type.endswith('+json')
+    ):
+        raise HTTPException(415, 'Expected a JSON request body')
+    try:
+        value = decoder.decode(raw)
+    except msgspec.ValidationError as exc:
+        # Typed decoding can stop on a field error before discovering invalid syntax.
+        try:
+            msgspec.json.decode(raw)
+        except (msgspec.DecodeError, UnicodeError) as syntax:
+            raise HTTPException(400, f'Malformed JSON body: {syntax}') from syntax
+        raise RequestValidationError([{'loc': ('body',), 'msg': str(exc), 'type': 'value_error.msgspec'}]) from exc
+    except (msgspec.DecodeError, UnicodeError) as exc:
+        raise HTTPException(400, f'Malformed JSON body: {exc}') from exc
+    return value.value if embedded else value
+
+
+class MsgspecRoute(APIRoute):
+    def get_route_handler(self):
+        context = _effective_route_context_var.get()
+        route = context if context is not None and context.original_route is self else self
+        prepare_parameters(route.dependant)
+        handler = super().get_route_handler()
+        config = getattr(self.endpoint, '_msgspec_body_config', None)
+        if config is None:
+            return handler
+        if route.body_field is not None:
+            raise TypeError('Other FastAPI body fields cannot be combined with a msgspec body')
+
+        async def handle(request):
+            # Invalid JSON must be rejected before dependency side effects.
+            request.scope['_msgspec_body_value'] = _parse_body(request, await request.body(), config)
+            return await handler(request)
+        return handle
+
+
+def install_openapi(app: FastAPI, *routers: 'MsgspecRouter') -> None:
+    """Install once after including routers, before serving the application."""
+    if not routers:
+        raise TypeError('Pass the MsgspecRouter instances included in the app')
+    if getattr(app, '_msgspec_openapi_installed', False):
+        raise RuntimeError('msgspec OpenAPI is already installed')
+    # FastAPI builds included contexts lazily; validate them before serving.
+    list(iter_route_contexts(app.routes))
+    original = app.openapi
+    app.openapi_schema = None
+
+    def openapi():
+        document = original()
+        components = document.setdefault('components', {}).setdefault('schemas', {})
+        for router in routers:
+            _merge_components(components, router.msgspec_components)
+        for route in iter_route_contexts(app.routes):
+            original_route = getattr(route, 'original_route', route)
+            if not isinstance(original_route, MsgspecRoute):
+                continue
+            fields = []
+            def collect(dependant):
+                for group in ('path_params', 'query_params', 'header_params', 'cookie_params'):
+                    fields.extend(getattr(dependant, group))
+                for dependency in dependant.dependencies:
+                    collect(dependency)
+            collect(route.dependant)
+            for method in route.methods:
+                operation = document.get('paths', {}).get(route.path_format, {}).get(method.lower(), {})
+                for parameter in operation.get('parameters', []):
+                    for field in fields:
+                        if (getattr(field, '_msgspec_parameter', False)
+                            and parameter['in'] == field.field_info.in_.value
+                            and parameter['name'] == field.alias):
+                            schema = deepcopy(field._msgspec_schema)
+                            for key in ('title', 'description', 'default'):
+                                if key in parameter.get('schema', {}):
+                                    schema[key] = parameter['schema'][key]
+                            parameter['schema'] = schema
+        return document
+
+    app.openapi = openapi
+    app._msgspec_openapi_installed = True
+
+
+class MsgspecRouter(APIRouter):
+    """Typed msgspec JSON bodies and validated responses for ordinary CRUD routes."""
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('route_class', MsgspecRoute)
+        kwargs.setdefault('default_response_class', MsgspecJSONResponse)
+        if not issubclass(kwargs['route_class'], MsgspecRoute):
+            raise TypeError('route_class must extend MsgspecRoute')
+        super().__init__(*args, **kwargs)
+        self.msgspec_components = {}
+
+    def include_router(self, router, *args, **kwargs):
+        if isinstance(router, MsgspecRouter):
+            _merge_components(self.msgspec_components, router.msgspec_components)
+        return super().include_router(router, *args, **kwargs)
+
+    def add_api_route(self, path, endpoint, **kwargs):
+        override = kwargs.get('route_class_override')
+        if override is not None and not issubclass(override, MsgspecRoute):
+            raise TypeError('route_class_override must extend MsgspecRoute')
+        # Included routes already have a prepared signature and response metadata.
+        if getattr(endpoint, '_msgspec_prepared', False):
+            return super().add_api_route(path, endpoint, **kwargs)
+        signature = inspect.signature(endpoint)
+        hints = _hints(endpoint)
+        parameters = [p.replace(annotation=hints.get(p.name, p.annotation)) for p in signature.parameters.values()]
+        return_type = hints.get('return', signature.return_annotation)
+        explicit = kwargs.get('response_model', inspect.Signature.empty)
+        inferred = explicit is inspect.Signature.empty or isinstance(explicit, DefaultPlaceholder)
+        output_type = return_type if inferred else explicit
+        validates_output = _json_type(output_type)
+        if validates_output:
+            output_type, output_strict = constrained_type(output_type)
+            if output_strict is False:
+                raise TypeError('JSON msgspec responses use strict validation')
+        output_decoder = msgspec.json.Decoder(type=output_type) if validates_output else None
+        # Like FastAPI with a Pydantic response_model at the top level: an instance of exactly
+        # the declared Struct class is trusted and encoded once; other top-level values,
+        # including subclass instances, are validated against the schema. Unlike Pydantic,
+        # values nested in a trusted instance are encoded as they are (a nested subclass keeps
+        # its extra fields, and the type parameters of a generic Struct are not checked).
+        output_class = (get_origin(base_type(output_type)) or base_type(output_type)) if validates_output else None
+        trusts_instances = isinstance(output_class, type) and issubclass(output_class, msgspec.Struct)
+        output_encoder = msgspec.json.Encoder() if validates_output else None
+        response_class = kwargs.get('response_class')
+        if response_class is None or isinstance(response_class, DefaultPlaceholder):
+            response_class = self.default_response_class
+        if isinstance(response_class, DefaultPlaceholder):
+            response_class = response_class.value
+        serializes_untyped_output = (
+            output_type in (inspect.Signature.empty, None)
+            and not uses_pydantic(return_type)
+            and response_class is MsgspecJSONResponse
+        )
+        handles_output = validates_output or serializes_untyped_output or (
+            explicit is None and _contains_struct(return_type)
+        )
+        untyped_encoder = (
+            msgspec.json.Encoder(enc_hook=_untyped_encode_hook)
+            if serializes_untyped_output else None
+        )
+        body = None
+        body_meta = None
+        for parameter in parameters:
+            metadata = _metadata(parameter, parameter.annotation)
+            if any(isinstance(x, Depends) for x in metadata):
+                continue
+            is_body = _contains_struct(parameter.annotation) or any(isinstance(x, Body) for x in metadata)
+            if _body_type(parameter.annotation) and not any(isinstance(x, Param) for x in metadata):
+                is_body = True
+            if is_body and _json_type(parameter.annotation):
+                if any(isinstance(x, Param) for x in metadata):
+                    raise TypeError('msgspec Struct query/path/header/cookie parameters are not supported')
+                if body is not None:
+                    raise TypeError('Only one msgspec body parameter is supported; other body fields cannot be combined')
+                body = parameter
+                body_meta = next((x for x in metadata if isinstance(x, Body)), None)
+
+        if body is None and not handles_output:
+            return super().add_api_route(path, endpoint, **kwargs)
+        if any(p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL) for p in parameters):
+            raise TypeError('Variadic msgspec endpoints are not supported')
+        if handles_output:
+            if validates_output:
+                for option in ('response_model_include', 'response_model_exclude',
+                               'response_model_exclude_unset', 'response_model_exclude_defaults',
+                               'response_model_exclude_none'):
+                    if kwargs.get(option):
+                        raise TypeError(f'{option} is not supported for msgspec responses')
+                if kwargs.get('response_model_by_alias', True) is False:
+                    raise TypeError('msgspec responses use encoded field names')
+            if validates_output and kwargs.get('status_code') in (204, 304):
+                raise TypeError('A typed msgspec response requires a response body')
+            response_class = kwargs.get('response_class')
+            if response_class is not None and not isinstance(response_class, DefaultPlaceholder) and response_class is not MsgspecJSONResponse:
+                raise TypeError('Custom response_class is not supported for typed msgspec responses')
+            kwargs['response_model'] = None
+            kwargs['response_class'] = MsgspecJSONResponse
+
+        components = {}
+        responses = deepcopy(kwargs.get('responses') or {})
+        openapi_extra = deepcopy(kwargs.get('openapi_extra') or {})
+        default = inspect.Signature.empty
+        decoder = None
+        embedded = False
+        if body is not None:
+            metadata = [x for x in get_args(body.annotation)[1:] if not isinstance(x, Body)] if get_origin(body.annotation) is Annotated else []
+            body_type, body_strict = constrained_type(base_type(body.annotation), metadata)
+            if body_strict is False:
+                raise TypeError('JSON msgspec bodies use strict validation')
+            if body_meta is not None:
+                if body_meta.media_type != 'application/json':
+                    raise TypeError('Only application/json msgspec bodies are supported')
+                body_type, body_strict = constrained_type(body_type, body_meta.metadata)
+                if body_strict is False:
+                    raise TypeError('JSON msgspec bodies use strict validation')
+                embedded = body_meta.embed is True
+                default = body_meta.default
+                from pydantic_core import PydanticUndefined
+                if default is PydanticUndefined or default is Ellipsis:
+                    default = inspect.Signature.empty
+                if not isinstance(body.default, Body) and body.default is not inspect.Signature.empty:
+                    default = body.default
+                if body_meta.default_factory is not None:
+                    raise TypeError('Body default_factory is not supported')
+            else:
+                default = body.default
+            decode_type = body_type
+            if embedded:
+                # One explicit JSON envelope, preserving a possible Body alias.
+                field = ('value', body_type) if default is inspect.Signature.empty else (
+                    'value', body_type, msgspec.field(default_factory=lambda: deepcopy(default))
+                )
+                identity = {'schema': msgspec.json.schema(body_type), 'alias': body_meta.alias or body.name,
+                            'required': default is inspect.Signature.empty}
+                if default is not inspect.Signature.empty:
+                    identity['default'] = default
+                name = 'MsgspecBody_' + sha256(msgspec.json.encode(identity)).hexdigest()[:16]
+                decode_type = msgspec.defstruct(name, [field],
+                                               rename={'value': body_meta.alias or body.name})
+            decoder = msgspec.json.Decoder(type=decode_type)
+            body_schema = _schema(decode_type, components)
+            openapi_extra['requestBody'] = {'required': default is inspect.Signature.empty,
+                'content': {'application/json': {'schema': body_schema}}}
+            responses.setdefault(400, {'description': 'Malformed JSON'})
+            responses.setdefault(422, {'description': 'Validation Error', 'content': {
+                'application/json': {'schema': {'$ref': '#/components/schemas/HTTPValidationError'}}}})
+            _merge_components(components, {'HTTPValidationError': validation_error_response_definition,
+                                           'ValidationError': validation_error_definition})
+        if validates_output:
+            code = kwargs.get('status_code') or 200
+            key = str(code) if str(code) in responses else code
+            result_meta = responses.setdefault(key, {})
+            result_meta.setdefault('description', kwargs.get('response_description', 'Successful Response'))
+            result_meta.setdefault('content', {})['application/json'] = {'schema': _schema(output_type, components)}
+        previous_components = deepcopy(self.msgspec_components)
+        _merge_components(self.msgspec_components, components)
+        kwargs['responses'] = responses
+        kwargs['openapi_extra'] = openapi_extra
+
+        remaining = [p for p in parameters if p is not body]
+        def injected_name(type_, fallback):
+            for p in remaining:
+                annotation = base_type(p.annotation)
+                if isinstance(annotation, type) and issubclass(annotation, type_):
+                    return p.name, False
+            names = {p.name for p in parameters}
+            while fallback in names:
+                fallback += '_'
+            remaining.append(inspect.Parameter(fallback, kind=inspect.Parameter.KEYWORD_ONLY, annotation=type_))
+            return fallback, True
+        request_name, remove_request = injected_name(Request, '__msgspec_request') if body else (None, False)
+        response_name, remove_response = injected_name(Response, '__msgspec_response') if handles_output else (None, False)
+
+        is_async = inspect.iscoroutinefunction(endpoint) or inspect.iscoroutinefunction(getattr(endpoint, '__call__', None))
+        @wraps(endpoint)
+        async def wrapper(**values):
+            sub_response = values.get(response_name)
+            if remove_response:
+                values.pop(response_name)
+            if body is not None:
+                request = values[request_name]
+                if remove_request:
+                    values.pop(request_name)
+                value = request.scope['_msgspec_body_value']
+                values[body.name] = value
+            if is_async:
+                result = await endpoint(**values)
+            else:
+                result = await run_in_threadpool(endpoint, **values)
+                if inspect.isawaitable(result):
+                    result = await result
+            if isinstance(result, Response):
+                return result
+            if not handles_output:
+                return msgspec.to_builtins(result) if _contains_struct(return_type) else result
+            if validates_output and not (trusts_instances and type(result) is output_class):
+                try:
+                    # Typed decoding validates fields and Meta, even for existing Structs.
+                    result = output_decoder.decode(output_encoder.encode(result))
+                except (TypeError, ValueError, OverflowError) as exc:
+                    raise ResponseValidationError([{'loc': ('response',), 'msg': str(exc), 'type': 'value_error.msgspec'}]) from exc
+            status_code = sub_response.status_code or kwargs.get('status_code') or 200
+            if untyped_encoder is not None:
+                response = Response(untyped_encoder.encode(result), status_code=status_code,
+                                    media_type='application/json')
+            else:
+                response = MsgspecJSONResponse(result, status_code=status_code)
+            if response.status_code < 200 or response.status_code in (204, 205, 304):
+                response.body = b''
+                if 'content-length' in response.headers:
+                    del response.headers['content-length']
+            response.raw_headers.extend(sub_response.raw_headers)
+            return response
+
+        wrapper.__signature__ = signature.replace(parameters=remaining, return_annotation=inspect.Signature.empty if handles_output else return_type)
+        wrapper._msgspec_prepared = True
+        if body is not None:
+            wrapper._msgspec_body_config = (decoder, default, embedded)
+        route_count = len(self.routes)
+        try:
+            result = super().add_api_route(path, wrapper, **kwargs)
+            if body is not None and self.routes[-1].body_field is not None:
+                raise TypeError('Other FastAPI body fields cannot be combined with a msgspec body')
+            return result
+        except Exception:
+            del self.routes[route_count:]
+            self.msgspec_components = previous_components
+            raise
+

msgspec_fastapi/validation.py

@@ -0,0 +1,239 @@
+"""Route-local validation for HTTP parameters; no global FastAPI changes."""
+import re
+
+from typing import Annotated, Any, Literal, Union, get_args, get_origin, get_type_hints
+from dataclasses import is_dataclass
+from typing_extensions import is_typeddict
+from types import UnionType
+
+import annotated_types
+import msgspec
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+
+def base_type(annotation):
+    return get_args(annotation)[0] if get_origin(annotation) is Annotated else annotation
+
+
+def structured_type(annotation):
+    value = get_origin(base_type(annotation)) or base_type(annotation)
+    return isinstance(value, type) and (
+        issubclass(value, msgspec.Struct) or is_typeddict(value) or is_dataclass(value)
+        or (issubclass(value, tuple) and hasattr(value, '_fields'))
+    )
+
+
+def uses_pydantic(annotation):
+    value = base_type(annotation)
+    return (isinstance(value, type) and issubclass(value, BaseModel)) or any(
+        uses_pydantic(item) for item in get_args(value)
+    )
+
+
+def _check_structured_metadata(annotation, seen=None):
+    if seen is None:
+        seen = set()
+    if get_origin(annotation) is Annotated:
+        annotation, *metadata = get_args(annotation)
+        if any(not isinstance(item, msgspec.Meta) for item in metadata):
+            raise TypeError('Use msgspec.Meta inside structured model fields')
+    origin = get_origin(annotation)
+    value = origin or annotation
+    structured = structured_type(annotation)
+    if structured and value not in seen:
+        seen.add(value)
+        for field_type in get_type_hints(value, include_extras=True).values():
+            _check_structured_metadata(field_type, seen)
+    for arg in get_args(annotation):
+        _check_structured_metadata(arg, seen)
+
+
+def constrained_type(annotation, metadata=()):
+    """Translate supported FastAPI constraints, rejecting unhandled validation."""
+    if get_origin(annotation) is Annotated:
+        annotation, *extras = get_args(annotation)
+        metadata = (*extras, *metadata)
+    origin, args = get_origin(annotation), get_args(annotation)
+    if structured_type(annotation):
+        _check_structured_metadata(annotation)
+    if args and origin is not Literal:
+        converted = []
+        for arg in args:
+            if arg is Ellipsis:
+                converted.append(arg)
+                continue
+            target, nested_strict = constrained_type(arg)
+            if nested_strict is not None:
+                raise TypeError('Nested strict constraints are not supported; use a strict top-level parameter')
+            converted.append(target)
+        converted = tuple(converted)
+        if hasattr(annotation, 'copy_with'):
+            annotation = annotation.copy_with(converted)
+        elif origin in (Union, UnionType):
+            annotation = Union[converted]
+        else:
+            annotation = origin[converted[0] if len(converted) == 1 else converted]
+    expanded = []
+    for item in metadata:
+        if isinstance(item, FieldInfo):
+            expanded.extend(item.metadata)
+        else:
+            expanded.append(item)
+    metadata = expanded
+    constraints = {}
+    metas = []
+    strict = None
+    for item in metadata:
+        if isinstance(item, msgspec.Meta):
+            metas.append(item)
+        elif isinstance(item, (annotated_types.Gt, annotated_types.Ge, annotated_types.Lt,
+                               annotated_types.Le, annotated_types.MultipleOf,
+                               annotated_types.MinLen, annotated_types.MaxLen)):
+            name = {'MinLen': 'min_length', 'MaxLen': 'max_length'}.get(type(item).__name__,
+                       {'MultipleOf': 'multiple_of'}.get(type(item).__name__, type(item).__name__.lower()))
+            constraints[name] = getattr(item, name)
+        elif type(item).__module__.startswith('pydantic') and type(item).__name__ == 'Strict':
+            strict = item.strict
+        elif type(item).__module__.startswith('pydantic') and type(item).__name__ == '_PydanticGeneralMetadata':
+            for name, value in vars(item).items():
+                if name not in ('pattern',):
+                    raise TypeError(f'Unsupported msgspec parameter constraint: {name}')
+                constraints[name] = value
+        else:
+            raise TypeError(f'Unsupported msgspec parameter metadata: {type(item).__name__}')
+    if constraints:
+        metas.append(msgspec.Meta(**constraints))
+    if metas:
+        # FastAPI constraints on nullable scalars apply to the non-null branch.
+        args = get_args(annotation)
+        if get_origin(annotation) in (Union, UnionType) and type(None) in args and len(args) == 2:
+            inner = next(arg for arg in args if arg is not type(None))
+            target = Union[Annotated[inner, *metas], type(None)]
+        else:
+            target = Annotated[annotation, *metas]
+    else:
+        target = annotation
+    return target, strict
+
+
+
+# Unicode White_Space used by Rust str::trim, excluding Python's extra C0 separators.
+_HTTP_WHITESPACE = '\t\n\v\f\r \x85\xa0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000'
+_HTTP_INTEGER = re.compile(r'-?(?:0|[1-9][0-9]*)\Z')
+
+
+def _http_int(value):
+    """Match pydantic-core 2.46.5 str_as_int/clean_int_str on HTTP strings."""
+    if not isinstance(value, str):
+        return value
+    # Preserve the direct parser's size/error behavior before its cleanup fallback.
+    if _HTTP_INTEGER.fullmatch(value):
+        return int(value)
+    number = value.strip(_HTTP_WHITESPACE)
+    if number.startswith('+'):
+        number = number[1:]
+        if number.startswith('-'):
+            raise ValueError('Invalid integer parameter')
+    negative = number.startswith('-')
+    if negative:
+        number = number[1:]
+        if number.startswith(('-', '+')):
+            raise ValueError('Invalid integer parameter')
+    if not number or number[0] not in '0123456789-':
+        raise ValueError('Invalid integer parameter')
+    if number[0] == '0':
+        for offset in range(1, len(number)):
+            char = number[offset]
+            if char in '0_':
+                continue
+            if char in '123456789-':
+                number = number[offset:]
+                break
+            if char == '.':
+                number = number[offset - 1:]
+                break
+            raise ValueError('Invalid integer parameter')
+        else:
+            number = number[-1:]
+    if '.' in number:
+        whole, decimal = number.split('.', 1)
+        if decimal and all(char == '0' for char in decimal):
+            number = whole
+    if ('_' in number and not number.startswith('_') and not number.endswith('_')
+            and '__' not in number):
+        number = number.replace('_', '')
+    if negative:
+        number = '-' + number
+    if not _HTTP_INTEGER.fullmatch(number):
+        raise ValueError('Invalid integer parameter')
+    return int(number)
+
+def _http_normalizer(annotation):
+    """Compile supported transport coercions once at route registration."""
+    annotation = base_type(annotation)
+    origin, args = get_origin(annotation), get_args(annotation)
+    if origin in (Union, UnionType) and type(None) in args and len(args) == 2:
+        return _http_normalizer(next(arg for arg in args if arg is not type(None)))
+    if origin in (list, set, frozenset, tuple):
+        if origin is tuple and args and args[-1] is not Ellipsis:
+            children = tuple(_http_normalizer(arg) for arg in args)
+            if not any(children):
+                return None
+            def normalize_tuple(value):
+                return [children[i](item) if i < len(children) and children[i] else item
+                        for i, item in enumerate(value)] if isinstance(value, (list, tuple)) else value
+            return normalize_tuple
+        child = _http_normalizer(args[0]) if args else None
+        if child is None:
+            return None
+        def normalize_sequence(value):
+            return [child(item) for item in value] if isinstance(value, (list, tuple)) else value
+        return normalize_sequence
+    if annotation is int:
+        return _http_int
+    if annotation is bool:
+        def normalize_bool(value):
+            if isinstance(value, str):
+                lowered = value.lower()
+                if lowered in ('yes', 'on', 'y', 't'):
+                    return True
+                if lowered in ('no', 'off', 'n', 'f'):
+                    return False
+            return value
+        return normalize_bool
+    if annotation is bytes:
+        return lambda value: value.encode('utf-8') if isinstance(value, str) else value
+    return None
+
+
+def _parameter_validator(target, strict):
+    normalizer = None if strict else _http_normalizer(target)
+    convert = msgspec.convert
+    def validate(value: Any, values=None, *, loc=()):
+        try:
+            if normalizer is not None:
+                value = normalizer(value)
+            return convert(value, type=target, strict=strict), []
+        except (ValueError, UnicodeError, OverflowError) as exc:
+            return None, [{'loc': loc, 'msg': str(exc), 'type': 'value_error.msgspec'}]
+    return validate
+
+
+def prepare_parameters(dependant):
+    """Keep FastAPI extraction/aliases/defaults; replace supported validators."""
+    for group in ('path_params', 'query_params', 'header_params', 'cookie_params'):
+        for field in getattr(dependant, group):
+            if uses_pydantic(field.field_info.annotation):
+                continue
+            if getattr(field, '_msgspec_parameter', False):
+                continue
+            target, strict = constrained_type(field.field_info.annotation, field.field_info.metadata)
+            strict = bool(strict)
+            schema = msgspec.json.schema(target)
+
+            field.validate = _parameter_validator(target, strict)
+            field._msgspec_parameter = True
+            field._msgspec_schema = schema
+    for dependency in dependant.dependencies:
+        prepare_parameters(dependency)

msgspec_fastapi-0.0.1.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: msgspec-fastapi
+Version: 0.0.1
+Summary: Experimental FastAPI router that decodes request bodies and encodes responses with msgspec
+Project-URL: Source, https://github.com/Siyet/msgspec-fastapi
+Project-URL: Issues, https://github.com/Siyet/msgspec-fastapi/issues
+Author: Aleksandr Tseluiko
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: FastAPI
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: fastapi<0.144,>=0.142.2
+Requires-Dist: msgspec>=0.22.0
+Description-Content-Type: text/markdown
+
+# msgspec-fastapi
+
+An experimental FastAPI router that uses msgspec for JSON request bodies and responses.
+
+This is a prototype. Its API may change, and it relies on private FastAPI internals, so
+it is pinned to FastAPI 0.142.2 to 0.143.x. It is a personal project, not part of
+msgspec; feedback is welcome in the issues.
+
+## Installation
+
+```sh
+pip install msgspec-fastapi
+```
+
+## Usage
+
+```python
+import msgspec
+from fastapi import FastAPI
+from msgspec_fastapi import MsgspecRouter, install_openapi
+
+
+class City(msgspec.Struct):
+    name: str
+    population: int
+
+
+router = MsgspecRouter()
+
+
+@router.post('/cities')
+async def create_city(city: City) -> City:
+    return city
+
+
+app = FastAPI()
+app.include_router(router)
+install_openapi(app, router)
+```
+
+## What it does
+
+- A msgspec body parameter (a Struct or another type msgspec can decode) is decoded from
+  the raw request bytes by a `msgspec.json.Decoder` built once at route registration.
+  A non-JSON content type returns 415, malformed JSON returns 400, and a missing or
+  invalid body returns 422. Bodies are decoded in msgspec strict mode: for example, the
+  JSON string `"1"` is not accepted for an `int` field, unlike FastAPI with Pydantic.
+- A msgspec response type, from the return annotation or `response_model`, is encoded
+  with msgspec. An instance of exactly the declared Struct class is encoded without
+  revalidation, as FastAPI does for a Pydantic `response_model`; other values are
+  validated against the declared type. Nested values and type parameters of a trusted
+  instance are not checked.
+- Responses of routes without a return annotation or `response_model` are also encoded
+  with msgspec, so the output can differ from FastAPI's `jsonable_encoder` (for example,
+  `bytes` are base64-encoded and `Decimal` is encoded as a string).
+- Path, query, header and cookie parameters keep FastAPI extraction, aliases and
+  defaults, but are converted with `msgspec.convert(strict=False)` instead of Pydantic,
+  so coercion differs for some inputs (for example, `" 1.5"` is rejected for `float`
+  and `"nan"` is accepted for `Decimal`). Parameter types must be supported by msgspec;
+  Pydantic-specific types such as `AnyUrl` raise `TypeError` at route registration.
+- `install_openapi` adds the msgspec JSON schemas to the OpenAPI document. It is required
+  for a valid document: call it once after including the routers, passing every
+  `MsgspecRouter` that is not included directly in another `MsgspecRouter`.
+- A Pydantic body or response model is left to FastAPI; the route parameters are still
+  validated with msgspec.
+
+## Limitations
+
+- Only one msgspec body parameter per route, and it cannot be combined with other
+  FastAPI body fields. Only JSON bodies are supported: `application/json`,
+  `application/*+json`, or a request without a content type.
+- Structs, alone or inside containers, are not supported as path, query, header or
+  cookie parameters.
+- `response_model_include`, `response_model_exclude`, `response_model_exclude_*` and
+  `response_model_by_alias=False` are rejected for typed msgspec responses.
+
+## Development
+
+```sh
+uv run --group test pytest
+```

msgspec_fastapi-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+msgspec_fastapi/__init__.py,sha256=qza4iZ78zIdyMQjhSyfu3kExhINEBjVp30ctKDIj6nw,165
+msgspec_fastapi/responses.py,sha256=Ocx51DUVWUU1zCqegwIO-NVqyFJK8Gf-SL4k1GABiEw,332
+msgspec_fastapi/router.py,sha256=jsNl6PF1ZkEmQTkT8Ny0_ySlg7fwv-D5B9PtKFW9y30,21106
+msgspec_fastapi/validation.py,sha256=zomhWlcqZzUWTnq7mNp6sVCPU2lh0kMsK2f5eazmAko,10049
+msgspec_fastapi-0.0.1.dist-info/METADATA,sha256=lOU-mSz8OkfYBuCA7HHq1Or1nO0qfkp_oxxMHSdHqsU,3791
+msgspec_fastapi-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+msgspec_fastapi-0.0.1.dist-info/licenses/LICENSE,sha256=-tcdcjgHx0RS0YgoKnr_WJOaYz5gCXajKEnmMHRvwkc,1526
+msgspec_fastapi-0.0.1.dist-info/RECORD,,

msgspec_fastapi-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

msgspec_fastapi-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Aleksandr Tseluiko
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.