PRODUCT COMPARISONS

FastAPI Python (How It Works For Developers)

Published September 29, 2024

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 IronSoftware.

Key Features of FastAPI

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.
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.
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.
Editor Support: Excellent support for code completion and type checking in editors like VS Code, making development faster and reducing errors.
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]"

pip install fastapi
pip install "uvicorn[standard]"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'pip install fastapi pip install "uvicorn[standard]"

VB C#

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}

from fastapi import FastAPI app = FastAPI() app.get("/") def read_root(): Return
If True Then
	"Hello": "World"
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@app.@get("/items/{item_id}") # @with query parameters def read_item(item_id: int, q: str = None): Return
'{
''INSTANT VB TODO TASK: The following line uses invalid syntax:
''	"item_id": item_id, "q": q}

VB C#

To run the application, use Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'uvicorn main:app --reload

VB C#

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:

Dependency Injection: FastAPI provides a powerful dependency injection system that allows you to manage dependencies cleanly and efficiently.
Background Tasks: You can define background tasks to be run after returning a response, useful for tasks like sending emails or processing data.
WebSockets: FastAPI supports WebSockets, enabling real-time communication between the client and server.
Security: FastAPI includes tools for handling security, including OAuth2, JWT tokens, and more.
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.

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

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'from pydantic import BaseModel class Item(BaseModel): name: str description: str = None price: float tax: float = None

VB C#

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"}

404, detail="Item not found"
status_code=404, detail
404, detail="Item not found"
status_code=404, detail
404, detail="Item not found"
status_code=404, detail
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: 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
item Return item app.get("/items/{item_id}") # [optional] str query parameter def read_item(item_id:= Integer): if item_id [not] in items: raise HTTPException(status_code) Return items(item_id) app.put("/items/{item_id}") # [with] path parameters def update_item(item_id: Integer, item: Item): if item_id [not] in items: raise HTTPException(status_code) items(item_id) = item Return item app.delete("/items/{item_id}") def delete_item(item_id: Integer): if item_id [not] in items: raise HTTPException(status_code) del items(item_id) Return
If True Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: 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) 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) items[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:= Integer): if item_id [not] in items: raise HTTPException(status_code) Return items(item_id) app.put("/items/{item_id}") # [with] path parameters def update_item(item_id: Integer, item: Item): if item_id [not] in items: raise HTTPException(status_code) items(item_id)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI, HTTPException app = FastAPI() items = {} @app.post("/items/") def create_item(item: Item): item_id = len(items) + 1 items[item_id]
{} app.post("/items/") def create_item(item:= Item): item_id = len(items) + 1 items(item_id)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI, HTTPException app = FastAPI() items = {} @app.post("/items/") def create_item(item: Item): item_id
FastAPI() items = {} app.post("/items/") def create_item(item:= Item): item_id
from fastapi import FastAPI, HTTPException app = FastAPI() items
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'	"message": "Item deleted"}

VB C#

Introducing IronPDF

FastAPI Python (How It Works For Developers): Figure 1

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

pip install fastapi
pip install ironPDF

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'pip install fastapi pip install ironPDF

VB C#

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

#Apply your license key
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI from fastapi.responses import FileResponse from ironpdf import * License.LicenseKey = "key" app = FastAPI() @app.get("/") def read_root(): return
"key" app = FastAPI() app.get("/") def read_root(): Return
If True Then
From fastapi import FastAPI From fastapi.responses import FileResponse From ironpdf import * License.LicenseKey = "key" app
	"Hello": "IronPDF"
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@app.@get("/items/{item_id}") # @with query parameters def read_item(item_id: int, q: str = None): Return
'{
'	"item_id": item_id, "q": q
'}
#Create a PDF from a HTML string using Python
	#Export to a file or Stream
	#To view the file in the browser, use "inline" for the media_type
	#Create a FileResponse object with the file path, media type and headers
	#Return the FileResponse object
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'@app.@get("/pdf") async def get_pdf(greet1: str = None,greet2: str = None): renderer = ChromePdfRenderer() 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) pdf.SaveAs("fastapi.pdf") headers = { "Content-Disposition": "inline; filename=sample.pdf" } response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers) Return response

VB C#

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.

Setting License Key: Applies the IronPDF license key to enable its features.
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.
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

FastAPI Python (How It Works For Developers): Figure 2

PDF

FastAPI Python (How It Works For Developers): Figure 3

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"

IRON VB CONVERTER ERROR developers@ironsoftware.com

VB C#

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.

NEXT >
A Comparison Between IronPDF For Python & PDFium Python