Dependency Injection

Dependency Injection: Dependency Injection is a design pattern that allows code to be isolated from its dependencies. This means that code doesn’t need to know how to create or manage its dependencies; it just needs to know how to use them. DI is achieved by injecting dependencies into the code at runtime. While this can be done manually, using a DI framework like FastAPI greatly simplifies the process.

1) Benefits of Using Dependencies in FastAPI

1. Isolation of Code:
   • Dependencies enable the isolation of code by passing them to functions and classes, rather than instantiating them directly. This isolation enhances code reusability, maintainability, and testability.
2. Improved Code Readability:
   • Dependencies make code more readable by encapsulating complex logic and clearly specifying the requirements of dependent functions and classes.
3. Reduced Code Duplication:
   • Dependencies minimize code duplication by facilitating the sharing of dependencies among different functions and classes.
4. Facilitated Testing:
   • Dependencies simplify the testing of code by allowing the simulation of dependencies in tests, making it easier to verify the functionality of the code.
5. Integration Flexibility:
   • FastAPI’s built-in support for dependency injection makes it easy to integrate with other frameworks and libraries. This flexibility empowers users to select the best tools for their tasks without being tied to a specific framework or library.

2) Common Uses of Dependencies

Dependencies can serve various purposes, including

1. Sharing connections to databases.
2. Implementing authorization and authentication.
3. Debugging and monitoring.
4. Injecting configuration settings.

3) Dependency Provider

A dependency provider is a function or class responsible for supplying dependencies to other functions or classes. FastAPI supports a built-in dependency provider, but you can also create your own customized dependency providers.

4) Dependency Scope

The scope of a dependency determines how long the dependency will persist. FastAPI supports four different dependency scopes:

• Singleton: Singleton dependencies are used for all requests once created.
• Request: Request dependencies are created once per request and destroyed when the request ends.
• Transient: Transient dependencies are created once per function or class call and destroyed when the function or class returns.
• Path Operation: Path operation dependencies are created once per path operation and destroyed when the path operation ends.

5) When to Use Dependencies

Dependencies should be used when it makes sense to isolate code, improve readability, reduce duplication, facilitate testing, or integrate with other frameworks and libraries. However, it’s essential to use dependencies only when needed, as an excessive number of dependencies can make your code more complex.

6) Types of FastAPI Dependencies

FastAPI supports two types of dependencies:

1. Built-in dependencies
2. Custom dependencies

For using both dependencies we need to install first FastAPI and uvicorn which we can install by using below command

pip install fastapi
pip install uvicorn 

In this article, we will explore FastAPI – Dependencies. FastAPI is a state-of-the-art, high-performance web framework for creating Python-based APIs. It is built on the principles of dependency injection and type hinting, which facilitate the creation of clean, maintainable, and scalable code. This article delves deeper into topics such as Dependency Injection, Dependency Provider, Dependency Scope, and the use of dependencies in FastAPI, all with practical examples. Following this, we will examine the advantages of incorporating dependencies.

FastAPI’s dependency injection approach stands out as one of its pivotal features. Dependencies refer to the components that a class or function requires for its operation. When a function or class is invoked, FastAPI automatically supplies the dependencies as declared in the code.