FastAPI Python (How It Works For Developers)

Introduction

FastAPIis a modern, high-performance web framework for building APIs with Python. It is designed to be easy to use and learn while providing powerful features like automatic validation, serialization, and automatic interactive API documentation. Additionally, it works with any template engine and allows you to use any default template configuration needed for your project.

Let’s dive into the details of FastAPI, its features, and how to use it effectively. Later in this article, we will also look into IronPDF a PDF generation Python package from Iron Software.

Key Features of FastAPI

1. High Performance: FastAPI is one of the fastest Python frameworks available, comparable to Node.js and Go, thanks to its use of Starlette for the web parts and Pydantic for the data parts.
2. Ease of Use: It is designed to be intuitive and reduce the time spent reading documentation. The framework leverages standard Python-type hints for data validation and serialization.
3. Automatic Interactive Documentation: FastAPI automatically generates interactive API documentation using OpenAPI and JSON Schema, accessible via /docs (Swagger UI) and /redoc (ReDoc) and interactive API docs upgrade means that this documentation updates automatically. The alternative API docs upgrade will also reflect this.
4. Editor Support: Excellent support for code completion and type checking in editors like VS Code, making development faster and reducing errors.
5. Standards-Based: It is based on (and fully compatible with) the open standards for APIs: OpenAPI and JSON Schema.

Installation

You can install FastAPI and Uvicorn (an ASGI server) using pip:

pip install fastapi
pip install "uvicorn[standard]"

Creating Your First FastAPI Application

Here’s a simple example to get you started with FastAPI and expose Python data through a user interface:

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "World"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "World"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

To run the application, use Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

This command will start a development server and automatically reload for code changes. You can access the interactive API documentation at http://127.0.0.1:8000/docs.

Advanced Features

FastAPI supports a wide range of advanced features, making it suitable for complex applications:

1. Dependency Injection: FastAPI provides a powerful dependency injection system that allows you to manage dependencies cleanly and efficiently.
2. Background Tasks: You can define background tasks to be run after returning a response, useful for tasks like sending emails or processing data.
3. WebSockets: FastAPI supports WebSockets, enabling real-time communication between the client and server.
4. Security: FastAPI includes tools for handling security, including OAuth2, JWT tokens, and more.
5. Database Integration: FastAPI can be easily integrated with databases using libraries like SQLAlchemy or Tortoise-ORM.

Example: Building a CRUD API

Let’s build a simple CRUD (Create, Read, Update, Delete) API for managing items.

1. Define the Data Model:

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

1. Create the FastAPI Application:

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

Introducing IronPDF

IronPDF is a powerful Python library designed for creating, editing, and signing PDFs from HTML, CSS, images, and JavaScript. It offers commercial-grade performance with a low memory footprint. Key features include:

HTML to PDF Conversion

Convert HTML files, HTML strings, and URLs to PDFs. For example, render a webpage as a PDF using the Chrome PDF renderer.

Cross-Platform Support

Compatible with various .NET platforms, including .NET Core, .NET Standard, and .NET Framework. It supports Windows, Linux, and macOS.

Editing and Signing

Set properties, add security with passwords and permissions, and apply digital signatures to your PDFs.

Page Templates and Settings

Customize PDFs with headers, footers, page numbers, and adjustable margins. Supports responsive layouts and custom paper sizes.

Standards Compliance

Adheres to PDF standards such as PDF/A and PDF/UA. Supports UTF-8 character encoding and handles assets like images, CSS, and fonts.

Generate PDF Documents using IronPDF and FastAPI

pip install fastapi
pip install ironPDF

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

Code Explanation

This code snippet demonstrates the integration of IronPDF with FastAPI to dynamically generate PDF documents based on user inputs and serve them as a downloadable response.

1. Setting License Key: Applies the IronPDF license key to enable its features.

2. FastAPI Initialization: Initializes a FastAPI instance (`app`) to handle HTTP requests.3. Basic Route Handlers: `read_root()`: Responds with a simple JSON message indicating "Hello IronPDF" when accessing the root URL (`/`). `read_item()`: Accepts an `item_id` path parameter and an optional `q` query parameter. Returns a JSON response with these function parameters.

3. PDF Generation Route (`/pdf`): `get_pdf()`:

• This async function handles GET requests to `/pdf` endpoint with optional query parameter named (`greet1` and `greet2`).
• Constructs an HTML string (`content`) that includes: A header indicating the document's origin and purpose. A paragraph demonstrating PDF generation using user inputs (`greet1` and `greet2`). Uses `ChromePdfRenderer()` from IronPDF to render the HTML content into a PDF (`pdf = renderer.RenderHtmlAsPdf(content)`).
• Saves the generated PDF as "fastapi.pdf" (`pdf.SaveAs("fastapi.pdf")`).5. Serving the PDF:
• Configures response headers to specify that the PDF should be viewed inline in the browser (`"Content-Disposition": "inline; filename=sample.pdf"`).
• Creates a `FileResponse` object pointing to the generated PDF file with the appropriate media type (`"application/pdf"`).
• Returns the `FileResponse` object, which triggers the download of the PDF document when the `/pdf` endpoint is accessed.

This code snippet illustrates how IronPDF can be seamlessly integrated with FastAPI to dynamically generate and serve PDF documents based on user inputs. It showcases the ability to convert HTML content into PDFs, making it suitable for applications requiring on-the-fly document generation and delivery over HTTP.

Output

Below shows the swagger output generated from the APIs

PDF

IronPDF License

IronPDF runs on the license key for python. IronPDF for Python offers a free trial license key to allow users to check out features before purchase.

Place the License Key at the start of the script before using the IronPDF package:

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

Conclusion

FastAPI is a powerful and easy-to-use framework for building APIs in Python. FastAPI has high performance, automatic documentation, and advanced features make it an excellent choice for both beginners and experienced developers. Whether you’re building a simple API or a complex web application, FastAPI provides the tools you need to succeed.

IronPDF is a robust Python library for creating, manipulating, and rendering PDF documents from HTML content. It offers features like HTML to PDF conversion, interactive form creation, PDF manipulation (merging, splitting), and text extraction. Ideal for generating dynamic PDFs with ease and integrating into various Python applications.