def patch_api(api: Api):
""" Wrap flask-restplus swagger decorator calls with functions that will convert Marshmallow Schemas to flask-restplus
Model objects before passing on the Model to the wrapped function
"""
api._restplus_expect = api.expect
def expect_patch(self, *inputs, **kwargs):
""" Reroute Api.expect() function to use the schema converter if provided object is a Marshmallow Schema"""
if isinstance(self, Schema) or isinstance(self, SchemaMeta):
model = convert_schema_to_model(api, self, self.__class__.__name__)
inputs = list(inputs)[0] = model
return api._restplus_expect(self, *inputs, **kwargs)
api.expect = expect_patch
api._restplus_response = api.response
def response_patch(self, *args, model=None, **kwargs):
""" Reroute Api.patch() function to use the schema -> model converter"""
restplus_model = convert_schema_to_model(api, model, model.__class__.__name__)
return api._restplus_response(self, *args, model=restplus_model, **kwargs)
api.response = response_patch
def register_method_parameters(self, method, matching_args: Union[dict, list]):
""" Provides a way to call the function wrapped by Api.param with a list of parameters. This allows user to
use their Model or Schema's .keys() attribute directly in a call to register_method_parameters, and have all
parameters registered at once instead of having to call @api.param() on every parameter.
Collection passed to this function can be a list of parameter names, or a dict of parameter names as keys
and descriptions as values.
"""
if isinstance(matching_args, dict):
for name, description in matching_args.items():
param_wrapper = self.param(name, description, _in='query')
param_wrapper(method)
elif isinstance(matching_args, list):
for name in matching_args:
param_wrapper = self.param(name, None, _in='query')
param_wrapper(method)
return self
from functools import partial
api.register_method_parameters = partial(register_method_parameters, self=api)
return api
