exceto requests.exceptions.RequestException como e:
                print(f"Erro ao buscar a URL {url}: {e}")
                return None

        def extrair_dados_com_perplexidade(conteudo_html, prompt):
            """Usa a Perplexity AI para extrair dados do HTML com base em um prompt."""
            se não conteudo_html:
                return "Sem conteúdo HTML para processar."
            
            try:
                # Construa a mensagem para a Perplexity AI
                mensagens = [
                    {"role": "system", "content": "Você é um assistente de IA que extrai informações de conteúdo HTML com base nas instruções do usuário. Forneça os dados extraídos em um formato conciso."},
                    {"role": "user", "content": f"Conteúdo HTML: {conteudo_html}\n\nInstrução: {prompt}"}
                ]
                
                chat_completion = cliente.chat.completions.create(
                    model="sonar-small-online", # Ou "sonar-medium-online" para tarefas mais complexas
                    mensagens=mensagens,
                    max_tokens=500
                )
                return chat_completion.choices[0].message.content
            except Exception como e:
                print(f"Erro ao extrair dados com a Perplexity AI: {e}")
                return None

        # Exemplo de Uso
        url_alvo = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        html = buscar_html(url_alvo)

        se html:
            prompt_extracao = "Extraia o nome do produto, preço e descrição. Apresente-os claramente."
            informacoes_extraidas = extrair_dados_com_perplexidade(html, prompt_extracao)
            print("\n--- Informações Extraídas ---")
            print(informacoes_extraidas)

    Esta solução demonstra o princípio fundamental de usar a Perplexity AI para interpretar HTML bruto e extrair informações desejadas, simplificando significativamente a fase inicial de extração de dados, afastando-se de uma análise baseada em seletores frágeis.

### 2. Extração de Dados Estruturados usando Modelos Pydantic

Esta solução se concentra em aproveitar a Perplexity AI para retornar dados extraídos em um formato estruturado previamente definido usando modelos Pydantic. Isso garante consistência nos dados e simplifica o processamento posterior.

*   **Descrição:** Em vez de receber texto livre da Perplexity AI, podemos orientar sua saída para se conformar a um esquema específico definido por um `BaseModel` do Pydantic. Isso é particularmente útil quando você precisa extrair vários campos (por exemplo, nome do produto, preço, avaliação) e deseja que eles sejam organizados de forma organizada em um objeto Python ou estrutura JSON. A biblioteca `instructor`, que envolve a API OpenAI (e, portanto, a API compatível da Perplexity AI), é excelente para esse propósito, permitindo saídas estruturadas e com dicas de tipo.

*   **Exemplo de Código/Passo a Passo:**

    1.  **Instale as bibliotecas necessárias:**

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

    2.  **Defina seu modelo Pydantic:** Crie um `BaseModel` que represente a estrutura dos dados que você deseja extrair.

    3.  **Modifique a função de extração:** Use a biblioteca `instructor` para integrar o modelo Pydantic com a chamada da API da Perplexity AI.

        ```python
        import requests
        from openai import OpenAI
        import os
        from pydantic import BaseModel
        import instructor # Importe a biblioteca instructor

        # Defina sua chave da API da Perplexity AI
        chave_api_perplexity = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_API_PERPLEXITY")

        # Patch do cliente OpenAI com instructor para saída estruturada
        cliente = instructor.patch(OpenAI(api_key=chave_api_perplexity, base_url="https://api.perplexity.ai"))

        # 1. Defina um modelo Pydantic para a estrutura de saída desejada
        class DetalhesDoProduto(BaseModel):
            nome: str
            preco: str
            descricao: str
            # Adicione mais campos conforme necessário, por exemplo, avaliacao: float, disponibilidade: bool

        def buscar_html(url):
            """Busca o conteúdo HTML de uma URL dada."""
            try:
                resposta = requests.get(url, timeout=10)
                resposta.raise_for_status()
                return resposta.text
            except requests.exceptions.RequestException como e:
                print(f"Erro ao buscar a URL {url}: {e}")
                return None

        def extrair_dados_estruturados_com_perplexidade(conteudo_html, modelo_alvo: BaseModel):
            """Usa a Perplexity AI para extrair dados estruturados do HTML com base em um modelo Pydantic."""
            se não conteudo_html:
                return None
            
            try:
                # O parâmetro response_model informa ao instructor para analisar a saída em nosso modelo Pydantic
                dados_extraidos = cliente.chat.completions.create(
                    model="sonar-small-online", # Ou "sonar-medium-online"
                    response_model=modelo_alvo,
                    mensagens=[
{"role": "system", "content": "Você é um assistente de IA que extrai informações estruturadas de conteúdo HTML. Extraia os detalhes solicitados no esquema JSON fornecido."},
{"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia os seguintes detalhes do produto: nome, preço e descrição."}

print(f"Erro ao buscar URL dinâmica {url} com Selenium: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Usa a Perplexity AI para extrair dados estruturados de HTML com base em um modelo 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": "Você é um assistente de IA que extrai informações estruturadas do conteúdo HTML. Extraia os detalhes solicitados para o esquema JSON fornecido."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia os seguintes detalhes do produto: nome, preço e descrição."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Erro ao extrair dados estruturados com Perplexity AI: {e}")
                return None

        # Exemplo de Uso (usando uma página dinâmica hipotética)
        # Nota: Substitua por uma página dinâmica real para testes
        dynamic_target_url = "https://www.example.com/dynamic-product-page" # Substitua por uma URL dinâmica real
        print(f"Buscando conteúdo dinâmico de: {dynamic_target_url}")
        dynamic_html = fetch_dynamic_html(dynamic_target_url)

        if dynamic_html:
            print("HTML dinâmico buscado com sucesso. Enviando para a Perplexity AI...")
            product_info = extract_structured_data_with_perplexity(dynamic_html, ProductDetails)
            if product_info:
                print("\n--- Detalhes do Produto Extraídos da Página Dinâmica ---")
                print(f"Nome: {product_info.name}")
                print(f"Preço: {product_info.price}")
                print(f"Descrição: {product_info.description}")
                print(f"Saída JSON: {product_info.model_dump_json(indent=2)}")
            else:
                print("Falha ao extrair informações do produto da página dinâmica.")
        else:
            print("Falha ao buscar HTML dinâmico.")
        

    Esta solução lida efetivamente com conteúdo dinâmico, garantindo que a Perplexity AI receba o HTML totalmente renderizado, permitindo que aplique suas capacidades de análise inteligente até mesmo em sites complexos impulsionados por JavaScript. Esta combinação é crucial para a extração abrangente de dados da web no ambiente online atual.



### 4. Contornando Medidas Anti-Scraping com Proxies e Perplexity AI

Muitos sites empregam mecanismos anti-scraping como bloqueio de IP, CAPTCHAs e limitação de taxa. Combinar Perplexity AI com soluções robustas de proxy ajuda a superar esses obstáculos, garantindo um fluxo de dados ininterrupto.

*   **Descrição:** Embora a Perplexity AI seja excelente em análise, ela não lida com desafios em nível de rede. É aqui que os serviços de proxy se tornam indispensáveis. Roteando suas solicitações através de uma rede de proxies residenciais ou de datacenter, você pode mascarar seu endereço IP, distribuir solicitações e contornar restrições geográficas. Uma vez que o proxy busca com sucesso a página da web, seu conteúdo HTML é passado para a Perplexity AI para extração inteligente. Esta separação de preocupações—proxy para acesso, IA para análise—cria uma arquitetura de scraping altamente eficaz e resiliente.

*   **Exemplo/Passos de Código:**

    1.  **Instale as bibliotecas necessárias:**

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

    2.  **Configure sua chave API da Perplexity AI e credenciais de proxy:** Para este exemplo, usaremos credenciais de espaço reservado para um serviço de proxy. Substitua `YOUR_PROXY_USERNAME` e `YOUR_PROXY_PASSWORD` pelas credenciais reais de um provedor como Oxylabs ou Brightdata.

    3.  **Escreva o script em Python:**

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

        # Defina sua chave API da Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "YOUR_PERPLEXITY_API_KEY")

        # Patch o cliente OpenAI com instructor para saída estruturada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        # Credenciais de proxy (substitua por suas credenciais reais)
        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):
            """Busca o conteúdo HTML de uma URL usando um proxy."""
            proxy_url = f"http://{PROXY_USERNAME}:{PROXY_PASSWORD}@pr.oxylabs.io:7777" # Exemplo de proxy residencial da Oxylabs
            proxies = {

"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": "pt-BR,pt;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"Erro ao buscar a URL {url} com proxy: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Usa a Perplexity AI para extrair dados estruturados do HTML com base em um modelo 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": "Você é um assistente de IA que extrai informações estruturadas do conteúdo HTML. Extraia os detalhes solicitados no esquema JSON fornecido."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia os seguintes detalhes do produto: nome, preço e descrição."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Erro ao extrair dados estruturados com Perplexity AI: {e}")
                return None

        # Exemplo de Uso
        target_url = "https://www.amazon.com/some-product-page" # Substitua por uma URL alvo que pode exigir proxies
        print(f"Buscando conteúdo de: {target_url} usando proxies...")
        html = fetch_html_with_proxy(target_url)

        if html:
            print("HTML buscado com sucesso via proxy. Enviando para a Perplexity AI...")
            product_info = extract_structured_data_with_perplexity(html, ProductDetails)
            if product_info:
                print("\n--- Detalhes do Produto Extraídos (via Proxy) ---")
                print(f"Nome: {product_info.name}")
                print(f"Preço: {product_info.price}")
                print(f"Descrição: {product_info.description}")
                print(f"Saída JSON: {product_info.model_dump_json(indent=2)}")
            else:
                print("Falha ao extrair informações do produto.")
        else:
            print("Falha ao buscar HTML via proxy.")
        ```

    Esta solução destaca a sinergia entre redes de proxy e a Perplexity AI. Proxies garantem acesso confiável a sites alvo, mesmo aqueles com rígidas medidas anti-bot, enquanto a Perplexity AI lida com a extração inteligente de dados do conteúdo recuperado. Essa combinação é essencial para operações de web scraping em larga escala e robustas, permitindo que você colete dados de uma gama mais ampla de fontes sem ser bloqueado ou limitado em taxa. Para uma gestão de proxy mais avançada, considere usar uma API dedicada de web scraping como a Scrapeless, que integra rotação de proxy, resolução de CAPTCHA e capacidades de navegador sem cabeça em um único serviço fácil de usar.

### 5. Automatizando a Identificação de Seletores com a Perplexity AI

Um dos aspectos mais frágeis do scraping web tradicional é a dependência de seletores CSS codificados ou expressões XPath. Esta solução demonstra como a Perplexity AI pode identificar seletores dinamicamente, tornando os scrapers mais resilientes a mudanças no site.

*   **Descrição:** Em vez de inspecionar manualmente uma página da web para encontrar os seletores corretos para elementos como nomes de produtos ou preços, a Perplexity AI pode ser solicitada com o HTML bruto e pedida para identificar os seletores CSS apropriados. Essa capacidade é particularmente poderosa porque permite que o scraper se adapte a pequenas mudanças no layout sem exigir modificações de código. A IA atua como um gerador de seletores inteligente, fornecendo os valores `str` necessários que podem ser usados por bibliotecas como BeautifulSoup para extração precisa.

*   **Exemplo de Código/Passo a Passo:**

    1.  **Instale as bibliotecas necessárias:**

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

    2.  **Configure sua chave da API da Perplexity AI** (como nas soluções anteriores).

    3.  **Escreva o script Python:**

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

        # Defina sua chave da API da Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_DA_API_PERPLEXITY")

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

        # Defina um modelo Pydantic para os seletores que queremos que o Perplexity identifique
        class ProductSelectors(BaseModel):
            name_selector: str
            price_selector: str
            description_selector: str

        def fetch_html(url):
            """Busca o conteúdo HTML de uma URL dada."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Erro ao buscar a URL {url}: {e}")
                return None

        def get_selectors_with_perplexity(html_content):
            """Usa a Perplexity AI para identificar seletores CSS a partir do HTML."""
            if not html_content:
                return None
            
            try:
                selectors = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=ProductSelectors,
                    messages=[
                        {"role": "system", "content": "Você é um assistente de IA que identifica seletores CSS a partir do conteúdo HTML. Forneça o seletor CSS mais preciso para os elementos solicitados."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nIdentifique os seletores CSS para o nome do produto, preço e descrição."}
                    ]
                )
                return selectors
            except Exception as e:
                print(f"Erro ao obter seletores com a Perplexity AI: {e}")
                return None

        def extract_data_with_bs4(html_content, selectors: ProductSelectors):
            """Extrai dados usando BeautifulSoup e os seletores fornecidos."""
            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}

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

        if html:
            print("HTML buscado. Perguntando à Perplexity AI pelos seletores...")
            product_selectors = get_selectors_with_perplexity(html)
            if product_selectors:
                print("\n--- Seletores Identificados ---")
                print(f"Seletor de Nome: {product_selectors.name_selector}")
                print(f"Seletor de Preço: {product_selectors.price_selector}")
                print(f"Seletor de Descrição: {product_selectors.description_selector}")
                
                print("\nExtraindo dados usando BeautifulSoup com seletores identificados pela IA...")
                extracted_data = extract_data_with_bs4(html, product_selectors)
                print("\n--- Dados do Produto Extraídos ---")
                print(f"Nome do Produto: {extracted_data['name']}")
                print(f"Preço do Produto: {extracted_data['price']}")
                print(f"Descrição do Produto: {extracted_data['description']}")
            else:
                print("Falha ao obter seletores da Perplexity AI.")
        else:
            print("Falha ao buscar HTML.")
        ```

    Esta solução melhora significativamente a adaptabilidade dos seus scrapers. Ao obter seletores dinamicamente, sua lógica de raspagem se torna menos dependente de estruturas de sites estáticas, reduzindo a manutenção e melhorando a longevidade dos seus pipelines de extração de dados. Esta abordagem é particularmente valiosa para monitorar sites que passam por atualizações frequentes de design, garantindo um fluxo contínuo de dados sem intervenção manual constante.



### 6. Raspagem Web em Tempo Real com a Perplexity AI

Dados em tempo real são cruciais para muitas aplicações, desde análise de mercado de ações até inteligência competitiva imediata. Esta solução demonstra como a Perplexity AI pode ser integrada em um pipeline de raspagem em tempo real para fornecer insights instantâneos.
* **Descrição:** A raspagem de dados da web em tempo real envolve o monitoramento contínuo de sites em busca de novas informações ou atualizações e o processamento delas assim que se tornam disponíveis. Ao combinar um mecanismo de captura de dados rápido com a Perplexity AI, você pode alcançar extração e análise quase instantâneas de novo conteúdo. Isso é particularmente útil para acompanhar dados em rápida mudança, como preços ao vivo, feeds de notícias ou tendências de redes sociais. A capacidade da Perplexity AI de analisar rapidamente e extrair informações relevantes de HTML recém-raspado a torna um componente ideal para tal sistema.

* **Exemplo de Código/Passo a Passo:**

    1. **Instale as bibliotecas necessárias:**

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

    2. **Configure sua chave da API Perplexity AI** (como nas soluções anteriores).

    3. **Escreva o script em Python:** Este exemplo usa a biblioteca `schedule` por simplicidade para simular o monitoramento em tempo real, mas em um ambiente de produção, filas de mensagens ou arquiteturas orientadas a eventos seriam mais adequadas.

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

        # Defina sua chave da API Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_API_PERPLEXITY")

        # Conecte o cliente OpenAI com o instructor para saída estruturada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class NewsArticle(BaseModel):
            title: str
            author: str
            summary: str
            url: str

        def fetch_html(url):
            """Obtém o conteúdo HTML de uma URL dada."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Erro ao buscar URL {url}: {e}")
                return None

        def extract_news_with_perplexity(html_content, article_url):
            """Usa a Perplexity AI para extrair detalhes do artigo de notícias."""
            if not html_content:
                return None
            
            try:
                extracted_data = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=NewsArticle,
                    messages=[
                        {"role": "system", "content": "Você é um assistente de IA que extrai informações estruturadas de artigos de notícias a partir de conteúdo HTML. Extraia os detalhes solicitados no esquema JSON fornecido."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia o título, autor e um breve resumo do artigo de notícias. A URL do artigo é {article_url}."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Erro ao extrair dados de notícias com a Perplexity AI: {e}")
                return None

        def real_time_scrape_job(target_url):
            print(f"\n--- Executando trabalho de raspagem em tempo real para {target_url} em {time.ctime()} ---")
            html = fetch_html(target_url)
            if html:
                news_article = extract_news_with_perplexity(html, target_url)
                if news_article:
                    print("\n--- Artigo de Notícias Extraído ---")
                    print(f"Título: {news_article.title}")
                    print(f"Autor: {news_article.author}")
                    print(f"Resumo: {news_article.summary}")
                    print(f"URL: {news_article.url}")
                else:
                    print("Falha ao extrair informações do artigo de notícias.")
            else:
                print("Falha ao buscar HTML para o trabalho em tempo real.")

        # Exemplo de Uso: Agendar para executar a cada 5 minutos
        # Nota: Substitua por uma página de notícias ou blog real para teste
        news_target_url = "https://www.example.com/latest-news" # Substitua por uma URL real e frequentemente atualizada
        
        # Agende o trabalho para ser executado a cada 5 minutos
        # schedule.every(5).minutes.do(real_time_scrape_job, news_target_url)

        print(f"Iniciando a raspagem em tempo real para {news_target_url}. Pressione Ctrl+C para parar.")
        # while True:
        #     schedule.run_pending()
        #     time.sleep(1)
        
        # Para demonstração, execute uma vez imediatamente
        real_time_scrape_job(news_target_url)
        ```
Esta solução demonstra como a Perplexity AI pode ser um componente poderoso em um pipeline de dados em tempo real. Ao automatizar a extração de informações estruturadas de conteúdo da web em rápida mudança, ela permite que as empresas reagem rapidamente a novas informações, mantenham conjuntos de dados atualizados e ganhem uma vantagem competitiva. A combinação de busca eficiente de dados e análise inteligente de IA garante que seus esforços de scraping em tempo real gerem insights valiosos e acionáveis sem atrasos significativos.

### 7. Extração de Várias Páginas e Paginação com Perplexity AI

Muitos sites exibem dados em várias páginas, exigindo o manuseio de paginação. Esta solução mostra como a Perplexity AI pode ajudar na navegação e extração de dados de conteúdo paginado.

*   **Descrição:** Ao extrair dados espalhados por várias páginas (por exemplo, resultados de busca, listas de produtos), um scraper precisa identificar e seguir links de paginação. A Perplexity AI pode ser usada não apenas para extrair dados de cada página, mas também para identificar inteligentemente a URL da próxima página ou controles de paginação. Isso torna a lógica de paginação mais robusta, já que a IA pode se adaptar a diferentes padrões de paginação (por exemplo, botões 'Próximo', números de página, funcionalidade 'Carregar Mais') com base em instruções em linguagem natural.

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

    1.  **Instale as bibliotecas necessárias:**

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

    2.  **Configure sua chave da API Perplexity AI** (como nas soluções anteriores).

    3.  **Escreva o script em Python:**

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

        # Defina sua chave da API Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_PERPLEXITY_API")

        # Atualize o cliente OpenAI com o instructor para saída estruturada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

        class ProductSummary(BaseModel):
            title: str
            price: str
            link: str

        class PaginationInfo(BaseModel):
            next_page_url: str | None = None

        def fetch_html(url):
            """Busca o conteúdo HTML de uma URL dada."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Erro ao buscar URL {url}: {e}")
                return None

        def extract_products_and_pagination(html_content, current_url):
            """Usa a Perplexity AI para extrair resumos de produtos e a URL da próxima página."""
            if not html_content:
                return [], None
            
            try:
                # Extrai resumos de produtos
                products_prompt = "Extraia o título, preço e link direto para cada produto listado nesta página. Forneça como uma lista de objetos JSON."
                products_raw = client.chat.completions.create(
                    model="sonar-small-online",
                    messages=[
                        {"role": "system", "content": "Você é um assistente de IA que extrai informações estruturadas de conteúdo HTML. Extraia os detalhes solicitados em um array JSON de objetos."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nInstrução: {products_prompt}"}
                    ],
                    response_model=list[ProductSummary]
                )

                # Identifica a URL da próxima página
                pagination_prompt = f"Do HTML fornecido, identifique a URL para a próxima página de resultados. Se não houver próxima página, retorne nulo. A URL da página atual é {current_url}."
                pagination_info = client.chat.completions.create(
                    model="sonar-small-online",
                    messages=[
                        {"role": "system", "content": "Você é um assistente de IA que identifica links de paginação a partir de conteúdo HTML."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nInstrução: {pagination_prompt}"}
                    ],
                    response_model=PaginationInfo
                )
                
                return products_raw, pagination_info.next_page_url
            except Exception as e:
                print(f"Erro ao extrair dados ou paginação com a Perplexity AI: {e}")
                return [], None

        # Exemplo de Uso
        base_url = "https://www.example.com/search-results?page=" # Substitua por uma URL paginada real
        current_page = 1
        all_products = []
        next_url = f"{base_url}{current_page}"

        print("Iniciando a extração de várias páginas...")
        while next_url and current_page <= 3: # Limite para 3 páginas como exemplo
            print(f"Extraindo a página: {next_url}")

    print("\n--- Todos os Produtos Extraídos ---")
    para produto em todos_produtos:
        print(f"Título: {produto.titulo}, Preço: {produto.preco}, Link: {produto.link}")
    print(f"Total de produtos extraídos: {len(todos_produtos)}")
    
Esta solução demonstra como a Perplexity AI pode simplificar a tarefa complexa de raspagem de várias páginas. Ao identificar inteligência tanto os dados quanto o próximo link de paginação, reduz a necessidade de lógica personalizada para o esquema de paginação único de cada site, tornando seus raspadores mais adaptáveis e eficientes para a coleta de dados em larga escala. Este é um passo significativo em direção à construção de agentes de raspagem verdadeiramente autônomos que podem navegar e extrair informações de sites inteiros.

```python
target_url = event.get("url")
            if not target_url:
                return {
                    "statusCode": 400,
                    "body": json.dumps({"message": "Faltando 'url' no payload do 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": "Falha ao extrair informações do produto."})
                    }
            else:
                return {
                    "statusCode": 500,
                    "body": json.dumps({"message": "Falha ao buscar HTML."})
                }
        ```

    4.  **Etapas de Implantação (Geral):**
        *   Empacote seu `lambda_function.py` junto com todas as suas dependências (incluindo `openai`, `requests`, `pydantic`, `instructor`) em um pacote de implantação (por exemplo, um arquivo `.zip`).
        *   Faça o upload do pacote para o seu provedor de nuvem escolhido (por exemplo, AWS Lambda).
        *   Configure a função com a memória, timeout e variáveis de ambiente apropriadas (especialmente `PERPLEXITY_API_KEY`).
        *   Configure os gatilhos (por exemplo, API Gateway para solicitações HTTP, SQS para processamento baseado em fila, EventBridge para tarefas agendadas).

    Esta abordagem serverless permite que você construa soluções de web scraping altamente escaláveis, rentáveis e orientadas a eventos. Ao transferir a execução para funções em nuvem, você paga apenas pelo tempo de computação realmente utilizado, tornando-se ideal para cargas de trabalho flutuantes e coleta de dados em larga escala. As capacidades de parseamento inteligente da Perplexity AI dentro dessa arquitetura garantem que mesmo com altos volumes, os dados extraídos permaneçam precisos e estruturados.



### 9. Tratamento de Erros e Robutez no Scraping da Perplexity AI

Construir scrapers da web robustos requer um tratamento abrangente de erros para gerenciar de forma eficiente problemas de rede, mudanças de site e falhas na API. Esta solução descreve estratégias para tornar os scrapers impulsionados pela Perplexity AI mais resilientes.

*   **Descrição:** Mesmo com a Perplexity AI, problemas inesperados podem surgir durante o web scraping. Implementar o tratamento adequado de erros garante que seu scraper não falhe e possa se recuperar ou registrar falhas de forma eficaz. Isso inclui lidar com erros HTTP, timeouts de rede, erros na API da Perplexity AI e casos em que a IA pode não conseguir extrair dados conforme esperado. As estratégias envolvem mecanismos de tentativa, processamento de fallback e registro detalhado.

*   **Exemplo de Código/Etapas:**

    1.  **Instale as bibliotecas necessárias:**

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

    2.  **Configure sua chave da API da Perplexity AI** (como nas soluções anteriores).

    3.  **Escreva o script em Python:** Este exemplo incorpora `tenacity` para uma lógica de retry robusta e um tratamento de erros mais abrangente.

        ```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 logging
        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

        # Defina sua chave da API da Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_DA_API_PERPLEXITY")

        # Patch do cliente OpenAI com instructor para saída estruturada
        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 retry para requisições de rede
        @retry(stop=stop_after_attempt(3), wait=wait_fixed(2), retry=retry_if_exception_type(requests.exceptions.RequestException))
        def fetch_html_robust(url):
            """Busca o conteúdo HTML de uma dada URL com tentativas."""
            logging.info(f"Attemptando buscar HTML de {url}")
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            return response.text

        # Decorador de retry para chamadas da 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 a Perplexity AI para extrair dados estruturados do HTML com tentativas."""
            if not html_content:
                logging.warning("Nenhum conteúdo HTML fornecido para extração.")
                return None

logging.info("Tentando extrair dados com a Perplexity AI.")
            extracted_data = client.chat.completions.create(
                model="sonar-small-online",
                response_model=target_model,
                messages=[
                    {"role": "system", "content": "Você é um assistente de IA que extrai informações estruturadas de conteúdo HTML. Extraia os detalhes solicitados para o esquema JSON fornecido."},
                    {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia os seguintes detalhes do produto: nome, preço e descrição."}
                ]
            )
            return extracted_data

        # Exemplo de uso
        target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        # Exemplo de uma URL que pode falhar (por exemplo, 404 ou erro de rede)
        # failing_url = "https://www.example.com/non-existent-page"

        print(f"\n--- Processando {target_url} ---")
        try:
            html = fetch_html_robust(target_url)
            if html:
                product_info = extract_structured_data_robust(html, ProductDetails)
                if product_info:
                    print("\n--- Detalhes do Produto Extraídos ---")
                    print(f"Nome: {product_info.name}")
                    print(f"Preço: {product_info.price}")
                    print(f"Descrição: {product_info.description}")
                else:
                    logging.error("A Perplexity AI falhou ao extrair dados após várias tentativas.")
            else:
                logging.error("Falha ao buscar HTML após várias tentativas.")
        except Exception as e:
            logging.critical(f"Erro crítico durante o processo de scraping para {target_url}: {e}")

        # Exemplo com uma URL potencialmente falhadora (descomente para testar)
        # print(f"\n--- Processando {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--- Detalhes do Produto Extraídos (URL Falhadora) ---")
        #             print(f"Nome: {product_info_failing.name}")
        #             print(f"Preço: {product_info_failing.price}")
        #             print(f"Descrição: {product_info_failing.description}")
        #         else:
        #             logging.error("A Perplexity AI falhou ao extrair dados da URL falhadora após várias tentativas.")
        #     else:
        #         logging.error("Falha ao buscar HTML da URL falhadora após várias tentativas.")
        # except Exception as e:
        #     logging.critical(f"Erro crítico durante o processo de scraping para {failing_url}: {e}")
        ```

    Esta solução enfatiza a importância de construir resiliência em suas operações de scraping. Ao implementar mecanismos de retry, tratamento de erros abrangente e registro detalhado, você pode criar scrapers alimentados pela Perplexity AI que são mais confiáveis e menos propensos a interrupções. Isso é crucial para manter fluxos de dados contínuos e garantir a integridade dos dados coletados, mesmo diante de ambientes web imprevisíveis.

### 10. Transformação e Limpeza Avançada de Dados com a Perplexity AI

Os dados extraídos brutos geralmente exigem transformação e limpeza adicionais antes de serem utilizados efetivamente. A Perplexity AI pode ser utilizada para automatizar esses processos pós-extração, garantindo a qualidade e consistência dos dados.

*   **Descrição:** Após a extração inicial de dados, os dados podem estar em formatos inconsistentes, conter ruídos ou exigir enriquecimento (por exemplo, conversão de moedas, padronização de datas, categorização de texto). A Perplexity AI, com suas fortes capacidades de compreensão de linguagem natural, pode ser utilizada para realizar essas tarefas avançadas de transformação e limpeza. Ao fornecer à IA os dados extraídos e instruções claras, ela pode reformatar, limpar e até enriquecer os dados, preparando-os para análise ou armazenamento. Isso reduz a necessidade de scripts de limpeza baseados em regras complexas e torna o pipeline de dados mais adaptável.

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

    1.  **Instalar as bibliotecas necessárias:**

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

    2.  **Configure sua chave da API da Perplexity AI** (como nas soluções anteriores).

    3.  **Escreva o script em Python:** Este exemplo demonstra a limpeza e padronização de detalhes do produto.

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

        # Defina sua chave da API da Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_API_PERPLEXITY")
        
        # Patch do cliente OpenAI com instrutor para saída estruturada
        client = instructor.patch(OpenAI(api_key=perplexity_api_key, base_url="https://api.perplexity.ai"))

class DetalhesProdutoBruto(BaseModel):
            nome: str
            preco_bruto: str = Field(alias="preco") # Usar alias para input potencialmente bagunçado
            descricao_bruta: str = Field(alias="descricao")

        class DetalhesProdutoEstruturado(BaseModel):
            nome_produto: str
            preco_usd: float
            resumo_descricao: str
            categoria: str

        def buscar_html(url):
            """Busca o conteúdo HTML de uma URL dada."""
            try:
                resposta = requests.get(url, timeout=10)
                resposta.raise_for_status()
                return resposta.text
            except requests.exceptions.RequestException as e:
                print(f"Erro ao buscar URL {url}: {e}")
                return None

        def extrair_dados_brutos_com_perplexidade(conteudo_html):
            """Usa a Perplexity AI para extrair dados brutos do HTML."""
            if not conteudo_html:
                return None
            
            try:
                dados_brutos = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=DetalhesProdutoBruto,
                    messages=[
                        {"role": "system", "content": "Você é um assistente AI que extrai informações brutas de produtos a partir de conteúdo HTML. Extraia o nome, preço e descrição."},
                        {"role": "user", "content": f"Conteúdo HTML: {conteudo_html}\n\nExtraia o nome do produto, sua string de preço bruto e sua descrição bruta."}
                    ]
                )
                return dados_brutos
            except Exception as e:
                print(f"Erro ao extrair dados brutos com a Perplexity AI: {e}")
                return None

        def transformar_e_limpar_dados_com_perplexidade(dados_brutos: DetalhesProdutoBruto):
            """Usa a Perplexity AI para transformar e limpar dados brutos extraídos."""
            if not dados_brutos:
                return None
            
            prompt_transformacao = f"Limpe e transforme os seguintes dados do produto em um formato estruturado:\n\nNome do Produto: {dados_brutos.nome}\nPreço Bruto: {dados_brutos.preco_bruto}\nDescrição Bruta: {dados_brutos.descricao_bruta}\n\nInstruções:\n1. Padronize o nome do produto (por exemplo, remova espaços extras, capitalize).
2. Converta o preço bruto para um float em USD. Se a moeda não for USD, assume-se que é e converta se necessário (por exemplo, '€100' para 100.0).
3. Resuma a descrição para um máximo de 50 palavras.
4. Inferir uma única categoria de produto (por exemplo, 'Eletrônicos', 'Vestuário', 'Livros') com base no nome e descrição.\n\nForneça a saída como um objeto JSON que corresponda ao esquema DetalhesProdutoEstruturado."

            try:
                dados_limpos = client.chat.completions.create(
                    model="sonar-small-online",
                    response_model=DetalhesProdutoEstruturado,
                    messages=[
                        {"role": "system", "content": "Você é um assistente AI que limpa e transforma dados brutos em um formato estruturado e padronizado com base nas instruções do usuário e em um esquema JSON fornecido."},
                        {"role": "user", "content": prompt_transformacao}
                    ]
                )
                return dados_limpos
            except Exception as e:
                print(f"Erro ao transformar dados com a Perplexity AI: {e}")
                return None

        # Exemplo de Uso
        url_alvo = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
        html = buscar_html(url_alvo)

        if html:
            print("HTML buscado. Extraindo dados brutos com a Perplexity AI...")
            info_produto_bruto = extrair_dados_brutos_com_perplexidade(html)
            
            if info_produto_bruto:
                print("\n--- Detalhes do Produto Bruto Extraído ---")
                print(f"Nome: {info_produto_bruto.nome}")
                print(f"Preço Bruto: {info_produto_bruto.preco_bruto}")
                print(f"Descrição Bruta: {info_produto_bruto.descricao_bruta}")

                print("\nTransformando e limpando dados com a Perplexity AI...")
                info_produto_limpo = transformar_e_limpar_dados_com_perplexidade(info_produto_bruto)

                if info_produto_limpo:
                    print("\n--- Detalhes do Produto Limpo e Transformado ---")
                    print(f"Nome do Produto: {info_produto_limpo.nome_produto}")
                    print(f"Preço (USD): {info_produto_limpo.preco_usd:.2f}")
                    print(f"Resumo da Descrição: {info_produto_limpo.resumo_descricao}")
                    print(f"Categoria: {info_produto_limpo.categoria}")
                    print(f"Saída JSON: {info_produto_limpo.model_dump_json(indent=2)}")
                else:
                    print("Falha ao limpar e transformar as informações do produto.")
            else:
                print("Falha ao extrair informações brutas do produto.")
        else:
            print("Falha ao buscar HTML.")

Esta solução demonstra a versatilidade da Perplexity AI além da simples extração. Ao aproveitar suas capacidades de linguagem natural para a transformação e limpeza de dados, você pode agilizar significativamente seus fluxos de trabalho pós-scraping. Esta abordagem é particularmente benéfica para manter alta qualidade dos dados, garantindo consistência entre diversas fontes de dados e preparando os dados para uso imediato em análises, modelos de aprendizado de máquina ou painéis de inteligência de negócios. Ela transforma dados brutos e desorganizados da web em insights limpos e acionáveis com mínima intervenção manual.

### 8. Integrando a Perplexity AI com Funções em Nuvem para Scraping Escalável

Para tarefas de scraping em grande escala, acionadas por eventos ou programadas, integrar a Perplexity AI com funções em nuvem sem servidor (por exemplo, AWS Lambda, Google Cloud Functions, Azure Functions) oferece imensa escalabilidade e eficiência de custos.

*   **Descrição:** Funções em nuvem permitem que você execute código em resposta a eventos (como a aparição de um novo item em uma fila ou um cronômetro agendado) sem a necessidade de provisionar ou gerenciar servidores. Ao implantar sua lógica de scraping impulsionada pela Perplexity AI dentro de uma função em nuvem, você pode criar soluções de scraping altamente escaláveis e econômicas. Cada invocação da função pode lidar com uma única tarefa de scraping, aproveitando a Perplexity AI para extração inteligente de dados e escalando automaticamente para atender à demanda. Esta arquitetura é ideal para processar grandes volumes de URLs ou para monitoramento contínuo de muitos sites.

*   **Exemplo de Código/Passo a Passo:**

    1.  **Pré-requisitos:**
        *   Uma conta AWS, Google Cloud ou Azure.
        *   Familiaridade com a implantação de funções sem servidor.
        *   Chave de API da Perplexity AI configurada de forma segura (por exemplo, através de variáveis de ambiente na função em nuvem).

    2.  **Instale as bibliotecas necessárias (para desenvolvimento local e empacotamento):**

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

    3.  **Exemplo (AWS Lambda com Python):**

        Crie um arquivo `lambda_function.py`:

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

        # Inicializa o cliente da Perplexity AI
        perplexity_api_key = os.getenv("PERPLEXITY_API_KEY")
        if not perplexity_api_key:
            raise ValueError("A variável de ambiente PERPLEXITY_API_KEY não está definida.")

        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):
            """Busca o conteúdo HTML de uma URL dada."""
            try:
                response = requests.get(url, timeout=10)
                response.raise_for_status()
                return response.text
            except requests.exceptions.RequestException as e:
                print(f"Erro ao buscar URL {url}: {e}")
                return None

        def extract_structured_data_with_perplexity(html_content, target_model: BaseModel):
            """Usa a Perplexity AI para extrair dados estruturados do HTML com base em um modelo 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": "Você é um assistente de IA que extrai informações estruturadas do conteúdo HTML. Extraia os detalhes solicitados para o esquema JSON fornecido."},
                        {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia os seguintes detalhes do produto: nome, preço e descrição."}
                    ]
                )
                return extracted_data
            except Exception as e:
                print(f"Erro ao extrair dados estruturados com a Perplexity AI: {e}")
                return None

        def lambda_handler(event, context):
            """Manipulador da função AWS Lambda."""
            print(f"Evento recebido: {json.dumps(event)}")
            
            # Esperando \'url\' na carga útil do evento
            target_url = event.get("url")
            if not target_url:
                return {
                    "statusCode": 400,
                    "body": json.dumps({"message": "Faltando \'url\' na carga útil do 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": "Falha ao extrair informações do produto."})
}
} else {
return {
"statusCode": 500,
"body": json.dumps({"message": "Falha ao buscar HTML."})
}
}

4. **Passos de Implantação (Geral):**
* Empacote seu `lambda_function.py` juntamente com todas as suas dependências (incluindo `openai`, `requests`, `pydantic`, `instructor`) em um pacote de implantação (por exemplo, um arquivo `.zip`).
* Carregue o pacote no seu provedor de nuvem escolhido (por exemplo, AWS Lambda).
* Configure a função com a memória apropriada, tempo limite e variáveis de ambiente (especialmente `PERPLEXITY_API_KEY`).
* Configure acionadores (por exemplo, API Gateway para requisições HTTP, SQS para processamento baseado em fila, EventBridge para tarefas agendadas).

Esta abordagem sem servidor permite que você construa soluções de web scraping altamente escaláveis, econômicas e orientadas a eventos. Ao transferir a execução para funções em nuvem, você paga apenas pelo tempo de computação realmente utilizado, tornando-a ideal para cargas de trabalho flutuantes e coleta de dados em grande escala. As capacidades de análise inteligente da Perplexity AI dentro desta arquitetura garantem que, mesmo com altos volumes, os dados extraídos permaneçam precisos e estruturados.

### 9. Tratamento de Erros e Robustez na Extração com Perplexity AI

Construir raspadores web robustos requer um tratamento de erros abrangente para gerenciar graciosamente problemas de rede, mudanças em sites e falhas de API. Esta solução descreve estratégias para tornar os raspadores alimentados pelo Perplexity AI mais resilientes.

* **Descrição:** Mesmo com o Perplexity AI, problemas inesperados podem surgir durante o web scraping. Implementar um tratamento de erros adequado garante que seu raspador não falhe e possa se recuperar ou registrar falhas de forma eficaz. Isso inclui lidar com erros HTTP, tempos limite de rede, erros na API do Perplexity AI e casos em que a IA pode falhar ao extrair dados conforme esperado. As estratégias envolvem mecanismos de repetição, parsing de fallback e registro detalhado.

* **Exemplo de Código/Passos:**

1. **Instalar bibliotecas necessárias:**

```bash
pip install openai requests pydantic instructor tenacity

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ção de logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Defina sua chave da API do Perplexity AI
perplexity_api_key = os.getenv("PERPLEXITY_API_KEY", "SUA_CHAVE_DE_API_PERPLEXITY")

# Modifique o cliente OpenAI com o instructor para saída estruturada
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 repetição para requisições de rede
@retry(stop=stop_after_attempt(3), wait=wait_fixed(2), retry=retry_if_exception_type(requests.exceptions.RequestException))
def fetch_html_robust(url):
    """Busca o conteúdo HTML de uma URL dada com repetições."""
    logging.info(f"Attemptando buscar HTML de {url}")
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    return response.text

# Decorador de repetição para chamadas do 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 o Perplexity AI para extrair dados estruturados do HTML com repetições."""
    if not html_content:
        logging.warning("Nenhum conteúdo HTML fornecido para extração.")
        return None
    
    logging.info("Tentando extrair dados com Perplexity AI.")
    extracted_data = client.chat.completions.create(
        model="sonar-small-online",
        response_model=target_model,
        messages=[
            {"role": "system", "content": "Você é um assistente de IA que extrai informações estruturadas do conteúdo HTML. Extraia os detalhes solicitados para o esquema JSON fornecido."},
            {"role": "user", "content": f"Conteúdo HTML: {html_content}\n\nExtraia os seguintes detalhes do produto: nome, preço e descrição."}
        ]
    )
    return extracted_data

    target_url = "https://www.scrapingcourse.com/ecommerce/product/ajax-full-zip-sweatshirt/"
    # Exemplo de uma URL que pode falhar (por exemplo, 404 ou erro de rede)
    # failing_url = "https://www.example.com/non-existent-page"

    print(f"\n--- Processando {target_url} ---")
    try:
        html = fetch_html_robust(target_url)
        if html:
            product_info = extract_structured_data_robust(html, ProductDetails)
            if product_info:
                print("\n--- Detalhes do Produto Extraídos ---")
                print(f"Nome: {product_info.name}")
                print(f"Preço: {product_info.price}")
                print(f"Descrição: {product_info.description}")
            else:
                logging.error("Perplexity AI falhou em extrair dados após tentativas.")
        else:
            logging.error("Falha ao buscar HTML após tentativas.")
    except Exception as e:
        logging.critical(f"Erro crítico durante o processo de scraping para {target_url}: {e}")

    # Exemplo com uma URL que pode falhar (descomente para testar)
    # print(f"\n--- Processando {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--- Detalhes do Produto Extraídos (URL com Falha) ---")
    #             print(f"Nome: {product_info_failing.name}")
    #             print(f"Preço: {product_info_failing.price}")
    #             print(f"Descrição: {product_info_failing.description}")
    #         else:
    #             logging.error("Perplexity AI falhou em extrair dados da URL com falha após tentativas.")
    #     else:
    #         logging.error("Falha ao buscar HTML da URL com falha após tentativas.")
    # except Exception as e:
    #     logging.critical(f"Erro crítico durante o processo de scraping para {failing_url}: {e}")
    ```

Esta solução enfatiza a importância de construir resiliência em suas operações de scraping. Ao implementar mecanismos de repetição, tratamento de erros abrangente e logging detalhado, você pode criar scrapers alimentados por Perplexity AI que são mais confiáveis e menos propensos a interrupções. Isso é crucial para manter fluxos de dados contínuos e garantir a integridade dos dados coletados, mesmo diante de ambientes web imprevisíveis.