it's possible to do dependency injection in Fastapi using abstract class? - dependency-injection

Question

I'm coming from asp.net core and I use DependencyInjection to implement inversion of control in my applications. I would like to know if there is any way to provide fastapi with a list of abstractclass-class dependency equivalences so that when some part of my code requires a dependency, it injects by constructor through the abstract class. (similar to how it is done in dot net core)
for more clarity in my question I attach a code snippet (not functional, for explaining purposes only ) of what I want to know if it is possible to do in fastapi:
## abstract class of repository for product
class ABCProductRepository(ABC):
#abstractmethod
def createProduct(self, productData: str):
# class that "implements" ABCProductRepository
class ProductRepository(ABCProductRepository):
def createProduct(self, productData: str):
print(f"I'm creating a new product: {productData}")
# Class provided with a UserRepository instance via dependency injection.
class ProductService():
def __init__(self, productRepo: AbstractUserRepository):
self.pRepo = productRepo:
self.pRepo.createProduct("usb cable")
# Fastapi section
app = FastAPI()
# configuration of dependencies
def config_dependencies(app):
app.imaginary_method_to_add_dependencies(
dependency = ABCProductRepository,
provider = ProductRepository,
other_imaginary_configs = ...
)
configure_dependencies(app)
# routes section
#app.post("/products")
def save_product(product: string):
ProductService()
I don't know if this can be done with Fastapi as it is done in asp net, or if a different independence injection library is required than the one fastapi provides.

Answer 1

The dependency injection technique can be accomplished with FastAPI using the Depends class.
Here's an example of what FastAPI can offer.
Repository:
Start building the repository by combining python's ABC class with a product repo, and assuming the scope is to CRUD a product, then pydantic can help us represent the model using the BaseModel
from abc import ABC, abstractmethod
from fastapi import FastAPI, Depends
from pydantic import BaseModel
class ProductModel(BaseModel):
"""
Pydantic model for request/response
"""
title: str
class ProductRepositoryABC(ABC):
"""
Abstract base product repository
"""
#abstractmethod
def create_product(self, product: ProductModel) -> ProductModel:
raise NotImplementedError
class ProductRepository(ProductRepositoryABC):
"""
Product repository
"""
def create_product(self, product: ProductModel) -> ProductModel:
print(f"I'm creating a new product: {product}")
return product
Service:
After creating the model and the repository, we can start creating a service by injecting the repo as a dependency.
class ProductService(object):
"""
Product service
"""
def __init__(self, product_repo: ProductRepositoryABC = Depends(ProductRepository)):
self.product_repo = product_repo
def create_product(self, product: ProductModel) -> ProductModel:
return self.product_repo.create_product(product=product)
Views/Routes:
Injecting a service into the route function is one step ahead; pass the service to the function as a param and use Depends to inject the service, which will be accessible in the function scope.
app = FastAPI()
#app.post(
"/products",
name="products:create",
response_model=ProductModel
)
def create_product(
product: ProductModel,
product_srv: ProductService = Depends(ProductService)
) -> ProductModel:
return product_srv.create_product(product=product)
Complete code:
main.py
from abc import ABC, abstractmethod
from fastapi import FastAPI, Depends
from pydantic import BaseModel
class ProductModel(BaseModel):
"""
Pydantic model for request/response
"""
title: str
class ProductRepositoryABC(ABC):
"""
Abstract base product repository
"""
#abstractmethod
def create_product(self, product: ProductModel) -> ProductModel:
raise NotImplementedError
class ProductRepository(ProductRepositoryABC):
"""
Product repository
"""
def create_product(self, product: ProductModel) -> ProductModel:
print(f"I'm creating a new product: {product}")
return product
class ProductService(object):
"""
Product service
"""
def __init__(self, product_repo: ProductRepositoryABC = Depends(ProductRepository)):
self.product_repo = product_repo
def create_product(self, product: ProductModel) -> ProductModel:
return self.product_repo.create_product(product=product)
app = FastAPI()
#app.post(
"/products",
name="products:create",
response_model=ProductModel
)
def create_product(
product: ProductModel,
product_srv: ProductService = Depends(ProductService)
) -> ProductModel:
return product_srv.create_product(product=product)
Global settings:
You can use Pydantic to build config-base settings with a class mapper for global settings, and build a utility for string imports, and there's a quite good well-testing functions on the Django community which you can use to import from string or use the import_module directly dynamically from importlib
config.py
from pydantic import BaseSettings
from .utils import import_string #YOUR IMPORT STRING FUNCTION
class Settings(BaseSettings):
app_name: str = "Awesome API"
services = {
"product_repo": {"class": import_string("repositories.ProductRepository")}
}
settings.py
from functools import lru_cache
from . import config
app = FastAPI()
#lru_cache()
def get_settings():
return config.Settings()
Start packaging your module with a more robust structure like the following
services/products.py
from settings import get_settings
settings = get_settings()
class ProductService(object):
"""
Product service
"""
def __init__(self, product_repo: ProductRepositoryABC = Depends(settings.get('services').get('class')):
self.product_repo = product_repo
def create_product(self, product: ProductModel) -> ProductModel:
return self.product_repo.create_product(product=product)
Note: One of the limitations of Depends is that currently there is no straight forward way to use it outside of FastAPI context, but luckily you can still use and combine it with a powerful tool like https://github.com/ets-labs/python-dependency-injector to build a robust decoupled modules FastAPI example
Final result:

Answer 2

#Josu16
I also had the same problem in FastAPI class as dependency, what I did and it may funny, is I created instance of the ProductService and pass the ProductRepository itslef to the argument of it. out side of the #router
pro_service = ProductService(ProductRepository)
it may notbest practice but it just work.
the product service file is like this :
def __init__(self, repo: ProductRepositoryABC = Depends()) -> None:
I'm trying to figureout the way based on Depends=()