main.py

from fastapi import FastAPI, File, UploadFile, HTTPException
import os
import uuid
import shutil
from google import genai
import re
import cv2
import numpy as np
import pytesseract
from PIL import Image
import math
from dotenv import load_dotenv
import uvicorn

# Cargar las variables de entorno desde el archivo .env
load_dotenv()

# Obtener la API key desde las variables de entorno
API_KEY = os.getenv("GENAI_API_KEY")

if not API_KEY:
    raise RuntimeError("Please set the environment variable GENAI_API_KEY with your API key.")

# Initialize Gemini client
client = genai.Client(api_key=API_KEY)

# Initialize FastAPI app
app = FastAPI()

@app.post("/ticket/")
async def analyze_ticket(file: UploadFile = File(...)):
    """
    Recibe un archivo de imagen, lo envía a Gemini Flash para procesarlo
    y devuelve un JSON con fecha, token y categoría.
    """
    # Guardar el archivo temporalmente
    temp_dir = "/tmp"
    os.makedirs(temp_dir, exist_ok=True)
    unique_name = f"{uuid.uuid4()}_{file.filename}"
    temp_path = os.path.join(temp_dir, unique_name)

    try:
        # Escribir el contenido en disco
        with open(temp_path, "wb") as buffer:
            shutil.copyfileobj(file.file, buffer)

        # Subir la imagen a Gemini
        uploaded = client.files.upload(file=temp_path)

        # Definir el prompt con instrucciones
        prompt = """
Necesito que realices las siguientes tareas sobre la imagen del ticket que te estoy enviando:

1. **Rotación automática**: Gira la imagen a la posición correcta para poder analizarla correctamente.
2. **Extracción de fecha**: Busca una fecha en el ticket. Puede tener distintos formatos como DD-MM-YYYY, YYYY/MM/DD, etc., pero necesito que la regreses en el siguiente formato: DD/MM/AAAA.
3. **Extracción del token de facturación**: Este puede aparecer con el texto \"Token\" o \"Token de facturación\".
4. **Clasificación de categoría**: Clasifica la imagen de acuerdo con las siguientes categorías:
   - **Boleto de autobús**: si contiene palabras como "pasajero", "destino", "primera plus", "servicio económico", "coordinados", "flecha amarilla", "unebus".
   - **Ticket de compra de alimentos**: si contiene palabras relacionadas con marcas como "subway", "doggis", "barrio chick'en", "burger king".
   - **Ticket de paquetería flecha amarilla**: si se menciona explícitamente "flecha amarilla" en contexto de mensajería o paquetería.
   - **Ticket de envío primera Plus**: si se menciona explícitamente "envíos primera plus".

    Devuelveme unicamente la categoria, el token y la fecha, si encuentras algo diferente a lo que te pido, no me lo regreses. Ignora cualquier otro texto que no sea el resultado de las tareas que te he pedido.
"""

        # Llamar al modelo de Gemini Flash
        response = client.models.generate_content(
            model="gemini-2.0-flash",
            contents=[uploaded, prompt]
        )

        print("Respuesta cruda de Gemini:")
        print(response.text)

        result= parse_text_response_ticket(response.text)

        print("Respuesta parseada:")
        print(result)

        return result

    except Exception as e:
        import traceback
        traceback.print_exc()  # muestra el error completo en consola
        raise HTTPException(status_code=500, detail=f"Error interno: {str(e)}")
    finally:
        # Eliminar el archivo temporal
        try:
            os.remove(temp_path)
        except OSError:
            pass

def parse_text_response_ticket(text: str) -> dict:
    categoria = re.search(r"\*\*Categoría:\*\*\s*(.+)", text)
    token = re.search(r"\*\*Token:\*\*\s*(.+)", text)
    fecha = re.search(r"\*\*Fecha:\*\*\s*(.+)", text)

    return {
        "categoría": categoria.group(1) if categoria else None,
        "token": token.group(1) if token else None,
        "fecha": fecha.group(1) if fecha else None
    }


@app.post("/fiscal/")
async def analyze_fiscal(file: UploadFile = File(...)):
    """
    Recibe un archivo, lo envía a Gemini Flash para procesarlo
    y devuelve los datos de identificación del constribuyente y datos de la ubicación.
    """
    
    temp_dir = "/tmp"
    os.makedirs(temp_dir, exist_ok=True)
    unique_name = f"{uuid.uuid4()}_{file.filename}"
    temp_path = os.path.join(temp_dir, unique_name)

    try:
        # Escribir el contenido en disco
        with open(temp_path, "wb") as buffer:
            shutil.copyfileobj(file.file, buffer)

        # Subir la imagen a Gemini
        uploaded = client.files.upload(file=temp_path)

        # Definir el prompt con instrucciones
        prompt = """
Eres un extractor de datos fiscales. Recibirás un archivo (PDF o imagen JPG/PNG/JPEG) y debes devolver las siguientes claves (en este orden y con este nombre exacto). Si no encuentras valor para una clave, asigna null. No incluyas nada más.

  - **RFC**
  - **Denominación/razón social**
  - **Régimen Capital**
  - **Nombre Comercial**
  - **Fecha de inicio de operaciones**
  - **Estatus del padrón**
  - **Fecha de último cambio de estado**
  - **Codigo postal**
  - **tipo de vialidad**
  - **nombre de vialidad**
  - **numero exterior**
  - **numero interior**
  - **nombre de la colonia**
  - **nombre de la localidad**
  - **nombre del municipio o demarcacion territorial**
  - **nombre de la entidad federativa**
  - **entre calle**
  - **y calle**
  - **correo electronico**
]

Ejemplo de salida:

  RFC: ABC123456T78
  Denominación/razón social: Mi Empresa S.A. de C.V.
  Régimen Capital: null
  Nombre Comercial: La Tiendita
  Fecha de inicio de operaciones: 01/03/2015
  Estatus del padrón": Vigente
  Fecha de último cambio de estado: 10/10/2020
  Codigo postal: 01234
  tipo de vialidad: Avenida
  nombre de vialidad: Insurgentes
  numero exterior: 123
  numero interior: null
  nombre de la colonia: Del Valle
  nombre de la localidad: null
  nombre del municipio o demarcacion territorial: Benito Juárez
  nombre de la entidad federativa: Ciudad de México
  entre calle: Patricio Sanz
  y calle: Amores
  correo electronico: contacto@miempresa.com

  no quiero la respuesta en formato JSON, ni en otro formato diferente a texto plano. No quiero que me digas que has terminado de procesar la imagen, ni que me digas que has encontrado los datos
  
    Devuelveme unicamente lo que te pedi, si encuentras algo diferente a lo que te pido, no me lo regreses. Ignora cualquier otro texto que no sea el resultado de las tareas que te he pedido.
"""

        # Llamar al modelo de Gemini Flash
        response = client.models.generate_content(
            model="gemini-2.0-flash",
            contents=[uploaded, prompt]
        )

        print("Respuesta cruda de Gemini:")
        print(response.text)

        result = parse_text_response_fiscal(response.text)

        print("Respuesta parseada:")
        print(result)

        return result

    except Exception as e:
        import traceback
        traceback.print_exc()  # muestra el error completo en consola
        raise HTTPException(status_code=500, detail=f"Error interno: {str(e)}")
    finally:
        # Eliminar el archivo temporal
        try:
            os.remove(temp_path)
        except OSError:
            pass

def parse_text_response_fiscal(text: str) -> dict:
    RFC = re.search(r"RFC:\s*(.+)",text)
    Denominacion = re.search(r"Denominación/razón social:\s*(.+)",text)
    regimen = re.search(r"Régimen Capital:\s*(.+)",text)
    nombre_comercial = re.search(r"Nombre Comercial:\s*(.+)",text)
    fecha_inicio = re.search(r"Fecha de inicio de operaciones:\s*(.+)", text)   
    estatus = re.search(r"Estatus del padrón:\s*(.+)", text)
    fecha_cambio = re.search(r"Fecha de último cambio de estado:\s*(.+)", text)
    cp = re.search(r"Codigo postal:\s*(.+)", text)
    tipo_vialidad = re.search(r"tipo de vialidad:\s*(.+)", text)
    nombre_vialidad = re.search(r"nombre de vialidad:\s*(.+)", text)
    numero_exterior = re.search(r"numero exterior:\s*(.+)", text)
    numero_interior = re.search(r"numero interior:\s*(.+)", text)
    nombre_colonia = re.search(r"nombre de la colonia:\s*(.+)", text)
    nombre_localidad = re.search(r"nombre de la localidad:\s*(.+)", text)
    nombre_municipio = re.search(r"nombre del municipio o demarcacion territorial:\s*(.+)", text)
    nombre_entidad = re.search(r"nombre de la entidad federativa:\s*(.+)", text)
    entre_calle = re.search(r"entre calle:\s*(.+)", text)
    y_calle = re.search(r"y calle:\s*(.+)", text)
    correo = re.search(r"correo electronico:\s*(.+)", text)

    return {
        "RFC": RFC.group(1) if RFC else None,
        "Denominación/razón social": Denominacion.group(1) if Denominacion else None,
        "Régimen Capital": regimen.group(1) if regimen else None,
        "Nombre Comercial": nombre_comercial.group(1) if nombre_comercial else None,
        "Fecha de inicio de operaciones": fecha_inicio.group(1) if fecha_inicio else None,
        "Estatus del padrón": estatus.group(1) if estatus else None,
        "Fecha de último cambio de estado": fecha_cambio.group(1) if fecha_cambio else None,
        "Codigo postal": cp.group(1) if cp else None,
        "tipo de vialidad": tipo_vialidad.group(1) if tipo_vialidad else None,
        "nombre de vialidad": nombre_vialidad.group(1) if nombre_vialidad else None,
        "numero exterior": numero_exterior.group(1) if numero_exterior else None,
        "numero interior": numero_interior.group(1) if numero_interior else None,
        "nombre de la colonia": nombre_colonia.group(1) if nombre_colonia else None,
        "nombre de la localidad": nombre_localidad.group(1) if nombre_localidad else None,
        "nombre del municipio o demarcacion territorial": nombre_municipio.group(1) if nombre_municipio else None,
        "nombre de la entidad federativa": nombre_entidad.group(1) if nombre_entidad else None,
        "entre calle": entre_calle.group(1) if entre_calle else None,
        "y calle": y_calle.group(1) if y_calle else None,
        "correo electronico": correo.group(1) if correo else None
    }


def correct_orientation(image):
    """
    Detecta la orientación usando Tesseract y rota la imagen para que el texto quede horizontal.
    """
    # Ejecutamos OSD sobre la imagen (mejor si está en color o escala de grises, no binarizada).
    osd = pytesseract.image_to_osd(image)
    rotation_angle = 0

    # Buscamos la línea donde aparece 'Rotate:'
    for line in osd.split('\n'):
        if "Rotate:" in line:
            rotation_angle = int(line.split(':')[1].strip())
            break
    
    # Si Tesseract indica que la imagen está rotada, la corregimos
    if rotation_angle != 0:
        (h, w) = image.shape[:2]
        center = (w // 2, h // 2)
        # Rota en sentido contrario (negativo) al ángulo detectado
        M = cv2.getRotationMatrix2D(center, -rotation_angle, 1.0)
        image = cv2.warpAffine(image, M, (w, h), 
                               flags=cv2.INTER_CUBIC, 
                               borderMode=cv2.BORDER_REPLICATE)
    return image

def correct_skew(image):
    """
    Detecta y corrige la inclinación (skew) de la imagen para que el texto quede recto.
    """
    # Convertir a escala de grises si la imagen está en color
    if len(image.shape) == 3:
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    else:
        gray = image.copy()
    
    # Aplicar umbral para binarizar
    _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # Detectar bordes
    edges = cv2.dilate(thresh, None)
    
    # Usar transformada de Hough para detectar líneas
    lines = cv2.HoughLinesP(edges, 1, np.pi/180, 100, minLineLength=100, maxLineGap=10)
    
    # Si no se detectan líneas, devolver la imagen original
    if lines is None:
        return image
    
    angles = []
    
    # Calcular ángulos de las líneas
    for line in lines:
        x1, y1, x2, y2 = line[0]
        # Si la línea no es vertical
        if x2 - x1 != 0:
            angle = math.atan2(y2 - y1, x2 - x1) * 180.0 / np.pi
            # Consideramos solo líneas que estén cercanas a la horizontal
            if abs(angle) < 45:
                angles.append(angle)
    
    # Si no hay ángulos válidos, devolver la imagen original
    if not angles:
        return image
    
    # Calcular el ángulo promedio de inclinación
    skew_angle = np.median(angles)
    
    # Corregir la inclinación
    (h, w) = image.shape[:2]
    center = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(center, skew_angle, 1.0)
    corrected = cv2.warpAffine(image, M, (w, h), 
                             flags=cv2.INTER_CUBIC, 
                             borderMode=cv2.BORDER_REPLICATE)
    
    return corrected

def apply_roi(image):
    """
    Aplica una región de interés (ROI) a la imagen usando proporciones negativas.
    La ROI se define como la mitad inferior de la imagen, usando todo el ancho.
    
    Parámetros:
    -----------
    image : np.ndarray
        Imagen de entrada (después de corregir la orientación).
    
    Retorna:
    --------
    roi : np.ndarray
        Imagen recortada a la región de interés.
    """
    # Obtener dimensiones de la imagen
    h, w = image.shape[:2]
    
    # Definir proporciones para la ROI
    x_start = int(w * 0.2)          # Desde el inicio del ancho
    x_end = int(w * 0.9)            # Hasta el final del ancho
    y_start = int(h * 0.1)  # Desde la mitad de la altura
    y_end = h            # Hasta el final de la altura
    
    # Recortar la imagen a la ROI
    roi = image[y_start:y_end, x_start:x_end]
    
    return roi

def noise_removal(image):
    import numpy as np
    kernel = np.ones((1, 1), np.uint8)
    image = cv2.dilate(image, kernel, iterations=1)
    kernel = np.ones((1, 1), np.uint8)
    image = cv2.erode(image, kernel, iterations=1)
    image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
    image = cv2.medianBlur(image, 3)
    return (image)

def normalize_resolution(image, target_dpi=300, target_resolution=(1920, 1080)):
    """
    Normaliza la resolución de la imagen a 500 ppp (DPI) y redimensiona a una resolución en píxeles específica.
    
    Args:
        image: Imagen en formato numpy array (formato OpenCV)
        target_dpi: Resolución objetivo en DPI (por defecto 500)
        target_resolution: Resolución objetivo en píxeles (por defecto 1920x1080)
        
    Returns:
        Imagen normalizada a la resolución especificada y redimensionada.
    """
    # Convertir imagen de OpenCV a formato PIL para trabajar con DPI
    if len(image.shape) == 3:
        pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    else:
        pil_image = Image.fromarray(image)
    
    # Verificar si la imagen tiene información de DPI
    try:
        current_dpi_x, current_dpi_y = pil_image.info.get('dpi', (72, 72))
    except:
        current_dpi_x, current_dpi_y = 72, 72
    
    # Si ya está en la resolución deseada, devolver la imagen original
    if int(current_dpi_x) == target_dpi and int(current_dpi_y) == target_dpi:
        pil_image = pil_image.resize(target_resolution, Image.LANCZOS)
        return np.array(pil_image)

    # Calcular el factor de escala para DPI
    scale_x = target_dpi / current_dpi_x
    scale_y = target_dpi / current_dpi_y
    
    # Calcular las nuevas dimensiones basadas en DPI
    new_width = int(pil_image.width * scale_x)
    new_height = int(pil_image.height * scale_y)
    
    # Redimensionar la imagen usando un algoritmo de alta calidad
    resized_pil = pil_image.resize((new_width, new_height), Image.LANCZOS)
    
    # Establecer el DPI en la imagen
    resized_pil.info['dpi'] = (target_dpi, target_dpi)
    
    # Redimensionar a la resolución deseada
    resized_pil = resized_pil.resize(target_resolution, Image.LANCZOS)
    
    # Convertir de nuevo a formato OpenCV
    if len(image.shape) == 3:
        normalized_image = cv2.cvtColor(np.array(resized_pil), cv2.COLOR_RGB2BGR)
    else:
        normalized_image = np.array(resized_pil)
    
    return normalized_image

def process_image(image_path, output_path):
    """
    Procesa una imagen aplicando corrección de orientación, 
    corrección de inclinación y normalización de resolución.
    
    Args:
        image_path: Ruta de la imagen a procesar
        output_path: Ruta donde guardar la imagen procesada
    """
    # Cargar la imagen
    image = cv2.imread(image_path)
    
    if image is None:
        raise ValueError(f"No se pudo cargar la imagen desde {image_path}")
    
    # Aplicar corrección de orientación
    print("Corrigiendo orientación...")
    oriented_image = correct_orientation(image)
    
    # Aplicar corrección de inclinación
    print("Corrigiendo inclinación...")
    deskewed_image = correct_skew(oriented_image)
    
    # Normalizar resolución a 500 DPI
    print("Normalizando resolución...")
    normalized_image = normalize_resolution(deskewed_image, target_dpi=600)

    # Aplicar la región de interés (ROI)
    image = apply_roi(normalized_image)

    # Convertir a escala de grises
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Aumentar la resolución (factor de escalado)
    #gray = cv2.resize(gray, None, fx=2, fy=2, interpolation=cv2.INTER_LINEAR)

    # Aumentar nitidez con Unsharp Mask
    #    - Se crea una versión desenfocada con GaussianBlur
    #    - Se combinan (imagen - desenfocada) para resaltar bordes
    #gaussian = cv2.GaussianBlur(gray, (0, 0), 3)
    #sharpened = cv2.addWeighted(gray, 2.0, gaussian, -1.0, 0)  # Incrementa el peso de la imagen original

    # Binarización
    _, binarized = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

    # Reducir ruido (fastNlMeansDenoising) con h moderado para no borrar detalles
    denoised = cv2.fastNlMeansDenoising(binarized, None, h=10, templateWindowSize=7, searchWindowSize=21)
    #denoised= noise_removal(binarized)

     # Operaciones morfológicas para eliminar trazos finos
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (4,3))  # Kernel más grande
    # Aplicamos OPENING (erosión seguida de dilatación) para eliminar ruido fino
    opened = cv2.morphologyEx(denoised, cv2.MORPH_OPEN, kernel)
    
    # Opcional: Dilatación para reforzar caracteres restantes
    kernel_dilate = cv2.getStructuringElement(cv2.MORPH_RECT, (3,4))
    cleaned = cv2.dilate(opened, kernel_dilate, iterations=1)
    kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (4,4))
    cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_OPEN, kernel)

    # Aplicar detector de bordes Canny
    edges = cv2.Canny(cleaned, 50, 150)

    # Combinar bordes detectados con la imagen binarizada
    reinforced = cv2.addWeighted(cleaned, 0.8, edges, 0.2, 0)  # Ajusta los pesos (0.8 y 0.2)
    
    # Guardar la imagen procesada
    cv2.imwrite(output_path, reinforced)
    print(f"Imagen procesada guardada en {output_path}")

    # Realizar OCR con Tesseract
    #     Prueba distintos modos psm (3, 6, 11) si no reconoce bien.
    config = '--oem 1 --psm 6 -c tessedit_char_whitelist=Token:token:0123456789'
    text = pytesseract.image_to_string(cleaned, lang='spa', config=config)

    configContext = '--oem 1 --psm 6'
    Context = pytesseract.image_to_string(denoised, lang='spa', config=configContext)
    print(Context)

    Category=classify_text(Context)
    Token=getToken(text)
    Date=getDate(text)

    return Category,Token,Date

def process_image_array(image):
    # Aplicar corrección de orientación
    print("Corrigiendo orientación...")
    oriented_image = correct_orientation(image)
    
    # Aplicar corrección de inclinación
    print("Corrigiendo inclinación...")
    deskewed_image = correct_skew(oriented_image)
    
    # Normalizar resolución a 600 DPI
    print("Normalizando resolución...")
    normalized_image = normalize_resolution(deskewed_image, target_dpi=600)
    
    # Aplicar la región de interés (ROI)
    image_roi = apply_roi(normalized_image)
    
    # Convertir a escala de grises
    gray = cv2.cvtColor(image_roi, cv2.COLOR_BGR2GRAY)
    
    # Binarización
    _, binarized = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
    
    # Reducir ruido
    denoised = cv2.fastNlMeansDenoising(binarized, None, h=10, templateWindowSize=7, searchWindowSize=21)
    
    # Operaciones morfológicas
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (4,3))
    opened = cv2.morphologyEx(denoised, cv2.MORPH_OPEN, kernel)
    kernel_dilate = cv2.getStructuringElement(cv2.MORPH_RECT, (3,4))
    cleaned = cv2.dilate(opened, kernel_dilate, iterations=1)
    kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (4,4))
    cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_OPEN, kernel)
    
    # Realizar OCR
    config = '--oem 1 --psm 6 -c tessedit_char_whitelist=Token:token:0123456789'
    text = pytesseract.image_to_string(cleaned, lang='spa', config=config)
    
    configContext = '--oem 1 --psm 6'
    Context = pytesseract.image_to_string(denoised, lang='spa', config=configContext)
    print(Context)
    
    Category = classify_text(Context)
    Token = getToken(text)
    Date = getDate(text)
    
    return Category, Token, Date

def classify_text(text):
    """
    Clasifica el texto extraído en una de las categorías:
    'Boleto de autobus', 'Paqueteria', o 'Comida'.

    Parámetros:
    -----------
    text : str
        Texto extraído por OCR.

    Retorna:
    --------
    category : str
        Categoría a la que pertenece el texto.
    """
    # Palabras clave para cada categoría
    keywords_boletos = ["servicio economico", "pasajero", "pasajeros", "boleto", "autobus", "autobuses", "autotransportes", "primeraplus"]
    keywords_paqueteria = ["paqueteria", "mensajeria"]
    keywords_comida = ["comida", "restaurante", "menu", "platillo"]

    # Convertir el texto a minúsculas para comparación insensible a mayúsculas
    text_lower = text.lower()

    # Verificar si el texto contiene palabras clave de cada categoría
    if any(keyword.lower() in text_lower for keyword in keywords_boletos):
        return "Boleto de autobus"
    elif any(keyword.lower() in text_lower for keyword in keywords_paqueteria):
        return "Paqueteria"
    elif any(keyword.lower() in text_lower for keyword in keywords_comida):
        return "Comida"
    else:
        return "Sin categoría"

def getDate(text):
    """
    Obtiene la cadena numerica de la fecha y elimina
    el error de lectura del OCR por medio de expresiones regulares, 
    sustituyendo 7 por /.

    Parámetros:
    -----------
    text : str
        Texto extraído por OCR.

    Retorna:
    --------
    corrected_date : str
        Fecha con el formato solicitado.
    """
# Dividir el texto en líneas
    lines = text.splitlines()
    # Buscar información en las líneas
    for line in lines:
        # Buscar la línea que coincide con el patrón
        if re.search(r'\d{2}7\d{2}7\d', line):
            matched_line = re.findall(r'\d+', line)
    print("matched_line:") 
    print(matched_line)
    if matched_line:
            corrected_date = re.sub(r'(?<=\d)7(?=\d)', '/', ''.join(matched_line))
            print("Fecha corregida:")
            print(corrected_date)
    return corrected_date

def getToken(text):
    """
    Obtiene la cadena numerica del token deteactdo y elimina
    el error de lectura del OCR por medio de expresiones regulares.

    Parámetros:
    -----------
    text : str
        Texto extraído por OCR.

    Retorna:
    --------
    token_numbers : str
        Cadena numerica del token detectado.
    """
    # Dividir el texto en líneas
    lines = text.splitlines()
    # Buscar información en las líneas
    for line in lines:
        # Buscar números en la línea que contiene "token"
        if "token" in line.lower():
            token_numbers = re.findall(r'\d+', line)

    print("token_numbers:") 
    print(token_numbers)
    if token_numbers:
            token_numbers = [re.sub(r'[\[\]\D]', '', token) for token in token_numbers]
            print("Token limpio:")
            print(token_numbers)
    return token_numbers

@app.post("/ticketmanual/")
async def procesar_imagen(file: UploadFile = File(...)):
    # Leer archivo recibido y convertirlo a un array de numpy
    contents = await file.read()
    np_arr = np.frombuffer(contents, np.uint8)
    image = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
    
    if image is None:
        return {"error": "No se pudo decodificar la imagen"}
    
    try:
        category, token, date = process_image_array(image)
        
        response = {
            "categoria": category,
            "token": token,
            "fecha": date
        }
        return response
    except Exception as e:
        return {"error": f"Error al procesar la imagen: {e}"}

if __name__ == "__main__":
    # Ejecutar el servidor FastAPI usando uvicorn
    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)