Update app.py

app.py

@@ -1,13 +1,12 @@
 import tweepy
-from transformers import pipeline, GPT2LMHeadModel, GPT2Tokenizer, AutoModelForSequenceClassification, AutoTokenizer
+from transformers import pipeline, GPT2LMHeadModel, GPT2Tokenizer
 import os
 import streamlit as st
 from datetime import datetime
 import time
 from tenacity import retry, stop_after_attempt, wait_exponential
-import torch
-from collections import Counter
 import re
+from collections import Counter
 
 def debug_print(message):
     """Função para imprimir mensagens de debug tanto no console quanto no Streamlit"""
@@ -15,175 +14,109 @@ def debug_print(message):
     st.text(message)
 
 @retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=4, max=10),
+    stop=stop_after_attempt(2),  # Reduzido para 2 tentativas
+    wait=wait_exponential(multiplier=1, min=2, max=4),  # Tempo de espera reduzido
     retry=lambda e: isinstance(e, tweepy.errors.TooManyRequests)
 )
 def fetch_tweets(client, query, tweet_fields):
     try:
-        debug_print(f"Iniciando busca com query: {query}")
-        debug_print(f"Campos solicitados: {tweet_fields}")
-        
         tweets = client.search_recent_tweets(
             query=query,
-            max_results=100,  # Aumentado para ter mais contexto
+            max_results=10,  # Reduzido para 10 tweets
             tweet_fields=tweet_fields
         )
         
-        if tweets is None:
-            debug_print("Nenhum resultado retornado da API")
+        if not hasattr(tweets, 'data') or tweets.data is None:
             return None
             
-        if not hasattr(tweets, 'data'):
-            debug_print("Resposta não contém dados")
-            return None
-            
-        debug_print(f"Tweets encontrados: {len(tweets.data) if tweets.data else 0}")
         return tweets
         
-    except tweepy.errors.TooManyRequests as e:
-        debug_print(f"Rate limit atingido: {str(e)}")
-        raise e
-    except tweepy.errors.TwitterServerError as e:
-        debug_print(f"Erro do servidor Twitter: {str(e)}")
-        raise e
-    except tweepy.errors.BadRequest as e:
-        debug_print(f"Erro na requisição: {str(e)}")
-        raise e
     except Exception as e:
-        debug_print(f"Erro inesperado na busca: {str(e)}")
-        raise e
+        debug_print(f"Erro na busca: {str(e)}")
+        return None
 
-@retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=4, max=10),
-    retry=lambda e: isinstance(e, tweepy.errors.TooManyRequests)
-)
 def post_tweet(client, text):
     try:
         response = client.create_tweet(text=text)
         return response
     except Exception as e:
         debug_print(f"Erro ao postar tweet: {str(e)}")
-        raise e
-
-def initialize_text_generator():
-    """Inicializa o modelo de geração de texto"""
-    # Usando um modelo GPT-2 em português maior para melhor qualidade
-    model_name = "pierreguillou/gpt2-small-portuguese"
-    tokenizer = GPT2Tokenizer.from_pretrained(model_name)
-    model = GPT2LMHeadModel.from_pretrained(model_name)
-    return model, tokenizer
+        return None
 
 def extract_context_from_tweets(tweets_data):
-    """Extrai contexto relevante dos tweets"""
+    """Versão simplificada da extração de contexto"""
     all_text = " ".join([tweet.text for tweet in tweets_data])
-    
-    # Remover URLs, mentions, RTs e caracteres especiais
     clean_text = re.sub(r'http\S+|@\S+|RT|[^\w\s]', ' ', all_text)
     
-    # Encontrar nomes de participantes (palavras capitalizadas frequentes)
+    # Encontrar nomes capitalizados frequentes
     words = clean_text.split()
     capitalized_words = [word for word in words if word.istitle() and len(word) > 2]
-    participants = Counter(capitalized_words).most_common(5)
-    
-    # Encontrar temas/eventos importantes
-    # Procurar por frases comuns que indicam eventos
-    event_patterns = [
-        r'paredão entre.*?(?=\s|$)',
-        r'prova do líder.*?(?=\s|$)',
-        r'prova do anjo.*?(?=\s|$)',
-        r'eliminação.*?(?=\s|$)',
-        r'briga entre.*?(?=\s|$)',
-        r'jogo da discórdia.*?(?=\s|$)'
-    ]
+    participants = Counter(capitalized_words).most_common(3)  # Reduzido para 3
     
+    # Eventos simplificados
     events = []
-    for pattern in event_patterns:
-        matches = re.findall(pattern, all_text.lower())
-        if matches:
-            events.extend(matches)
+    event_keywords = ['paredão', 'prova', 'líder', 'eliminação', 'briga']
+    for keyword in event_keywords:
+        if keyword in clean_text.lower():
+            events.append(keyword)
     
     return {
         'participants': [p[0] for p in participants],
-        'events': list(set(events))[:3],  # Top 3 eventos únicos
+        'events': events[:2],  # Limitado a 2 eventos
         'raw_text': clean_text
     }
 
 def generate_comment(context, sentiment_ratio, model, tokenizer):
-    """Gera um comentário contextualizado sobre o BBB"""
-    
-    # Criar prompt baseado no contexto e sentimento
-    sentiment_tone = ""
+    """Versão otimizada da geração de comentários"""
+    # Determinar o tom com base no sentimento
     if sentiment_ratio['positive'] > 0.5:
-        sentiment_tone = "positivo"
+        tone = "clima animado"
     elif sentiment_ratio['negative'] > 0.5:
-        sentiment_tone = "negativo"
+        tone = "clima tenso"
     else:
-        sentiment_tone = "dividido"
+        tone = "opiniões divididas"
     
-    # Construir contexto para o prompt
-    prompt = f"No BBB25, com clima {sentiment_tone}"
+    # Construir prompt base
+    prompt = f"BBB25 com {tone}"
     
-    # Adicionar participantes relevantes
+    # Adicionar contexto se disponível
     if context['participants']:
-        participants_str = ", ".join(context['participants'][:2])
-        prompt += f", {participants_str} se destacam"
-    
-    # Adicionar eventos relevantes
+        prompt += f", {context['participants'][0]}"
     if context['events']:
-        event_str = context['events'][0]
-        prompt += f". {event_str.capitalize()}"
+        prompt += f", {context['events'][0]}"
     
     # Gerar texto
-    inputs = tokenizer.encode(prompt, return_tensors='pt', max_length=150, truncation=True)
-    
-    outputs = model.generate(
-        inputs,
-        max_length=200,
-        num_return_sequences=3,
-        temperature=0.9,
-        top_k=50,
-        top_p=0.95,
-        do_sample=True,
-        no_repeat_ngram_size=2,
-        pad_token_id=tokenizer.eos_token_id
-    )
-    
-    # Gerar múltiplas opções e escolher a melhor
-    generated_texts = []
-    for output in outputs:
-        text = tokenizer.decode(output, skip_special_tokens=True)
-        # Limpar e formatar o texto
+    try:
+        inputs = tokenizer.encode(prompt, return_tensors='pt', max_length=100, truncation=True)
+        outputs = model.generate(
+            inputs,
+            max_length=150,  # Reduzido para melhor performance
+            num_return_sequences=1,  # Apenas uma sequência
+            temperature=0.8,
+            top_k=40,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+        
+        text = tokenizer.decode(outputs[0], skip_special_tokens=True)
         text = re.sub(r'\s+', ' ', text).strip()
-        if len(text) > 30:  # Garantir que temos um texto substancial
-            generated_texts.append(text)
-    
-    # Escolher o melhor texto
-    best_text = max(generated_texts, key=len) if generated_texts else prompt
-    
-    # Adicionar hashtags relevantes
-    hashtags = " #BBB25"
-    if context['participants']:
-        hashtags += f" #{context['participants'][0].replace(' ', '')}"
-    if context['events']:
-        event_tag = context['events'][0].split()[0].capitalize()
-        hashtags += f" #{event_tag}"
-    
-    # Garantir que está dentro do limite do Twitter
-    max_length = 280 - len(hashtags)
-    if len(best_text) > max_length:
-        best_text = best_text[:max_length-3] + "..."
-    
-    return best_text + hashtags
+        
+        # Adicionar hashtags
+        hashtags = " #BBB25"
+        if len(text) + len(hashtags) > 280:
+            text = text[:277-len(hashtags)] + "..."
+        
+        return text + hashtags
+        
+    except Exception as e:
+        debug_print(f"Erro na geração: {str(e)}")
+        return f"BBB25: {tone} hoje! #BBB25"  # Fallback simples
 
 def main():
     try:
         st.title("Análise de Sentimentos - BBB25")
         
-        # Verificar variáveis de ambiente
-        debug_print("Verificando variáveis de ambiente...")
-        
+        # Verificação simplificada de variáveis de ambiente
         required_vars = [
             'TWITTER_API_KEY',
             'TWITTER_API_SECRET_KEY',
@@ -192,20 +125,10 @@ def main():
             'TWITTER_BEARER_TOKEN'
         ]
 
-        missing_vars = []
-        for var in required_vars:
-            if os.getenv(var) is None:
-                missing_vars.append(var)
-                debug_print(f"Erro: A variável de ambiente '{var}' não está definida.")
-            else:
-                debug_print(f"{var} carregada com sucesso.")
-
-        if missing_vars:
-            raise ValueError(f"Variáveis de ambiente faltando: {', '.join(missing_vars)}")
-
-        debug_print("Iniciando autenticação com Twitter...")
+        if any(os.getenv(var) is None for var in required_vars):
+            raise ValueError("Faltam variáveis de ambiente necessárias")
         
-        # Autenticação com Twitter
+        # Autenticação Twitter
         client = tweepy.Client(
             bearer_token=os.getenv('TWITTER_BEARER_TOKEN'),
             consumer_key=os.getenv('TWITTER_API_KEY'),
@@ -215,132 +138,76 @@ def main():
             wait_on_rate_limit=True
         )
 
-        # Inicializar modelo de geração de texto
-        debug_print("Inicializando modelo de geração de texto...")
-        model, tokenizer = initialize_text_generator()
+        # Inicializar modelo
+        model_name = "pierreguillou/gpt2-small-portuguese"
+        tokenizer = GPT2Tokenizer.from_pretrained(model_name)
+        model = GPT2LMHeadModel.from_pretrained(model_name)
 
-        # Query principal
+        # Buscar tweets
         query = 'BBB25 lang:pt -is:retweet -is:reply'
-        tweet_fields = ['text', 'created_at', 'lang', 'public_metrics']
-        
-        debug_print("Iniciando busca principal de tweets...")
+        tweet_fields = ['text', 'created_at']
         
         with st.spinner('Buscando tweets...'):
             tweets = fetch_tweets(client, query, tweet_fields)
             
-            if tweets is None:
+            if tweets is None or not tweets.data:
                 st.error("Não foi possível obter tweets")
                 return
             
-            if not tweets.data:
-                st.warning("Nenhum tweet encontrado com os critérios especificados")
-                debug_print("Busca retornou vazia")
-                return
-            
-            debug_print(f"Encontrados {len(tweets.data)} tweets")
-            
-            # Extrair contexto dos tweets
             context = extract_context_from_tweets(tweets.data)
-            debug_print("Contexto extraído dos tweets:")
-            debug_print(f"Participantes mencionados: {context['participants']}")
-            debug_print(f"Eventos detectados: {context['events']}")
 
         # Análise de sentimentos
         with st.spinner('Analisando sentimentos...'):
-            debug_print("Iniciando análise de sentimentos...")
-            
             sentiment_pipeline = pipeline(
                 "sentiment-analysis",
                 model="nlptown/bert-base-multilingual-uncased-sentiment"
             )
             
             sentiments = []
-            for tweet in tweets.data:
-                if hasattr(tweet, 'lang') and tweet.lang == 'pt':
-                    result = sentiment_pipeline(tweet.text)
-                    rating = int(result[0]['label'].split()[0])
-                    if rating >= 4:
-                        sentiments.append('positive')
-                    elif rating <= 2:
-                        sentiments.append('negative')
-                    else:
-                        sentiments.append('neutral')
-                    debug_print(f"Sentimento analisado: {rating} estrelas")
-                    
-            time.sleep(1)
-                
+            for tweet in tweets.data[:10]:  # Limitado a 10 tweets
+                result = sentiment_pipeline(tweet.text[:512])  # Limitado a 512 caracteres
+                rating = int(result[0]['label'].split()[0])
+                if rating >= 4:
+                    sentiments.append('positive')
+                elif rating <= 2:
+                    sentiments.append('negative')
+                else:
+                    sentiments.append('neutral')
+            
         # Calcular taxas
         if sentiments:
-            positive = sentiments.count('positive')
-            negative = sentiments.count('negative')
-            neutral = sentiments.count('neutral')
             total = len(sentiments)
-            
-            debug_print(f"Total de sentimentos analisados: {total}")
-            
             sentiment_ratios = {
-                'positive': positive / total,
-                'negative': negative / total,
-                'neutral': neutral / total
+                'positive': sentiments.count('positive') / total,
+                'negative': sentiments.count('negative') / total,
+                'neutral': sentiments.count('neutral') / total
             }
             
-            # Gerar comentário usando IA
-            with st.spinner('Gerando novo comentário...'):
-                debug_print("Iniciando geração de comentário com IA...")
+            # Gerar e postar tweet
+            with st.spinner('Gerando e postando tweet...'):
                 tweet_text = generate_comment(context, sentiment_ratios, model, tokenizer)
-                debug_print(f"Comentário gerado: {tweet_text}")
-            
-            # Postar tweet
-            with st.spinner('Postando tweet...'):
-                debug_print("Tentando postar tweet...")
-                try:
-                    post_tweet(client, tweet_text)
-                    st.success("Tweet postado com sucesso!")
-                    debug_print("Tweet postado com sucesso")
-                except Exception as e:
-                    st.error(f"Erro ao postar tweet: {str(e)}")
-                    debug_print(f"Erro ao postar tweet: {str(e)}")
+                post_tweet(client, tweet_text)
             
-            # Interface Streamlit
-            st.title("Resultados da Análise")
+            # Interface
+            st.title("Resultados")
             
-            # Mostrar estatísticas
             col1, col2, col3 = st.columns(3)
             with col1:
-                st.metric("Sentimento Positivo", f"{sentiment_ratios['positive']:.1%}")
+                st.metric("Positivo", f"{sentiment_ratios['positive']:.1%}")
             with col2:
-                st.metric("Sentimento Neutro", f"{sentiment_ratios['neutral']:.1%}")
+                st.metric("Neutro", f"{sentiment_ratios['neutral']:.1%}")
             with col3:
-                st.metric("Sentimento Negativo", f"{sentiment_ratios['negative']:.1%}")
-            
-            # Mostrar contexto extraído
-            st.subheader("Contexto Analisado")
-            st.write("Participantes em destaque:", ", ".join(context['participants']))
-            st.write("Eventos detectados:", ", ".join(context['events']))
+                st.metric("Negativo", f"{sentiment_ratios['negative']:.1%}")
             
-            # Mostrar tweet gerado
-            st.subheader("Tweet Gerado e Postado")
+            st.subheader("Tweet Gerado")
             st.write(tweet_text)
             
-            # Logging
-            debug_print("Salvando log...")
-            log_entry = {
-                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
-                'positive_ratio': sentiment_ratios['positive'],
-                'negative_ratio': sentiment_ratios['negative'],
-                'neutral_ratio': sentiment_ratios['neutral'],
-                'context': context,
-                'tweet': tweet_text
-            }
-            
+            # Log simplificado
             with open('posting_log.txt', 'a') as f:
-                f.write(f"{str(log_entry)}\n")
-            debug_print("Log salvo com sucesso")
+                f.write(f"{datetime.now()}: {tweet_text}\n")
 
     except Exception as e:
         st.error(f"Erro: {str(e)}")
-        debug_print(f"Erro fatal: {str(e)}")
-        raise e
 
     finally:
         st.markdown("---")