Update app.py

app.py

@@ -1,278 +1,71 @@
-import streamlit as st
-from transformers import T5ForConditionalGeneration, T5Tokenizer
-import torch
-from torch.utils.data import Dataset, DataLoader
-import json
+import tweepy
+from transformers import pipeline, GPT2LMHeadModel, GPT2Tokenizer
 import os
-from datetime import datetime
-import tempfile
 
-# Custom dataset for fine-tuning
-class TextHumanizerDataset(Dataset):
-    def __init__(self, data, tokenizer, max_length=512):
-        self.data = data
-        self.tokenizer = tokenizer
-        self.max_length = max_length
+# Autenticação com Twitter para leitura
+client = tweepy.Client(bearer_token=os.environ.get('AAAAAAAAAAAAAAAAAAAAAFhdyAEAAAAAIG7CES2Ej98j9NGylgrb0yOrvvA%3DoSuAx9ZWUbyofrjM5VYiQBqjZA0oXXs4Ik21py9BZEn8mrAvzW'))
 
-    def __len__(self):
-        return len(self.data)
-
-    def __getitem__(self, idx):
-        item = self.data[idx]
-        input_encoding = self.tokenizer(
-            f"reescreva em português natural, mantendo todas as informações: {item['input_text']}",
-            max_length=self.max_length,
-            padding='max_length',
-            truncation=True,
-            return_tensors='pt'
-        )
-        
-        target_encoding = self.tokenizer(
-            item['output_text'],
-            max_length=self.max_length,
-            padding='max_length',
-            truncation=True,
-            return_tensors='pt'
-        )
-
-        return {
-            'input_ids': input_encoding['input_ids'].squeeze(),
-            'attention_mask': input_encoding['attention_mask'].squeeze(),
-            'labels': target_encoding['input_ids'].squeeze()
-        }
-
-def get_storage_path():
-    """Retorna o caminho correto para armazenamento no Hugging Face Spaces"""
-    if os.environ.get('SPACE_ID'):  # Verifica se está rodando no Spaces
-        return '/data'  # Diretório persistente no Spaces
-    else:
-        # Fallback para desenvolvimento local
-        temp_dir = tempfile.gettempdir()
-        feedback_dir = os.path.join(temp_dir, 'feedback_data')
-        os.makedirs(feedback_dir, exist_ok=True)
-        return feedback_dir
-
-def save_feedback(input_text, output_text, rating):
-    """Salva o feedback do usuário para futuro treinamento"""
-    feedback_data = {
-        'input_text': input_text,
-        'output_text': output_text,
-        'rating': rating,
-        'timestamp': datetime.now().isoformat()
-    }
-    
-    storage_path = get_storage_path()
-    feedback_file = os.path.join(storage_path, 'feedback.json')
-    
-    try:
-        # Cria arquivo se não existir
-        if not os.path.exists(feedback_file):
-            with open(feedback_file, 'w') as f:
-                f.write('')
-        
-        # Append do novo feedback
-        with open(feedback_file, 'a') as f:
-            f.write(json.dumps(feedback_data) + '\n')
-            
-        return True
-    except Exception as e:
-        st.error(f"Erro ao salvar feedback: {str(e)}")
-        return False
-
-def fine_tune_model():
-    """Realiza fine-tuning do modelo com dados de feedback positivo"""
-    storage_path = get_storage_path()
-    feedback_file = os.path.join(storage_path, 'feedback.json')
-    
-    if not os.path.exists(feedback_file):
-        return
-    
-    try:
-        # Carrega dados de feedback
-        positive_examples = []
-        with open(feedback_file, 'r') as f:
-            for line in f:
-                if line.strip():  # Ignora linhas vazias
-                    feedback = json.loads(line)
-                    if feedback['rating'] >= 4:  # Usa apenas feedback positivo
-                        positive_examples.append({
-                            'input_text': feedback['input_text'],
-                            'output_text': feedback['output_text']
-                        })
-        
-        if not positive_examples:
-            return
-        
-        # Cria dataset e dataloader
-        dataset = TextHumanizerDataset(positive_examples, st.session_state.tokenizer)
-        dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
-        
-        # Configura otimizador
-        optimizer = torch.optim.AdamW(st.session_state.model.parameters(), lr=1e-5)
-        
-        # Fine-tuning
-        st.session_state.model.train()
-        for batch in dataloader:
-            optimizer.zero_grad()
-            outputs = st.session_state.model(
-                input_ids=batch['input_ids'],
-                attention_mask=batch['attention_mask'],
-                labels=batch['labels']
-            )
-            loss = outputs.loss
-            loss.backward()
-            optimizer.step()
-        
-        st.session_state.model.eval()
-        return True
-    
-    except Exception as e:
-        st.error(f"Erro durante o fine-tuning: {str(e)}")
-        return False
-
-def clean_generated_text(text):
-    """Remove comandos e limpa o texto gerado"""
-    text = text.strip()
-
-    # Lista de prefixos de comando para remover
-    prefixes = [
-        "reescreva o seguinte texto",
-        "reescreva este texto",
-        "reescreva o texto",
-        "traduza",
-        "humanize:",
-        "humanizar:",
-        "em português",
-        "de forma mais natural"
-    ]
-
-    # Remove os prefixos de comando
-    text_lower = text.lower()
-    for prefix in prefixes:
-        if text_lower.startswith(prefix):
-            text = text[len(prefix):].strip()
-            text_lower = text.lower()
-    
-    # Capitaliza a primeira letra
-    if text:
-        text = text[0].upper() + text[1:]
-    
-    return text
-
-def humanize_text(text):
-    """Humaniza o texto mantendo coerência e tamanho"""
-    prompt = f"reescreva em português natural, mantendo todas as informações: {text}"
-    
-    # Tokenização com padding
-    inputs = st.session_state.tokenizer(
-        prompt,
-        return_tensors="pt",
-        max_length=512,  # Reduzido para evitar problemas de memória
-        padding=True,
-        truncation=True
-    )
-
-    # Parâmetros mais conservadores para geração
-    try:
-        outputs = st.session_state.model.generate(
-            inputs.input_ids,
-            max_length=512,  # Reduzido para maior estabilidade
-            min_length=int(len(text.split()) * 0.8),  # Garante pelo menos 80% do tamanho original
-            do_sample=False,  # Desativa amostragem para maior estabilidade
-            num_beams=2,      # Reduzido para evitar problemas de memória
-            repetition_penalty=1.1,  # Reduzido para evitar instabilidades
-            length_penalty=1.0,      # Valor neutro
-            early_stopping=True,     # Ativa early stopping
-            no_repeat_ngram_size=2   # Evita repetições de bigramas
-        )
-        
-        result = st.session_state.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        result = clean_generated_text(result)
-        
-        # Garante tamanho mínimo de forma mais suave
-        if len(result.split()) < len(text.split()):
-            missing_words = len(text.split()) - len(result.split())
-            original_words = text.split()[-missing_words:]
-            result = result + " " + " ".join(original_words)
-        
-        return result
-        
-    except Exception as e:
-        st.error(f"Erro durante a geração: {str(e)}")
-        # Fallback: retorna o texto original em caso de erro
-        return text
-
-# Initialize session state
-if 'model_loaded' not in st.session_state:
-    st.session_state.tokenizer = T5Tokenizer.from_pretrained("t5-base")
-    st.session_state.model = T5ForConditionalGeneration.from_pretrained("t5-base")
-    st.session_state.model_loaded = True
-
-# UI Components
-st.set_page_config(page_title="Advanced Text Humanizer", page_icon="🤖")
-
-st.title("🤖 → 🧑 Humanizador de Texto Avançado")
-st.markdown("""
-Este aplicativo transforma textos robotizados em linguagem mais natural e humana, 
-mantendo todas as informações originais e incluindo sistema de feedback para melhoria contínua.
-""")
-
-# Input area
-input_text = st.text_area(
-    "Cole seu texto de robô aqui:",
-    height=150,
-    help="Cole seu texto aqui para transformá-lo em uma versão mais natural e humana."
+# Autenticação com Twitter para postagem
+auth = tweepy.OAuth1UserHandler(
+    os.environ.get('lXr9PmhTdm2hxC20AmNIguxsn'),
+    os.environ.get('LMsDCue1BSBGydpC9ykw0MJTzJ35rbWwcIjkVbgp8PW1apjmFo'),
+    os.environ.get('69748110-yMiyeul89rwhUDJmgCNW0vfAVm3hIJRdFhOlVUc6d'),
+    os.environ.get('ioExZSIT0LZ5pvUXxDRtTuNUp8lCaoIP2H5vCJsphvFbk')
 )
+api = tweepy.API(auth)
+
+# Coletar tweets
+query = 'BBB25 -filter:retweets'
+tweets = client.search_recent_tweets(query=query, lang='pt', max_results=100)
+
+# Análise de sentimentos
+sentiment_pipeline = pipeline('sentiment-analysis', model='cardiffnlp/twitter-xlm-roberta-base-sentiment')
+
+sentiments = []
+for tweet in tweets.data:
+    result = sentiment_pipeline(tweet.text)
+    sentiments.append(result[0]['label'])
+
+# Calcular taxas
+positive = sentiments.count('positive')
+negative = sentiments.count('negative')
+total = len(sentiments)
+
+positive_ratio = positive / total
+negative_ratio = negative / total
+
+# Gerar mensagem com IA
+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."
+
+input_ids = tokenizer.encode(prompt, return_tensors='pt')
+
+# Gerar texto com limite de tokens correspondente a 280 caracteres
+outputs = model.generate(input_ids, max_length=25, do_sample=True)
+generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# Limitar o tweet a 280 caracteres
+generated_text = generated_text[:280]
+
+# Postar no Twitter
+try:
+    api.update_status(status=generated_text)
+    print(f"Postado: {generated_text}")
+except Exception as e:
+    print(f"Erro ao postar: {e}")
+
+# Logging (opcional)
+with open('posting_log.txt', 'a') as f:
+    f.write(f"Positive Ratio: {positive_ratio}, Negative Ratio: {negative_ratio}, Posted: {generated_text}\n")
+    
 
-# Process button and results
-if st.button("Humanizar", type="primary"):
-    if not input_text:
-        st.warning("⚠️ Por favor, cole um texto primeiro!")
-    else:
-        with st.spinner("Processando o texto..."):
-            try:
-                final_text = humanize_text(input_text)
-                
-                # Display results
-                st.success("✨ Texto humanizado:")
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    st.text("Original:")
-                    st.info(input_text)
-                    st.write(f"Palavras: {len(input_text.split())}")
-                
-                with col2:
-                    st.text("Resultado:")
-                    st.info(final_text)
-                    st.write(f"Palavras: {len(final_text.split())}")
-                
-                # Feedback section
-                st.markdown("### Feedback")
-                rating = st.slider(
-                    "Como você avalia a qualidade do texto humanizado?",
-                    min_value=1,
-                    max_value=5,
-                    value=3,
-                    help="1 = Muito ruim, 5 = Excelente"
-                )
-                
-                if st.button("Enviar Feedback"):
-                    if save_feedback(input_text, final_text, rating):
-                        st.success("Feedback salvo com sucesso! Obrigado pela contribuição.")
-                        
-                        # Trigger fine-tuning if we have enough positive feedback
-                        if rating >= 4:
-                            with st.spinner("Atualizando modelo com seu feedback..."):
-                                if fine_tune_model():
-                                    st.success("Modelo atualizado com sucesso!")
-                                else:
-                                    st.warning("Não foi possível atualizar o modelo neste momento.")
-                    else:
-                        st.error("Não foi possível salvar o feedback. Tente novamente mais tarde.")
-                
-            except Exception as e:
-                st.error(f"❌ Erro no processamento: {str(e)}")
 
 # Footer
 st.markdown("---")