Python Full Stack Web Developer Course

Practical Exercise: Building a Web API Response Framework

Let's apply what we've learned to build a simple framework for standardizing API responses in a web application. This is a common use case for inheritance and method overriding in real-world web development.

# Exercise: Creating a flexible API response system using inheritance

class ApiResponse:
    """Base class for all API responses"""
    
    def __init__(self, data=None, message=None):
        self.data = data
        self.message = message
        self.status_code = 200  # Default status code
    
    def to_dict(self):
        """Convert the response to a dictionary that can be serialized to JSON"""
        return {
            'status': 'success' if self.is_success() else 'error',
            'message': self.message,
            'data': self.data
        }
    
    def is_success(self):
        """Determine if this response represents a successful operation"""
        return 200 <= self.status_code < 300


class SuccessResponse(ApiResponse):
    """Represents a successful API operation"""
    
    def __init__(self, data=None, message="Operation successful"):
        super().__init__(data, message)
        self.status_code = 200


class CreatedResponse(SuccessResponse):
    """Represents a successful resource creation"""
    
    def __init__(self, data=None, message="Resource created successfully"):
        super().__init__(data, message)
        self.status_code = 201
    
    def to_dict(self):
        """Override to include the resource ID in a standard location"""
        response_dict = super().to_dict()
        if self.data and 'id' in self.data:
            response_dict['resource_id'] = self.data['id']
        return response_dict


class ErrorResponse(ApiResponse):
    """Base class for error responses"""
    
    def __init__(self, message="An error occurred", data=None, error_code=None):
        super().__init__(data, message)
        self.status_code = 400  # Default error status
        self.error_code = error_code
    
    def to_dict(self):
        """Override to include error details"""
        response_dict = super().to_dict()
        if self.error_code:
            response_dict['error_code'] = self.error_code
        return response_dict


class NotFoundResponse(ErrorResponse):
    """Resource not found response"""
    
    def __init__(self, resource_type, resource_id, message=None):
        if not message:
            message = f"{resource_type} with ID {resource_id} was not found"
        super().__init__(message=message, error_code="NOT_FOUND")
        self.status_code = 404


class ValidationErrorResponse(ErrorResponse):
    """Validation error response with field-specific errors"""
    
    def __init__(self, validation_errors, message="Validation failed"):
        super().__init__(message=message, data=validation_errors, error_code="VALIDATION_ERROR")
        self.status_code = 422  # Unprocessable Entity
    
    def to_dict(self):
        """Override to format validation errors in a standard way"""
        response_dict = super().to_dict()
        # Rename 'data' to 'errors' for clarity in validation error responses
        response_dict['errors'] = response_dict.pop('data')
        return response_dict


# Example usage in a web application context

def get_user(user_id):
    """Simulate a user lookup API endpoint"""
    # In a real app, this would query a database
    if user_id == 123:
        return SuccessResponse(data={
            'id': 123,
            'username': 'johndoe',
            'email': 'john@example.com'
        })
    else:
        return NotFoundResponse('User', user_id)


def create_user(user_data):
    """Simulate a user creation API endpoint"""
    # In a real app, this would validate and save to a database
    errors = {}
    
    if not user_data.get('username'):
        errors['username'] = "Username is required"
    
    if not user_data.get('email') or '@' not in user_data.get('email', ''):
        errors['email'] = "Valid email is required"
    
    if errors:
        return ValidationErrorResponse(errors)
    
    # Simulate successful creation with an ID
    return CreatedResponse(data={
        'id': 456,
        'username': user_data.get('username'),
        'email': user_data.get('email')
    })


# Test the API response framework
print("\nGetting existing user:")
response = get_user(123)
print(response.to_dict())

print("\nGetting non-existent user:")
response = get_user(999)
print(response.to_dict())

print("\nCreating user with valid data:")
response = create_user({
    'username': 'janedoe',
    'email': 'jane@example.com'
})
print(response.to_dict())

print("\nCreating user with invalid data:")
response = create_user({
    'username': '',
    'email': 'invalid-email'
})
print(response.to_dict())

Exercise Explanation:

In this exercise, we've created a hierarchy of API response classes:

1. ApiResponse: The base class with common functionality for all responses
2. SuccessResponse and ErrorResponse: Two main categories of responses
3. More specific response types like CreatedResponse, NotFoundResponse, and ValidationErrorResponse that inherit from these categories

Each subclass overrides the to_dict method when necessary to customize the response structure while maintaining a consistent format. This demonstrates how inheritance and method overriding can create a flexible, extensible system that ensures consistency across an application.

In a real-world web application using Flask or Django, these response classes would be integrated with the framework's response mechanisms. For example, in Flask:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/users/')
def get_user_api(user_id):
    response = get_user(user_id)
    return jsonify(response.to_dict()), response.status_code

@app.route('/api/users', methods=['POST'])
def create_user_api():
    user_data = request.json
    response = create_user(user_data)
    return jsonify(response.to_dict()), response.status_code