<>

LABORATORIO IV
Introducción a FASTAPI
<> FastAPI
FastAPI es un framework moderno, rápido y robusto creado con la idea de aprovechar de
forma nativa los type-hints de Python, enfocándose en la performance y en las
necesidades de las aplicaciones de la actualidad. Está construido sobre Starlette y
Pydantic, lo que le permite soportar de forma nativa numerosos características y que
la experiencia de desarrollo sea la mejor posible.
https://fastapi.tiangolo.com/

Starlette: es un conjunto de herramientas para brindar ASGI (Asynchronous Server

Gateway Interface) liviano , ideal para crear servicios web asíncronos en Python.
https://www.starlette.io/

Pydantic: es una herramienta de validación de datos y gestión de configuración usando

notación de tipos en Python. Se puede usar en Python a partir de la versión 3.6.
https://docs.pydantic.dev/latest/
<> Ventajas del framework FASTAPI
• Fácil para comenzar en un principio.

• Bastante flexibilidad en cuanto a cómo estructurar el código.

• Es fácil agregar, modificar o eliminar código.

• ASGI soportado de forma nativa.

• Documentación autogenerada a partir de anotaciones.

• Validación de tipos, incluso en JSON anidados.

• Inyección de dependencias para validaciones automáticas.

• Excelente performance.

• Posibilidad de ser utilizado en proyectos de cualquier tamaño.

<> Introducción a los Tipos
de Python.
Python tiene soporte para "type hints" opcionales.
Los type hints son una nueva sintaxis, presente desde Python
3.6+, que permite declarar el tipo de una variable.

Usando las declaraciones de tipos para las variables, los

editores y otras herramientas pueden proveerte un soporte
mejor.

Se pueden declarar todos los tipos estándar de Python: int,

float, bool, bytes y str.

Y además también los sub-tipos: dict, list, set y tuple.

<> Introducción a los Tipos
de Python.
Ejemplo: Si type hints

def get_full_name(first_name, last_name):

full_name = first_name.title() + " " + last_name.title()
return full_name
print(get_full_name("john", "doe"))

Añadiendo type hints

def get_full_name(first_name: str, last_name: str)->str:

full_name = first_name.title() + " " + last_name.title()
return full_name
print(get_full_name("john", "doe"))
 Dependencias
<> principales.

Python 3.X: Verificar que esté instalada con el comando:

$ python –V.

PIP: Comprobar que el instalador de paquetes pip se encuentre

en el equipo, con el comando:

$ pip –V.
<> Configuración del
ambiente de desarrollo.
Debemos generar un ambiente virtual para poder crear la
primera aplicación en FastApi.

En Python, los ambientes virtuales son entornos de desarrollo

aislados al sistema operativo, por lo tanto, los paquetes que
instalemos no serán instalados en el sistema operativo si no
en el ambiente virtual.

Podemos crear tantos ambientes virtuales como queramos,

usualmente tenemos un ambiente virtual por proyecto y con
esto, se manejan de manera independiente todos los paquetes y
dependencias necesarios para un proyecto en Python en
general.
<> Configuración del
ambiente de desarrollo.
En Python, los ambientes virtuales se pueden crear y gestionar
con la herramienta venv, que viene incluida en la librería
estándar de Python aunque también es posible instalarlo
mediante:
$ pip install virtualenv

Para crear el ambiente virtual, tenemos el comando de:

$ python3 -m venv nombre_carpeta

El cual generará el ambiente virtual, que no es más que una

carpeta con varios archivos y subcarpetas.
 Activar ambiente
<> virtual.
Para activar el ambiente virtual, debemos ingresar a la
carpeta del mismo.

Ejecutamos en MacOS o Linux:

$ source bin/activate

En Windows el comando sería como:

$ Scripts\activate

Y con esto, ya tenemos todo listo para iniciar nuestro

proyecto. Tener en cuenta que para ejecutar cualquier comando
de Python o de pip siempre hay que tener previamente activo el
ambiente virtual.
 Instalar FASTAPI y
<>
UVICORN
Dentro de la carpeta del ambiente virtual y luego de ser
activado ejecutamos:

$ pip install fastapi

Uvicorn es un servidor web HTTP de tipo ASGI (Asynchronous

Server Gateway Interface) que podemos usar en múltiples
frameworks webs de Python de tipo asíncronos como lo son
Django, Flask y por supuesto FastApi.
Para instalar el servidor lo podemos hacer como si fuera un
paquete más para Python con:

$ pip install uvicorn

<> HOLA MUNDO en FASTAPI
Debemos crear un archivo dentro del proyecto, apy.py por
ejemplo

Con el siguiente código:

api.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")

def hello_world():

return {"hello": "world"}

<> HOLA MUNDO en FASTAPI
En este primer ejemplo, lo primero que hacemos es cargar una clase que proporciona acceso al
framework: from fastapi import FastAPI.

Con esta clase, creamos una instancia de FastApi: app = FastAPI()

Lo cual nos da acceso a múltiples funcionalidades del framework, como lo es, crear las rutas de
la aplicación.
Definimos una petición de tipo GET para la raíz y mediante un decorador:@app.get("/")

Por supuesto, podemos acceder a otros tipos de peticiones como POST, PUT, PATCH y DELETE.
Es decir, para enviar una petición de tipo GET, usamos la función deget(), para enviar una
petición de tipo POST, usamos la función de post().

Al igual que ocurre con otros frameworks web, cada petición es procesada mediante una función,
en el ejemplo anterior, la petición de tipo GET para la raíz, es procesada mediante una función
llamada hello_world() que lo único que hace es devolver un diccionario indicando el mensaje de
"hola mundo":

@app.get("/")
def hello_world():
return {"hello": "world"}
<> HOLA MUNDO en FASTAPI
Finalmente para poder ver los resultados necesitamos correr un
servidor que procese las peticiones HTTP. Para ello tenemos
que debemos ejecutar UVICORN, con el siguiente comando:

$ uvicorn api:app --reload

En donde api es el nuestro archivo api.py y app el nombre de

la instancia de FASTAPI. La opción reload es para que el
servidor se mantenga atento a los cambios; es decir, con esta
opción, el servidor se recargará cada vez que se realicen
cambios en la aplicación.
<> HOLA MUNDO en FASTAPI
Finalmente para poder ver los resultados necesitamos correr un
servidor que procese las peticiones HTTP. Para ello tenemos
que debemos ejecutar UVICORN, con el siguiente comando:

$ uvicorn api:app --reload

En donde api es el nuestro archivo api.py y app el nombre de

la instancia de FASTAPI. La opción reload es para que el
servidor se mantenga atento a los cambios; es decir, con esta
opción, el servidor se recargará cada vez que se realicen
cambios en la aplicación.
Luego desde un navegador web podremos ingresar a
http://127.0.0.1:8000 y podremos ver el resultado del
endpoint.
También existe un parámetro --port:8001 para indicar otro
puerto diferente al 8000 por defecto.
<> PARAMETROS DE RUTA
Los parámetros de ruta son segmentos de la URL que contienen
información específica, como un ID de producto o un término de
búsqueda. Por ejemplo, una URL que incluye un parámetro de
ruta para un producto podría verse así:
"www.ejemplo.com/producto/123".

En FASTAPI los parámetros de rutas se escriben de la siguiente

manera:

@app.get("/movies/{id}")
def get_movies(id: int):
#TODO
return {“MOVIE ID": id}
<> PARAMETROS QUERY
Los parámetros query son conjunto de argumentos opcionales
clave valor que se añaden al final de la URL luego del signo ?
y nos permiten pasarle al endpoint información para hacer
filtrados , ordenamientos, paginaciones, etc.

www.ejemplo.com/movies?categoria=Accion&year=2020

En FASTAPI los parámetros de rutas se escriben de la siguiente

manera:

@app.get("/movies/{")
def get_movies(categoria:str, year:int):
#TODO filtrar lista de películas x cat y año
return {movie}