Skip to main content

Eve Overview

Eve is a powerful and flexible web framework for building RESTful APIs.

It is designed to simplify the process of creating, deploying, and managing web applications. With its intuitive and expressive syntax, Eve allows developers to focus on writing business logic instead of boilerplate code.

In this tutorial, we will explore the history, features, and examples of the Eve web framework.

History​

Eve was created by Nicola Iarocci in 2013. It was inspired by the Flask microframework and the Django REST framework. Since its inception, Eve has gained popularity among developers for its simplicity and scalability.

Features​

Eve provides several features that make it an excellent choice for developing web applications. Let's take a closer look at some of its key features:

1. Data Modeling​

Eve allows developers to define data models using a simple domain-specific language (DSL). This DSL is inspired by MongoDB's query language and makes it easy to define the structure and relationships of your data.

Here's an example of defining a data model in Eve:

from eve import Eve

app = Eve()

app.config['DOMAIN'] = {
    'people': {
        'schema': {
            'name': {
                'type': 'string',
                'required': True
            },
            'age': {
                'type': 'integer'
            }
        }
    }
}

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

In this example, we define a people collection with two fields: name (required string) and age (integer).

2. RESTful API Generation​

Eve automatically generates a RESTful API based on the data models you define. This API supports standard CRUD operations (Create, Read, Update, Delete) and provides endpoints for querying and filtering data.

For example, with the data model defined above, Eve automatically generates the following API endpoints:

  • GET /people: Retrieve all people
  • POST /people: Create a new person
  • GET /people/{person_id}: Retrieve a specific person
  • PUT /people/{person_id}: Update a specific person
  • DELETE /people/{person_id}: Delete a specific person

3. Authentication and Authorization​

Eve provides built-in support for authentication and authorization. You can easily configure authentication mechanisms such as basic authentication or token-based authentication.

Here's an example of enabling basic authentication in Eve:

from eve import Eve
from eve.auth import BasicAuth

class MyBasicAuth(BasicAuth):
    def check_auth(self, username, password, allowed_roles, resource, method):
        # Implement your authentication logic here
        return username == 'admin' and password == 'password'

app = Eve(auth=MyBasicAuth)

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

In this example, we define a custom authentication class MyBasicAuth that checks if the username is admin and the password is password. You can customize this logic to suit your application's requirements.

4. Validation and Data Transformation​

Eve provides powerful validation and data transformation capabilities. You can define validation rules for each field in your data models, such as data type, required fields, and custom validation functions.

Here's an example of defining validation rules in Eve:

from eve import Eve

app = Eve()

app.config['DOMAIN'] = {
    'people': {
        'schema': {
            'name': {
                'type': 'string',
                'required': True
            },
            'age': {
                'type': 'integer',
                'min': 18,
                'max': 100
            }
        }
    }
}

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

In this example, we define that the age field should be an integer between 18 and 100.

5. Extension Support​

Eve supports extensions that provide additional functionality. There are several community-developed extensions available, including support for pagination, filtering, and caching.

You can easily integrate these extensions into your Eve application to enhance its capabilities.

Examples​

Let's explore some examples to understand how to use Eve in practice.

Example 1: Creating a Simple API​

from eve import Eve

app = Eve()

app.config['DOMAIN'] = {
    'people': {
        'schema': {
            'name': {
                'type': 'string',
                'required': True
            },
            'age': {
                'type': 'integer'
            }
        }
    }
}

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

In this example, we create a simple API with a people collection that has two fields: name and age. When you run this code and make a GET request to http://localhost:5000/people, you will receive an empty JSON response.

Example 2: Authenticating Requests​

from eve import Eve
from eve.auth import BasicAuth

class MyBasicAuth(BasicAuth):
    def check_auth(self, username, password, allowed_roles, resource, method):
        return username == 'admin' and password == 'password'

app = Eve(auth=MyBasicAuth)

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

In this example, we enable basic authentication using a custom authentication class MyBasicAuth. Only requests with the username admin and password password will be authenticated.

Example 3: Validation and Data Transformation​

from eve import Eve

app = Eve()

app.config['DOMAIN'] = {
    'people': {
        'schema': {
            'name': {
                'type': 'string',
                'required': True
            },
            'age': {
                'type': 'integer',
                'min': 18,
                'max': 100
            }
        }
    }
}

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

In this example, we define validation rules for the age field. It should be an integer between 18 and 100. If you try to create or update a person with an invalid age, Eve will return a validation error.

To learn more about Eve, visit the official website: https://docs.python-eve.org/