st.file_uploader, st.camera_input, st.audio_input y st.feedback

st.file_uploader: carga de archivos

st.file_uploader es el componente que permite al usuario seleccionar archivos desde su sistema local para procesarlos en la aplicación. El archivo se transmite al servidor de Streamlit y queda disponible como un objeto en memoria (similar a BytesIO), lo que permite leerlo directamente con bibliotecas como Pandas, PIL o pypdf sin guardarlo previamente en disco.

El parámetro type restringe los tipos de archivo aceptados, mostrando un filtro en el diálogo de selección del sistema operativo:

import streamlit as st
import pandas as pd

# Carga de un solo archivo
archivo = st.file_uploader("Sube tu dataset", type=["csv", "xlsx", "parquet"])

if archivo is not None:
    st.success(f"Archivo recibido: **{archivo.name}** ({archivo.size:,} bytes)")

    # Procesar según el tipo de archivo
    if archivo.name.endswith(".csv"):
        df = pd.read_csv(archivo)
    elif archivo.name.endswith(".xlsx"):
        df = pd.read_excel(archivo, engine="openpyxl")
    elif archivo.name.endswith(".parquet"):
        df = pd.read_parquet(archivo)

    st.dataframe(df.head(10))
    st.write(f"Dimensiones: {df.shape[0]:,} filas × {df.shape[1]} columnas")

El tamaño máximo de archivo por defecto es de 200 MB. Este límite se puede ajustar en el archivo de configuración .streamlit/config.toml con la clave server.maxUploadSize.

flowchart TD
    A[Captura desde usuario] --> B{"Origen?"}
    B -->|Archivo local| C[st.file_uploader CSV XLSX PDF]
    B -->|Camara web| D[st.camera_input PNG bytes]
    B -->|Microfono| E[st.audio_input WAV bytes]
    B -->|Valoración| F[st.feedback thumbs faces stars]
    C --> G{"Múltiples?"}
    G -->|No| H[Devuelve UploadedFile]
    G -->|Si accept_multiple_files| I[Devuelve List UploadedFile]
    H --> J[pandas.read_csv directo]
    I --> J
    D --> K[PIL Image.open]
    E --> L[Procesar con whisper o pydub]
    F --> M[Almacena rating en BD]
    J --> N[Dashboard del usuario]

Carga múltiple de archivos

El parámetro accept_multiple_files=True permite seleccionar varios archivos a la vez. El widget devuelve una lista de objetos, que se puede iterar para procesar cada archivo de forma independiente o combinarlos en un solo DataFrame:

import streamlit as st
import pandas as pd

archivos = st.file_uploader(
    "Sube uno o más archivos CSV",
    type="csv",
    accept_multiple_files=True
)

if archivos:
    dataframes = []
    for archivo in archivos:
        df = pd.read_csv(archivo)
        df["_origen"] = archivo.name
        dataframes.append(df)

    df_combinado = pd.concat(dataframes, ignore_index=True)
    st.success(f"Combinados {len(archivos)} archivos: {len(df_combinado):,} registros totales.")
    st.dataframe(df_combinado.head(20))

Carga de imágenes con procesamiento

import streamlit as st
from PIL import Image
import numpy as np

imagen = st.file_uploader("Sube una imagen", type=["png", "jpg", "jpeg", "webp"])

if imagen is not None:
    img = Image.open(imagen)

    col1, col2 = st.columns(2)
    with col1:
        st.subheader("Original")
        st.image(img, use_container_width=True)
        st.caption(f"Tamaño: {img.size[0]}×{img.size[1]} px | Modo: {img.mode}")

    with col2:
        st.subheader("Escala de grises")
        img_gris = img.convert("L")
        st.image(img_gris, use_container_width=True)

    # Estadísticas del array
    arr = np.array(img)
    st.write(f"Valores: min={arr.min()}, max={arr.max()}, media={arr.mean():.1f}")

Carga de PDF con lectura de texto

import streamlit as st

pdf = st.file_uploader("Sube un PDF", type="pdf")

if pdf is not None:
    try:
        import pypdf
        lector = pypdf.PdfReader(pdf)
        n_paginas = len(lector.pages)
        st.info(f"PDF cargado: {n_paginas} páginas.")

        pagina_sel = st.slider("Página a mostrar", 1, n_paginas, 1)
        texto = lector.pages[pagina_sel - 1].extract_text()
        st.text_area(f"Contenido de la página {pagina_sel}", value=texto, height=300)
    except ImportError:
        st.error("Instala pypdf: pip install pypdf")

st.camera_input: captura de imagen desde cámara web

st.camera_input activa la cámara web del dispositivo y permite al usuario capturar una imagen directamente desde la interfaz de la aplicación. El componente muestra una vista previa en directo y un botón de captura. La imagen resultante se devuelve como un objeto UploadedFile, compatible con PIL y NumPy para su procesamiento inmediato:

import streamlit as st
from PIL import Image
import numpy as np

st.title("Análisis de imagen en tiempo real")

foto = st.camera_input("Captura una imagen con tu cámara")

if foto is not None:
    img = Image.open(foto)
    st.image(img, caption="Imagen capturada", use_container_width=True)

    # Análisis básico
    arr = np.array(img)
    r_media = arr[:, :, 0].mean()
    g_media = arr[:, :, 1].mean()
    b_media = arr[:, :, 2].mean()

    col1, col2, col3 = st.columns(3)
    col1.metric("Canal Rojo (R)", f"{r_media:.1f}")
    col2.metric("Canal Verde (G)", f"{g_media:.1f}")
    col3.metric("Canal Azul (B)", f"{b_media:.1f}")

st.audio_input: grabación de audio desde micrófono

import streamlit as st

st.title("Grabadora de audio")

audio_grabado = st.audio_input("Graba un mensaje de voz")

if audio_grabado is not None:
    st.audio(audio_grabado)
    st.success(f"Audio grabado: {audio_grabado.size:,} bytes")

    # Guardar el audio (en un flujo real, se enviaría a una API de transcripción)
    st.download_button(
        "Descargar audio",
        data=audio_grabado,
        file_name="grabacion.wav",
        mime="audio/wav"
    )

st.feedback: valoraciones del usuario

import streamlit as st

st.title("¿Te ha sido útil este análisis?")

# Thumbs up/down
valoracion_thumbs = st.feedback("thumbs")
if valoracion_thumbs == 1:
    st.success("¡Gracias! Nos alegra que haya sido útil.")
elif valoracion_thumbs == 0:
    st.info("Gracias por tu opinión. Seguiremos mejorando.")

# Caritas (emoji)
valoracion_caras = st.feedback("faces")

# Estrellas (1-5)
st.markdown("### Valora el modelo")
estrellas = st.feedback("stars")
if estrellas is not None:
    st.write(f"Has dado {estrellas + 1} estrella(s) de 5.")

st.feedback devuelve None si el usuario no ha interactuado, 0 para la primera opción (pulgar abajo / cara triste / 1 estrella) e incrementa en 1 por cada nivel. Las tres modalidades son "thumbs", "faces" y "stars".

La combinación de st.feedback con st.session_state permite acumular valoraciones a lo largo de la sesión y calcular estadísticas agregadas, como la puntuación media o el porcentaje de feedback positivo, que pueden mostrarse en un panel de métricas.