Update app.py

app.py

@@ -5,6 +5,9 @@ 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
 
 def debug_print(message):
     """Função para imprimir mensagens de debug tanto no console quanto no Streamlit"""
@@ -23,7 +26,7 @@ def fetch_tweets(client, query, tweet_fields):
         
         tweets = client.search_recent_tweets(
             query=query,
-            max_results=10,
+            max_results=100,  # Aumentado para ter mais contexto
             tweet_fields=tweet_fields
         )
         
@@ -64,6 +67,116 @@ def post_tweet(client, text):
         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
+
+def extract_context_from_tweets(tweets_data):
+    """Extrai contexto relevante dos tweets"""
+    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)
+    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|$)'
+    ]
+    
+    events = []
+    for pattern in event_patterns:
+        matches = re.findall(pattern, all_text.lower())
+        if matches:
+            events.extend(matches)
+    
+    return {
+        'participants': [p[0] for p in participants],
+        'events': list(set(events))[:3],  # Top 3 eventos únicos
+        '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 = ""
+    if sentiment_ratio['positive'] > 0.5:
+        sentiment_tone = "positivo"
+    elif sentiment_ratio['negative'] > 0.5:
+        sentiment_tone = "negativo"
+    else:
+        sentiment_tone = "dividido"
+    
+    # Construir contexto para o prompt
+    prompt = f"No BBB25, com clima {sentiment_tone}"
+    
+    # Adicionar participantes relevantes
+    if context['participants']:
+        participants_str = ", ".join(context['participants'][:2])
+        prompt += f", {participants_str} se destacam"
+    
+    # Adicionar eventos relevantes
+    if context['events']:
+        event_str = context['events'][0]
+        prompt += f". {event_str.capitalize()}"
+    
+    # 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
+        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
+
 def main():
     try:
         st.title("Análise de Sentimentos - BBB25")
@@ -92,7 +205,7 @@ def main():
 
         debug_print("Iniciando autenticação com Twitter...")
         
-        # Autenticação com Twitter para leitura e escrita
+        # Autenticação com Twitter
         client = tweepy.Client(
             bearer_token=os.getenv('TWITTER_BEARER_TOKEN'),
             consumer_key=os.getenv('TWITTER_API_KEY'),
@@ -102,15 +215,9 @@ def main():
             wait_on_rate_limit=True
         )
 
-        # Vamos testar a autenticação com uma query simples
-        debug_print("Testando autenticação...")
-        try:
-            test_query = "test"
-            test_response = client.search_recent_tweets(query=test_query, max_results=10)
-            debug_print("Teste de autenticação bem sucedido")
-        except Exception as e:
-            debug_print(f"Erro no teste de autenticação: {str(e)}")
-            raise e
+        # Inicializar modelo de geração de texto
+        debug_print("Inicializando modelo de geração de texto...")
+        model, tokenizer = initialize_text_generator()
 
         # Query principal
         query = 'BBB25 lang:pt -is:retweet -is:reply'
@@ -132,16 +239,16 @@ def main():
             
             debug_print(f"Encontrados {len(tweets.data)} tweets")
             
-            # Mostrar alguns tweets encontrados para debug
-            st.subheader("Tweets encontrados (preview):")
-            for i, tweet in enumerate(tweets.data[:3]):
-                st.text(f"Tweet {i+1}: {tweet.text[:100]}...")
+            # 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...")
             
-            # Usando modelo multilingual que suporta português
             sentiment_pipeline = pipeline(
                 "sentiment-analysis",
                 model="nlptown/bert-base-multilingual-uncased-sentiment"
@@ -151,8 +258,6 @@ def main():
             for tweet in tweets.data:
                 if hasattr(tweet, 'lang') and tweet.lang == 'pt':
                     result = sentiment_pipeline(tweet.text)
-                    # Este modelo retorna ratings de 1 a 5 estrelas
-                    # Vamos mapear para nossos sentimentos
                     rating = int(result[0]['label'].split()[0])
                     if rating >= 4:
                         sentiments.append('positive')
@@ -173,42 +278,23 @@ def main():
             
             debug_print(f"Total de sentimentos analisados: {total}")
             
-            positive_ratio = positive / total
-            negative_ratio = negative / total
-            neutral_ratio = neutral / total
+            sentiment_ratios = {
+                'positive': positive / total,
+                'negative': negative / total,
+                'neutral': neutral / total
+            }
             
-            # Gerar mensagem com IA
-            with st.spinner('Gerando novo tweet...'):
-                debug_print("Iniciando geração de texto...")
-                tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
-                model = GPT2LMHeadModel.from_pretrained('gpt2')
-                
-                if positive_ratio > 0.6:
-                    prompt = "Write an exciting tweet about BBB25 with a positive tone in Portuguese."
-                elif negative_ratio > 0.6:
-                    prompt = "Write an informative tweet about BBB25 with a neutral tone in Portuguese."
-                else:
-                    prompt = "Write a buzzing tweet about BBB25 with an engaging tone in Portuguese."
-                
-                debug_print(f"Usando prompt: {prompt}")
-                
-                input_ids = tokenizer.encode(prompt, return_tensors='pt')
-                outputs = model.generate(
-                    input_ids,
-                    max_length=25,
-                    do_sample=True,
-                    pad_token_id=tokenizer.eos_token_id
-                )
-                
-                generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-                generated_text = generated_text[:280]
-                debug_print(f"Texto gerado: {generated_text}")
+            # Gerar comentário usando IA
+            with st.spinner('Gerando novo comentário...'):
+                debug_print("Iniciando geração de comentário com IA...")
+                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, generated_text)
+                    post_tweet(client, tweet_text)
                     st.success("Tweet postado com sucesso!")
                     debug_print("Tweet postado com sucesso")
                 except Exception as e:
@@ -221,24 +307,30 @@ def main():
             # Mostrar estatísticas
             col1, col2, col3 = st.columns(3)
             with col1:
-                st.metric("Sentimento Positivo", f"{positive_ratio:.1%}")
+                st.metric("Sentimento Positivo", f"{sentiment_ratios['positive']:.1%}")
             with col2:
-                st.metric("Sentimento Neutro", f"{neutral_ratio:.1%}")
+                st.metric("Sentimento Neutro", f"{sentiment_ratios['neutral']:.1%}")
             with col3:
-                st.metric("Sentimento Negativo", f"{negative_ratio:.1%}")
+                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']))
             
             # Mostrar tweet gerado
             st.subheader("Tweet Gerado e Postado")
-            st.write(generated_text)
+            st.write(tweet_text)
             
             # Logging
             debug_print("Salvando log...")
             log_entry = {
                 'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
-                'positive_ratio': positive_ratio,
-                'negative_ratio': negative_ratio,
-                'neutral_ratio': neutral_ratio,
-                'tweet': generated_text
+                'positive_ratio': sentiment_ratios['positive'],
+                'negative_ratio': sentiment_ratios['negative'],
+                'neutral_ratio': sentiment_ratios['neutral'],
+                'context': context,
+                'tweet': tweet_text
             }
             
             with open('posting_log.txt', 'a') as f: