awswaf_classification.py

import os
import base64
import requests
from dotenv import load_dotenv

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

# Configuracion de la API de CapSolver
CAPSOLVER_API_KEY = os.getenv("CAPSOLVER_API_KEY")
CREATE_TASK_URL = "https://api.capsolver.com/createTask"

# Tipos de preguntas para clasificacion AWS WAF
# Preguntas tipo cuadricula (soporta hasta 9 imagenes)
GRID_QUESTIONS = [
    "aws:grid:bed",        # cama
    "aws:grid:bag",        # bolsa
    "aws:grid:hat",        # sombrero
    "aws:grid:chair",      # silla
    "aws:grid:bucket",     # cubo
    "aws:grid:curtain",    # cortina
    "aws:grid:mop",        # fregona
    "aws:grid:clock",      # reloj
    "aws:grid:suitcase",   # maleta
    "aws:grid:binocular",  # binoculares
    "aws:grid:cooking pot" # olla
]

# Tipo ciudad de coche de juguete (soporta 1 imagen, marca el punto final del camino del coche)
TOYCARCITY_QUESTIONS = [
    "aws:toycarcity:carcity"
]


def solve_awswaf_classification(images, question):
    """
    Clasificar desafios de imagenes de AWS WAF.

    Args:
        images: Lista de imagenes codificadas en base64 (hasta 9 para cuadricula, 1 para toycarcity)
        question: Tipo de pregunta (ver GRID_QUESTIONS o TOYCARCITY_QUESTIONS)

    Returns:
        Solucion conteniendo objetos (cuadricula) o coordenadas de caja (toycarcity)
    """
    if not images:
        raise ValueError("Se debe proporcionar al menos una imagen")

    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "AwsWafClassification",
            "images": images if isinstance(images, list) else [images],
            "question": question
        }
    }

    # AwsWafClassification devuelve resultado directamente (no necesita polling)
    response = requests.post(CREATE_TASK_URL, json=payload)
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Error al resolver: {result.get('errorDescription')}")

    return result.get("solution", {})


def load_images_as_base64(image_paths):
    """Funcion auxiliar para cargar multiples imagenes como base64."""
    images = []
    for path in image_paths:
        with open(path, "rb") as f:
            images.append(base64.b64encode(f.read()).decode("utf-8"))
    return images


def main():
    if not CAPSOLVER_API_KEY:
        print("Error: CAPSOLVER_API_KEY no encontrada en el archivo .env")
        print("Por favor, crea un archivo .env con tu clave API:")
        print("CAPSOLVER_API_KEY=tu_clave_api_aqui")
        return

    print("Clasificacion de Imagenes AWS WAF")

    print("\nPreguntas de Cuadricula (soporta hasta 9 imagenes):")
    for q in GRID_QUESTIONS:
        print(f"  {q}")

    print("\nPreguntas de Ciudad de Coche de Juguete (1 imagen):")
    for q in TOYCARCITY_QUESTIONS:
        print(f"  {q}")

    print("\nEjemplo de uso:")
    print("  # Para desafios de cuadricula:")
    print('  images = load_images_as_base64(["img1.png", "img2.png", ...])')
    print('  solution = solve_awswaf_classification(images, "aws:grid:chair")')
    print("  # Devuelve: {'objects': [0, 2, 5]}  # indices de imagenes coincidentes")

    print("\n  # Para ciudad de coche de juguete:")
    print('  solution = solve_awswaf_classification([imagen_base64], "aws:toycarcity:carcity")')
    print("  # Devuelve: {'box': [x, y]}  # coordenadas del punto final")


if __name__ == "__main__":
    main()