Arquitectura limpia a través de los ojos de un desarrollador de Python

La búsqueda de la elegancia más el poderoso dinamismo del lenguaje han creado muchas bibliotecas con una API realmente encantadora. 

Código malo

Arquitectura limpia

• La regla de prioridad para la capa interna : es la capa interna la que determina la interfaz a través de la cual interactuará con el mundo exterior;
• Regla de dependencia : las dependencias deben dirigirse desde la capa interna hacia la externa.

• Regla de cruce de fronteras;
• Regla de dependencia;
• La regla de prioridad de la capa interna.

• Facilidad de prueba : las capas están aisladas, respectivamente, se pueden probar sin parches de mono, puede configurar granularmente el recubrimiento para diferentes capas, dependiendo del grado de su importancia;
• La facilidad de cambiar las reglas de negocio , ya que todas se recopilan en un solo lugar, no se extienden por el proyecto y no se mezclan con código de bajo nivel;
• Independencia de los agentes externos : la presencia de abstracciones entre la lógica empresarial y el mundo exterior en ciertos casos le permite cambiar las fuentes externas sin afectar las capas internas. Funciona si no ha vinculado la lógica de negocios a las características específicas de los agentes externos, por ejemplo, transacciones de bases de datos;
• , , , .

, . . , . « 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 , , , .

• Regla de cruce de fronteras: los modelos piradínicos, que son esencialmente DTO, cruzan fronteras ;
• Regla de dependencia : la capa de lógica de negocios es independiente de otras capas;
• La regla de prioridad para la capa interna : es la capa de lógica de negocios que define la interfaz (RoomStorage), a través de la cual la lógica de negocios interactúa con el mundo exterior.