subido codigo documentado

Author: VforVitorio

app/fastf1.py

@@ -5,52 +5,60 @@
 
 
 class sesion():
+    """Clase que representa una sesión de F1 y permite cargar, filtrar y exportar datos."""
 
     def __init__(self, year, circuit, session, drivers):
+        """Inicializa la sesión con el año, circuito, tipo de sesión y pilotos.
+
+        Args:
+            year (int): Año de la sesión.
+            circuit (str): Nombre del circuito.
+            session (str): Tipo de sesión (FP1, FP2, FP3, Q, R).
+            drivers (list): Lista de códigos de los pilotos.
+        """
         self.year: int = year
         self.circuit: str = circuit
         self.session: str = session
         self.drivers: list = drivers
-        self.session_data: pd.DataFrame = None
-        self.data_filtered_pilots: pd.DataFrame = None
+        self.session_data: pd.DataFrame = None  # Datos completos de la sesión
+        self.data_filtered_pilots: pd.DataFrame = None  # Datos filtrados por piloto
 
     def __str__(self):
-        return f'Cargando la sesion {self.session} del año {self.year}'
+        """Representación en cadena de la sesión."""
+        return f'Cargando la sesión {self.session} del año {self.year}'
 
     async def load_sesion(self):
-        """
-        Carga la sesión especificicada por el usuario
-        """
+        """Carga la sesión especificada por el usuario utilizando la biblioteca fastf1."""
         carga_sesion = fastf1.get_session(
             self.year,
             self.circuit,
             self.session
         )
-        carga_sesion.load()
+        carga_sesion.load()  # Carga los datos de la sesión
 
         if carga_sesion.laps is not None:
-            self.session_data = carga_sesion.laps.reset_index()  # Si hay vueltas, las asignamos
+            # Si hay vueltas registradas, las almacenamos en session_data
+            self.session_data = carga_sesion.laps.reset_index()
         else:
             # Si no hay vueltas, asignamos un DataFrame vacío
             self.session_data = pd.DataFrame()
-        print("Contenido de `SesionState.session_data`:", self.session_data)
+        print("Contenido de `session_data`:", self.session_data)
 
     async def filter_by_driver(self):
+        """Filtra las vueltas por los nombres de los pilotos especificados."""
         if self.session_data is not None and not self.session_data.empty:
-            # Filtrar las vueltas por los nombres de los pilotos
+            # Filtrar las vueltas por los pilotos
             self.data_filtered_pilots = self.session_data[self.session_data['Driver'].isin(
                 self.drivers)]
-            # Reseteo del índice
+            # Resetear el índice
             self.data_filtered_pilots.reset_index(drop=True, inplace=True)
-            print("Contenido de `SesionState.data_filtered_pilots`:",
+            print("Contenido de `data_filtered_pilots`:",
                   self.data_filtered_pilots)
         else:
             print("Error: Los datos de la sesión no están disponibles. Asegúrate de ejecutar `load_sesion` primero.")
 
     async def _drop_tables(self):
-        """
-        Elimina las columnas especificadas en `variables_to_change` del DataFrame `data_filtered_pilots`.
-        """
+        """Elimina columnas innecesarias del DataFrame `data_filtered_pilots`."""
         variables_to_drop = [
             'Sector1SessionTime',
             'Sector2SessionTime',
@@ -67,9 +75,7 @@ async def _drop_tables(self):
             print("Error: No hay datos filtrados disponibles para modificar. Asegúrate de ejecutar `filter_by_driver` primero.")
 
     async def _change_units(self):
-        """
-        Cambia las unidades de tiempo de milisegundos a minutos y segundos.
-        """
+        """Convierte las unidades de tiempo de milisegundos a minutos y segundos."""
         variables_to_change = [
             'Time', 'LapTime',
             'Sector1Time', 'Sector2Time', 'Sector3Time'
@@ -87,12 +93,11 @@ async def _change_units(self):
             print("Error: No hay datos filtrados disponibles para modificar. Asegúrate de ejecutar `filter_by_driver` primero.")
 
     async def data_to_json(self):
-        """
-        Convierte `data_filtered_pilots` a JSON y lo guarda en un archivo.
-        """
+        """Convierte `data_filtered_pilots` a JSON y lo guarda en un archivo."""
         if self.data_filtered_pilots is not None and not self.data_filtered_pilots.empty:
-            # Eliminar los índices llamando a la función _drop_tables
+            # Eliminar columnas innecesarias
             await self._drop_tables()
+            # Cambiar las unidades de tiempo
             await self._change_units()
 
             # Convertir a JSON con la estructura especificada
@@ -123,9 +128,7 @@ async def data_to_json(self):
 
 
 def get_user_input():
-    """
-    Solicita al usuario que introduzca los detalles de la sesión.
-    """
+    """Solicita al usuario que introduzca los detalles de la sesión."""
     year = int(input("Introduce el año de la sesión: "))
     circuit = input("Introduce el circuito de la sesión: ")
     session = input("Introduce el tipo de sesión (FP1, FP2, FP3, Q, R): ")
@@ -136,14 +139,12 @@ def get_user_input():
 
 
 async def main():
-    """
-    Función principal para cargar, filtrar y guardar datos de la sesión.
-    """
+    """Función principal para cargar, filtrar y guardar datos de la sesión."""
     year, circuit, session, drivers = get_user_input()
     f1 = sesion(year, circuit, session, drivers)
     await f1.load_sesion()
     await f1.filter_by_driver()
     await f1.data_to_json()
 
-# Run the main function
+# Ejecutar la función principal
 asyncio.run(main())

app/main.py

@@ -13,8 +13,9 @@
 load_dotenv()
 
 # Configuración de Supabase
-SUPABASE_URL = os.getenv("SUPABASE_URL")
-SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+SUPABASE_URL = os.getenv("SUPABASE_URL")  # URL de Supabase
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")  # Clave de la API de Supabase
+# Crear cliente de Supabase
 supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
 
 # Crear la aplicación FastAPI
@@ -31,7 +32,10 @@ def read_root():
     return {"message": "Bienvenido a la API de gestión de usuarios"}
 
 # Clases Pydantic para ítems y usuarios
+
+
 class Description(BaseModel):
+    """Modelo para la descripción detallada de un ítem."""
     DriverNumber: str
     LapTime: Optional[str] = None
     Sector1Time: Optional[str] = None
@@ -44,25 +48,36 @@ class Description(BaseModel):
 
 
 class Item(BaseModel):
+    """Modelo para un ítem que incluye id, nombre y descripción."""
     id: int
     name: str
     description: Description
 
 
 class ItemCreate(BaseModel):
+    """Modelo para la creación de un nuevo ítem."""
     name: str
     description: Description
 
 
 class UserUpdate(BaseModel):
+    """Modelo para actualizar los datos de un usuario."""
     nick: Optional[str] = None
     name: Optional[str] = None
     surname: Optional[str] = None
     gender: Optional[str] = None
     email: Optional[str] = None
 
 # Funciones auxiliares para manejo de JSON
+
+
 def read_data():
+    """
+    Lee los datos desde un archivo JSON y los procesa.
+
+    Returns:
+        list: Lista de ítems con id y nombre asignados si no existen.
+    """
     try:
         with open("app/data/data_filtered_pilots.json", "r", encoding="utf-8") as file:
             data = json.load(file)
@@ -75,10 +90,18 @@ def read_data():
     except FileNotFoundError:
         return []
 
+
 def write_data(data):
+    """
+    Escribe los datos en un archivo JSON.
+
+    Args:
+        data (list): Lista de ítems a escribir.
+    """
     with open("app/data/data_filtered_pilots.json", "w", encoding="utf-8") as file:
         json.dump(data, file, indent=4)
 
+
 @app.post("/register")
 def register_user(
     nick: str,
@@ -89,9 +112,21 @@ def register_user(
     password: str
 ):
     """
-    endpoint registro usuarios
+    Endpoint para registrar nuevos usuarios.
+
+    Args:
+        nick (str): Apodo del usuario.
+        name (str): Nombre del usuario.
+        surname (str): Apellido del usuario.
+        gender (str): Género del usuario.
+        email (str): Correo electrónico del usuario.
+        password (str): Contraseña del usuario.
+
+    Returns:
+        dict: Mensaje de confirmación.
     """
-    hashed_password = get_password_hash(password)
+    hashed_password = get_password_hash(
+        password)  # Generar hash de la contraseña
     response = supabase.table("users").insert({
         "nick": nick,
         "name": name,
@@ -101,16 +136,26 @@ def register_user(
         "password": hashed_password,
     }).execute()
 
-    print(response)  # Depurar la estructura de la respuesta
+    print(response)  # Imprimir respuesta para depuración
     return {"message": "¡USUARIO CREADO EXITOSAMENTE!"}
 
 
 @app.post("/token", response_model=None)
 def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
     """
-    Crea token para la autenticación
+    Crea un token de acceso para autenticación.
+
+    Args:
+        form_data (OAuth2PasswordRequestForm): Datos del formulario de inicio de sesión.
+
+    Raises:
+        HTTPException: Si las credenciales son inválidas.
+
+    Returns:
+        dict: Token de acceso y tipo de token.
     """
-    response = supabase.table("users").select("*").eq("nick", form_data.username).execute()
+    response = supabase.table("users").select(
+        "*").eq("nick", form_data.username).execute()
     user = response.data[0] if response.data else None
     if not user or not verify_password(form_data.password, user["password"]):
         raise HTTPException(status_code=400, detail="Credenciales inválidas")
@@ -121,23 +166,40 @@ def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
 
 @app.get("/users/me")
 def read_users_me(current_user: str = Depends(get_current_user)):
+    """
+    Obtiene los datos del usuario actual autenticado.
+
+    Args:
+        current_user (str): Correo electrónico del usuario actual.
 
-    response = supabase.table("users").select("*").eq("email", current_user).execute()
+    Raises:
+        HTTPException: Si el usuario no es encontrado.
 
+    Returns:
+        dict: Datos del usuario actual.
+    """
+    response = supabase.table("users").select(
+        "*").eq("email", current_user).execute()
     if not response.data:
         raise HTTPException(status_code=404, detail="Usuario no encontrado")
     return response.data[0]
 
+# Operaciones relacionadas con usuarios desde Supabase
 
 
-##################################################################################################
-
-
-# Operaciones relacionadas con usuarios desde Supabase
 @app.get("/users/supabase", tags=["Usuarios"])
 async def get_users_from_supabase(current_user: str = Depends(get_current_user)):
     """
-    Devuelve todos los usuarios de la base de datos
+    Devuelve todos los usuarios almacenados en Supabase.
+
+    Args:
+        current_user (str): Correo electrónico del usuario actual.
+
+    Raises:
+        HTTPException: Si ocurre un error al obtener los datos.
+
+    Returns:
+        dict: Mensaje y lista de usuarios.
     """
     try:
         supabase_client = SupabaseAPI("users", "*")
@@ -146,28 +208,57 @@ async def get_users_from_supabase(current_user: str = Depends(get_current_user))
             return {"message": "No se encontraron usuarios", "data": []}
         return {"message": "Usuarios obtenidos exitosamente", "data": users}
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error al obtener datos de Supabase: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error al obtener datos de Supabase: {str(e)}")
 
-# TODO cambiar filtro a por nick
 
 @app.put("/users/{email}", tags=["Usuarios"])
 async def update_user(email: str, user_update: UserUpdate, current_user: str = Depends(get_current_user)):
+    """
+    Actualiza un usuario existente.
+
+    Args:
+        email (str): Correo electrónico del usuario a actualizar.
+        user_update (UserUpdate): Datos a actualizar.
+        current_user (str): Correo electrónico del usuario actual.
+
+    Raises:
+        HTTPException: Si no se proporcionan datos o si ocurre un error.
+
+    Returns:
+        dict: Mensaje y datos actualizados.
+    """
     try:
-        update_data = {k: v for k, v in user_update.dict().items() if v is not None}
+        update_data = {k: v for k, v in user_update.dict().items()
+                       if v is not None}
         if not update_data:
-            raise HTTPException(status_code=400, detail="No se proporcionaron datos para actualizar")
-        supabase_client = SupabaseAPI(tabla="users", select="*", data=update_data)
+            raise HTTPException(
+                status_code=400, detail="No se proporcionaron datos para actualizar")
+        supabase_client = SupabaseAPI(
+            tabla="users", select="*", data=update_data)
         response = supabase_client.update_user(email, update_data)
         return {"message": "Usuario actualizado exitosamente", "data": response.data}
     except ValueError as ve:
         raise HTTPException(status_code=404, detail=str(ve))
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error actualizando usuario: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error actualizando usuario: {str(e)}")
+
 
 @app.delete("/users/{nick}", tags=["Usuarios"])
 async def delete_user(nick: str, current_user: str = Depends(get_current_user)):
     """
-    Borra usuario solo si está autenticado
+    Elimina un usuario especificado por su nick.
+
+    Args:
+        nick (str): Apodo del usuario a eliminar.
+        current_user (str): Correo electrónico del usuario actual.
+
+    Raises:
+        HTTPException: Si ocurre un error durante la eliminación.
+
+    Returns:
+        dict: Mensaje de confirmación y datos de la operación.
     """
     try:
         supabase_client = SupabaseAPI(tabla="users", select="*")

app/routes/oauth.py

@@ -7,39 +7,89 @@
 import os
 from dotenv import load_dotenv
 
+# Cargar variables de entorno desde un archivo .env
 load_dotenv()
 
 # Configuración de JWT
-SECRET_KEY = os.getenv("SECRET_KEY")
-ALGORITHM = os.getenv("ALGORITHM")
+SECRET_KEY = os.getenv("SECRET_KEY")  # Clave secreta para firmar el JWT
+ALGORITHM = os.getenv("ALGORITHM")  # Algoritmo utilizado para firmar el JWT
+# Tiempo de expiración del token
 ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES"))
 
 # Configuración de OAuth2
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 # Métodos auxiliares
+
+
 def verify_password(plain_password, hashed_password):
+    """Verifica si la contraseña en texto plano coincide con la contraseña encriptada.
+
+    Args:
+        plain_password (str): Contraseña proporcionada por el usuario.
+        hashed_password (str): Contraseña almacenada en la base de datos.
+
+    Returns:
+        bool: True si las contraseñas coinciden, False en caso contrario.
+    """
     return pwd_context.verify(plain_password, hashed_password)
 
+
 def get_password_hash(password):
+    """Genera el hash de una contraseña.
+
+    Args:
+        password (str): Contraseña en texto plano.
+
+    Returns:
+        str: Hash de la contraseña.
+    """
     return pwd_context.hash(password)
 
+
 def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Crea un token de acceso JWT.
+
+    Args:
+        data (dict): Información a incluir en el token.
+        expires_delta (timedelta, optional): Tiempo hasta la expiración del token. Por defecto es 15 minutos.
+
+    Returns:
+        str: Token JWT codificado.
+    """
     to_encode = data.copy()
-    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15)
+                                  )  # Calcula la fecha de expiración
+    to_encode.update({"exp": expire})  # Agrega la fecha de expiración al token
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY,
+                             algorithm=ALGORITHM)  # Codifica el token
     return encoded_jwt
 
 # Dependencia para obtener al usuario actual
+
+
 def get_current_user(token: str = Depends(oauth2_scheme)):
+    """Obtiene el usuario actual a partir del token proporcionado.
+
+    Args:
+        token (str): Token de acceso JWT.
+
+    Raises:
+        HTTPException: Si el token es inválido o ha expirado.
+
+    Returns:
+        str: Nombre de usuario extraído del token.
+    """
     try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[
+                             ALGORITHM])  # Decodifica el token
+        # Obtiene el nombre de usuario del token
         username: str = payload.get("sub")
         if username is None:
             raise HTTPException(status_code=401, detail="Token inválido")
         return username
     except JWTError:
-        raise HTTPException(status_code=401, detail="Token inválido o expirado")
-
+        raise HTTPException(
+            status_code=401, detail="Token inválido o expirado"
+        )

app/supabase_data.py

@@ -6,7 +6,15 @@
 class SupabaseAPI():
     def __init__(self, tabla, select, data=None):
         """
-        Si no recibe datos para hacer un post data debe estar en None
+        Inicializa la instancia de SupabaseAPI.
+
+        Args:
+            tabla (str): Nombre de la tabla en Supabase.
+            select (str): Campos a seleccionar en las consultas.
+            data (dict, optional): Datos a insertar o actualizar. Por defecto es None.
+
+        Nota:
+            Si no se reciben datos para una operación de inserción o actualización, 'data' debe estar en None.
         """
         # Cargar las variables de entorno desde el archivo .env
         load_dotenv()
@@ -19,41 +27,57 @@ def __init__(self, tabla, select, data=None):
 
         # Verificar si las variables de entorno están definidas
         if not SUPABASE_URL or not SUPABASE_KEY:
-            raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set")
+            raise ValueError(
+                "SUPABASE_URL y SUPABASE_KEY deben estar configuradas")
 
         # Crear el cliente de Supabase utilizando la URL y la clave
         self.supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-        self.tabla = tabla
-        self.select = select
-        self.data = data
+        self.tabla = tabla  # Nombre de la tabla a interactuar
+        self.select = select  # Campos a seleccionar en las consultas
+        self.data = data  # Datos para operaciones de inserción o actualización
 
     def fetch_data(self):
+        """
+        Obtiene datos de la tabla especificada.
+
+        Returns:
+            Response: Respuesta de Supabase con los datos obtenidos.
+        """
         return self.supabase.table(self.tabla).select(self.select).execute()
 
     def post_data(self):
+        """
+        Inserta datos en la tabla especificada.
+
+        Returns:
+            Response: Respuesta de Supabase después de la inserción.
+        """
         response = (
             self.supabase.table(self.tabla)
             .insert(self.data)
             .execute()
         )
         return response
 
-    # TODO:
-    # Crear metodos update y delete para users
     def update_user(self, email: str, updated_data: dict):
         """
-        Actualiza la información de un usuario basándose en su email.
+        Actualiza la información de un usuario basado en su email.
+
         Args:
-            email (str): Email del usuario a actualizar
-            updated_data (dict): Datos a actualizar
+            email (str): Email del usuario a actualizar.
+            updated_data (dict): Diccionario con los datos a actualizar.
+
         Returns:
-            Response: Respuesta de Supabase con los datos actualizados
+            Response: Respuesta de Supabase con los datos actualizados.
+
+        Raises:
+            ValueError: Si no se encuentra el usuario o ocurre un error en la actualización.
         """
         try:
             print(f"Iniciando actualización para usuario con email: {email}")
 
-            # Verificar usuario existente
+            # Verificar si el usuario existe
             check_user = (
                 self.supabase.table(self.tabla)
                 .select("*")
@@ -68,19 +92,19 @@ def update_user(self, email: str, updated_data: dict):
             print(f"Usuario encontrado: {usuario_actual}")
             print(f"Aplicando actualización: {updated_data}")
 
-            # Combinar datos actuales con nuevos datos
+            # Combinar datos actuales con los nuevos datos
             datos_actualizados = {**usuario_actual}
             datos_actualizados.update(updated_data)
 
-            # Realizar actualización usando datos combinados
+            # Realizar la actualización usando los datos combinados
             response = (
                 self.supabase.table(self.tabla)
                 .update(datos_actualizados)
                 .eq("email", email)
                 .execute()
             )
 
-            # Verificar actualización
+            # Verificar si la actualización fue exitosa
             if not response or not response.data:
                 verify = (
                     self.supabase.table(self.tabla)
@@ -100,6 +124,18 @@ def update_user(self, email: str, updated_data: dict):
             raise ValueError(f"Error actualizando usuario: {str(e)}")
 
     def delete_user(self, nick: str):
+        """
+        Elimina un usuario basado en su nick.
+
+        Args:
+            nick (str): Nick del usuario a eliminar.
+
+        Returns:
+            Response: Respuesta de Supabase después de la eliminación.
+
+        Raises:
+            ValueError: Si no se encuentra el usuario o ocurre un error en la eliminación.
+        """
         try:
             response = (
                 self.supabase.table('users')

requirements.txt

@@ -1,5 +1,35 @@
-fastapi
-uvicorn
-pydantic
-supabase-py
-python-dotenv
+annotated-types==0.7.0
+anyio==4.6.2.post1
+bcrypt==4.2.1
+certifi==2024.8.30
+cffi==1.17.1
+charset-normalizer==3.4.0
+click==8.1.7
+cryptography==44.0.0
+defusedxml==0.8.0rc2
+ecdsa==0.19.0
+exceptiongroup==1.2.2
+fastapi==0.115.5
+h11==0.14.0
+idna==3.10
+oauthlib==3.2.2
+passlib==1.7.4
+pyasn1==0.6.1
+pycparser==2.22
+pydantic==2.10.2
+pydantic_core==2.27.1
+PyJWT==2.10.1
+python-jose==3.3.0
+python-multipart==0.0.17
+python3-openid==3.2.0
+requests==2.32.3
+requests-oauthlib==2.0.0
+rsa==4.9
+six==1.16.0
+sniffio==1.3.1
+social-auth-core==4.5.4
+SQLAlchemy==2.0.36
+starlette==0.41.3
+typing_extensions==4.12.2
+urllib3==2.2.3
+uvicorn==0.32.1