Rest Plus - Python

RestPlus is a Python framework that makes it easy to develop RESTful APIs. It builds on top of Flask and provides a lot of useful features out of the box, like automatic request parsing and response marshalling. In this article, we'll take a closer look at what RestPlus can do and how to use it.

Installation

You can install RestPlus using pip:

pip install Flask-RestPlus

Getting Started

First, let's create a simple RESTful API using RestPlus. We'll create a new Python file called main.py.

from flask import Flask
from flask_restplus import Api, Resource

app = Flask(__name__)
api = Api(app)

@api.route('/hello')
class HelloWorld(Resource):
    def get(self):
        return {'hello': 'world'}

if __name__ == '__main__':
    app.run(debug=True)

This example creates a new Flask application, creates a new RestPlus API object, and defines a new API route that returns a JSON object with a "hello" key and a "world" value. Note that we use the @api.route decorator to define the route.

Now that we've defined our API, we can run it using the following command:

python main.py

If we navigate to http://localhost:5000/hello, we should see our "hello world" JSON response.

Parsing Request Data

RestPlus makes it easy to parse request data using its built-in request parsing feature. Let's modify our previous example to accept a request parameter.

from flask import Flask
from flask_restplus import Api, Resource, reqparse

app = Flask(__name__)
api = Api(app)
parser = reqparse.RequestParser()
parser.add_argument('name', type=str, help='Your name')

@api.route('/hello')
class HelloWorld(Resource):
    @api.expect(parser)
    def get(self):
        args = parser.parse_args()
        return {'hello': args['name']}

if __name__ == '__main__':
    app.run(debug=True)

In this example, we've added a RequestParser object to our API and defined a new route parameter name using the add_argument method. We've also added the @api.expect decorator to our route method to tell RestPlus to expect the name parameter in the request.

We can now pass a name parameter to our API route by calling http://localhost:5000/hello?name=John. Our response should now say "hello John".

Marshalling Response Data

RestPlus also makes it easy to marshal response data using its built-in response marshalling feature. Let's modify our previous example to return a custom object.

from flask import Flask
from flask_restplus import Api, Resource, fields, marshal_with

app = Flask(__name__)
api = Api(app)
resource_fields = {
    'name': fields.String,
    'age': fields.Integer,
    'location': fields.String,
}

@api.route('/profile')
class Profile(Resource):
    @api.expect(resource_fields)
    @api.marshal_with(resource_fields)
    def post(self):
        profile = {
            'name': 'John',
            'age': 35,
            'location': 'San Francisco',
        }
        return profile

if __name__ == '__main__':
    app.run(debug=True)

In this example, we've defined a new resource field resource_fields that describes the structure of our custom object. We've added the $api.marshal_with decorator to our post method to tell RestPlus to marshal our returned data using the resource_fields definition.

If we call our API using http://localhost:5000/profile, we should see our JSON response marshalled according to the resource_fields definition.

Conclusion

RestPlus is a powerful Python framework that makes it easy to develop RESTful APIs. It provides many useful features out of the box, like request parsing and response marshalling, that can help you quickly develop high-quality APIs. With its intuitive syntax and easy-to-use decorators, RestPlus is quickly becoming a popular choice for developers looking to build APIs with Python.