Models

No conoces un tweet cuando lo vez?

Apuntes:
https://hackmd.io/@EY-75X2IS6-Sv0wXHoIR0Q/rk8vjxCrt#Models

Models

Documentacion Oficial: https://fastapi.tiangolo.com/tutorial/sql-databases/

Un modelo es la representacion de una entidad en codigo, al menos de una manera descriptiva.

¿Como luce un modelo dentro de FastAPI?

Modelo pydantic para validar datos:

from typing import List, Optional

from pydantic import BaseModel


class ItemBase(BaseModel):
    title: str
    description: Optional[str] = None


class ItemCreate(ItemBase):
    pass


class Item(ItemBase):
    id: int
    owner_id: int

    class Config:
        orm_mode = True


class UserBase(BaseModel):
    email: str


class UserCreate(UserBase):
    password: str


class User(UserBase):
    id: int
    is_active: bool
    items: List[Item] = []

    class Config:
        orm_mode = True

Un modelo para mapear los datos a la base de datos (ORM, SQLalchemy)

from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
from sqlalchemy.orm import relationship

from .database import Base


class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True)
    hashed_password = Column(String)
    is_active = Column(Boolean, default=True)

    items = relationship("Item", back_populates="owner")


class Item(Base):
    __tablename__ = "items"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, index=True)
    description = Column(String, index=True)
    owner_id = Column(Integer, ForeignKey("users.id"))

    owner = relationship("User", back_populates="items")

Modelos

Los modelos son la representación de una entidad en código, una entidad es un objeto de la vida real, que tiene ciertos atributos. Por ejemplo:

• Carro: color, motor, año, marca
• Persona: edad, nombres, apellidos, altura

Para poder crear modelos en el código se utiliza la librería Pydantic, importando la clase BaseModel:

from pydantic import BaseModel

Un ejemplo de una aplicación sería:

#Python
from typing import Optional

#Pydantic
from pydantic import BaseModel

#FastAPI
from fastapi import FastAPI
from fastapi import Body

app = FastAPI()

#Models
class Person(BaseModel):              #Se crea una clase que herede la clase BaseModel, los atributos de la clase serían los atributos de la entidad/modelo
    first_name: str 
    last_name: str
    age: int                          #Se usan los dos puntos y el tipo de dato para definir que tipo de dato va a llevar este atributo en JSON
    hair_color: Optional[str] = None
    is_married: Optional[bool] = None #Para poder tener atributos opcionales con un tipo de dato, se usa la clase Optional[{type}] y se pone un valor por defecto que                                           sería None, que en bases de datos es null


@app.get("/")                         #Un path operation que usa el método get en la ruta /
def home():
    return {"Hello": "World"}

@app.post("/person/new")              #Un path operation que usa el metodo post en la ruta /person/new
def create_person(person: Person = Body(...)):  #Se usa un Request Body, se importa la clase Body de FastAPI esta en su constructor usa un parametro, en este caso son                                                    los 3 puntos, que indican que ese Request Body es obligatorio. Se usa una variable que serviría como parametro para                                                      usar el modelo, en este caso person que sería tipo Person
    return person

Excelente clase, ya queda menos de la mitad para terminar 😄 !

Entidad: es cualquier objeto real
Modelo: es la representación de una entidad en código, al menos de manera descriptiva, por lo que cada entidad debe tener por lo menos un modelo.
Pydantic de esta librería traeremos una clase llamada BaseModel para crear los modelos.

El curso de programación orientada a objetos en Python al parecer existe hace rato en la plataforma… Mi problema con ese curso es el profesor, deja demasiados temas abiertos o implicitos, es molestisimo tener que seguirle el ritmo así. No es como si fuera la universidad donde hay limitaciones de tiempo y espacio, no se porque entonces justificar dichas cosas.

Entidad es cualquier objeto que nos rodea
Modelo es la representación de una entidad en código, al menos de manera descriptiva, por lo que cada entidad debe tener por lo menos un modelo. Esto se logra con una librería llamada pydantic de ella traeremos una clase llamada BaseModel para crear los modelos.

Uso de Optional de la librería typing para indicar que un atributo es opcional dentro de un modelo.

Es un burro dientón?

Tener en cuenta que la última actualización de FastAPI hizo que no sea necesario usar los 3 puntos (…). Es natural que no se diga porque apenas fue actualizada en mayo de este año (05-2022).

Fuente: https://github.com/tiangolo/fastapi/releases/tag/0.78.0

eso de modelos me remonta a django ajjaja

Un módelo es la descripción en código de una entidad.

POST

from typing import Optional
from pydantic import BaseModel
from fastapi import FastAPI
from fastapi import Body

app = FastAPI()

class Person(BaseModeL):
	first_name: str
	 last_name: str
	age: int
	hair_color: Optional[str] = None
	is_maried: Optional[booL] = None


@app.get("/")
def home():
    return {#Hello": "World"}

@app.post("/person/new")
def create_person(person: Person = Body(...)):
	return person

Un paso final es colocar el curl que da fast API en la terminal y puedes observar que respuesta da

curl -X 'POST' \
  'http://localhost:8000/person/new' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "first_name": "Daniel",
  "last_name": "Salazar",
  "age": 30,
  "hair_color": "Black",
  "is_married": true
}'
#respuesta
{"first_name":"Daniel","last_name":"Salazar","age":30,"hair_color":"Black","is_married":true}

Models
la representación de una entidad en código.

Mi resumen:

Modelo: Reprensentación descriptiva en código de una entidad del mundo real (Ejemplo: Casa, Carro, Autobús, )
Para crear modelos se debe importar:
- From pydantic import BaseModel
- From typing import Optional
- Request body es un parámetro que se pasa
en la definición de la función.
- Se debe importar:
- from fastapi import Body

Flor de clase:

#Python
from typing import Optional

#Pydantic
from pydantic import BaseModel

# FastAPI
from fastapi import FastAPI
from fastapi import Body

app = FastAPI()

# Models

class Person(BaseModel): # Person parameters
    first_name: str
    last_name: str
    age_person: int
    colos_eye: Optional[str] = None
    maried: Optional[bool] = None

@app.get("/") #Path operation decorator
def home(): #Path operation function
    return {"First API": "Congratulation"} #JSON

# Request and Response Bondy

@app.post("/person/new") # Acces a new person
def create_person(person: Person = Body(...)): # acces to the parameters of person
    return person