def _get_response_definition(self, schema):
return {
sw.description: get_response_description(schema),
sw.content: {
"application/json": {sw.schema: get_ref_schema(self._ref_base, schema)}
},
}
def _get_paths(self, paths, default_headers_schema):
path_definitions = {}
for path, methods in paths.items():
swagger_path, path_args = format_path_for_swagger(path)
# Different Flask paths might correspond to the same Swagger path
# because of Flask URL path converters. In this case, let's just
# work off the same path definitions.
if swagger_path in path_definitions:
path_definition = path_definitions[swagger_path]
else:
path_definitions[swagger_path] = path_definition = {}
if path_args:
path_params = [
{
sw.name: path_arg.name,
sw.required: True,
sw.in_: sw.path,
sw.type_: self.flask_converters_to_swagger_types[path_arg.type],
}
for path_arg in path_args
]
# We have to check for an ugly case here. If different Flask
# paths that map to the same Swagger path use different URL
# converters for the same parameter, we have a problem. Let's
# just throw an error in this case.
if sw.parameters in path_definition:
verify_parameters_are_the_same(
path_definition[sw.parameters], path_params
)
path_definition[sw.parameters] = path_params
for method, d in methods.items():
responses_definition = {
sw.default: {
sw.description: get_response_description(
self.default_response_schema
),
sw.schema: {
sw.ref: create_ref(
self._ref_base,
get_swagger_title(self.default_response_schema),
)
},
}
}
if d.response_body_schema:
for status_code, schema in d.response_body_schema.items():
if schema is not None:
response_definition = {
sw.description: get_response_description(schema),
sw.schema: get_ref_schema(self._ref_base, schema),
}
responses_definition[str(status_code)] = response_definition
else:
responses_definition[str(status_code)] = {
sw.description: "No response body."
}
parameters_definition = []
if d.query_string_schema:
parameters_definition.extend(
self._convert_jsonschema_to_list_of_parameters(
self._query_string_converter(d.query_string_schema),
in_=sw.query,
)
)
if d.request_body_schema:
schema = d.request_body_schema
parameters_definition.append(
{
sw.name: schema.__class__.__name__,
sw.in_: sw.body,
sw.required: True,
sw.schema: get_ref_schema(self._ref_base, schema),
}
)
if d.headers_schema is USE_DEFAULT and default_headers_schema:
parameters_definition.extend(
self._convert_jsonschema_to_list_of_parameters(
self._headers_converter(default_headers_schema),
in_=sw.header,
)
)
elif (
d.headers_schema is not USE_DEFAULT and d.headers_schema is not None
):
parameters_definition.extend(
self._convert_jsonschema_to_list_of_parameters(
self._headers_converter(d.headers_schema), in_=sw.header
)
)
method_lower = method.lower()
path_definition[method_lower] = {
sw.operation_id: d.endpoint or get_swagger_title(d.func),
sw.responses: responses_definition,
}
if d.func.__doc__:
path_definition[method_lower][sw.description] = d.func.__doc__
if parameters_definition:
path_definition[method_lower][sw.parameters] = parameters_definition
if d.authenticator is None:
path_definition[method_lower][sw.security] = []
elif d.authenticator is not USE_DEFAULT:
security = self.authenticator_converter.get_security_requirement(
d.authenticator
)
path_definition[method_lower][sw.security] = security
if d.tags:
path_definition[method_lower][sw.tags] = d.tags
return path_definitions
