es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Cómo acelerar el desarrollo de una API REST en Python?

02 Aug, 2023 Programación

Estoy tratando de crear una aplicación de backend utilizando FastApi y SQLAlchemy. Tengo muchas entidades que tienen relaciones con la base de datos. Entonces, mi pregunta es: ¿Cómo acelerar el desarrollo? Ahora escribo el siguiente código para cada entidad:

@app.get(“/holidays”)
def obtenerVacaciones():
session = Session(bind=engine)
vacaciones: List[Vacaciones] = session.query(Vacaciones).all()
return [x.to_json() for x in vacaciones]

@app.get(“/exclusive_operations”)
def obtenerOperacionesExclusivas():
session = Session(bind=engine)
operaciones_exclusivas: List[OperacionExclusiva] = session.query(OperacionExclusiva).all()
return [x.to_json() for x in operaciones_exclusivas]

@app.get(“/category_descriptions”)
def obtenerDescripcionesCategoria():
session = Session(bind=engine)
descripciones_categorias: List[DescripcionCategoria] = session.query(DescripcionCategoria).all()
return [x.to_json() for x in descripciones_categorias]

Entonces, si quiero crear todas las operaciones CRUD, necesito crear 12 métodos típicos para 3 entidades. ¿Quizás exista otra solución?

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Sí, hay una forma de acelerar tu proceso de desarrollo. Puedes usar la base declarativa de SQLAlchemy para crear un modelo base para tus entidades. Esto te permitirá definir tus entidades utilizando clases, las cuales pueden ser heredadas por tus clases de entidad individuales.

    Por ejemplo, puedes crear una clase de modelo base de esta manera:

    from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class BaseModel(Base):
    __abstract__ = True

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(50), nullable=False)
    description = Column(String(255))

    def to_json(self):
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

    Luego puedes crear tus clases de entidad de esta manera:

    class Holiday(BaseModel):
    __tablename__ = 'holidays'

    start_date = Column(Date, nullable=False)
    end_date = Column(Date, nullable=False)


class ExclusiveOperation(BaseModel):
    __tablename__ = 'exclusive_operations'

    start_date = Column(Date, nullable=False)
    end_date = Column(Date, nullable=False)


class CategoryDescr(BaseModel):
    __tablename__ = 'category_descrs'

    category_type = Column(String(50), nullable=False)
    category_description = Column(String(255), nullable=False)

    Y finalmente, puedes crear métodos genéricos CRUD utilizando el sistema de inyección de dependencias de FastAPI y el objeto de sesión de SQLAlchemy. Aquí tienes un ejemplo para solicitudes GET:

    from typing import List

from sqlalchemy.orm import Session
from fastapi import Depends, FastAPI

from models import BaseModel

app = FastAPI()

def get_db():
    try:
        db = SessionLocal()
        yield db
    finally:
        db.close()

@app.get("/{table_name}", response_model=List[BaseModel])
def get_records(table_name: str, db: Session = Depends(get_db)):
    table = getattr(models, table_name.capitalize())
    return db.query(table).all()

    De esta manera, solo necesitas definir las clases de entidad y los métodos CRUD una vez, y puedes usarlos para todas tus otras entidades.

Comments are closed.