Update app.py

app.py

@@ -1,169 +1,147 @@
-import gradio as gr
-from transformers import pipeline
-import feedparser
-from datetime import datetime, timedelta
-import pytz
+import requests
 from bs4 import BeautifulSoup
-import hashlib
-import threading
+from transformers import pipeline
 import pandas as pd
+from datetime import datetime, timedelta
 
-# Global settings
-SUMMARIZER_MODELS = {
-    "Default (facebook/bart-large-cnn)": "facebook/bart-large-cnn",
-    "Free Model (distilbart-cnn-6-6)": "sshleifer/distilbart-cnn-6-6"
+# Configuración inicial
+SITIOS = {
+    "Mundo Gremial": "https://www.mundogremial.com.ar",
+    "ANRed": "https://www.anred.org",
+    "Prensa Obrera": "https://www.prensaobrera.com",
+    "La Izquierda Diario": "https://www.laizquierdadiario.com"
 }
-CACHE_SIZE = 500
-RSS_FETCH_INTERVAL = timedelta(hours=8)
-ARTICLE_LIMIT = 5
-
-NEWS_SOURCES = {
-    "Movilizaciones Sindicales": {
-      
-        "Pagina12": "https://www.pagina12.com.ar/rss/edicion-impresa",
-       
-    }
-}
-
-class NewsCache:
-    def __init__(self, size):
-        self.cache = {}
-        self.size = size
-        self.lock = threading.Lock()
-
-    def get(self, key):
-        with self.lock:
-            return self.cache.get(key)
-
-    def set(self, key, value):
-        with self.lock:
-            if len(self.cache) >= self.size:
-                oldest_key = next(iter(self.cache))
-                del self.cache[oldest_key]
-            self.cache[key] = value
-
-cache = NewsCache(CACHE_SIZE)
-
-def fetch_rss_news(categories):
-    articles = []
-    cutoff_time = datetime.now(pytz.UTC) - RSS_FETCH_INTERVAL
-    for category in categories:
-        for source, url in NEWS_SOURCES.get(category, {}).items():
-            try:
-                feed = feedparser.parse(url)
-                for entry in feed.entries:
-                    published = datetime(*entry.published_parsed[:6], tzinfo=pytz.UTC)
-                    if published > cutoff_time:
-                        articles.append({
-                            "title": entry.title,
-                            "description": BeautifulSoup(entry.description, "html.parser").get_text(),
-                            "link": entry.link,
-                            "category": category,
-                            "source": source,
-                            "published": published
-                        })
-            except Exception:
-                continue
-    articles = sorted(articles, key=lambda x: x["published"], reverse=True)[:ARTICLE_LIMIT]
-    return articles
-
-def summarize_text(text, model_name):
-    summarizer = pipeline("summarization", model=model_name, device=-1)
-    content_hash = hashlib.md5(text.encode()).hexdigest()
-    cached_summary = cache.get(content_hash)
-    if cached_summary:
-        return cached_summary
-    try:
-        result = summarizer(text, max_length=120, min_length=40, truncation=True)
-        summary = result[0]['summary_text']
-        cache.set(content_hash, summary)
-        return summary
-    except Exception:
-        return "Summary unavailable."
-
-def summarize_articles(articles, model_name):
-    summaries = []
-    for article in articles:
-        content = article["description"]
-        summary = summarize_text(content, model_name)
-        summaries.append(f"""
-        📰 {article['title']}
-        - 📁 Category: {article['category']}
-        - 💡 Source: {article['source']}
-        - 🔗 Read More: {article['link']}
-        📃 Summary: {summary}
-        """)
-    return "\n".join(summaries)
-
-def generate_summary(selected_categories, model_name):
-    if not selected_categories:
-        return "Please select at least one category."
-    articles = fetch_rss_news(selected_categories)
-    if not articles:
-        return "No recent news found in the selected categories."
-    return summarize_articles(articles, model_name)
-
-def fetch_union_mobilizations():
-    articles = []
-    cutoff_time = datetime.now(pytz.UTC) - timedelta(days=1)
-    for source, url in NEWS_SOURCES["Movilizaciones Sindicales"].items():
-        try:
-            feed = feedparser.parse(url)
-            for entry in feed.entries:
-                published = datetime(*entry.published_parsed[:6], tzinfo=pytz.UTC)
-                if published > cutoff_time:
-                    # Filtrar por movilizaciones sindicales
-                    if "movilización" in entry.title.lower() or "sindical" in entry.title.lower():
-                        articles.append({
-                            "title": entry.title,
-                            "description": BeautifulSoup(entry.description, "html.parser").get_text(),
-                            "link": entry.link,
-                            "source": source,
-                            "published": published
-                        })
-        except Exception:
-            continue
-    return articles
-
-def create_mobilization_table():
-    articles = fetch_union_mobilizations()
-    if not articles:
-        return "No se encontraron movilizaciones sindicales recientes."
-    
-    # Crear una tabla con pandas
-    df = pd.DataFrame(articles)
-    return df.to_string(index=False)
-
-# Gradio Interface
-demo = gr.Blocks()
-
-with demo:
-    gr.Markdown("# 📰 AI News Summarizer")
-    with gr.Row():
-        categories = gr.CheckboxGroup(
-            choices=list(NEWS_SOURCES.keys()),
-            label="Select News Categories"
-        )
-        model_selector = gr.Radio(
-            choices=list(SUMMARIZER_MODELS.keys()),
-            label="Choose Summarization Model",
-            value="Default (facebook/bart-large-cnn)"
-        )
-    summarize_button = gr.Button("Get News Summary")
-    summary_output = gr.Textbox(label="News Summary", lines=20)
-
-    def get_summary(selected_categories, selected_model):
-        model_name = SUMMARIZER_MODELS[selected_model]
-        return generate_summary(selected_categories, model_name)
-
-    summarize_button.click(get_summary, inputs=[categories, model_selector], outputs=summary_output)
-
-if __name__ == "__main__":
-    demo.launch()
-
-
-
-
 
+# Fecha actual y límite para noticias recientes (últimos 7 días)
+FECHA_ACTUAL = datetime(2025, 1, 28)  # Hoy es 28 de enero de 2025
+LIMITE_RECIENTE = FECHA_ACTUAL - timedelta(days=7)
 
+# Cargar modelo de IA para análisis de texto
+analizador = pipeline("text-classification", model="deepseek-ai/r1-zero")
 
+# Función para hacer scraping en un sitio
+def scrapear_sitio(url):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, "html.parser")
+        return soup
+    except Exception as e:
+        print(f"Error al scrapear {url}: {e}")
+        return None
+
+# Función para extraer noticias de Mundo Gremial
+def extraer_mundo_gremial(soup):
+    noticias = []
+    for articulo in soup.find_all("article", class_="post"):
+        titulo = articulo.find("h2").text.strip()
+        enlace = articulo.find("a")["href"]
+        contenido = articulo.find("div", class_="entry-content").text.strip()
+        fecha_texto = articulo.find("time")["datetime"]  # Extraer fecha
+        fecha = datetime.strptime(fecha_texto, "%Y-%m-%d")  # Convertir a objeto datetime
+        noticias.append({"titulo": titulo, "contenido": contenido, "enlace": enlace, "fecha": fecha})
+    return noticias
+
+# Función para extraer noticias de ANRed
+def extraer_anred(soup):
+    noticias = []
+    for articulo in soup.find_all("article"):
+        titulo = articulo.find("h2").text.strip()
+        enlace = articulo.find("a")["href"]
+        contenido = articulo.find("div", class_="entry-content").text.strip()
+        fecha_texto = articulo.find("time")["datetime"]  # Extraer fecha
+        fecha = datetime.strptime(fecha_texto, "%Y-%m-%d")  # Convertir a objeto datetime
+        noticias.append({"titulo": titulo, "contenido": contenido, "enlace": enlace, "fecha": fecha})
+    return noticias
+
+# Función para extraer noticias de Prensa Obrera
+def extraer_prensa_obrera(soup):
+    noticias = []
+    for articulo in soup.find_all("article"):
+        titulo = articulo.find("h2").text.strip()
+        enlace = articulo.find("a")["href"]
+        contenido = articulo.find("div", class_="entry-content").text.strip()
+        fecha_texto = articulo.find("time")["datetime"]  # Extraer fecha
+        fecha = datetime.strptime(fecha_texto, "%Y-%m-%d")  # Convertir a objeto datetime
+        noticias.append({"titulo": titulo, "contenido": contenido, "enlace": enlace, "fecha": fecha})
+    return noticias
+
+# Función para extraer noticias de La Izquierda Diario
+def extraer_la_izquierda_diario(soup):
+    noticias = []
+    for articulo in soup.find_all("article"):
+        titulo = articulo.find("h2").text.strip()
+        enlace = articulo.find("a")["href"]
+        contenido = articulo.find("div", class_="entry-content").text.strip()
+        fecha_texto = articulo.find("time")["datetime"]  # Extraer fecha
+        fecha = datetime.strptime(fecha_texto, "%Y-%m-%d")  # Convertir a objeto datetime
+        noticias.append({"titulo": titulo, "contenido": contenido, "enlace": enlace, "fecha": fecha})
+    return noticias
+
+# Función para clasificar noticias
+def clasificar_noticia(texto):
+    try:
+        resultado = analizador(texto)
+        return resultado[0]["label"]
+    except Exception as e:
+        print(f"Error al clasificar texto: {e}")
+        return "Desconocido"
+
+# Función para detectar conflictos laborales
+def es_conflicto_laboral(texto):
+    palabras_clave = ["huelga", "paro", "despido", "salario", "protesta", "trabajadores", "sindicato"]
+    return any(palabra in texto.lower() for palabra in palabras_clave)
+
+# Función para detectar protestas próximas
+def es_protesta_proxima(texto):
+    palabras_clave = ["marcha", "manifestación", "concentración", "asamblea", "corte", "huelga"]
+    return any(palabra in texto.lower() for palabra in palabras_clave)
+
+# Procesar todos los sitios
+conflictos_laborales = []
+agenda_protestas = []
+
+for nombre, url in SITIOS.items():
+    print(f"Scrapeando {nombre}...")
+    soup = scrapear_sitio(url)
+    if soup:
+        if nombre == "Mundo Gremial":
+            noticias = extraer_mundo_gremial(soup)
+        elif nombre == "ANRed":
+            noticias = extraer_anred(soup)
+        elif nombre == "Prensa Obrera":
+            noticias = extraer_prensa_obrera(soup)
+        elif nombre == "La Izquierda Diario":
+            noticias = extraer_la_izquierda_diario(soup)
+
+        for noticia in noticias:
+            # Filtrar noticias recientes (últimos 7 días)
+            if noticia["fecha"] >= LIMITE_RECIENTE:
+                if es_conflicto_laboral(noticia["contenido"]):
+                    conflictos_laborales.append({
+                        "Sitio": nombre,
+                        "Título": noticia["titulo"],
+                        "Enlace": noticia["enlace"],
+                        "Fecha": noticia["fecha"].strftime("%Y-%m-%d")
+                    })
+                if es_protesta_proxima(noticia["contenido"]):
+                    agenda_protestas.append({
+                        "Sitio": nombre,
+                        "Título": noticia["titulo"],
+                        "Enlace": noticia["enlace"],
+                        "Fecha": noticia["fecha"].strftime("%Y-%m-%d")
+                    })
+
+# Crear tablas con Pandas
+df_conflictos = pd.DataFrame(conflictos_laborales)
+df_protestas = pd.DataFrame(agenda_protestas)
+
+# Guardar tablas en archivos CSV
+df_conflictos.to_csv("conflictos_laborales.csv", index=False)
+df_protestas.to_csv("agenda_protestas.csv", index=False)
+
+print("Tablas generadas:")
+print("\nConflictos Laborales en Desarrollo (últimos 7 días):")
+print(df_conflictos)
+print("\nAgenda de Protestas Próximas (últimos 7 días):")
+print(df_protestas)