FastAPI-Framework

A robust FastAPI construct: emphasizing maximal performance, minimal learning curve, rapid feature realization, and production readiness.

Official Reference Material: https://fastapi.tiangolo.com

Source Repository: https://github.com/tiangolo/fastapi

FastAPI is a contemporary, extremely swift (high-performance), web development scaffolding for constructing APIs utilizing Python 3.6+ features, grounded in native Python type hints.

The core benefits encompass:

• Velocity: Exceptional operational speed, achieving parity with platforms such as NodeJS and Go (achieved via Starlette and Pydantic integrations). Among the fastest Python scaffolds available.
• Development Pace: Accelerates feature realization by a factor of 200% to 300%. *
• Defect Reduction: Leads to an approximate 40% decrease in developer-introduced logical errors. *
• User Experience: Superior integration with development environments. Intelligent code completion across the board. Minimizes time spent debugging.
• Simplicity: Engineered for ease of adoption and utilization. Decreases time spent consulting documentation.
• Conciseness: Substantially reduces boilerplate code. Multiple functionalities derived from singular parameter definitions. Fewer potential bugs.
• Reliability: Produces code suitable for demanding production environments. Features built-in, interactive API specification generation.
• Standard Compliance: Built upon (and fully interoperable with) established open protocols for APIs: OpenAPI (formerly Swagger) and JSON Schema.

* Quantifications derived from internal development team testing on production-grade software artifacts.

Key Supporters

View additional patrons

Endorsements

"[...] I am utilizing FastAPI extensively in current projects. [...] I intend to deploy it across all our team's ML provisioning units at Microsoft. Some of these are being integrated into the core Windows OS stack and select Office suites."

"We integrated the FastAPI library to initiate a REST server capable of furnishing inference results. [For Ludwig]"

"Netflix is delighted to announce the open-source release of our operational continuity orchestration mechanism: Dispatch! [Developed using FastAPI]_"

"I am incredibly enthusiastic about FastAPI. It is genuinely enjoyable to use!"

"Frankly, the artifact you've constructed appears exceedingly stable and polished. In numerous respects, it embodies what I envisioned for Hug—it's truly inspirational to observe such an implementation."

"If you seek to master a single modern scaffold for building RESTful interfaces, investigate FastAPI [...] It boasts speed, is straightforward to employ, and simple to grasp [...]"

"We have transitioned to using FastAPI for our API endpoints [...] We believe you will find merit in it [...]"

Typer: The CLI Counterpart to FastAPI

Should your objective be the creation of a CLI application intended for terminal interaction rather than a web endpoint, examine Typer.

Typer functions as FastAPI's companion utility, explicitly designed to be the FastAPI of CLIs. ⌨️ 🚀

Prerequisites

Runtime environment Python 3.6 or later is mandatory.

FastAPI leverages foundational components from established projects:

• Starlette for handling the asynchronous web server operations.
• Pydantic for rigorous data structure definition and validation.

Deployment

You also require an ASGI-compliant server, suitable for production environments, such as Uvicorn or Hypercorn.

Illustrative Implementation

Script Formulation

• Establish a file named main.py containing the subsequent code:

Python from typing import Optional

from fastapi import FastAPI

app = FastAPI()

@app.get("/") def read_root(): return {"Hello": "World"}

@app.get("/items/{item_id}") def read_item(item_id: int, q: Optional[str] = None): return {"item_id": item_id, "q": q}

Execution

Launch the server using the command:

Endpoint Verification

Access the URL http://127.0.0.1:8000/items/5?q=somequery in a web client.

The resulting JSON payload will be:

JSON {"item_id": 5, "q": "somequery"}

You have successfully established an accessible service that:

• Accepts HTTP requests targeting the network locations / and /items/{item_id}.
• Both locations respond to GET operations (HTTP methods).
• The /items/{item_id} location mandates an int path parameter named item_id.
• The /items/{item_id} location permits an optional string query parameter designated q.

Automated Interactive Documentation (Swagger UI)

Navigate to http://127.0.0.1:8000/docs.

This displays the automatically generated, interactive API specification interface (powered by Swagger UI):

Alternative Interactive Documentation (ReDoc)

Alternatively, visit http://127.0.0.1:8000/redoc.

This presents the secondary, automatically generated documentation scheme (powered by ReDoc):

Schema Extension Example

Now, update the file main.py to accept data payloads via a PUT interaction.

Define the incoming body structure using standard Python type declarations, leveraging Pydantic's capabilities.

Python hl_lines="4 9-12 25-27" from typing import Optional

from fastapi import FastAPI from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel): name: str price: float is_offer: Optional[bool] = None

@app.get("/") def read_root(): return {"Hello": "World"}

@app.get("/items/{item_id}") def read_item(item_id: int, q: Optional[str] = None): return {"item_id": item_id, "q": q}

@app.put("/items/{item_id}") def update_item(item_id: int, item: Item): return {"item_name": item.name, "item_id": item_id}

The running server should automatically refresh (due to the --reload flag used previously with uvicorn).

Updated Interactive Documentation (Swagger UI)

Revisit http://127.0.0.1:8000/docs.

• The interactive specification is dynamically augmented, now detailing the requisite request body structure:

• Clicking the "Try it out" toggle enables interactive parameter input and direct API testing via the interface:

• Executing the operation via the "Execute" button directs the interface to transmit parameters to your service, process the returned data, and display the results on screen:

Updated Alternative Documentation (ReDoc)

Access http://127.0.0.1:8000/redoc.

• This alternative specification view also reflects the new path parameter requirements and the incoming data structure:

Summary of Mechanics

In essence, you define the expected types for parameters, request bodies, etc., strictly as function signature arguments.

This declaration relies solely on native, modern Python type annotations.

You are absolved from mastering proprietary syntax or specialized library classes.

It is purely standard Python 3.6+ in operation.

For instance, specifying an integer type:

Python item_id: int

Or for a more intricate structure like the Item entity:

Python item: Item

...This singular definition yields a suite of automated capabilities:

• Development environment assistance, including:
  • Code completion hints.
  • Static type validation checks.
• Comprehensive data integrity checks:
  • Automated, unambiguous error reporting for malformed input.
  • Validation robustness extends to deeply nested JSON payloads.
• Input Data Transformation (Serialization/Parsing): Converting data received over the network into native Python types, sourced from:
  • JSON bodies.
  • Path segments.
  • URL query strings.
  • HTTP Cookies.
  • Request Headers.
  • Form submissions.
  • Uploaded Files.
• Output Data Transformation (Serialization/Parsing): Converting internal Python structures back into network-transmissible formats (typically JSON):
  • Native Python types (str, int, float, bool, list, etc.).
  • datetime objects.
  • UUID objects.
  • ORM models from databases.
  • ...and numerous other types.
• Instantaneous generation of interactive API documentation, offering two distinct user interface formats:
  • Swagger UI.
  • ReDoc.

Returning to the preceding code demonstration, FastAPI automatically manages the following:

• For GET and PUT requests, it confirms the presence of the item_id in the URL path.
• For GET and PUT requests, it validates that item_id conforms to the int type.
  • Should this validation fail, the requesting client receives an informative, clear error message.
• For GET requests, it inspects for an optional query parameter named q (e.g., accessed via http://127.0.0.1:8000/items/foo?q=somequery).
  • Since q is initialized with = None, it is deemed optional.
  • Omitting = None would enforce its presence (analogous to the mandatory body requirement in the PUT example).
• For PUT requests destined for /items/{item_id}, it processes the request body as JSON:
  • Verifies the existence of a mandatory attribute name expected to be a str.
  • Verifies the existence of a mandatory attribute price expected to be a float.
  • Verifies the optional presence of an attribute is_offer, expected to be a bool if provided.
  • This validation mechanism functions seamlessly even for complex, nested JSON object hierarchies.
• Handles the bidirectional conversion between JSON and internal Python representations automatically.
• Generates complete OpenAPI specification metadata, which can be consumed by:
  • Interactive visualization tools.
  • Systems designed for automatic client SDK generation across diverse programming languages.
• Provides two fully functional interactive documentation portals out-of-the-box.

We have merely touched upon the foundational capabilities, but the core operational paradigm should be clear. Try altering the return statement:

Python return {"item_name": item.name, "item_id": item_id}

...by modifying the output from:

Python ... "item_name": item.name ...

...to:

Python ... "item_price": item.price ...

...and observe how your IDE's code-completion feature accurately anticipates attribute names and their associated data types:

For a more comprehensive exploration of advanced capabilities, consult the Tutorial / User Guide.

Preview of Further Topics: the tutorial covers:

• Defining parameters originating from varied sources: headers, cookies, form fields, and file uploads.
• Implementing validation constraints like string length limits or regular expression matching.
• A highly capable and easily managed Dependency Resolution mechanism.
• Security and authorization implementations, including support for OAuth2 utilizing JWT tokens and HTTP Basic authentication schemes.
• More sophisticated (yet equally accessible) methods for defining deeply nested JSON structures (facilitated by Pydantic).
• GraphQL integration solutions, notably with Strawberry and other complementary libraries.
• Numerous supplementary functionalities (inherited from Starlette), such as:
  • WebSockets support.
  • Extremely streamlined testing procedures leveraging requests and pytest.
  • Cross-Origin Resource Sharing (CORS) handling.
  • Cookie Session management.
  • ...and additional features.

Performance Metrics

Independent performance analyses conducted by TechEmpower consistently rank FastAPI applications, when served via Uvicorn, as among the fastest Python frameworks available. To gain deeper insight into these results, refer to the Benchmarks section. (*)

Optional Dependencies

Required by Pydantic:

• ujson - For accelerated JSON data deserialization.
• email_validator - For validating electronic mail address formats.

Required by Starlette:

• requests - Necessary for utilizing the TestClient utility.
• jinja2 - Needed if employing the default configuration for template rendering.
• python-multipart - Essential for processing form submissions via request.form().
• itsdangerous - Required for supporting SessionMiddleware functionality.
• pyyaml - Needed for Starlette's SchemaGenerator functionality (generally superfluous when using FastAPI).
• ujson - Required for utilizing UJSONResponse.

Required by FastAPI / Starlette Infrastructure:

• uvicorn - The server engine responsible for loading and dispatching application requests.
• orjson - Necessary if ORJSONResponse is selected for response handling.

You can provision all these optional packages via pip install "fastapi[all]".

Licensing Terms

This software artifact is released under the stipulations of the MIT license.

--- WIKIPEDIA CONTEXT ---

WIKIPEDIA: XMLHttpRequest (XHR) represents an Application Programming Interface structured as a JavaScript entity whose member functions facilitate the transmission of HTTP inquiries from a web browser environment to a backend web server. These functions permit browser-resident applications to dispatch queries to the server subsequent to initial page load completion, and subsequently receive resultant data. XMLHttpRequest is a foundational element of Ajax programming methodologies. Before the advent of Ajax, the primary means of server interaction involved hyperlink navigation and form submissions, actions that often necessitated a complete replacement of the currently viewed page.

== Chronology == The conceptual basis for XMLHttpRequest was formulated in the year 2000 by the software engineers developing Microsoft Outlook. This concept was then actualized within the Internet Explorer 5 browser release (1999). Nevertheless, the initial syntax did not employ the canonical XMLHttpRequest identifier. Instead, developers relied on instantiating objects via ActiveXObject("Msxml2.XMLHTTP") or ActiveXObject("Microsoft.XMLHTTP"). As of Internet Explorer 7 (2006), standardized cross-browser support for the XMLHttpRequest identifier became universal. The XMLHttpRequest identifier has since established itself as the predominant standard across all major browser engines, including Mozilla's Gecko rendering platform (2002), Safari version 1.2 (2004), and Opera version 8.0 (2005).

=== Formalization === The World Wide Web Consortium (W3C) formally issued a Working Draft specification detailing the XMLHttpRequest object on April 5, 2006. On February 25, 2008, the W3C published the Level 2 specification iteration. Level 2 extended capabilities to include mechanisms for tracking request progress events, enabling cross-site data fetching, and managing binary byte streams. By the conclusion of 2011, the Level 2 document was integrated back into the primary specification document. At the close of 2012, stewardship of the development process transferred to the WHATWG, which now maintains a continuous, evolving document utilizing Web IDL definitions.

== Operational Steps == Generally, dispatching a request using XMLHttpRequest necessitates adherence to several sequential programming actions.

1. Instantiate an XMLHttpRequest object by invoking its constructor:
2. Invoke the "open" method to delineate the request method (type), pinpoint the target resource Uniform Resource Identifier, and choose between synchronous or asynchronous execution mode:
3. For asynchronous requests, establish an event listener function that will be notified upon state transitions of the request:
4. Commence the data transmission sequence by calling the "send" method, optionally carrying payload data:
5. Monitor and react to state changes within the designated event listener. If the server returns response material, it is, by default, housed within the "responseText" attribute. When the object finalizes response processing, its state transitions to 4, the terminal "done" state. Aside from these fundamental actions, XMLHttpRequest provides extensive configuration options governing request transmission behavior and response interpretation. Custom header fields can be appended to outbound requests to inform the server of specific processing expectations, and data can be transmitted to the server as part of the "send" invocation. The received response can be programmatically converted from raw text (including JSON format) into readily manipulable JavaScript objects, or it can be processed incrementally as data arrives, circumventing the need to await the complete payload. The request can be halted prematurely or configured to fail if processing time exceeds a specified duration.

== Cross-domain Interactions ==

In the nascent phase of the World Wide Web's evolution, it was recognized that allowing requests across domain boundaries could potentially lead to security vulnerabilities, thereby restricting XHR interactions initially.