Upload 5 files

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,64 @@
+
+# 🚀 Guía de Deployment en Hugging Face Spaces
+
+## Paso 1: Preparar la cuenta
+1. Ir a https://huggingface.co/
+2. Crear una cuenta o iniciar sesión
+3. Generar un Access Token con permisos de escritura:
+   - Ir a Settings > Access Tokens
+   - Crear nuevo token con scope "Write"
+
+## Paso 2: Crear el Space
+1. Ir a https://huggingface.co/spaces
+2. Hacer clic en "Create new Space"
+3. Configurar:
+   - Space name: web-scraper-tool (o el nombre que prefieras)
+   - License: Apache-2.0
+   - Select the SDK: Gradio
+   - SDK version: 4.12.0
+   - Hardware: CPU basic (gratuito)
+   - Visibility: Public
+
+## Paso 3: Subir los archivos
+### Opción A: Interface Web
+1. Una vez creado el Space, ir a "Files"
+2. Subir cada archivo uno por uno:
+   - app.py
+   - web_scraper_tool.py
+   - requirements.txt
+   - .gitattributes
+   - README.md
+
+### Opción B: Git (Recomendado)
+```bash
+# Clonar el repositorio
+git clone https://huggingface.co/spaces/TU_USERNAME/TU_SPACE_NAME
+cd TU_SPACE_NAME
+
+# Copiar todos los archivos aquí
+# Luego hacer commit y push
+git add .
+git commit -m "Initial commit: Web Scraper Tool"
+git push
+```
+
+## Paso 4: Verificar el deployment
+1. El Space comenzará a buildear automáticamente
+2. Ver los logs en tiempo real en la página del Space
+3. Una vez completado, la aplicación estará disponible
+
+## Paso 5: Configuraciones adicionales (Opcional)
+- Cambiar el hardware si necesitas más recursos
+- Configurar secretos si tienes API keys
+- Personalizar el README.md con más información
+
+## 🎯 URLs de ejemplo
+- Tu Space estará disponible en: https://huggingface.co/spaces/TU_USERNAME/TU_SPACE_NAME
+- La aplicación se ejecutará automáticamente
+
+## 🔧 Troubleshooting común
+1. **Error de dependencias**: Verificar requirements.txt
+2. **Import error**: Asegurar que todos los archivos están subidos
+3. **Build failed**: Revisar los logs para errores específicos
+
+¡Tu aplicación estará lista en unos minutos! 🎉

README.md

@@ -1,12 +1,42 @@
 ---
-title: ScrapIT
-emoji: 🏃
-colorFrom: yellow
-colorTo: indigo
+title: Web Scraper Tool
+emoji: 🕸️
+colorFrom: purple
+colorTo: blue
 sdk: gradio
-sdk_version: 5.33.2
+sdk_version: 4.12.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🕸️ Web Scraper Tool
+
+Una herramienta web para hacer scraping de páginas web y convertirlas a PDF o texto plano. 
+Esta aplicación está optimizada para generar archivos que puedan ser procesados por Copilot.
+
+## ✨ Características
+
+- ✅ Extracción de contenido web
+- 📄 Conversión a PDF o texto plano
+- 🖼️ Detección automática de imágenes
+- 🎨 Interfaz minimalista y profesional
+- 🤖 Optimizado para generar archivos compatibles con Copilot
+
+## 🚀 Uso
+
+1. Ingresa la URL de la página web que deseas procesar
+2. Selecciona el formato de salida (PDF o TXT)
+3. Haz clic en "Procesar URL"
+4. Descarga el archivo generado
+
+## 🛠️ Tecnologías utilizadas
+
+- Python
+- Gradio
+- BeautifulSoup
+- WeasyPrint
+- Hugging Face Spaces
+
+## 👨‍💻 Autor
+
+Desarrollado con 💜 para solucionar problemas de procesamiento de contenido web

app.py

@@ -0,0 +1,130 @@
+import gradio as gr
+import os
+import tempfile
+import time
+from web_scraper_tool import WebScrapperTool
+
+# Inicializar el scraper
+scraper = WebScrapperTool("temp_output")
+
+def scrape_url(url, output_format, progress=gr.Progress()):
+    """Función principal que procesa la URL ingresada"""
+    progress(0, desc="Iniciando...")
+
+    # Validar URL
+    if not url.startswith(('http://', 'https://')):
+        return None, "Error: La URL debe comenzar con http:// o https://"
+
+    try:
+        progress(0.2, desc="Analizando URL...")
+        # Detectar si es una imagen
+        is_image = scraper.is_image_url(url)
+
+        progress(0.4, desc="Iniciando descarga...")
+
+        temp_dir = tempfile.mkdtemp()
+        timestamp = int(time.time())
+
+        if is_image:
+            progress(0.6, desc="Procesando imagen...")
+            filename = f"imagen_{timestamp}.txt"
+            output_path = os.path.join(temp_dir, filename)
+
+            # Obtenemos metadatos de la imagen
+            metadata = scraper.get_image_metadata(url)
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(f"URL de la imagen: {url}\n\n")
+                f.write("Metadatos de la imagen:\n")
+                for key, value in metadata.items():
+                    f.write(f"{key}: {value}\n")
+
+            progress(1.0, desc="¡Listo!")
+            return output_path, f"✅ Archivo generado exitosamente. Se detectó que la URL es una imagen."
+        else:
+            if output_format == "txt":
+                progress(0.6, desc="Extrayendo texto...")
+                filename = f"contenido_{timestamp}.txt"
+                output_path = os.path.join(temp_dir, filename)
+                scraper.scrape_to_text(url, output_path)
+            else:  # PDF
+                progress(0.6, desc="Generando PDF...")
+                filename = f"contenido_{timestamp}.pdf"
+                output_path = os.path.join(temp_dir, filename)
+                scraper.scrape_to_pdf(url, output_path)
+
+            progress(1.0, desc="¡Listo!")
+            return output_path, f"✅ Archivo generado exitosamente en formato {output_format.upper()}"
+
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+# Estilos CSS personalizados para una apariencia minimalista
+css = """
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    max-width: 800px;
+    margin: 0 auto;
+}
+.main-header {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+.app-description {
+    margin-bottom: 2rem;
+    text-align: center;
+    color: #666;
+}
+.gr-button {
+    border-radius: 4px !important;
+}
+.gr-button-primary {
+    background: linear-gradient(90deg, #5c1edb, #775af5) !important;
+}
+footer {
+    margin-top: 3rem;
+    text-align: center;
+    font-size: 0.8rem;
+    color: #888;
+}
+"""
+
+# Definir la interfaz de Gradio
+with gr.Blocks(css=css) as demo:
+    gr.HTML("<h1 class='main-header'>🕸️ Web Scraper Tool</h1>")
+    gr.HTML("<p class='app-description'>Ingresa una URL para extraer su contenido en formato PDF o texto plano. La herramienta detectará automáticamente si se trata de una imagen.</p>")
+
+    with gr.Row():
+        url_input = gr.Textbox(
+            label="URL", 
+            placeholder="https://ejemplo.com",
+            info="Ingresa la URL que deseas procesar"
+        )
+
+    with gr.Row():
+        format_select = gr.Radio(
+            ["txt", "pdf"], 
+            label="Formato de salida", 
+            value="txt",
+            info="Selecciona el formato para guardar el contenido"
+        )
+
+    with gr.Row():
+        submit_btn = gr.Button("Procesar URL", variant="primary")
+
+    with gr.Row():
+        output_message = gr.Textbox(label="Estado")
+
+    with gr.Row():
+        file_output = gr.File(label="Archivo generado")
+
+    submit_btn.click(
+        fn=scrape_url,
+        inputs=[url_input, format_select],
+        outputs=[file_output, output_message]
+    )
+
+    gr.HTML("<footer>Desarrollado con <a href='https://gradio.app'>Gradio</a> y <a href='https://huggingface.co/spaces'>Hugging Face Spaces</a></footer>")
+
+# Iniciar la aplicación
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.12.0
+requests==2.31.0
+beautifulsoup4==4.12.2
+weasyprint==60.2
+Pillow==10.0.0
+lxml==4.9.3
+html5lib==1.1

web_scraper_tool.py

@@ -0,0 +1,201 @@
+import requests
+from bs4 import BeautifulSoup
+import os
+from weasyprint import HTML, CSS
+from PIL import Image
+from io import BytesIO
+import re
+import random
+import mimetypes
+import json
+import time
+
+class WebScrapperTool:
+    """Herramienta para hacer scraping de páginas web y convertir a diferentes formatos"""
+
+    def __init__(self, output_dir):
+        """Inicializa la herramienta
+
+        Args:
+            output_dir: Directorio donde se guardarán los archivos
+        """
+        self.output_dir = output_dir
+        self.session = self._create_session()
+
+        # Crear directorio de salida si no existe
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+    def _create_session(self):
+        """Crea una sesión de requests con user agent aleatorio"""
+        session = requests.Session()
+
+        # Lista de user agents comunes
+        user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Safari/605.1.15',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36 Edg/92.0.902.67'
+        ]
+
+        # Configurar headers con user agent aleatorio
+        headers = {
+            'User-Agent': random.choice(user_agents),
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3',
+            'Upgrade-Insecure-Requests': '1',
+            'DNT': '1',  # Do Not Track
+        }
+
+        session.headers.update(headers)
+        return session
+
+    def is_image_url(self, url):
+        """Verifica si una URL es una imagen basándose en la extensión y/o Content-Type
+
+        Args:
+            url: URL a verificar
+
+        Returns:
+            bool: True si es una imagen, False en caso contrario
+        """
+        # Verificar por extensión de archivo
+        image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.bmp', '.tiff']
+        if any(url.lower().endswith(ext) for ext in image_extensions):
+            return True
+
+        # Verificar por Content-Type
+        try:
+            response = self.session.head(url, timeout=10)
+            content_type = response.headers.get('Content-Type', '')
+            return content_type.startswith('image/')
+        except:
+            # Si falla la verificación por header, intentamos con la extensión solamente
+            return False
+
+    def get_image_metadata(self, url):
+        """Obtiene metadatos de una imagen
+
+        Args:
+            url: URL de la imagen
+
+        Returns:
+            dict: Diccionario con metadatos
+        """
+        try:
+            # Obtener la imagen
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+
+            # Metadatos básicos
+            metadata = {
+                'URL': url,
+                'Content-Type': response.headers.get('Content-Type', 'Desconocido'),
+                'Tamaño (bytes)': len(response.content),
+            }
+
+            # Intentar obtener dimensiones
+            try:
+                img = Image.open(BytesIO(response.content))
+                metadata['Dimensiones'] = f"{img.width}x{img.height} píxeles"
+                metadata['Formato'] = img.format
+                metadata['Modo'] = img.mode
+            except:
+                metadata['Dimensiones'] = "No se pudieron determinar"
+
+            return metadata
+        except Exception as e:
+            return {'Error': str(e)}
+
+    def scrape_to_text(self, url, output_path=None):
+        """Hace scraping de una URL y guarda el contenido como texto plano
+
+        Args:
+            url: URL para hacer scraping
+            output_path: Ruta donde guardar el archivo de texto
+
+        Returns:
+            str: Ruta al archivo generado
+        """
+        try:
+            # Obtener contenido de la página
+            response = self.session.get(url, timeout=15)
+            response.raise_for_status()
+
+            # Parsear HTML
+            soup = BeautifulSoup(response.text, 'html.parser')
+
+            # Eliminar scripts, estilos y elementos no visibles
+            for element in soup(['script', 'style', 'head', 'title', 'meta', '[document]']):
+                element.extract()
+
+            # Obtener texto
+            text = soup.get_text(separator='\n')
+
+            # Limpiar espacios en blanco excesivos
+            lines = [line.strip() for line in text.split('\n')]
+            text = '\n'.join(line for line in lines if line)
+
+            # Generar nombre de archivo si no se proporciona
+            if not output_path:
+                filename = f"texto_{int(time.time())}.txt"
+                output_path = os.path.join(self.output_dir, filename)
+
+            # Guardar texto en archivo
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(f"URL: {url}\n\n")
+                f.write(text)
+
+            return output_path
+        except Exception as e:
+            raise Exception(f"Error al hacer scraping a texto: {str(e)}")
+
+    def scrape_to_pdf(self, url, output_path=None):
+        """Hace scraping de una URL y guarda el contenido como PDF
+
+        Args:
+            url: URL para hacer scraping
+            output_path: Ruta donde guardar el archivo PDF
+
+        Returns:
+            str: Ruta al archivo generado
+        """
+        try:
+            # Generar nombre de archivo si no se proporciona
+            if not output_path:
+                filename = f"documento_{int(time.time())}.pdf"
+                output_path = os.path.join(self.output_dir, filename)
+
+            # CSS para mejorar el estilo del PDF
+            css_string = """
+                @page {
+                    margin: 1cm;
+                }
+                body {
+                    font-family: Arial, sans-serif;
+                    line-height: 1.5;
+                    font-size: 12px;
+                }
+                h1, h2, h3, h4, h5, h6 {
+                    margin-top: 1em;
+                    margin-bottom: 0.5em;
+                }
+                p {
+                    margin-bottom: 0.5em;
+                }
+                img {
+                    max-width: 100%;
+                    height: auto;
+                }
+            """
+
+            # Generar PDF
+            HTML(url=url).write_pdf(
+                output_path,
+                stylesheets=[CSS(string=css_string)]
+            )
+
+            return output_path
+        except Exception as e:
+            raise Exception(f"Error al convertir a PDF: {str(e)}")