Serving Your Personal Tutor with a RESTful API Using FastAPI

Welcome to the next step in our journey of building a personal tutor service with FastAPI . In the previous lesson, we focused on the TutorController, which manages tutoring sessions and handles student queries by interacting with both the model and service layers. Now, we will take a significant step forward by creating a RESTful API for our personal tutor service using FastAPI. We'll start by setting up the main FastAPI application, then adapt the TutorController to integrate with FastAPI's session management.

Understanding RESTful APIs and FastAPI

RESTful APIs are a way for different software systems to communicate over the internet. They provide a set of rules that allow programs to exchange data. FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.7+ based on standard Python type hints. It is designed to be easy to use and to provide automatic interactive API documentation. To get started with FastAPI, you can install it using pip by running the following command in your terminal or command prompt: Shell pip install fastapi Additionally, to run the FastAPI application, you'll need to install Uvicorn, an ASGI server: Shell pip install uvicorn Now, we can use FastAPI to connect the components we've already built, allowing students to interact with our personal tutor service through a web interface. This will enable seamless communication between students and our tutoring service.

Initializing a FastAPI App

First, we need to initialize the FastAPI application: Python from fastapi import FastAPI # Initialize FastAPI app app = FastAPI(title="Personal Tutor API") Here, we import the FastAPI module and instantiate the FastAPI class to create our application object, app . We also give it a title, "Personal Tutor API," which will be displayed in the automatic API documentation that FastAPI generates. This object will be used to configure and run our web application.

Adding Session Management with Starlette Middleware

FastAPI does not have built-in session management, but it's built on top of Starlette, which provides session handling capabilities. When you install FastAPI, Starlette comes bundled with it, giving you access to its middleware components. A middleware is a function that works with every request before it's processed by any specific route handler. It sits between the server receiving the request and your route functions, allowing you to modify requests or responses globally. We can add Starlette's SessionMiddleware to our FastAPI application to enable session management: Python from starlette.middleware.sessions import SessionMiddleware # Add session middleware app.add_middleware(SessionMiddleware, secret_key="your_secret_key_here") The SessionMiddleware handles creating, reading, and updating session data stored in cookies. The secret_key parameter is crucial for securing session data, as it's used to sign the session cookies to prevent tampering.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Adapting the TutorController

The TutorController has been designed to work seamlessly with FastAPI, handling student IDs and session management effectively. Let's examine its key methods and how they integrate with our API.

Python

class TutorController:
    def __init__(self):
        self.tutor_service = TutorService()
    
    def create_session(self, student_id):
        if not student_id:
            return self._error_response('Session expired', 401)
        
        session_id = self.tutor_service.create_session(student_id)
        
        return self._success_response({
            'session_id': session_id,
            'message': 'Tutoring session created successfully'
        })

class TutorController:
    def __init__(self):
        self.tutor_service = TutorService()
    
    def create_session(self, student_id):
        if not student_id:
            return self._error_response('Session expired', 401)
        
        session_id = self.tutor_service.create_session(student_id)
        
        return self._success_response({
            'session_id': session_id,
            'message': 'Tutoring session created successfully'
        })

The create_session method accepts a student_id parameter from FastAPI's session management. It checks if the student ID is valid, creates a new tutoring session using the TutorService, and returns a success response with the session ID.

Python

    def send_query(self, student_id, session_id, student_query):
        if not student_id:
            return self._error_response('Session expired', 401)
        
        if not session_id or not student_query:
            return self._error_response('Missing session_id or query', 400)
            
        try:
            tutor_response = self.tutor_service.process_query(
                student_id, 
                session_id, 
                student_query
            )
            return self._success_response({'message': tutor_response})
            
        except ValueError as e:
            return self._error_response(str(e), 404)
        except RuntimeError as e:
            return self._error_response(str(e), 500)

    def send_query(self, student_id, session_id, student_query):
        if not student_id:
            return self._error_response('Session expired', 401)
        
        if not session_id or not student_query:
            return self._error_response('Missing session_id or query', 400)
            
        try:
            tutor_response = self.tutor_service.process_query(
                student_id, 
                session_id, 
                student_query
            )
            return self._success_response({'message': tutor_response})
            
        except ValueError as e:
            return self._error_response(str(e), 404)
        except RuntimeError as e:
            return self._error_response(str(e), 500)

The send_query method is responsible for processing student queries. It receives the student ID, session ID, and the query content. After validating these parameters, it calls the process_query method on the TutorService to generate a response. The method includes comprehensive error handling, returning appropriate error responses for various scenarios.

Python

    def _success_response(self, data):
        response = {
            'status': 'success',
            'data': data
        }
        return response
    
    def _error_response(self, message, status_code):
        response = {
            'status': 'error',
            'error': {
                'message': message,
                'code': status_code
            }
        }
        return response, status_code

    def _success_response(self, data):
        response = {
            'status': 'success',
            'data': data
        }
        return response
    
    def _error_response(self, message, status_code):
        response = {
            'status': 'error',
            'error': {
                'message': message,
                'code': status_code
            }
        }
        return response, status_code

The controller also includes helper methods for generating consistent success and error responses. The _success_response method wraps data in a standard structure, while the _error_response method creates a tuple containing the error details and the appropriate HTTP status code. This consistent response format makes it easier for our FastAPI routes to handle the controller's output.