Support multiple media types under the same status code

docs/Example.md

@@ -180,6 +180,38 @@ if __name__ == '__main__':
     app.run(debug=True)
 ```
 
+## Multiple media types
+
+```python
+
+@app.get(
+    '/book/<int:bid>',
+    tags=[book_tag],
+    summary='new summary',
+    description='new description',
+    responses={
+        200: {
+            "description": "Multiple media types under the same status code",
+            "content": {
+                "application/json": BookResponse,
+                "application/xml": BookResponse,
+            }
+        },
+        201: {"content": {"text/csv": {"schema": {"type": "string"}}}}
+    },
+    security=security
+)
+def get_book(path: BookPath):
+    """Get a book
+    to get some book by id, like:
+    http://localhost:5000/book/3
+    """
+    if path.bid == 4:
+        return NotFoundResponse().dict(), 404
+    return {"code": 0, "message": "ok", "data": {"bid": path.bid, "age": 3, "author": 'no'}}
+
+```
+
 ## APIBlueprint
 
 ```python

flask_openapi3/utils.py

@@ -328,13 +328,44 @@ def get_responses(
     _responses = {}
     _schemas = {}
 
+    def register_schema(name, schema: Any) -> None:
+        _schemas[name] = Schema(**schema)
+        definitions = schema.get("$defs")
+        if definitions:
+            # Add schema definitions to _schemas
+            for name, value in definitions.items():
+                _schemas[normalize_name(name)] = Schema(**value)
+
     for key, response in responses.items():
         if response is None:
             # If the response is None, it means HTTP status code "204" (No Content)
             _responses[key] = Response(description=HTTP_STATUS.get(key, ""))
         elif isinstance(response, dict):
             response["description"] = response.get("description", HTTP_STATUS.get(key, ""))
-            _responses[key] = Response(**response)
+            if "content" in response:
+                response_content_map = {}
+                for content_type, model in response["content"].items():
+                    if isinstance(model, dict):
+                        # inline schema
+                        response_content_map[content_type] = MediaType(
+                            schema=Schema(**model["schema"])
+                        ) if "schema" in model else MediaType(
+                            schema=Schema(type=DataType.STRING)
+                        )
+                    elif issubclass(model, BaseModel):
+                        # pydantic model
+                        schema = get_model_schema(model, mode="serialization")
+                        original_title = schema.get("title") or model.__name__
+                        name = normalize_name(original_title)
+                        response_content_map[content_type] = MediaType(
+                            schema=Schema(**{"$ref": f"{OPENAPI3_REF_PREFIX}/{name}"})
+                        )
+                        register_schema(name, schema)
+                _responses[key] = Response(
+                    description=HTTP_STATUS.get(key, ""),
+                    content=response_content_map)
+            else:
+                _responses[key] = Response(**response)
         else:
             # OpenAPI 3 support ^[a-zA-Z0-9\.\-_]+$ so we should normalize __name__
             schema = get_model_schema(response, mode="serialization")
@@ -367,12 +398,7 @@ def get_responses(
                     _content["application/json"].encoding = openapi_extra.get("encoding")  # type: ignore
                 _content.update(openapi_extra.get("content", {}))  # type: ignore
 
-            _schemas[name] = Schema(**schema)
-            definitions = schema.get("$defs")
-            if definitions:
-                # Add schema definitions to _schemas
-                for name, value in definitions.items():
-                    _schemas[normalize_name(name)] = Schema(**value)
+            register_schema(name, schema)
 
     components_schemas.update(**_schemas)
     operation.responses = _responses