except requests.exceptions.RequestException as e:
                print(f"Error fetching URL {url}: {e}")
                return None

        def extract_data_with_perplexity(html_content, prompt):
            """Utiliza Perplexity AI para extraer datos de HTML basándose en una instrucción."""
            if not html_content:
                return "No hay contenido HTML para procesar."
            
            try:
                # Construir el mensaje para Perplexity AI
                messages = [
                    {"role": "system", "content": "Eres un asistente de IA que extrae información del contenido HTML basado en las instrucciones del usuario. Proporciona los datos extraídos en un formato conciso."},
                    {"role": "user", "content": f"Contenido HTML: {html_content}\n\nInstrucción: {prompt}"}
                ]
                
                chat_completion = client.chat.completions.create(
                    model="sonar-small-online", # O "sonar-medium-online" para tareas más complejas
                    messages=messages,
                    max_tokens=500
                )
                return chat_completion.choices[0].message.content
            except Exception as e:
                print(f"Error extrayendo datos con Perplexity AI: {e}")
                return None

        # Ejemplo de uso
        target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        html = fetch_html(target_url)

        if html:
            extraction_prompt = "Extraer el nombre del producto, el precio y la descripción. Presentarlos claramente."
            extracted_info = extract_data_with_perplexity(html, extraction_prompt)
            print("\n--- Información extraída ---")
            print(extracted_info)
        ```

    Esta solución demuestra el principio fundamental de usar Perplexity AI para interpretar HTML en bruto y extraer la información deseada, simplificando significativamente la fase inicial de extracción de datos al alejarse del análisis basado en selectores frágiles.



### 2. Extracción de Datos Estructurados utilizando Modelos Pydantic

Esta solución se centra en aprovechar Perplexity AI para devolver datos extraídos en un formato estructurado y predefinido utilizando modelos Pydantic. Esto garantiza la consistencia de los datos y simplifica el procesamiento posterior.

*   **Descripción:** En lugar de recibir texto libre de forma de Perplexity AI, podemos guiar su salida para que se ajuste a un esquema específico definido por un `BaseModel` de Pydantic. Esto es particularmente útil cuando necesitas extraer múltiples campos (por ejemplo, nombre del producto, precio, calificación) y deseas que estén organizados de manera ordenada en un objeto de Python o estructura JSON. La biblioteca `instructor`, que envuelve la API de OpenAI (y así la API compatible de Perplexity AI), es excelente para este propósito, permitiendo salidas estructuradas con tipado.

*   **Ejemplo de Código/Pasos:**

    1.  **Instalar las bibliotecas necesarias:**

        ```bash
        pip install openai requests pydantic instructor
        ```

    2.  **Definir tu modelo Pydantic:** Crea un `BaseModel` que represente la estructura de los datos que deseas extraer.

    3.  **Modificar la función de extracción:** Utiliza la biblioteca `instructor` para integrar el modelo Pydantic con la llamada a la API de Perplexity AI.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor # Importar la biblioteca instructor

        # Establecer tu clave API de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "TU_CLAVE_API_DE_PERPLEXITY")

        # Modificar el cliente de OpenAI con instructor para una salida estructurada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        # 1. Definir un modelo Pydantic para la estructura de salida deseada
        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str
            # Agregar más campos según sea necesario, por ejemplo, rating: float, availability: bool

        def fetch_html(url):
            """Obtiene el contenido HTML de una URL dada."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Error al obtener la URL {url}: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Utiliza Perplexity AI para extraer datos estructurados de HTML basándose en un modelo Pydantic."""
            if not html_content:
                return None
            
            try:
                # El parámetro response_model le dice a instructor que analice la salida en nuestro modelo Pydantic
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online", # O "sonar-medium-online"
                    response_model=target_model,
                    messages=[
{"role": "system", "content": "Eres un asistente de IA que extrae información estructurada del contenido HTML. Extrae los detalles solicitados en el esquema JSON proporcionado."},
{"role": "user", "content": f"Contenido HTML: {html_content}\n\nExtrae los siguientes detalles del producto: nombre, precio y descripción."}
print(f"Error al recuperar la URL dinámica {url} con Selenium: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Utiliza Perplexity AI para extraer datos estructurados del HTML basado en un modelo de Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Eres un asistente de IA que extrae información estructurada del contenido HTML. Extrae los detalles solicitados en el esquema JSON proporcionado."},
                        {"role": "user", "content": f"Contenido HTML: {html_content}\n\nExtrae los siguientes detalles del producto: nombre, precio y descripción."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Error al extraer datos estructurados con Perplexity AI: {e}")
                return None

        # Ejemplo de uso (usando una página dinámica hipotética)
        # Nota: Reemplazar con una página dinámica real para probar
        dynamic_target_url = "https://www.example.com/dynamic-product-page" # Reemplazar con una URL dinámica real
        print(f"Recuperando contenido dinámico de: {dynamic_target_url}")
        dynamic_html = fetch_dynamic_html(dynamic_target_url)

        if dynamic_html:
            print("HTML dinámico recuperado con éxito. Pasando a Perplexity AI...")
            product_info = extract_structured_data_with_perplexity(dynamic_html, ProductDetails)
            if product_info:
                print("\n--- Detalles del producto extraídos de la página dinámica ---")
                print(f"Nombre: {product_info.name}")
                print(f"Precio: {product_info.price}")
                print(f"Descripción: {product_info.description}")
                print(f"Salida JSON: {product_info.model_dump_json(indent=2)}")
            else:
                print("No se pudo extraer la información del producto de la página dinámica.")
        else:
            print("No se pudo recuperar el HTML dinámico.")
        ```

    Esta solución aborda eficazmente el contenido dinámico al garantizar que Perplexity AI reciba el HTML completamente renderizado, lo que le permite aplicar sus capacidades de análisis inteligente incluso en los sitios web más complejos impulsados por JavaScript. Esta combinación es crucial para la extracción integral de datos web en el entorno web actual.



### 4. Evitando Medidas Antiscraping con Proxies y Perplexity AI

Muchos sitios web emplean mecanismos antiscraping como el bloqueo de IP, CAPTCHAs y limitación de tasas. Combinar Perplexity AI con soluciones de proxy robustas ayuda a superar estos obstáculos, asegurando un flujo de datos ininterrumpido.

*   **Descripción:** Mientras que Perplexity AI sobresale en el análisis, no maneja los desafíos a nivel de red. Aquí es donde los servicios de proxy se vuelven indispensables. Al enrutar tus solicitudes a través de una red de proxies residenciales o de centros de datos, puedes ocultar tu dirección IP, distribuir solicitudes y eludir restricciones geográficas. Una vez que el proxy obtiene con éxito la página web, su contenido HTML se pasa a Perplexity AI para su extracción inteligente. Esta separación de preocupaciones: proxy para acceso, IA para análisis, crea una arquitectura de scraping altamente efectiva y resiliente.

*   **Ejemplo de código/Pasos:**

    1.  **Instalar las bibliotecas necesarias:**

        ```bash
        pip install openai requests pydantic instructor
        ```

    2.  **Configura tu clave API de Perplexity AI y credenciales de proxy:** Para este ejemplo, utilizaremos credenciales de marcador de posición para un servicio de proxy. Reemplaza `YOUR_PROXY_USERNAME` y `YOUR_PROXY_PASSWORD` con credenciales reales de un proveedor como Oxylabs o Brightdata.

    3.  **Escribe el script en Python:**

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor

        # Establece tu clave API de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Parchea el cliente OpenAI con instructor para salida estructurada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        # Credenciales del proxy (reemplaza con tus credenciales reales)
        PROXY_USERNAME = os.getenv("PROXY_USERNAME", "YOUR_PROXY_USERNAME")
        PROXY_PASSWORD = os.getenv("PROXY_PASSWORD", "YOUR_PROXY_PASSWORD")

        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str

        def fetch_html_with_proxy(url):
            """Recupera el contenido HTML de una URL utilizando un proxy."""
            proxy_url = f"http://{PROXY_USERNAME}:{PROXY_PASSWORD}@pr.oxylabs.io:7777" # Ejemplo para el proxy residencial de Oxylabs
            proxies = {
```python
"http": proxy_url,
                "https": proxy_url,
            }
            headers = {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
                "Accept-Language": "es-ES,es;q=0.9",
            }
            try:
                response = requests.get(url, headers=headers, proxies=proxies, timeout=15)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Error fetching URL {url} with proxy: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Usa Perplexity AI para extraer datos estructurados de HTML basados en un modelo de Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Eres un asistente de IA que extrae información estructurada del contenido HTML. Extrae los detalles solicitados en el esquema JSON proporcionado."},
                        {"role": "user", "content": f"Contenido HTML: {html_content}\n\nExtrae los siguientes detalles del producto: nombre, precio y descripción."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Error extrayendo datos estructurados con Perplexity AI: {e}")
                return None

        # Ejemplo de Uso
        target_url = "https://www.amazon.com/some-product-page" # Reemplaza con una URL de destino que pueda requerir proxies
        print(f"Buscando contenido desde: {target_url} usando proxies...")
        html = fetch_html_with_proxy(target_url)

        if html:
            print("HTML obtenido exitosamente a través del proxy. Pasando a Perplexity AI...")
            product_info = extract_structured_data_with_perplexity(html, ProductDetails)
            if product_info:
                print("\n--- Detalles del Producto Extraídos (a través del Proxy) ---")
                print(f"Nombre: {product_info.name}")
                print(f"Precio: {product_info.price}")
                print(f"Descripción: {product_info.description}")
                print(f"Salida JSON: {product_info.model_dump_json(indent=2)}")
            else:
                print("Falló al extraer información del producto.")
        else:
            print("Falló al obtener HTML a través del proxy.")
        ```

    Esta solución destaca la sinergia entre las redes proxy y Perplexity AI. Los proxies aseguran un acceso confiable a los sitios web de destino, incluso aquellos con estrictas medidas anti-bot, mientras que Perplexity AI maneja la extracción inteligente de datos del contenido recuperado. Esta combinación es esencial para operaciones de raspado web a gran escala y robustas, permitiéndote recopilar datos de una gama más amplia de fuentes sin ser bloqueado o limitado en la tasa de acceso. Para una gestión avanzada de proxies, considera usar una API de raspado web dedicada como Scrapeless, que integra rotación de proxies, solución de CAPTCHA y capacidades de navegador sin cabeza en un único servicio fácil de usar.

### 5. Automatizando la Identificación de Selectores con Perplexity AI

Uno de los aspectos más frágiles del raspado web tradicional es la dependencia de selectores CSS codificados a mano o expresiones XPath. Esta solución demuestra cómo Perplexity AI puede identificar dinámicamente los selectores, haciendo que los raspadores sean más resistentes a los cambios en los sitios web.

*   **Descripción:** En lugar de inspeccionar manualmente una página web para encontrar los selectores correctos para elementos como nombres de productos o precios, Perplexity AI puede ser solicitado con el HTML en bruto y se le puede pedir que identifique los selectores CSS apropiados. Esta capacidad es particularmente poderosa porque permite que el raspador se adapte a cambios menores en el diseño sin requerir modificaciones en el código. La IA actúa como un generador de selectores inteligente, proporcionando los valores `str` necesarios que luego pueden ser utilizados por bibliotecas como BeautifulSoup para una extracción precisa.

*   **Ejemplo de Código/Pasos:**

    1.  **Instalar las bibliotecas necesarias:**

        ```bash
        pip install openai requests pydantic instructor beautifulsoup4
        ```

    2.  **Configurar tu clave de API de Perplexity AI** (como en soluciones anteriores).

    3.  **Escribir el script en Python:**

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor
        from bs4 import BeautifulSoup

        # Configura tu clave de API de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "TU_CLAVE_DE_API_DE_PERPLEXITY")
        
        # Parchea el cliente de OpenAI con instructor para salida estructurada

    # Definir un modelo Pydantic para los selectores que queremos que Perplexity identifique
    class ProductSelectors(BaseModel):
        name_selector: str
        price_selector: str
        description_selector: str

    def fetch_html(url):
        """Obtiene el contenido HTML de una URL dada."""
        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text
        except requests.exceptions.RequestException as e:
            print(f"Error al obtener la URL {url}: {e}")
            return None

    def get_selectors_with_perplexity(html_content):
        """Utiliza Perplexity AI para identificar selectores CSS de HTML."""
        if not html_content:
            return None
        
        try:
            selectors = client.chat.completions.create(
                model="sonar-small-online",
                response_model=ProductSelectors,
                messages=[
                    {"role": "system", "content": "Eres un asistente IA que identifica selectores CSS a partir del contenido HTML. Proporciona el selector CSS más preciso para los elementos solicitados."},
                    {"role": "user", "content": f"Contenido HTML: {html_content}\n\nIdentifica los selectores CSS para el nombre del producto, precio y descripción."}
                ]
            )
            return selectors
        except Exception as e:
            print(f"Error al obtener selectores con Perplexity AI: {e}")
            return None

    def extract_data_with_bs4(html_content, selectors: ProductSelectors):
        """Extrae datos utilizando BeautifulSoup y los selectores proporcionados."""
        soup = BeautifulSoup(html_content, 'html.parser')
        name = soup.select_one(selectors.name_selector).get_text(strip=True) if soup.select_one(selectors.name_selector) else "N/A"
        price = soup.select_one(selectors.price_selector).get_text(strip=True) if soup.select_one(selectors.price_selector) else "N/A"
        description = soup.select_one(selectors.description_selector).get_text(strip=True) if soup.select_one(selectors.description_selector) else "N/A"
        return {"name": name, "price": price, "description": description}

    # Ejemplo de uso
    target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
    html = fetch_html(target_url)

    if html:
        print("HTML obtenido. Preguntando a Perplexity AI por selectores...")
        product_selectors = get_selectors_with_perplexity(html)
        if product_selectors:
            print("\n--- Selectores Identificados ---")
            print(f"Selector de Nombre: {product_selectors.name_selector}")
            print(f"Selector de Precio: {product_selectors.price_selector}")
            print(f"Selector de Descripción: {product_selectors.description_selector}")
            
            print("\nExtrayendo datos usando BeautifulSoup con selectores identificados por IA...")
            extracted_data = extract_data_with_bs4(html, product_selectors)
            print("\n--- Datos del Producto Extraídos ---")
            print(f"Nombre del Producto: {extracted_data['name']}")
            print(f"Precio del Producto: {extracted_data['price']}")
            print(f"Descripción del Producto: {extracted_data['description']}")
        else:
            print("No se pudieron obtener selectores de Perplexity AI.")
    else:
        print("No se pudo obtener el HTML.")

    print("\n--- Todos los productos extraídos ---")
    for product in all_products:
        print(f"Título: {product.title}, Precio: {product.price}, Enlace: {product.link}")
    print(f"Total de productos extraídos: {len(all_products)}")
    ```

Esta solución demuestra cómo Perplexity AI puede simplificar la tarea compleja de la recopilación de datos en múltiples páginas. Al identificar inteligentemente tanto los datos como el siguiente enlace de paginación, reduce la necesidad de lógica personalizada para cada esquema de paginación único de los sitios web, haciendo que tus scrapers sean más adaptables y eficientes para la recopilación de datos a gran escala. Este es un paso significativo hacia la construcción de agentes de raspado verdaderamente autónomos que pueden navegar y extraer información de sitios web completos.

target_url = event.get("url")
            if not target_url:
                return {
                    "statusCode": 400,
                    "body": json.dumps({"message": "Falta 'url' en la carga útil del evento"})
                }

            html = fetch_html(target_url)
            if html:
                product_info = extract_structured_data_with_perplexity(html, ProductDetails)
                if product_info:
                    return {
                        "statusCode": 200,
                        "body": product_info.model_dump_json(indent=2)
                    }
                else:
                    return {
                        "statusCode": 500,
                        "body": json.dumps({"message": "Fallo al extraer la información del producto."})
                    }
            else:
                return {
                    "statusCode": 500,
                    "body": json.dumps({"message": "Fallo al recuperar el HTML."})
                }
        ```

    4.  **Pasos de Implementación (General):**
        *   Empaquete su `lambda_function.py` junto con todas sus dependencias (incluyendo `openai`, `requests`, `pydantic`, `instructor`) en un paquete de implementación (por ejemplo, un archivo `.zip`).
        *   Cargue el paquete a su proveedor de nube elegido (por ejemplo, AWS Lambda).
        *   Configure la función con la memoria, el tiempo de espera y las variables de entorno adecuadas (especialmente `PERPLEXITY_API_KEY`).
        *   Configure los desencadenadores (por ejemplo, API Gateway para solicitudes HTTP, SQS para procesamiento basado en cola, EventBridge para tareas programadas).

    Este enfoque sin servidor le permite construir soluciones de raspado web altamente escalables, rentables y basadas en eventos. Al delegar la ejecución a funciones de la nube, solo paga por el tiempo de cómputo realmente utilizado, lo que lo hace ideal para cargas de trabajo fluctuantes y recolección de datos a gran escala. Las capacidades de análisis inteligente de Perplexity AI dentro de esta arquitectura aseguran que incluso con altos volúmenes, los datos extraídos se mantengan precisos y estructurados.

### 9. Manejo de Errores y Robustez en el Raspado con Perplexity AI

Construir raspadores web robustos requiere un manejo de errores integral para gestionar suavemente problemas de red, cambios en los sitios web y fallas de API. Esta solución describe estrategias para hacer que los raspadores impulsados por Perplexity AI sean más resilientes.

*   **Descripción:** Incluso con Perplexity AI, pueden surgir problemas inesperados durante el raspado web. Implementar un manejo de errores adecuado asegura que su raspador no se bloquee y pueda recuperarse o registrar fallas de manera efectiva. Esto incluye manejar errores HTTP, tiempos de espera de red, errores de API de Perplexity AI y casos en los que la IA puede no extraer datos como se esperaba. Las estrategias involucran mecanismos de reintento, análisis de respaldo y registro detallado.

*   **Ejemplo de Código/Pasos:**

    1.  **Instalar bibliotecas necesarias:**

        ```bash
        pip install openai requests pydantic instructor tenacity
        ```

    2.  **Configure su clave API de Perplexity AI** (como en soluciones anteriores).

    3.  **Escriba el script en Python:** Este ejemplo incorpora `tenacity` para una lógica de reintento robusta y un manejo de errores más integral.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor
        from tenacity import retry, stop_after_attempt, wait_fixed, retry_if_exception_type
        import logging

        # Configurar registro
        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

        # Establecer su clave API de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SU_CLAVE_API_DE_PERPLEXITY")

        # Parchear el cliente OpenAI con instructor para salida estructurada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str | None = None
            price: str | None = None
            description: str | None = None

        # Decorador de reintento para solicitudes de red
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), retry=retry_if_exception_type(requests.exceptions.RequestException))
        def fetch_html_robust(url):
            """Recupera el contenido HTML de una URL dada con reintentos."""
            logging.info(f"Intentando recuperar HTML de {url}")
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text

        # Decorador de reintento para llamadas a Perplexity AI
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(5), retry=retry_if_exception_type(Exception))
        def extract_structured_data_robust(html_content, target_model: BaseModel):
            """Utiliza Perplexity AI para extraer datos estructurados del HTML con reintentos."""
            if not html_content:
                logging.warning("No se proporcionó contenido HTML para la extracción.")
                return None

logging.info("Intentando extraer datos con Perplexity AI.")
            extracted_data = client.chat.completions.create(
                model="sonar-small-online",
                response_model=target_model,
                messages=[
                    {"role": "system", "content": "Eres un asistente AI que extrae información estructurada de contenido HTML. Extrae los detalles solicitados en el esquema JSON proporcionado."},
                    {"role": "user", "content": f"Contenido HTML: {html_content}\n\nExtrae los siguientes detalles del producto: nombre, precio y descripción."}
                ]
            )
            return extracted_data

        # Ejemplo de Uso
        target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        # Ejemplo de un URL que podría fallar (por ejemplo, 404 o error de red)
        # failing_url = "https://www.example.com/non-existent-page"

        print(f"\n--- Procesando {target_url} ---")
        try:
            html = fetch_html_robust(target_url)
            if html:
                product_info = extract_structured_data_robust(html, ProductDetails)
                if product_info:
                    print("\n--- Detalles del Producto Extraídos ---")
                    print(f"Nombre: {product_info.name}")
                    print(f"Precio: {product_info.price}")
                    print(f"Descripción: {product_info.description}")
                else:
                    logging.error("Perplexity AI no logró extraer datos después de varios intentos.")
            else:
                logging.error("No se pudo obtener HTML después de varios intentos.")
        except Exception as e:
            logging.critical(f"Error crítico durante el proceso de raspado para {target_url}: {e}")

        # Ejemplo con un URL que podría fallar (descomentar para probar)
        # print(f"\n--- Procesando {failing_url} ---")
        # try:
        #     html_failing = fetch_html_robust(failing_url)
        #     if html_failing:
        #         product_info_failing = extract_structured_data_robust(html_failing, ProductDetails)
        #         if product_info_failing:
        #             print("\n--- Detalles del Producto Extraídos (URL con Fallo) ---")
        #             print(f"Nombre: {product_info_failing.name}")
        #             print(f"Precio: {product_info_failing.price}")
        #             print(f"Descripción: {product_info_failing.description}")
        #         else:
        #             logging.error("Perplexity AI falló al extraer datos de la URL con fallo después de varios intentos.")
        #     else:
        #         logging.error("No se pudo obtener HTML de la URL con fallo después de varios intentos.")
        # except Exception as e:
        #     logging.critical(f"Error crítico durante el proceso de raspado para {failing_url}: {e}")
        ```

    Esta solución enfatiza la importancia de construir resistencia en tus operaciones de raspado. Al implementar mecanismos de reintento, manejo de errores integral y registro detallado, puedes crear raspadores impulsados por Perplexity AI que sean más fiables y menos propensos a interrupciones. Esto es crucial para mantener flujos de datos continuos y asegurar la integridad de tus datos recopilados, incluso ante entornos web impredecibles.

### 10. Transformación y Limpieza de Datos Avanzadas con Perplexity AI

Los datos extraídos en bruto a menudo requieren una transformación y limpieza adicionales antes de poder ser utilizados de manera efectiva. Perplexity AI puede aprovecharse para automatizar estos procesos posteriores a la extracción, asegurando la calidad y consistencia de los datos.

*   **Descripción:** Después de la extracción inicial de datos, los datos pueden estar en formatos inconsistentes, contener ruido o requerir enriquecimiento (por ejemplo, convertir monedas, estandarizar fechas, categorizar texto). Perplexity AI, con sus fuertes capacidades de comprensión del lenguaje natural, puede utilizarse para realizar estas tareas avanzadas de transformación y limpieza. Al proporcionar a la IA los datos extraídos y instrucciones claras, puede reformatear, limpiar e incluso enriquecer los datos, preparándolos para análisis o almacenamiento. Esto reduce la necesidad de complejos scripts de limpieza basados en reglas y hace que el pipeline de datos sea más adaptable.

*   **Ejemplo de Código/Pasos:**

    1.  **Instalar bibliotecas necesarias:**

        ```bash
        pip install openai requests pydantic instructor
        ```

    2.  **Configura tu clave API de Perplexity AI** (como en soluciones anteriores).

    3.  **Escribe el script de Python:** Este ejemplo demuestra la limpieza y estandarización de los detalles del producto.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel, Field
        import instructor

        # Establece tu clave API de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Parchea el cliente de OpenAI con instructor para salida estructurada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

class DetallesProductoRaw(BaseModel):
            nombre: str
            precio_raw: str = Field(alias="precio") # Usar alias para entradas potencialmente desordenadas
            descripcion_raw: str = Field(alias="descripcion")

        class DetallesProductoLimpiados(BaseModel):
            nombre_producto: str
            precio_usd: float
            resumen_descripcion: str
            categoria: str

        def obtener_html(url):
            """Obtiene el contenido HTML de una URL dada."""
            try:
                respuesta = requests.get(url, timeout=10)
                respuesta.raise_for_status()
                return respuesta.text
            except requests.exceptions.RequestException as e:
                print(f"Error al obtener la URL {url}: {e}")
                return None

        def extraer_datos_raw_con_perplexity(contenido_html):
            """Utiliza Perplexity AI para extraer datos raw del HTML."""
            if not contenido_html:
                return None
            
            try:
                datos_raw = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=DetallesProductoRaw,
                    messages=[
                        {"role": "system", "content": "Eres un asistente de IA que extrae información de producto raw del contenido HTML. Extrae el nombre, precio y descripción."},
                        {"role": "user", "content": f"Contenido HTML: {contenido_html}\n\nExtrae el nombre del producto, su cadena de precio raw y su descripción raw."}
                    ]
                )
                return datos_raw
            except Exception as e:
                print(f"Error al extraer datos raw con Perplexity AI: {e}")
                return None

        def transformar_y_limpiar_datos_con_perplexity(datos_raw: DetallesProductoRaw):
            """Utiliza Perplexity AI para transformar y limpiar datos extraídos raw."""
            if not datos_raw:
                return None
            
            prompt_transformacion = f"Limpia y transforma los siguientes datos del producto a un formato estructurado:\n\nNombre del Producto: {datos_raw.nombre}\nPrecio Raw: {datos_raw.precio_raw}\nDescripción Raw: {datos_raw.descripcion_raw}\n\nInstrucciones:\n1. Estandariza el nombre del producto (por ejemplo, elimina espacios extra, capitaliza).
2. Convierte el precio raw a un float en USD. Si la moneda no es USD, asume que lo es y convierte si es necesario (por ejemplo, '€100' a 100.0).
3. Resume la descripción a un máximo de 50 palabras.
4. Infiera una única categoría de producto (por ejemplo, 'Electrónica', 'Ropa', 'Libros') basada en el nombre y la descripción.\n\nProporciona la salida como un objeto JSON que coincida con el esquema DetallesProductoLimpiados."

            try:
                datos_limpios = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=DetallesProductoLimpiados,
                    messages=[
                        {"role": "system", "content": "Eres un asistente de IA que limpia y transforma datos raw en un formato estructurado y estandarizado basado en las instrucciones del usuario y un esquema JSON proporcionado."},
                        {"role": "user", "content": prompt_transformacion}
                    ]
                )
                return datos_limpios
            except Exception as e:
                print(f"Error al transformar datos con Perplexity AI: {e}")
                return None

        # Ejemplo de Uso
        url_objetivo = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        html = obtener_html(url_objetivo)

        if html:
            print("HTML obtenido. Extrayendo datos raw con Perplexity AI...")
            info_producto_raw = extraer_datos_raw_con_perplexity(html)
            
            if info_producto_raw:
                print("\n--- Detalles del Producto Raw Extraídos ---")
                print(f"Nombre: {info_producto_raw.nombre}")
                print(f"Precio Raw: {info_producto_raw.precio_raw}")
                print(f"Descripción Raw: {info_producto_raw.descripcion_raw}")

                print("\nTransformando y limpiando datos con Perplexity AI...")
                info_producto_limpio = transformar_y_limpiar_datos_con_perplexity(info_producto_raw)

                if info_producto_limpio:
                    print("\n--- Detalles del Producto Limpiados y Transformados ---")
                    print(f"Nombre del Producto: {info_producto_limpio.nombre_producto}")
                    print(f"Precio (USD): {info_producto_limpio.precio_usd:.2f}")
                    print(f"Resumen de Descripción: {info_producto_limpio.resumen_descripcion}")
                    print(f"Categoría: {info_producto_limpio.categoria}")
                    print(f"Salida JSON: {info_producto_limpio.model_dump_json(indent=2)}")
                else:
                    print("Error al limpiar y transformar la información del producto.")
            else:
                print("Error al extraer información raw del producto.")
        else:
            print("Error al obtener HTML.")

    Esta solución muestra la versatilidad de Perplexity AI más allá de la mera extracción. Al aprovechar sus capacidades de procesamiento de lenguaje natural para la transformación y limpieza de datos, puedes simplificar significativamente tus flujos de trabajo posteriores a la recolección de datos. Este enfoque es particularmente beneficioso para mantener una alta calidad de datos, asegurando consistencia entre diversas fuentes de datos y preparando datos para un uso inmediato en análisis, modelos de aprendizaje automático o tableros de inteligencia empresarial. Convierte datos web desordenados y en bruto en información clara y procesable con una intervención manual mínima.

### 8. Integración de Perplexity AI con Funciones en la Nube para una Recolección Escalable

Para tareas de recolección de datos a gran escala, impulsadas por eventos o programadas, integrar Perplexity AI con funciones en la nube sin servidor (por ejemplo, AWS Lambda, Google Cloud Functions, Azure Functions) ofrece una gran escalabilidad y eficiencia de costos.

*   **Descripción:** Las funciones en la nube te permiten ejecutar código en respuesta a eventos (como un nuevo elemento que aparece en una cola o un temporizador programado) sin provisionar o gestionar servidores. Al implementar tu lógica de recolección de datos impulsada por Perplexity AI dentro de una función en la nube, puedes crear soluciones de recolección de datos altamente escalables y rentables. Cada invocación de función puede manejar una única tarea de recolección, aprovechando Perplexity AI para la extracción inteligente de datos y escalando automáticamente para satisfacer la demanda. Esta arquitectura es ideal para procesar grandes volúmenes de URLs o para el monitoreo continuo de muchos sitios web.

*   **Ejemplo de Código/Pasos:**

    1.  **Requisitos Previos:**
        *   Una cuenta de AWS, Google Cloud o Azure.
        *   Familiaridad con la implementación de funciones sin servidor.
        *   Clave API de Perplexity AI configurada de forma segura (por ejemplo, a través de variables de entorno en la función en la nube).

    2.  **Instalar las bibliotecas necesarias (para desarrollo local y empaquetado):**

        ```bash
        pip install openai requests pydantic instructor
        ```

    3.  **Ejemplo (AWS Lambda con Python):**

        Crea un archivo `lambda_function.py`:

        ```python
        import json
        import os
        import requests
        from openai import OpenAI
        from pydantic import BaseModel
        import instructor

        # Inicializa el cliente de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY")
        if not perplexity_api_key:
            raise ValueError("La variable de entorno PERPLEXITY_API_KEY no está configurada.")

        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str
            price: str
            description: str

        def fetch_html(url):
            """Obtiene el contenido HTML de una URL dada."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Error al obtener la URL {url}: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Utiliza Perplexity AI para extraer datos estructurados de HTML basado en un modelo de Pydantic."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=target_model,
                    messages=[
                        {"role": "system", "content": "Eres un asistente de IA que extrae información estructurada del contenido HTML. Extrae los detalles solicitados en el esquema JSON proporcionado."},
                        {"role": "user", "content": f"Contenido HTML: {html_content}\n\nExtrae los siguientes detalles del producto: nombre, precio y descripción."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Error al extraer datos estructurados con Perplexity AI: {e}")
                return None

        def lambda_handler(event, context):
            """Controlador de función de AWS Lambda."""
            print(f"Evento recibido: {json.dumps(event)}")
            
            # Esperando 'url' en la carga útil del evento
            target_url = event.get("url")
            if not target_url:
                return {
                    "statusCode": 400,
                    "body": json.dumps({"message": "Falta 'url' en la carga útil del evento"})
                }

            html = fetch_html(target_url)
            if html:
                product_info = extract_structured_data_with_perplexity(html, ProductDetails)
                if product_info:
                    return {
                        "statusCode": 200,
                        "body": product_info.model_dump_json(indent=2)
                    }
                else:
                    return {

"statusCode": 500,
                        "body": json.dumps({"message": "No se pudo extraer la información del producto."})
                    }
            else:
                return {
                    "statusCode": 500,
                    "body": json.dumps({"message": "No se pudo obtener el HTML."})
                }
        ```

    4.  **Pasos de Despliegue (Generales):**
        *   Empaqueta tu `lambda_function.py` junto con todas sus dependencias (incluyendo `openai`, `requests`, `pydantic`, `instructor`) en un paquete de despliegue (por ejemplo, un archivo `.zip`).
        *   Sube el paquete a tu proveedor de nube elegido (por ejemplo, AWS Lambda).
        *   Configura la función con la memoria, el tiempo de espera y las variables de entorno apropiadas (especialmente `PERPLEXITY_API_KEY`).
        *   Configura activadores (por ejemplo, API Gateway para solicitudes HTTP, SQS para procesamiento basado en colas, EventBridge para tareas programadas).

    Este enfoque sin servidor te permite construir soluciones de web scraping altamente escalables, rentables y basadas en eventos. Al delegar la ejecución a funciones en la nube, solo pagas por el tiempo de cómputo realmente utilizado, lo que lo hace ideal para cargas de trabajo fluctuantes y recolección de datos a gran escala. Las capacidades de análisis inteligente de Perplexity AI dentro de esta arquitectura aseguran que incluso con altos volúmenes, los datos extraídos permanezcan precisos y estructurados.



### 9. Manejo de Errores y Robustez en el Web Scraping con Perplexity AI

Construir scrapers web robustos requiere un manejo de errores integral para gestionar sin problemas problemas de red, cambios en los sitios web y fallos de API. Esta solución describe estrategias para hacer que los scrapers impulsados por Perplexity AI sean más resilientes.

*   **Descripción:** Incluso con Perplexity AI, pueden surgir problemas inesperados durante el web scraping. Implementar un manejo adecuado de errores asegura que tu scraper no se bloquee y pueda recuperarse o registrar fallos de manera efectiva. Esto incluye manejar errores HTTP, tiempos de espera de red, errores de API de Perplexity AI y casos en los que la IA podría no extraer datos como se esperaba. Las estrategias incluyen mecanismos de reintento, análisis de respaldo y registros detallados.

*   **Ejemplo de Código/Pasos:**

    1.  **Instala las bibliotecas necesarias:**

        ```bash
        pip install openai requests pydantic instructor tenacity
        ```

    2.  **Configura tu clave de API de Perplexity AI** (como en soluciones anteriores).

    3.  **Escribe el script de Python:** Este ejemplo incorpora `tenacity` para una lógica de reintento robusta y un manejo de errores más completo.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor
        from tenacity import retry, stop_after_attempt, wait_fixed, retry_if_exception_type
        import logging

        # Configura el registro de eventos
        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

        # Establece tu clave de API de Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "TU_CLAVE_API_DE_PERPLEXITY")

        # Parchea el cliente de OpenAI con instructor para salida estructurada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductDetails(BaseModel):
            name: str | None = None
            price: str | None = None
            description: str | None = None

        # Decorador de reintento para solicitudes de red
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), retry=retry_if_exception_type(requests.exceptions.RequestException))
        def fetch_html_robust(url):
            """Obtiene el contenido HTML de una URL dada con reintentos."""
            logging.info(f"Intentando obtener HTML de {url}")
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text

        # Decorador de reintento para llamadas a Perplexity AI
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(5), retry=retry_if_exception_type(Exception))
        def extract_structured_data_robust(html_content, target_model: BaseModel):
            """Usa Perplexity AI para extraer datos estructurados de HTML con reintentos."""
            if not html_content:
                logging.warning("No se proporcionó contenido HTML para la extracción.")
                return None
            
            logging.info("Intentando extraer datos con Perplexity AI.")
            extracted_data = client.chat.completions.create(
                model="sonar-small-online",
                response_model=target_model,
                messages=[
                    {"role": "system", "content": "Eres un asistente de IA que extrae información estructurada del contenido HTML. Extrae los detalles solicitados en el esquema JSON proporcionado."},
                    {"role": "user", "content": f"Contenido HTML: {html_content}\n\nExtrae los siguientes detalles del producto: nombre, precio y descripción."}
                ]
            )
            return extracted_data

    target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
    # Ejemplo de una URL que podría fallar (por ejemplo, 404 o error de red)
    # failing_url = "https://www.example.com/non-existent-page"

    print(f"\n--- Procesando {target_url} ---")
    try:
        html = fetch_html_robust(target_url)
        if html:
            product_info = extract_structured_data_robust(html, ProductDetails)
            if product_info:
                print("\n--- Detalles del Producto Extraídos ---")
                print(f"Nombre: {product_info.name}")
                print(f"Precio: {product_info.price}")
                print(f"Descripción: {product_info.description}")
            else:
                logging.error("Perplexity AI no pudo extraer datos tras múltiples intentos.")
        else:
            logging.error("No se pudo obtener el HTML tras múltiples intentos.")
    except Exception as e:
        logging.critical(f"Error crítico durante el proceso de scraping para {target_url}: {e}")

    # Ejemplo con una URL que podría fallar (descomentar para probar)
    # print(f"\n--- Procesando {failing_url} ---")
    # try:
    #     html_failing = fetch_html_robust(failing_url)
    #     if html_failing:
    #         product_info_failing = extract_structured_data_robust(html_failing, ProductDetails)
    #         if product_info_failing:
    #             print("\n--- Detalles del Producto Extraídos (URL Fallida) ---")
    #             print(f"Nombre: {product_info_failing.name}")
    #             print(f"Precio: {product_info_failing.price}")
    #             print(f"Descripción: {product_info_failing.description}")
    #         else:
    #             logging.error("Perplexity AI no pudo extraer datos de la URL fallida tras múltiples intentos.")
    #     else:
    #         logging.error("No se pudo obtener el HTML de la URL fallida tras múltiples intentos.")
    # except Exception as e:
    #     logging.critical(f"Error crítico durante el proceso de scraping para {failing_url}: {e}")
    ```

Esta solución enfatiza la importancia de construir resiliencia en sus operaciones de scraping. Al implementar mecanismos de reintento, manejo de errores exhaustivo y registro detallado, puede crear scrapers impulsados por Perplexity AI que sean más confiables y menos propensos a interrupciones. Esto es crucial para mantener flujos de datos continuos y garantizar la integridad de los datos recopilados, incluso frente a entornos web impredecibles.