Arquitetura limpa através dos olhos de um desenvolvedor Python

A busca pela elegância e o poderoso dinamismo da linguagem criaram muitas bibliotecas com uma API verdadeiramente deliciosa. 

Código incorreto

Arquitetura limpa

• A regra de prioridade para a camada interna - é a camada interna que determina a interface através da qual ela irá interagir com o mundo exterior;
• Regra de dependência - As dependências devem ser direcionadas da camada interna para a externa.

• Regra de passagem de fronteira;
• Regra de dependência;
• A regra de prioridade da camada interna.

• Facilidade de teste - as camadas são isoladas, respectivamente, podem ser testadas sem remendo de macacos, você pode definir granularmente o revestimento para diferentes camadas, dependendo do grau de importância;
• A facilidade de alterar as regras de negócios , uma vez que todas elas são coletadas em um único local, não são espalhadas pelo projeto e não são misturadas ao código de baixo nível;
• Independência de agentes externos : em alguns casos, a presença de abstrações entre a lógica de negócios e o mundo externo permite alterar fontes externas sem afetar as camadas internas. Funciona se você não vinculou a lógica de negócios aos recursos específicos de agentes externos, por exemplo, transações de banco de dados;
• , , , .

, . . , . « Clean Architecture».

Python

from rentomatic.response_objects import response_objects as res

class RoomListUseCase(object):
   def __init__(self, repo):
       self.repo = repo
   def execute(self, request_object):
       if not request_object:
           return res.ResponseFailure.build_from_invalid_request_object(
               request_object)
       try:
           rooms = self.repo.list(filters=request_object.filters)
           return res.ResponseSuccess(rooms)
       except Exception as exc:
           return res.ResponseFailure.build_system_error(
               "{}: {}".format(exc.__class__.__name__, "{}".format(exc)))

repo RoomListUseCase, execute — . - , , . - . , , , repo .

from typing import Optional, List
from pydantic import BaseModel

class Room(BaseModel):
   code: str
   size: int
   price: int
   latitude: float
   longitude: float

class RoomFilter(BaseModel):
   code: Optional[str] = None
   price_min: Optional[int] = None
   price_max: Optional[int] = None

class RoomStorage:
   def get_rooms(self, filters: RoomFilter) -> List[Room]: ...

class RoomListUseCase:
   def __init__(self, repo: RoomStorage):
       self.repo = repo
   def show_rooms(self, filters: RoomFilter) -> List[Room]:
       rooms = self.repo.get_rooms(filters=filters)
       return rooms

def rool_list_use_case(filters: RoomFilter, repo: RoomStorage) -> List[Room]:
   rooms = repo.get_rooms(filters=filters)
   return rooms

from typing import List
from fastapi import FastAPI, Depends
from rentomatic import services, adapters
app = FastAPI()

def get_use_case() -> services.RoomListUseCase:
   return services.RoomListUseCase(adapters.MemoryStorage())

@app.post("/rooms", response_model=List[services.Room])
def rooms(filters: services.RoomFilter, use_case=Depends(get_use_case)):
   return use_case.show_rooms(filters)

, , , RoomStorage. , 15 , , , .

• Regra de passagem de fronteira: modelos pydantic, que são essencialmente DTOs, atravessam fronteiras ;
• Regra de dependência : a camada de lógica de negócios é independente de outras camadas;
• A regra de prioridade para a camada interna : é a camada de lógica de negócios que define a interface (RoomStorage), através da qual a lógica de negócios interage com o mundo externo.