Faça como eu fiz: lidar com exceções e IA

import os
import json
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
base_url=os.getenv("OLLAMA_BASE_URL", "http://localhost:11434/v1"),
api_key=os.getenv("OLLAMA_API_KEY", "ollama_local")
)
MODELO_LOCAL = os.getenv("MODELO_LOCAL", "gemma2:2b")

def chamar_llm_seguro(prompt: str) -> str:
"""
Realiza a chamada ao LLM local isolada em um bloco try/except.
Retorna apenas a primeira palavra da resposta, normalizada.
"""
try:
resposta = client.chat.completions.create(
model=MODELO_LOCAL,
messages=[
{
"role": "system",
"content": (
"Você é um assistente conciso. "
"Responda EXCLUSIVAMENTE com uma única palavra em português, "
"sem explicações, sem pontuação extra, sem aspas."
),
},
{"role": "user", "content": prompt},
],
temperature=0.0,
)
conteudo = resposta.choices[0].message.content.strip()
# Pega só o primeiro token e remove pontuação residual
primeira_palavra = conteudo.split()[0].strip(".,;:!?"'")
return primeira_palavra

except ConnectionError:
    print("[ERRO]: Não foi possível conectar ao servidor local do Ollama/LM Studio. Ele está ativo?")
    return "Erro_Conexao"

except Exception as e:
    print(f"[ERRO IMPREVISTO]: Falha na comunicação com a IA. Detalhes: {e}")
    return "Erro_Processamento"

def processar_lote_e_contar(df: pd.DataFrame) -> tuple[pd.DataFrame, dict]:
"""Processa o DataFrame em lote, classifica as resenhas e conta as avaliações."""
print("\n--- Iniciando Processamento em Lote ---")
df = df.copy() # evita SettingWithCopyWarning
df["categoria_ia"] = df["resenha"].apply(
lambda r: chamar_llm_seguro(
f"Classifique a categoria do problema desta resenha em UMA única palavra "
f"(Ex: Entrega, Qualidade, Suporte): '{r}'"
)
)
contagem_dict = df["categoria_ia"].value_counts().to_dict()

return df, contagem_dict

def unificar_resultados(df_processado: pd.DataFrame, contagem: dict) -> str:
"""Une os resultados individuais e as métricas em um único texto formatado."""
linhas_texto = ["=== RELATÓRIO CONSOLIDADO DE AVALIAÇÕES ==="]
# Detalhamento por resenha
linhas_texto.append("\n--- Detalhamento por Resenha ---")
for _, linha in df_processado.iterrows():
linhas_texto.append(
f"Resenha: '{linha['resenha']}' -> Classificação: {linha['categoria_ia']}"
)
linhas_texto.append("\n--- Resumo Estatístico ---")
if contagem:
for categoria, total in contagem.items():
linhas_texto.append(f"Categoria [{categoria}]: {total} avaliação(ões).")
else:
linhas_texto.append("Nenhuma categoria foi gerada.")

return "\n".join(linhas_texto)

def salvar_resultados(df_resultado: pd.DataFrame, contagem: dict, relatorio: str) -> None:
"""Persiste os resultados em dois formatos: TXT (legível) e JSON (estruturado)."""
with open("relatorio_avaliacoes.txt", "w", encoding="utf-8") as f:
f.write(relatorio)
payload = {
"detalhes": df_resultado.to_dict(orient="records"),
"resumo": contagem,
}
with open("relatorio_avaliacoes.json", "w", encoding="utf-8") as f:
json.dump(payload, f, ensure_ascii=False, indent=2)

print("\n[OK] Relatórios salvos: 'relatorio_avaliacoes.txt' e 'relatorio_avaliacoes.json'")

if name == "main":
dados_exemplo = {
"resenha": [
"O produto chegou quebrado e trincado.",
"Demorou mais de 3 semanas para chegar na minha casa.",
"Ninguém me responde no chat do suporte.",
"A caixa veio vazia, um absurdo!",
"Atendimento nota 10, resolveram meu problema rapidamente.",
]
}
df_inicial = pd.DataFrame(dados_exemplo)
df_resultado, dicionario_contagem = processar_lote_e_contar(df_inicial)
relatorio_final = unificar_resultados(df_resultado, dicionario_contagem)
print("\n" + relatorio_final)
salvar_resultados(df_resultado, dicionario_contagem, relatorio_final)

Olá, Marcelo! Como vai?

Parabéns pela realização das atividades!

Você conseguiu apresentar um código bem estruturado com tratamento de exceções, demonstrou clareza ao manipular dados com pandas e ainda trouxe uma integração prática com LLMs para análise de resenhas. Além disso, mostrou preocupação em salvar os resultados em diferentes formatos, o que evidencia organização e visão prática. Isso reforça a importância de unir boas práticas de programação com inteligência artificial para gerar relatórios úteis e confiáveis.

Se quiser aprofundar ainda mais, algumas boas práticas são:

• Documentar funções: manter descrições claras para facilitar manutenção e colaboração.
• Validar entradas: garantir que os dados recebidos estejam no formato esperado antes do processamento.
• Automatizar testes: criar pequenos testes unitários para validar cada parte do fluxo.

Ah uma pergunta: O que você considera mais interessante neste processo, a parte de estruturar o código com segurança ou observar como a IA classifica e organiza as resenhas automaticamente?

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!