OpenAPI Core

Warnings

• breaking Support for Python 3.9 was dropped in version 0.23.0b1. Support for Python 3.8 was dropped in version 0.20.0.
  Fix: Upgrade your Python environment to 3.10 or newer.
• breaking With the introduction of OpenAPI 3.2 support, older 'V3 aliases' for specification components have been moved to 'V32' paths. For example, if you were directly importing from `openapi_core.spec.v3_0` it might need adjustment if those aliases were changed or removed.
  Fix: Review your imports related to `openapi_core.spec` and adjust them to the new V32 structure or use the main `OpenAPI` class for abstraction where possible.
• deprecated The `spec_base_uri` configuration parameter for `OpenAPI` initialization is deprecated.
  Fix: Use the `base_uri` parameter directly in `OpenAPI.from_dict()` or `OpenAPI.from_file()` instead.
• breaking The defaults for `style_deserializers_factory` and `media_tyles_deserialization_factory` in configuration and protocols were changed to `None`.
  Fix: If you relied on implicit defaults, you might need to explicitly configure these factories or update your code to handle `None` where a default factory was previously expected.
• gotcha Version 0.23.0 introduced an opt-in strict mode for omitted `additionalProperties`. By default, `additionalProperties` are allowed if not explicitly forbidden in the schema, but this mode can make validation stricter.
  Fix: If you encounter unexpected validation errors for properties not explicitly defined in your OpenAPI schema, consider whether you have enabled the strict mode or if your schema implicitly disallows additional properties. Adjust your schema or disable strict mode if necessary.

Install

• pip install openapi-core Base installation
• pip install openapi-core[flask,starlette,falcon,django,aiohttp] With web framework integrations

Imports

• OpenAPI

  from openapi_core import OpenAPI

  Main class to load and parse an OpenAPI specification.
• RequestValidator

  from openapi_core.validation.request.validators import RequestValidator

  Used for server-side request validation.
• ResponseValidator

  from openapi_core.validation.response.validators import ResponseValidator

  Used for server-side response validation.
• OpenAPIRequest

  from openapi_core.wrappers.mock import MockRequest as OpenAPIRequest

  Example of a wrapper for request objects. Specific framework wrappers are available in `openapi_core.contrib.*`
• OpenAPIResponse

  from openapi_core.wrappers.mock import MockResponse as OpenAPIResponse

  Example of a wrapper for response objects. Specific framework wrappers are available in `openapi_core.contrib.*`

Quickstart

This quickstart demonstrates loading an OpenAPI specification, creating mock requests and responses, and then using `RequestValidator` and `ResponseValidator` to validate them against the loaded spec. It covers both request parameters and response body validation. In real-world scenarios, you would use framework-specific request/response wrappers (e.g., `FlaskRequest`, `StarletteRequest`).

import io
from openapi_core import OpenAPI
from openapi_core.validation.request.validators import RequestValidator
from openapi_core.validation.response.validators import ResponseValidator
from openapi_core.wrappers.mock import MockRequest, MockResponse

# Define a simple OpenAPI spec
oas_spec = {
    "openapi": "3.0.0",
    "info": {"title": "Test API", "version": "1.0.0"},
    "paths": {
        "/hello": {
            "get": {
                "parameters": [
                    {
                        "name": "name",
                        "in": "query",
                        "required": True,
                        "schema": {"type": "string"}
                    }
                ],
                "responses": {
                    "200": {
                        "description": "A greeting",
                        "content": {
                            "application/json": {
                                "schema": {"type": "object", "properties": {"message": {"type": "string"}}}
                            }
                        }
                    }
                }
            }
        }
    }
}

# Load the OpenAPI specification
openapi = OpenAPI.from_dict(oas_spec)

# --- Request Validation ---

# Create a mock request for validation
request = MockRequest(
    host_url="http://localhost",
    path="/hello",
    method="get",
    query_string="name=World"
)

validator = RequestValidator(openapi)
result = validator.validate(request)

if result.errors:
    print(f"Request validation errors: {result.errors}")
else:
    print("Request validated successfully.")
    # Access validated parameters
    print(f"Validated query parameters: {result.parameters.query}")

# --- Response Validation ---

# Create a mock response for validation
response = MockResponse(
    data=io.BytesIO(b'{"message": "Hello, World!"}'),
    status_code=200,
    mimetype="application/json"
)

validator = ResponseValidator(openapi)
result = validator.validate(request, response)

if result.errors:
    print(f"Response validation errors: {result.errors}")
else:
    print("Response validated successfully.")