No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Validaciones: Query Parameters

12/20
Recursos

Aportes 18

Preguntas 7

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Mis Apuntes: https://rain-scabiosa-74f.notion.site/Curso-de-FastAPI-c414d59370504c448505a80b69f93b12

from typing import Optional

from fastapi import FastAPI
from fastapi import Query

app = FastApi()

@app.get('/person/detail')
def show_person(
    name: Optional[str] = Query(
        default=None,
        min_length=1,
        max_length=50
    ),

    # El ... para hacerlo obligatorio, no recomendado en un Query parameter
    age: int = Query(...)
):
    '''
    Funcion para probar la validacion en los query parameter.
    El Age esta obligatorio, no se recomienda hacer esto, si necesitas un
    parametro obligatorio se recomienda hacerlo en un path parameter
    '''
    return {name: age}

Validaciones

Las validaciones tal como se definen, nos sirven para comprobar si son correctos los parámetros entregados en cada una de las peticiones. Estas validaciones funcionan restringiendo o indicando el formato de entrega en cada una de las peticiones.
\

Query parameters

Entonces, se definen las validaciones para las Query Parameters para definir un estándar de consulta y especificar cómo se deben entregar los datos.

EJ:

Se define la siguiente consulta (QUERY):

https://domain.com/user/detail?nombre=Manolo&edad=20

Como validaciones tendríamos que limitar el tamaño de caracteres que puede tener el atributo “nombre” (50 > largo > 1), además de limitar los valores para “edad” (300 > edad > 0).

# Validaciones.
@mi_app.get("/user/detail") # Ruta para realizar la consulta.
def mostrar_usuario(
	#Opcional.
	nombre: Optional[str] = Query(None, min_length=1, max_length=50),
	# Obligatorio.
	edad: int = Query(...)
   ):

   return {nombre: edad};

Mis apuntes: 😎

Un aporte: El comando “git add .” también hace lo mismo que el comando “git add -A”. La diferencia es que el primero contempla todos los cambios (archivos nuevos y modificados) a exepción de los archivos eliminados. El Segundo comando (Que usa Facundo) manda al stagin area todo.

A alguien más le pareció raro que Age se declarara como string???

Mis Apuntes:
https://hackmd.io/@EY-75X2IS6-Sv0wXHoIR0Q/rk8vjxCrt#Validaciones-Query-Parameters

#Python
from typing import Optional

#FastAPI
from fastapi import FastAPI
from fastapi import Body, Query

app = FastAPI()

@app.get("/person/detail")
def show_person(
    name: Optional[str] = Query(None, min_length=1, max_length=50),
    age: str = Query(...)
): 
    return {name: age}

Excelente clase, amigos les comparto otra manera de hacer validaciones y restringir por ejemplo cantidad de carcateres o tipos de datos en la Api, además un paquete de serialización / deserialización todo esto con una libreria Marshmallow
les dejo el link
https://www.peterspython.com/es/blog/flask-restful-api-validacion-de-parametros-de-solicitud-con-esquemas-marshmallow

También podemos definir una expresión regular con la que debe coincidir el parámetro:

from typing import Optional

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(

    q: Optional[str] = Query(None, min_length=3, max_length=50, regex="^fixedquery$")

):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

Siempre es importante tener referencia a la Documentación Oficial

Por ahora voy esto, estoy haciendo a la vez un crud con mysql.

Conexión con la base de datos :

import pymysql

class Users:
    def iniciar_conexion(self):
        self.conexion = pymysql.connect(
            host="localhost",
            user="root",
            password="xxxxx",
            database="api"
            )


        return self.conexion

    def create(self, first_name, last_name, age):
        self.conexion = self.iniciar_conexion()
        self.cursor = self.conexion.cursor()

        sentenciasql = 'INSERT INTO users(first_name, last_name, age) VALUES("{}", "{}", {})'.format(first_name, last_name, age)

        self.cursor.execute(sentenciasql)
        self.conexion.commit()


    def read(self, first_name):
        
        self.conexion = self.iniciar_conexion()
        self.cursor = self.conexion.cursor()

        sentenciasql = 'SELECT * FROM users WHERE first_name = {}'.format(first_name)

        self.cursor.execute(sentenciasql)
        users = self.cursor.fetchall()
        for user in users:
            return {"id" : user[0], "first_name":user[1], "last_name":user[2]}

        self.conexion.commit()

Archivo main :

from typing import Optional
from fastapi.params import Body
from pydantic import BaseModel
from fastapi import FastAPI
from fastapi import Body, Query

from conexion import Users


class Persona(BaseModel):
      first_name : str
      last_name : str
      age : int
      is_married : Optional[bool] = False


users = Users()
    
app = FastAPI()

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

    
@app.post("/post")
def create(person : Persona = Body(...)):

    users.iniciar_conexion()
    users.create(person.first_name, person.last_name, person.age)

    return person


@app.get("/person/detalles")
def detalles(
    name : Optional[str] = Query(None, min_length=1, max_length=50)
):
    
    users.iniciar_conexion()
    usuarios = users.read(name)
    return usuarios

Ejemplo de mas Query Parameters
![](

ufff cada vez me esta gustando. esto de las apis

Pobre hijo de Elon Musk con ese nombre lo van a rechazar en cada página web

Validaciones

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

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

@app.get("/person/detail")
def show_person(
	name: Optional[str] = Query(None, min_Length=1, max_Length=50)
	age: str = Query(...)
):
	return{name: age}

Validaciones: Query Parameters
Restricciones a lo que ponga el usuario.

Validaciones: Query Parameters

En este ejemplo estamos haciendo que un query parameter sea obligatorio, lo cual no es ni muy común ni buena práctica, pero es para fines didácticos.

@app.get("/person/detail")
def show_person(
    name: Optional[str] = Query(None, min_length=1, max_length=50),
    age: int = Query(...)
):
    return {"name": name, "age": age}

Con esto, si accedemos https://localhost:8000/person/detail?name=Miguel&age=23 obtenemos un JSON:

{
  "name": "Miguel",
  "age": 23
}

Sacando lo mejor de uno:

#Python
from typing import Optional

#Pydantic
from pydantic import BaseModel

# FastAPI
from fastapi import FastAPI
from fastapi import Body, Query

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

# Validations: Query Parameters

@app.get("/person/detail")
def show_person(
    name: Optional[str] = Query(None, min_length=1, max_length=50),
    age: str = Query(...)
):
    return {name: age}

la importancia de los signos de puntuación

In this video we can see how make validations in query parameters and this make the follow way:

...
from fastapi import Query
...
@app.get("/person/detail")
def show_person(
	name: Optional[str] = Query(None, min_length=1, max_length=50),
	age: str = Query(...)
):
	return {name: age}