{"id":2056,"date":"2024-01-23T08:40:03","date_gmt":"2024-01-23T08:40:03","guid":{"rendered":"https:\/\/blog.amt.in\/?p=2056"},"modified":"2024-01-23T08:40:03","modified_gmt":"2024-01-23T08:40:03","slug":"insights-on-fastapi","status":"publish","type":"post","link":"https:\/\/blog.amt.in\/index.php\/2024\/01\/23\/insights-on-fastapi\/","title":{"rendered":"Insights on FastAPI"},"content":{"rendered":"

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints. It was created by Sebasti\u00c3\u00a1n Ram\u00c3\u00adrez and is designed to be easy to use, fast to develop with, and provide automatic validation of request and response data using Python’s type hints.<\/p>\n

Key features of FastAPI include:<\/p>\n

    \n
  1. Fast Execution:<\/strong> It is built on top of Starlette and Pydantic, making use of asynchronous programming for high performance.<\/li>\n
  2. Automatic Documentation:<\/strong> FastAPI automatically generates interactive API documentation using Swagger UI and ReDoc based on the Python type hints provided in your code.<\/li>\n
  3. Type Annotations:<\/strong> FastAPI leverages Python type hints for request and response parameters, enabling automatic validation and generation of OpenAPI (formerly Swagger) documentation.<\/li>\n
  4. Dependency Injection:<\/strong> It supports dependency injection, making it easy to organize and manage dependencies in your application.<\/li>\n
  5. WebSocket Support:<\/strong> FastAPI includes support for WebSocket communication, allowing bidirectional communication between the client and server.<\/li>\n
  6. Security Features:<\/strong> It includes built-in security features, such as OAuth2 and API key authentication, as well as support for dependency injection for managing security requirements.<\/li>\n<\/ol>\n

    Here’s a simple example of a FastAPI application:<\/p>\n

    \n
    python<\/div>\n
    \n

    from<\/span> fastapi import<\/span> FastAPI<\/code><\/p>\n

    app = FastAPI()<\/p>\n

    @app.get(“\/”<\/span><\/span>)<\/span>
    \ndef<\/span> read_root<\/span>():
    \nreturn<\/span> {“Hello”<\/span>: “World”<\/span>}<\/p>\n

    @app.get(“\/items\/{item_id}”<\/span><\/span>)<\/span>
    \ndef<\/span> read_item<\/span>(item_id: int<\/span>, query_param: str<\/span> = None<\/span><\/span>):
    \nreturn<\/span> {“item_id”<\/span>: item_id, “query_param”<\/span>: query_param}<\/p>\n<\/div>\n<\/div>\n

    In this example, the read_root<\/code> function responds to the root endpoint (“\/”) with a JSON response, and the read_item<\/code> function responds to the “\/items\/{item_id}” endpoint with the item_id and an optional query parameter.<\/p>\n

    To run a FastAPI application, you typically use the uvicorn<\/code> ASGI server:<\/p>\n

    \n
    bash<\/div>\n
    uvicorn your_app_name:app --reload
    \n<\/code><\/div>\n<\/div>\n

    Replace your_app_name<\/code> with the actual name of your Python file or module containing the FastAPI app instance.<\/p>\n

    FastAPI has gained popularity for its combination of speed, ease of use, and automatic documentation generation, making it a popular choice for building APIs with Python.<\/p>\n

    Here are some more features and concepts in FastAPI:<\/p>\n

      \n
    1. Data Validation with Pydantic:<\/strong> FastAPI uses Pydantic models for data validation and serialization. By defining data models using Pydantic, you get automatic validation of request and response data based on the declared types.\n
      \n
      python<\/div>\n
      \n

      from<\/span> pydantic import<\/span> BaseModel<\/code><\/p>\n

      class<\/span> Item<\/span>(BaseModel<\/span>):
      \nname: str<\/span>
      \ndescription: str<\/span> = None<\/span>
      \nprice: float<\/span>
      \ntax: float<\/span> = None<\/span><\/p>\n<\/div>\n<\/div>\n<\/li>\n

    2. Path Parameters and Query Parameters:<\/strong> FastAPI supports path parameters, query parameters, and request bodies, allowing you to easily define and handle different types of data in your API.\n
      \n
      python<\/div>\n
      @app.get(\"\/items\/{item_id}\"<\/span><\/span>)<\/span>
      \ndef<\/span> read_item<\/span>(item_id: int<\/span>, query_param: str<\/span> = None<\/span><\/span>):
      \nreturn<\/span> {\"item_id\"<\/span>: item_id, \"query_param\"<\/span>: query_param}
      \n<\/code><\/div>\n<\/div>\n<\/li>\n
    3. Request and Response Objects:<\/strong> FastAPI provides Request<\/code> and Response<\/code> objects that you can use to access information about the incoming request and customize the outgoing response.\n
      \n
      python<\/div>\n
      \n

      from<\/span> fastapi import<\/span> Request<\/code><\/p>\n

      @app.get(“\/headers”<\/span><\/span>)<\/span>
      \ndef<\/span> read_headers<\/span>(request: Request<\/span>):
      \nreturn<\/span> {“headers”<\/span>: request.headers}<\/p>\n<\/div>\n<\/div>\n<\/li>\n

    4. Dependency Injection:<\/strong> FastAPI has a built-in dependency injection system that allows you to organize and manage dependencies in your application. Dependencies can be automatically injected into route functions.\n
      \n
      python<\/div>\n
      \n

      from<\/span> fastapi import<\/span> Depends, HTTPException<\/code><\/p>\n

      def<\/span> get_current_user<\/span>(api_key: str<\/span> = Depends(get_api_key)<\/span>):
      \n# Dependency logic here<\/span>
      \nreturn<\/span> User(api_key)<\/p>\n

      @app.get(“\/users\/me”<\/span><\/span>)<\/span>
      \ndef<\/span> read_current_user<\/span>(current_user: User = Depends(get_current_user)<\/span>):
      \nreturn<\/span> {“username”<\/span>: current_user.username}<\/p>\n<\/div>\n<\/div>\n<\/li>\n

    5. Security and Authentication:<\/strong> FastAPI includes built-in support for OAuth2, API key authentication, and other security features. You can easily add authentication and authorization to your routes.\n
      \n
      python<\/div>\n
      from<\/span> fastapi import<\/span> Depends, HTTPException, status
      \nfrom<\/span> fastapi.security import<\/span> OAuth2PasswordBearer<\/code><\/code>security = OAuth2PasswordBearer(tokenUrl=“token”<\/span>)<\/p>\n

      <\/code><\/code>@app.get(“\/users\/me”<\/span><\/span>)<\/span>
      \ndef<\/span> read_current_user<\/span>(token: str<\/span> = Depends(security)<\/span>):
      \n# Verify token logic here<\/span>
      \nreturn<\/span> {“token”<\/span>: token}<\/p>\n<\/div>\n<\/div>\n<\/li>\n

    6. Middleware Support:<\/strong> FastAPI supports the use of middleware to customize the behavior of your application. You can add middleware functions to handle tasks such as logging, authentication, or other pre-processing.\n
      \n
      python<\/div>\n
      \n

      from<\/span> fastapi.middleware.cors import<\/span> CORSMiddleware<\/code><\/p>\n

      app.add_middleware(
      \nCORSMiddleware,
      \nallow_origins=[“*”<\/span>],
      \nallow_credentials=True<\/span>,
      \nallow_methods=[“*”<\/span>],
      \nallow_headers=[“*”<\/span>],
      \n)<\/p>\n<\/div>\n<\/div>\n<\/li>\n<\/ol>\n

      These are just a few of the many features and capabilities of FastAPI. The framework is designed to be powerful, efficient, and easy to use, making it a great choice for building APIs in Python.<\/p>\n

      Above is the brief about FastAPI. Watch this space more updates on the latest trends in Technology<\/p>\n","protected":false},"excerpt":{"rendered":"

      FastAPI is a modern, fast<\/p>\n","protected":false},"author":1,"featured_media":2058,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[547,1075,153,7],"tags":[548,1076,155,18],"class_list":["post-2056","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-api","category-fastapi","category-python","category-techtrends","tag-api","tag-fastapi","tag-python","tag-technology"],"_links":{"self":[{"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/posts\/2056","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/comments?post=2056"}],"version-history":[{"count":2,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/posts\/2056\/revisions"}],"predecessor-version":[{"id":2059,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/posts\/2056\/revisions\/2059"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/media\/2058"}],"wp:attachment":[{"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/media?parent=2056"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/categories?post=2056"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.amt.in\/index.php\/wp-json\/wp\/v2\/tags?post=2056"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}