Parámetros Query

La solicitud del profe realizada por medio de list comprehension.

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str):
    return [movie for movie in movies if movie['genre'] == category]

Un query parameter es un conjunto de parámetros opcionales los cuales son añadidos al finalizar la ruta, con el objetivo de definir contenido o acciones en la url, estos elementos se añaden después de un ?, para agregar más query parameters utilizamos &.

Ejemplo:

www.youtube.com/watch?v=cCEtxQo52Os&t=6s&ab_channel=ConAnimoDeOfender
.
Notas tomadas del curso anterior de FastAPI del profe Facundo.

Solución usando high-order functions: FILTER

@app.get('/movies/', tags = ['movies'])
def get_movies_by_category(category: str):
   return list(filter(lambda item: item['category'] == category , movies))

Si alguien quiere intentar el ejercicio filtrando por año y no le sale es probablemente porque están definiendo el parametro year como int, sin embargo si revisan el diccionario de movies el valor del año viene entre comillas por lo que el programa lo va a reconocer como un string. Las ocpiones para que funcione son 2: o definen el año como string en los parámetros de la función o pueden modificar el diccionario quitandole las comillas al valor de año para que sea reconocido como un int

La solicitud utilizando year como parametro opcional

def valid_querie(year:int,category:str,movie:dict):
    return movie['category'] == category and movie['year'] == year


@app.get('/movies/', tags=["movies"]) # query parameters
def get_movies_by_query(category:str,year:int=None):
    if year is None:
        return [movie for movie in movies if movie['category'] == category]
    else:
        return [movie for movie in movies if valid_querie(year,category,movie)]
    

Usando filter:

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str,year:int):
    return list(filter(lambda x: x['category'] == category, movies))

Mi aporte:

category_movie = [item for item in movies if item['category'] == category]

Mi Aporte 😃

@router.get(
    "/category/",
    status_code=status.HTTP_200_OK,
    summary="List movies",
)
async def get_movie(category: str):
    """
    Obtener película por categorías por Query Parameters
    """
    filtered_list_movies = list(filter(lambda x: category == x["category"], movies_list))
    list_movies = list(filtered_list_movies)
    if not list_movies:
        raise HTTPException(status_code=404, detail="Movie not found!")

    return JSONResponse(content=list_movies) 

@app.get('/movies/', tags=["movies"])
def get_movies_by_category(category: str, year: int):
    """Function Get movies by category"""
    movie = list(filter(lambda item: item["category"] == category, movies))
    return movie if len(movie) > 0 else []

Mi solución:

@app.get('/movies/', tags=['Movies'])
def get_movies_by_category(category: str, year: int):
    for movie in movies:
        if movie['category'] == category:
            return movie

Mi solución

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    for item in movies:
        if item["category"] == category and item["year"] == str(year):
            return item
    return []

Yo lo resolvi usando list comprehension, asumi que como los 2 parametos son requeridos las peliculas deben tener la misma categoria y el mismo año,

@app.get("/movies/", tags=['movies'])
def get_movies_by_category(category: str, year: str):
    # Filtrar las películas por categoría y año
    filtered_movies = [movie for movie in movies if movie['category'] == category and movie['year'] == year]
    # Si hay películas que cumplen (o sea la lista tiene elementos)
    if filtered_movies:
        return filtered_movies
    return f'No hay películas para la categoría {category} y el año {year}'

Hola, les dejo una solución considerando el título, el año, la categoría y el puntaje de las películas:

@app.get("/movies/", tags=['movie'])
async def get_movies_by_category(
        category: Optional[str] = Query(None),
        year: Optional[int] = Query(None),
        title: Optional[str] = Query(None),
        rating: Optional[Union[float, int]] = Query(None, ge=0, le=10)
):
    result = list(filter(
        lambda movie: movie["title"] == (title if title is not None else movie["title"])
                      and movie["year"] == (str(year) if year is not None else movie["year"])
                      and movie["category"] == (category if category is not None else movie["category"])
                      and movie["rating"] == (rating if rating is not None else movie["rating"]),
        movies
    ))

    return result

La respuesta al reto:

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    movies_by_category = []
    for item in movies:
        if item["category"] == category:
            movies_by_category.append(item)
    return movies_by_category

Les dejo un aporte:

Parámetros de ruta: Estos son valores que se extraen directamente de la ruta misma, como {id} en tu primer ejemplo.
Parámetros de consulta: Estos son valores que se extraen de la parte de la consulta de la URL (después de un ?), como name y lastname en tu segundo ejemplo.
Aquí está la diferencia detallada:

1. Parámetros de Ruta
   Ubicación: Directamente en la URL, como parte de la ruta.
   Uso: Comúnmente usado para identificar un recurso específico.
   Ejemplo: Con la ruta /person/{id}, puedes hacer una petición a /person/5 para obtener la información de la persona con id 5.
   Características:
   Obligatorio por defecto.
   La URL no es válida sin este parámetro.

2. Parámetros de Consulta (Query Parameters)
   Ubicación: Después del ? en la URL.
   Uso: Comúnmente usado para filtros, ordenamiento, paginación, o como datos adicionales para la consulta.
   Ejemplo: Con la ruta /person/, puedes hacer una petición a /person/?name=John&lastname=Doe para obtener información sobre la persona llamada John Doe.
   Características:
   Opcional por defecto (a menos que especifiques None como valor predeterminado o uses el tipo Optional).
   Los parámetros que no estén presentes en la URL simplemente tendrán un valor None (o cualquier otro valor predeterminado que hayas establecido).
   ¿Cuándo usar cuál?

Parámetros de ruta: Son ideales para recursos específicos, como obtener un usuario específico por ID. Son obligatorios, por lo que si el cliente no proporciona este parámetro, la URL será inválida.
Parámetros de consulta: Son ideales para proporcionar opciones adicionales a una consulta, como filtros, ordenamiento o paginación. También son útiles para operaciones que no involucran la identificación de un recurso específico.

En resumen, la elección entre parámetros de ruta y de consulta se basa en las necesidades específicas de tu aplicación y en cómo quieres estructurar las URLs y las operaciones disponibles para los clientes de tu API.

La solicitud utilizando list comprehension:

@app.get("/person/" , tags = ["person"])
def searh_person_name(name: str, lastname: str):
    return [item for item in persons if item["name"] == name and item["Lastname"] == lastname]

Esta fue mi solución

@app.get('/movies/', tags=['movies'])
def get_movie_by_category(category: str, year: int = None):
    movies_by_category = filter(lambda y: y['category'].lower() == category 
                                , movies)
    
    return list(movies_by_category)

@app.get('/movies/', tags=['movies']) # Parámetro query /
def get_movies_by_category(category: str):
    category = category.capitalize()
    #movie = list(filter(lambda x: x['category'] == category, movies))
    movie = [x for x in movies if x['category'] == category]
    return movie if len(movie) > 0 else 'Movie not found'

me gusta las funciones lambda!

De esta forma encuentra la categoría aunque no tenga tilde o mayúscula

@app.get('/movies', tags=["Movies"])
def get_movies(category: Optional[str] = None, year: Optional[int] = None):

    if category:
        normalizeStr = lambda s: unidecode(s).lower()
        movies_by_category = [m for m in movies if normalizeStr(m['category']) == normalizeStr(category)]
        return movies_by_category

instalé unidecode para cambiar los caracteres especiales y el método lower para comparar ambos strings con minúsculas

Mi aporte cambiando a Str la fecha

@app.get('/movies/',tags=['movies'])
def get_movies_by_category(category:str,year:str):
    cat_list = []
    for item in movies:
        if item["year"]== year and item["category"]== category:
            cat_list.append(item)
    return cat_list

Solucion del reto:

def get_movies_by_category(category: str):
    movies_list = []
    for item in movies:
        if item["category"] == category:
            movies_list.append(item)
    return movies_list

Las maravillas del backend y de las funciones lambda de Python:

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str):
    filtered_movies = list(filter(lambda item: item['category'] == category, movies))
    return filtered_movies[0] if filtered_movies else ['Movie category not found']

Quedo delicioso! Seda para los dedos del backend:

lo cambie un poco para entender lo mejor y asi ver que funcione

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category:str):
    return [item for item in movies
            if item['categoria'] == category] 

en una sola linea

@app.get("/moivies/", tags=["movies"])
def get_movies_by_category(category: str, year: str):
    
    return [movie for movie in movies if movie["category"] == category and movie['year'] == year]

mi solucion:

movies_filtered = list(filter(lambda item: item['category'] == category, movies))

@app.get('/movies/', tags=['Movies'])
def get_movies_by_category(category: str):
    movie = filter(lambda x: x['category'] == category, movies )
    return list(movie)

Mi solución

@app.get('/movie/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    return list(filter(lambda x: x['category'] == category and x['year'] == year, movies))

Esta es mi solución al reto, donde es necesario que el año y la categoría sean validas.

@app.get("/movies/", tags=["movies"])
def get_movies_by_categories(category:str, year:int):
    for movie in movies:
        if movie["category"] == category and int(movie["year"]) == year:
            return movie
    return category, year```

Aquí está mi solución usando filter() :3

@app.get('/movies/', tags=["movies"])
def get_movies_by_category(category_requested: str):

    catalog = list(filter(lambda movie: movie['category'] == category_requested, movies))

    # Raise error if catalog is empty
    if not catalog:
        raise HTTPException(status_code=404, detail="Item not found")
    
    return catalog 

Code

@app.get("/movies/", tags=['movies'])
def get_movies_by_category(category: str):
    movies_by_category = []
    for movie in movies:
        if movie['category'] == category:
            movies_by_category.append(movie)
    return movies_by_category    

@app.get("/movies/", tags=[“movies”])#parametros query
def get_movies_by_category(category : str):
for item in movies:
if item[“category”] == category:
return item
return []

@app.get("/movies/", tags=["List of Movies by cat"])
def get_movie_by_cat(category: str, year: int):
    for item in movies:
        print(item['category'], item['year'])
        if item['category'] == category and item['year'] == year:
            return item
    return {'Error': 'No se encontro la pelicula'}

Para el reto propuesto decidí utilizar el método filter, así me quedó:

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str):
  filter_data = list(filter(lambda x: x['category'] == category.title(), movies))
  return filter_data

Saludos,

comparto mi solución al reto:

# get /movies => query route
@app.get('/movies/', tags = ['movies'])
def getMoviesByCategory(category: str, year: str):
    # filter movies by category or year
    result = list(filter(lambda item: category in item['category'] or year in item['year'], movies))
    if result:
        return result
    else:
        return []

Este es mi solución filtrando la categoria usando el query de categoria y año de la clase.

@app.get('/movies/', tags = ['movies'])#agregando la barra en movies/ ya no se sobreescribe la funcion get_movies
def get_movies_by_category(category: str, year: int):
    result = [item for item in movies if (item["category"] == category and item["year"] == year)]
    return result>

hecho con list comprehension

@app.get('/movies/', tags=['Movies'])
def get_movies_by_category(category:str,year:int):
    categorie = [i for i in movies if i['category'] == category]
    return categorie

Tarea.

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    for movie in movies:
        if movie["category"] == category and movie["year"] == year:
            return movie
    return []

Mi solución

@app.get('/movies/', tags=["Movies"])
def get_movie_by_category(category: str):
    movie = list(filter(lambda movie: movie['category'] == category, movies))
    
    return movie if movie else {'Movie': 'Not Found'}

también se pueden procesar parámetros no predefinidos usando el estándar **kwargs en la función asociada a la url. Estos son un diccionario.

Aquí va mi código

from fastapi import FastAPI
from fastapi.responses import HTMLResponse

app = FastAPI()
#Para cambiar el nombre de la aplicación
app.title = "Mi aplicación con FastAPI"

#Para cambiar la version de nuestra aplicación
app.version = "0.0.1"

data_tables = [
    {
        "table_id" : 1,
        "etiqueta" : 'felicidad',
        "title" : "Encuesta Nacional de Bienestar Autorreportado",
        "año_ejecucion" : 2021,
        "Simbolo" : "ENBIARE"
    },
    {
        "table_id" : 2,
        "etiqueta" : 'trabajo_infantil',
        "title" : "Encuesta Nacional de Trabajo Infantil",
        "año_ejecucion" : 2019,
        "Simbolo" : "ENTI"
    },
    {
        "table_id" : 3,
        "etiqueta" : 'gobierno',
        "title" : "Encuesta Nacional de Calidad e Impacto Gubernamental",
        "año_ejecucion" : 2021,
        "Simbolo" : "ENCIG"
    },
    {
        "table_id" : 4,
        "etiqueta" : 'salud',
        "title" : "Encuesta Nacional de Salud y Nutrición",
        "año_ejecucion" : 2018,
        "Simbolo" : "ENSANUT"
    }
]

#los tags nos permite agrupar las rutas de la aplicación
@app.get("/", tags=['Home'])
def read_root():
    return HTMLResponse(
        '<h1 style = "background-color: coral;margin: 50vh auto"> Hola Mundo </h1>'
    ) 

@app.get("/data_tables", tags=['Tablas de datos'])
def get_table():
    return data_tables

@app.get("/data_tables/{table_id}", tags=['Tablas de datos'])
def get_table(table_id: int):
    for item in data_tables:
        if item['table_id'] == table_id:
            return item
    return []

@app.get("/data_tables/", tags=['Tablas de datos'])
def query_table(etiqueta:str, year:int):
    #for item in data_tables:
    #    if item['etiqueta'] == etiqueta and item['año_ejecucion'] == year :
    #        return item
    return [item for item in data_tables if item['etiqueta'] == etiqueta and item['año_ejecucion'] == year ]

Les comparto mi codigo para que los filtre por categoria y por año, sim embargo antes de eso tener en cuenta que en los registros de las peliculas el año debe ser un strin, por lo cual se deben eliminar las comillas ya que a la consulta el parametro de año se solicita como un int:

@app.get('/movies/', tags=['movies'])
def get_movies_by_category_and_year(category: str, year: int):
    filtered_movies = list(filter(lambda x: x['category'] == category and x['year'] == year, movies))
    return filtered_movies if len(filtered_movies) > 0 else "No Datos"

Aqui mi solucion al reto

@app.get('/movie/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    result = []
    for movie in movies:
        if movie['category'] == category and int(movie['year']) == year:
            result.append(movie)
    if result:
        return {'movies': result}
    else:
        raise HTTPException(status_code=404, detail="No se encontraron películas para la categoría y año especificados")

Mi aporte al reto

@app.get("/movies/", tags=["movies"])
def get_movie_by_categorie(category:str):
    movie=list(filter(lambda x: x['category']==category, movies))
    return movie

@app.get("/movies/", tags=["movies"])
def get_movies_by_category(category:str, year:int):
    movies_category = list(filter(lambda movie: movie["category"] == category, movies))
    return movies

Yo lo hice de esta forma:

@app.get('/clientes/',tags = ["clientes"])
def get_clientes_por_pais(pais:str, metodologia:int):
    return list(filter(lambda x: x['pais']==pais and x['metodologia']==metodologia,clientes))

Easy, aquí mi aporte

@app.get('/movies/',tags=['movies'])
def filtrado(category:str,year:int):
    for movie in movies:
        if movie['category']==category:
            return movie
    return []

#Filtrar pelicula por categoria
@app.get("/movies/", tags=["movies"])
def get_movies_by_category(category: str):
    category_movie = list(filter(lambda x: x['category'] == category,movies))
    return"No se encontró la categoria" if not category_movie else category_movie[0]

Reto resulto:

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    return list(filter(lambda x: x['category'] == category ,movies))

Here my solution (I’m using the list of movies in another file and I use import to call it) .😊

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str):
    list_of_movies_by_category = [] 
    
    for item in movies.list_of_movies:
        if item['category'] == category:        
            list_of_movies_by_category.append(item)
            
    return list_of_movies_by_category

Hola,
Hice 2 uno con category y otro con categoria o año.

@app.get('/films/', tags=['Films'])
def get_film_by_category(category: str):
    list_films = []
    for item in films:
        if item['category'] == category:
            list_films.append(item)
    return list_films


@app.get('/films/{category}/{year}', tags=['Films'])
def get_film_by_category_or_year(category: str, year: int):
    list_films = []
    for item in films:
        if item['category'] == category or item['year'] == year:
            list_films.append(item)
    return list_films

Espero sirva

Mi solucion al desafio

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str):
    return list(filter(lambda movie:movie['category']==category, movies))

Les comparto mi solución:

@app.get("/movies/",tags=["movies"])
def getMoviesByCategory(category:str,year:int):
    moviesfound = []
    for item in movies:
        if item["category"]==category:
            moviesfound.append(item)
    return moviesfound

Mi aporte al reto.

def get_movies_de_categorias(category: str, year: str):
    for pelis in movies:
        if pelis["category"] == category and  pelis["year"] == year:
            return pelis
    return []

Voy a colocar una solucion que quizas nadie vio, y es que para que resolver solo el reto, si podemos crear una funcion con que podemos solicitar solo con la categoria, solo con el año, y tambien con ambos, y que incluso nos diga pendejos si no colocamos nada.

@app.get('/movie/', 
        tags=['films'],
        status_code=status.HTTP_200_OK,
        summary="Movie by category our year")
def get_movie_by_category_our_year(category: str=None, year: int=None):
    """
    Obtener película/as por una categoría o año por Query Parameters
    """
    if category is None and year is None:
        raise HTTPException(status_code=404, detail="Coloque algo, no sea pendejo")
        
    elif year is None:
        movie_categorie = [movie for movie in films if movie['category'] == category]
        if not movie_categorie:
            raise HTTPException(status_code=404, detail="Category of movie not found")
        return JSONResponse(content=movie_categorie)
    
    elif category is None:
        movie_year = [movie for movie in films if movie['year'] == str(year)]
        if not movie_year:
            raise HTTPException(status_code=404, detail="Year of movie not found")
        return JSONResponse(content=movie_year)
    
    else:
        movie_categorie_year = [movie for movie in films if (movie['category'] == category and movie['year'] == str(year))]
        if not movie_categorie_year:
            raise HTTPException(status_code=404, detail="Category our year of movie not found")
        return JSONResponse(content=movie_categorie_year)

Esta es mi respuesta al ejercicio planteado por el profesor

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    return [movie for movie in movies if (movie['category'] == category and movie['year'] == year)]

Hola, les dejo el reto de hacer funcionar el filtrado.

@app.get(’/movies/’, tags=[movies])
def get_movies_by_category(category: str, year: int):
for i in movies:
if i [‘category’] == category:
if i [‘year’] == year:
return i
return [‘Tu pelicula no coincide con ninguna en la lista’]

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    _movies = []
    for movie in movies:
        if category == movie['category'] and str(year) == movie['year']:
            print("1")
            if movie not in _movies:
                _movies.append(movie)
    return _movies

Yo estoy haciendo una “página” de Michis(Gatos).

La información que contiene el diccionario es:

• id
• raza
• tamaño promedio
• Variedad de Colores.

El diccionario cuenta con valores del 1 al 36
Para esta parte de parámetros Query se ingresa el id, o la raza, para hacer una búsqueda de sus valores. Y validando la información en el proceso, en caso de que la respuesta no sea la esperada, damos un «aviso»

El código:

# --- Parametros QUERY --- #

@app.get('/cats/', tags=['Cat Breed'])
def get_breed_by_id(id_cat: int = None, breed_cat: str = None):
    '''
    **If you don't remember a breed, don't worry.**
    
    # Use **GET ID** to find a breed of cat
    
    __Choose from 1 to 36__
    '''
    
    ## ---- variables ---- ##
    results = []  # Lista vacía para almacenar los resultados de la búsqueda
    ## ---- variables ---- ## 
    
    # Si se proporciona un id_cat pero no es válido, devuelve 'ID inválido'
    if id_cat is not None and id_cat not in cats:
        return 'Invalid ID'
    
    # Si se proporciona un id_cat, devuelve la información de la raza del gato correspondiente
    elif id_cat is not None:
        value = cats[id_cat]
        
        # Si se proporciona un breed_cat y no coincide con la raza del gato, devuelve "Raza de gato no encontrada"
        if breed_cat is not None and value['breed'].lower() != breed_cat.lower():
            return 'Cat breed not found'
        
        # Devuelve información sobre la raza del gato
        return {
            "breed": value['breed'], 
            "weight": value['weight'], 
            "size": value['size'],
            "color": value['color']
        }
    
    # Si se proporciona un breed_cat, busca y devuelve todas las razas de gatos que coincidan
    elif breed_cat is not None:
        for value in cats.values():
            if value['breed'].lower() == breed_cat.lower():
                results.append(
                    {
                        "id": value["id"],
                        "breed": value["breed"], 
                        "weight": value["weight"], 
                        "size": value["size"], 
                        "color": value["color"]
                    }
                )
        # Si se encuentran razas de gatos, devuelve la lista de resultados
        if len(results) > 0:
            return results
        else:
            # Si no se encuentra ninguna raza de gato, devuelve "Raza de gato no encontrada"
            return "Cat breed not found"
    
    # Si no se proporciona ni id_cat ni breed_cat, devuelve "Proporcione el parámetro ID o breed"
    else:
        return "Please provide either ID or breed parameter"

Código completo en GitHub

@app.get('/movies/',tags= ['Movies'])
def get_movies_by_category(category:str, year:int):
    category_movies = []
    for item in movies:
        if item['category']== category and item['year']== year:
            category_movies.append(item)
    return category_movies

La solicitud del profe realizada por medio filter.

@app.get("/movie/", tags=["movie by category"])
def get_movie_by_category(category: str, year: int):
    new_list = list(filter(lambda movie: movie['category'] == category and movie['year'] == year, movies))
    if len(new_list) > 0:
        return new_list
    else:
        return {"Error": f"movie category {category} and year {year} no exists"}

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: str):
    for item in movies:
        if item["category"] == category and item["year"] == year:
            return item
    return []

El código que proporcionas es una función de Python que utiliza el framework web Flask. La función está diseñada para manejar solicitudes GET HTTP en la ruta “/movies/” y tomar un parámetro de cadena llamado “category” en la URL.

Aquí está la explicación línea por línea del código:

python

<@app.get('/movies/' ,tags=['movies'])> 

Esta línea utiliza el decorador app.get de Flask para especificar que esta función manejará las solicitudes HTTP GET en la ruta “/movies/”. También se especifica la etiqueta ‘movies’ para esta ruta. Es posible que esto se utilice en la documentación o en otros lugares para organizar y etiquetar diferentes rutas en la aplicación.

python

<def get_movies_by_category(category:str):> 

Esta línea define la función get_movies_by_category, que toma un parámetro de cadena llamado “category”. El tipo de datos del parámetro se especifica como str.

python
Copy code

<return list(filter(lambda i :i['category']==category, movies ))> 

Esta línea utiliza la función filter() de Python para filtrar la lista de películas por categoría. El resultado se convierte en una lista y se devuelve. En esta línea, i es una variable temporal que representa cada elemento de la lista de películas. La expresión i[‘category’]==category compara el valor del campo “category” en cada película con el valor del parámetro “category”. Si la comparación es verdadera, la película se incluye en la lista filtrada.

Ten en cuenta que el código que has proporcionado no incluye la definición de la variable “movies”, por lo que no podemos proporcionar información sobre ella. Pero se espera que “movies” sea una lista de objetos que contienen información sobre películas, y cada objeto debe tener un campo llamado “category”.

Usand query para buscar en el diccionario

@app.get('/moviesquery/', tags=['movies'])
def get_movies_by_category(category: int, year: int):
    for item in movies:
        if item["id"] == category and item["year"] == year:
            return item
    return ['Movie no Found']

“en el diccionario cambio el año a entero”

Hello, my solution for this challange

@app.get('/movies/', tags=['Movies'])
def get_Movies_by_category(category: str, year: int):
    movie_category = [item for item in movies if item['category'] == category ]
    return movie_category

Hola, les dejo la solución

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str):
    filtered_movies = list(filter(lambda movie: movie['category']==category, movies))
    return filtered_movies

Una resolucion posible

@app.get(’/movies/’, tags= [‘movies’])
def get_movies_by_category(category: str, year: int):
aux_list = []
for item in movies:
if (item[‘category’].lower() == category.lower()) and item[‘year’] == year:
aux_list.append(item)
return aux_list

según entendí era lo mismo que con el id
así que el mío quedo así

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: int):
    for item in movies:
        if  item['year'] == str(year) or item['category'] == category:
            return item
    return []

esta es la función para filtrar la película ya sea que el año este correcto o que la categoría este correcta y pues obviamente si las dos están correctas también

Mi solución:

@app.get("/movies/", tags = ["movies"])
def filter_category(category: str):
   movie = list(filter(lambda item: item["category"] == category, movies))
   if len(movie) != 0:
      return movie
   else:
      return []

Query funcional con year como argumento:

def get_movies_by_query(category : str, year : str = None): 

    def query_movies(item):
        print("Category => ", category)
        print("Category => ", year)
        return item['year'] == year and item['category'] == category

    if year is None: 
        return list(filter(lambda item: item['category'] == category, movies))
    else:
        return list(filter(query_movies, movies))

Mi solucion:

 return [movie for movie in movies if movie['category'] == category]   

mi aporte para filtrar por nombre o por año ,con cualquiera de las opciones validadoras correcta

<
@app.get('/movies/', tags=['movies']) 
def get_movies_by_category(category:str,year:int):
    for movie in movies:
       if movie["category"]==category or movie["year"]==year:
            return movies
        
    return[]
     


> 

Mi implementación

@app.get('/movie/', tags=['movies'])
def get_movie_by_category(category: str):
    try:
        return [movie for movie in movies if movie['category'] == category][0]
    except IndexError:
        return {'error': 'Category not found'}

Filtered by category and year

@app.get('/movies/', tags=['movies'])
def get_movies_by_category(category: str, year: str = None):
    movies = [movie for movie in movie_list if movie['category'] == category]

    if year:
        movies = [movie for movie in movies if movie['year'] == year]

    return movies

 @app.get("/movies/",tags=["movies"])
def get_movies_by_cat(category:str, year:int):
    #Retorna todas las peliculas con x categoria usando list comprenhension
    return [movie for movie in movies if["category"] ==category]

Lo hice usando las funciones filter y map:

def get_movies_by_category(
    category: str,
    year: int
):
    result = list(filter(lambda x: x["category"] == category, movies))
    result = list(map(lambda movie: movie["title"], result))
    
    return result

• Un parámetro de ruta es una parte específica de la URL que se utiliza para recibir un valor específico, mientras que un parámetro de consulta es una parte de la URL que se utiliza para recibir valores de búsqueda o filtro.

www.mi-app.com/product/{id}

• Un parametro de query es un valor opcional que se coloca en la URL y se utiliza para filtrar resultados o búsquedas en la aplicación. Es un valor adicional que se coloca después de un signo de interrogación ? y se utiliza para especificar un criterio adicional.

www.mi-app.com/product?color=rojo

Mi solucion:

@app.get('/movies/', tags = ['Movies'])
def get_movie_category(category: str, year: int):
	movie = list(filter(lambda x: x["category"] == category and x["year"] == year, movies))
	return movie

Les dejo la solución con Comprehensions:

@app.get('/movies/',tags=['movies'])
def get_movies_by_category(category: str, year: int):
    return [item for item in movies if (item['category']==category or int(item['year'])==year)]    

@app.get('/movies/', tags = ['Movies'])
def get_movies_by_category(category: str):
    filter_movies = list(filter(lambda x: x['category'] == category, movies))
    filter_movies = filter_movies if len(filter_movies) else 'No hay peliculas de esa categoria'
    return filter_movies

@app.get('/movies/', tags=['movies']) #query parameters
def get_movies_by_category(category: str, year: int):
    for item in movies:
        if item['category'] == category:
            return item
    return []

Hola a todos, les compato mi solución al reto de la clase:

Estoy usando routers https://fastapi.tiangolo.com/tutorial/bigger-applications/

El repo es este: https://github.com/cristian-rincon/movies-api

Mi perfil de GitHub por si me quieren seguir: https://github.com/cristian-rincon

@router.get("/genres/{genre}")
def get_movies_by_genre(genre: str):
    movies_by_genre = []
    for movie in movies:
        genres = list(movie["genre"].split("|"))
        if genre.capitalize() in genres:
            movies_by_genre.append(movie)
    return movies_by_genre

Siguiendo el ejemplo anterior, almacenamos en otra lista, los elementos encontrados con la categoria.

@app.get('/movies_category/', tags=['movies'])
def get_movies_by_category(category: str):
    movies_found=[]
    for item in movies:
        if item["category"] == category: 
            movies_found.append(item)
    return movies_found