Translate the document into English was a bit difficult, I have tried.
Improve Flask-RESTFul's behavior. Add some new features.
All features that shown below was optional, choose according to your needs.
source: error_handling.py
Flask-RESTFul's error handler can only output error message for the exceptions that raised by itself.
This make it can handling other kind of exceptions in same way.
api = restful_extend.ErrorHandledApi(app) # instead of `api = restful.Api(app)`
class MyRoutes(Resource):
def get(self):
raise Exception("errmsg") # now, the 'errmsg' can output to clientsources: extend_json.py, json_encode_manager.py
Support more data type by default, and you can simply add supports for new data type.
# This is a custom type, you can't direct return a value of this type in Flask or Flask-RESTFul.
class RationalNumber(object):
def __init__(self, numerator, denominator):
self.numerator = numerator
self.denominator = denominator
api = restful.Api(app)
# Enable enhanced json encode feature
enhance_json_encode(api)
# create and register a custom encoder, to encode your custom type to serializable value.
def rational_encoder(rational):
return rational.numerator * 1.0 / rational.denominator
api.json_encoder.register(rational_encoder, RationalNumber)
class MyRoutes(Resource):
def get(self):
return RationalNumber(1, 5) # now you can return the value of your custom type directlysource: extend_json.py
Respond jsonp request automatically
api = restful.Api(app)
support_jsonp(api)
class MyRoutes(Resource):
def get(self):
return dict(foo='bar')
api.add_resource(MyRoutes, '/my_routes')
# normal request: /my_routes response: {"foo": "bar"}
# jsonp request: /my_routes?callback=my_cb response: my_cb({"foo": "bar"})source: marshal.py
Extend Flask-RESTFul's marshal_with decorator's behavior. Auto define fields for ORM model.
class MyRoutes(Resource):
# With `marshal_with_model`, you can return an model instance or model query
# in view function directly.
@marshal_with_model(MyModel, excludes=['id'])
def get(self):
return MyModel.query # response: [my_model1, my_model2, ...]
# If you need return different type of model in different situation, you can use `quick_marshal`
def post(self):
if something:
return quick_marshal(MyModel)(MyModel.query.get(1)) # response: my_model
else:
return quick_marshal(HisModel)(HisModel.query) # response: [his_model1, ...]source: model_converter.py
api = restful.Api(app)
class Student(db.model):
id = Column(Integer, primary_key=True)
name = Column(String(50))
register_model_converter(Student)
class MyRoutes(object):
def get(self, classmate):
pass
api.add_resource(MyRoutes, '/classmates/<Student:classmate>')
# request: /classmates/102 response: {"id": 102, "name": "superman"}source: model_reqparse.py
required: fixed_type (see next section)
class Student(db.model):
id = Column(Integer, primary_key=True)
name = Column(String(50))
age = Column(Integer)
class MyRoutes(object):
def post(self):
# use `make_request_parser` quickly create a `RequestParser`
parser = make_request_parser(Student)
# you can update the parser as usual
parser.add_argument('is_a_boy')
request_data = parser.parse_args()
print request_data['name'], request_data['age']
# do something...
class MyRoutes2(object):
def post(self):
# if you want padding the request data to a model,
# you can use `populate_model`, it's more convenience.
model = Student.query.get(1)
populate_model(model) # the model was updated use user request datasources: model_reqparse.py, reqparse_fixed_type.py
fix_argument_convert
Change reqparse.Argument.convert's original behavior.
You should call this function before use make_request_parser, populate_model or fixed types.
fixed types
A set of customized type_constructor.
Use them in place of int、str、datetime... to be the type used in Argument's type parameter, this can provide some additional feature.
source: model_validates.py
Simplify and extend SQLAlchemy's attribute validates process. This function has no relationship with Flask-RESTful.
For more details, please read the documents in source.