Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

que puedo hacer si en algunas paginas se bloquea esta llamada al hacer un request?:…

  1. User

    que puedo hacer si en algunas paginas se bloquea esta llamada al hacer un request?: "from youtube_transcript_api import YouTubeTranscriptApi import requests from bs4 import BeautifulSoup import PyPDF2 from io import BytesIO

    def fetch_text_from_url(url): """ Obtiene texto de una URL de YouTube u otros documentos HTML o PDF.

    :param url: Una cadena que representa la URL de la que se desea obtener el texto.
    :return: Una tupla (tipo_de_contenido, texto) donde 'tipo_de_contenido' es 'html', 'pdf', 'youtube' o 'other',
             y 'texto' es el texto extraído o un mensaje de error.
    """
    
    def check_url_content_type(url):
        try:
            response = requests.head(url, allow_redirects=True)
            content_type = response.headers.get('Content-Type', '').lower()
    
            if 'application/pdf' in content_type:
                return 'pdf'
            elif 'youtube' in url:
                return 'youtube'
            elif 'text/html' in content_type:
                return 'html'            
            else:
                return 'other'
        except requests.exceptions.RequestException:
            return None
    
    headers = {
        'User-Agent': ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
                       '(KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'),
        'Accept-Language': 'en-US,en;q=0.9',
    }
    
    try:
        # Para analizar qué tipo de contenido se tiene
        content_type = check_url_content_type(url)
    
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        
        if content_type == 'youtube':
    
            # Extraer el video_id de la URL de YouTube
            if 'v=' in url:
                soup = BeautifulSoup(response.text, 'html.parser')
                text = soup.get_text()
                formatted_text = '\n'.join([line.strip() for line in text.splitlines() if line.strip()])
                video_id = url.split('v=')[1].split('&')[0]
            
                # Obtener la transcripción usando youtube_transcript_api
                try:
                    transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
                    transcript_text = "\n".join([entry['text'] for entry in transcript_list])
                    return 'youtube', formatted_text +  '\n' + transcript_text
                except Exception as e:
                    return 'error', f'No se pudo obtener la transcripción: {e}'
    
        
    
        if content_type == 'html':
            soup = BeautifulSoup(response.text, 'html.parser')
            text = soup.get_text()
            formatted_text = '\n'.join([line.strip() for line in text.splitlines() if line.strip()])
            return 'html', formatted_text
    
        elif content_type == 'pdf':
            pdf_file = BytesIO(response.content)
            pdf_reader = PyPDF2.PdfReader(pdf_file)
    
            pdf_text = ''
            for page in pdf_reader.pages:
                if len(pdf_text) > 100000:
                    break
                pdf_text += page.extract_text()
            return 'pdf', pdf_text
    
        else:
            return 'other', 'Tipo de contenido no soportado o desconocido.'
    
    except requests.exceptions.RequestException as e:
        return 'error', f'Error al realizar la solicitud: {e}'
    
    except Exception as e:
        return 'error', f'Ocurrió un error: {e}'
    

    "

  2. Assistant

    Si al realizar solicitudes (requests) a ciertas páginas tu código está siendo bloqueado, es probable que esas páginas estén implementando medidas anti-scraping o de protección contra bots. A continuación, te proporciono varias estrategias que puedes emplear para mitigar este problema:

    1. Ajustar y Mejorar las Cabeceras (Headers) de la Solicitud

    Aunque ya estás utilizando un User-Agent estándar, podrías intentar imitar más cabeceras que un navegador real enviaría. Por ejemplo:

    headers = {
        'User-Agent': ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
                       '(KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'),
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Referer': 'https://www.google.com/',  # Puede ayudar a evitar bloqueos básicos
        'Connection': 'keep-alive',
        # Puedes añadir más cabeceras según sea necesario
    }
    

    2. Manejar Sesiones y Cookies

    Usar una sesión (requests.Session) puede ayudar a mantener cookies y hacer que las solicitudes sean más coherentes, lo que a veces evita bloqueos.

    session = requests.Session()
    session.headers.update(headers)
    
    # Luego usa `session.get(url)` en lugar de `requests.get(url)`
    response = session.get(url)
    

    3. Rotar Proxies

    Algunas páginas bloquean IPs que realizan múltiples solicitudes en poco tiempo. Utilizar proxies puede ayudarte a evitar esto.

    import random
    
    proxies = [
        'http://proxy1.com:port',
        'http://proxy2.com:port',
        # Añade más proxies
    ]
    
    proxy = random.choice(proxies)
    response = requests.get(url, headers=headers, proxies={'http': proxy, 'https': proxy})
    

    Nota: Asegúrate de usar proxies confiables y legales. Algunos proxies gratuitos pueden ser inseguros o lentos.

    4. Implementar Retrasos y Reintentos

    Agregar retrasos entre solicitudes y reintentar en caso de fallos puede reducir la probabilidad de ser bloqueado.

    import time
    import random
    from requests.adapters import HTTPAdapter
    from requests.packages.urllib3.util.retry import Retry
    
    session = requests.Session()
    session.headers.update(headers)
    
    # Configurar reintentos
    retries = Retry(total=5, backoff_factor=1, status_forcelist=[429, 500, 502, 503, 504])
    session.mount('http://', HTTPAdapter(max_retries=retries))
    session.mount('https://', HTTPAdapter(max_retries=retries))
    
    # Antes de cada solicitud
    time.sleep(random.uniform(1, 3))  # Espera entre 1 y 3 segundos
    response = session.get(url, proxies={'http': proxy, 'https': proxy})
    

    5. Usar Navegadores Sin Cabeza (Headless Browsers)

    Algunas páginas cargan contenido dinámicamente con JavaScript o tienen medidas anti-scraping más avanzadas. Usar una herramienta como Selenium puede ayudarte a simular un navegador real.

    from selenium import webdriver
    from selenium.webdriver.chrome.service import Service
    from webdriver_manager.chrome import ChromeDriverManager
    from bs4 import BeautifulSoup
    
    # Configurar opciones para evitar detección
    options = webdriver.ChromeOptions()
    options.add_argument("--headless")
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument('--no-sandbox')
    options.add_argument('--disable-dev-shm-usage')
    
    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
    driver.get(url)
    
    # Esperar a que JavaScript cargue el contenido si es necesario
    time.sleep(3)  # Ajusta según sea necesario
    
    html = driver.page_source
    soup = BeautifulSoup(html, 'html.parser')
    text = soup.get_text()
    
    driver.quit()
    
    # Procesa `text` según tus necesidades
    

    Nota: Usar Selenium es más pesado y lento que requests, pero es útil para páginas que dependen en gran medida de JavaScript.

    6. Utilizar Bibliotecas Anti-Bloqueo Especializadas

    Herramientas como cloudscraper están diseñadas para manejar desafíos como Cloudflare.

    import cloudscraper
    
    scraper = cloudscraper.create_scraper()
    response = scraper.get(url)
    
    # Procesa `response.text` con BeautifulSoup o como necesites
    

    Instalación:

    pip install cloudscraper
    

    7. Revisar el robots.txt del Sitio Web

    Antes de realizar scraping, es buena práctica verificar el archivo robots.txt del sitio para asegurarte de que estás cumpliendo con sus directrices.

    robots_url = 'https://www.ejemplo.com/robots.txt'
    robots_response = requests.get(robots_url)
    print(robots_response.text)
    

    8. Manejo Adecuado de Excepciones y Logs

    Asegúrate de manejar las excepciones apropiadamente y mantener registros (logs) de tus solicitudes fallidas para analizar patrones de bloqueo.

    import logging
    
    logging.basicConfig(filename='scraping.log', level=logging.INFO)
    
    try:
        response = session.get(url, proxies={'http': proxy, 'https': proxy})
        response.raise_for_status()
        # Procesa la respuesta
    except requests.exceptions.RequestException as e:
        logging.error(f'Error al acceder a {url}: {e}')
    

    9. Considerar Aspectos Legales y Éticos

    Finalmente, siempre es importante asegurarse de que el scraping que realizas respeta los términos de servicio del sitio web y las leyes locales. Algunos sitios prohíben explícitamente el scraping, y violar estas políticas puede tener consecuencias legales.

    Implementación Recomendada en Tu Código

    Integrando algunas de las estrategias anteriores, podrías modificar tu función fetch_text_from_url de la siguiente manera:

    from youtube_transcript_api import YouTubeTranscriptApi
    import requests
    from bs4 import BeautifulSoup
    import PyPDF2
    from io import BytesIO
    import time
    import random
    from requests.adapters import HTTPAdapter
    from requests.packages.urllib3.util.retry import Retry
    import logging
    
    # Configurar logging
    logging.basicConfig(filename='fetch_text.log', level=logging.INFO)
    
    def fetch_text_from_url(url):
        """
        Obtiene texto de una URL de YouTube u otros documentos HTML o PDF.
        
        :param url: Una cadena que representa la URL de la que se desea obtener el texto.
        :return: Una tupla (tipo_de_contenido, texto) donde 'tipo_de_contenido' es 'html', 'pdf', 'youtube' o 'other',
                 y 'texto' es el texto extraído o un mensaje de error.
        """
    
        def check_url_content_type(session, url):
            try:
                response = session.head(url, allow_redirects=True, timeout=10)
                content_type = response.headers.get('Content-Type', '').lower()
    
                if 'application/pdf' in content_type:
                    return 'pdf'
                elif 'youtube' in url:
                    return 'youtube'
                elif 'text/html' in content_type:
                    return 'html'            
                else:
                    return 'other'
            except requests.exceptions.RequestException as e:
                logging.error(f'Error al verificar el tipo de contenido: {e}')
                return None
    
        headers = {
            'User-Agent': ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
                           '(KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'),
            'Accept-Language': 'en-US,en;q=0.9',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
            'Referer': 'https://www.google.com/',
            'Connection': 'keep-alive',
        }
    
        # Configurar sesión con reintentos
        session = requests.Session()
        session.headers.update(headers)
        retries = Retry(total=5, backoff_factor=1, status_forcelist=[429, 500, 502, 503, 504])
        session.mount('http://', HTTPAdapter(max_retries=retries))
        session.mount('https://', HTTPAdapter(max_retries=retries))
    
        # Opcional: implementar proxies si es necesario
        proxies = [
            # 'http://proxy1.com:port',
            # 'http://proxy2.com:port',
        ]
    
        try:
            # Elegir proxy si hay disponibles
            proxy = random.choice(proxies) if proxies else None
    
            # Verificar tipo de contenido
            content_type = check_url_content_type(session, url)
            if not content_type:
                return 'error', 'No se pudo determinar el tipo de contenido.'
    
            # Implementar retraso para evitar ser bloqueado
            time.sleep(random.uniform(1, 3))
    
            # Realizar la solicitud GET
            response = session.get(url, proxies={'http': proxy, 'https': proxy} if proxy else None, timeout=20)
            response.raise_for_status()
    
            if content_type == 'youtube':
                # Procesamiento de YouTube
                if 'v=' in url:
                    soup = BeautifulSoup(response.text, 'html.parser')
                    text = soup.get_text()
                    formatted_text = '\n'.join([line.strip() for line in text.splitlines() if line.strip()])
                    video_id = url.split('v=')[1].split('&')[0]
                
                    try:
                        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
                        transcript_text = "\n".join([entry['text'] for entry in transcript_list])
                        return 'youtube', formatted_text +  '\n' + transcript_text
                    except Exception as e:
                        logging.error(f'Error al obtener transcripción de YouTube: {e}')
                        return 'error', f'No se pudo obtener la transcripción: {e}'
    
            elif content_type == 'html':
                soup = BeautifulSoup(response.text, 'html.parser')
                text = soup.get_text()
                formatted_text = '\n'.join([line.strip() for line in text.splitlines() if line.strip()])
                return 'html', formatted_text
    
            elif content_type == 'pdf':
                pdf_file = BytesIO(response.content)
                pdf_reader = PyPDF2.PdfReader(pdf_file)
    
                pdf_text = ''
                for page in pdf_reader.pages:
                    if len(pdf_text) > 100000:
                        break
                    extracted = page.extract_text()
                    if extracted:
                        pdf_text += extracted
                return 'pdf', pdf_text
    
            else:
                return 'other', 'Tipo de contenido no soportado o desconocido.'
    
        except requests.exceptions.RequestException as e:
            logging.error(f'Error al realizar la solicitud: {e}')
            return 'error', f'Error al realizar la solicitud: {e}'
    
        except Exception as e:
            logging.error(f'Error inesperado: {e}')
            return 'error', f'Ocurrió un error: {e}'
    

    Consideraciones Finales

    • Respeto a las Políticas del Sitio: Asegúrate siempre de respetar las políticas del sitio web que estás accediendo. El scraping no autorizado puede violar términos de servicio y leyes locales.

    • Carga y Rendimiento: Implementa tus solicitudes de manera responsable para no sobrecargar los servidores de destino. Usa retrasos y límites adecuados.

    • Manejo de Datos Sensibles: Si estás manejando datos sensibles o personales, asegúrate de cumplir con las regulaciones de privacidad pertinentes.

    Implementando estas estrategias, deberías reducir la probabilidad de que tus solicitudes sean bloqueadas y mejorar la confiabilidad de tu función fetch_text_from_url.