Python - Web Scrapping EventBrite

from selenium import webdriver

from bs4 import BeautifulSoup

import csv

from dateutil import parser

from datetime import datetime, timedelta

from dateutil import tz

# Definir la función para normalizar fechas

def normalize_date(input_date):

    if "today" in input_date.lower():

        return datetime.now().date()

    elif "tomorrow" in input_date.lower():

        return (datetime.now() + timedelta(days=1)).date()

    elif any(day in input_date.lower() for day in ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]):

        # Encontramos un día de la semana, calculamos la próxima fecha

        current_date = datetime.now().date()

        days_until_next_day = (current_date.weekday(

        ) - ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"].index(input_date.lower())) % 7

        return (current_date + timedelta(days=days_until_next_day)).strftime("%a, %b %d")

    try:

        # Cambiar el formato de fecha para omitir las comillas

        return datetime.strptime(input_date, "%a, %b %d").date().replace(year=datetime.now().year).strftime("%Y-%m-%d")

    except ValueError:

        try:

            # Intentar convertir a formato de fecha directamente

            return datetime.strptime(input_date, "%Y-%m-%d").date()

        except ValueError:

            # Devuelve la entrada original si no coincide con ninguno de los casos anteriores

            return input_date

# URL base de Eventbrite para eventos en Madrid

base_url = "https://www.eventbrite.com/d/spain--madrid/free--events--next-month/?page="

# Inicializa el controlador web de Selenium

# Necesitas tener Chrome y chromedriver instalados

driver = webdriver.Chrome()

# driver = webdriver.Firefox()

# Número de páginas a buscar

num_pages = 5

# Conjunto para evitar eventos duplicados

seen_events = set()

# Lista para almacenar los datos de los eventos

data = []

for page_number in range(1, num_pages + 1):

    # Construye la URL de la página actual

    url = f"{base_url}{page_number}"

    # print(f'\n===> url: {url}')

    # Realiza la solicitud HTTP para obtener la página

    driver.get(url)

    # Espera a que la página se cargue completamente (puedes ajustar el tiempo según sea necesario)

    driver.implicitly_wait(10)

    # Obtiene el contenido de la página después de que se haya ejecutado JavaScript

    page_source = driver.page_source

    # Parsea la página con BeautifulSoup

    soup = BeautifulSoup(page_source, 'html.parser')

    # Encuentra todos los elementos que contienen detalles de eventos

    event_elements = soup.find_all("div", class_="Stack_root__1ksk7")

    for event_element in event_elements:

        # Encuentra el nombre del evento y la imagen directamente de la página principal

        event_name_element = event_element.find(

            "h2", class_="Typography_root__4bejd")

        event_name = event_name_element.text.strip(

        ) if event_name_element else "Título no disponible"

        # IMAGEN

        image_element = soup.find("img", {"class": "event-card-image"})

        # Extracta la URL de la imagen

        image_url = image_element['src'] if image_element else "URL de imagen no disponible"

        # print(image_url)

        # URL DEL EVENTO

        url_element = event_element.find("a", class_="event-card-link")

        event_url = url_element['href'] if url_element else "URL de evento no disponible"

        # DESCRIPCIÓN

        # Utiliza la URL del evento como descripción

        categoria = "n/a"

        description = "No hay descriccion"

        if "URL de evento no disponible" not in event_url:

            # print(f"\n===> Event url: {event_url}")

            driver.get(event_url)

            driver.implicitly_wait(10)

            page_source = driver.page_source

            soup_evento = BeautifulSoup(page_source, 'html.parser')

            summary_element = soup_evento.find("p", class_="summary")

            description = summary_element.text.strip(

            ) if summary_element else "No hay descricion"

            # print(f"==> {description}")

            # Encontrar las categorias

            tags_element = soup_evento.findAll("a", class_="tags-link")

            categorias = []

            for tag in tags_element:

                # print(f"tag: {tag.text}")

                categorias.append(tag.text)

            categoria = "|".join(categorias)

        # LOCALIZACIÓN

        # Encuentra el elemento del párrafo de la ubicación

        location_element = soup.find("p",

                                     class_="Typography_root__4bejd #585163 Typography_body-md__4bejd event-card__clamp-line--one Typography_align-match-parent__4bejd")

        # Extrae el texto de la ubicación sin las etiquetas HTML y sin la clase

        location = location_element.text.strip(

        ) if location_element else "Information not available"

        # FECHA

        date_element = soup.find("p",

                                 class_="Typography_root__4bejd #3a3247 Typography_body-md-bold__4bejd Typography_align-match-parent__4bejd")

        # Extrae el texto de la fecha sin las etiquetas HTML y sin la clase

        date_text = date_element.text.strip() if date_element else "Fecha no disponible"

        # Procesar la fecha para obtener el formato deseado

        date_parts = date_text.split('•')

        date = normalize_date(date_parts[0].strip(

        )) if date_parts else normalize_date(date_text)

        # HORA

        time = date_parts[1].strip() if date_parts else date_text

        # Convertir a formato de 24 horas y manejar la zona horaria

        try:

            # Utilizar dateutil.parser para manejar diferentes formatos de hora y zona horaria

            parsed_time = parser.parse(time)

            # Convertir la hora a formato de 24 horas

            time = parsed_time.strftime("%H:%M")

        except ValueError:

            # En caso de error al convertir, dejar el valor original

            pass

        # Verifica si el evento ya ha sido procesado

        if event_name not in seen_events:

            # Agrega los datos a la lista y al conjunto

            data.append(

                [event_name, image_url, event_url, location, date, time, description, categoria])

            seen_events.add(event_name)

# Guardar datos en CSV

with open('eventbrite_main_info.csv', 'w', newline='', encoding='utf-8') as csvfile:

    writer = csv.writer(csvfile)

    writer.writerow(["Name", "Image URL", "Event URL",

                    "Location", "Date", "Time", "Description", "Categoria"])

    for event in data:

        writer.writerow(event)

print("Scraping completado. Los datos han sido guardados en eventbrite_main_info.csv.")

# Cerrar el controlador de Selenium

driver.quit()

forward_days = 5

from selenium import webdriver

from bs4 import BeautifulSoup

import csv

from dateutil import parser

from datetime import datetime, timedelta

from dateutil import tz

def is_date_ok(date, forward_days):

    '''Chequea que los dias del date sean mayor o igual a dias en adelante'''

    try:

        today = datetime.now().date()

        delta = date - today

        print(f"===> Delta days: {delta.days}")

        return delta.days >= forward_days

    except TypeError:

        print(f"La date no es date type: {date}")

        return False

def normalize_date(input_date):

    '''Definir la función para normalizar fechas'''

    # print(f"===> input_date: [{input_date}]")

    if "today" in input_date.lower():

        return datetime.now().date()

    elif "tomorrow" in input_date.lower():

        return (datetime.now() + timedelta(days=1)).date()

    elif any(day in input_date.lower() for day in ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]):

        # Encontramos un día de la semana, calculamos la próxima fecha

        current_date = datetime.now().date()

        days_until_next_day = (current_date.weekday(

        ) - ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"].index(input_date.lower())) % 7

        # return (current_date + timedelta(days=days_until_next_day)).strftime("%a, %b %d")

        return (datetime.now() + timedelta(days=days_until_next_day)).date()

    try:

        # Cambiar el formato de fecha para omitir las comillas

        value = datetime.strptime(input_date, "%a, %b %d").date().replace(

            year=datetime.now().year).strftime("%Y-%m-%d")

        return datetime.strptime(value, "%Y-%m-%d").date()

    except ValueError:

        try:

            # Intentar convertir a formato de fecha directamente

            value = datetime.strptime(input_date, "%a, %d %b").date().replace(

                year=datetime.now().year).strftime("%Y-%m-%d")

            return datetime.strptime(value, "%Y-%m-%d").date()

            # return datetime.strptime(input_date, "%Y-%m-%d").date()

        except ValueError:

            # Devuelve la entrada original si no coincide con ninguno de los casos anteriores

            return input_date

def main():

    # URL base de Eventbrite para eventos en Madrid

    base_url = "https://www.eventbrite.com/d/spain--madrid/free--events--next-month/?page="

    # Inicializa el controlador web de Selenium

    # Necesitas tener Chrome y chromedriver instalados

    driver = webdriver.Chrome()

    # driver = webdriver.Firefox()

    # Número de páginas a buscar

    num_pages = 4

    # Dias en adelanto

    forward_days = 5

    # Conjunto para evitar eventos duplicados

    seen_events = set()

    # Lista para almacenar los datos de los eventos

    data = []

    for page_number in range(1, num_pages + 1):

        # Construye la URL de la página actual

        url = f"{base_url}{page_number}"

        print(f'\n===> url: {url}')

        # Realiza la solicitud HTTP para obtener la página

        driver.get(url)

        # Espera a que la página se cargue completamente (puedes ajustar el tiempo según sea necesario)

        driver.implicitly_wait(10)

        # Obtiene el contenido de la página después de que se haya ejecutado JavaScript

        page_source = driver.page_source

        # Parsea la página con BeautifulSoup

        soup = BeautifulSoup(page_source, 'html.parser')

        # Encuentra todos los elementos que contienen detalles de eventos

        event_elements = soup.find_all("div", class_="Stack_root__1ksk7")

        for event_element in event_elements:

            # Encuentra el nombre del evento y la imagen directamente de la página principal

            event_name_element = event_element.find(

                "h2", class_="Typography_root__4bejd")

            event_name = event_name_element.text.strip(

            ) if event_name_element else "Título no disponible"

            # IMAGEN

            image_element = soup.find("img", {"class": "event-card-image"})

            # Extracta la URL de la imagen

            image_url = image_element['src'] if image_element else "URL de imagen no disponible"

            # print(image_url)

            # URL DEL EVENTO

            url_element = event_element.find("a", class_="event-card-link")

            event_url = url_element['href'] if url_element else "URL de evento no disponible"

            # DESCRIPCIÓN

            # Utiliza la URL del evento como descripción

            categoria = "n/a"

            description = "No hay descriccion"

            if "URL de evento no disponible" not in event_url:

                # print(f"\n===> Event url: {event_url}")

                driver.get(event_url)

                driver.implicitly_wait(10)

                page_source = driver.page_source

                soup_evento = BeautifulSoup(page_source, 'html.parser')

                summary_element = soup_evento.find("p", class_="summary")

                description = summary_element.text.strip(

                ) if summary_element else "No hay descricion"

                # print(f"==> {description}")

                # Encontrar las categorias

                tags_element = soup_evento.findAll("a", class_="tags-link")

                categorias = []

                for tag in tags_element:

                    # print(f"tag: {tag.text}")

                    categorias.append(tag.text)

                categoria = "|".join(categorias)

            # LOCALIZACIÓN

            # Encuentra el elemento del párrafo de la ubicación

            location_element = soup.find("p",

                                         class_="Typography_root__4bejd #585163 Typography_body-md__4bejd event-card__clamp-line--one Typography_align-match-parent__4bejd")

            # Extrae el texto de la ubicación sin las etiquetas HTML y sin la clase

            location = location_element.text.strip(

            ) if location_element else "Information not available"

            # FECHA

            date_element = soup.find("p",

                                     class_="Typography_root__4bejd #3a3247 Typography_body-md-bold__4bejd Typography_align-match-parent__4bejd")

            # Extrae el texto de la fecha sin las etiquetas HTML y sin la clase

            date_text = date_element.text.strip() if date_element else "Fecha no disponible"

            # Procesar la fecha para obtener el formato deseado

            date_parts = date_text.split('•')

            date = normalize_date(date_parts[0].strip(

            )) if date_parts else normalize_date(date_text)

            print(f"Normalize date: [{date}]")

            # HORA

            time = date_parts[1].strip() if date_parts else date_text

            # Convertir a formato de 24 horas y manejar la zona horaria

            try:

                # Utilizar dateutil.parser para manejar diferentes formatos de hora y zona horaria

                parsed_time = parser.parse(time)

                # Convertir la hora a formato de 24 horas

                time = parsed_time.strftime("%H:%M")

            except ValueError:

                # En caso de error al convertir, dejar el valor original

                print(f"-- Error parsing {time}")

                pass

            # Verifica si el evento ya ha sido procesado

            if event_name not in seen_events and is_date_ok(date, forward_days):

                print(f"===> Event name: [{event_name}]")

                # Agrega los datos a la lista y al conjunto

                data.append(

                    [event_name, image_url, event_url, location, date, time, description, categoria])

                seen_events.add(event_name)

    print(f"Seen events size: {len(seen_events)}")

    print(f"Number of events: {len(data)}")

    # Guardar datos en CSV

    with open('eventbrite_main_info.csv', 'w', newline='', encoding='utf-8') as csvfile:

        writer = csv.writer(csvfile)

        writer.writerow(["Name", "Image URL", "Event URL",

                        "Location", "Date", "Time", "Description", "Categoria"])

        for event in data:

            writer.writerow(event)

    print("Scraping completado. Los datos han sido guardados en eventbrite_main_info.csv.")

    # Cerrar el controlador de Selenium

    driver.quit()

# Comenzando a processar

main()

from selenium import webdriver

from bs4 import BeautifulSoup

import csv

from dateutil import parser

from datetime import datetime, timedelta

from dateutil import tz

from selenium.webdriver.support.wait import WebDriverWait

from selenium.webdriver.common.by import By

from selenium.webdriver.support import expected_conditions as EC

from selenium.webdriver.firefox.options import Options

def is_date_ok(date, forward_days):

    '''Chequea que los dias del date sean mayor o igual a dias en adelante'''

    try:

        today = datetime.now().date()

        delta = date - today

        # print(f"===> Delta days: {delta.days}")

        return delta.days >= forward_days

    except TypeError:

        print(f"La date no es date type: {date}")

        return False

def normalize_date(input_date):

    '''Definir la función para normalizar fechas'''

    # print(f"===> input_date: [{input_date}]")

    if "today" in input_date.lower():

        return datetime.now().date()

    elif "tomorrow" in input_date.lower():

        return (datetime.now() + timedelta(days=1)).date()

    elif any(day in input_date.lower() for day in ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]):

        # Encontramos un día de la semana, calculamos la próxima fecha

        current_date = datetime.now().date()

        days_until_next_day = (current_date.weekday(

        ) - ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"].index(input_date.lower())) % 7

        # return (current_date + timedelta(days=days_until_next_day)).strftime("%a, %b %d")

        return (datetime.now() + timedelta(days=days_until_next_day)).date()

    try:

        # Cambiar el formato de fecha para omitir las comillas

        value = datetime.strptime(input_date, "%a, %b %d").date().replace(

            year=datetime.now().year).strftime("%Y-%m-%d")

        return datetime.strptime(value, "%Y-%m-%d").date()

    except ValueError:

        try:

            # Intentar convertir a formato de fecha directamente

            value = datetime.strptime(input_date, "%a, %d %b").date().replace(

                year=datetime.now().year).strftime("%Y-%m-%d")

            return datetime.strptime(value, "%Y-%m-%d").date()

            # return datetime.strptime(input_date, "%Y-%m-%d").date()

        except ValueError:

            # Devuelve la entrada original si no coincide con ninguno de los casos anteriores

            return input_date

def main():

    # URL base de Eventbrite para eventos en Madrid

    base_url = "https://www.eventbrite.com/d/spain--madrid/free--events--next-month/?page="

    # Inicializa el controlador web de Selenium

    # Necesitas tener Chrome y chromedriver instalados

    driver = webdriver.Chrome()

    # options = Options()

    # options.headless = False

    # driver = webdriver.Firefox(options=options)

    # Número de páginas a buscar

    num_pages = 5

    # Dias en adelanto

    forward_days = 15

    # Conjunto para evitar eventos duplicados

    seen_events = set()

    # Lista para almacenar los datos de los eventos

    data = []

    for page_number in range(1, num_pages + 1):

        # Construye la URL de la página actual

        url = f"{base_url}{page_number}"

        print(f'\n\n===> url: {url}')

        # Realiza la solicitud HTTP para obtener la página

        driver.get(url)

        # Espera a que la página se cargue completamente (puedes ajustar el tiempo según sea necesario)

        # driver.implicitly_wait(10)

        WebDriverWait(driver, 10).until(

            EC.presence_of_element_located((By.CLASS_NAME, "Stack_root__1ksk7")))

        # Obtiene el contenido de la página después de que se haya ejecutado JavaScript

        page_source = driver.page_source

        # Parsea la página con BeautifulSoup

        soup = BeautifulSoup(page_source, 'html.parser')

        # Encuentra todos los elementos que contienen detalles de eventos

        event_elements = soup.find_all("div", class_="Stack_root__1ksk7")

        for event_element in event_elements:

            # FECHA

            date_element = event_element.find("p",

                                              class_="Typography_root__4bejd #585163 Typography_body-md__4bejd event-card__clamp-line--one Typography_align-match-parent__4bejd")

            # Extrae el texto de la fecha sin las etiquetas HTML y sin la clase

            date_text = date_element.text.strip() if date_element else "Fecha no disponible"

            # Encuentra el nombre del evento y la imagen directamente de la página principal

            event_name_element = event_element.find(

                "h2", class_="Typography_root__4bejd")

            event_name = event_name_element.text.strip(

            ) if event_name_element else "Título no disponible"

            print(

                f"\n----- Date_text: [{date_text}] and event name: [{event_name}]")

            # Procesar la fecha para obtener el formato deseado

            date_parts = date_text.split('•')

            date = normalize_date(date_parts[0].strip(

            )) if date_parts else normalize_date(date_text)

            print(f"Normalize date: [{date}] and date_text: [{date_text}]")

            if not is_date_ok(date, forward_days):

                continue

            # HORA

            time = date_parts[1].strip() if date_parts else date_text

            # IMAGEN

            image_element = event_element.find(

                "img", {"class": "event-card-image"})

            # Extracta la URL de la imagen

            image_url = image_element['src'] if image_element else "URL de imagen no disponible"

            # print(image_url)

            # URL DEL EVENTO

            url_element = event_element.find("a", class_="event-card-link")

            event_url = url_element['href'] if url_element else "URL de evento no disponible"

            # DESCRIPCIÓN

            # Utiliza la URL del evento como descripción

            categoria = "n/a"

            description = "No hay descriccion"

            location = "No hay locaccion"

            if "URL de evento no disponible" not in event_url:

                # print(f"\n===> Event url: {event_url}")

                driver.get(event_url)

                # driver.implicitly_wait(10)

                page_source = driver.page_source

                WebDriverWait(driver, 10).until(

                    EC.presence_of_element_located((By.CLASS_NAME, "summary")))

                soup_evento = BeautifulSoup(page_source, 'html.parser')

                summary_element = soup_evento.find("p", class_="summary")

                description = summary_element.text.strip(

                ) if summary_element else "No hay descricion"

                location_element = soup_evento.find(

                    "p", class_="location-info__address-text")

                location = location_element.text.strip(

                ) if location_element else "No hay locaccion"

                # print(f"==> {description}")

                # Encontrar las categorias

                tags_element = soup_evento.findAll("a", class_="tags-link")

                categorias = []

                for tag in tags_element:

                    # print(f"tag: {tag.text}")

                    categorias.append(tag.text)

                categoria = "|".join(categorias)

            # Convertir a formato de 24 horas y manejar la zona horaria

            try:

                # Utilizar dateutil.parser para manejar diferentes formatos de hora y zona horaria

                parsed_time = parser.parse(time)

                # Convertir la hora a formato de 24 horas

                time = parsed_time.strftime("%H:%M")

            except ValueError:

                # En caso de error al convertir, dejar el valor original

                print(f"-- Error parsing {time}")

                pass

            # Verifica si el evento ya ha sido procesado

            if event_name not in seen_events:

                print(f"===> Event name: [{event_name}] and date: [{date}]")

                # Agrega los datos a la lista y al conjunto

                data.append(

                    [event_name, image_url, event_url, location, date, time, description, categoria])

                seen_events.add(event_name)

    print(f"Seen events size: {len(seen_events)}")

    print(f"Number of events: {len(data)}")

    # Guardar datos en CSV

    with open('eventbrite_main_info.csv', 'w', newline='', encoding='utf-8') as csvfile:

        writer = csv.writer(csvfile)

        writer.writerow(["Name", "Image URL", "Event URL",

                        "Location", "Date", "Time", "Description", "Categoria"])

        for event in data:

            writer.writerow(event)

    print("Scraping completado. Los datos han sido guardados en eventbrite_main_info.csv.")

    # Cerrar el controlador de Selenium

    driver.quit()

# Comenzando a processar

main()

from selenium import webdriver

from bs4 import BeautifulSoup

import csv

from dateutil import parser

from datetime import datetime, timedelta

from selenium.webdriver.support.wait import WebDriverWait

from selenium.webdriver.common.by import By

from selenium.webdriver.support import expected_conditions as EC

from selenium.webdriver.firefox.options import Options

NUMERO_DE_PAGINAS_A_BUSCAR = 5

DIAS_EN_ADELANTO = 4

BASE_URL = "https://www.eventbrite.com/d/spain--madrid/free--events/?page="

# BASE_URL = "https://www.eventbrite.com/d/spain--madrid/free--events--next-month/?page="

FECHA_NO_DISPONIBLE = "Fecha no disponible"

HORA_NO_DISPONIBLE = "Hora no disponible"

TITULO_NO_DISPONIBLE = "Título no disponible"

URL_IMAGEN_NO_DISPONIBLE = "URL de imagen no disponible"

URL_EVENTO_NO_DISPONIBLE = "URL de evento no disponible"

NO_HAY_DESCRICCION = "No hay descricion"

NO_HAY_LOCACCION = "No hay locaccion"

CLASS_EVENT_NAME = "Typography_root__4bejd"

CLASS_URL_EVENT = "event-card-link"

CLASS_IMAGE_EVENT = "event-card-image"

CLASS_DATE_EVENT = "Typography_root__4bejd"

CLASS_SUMMARY = "summary"

CLASS_TAGS = "tags-link"

CLASS_EVENT_ELEMENT = "Stack_root__1ksk7"

def get_event_time(date_parts, date_text):

    '''Retorna la hora del evento'''

    time = date_parts[1].strip() if date_parts else date_text

    # Convertir a formato de 24 horas y manejar la zona horaria

    try:

        # Utilizar dateutil.parser para manejar diferentes formatos de hora y zona horaria

        parsed_time = parser.parse(time)

        # Convertir la hora a formato de 24 horas

        time = parsed_time.strftime("%H:%M")

    except ValueError:

        # En caso de error al convertir, dejar el valor original

        print(f"-- Error parsing [{time}]")

        time = "00:00"

    return time

def get_event_date(date_elements, event_name):

    '''Retorna la fecha del evento'''

    date = None

    date_text = None

    date_parts = None

    for delement in date_elements:

        date_text = delement.text.strip() if delement else FECHA_NO_DISPONIBLE

        print(

            f"-----+++> event name: [{event_name}] and Date_text: [{date_text}]")

        date_parts = date_text.split('•')

        date = normalize_date(date_parts[0].strip(

        )) if date_parts else normalize_date(date_text)

        if date.__class__.__name__ == 'date':

            break

    return date, date_text, date_parts

def get_event_date_time(event_element, event_name, forward_days):

    '''Retorna el evento fecha y tiempo'''

    date_elements = event_element.find_all(

        "p", class_=CLASS_DATE_EVENT)

    date, date_text, date_parts = get_event_date(

        date_elements=date_elements, event_name=event_name)

    time = HORA_NO_DISPONIBLE

    if date.__class__.__name__ == 'date':

        if is_date_ok(date, forward_days):

            # HORA

            time = get_event_time(date_parts=date_parts, date_text=date_text)

        else:

            print(

                f"---> Removing because date [{date}] is less than date + forward days: [{forward_days}]")

            date = None

    else:

        date = FECHA_NO_DISPONIBLE

    return date, time

def is_date_ok(date, forward_days):

    '''Chequea que los dias del date sean mayor o igual a dias en adelante'''

    try:

        today = datetime.now().date()

        delta = date - today

        # print(f"===> Delta days: {delta.days}")

        return delta.days >= forward_days

    except TypeError:

        print(f"---> La fecha no es date type: {date}")

        return False

def get_date_from_weekday(input_date):

    '''Calculamos la fecha al dia de la semana'''

    days_of_week = {

        0: "monday",

        1: "tuesday",

        2: "wednesday",

        3: "thursday",

        4: "friday",

        5: "saturday",

        6: "sunday",

    }

    current_date = datetime.now().date()

    for i in range(6):

        current_date = current_date + timedelta(days=1)

        value = days_of_week[current_date.weekday()]

        if input_date.lower() == value:

            break

    return current_date

def normalize_date(input_date):

    '''Definir la función para normalizar fechas'''

    # print(f"===> input_date: [{input_date}]")

    if "today" in input_date.lower():

        return datetime.now().date()

    elif "tomorrow" in input_date.lower():

        return (datetime.now() + timedelta(days=1)).date()

    elif any(day in input_date.lower() for day in ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]):

        return get_date_from_weekday(input_date=input_date)

    try:

        # Cambiar el formato de fecha para omitir las comillas

        value = datetime.strptime(input_date, "%a, %b %d").date().replace(

            year=datetime.now().year).strftime("%Y-%m-%d")

        return datetime.strptime(value, "%Y-%m-%d").date()

    except ValueError:

        try:

            # Intentar convertir a formato de fecha directamente

            value = datetime.strptime(input_date, "%a, %d %b").date().replace(

                year=datetime.now().year).strftime("%Y-%m-%d")

            return datetime.strptime(value, "%Y-%m-%d").date()

            # return datetime.strptime(input_date, "%Y-%m-%d").date()

        except ValueError:

            # Devuelve la entrada original si no coincide con ninguno de los casos anteriores

            return input_date

def get_cat_desc_location(driver, event_url):

    '''Retorna la categorias, descriccion y locaccion del evento'''

    categoria = "n/a"

    description = "No hay descriccion"

    location = "No hay locaccion"

    if "URL de evento no disponible" not in event_url:

        # print(f"\n===> Event url: {event_url}")

        driver.get(event_url)

        # driver.implicitly_wait(10)

        page_source = driver.page_source

        WebDriverWait(driver, 10).until(

            EC.presence_of_element_located((By.CLASS_NAME, CLASS_SUMMARY)))

        soup_evento = BeautifulSoup(page_source, 'html.parser')

        summary_element = soup_evento.find("p", class_=CLASS_SUMMARY)

        description = summary_element.text.strip(

        ) if summary_element else NO_HAY_DESCRICCION

        location_element = soup_evento.find(

            "p", class_="location-info__address-text")

        location = location_element.text.strip(

        ) if location_element else NO_HAY_LOCACCION

        # print(f"==> {description}")

        # Encontrar las categorias

        tags_element = soup_evento.findAll("a", class_=CLASS_TAGS)

        categorias = []

        for tag in tags_element:

            # print(f"tag: {tag.text}")

            categorias.append(tag.text)

        categoria = "|".join(categorias)

    return categoria, description, location

def main():

    # URL base de Eventbrite para eventos en Madrid

    # base_url = BASE_URL

    base_url = BASE_URL

    # Inicializa el controlador web de Selenium

    # Necesitas tener Chrome y chromedriver instalados

    driver = webdriver.Chrome()

    # options = Options()

    # options.headless = True

    # driver = webdriver.Firefox(options=options)

    # Número de páginas a buscar

    num_pages = NUMERO_DE_PAGINAS_A_BUSCAR

    # Dias en adelanto

    forward_days = DIAS_EN_ADELANTO

    # Conjunto para evitar eventos duplicados

    seen_events = set()

    # Lista para almacenar los datos de los eventos

    data = []

    for page_number in range(1, num_pages + 1):

        # Construye la URL de la página actual

        url = f"{base_url}{page_number}"

        print(f'\n\n===> url: {url}')

        # Realiza la solicitud HTTP para obtener la página

        driver.get(url)

        # Espera a que la página se cargue completamente (puedes ajustar el tiempo según sea necesario)

        driver.implicitly_wait(10)

        # WebDriverWait(driver, 10).until(

        #     EC.presence_of_element_located((By.CLASS_NAME, "Stack_root__1ksk7")))

        # Obtiene el contenido de la página después de que se haya ejecutado JavaScript

        page_source = driver.page_source

        # with open('output.txt', 'a') as f:

        #     f.write(page_source)

        # Parsea la página con BeautifulSoup

        soup = BeautifulSoup(page_source, 'html.parser')

        # Encuentra todos los elementos que contienen detalles de eventos

        event_elements = soup.find_all("div", class_=CLASS_EVENT_ELEMENT)

        print(f"====> Number of rows found: {len(event_elements)}")

        for event_element in event_elements:

            # Event name

            event_name_element = event_element.find(

                "h2", class_=CLASS_EVENT_NAME)

            event_name = event_name_element.text.strip(

            ) if event_name_element else TITULO_NO_DISPONIBLE

            if TITULO_NO_DISPONIBLE in event_name:

                continue

            # Event date and time

            date, time = get_event_date_time(

                event_element=event_element, event_name=event_name, forward_days=forward_days)

            if date is None:

                continue

            # IMAGEN

            image_element = event_element.find(

                "img", {"class": CLASS_IMAGE_EVENT})

            # Extracta la URL de la imagen

            image_url = image_element['src'] if image_element else URL_IMAGEN_NO_DISPONIBLE

            # print(image_url)

            # URL DEL EVENTO

            url_element = event_element.find("a", class_=CLASS_URL_EVENT)

            event_url = url_element['href'] if url_element else URL_EVENTO_NO_DISPONIBLE

            categoria, description, location = get_cat_desc_location(

                driver, event_url)

            # Verifica si el evento ya ha sido procesado

            if event_name not in seen_events:

                print(

                    f"===> Adding event name: [{event_name}] and date: [{date}]")

                # Agrega los datos a la lista y al conjunto

                data.append(

                    [event_name, image_url, event_url, location, date, time, description, categoria])

                seen_events.add(event_name)

            else:

                print(

                    f"----> Already added event name: [{event_name}] and date: [{date}]")

            print("\n ---")

    print(f"Seen events size: {len(seen_events)}")

    print(f"Number of events: {len(data)}")

    # Guardar datos en CSV

    with open('eventbrite_main_info.csv', 'w', newline='', encoding='utf-8') as csvfile:

        writer = csv.writer(csvfile)

        writer.writerow(["Name", "Image URL", "Event URL",

                        "Location", "Date", "Time", "Description", "Categoria"])

        for event in data:

            writer.writerow(event)

    print("Scraping completado. Los datos han sido guardados en eventbrite_main_info.csv.")

    # Cerrar el controlador de Selenium

    driver.quit()

# Comenzando a processar

if __name__ == "__main__":

    main()

from selenium import webdriver

from bs4 import BeautifulSoup

import csv

from dateutil import parser

from datetime import datetime, timedelta

from selenium.webdriver.support.wait import WebDriverWait

from selenium.webdriver.common.by import By

from selenium.webdriver.support import expected_conditions as EC

from selenium.webdriver.firefox.options import Options

NUMERO_DE_PAGINAS_A_BUSCAR = 1

DIAS_EN_ADELANTO = 4

BASE_URL = "https://www.eventbrite.com/d/spain--madrid/free--events/?page="

# BASE_URL = "https://www.eventbrite.com/d/spain--madrid/free--events--next-month/?page="

FECHA_NO_DISPONIBLE = "Fecha no disponible"

HORA_NO_DISPONIBLE = "Hora no disponible"

TITULO_NO_DISPONIBLE = "Título no disponible"

URL_IMAGEN_NO_DISPONIBLE = "URL de imagen no disponible"

URL_EVENTO_NO_DISPONIBLE = "URL de evento no disponible"

NO_HAY_DESCRICCION = "No hay descricion"

NO_HAY_LOCACCION = "No hay locaccion"

NO_HAY_DIRECCION = "No hay direccion"

CLASS_EVENT_NAME = "Typography_root__4bejd"

CLASS_URL_EVENT = "event-card-link"

CLASS_IMAGE_EVENT = "event-card-image"

CLASS_DATE_EVENT = "Typography_root__4bejd"

CLASS_SUMMARY = "summary"

CLASS_TAGS = "tags-link"

CLASS_EVENT_ELEMENT = "Stack_root__1ksk7"

CLASS_LOCATION = "location-info__address-text"

CLASS_ADDRESS = "location-info__address"

def get_event_time(date_parts, date_text):

    '''Retorna la hora del evento'''

    time = date_parts[1].strip() if date_parts else date_text

    # Convertir a formato de 24 horas y manejar la zona horaria

    try:

        # Utilizar dateutil.parser para manejar diferentes formatos de hora y zona horaria

        parsed_time = parser.parse(time)

        # Convertir la hora a formato de 24 horas

        time = parsed_time.strftime("%H:%M")

    except ValueError:

        # En caso de error al convertir, dejar el valor original

        print(f"-- Error parsing [{time}]")

        time = "00:00"

    return time

def get_event_date(date_elements, event_name):

    '''Retorna la fecha del evento'''

    date = None

    date_text = None

    date_parts = None

    for delement in date_elements:

        date_text = delement.text.strip() if delement else FECHA_NO_DISPONIBLE

        print(

            f"-----+++> event name: [{event_name}] and Date_text: [{date_text}]")

        date_parts = date_text.split('•')

        date = normalize_date(date_parts[0].strip(

        )) if date_parts else normalize_date(date_text)

        if date.__class__.__name__ == 'date':

            break

    return date, date_text, date_parts

def get_event_date_time(event_element, event_name, forward_days):

    '''Retorna el evento fecha y tiempo'''

    date_elements = event_element.find_all(

        "p", class_=CLASS_DATE_EVENT)

    date, date_text, date_parts = get_event_date(

        date_elements=date_elements, event_name=event_name)

    time = HORA_NO_DISPONIBLE

    if date.__class__.__name__ == 'date':

        if is_date_ok(date, forward_days):

            # HORA

            time = get_event_time(date_parts=date_parts, date_text=date_text)

        else:

            print(

                f"---> Removing because date [{date}] is less than date + forward days: [{forward_days}]")

            date = None

    else:

        date = FECHA_NO_DISPONIBLE

    return date, time

def is_date_ok(date, forward_days):

    '''Chequea que los dias del date sean mayor o igual a dias en adelante'''

    try:

        today = datetime.now().date()

        delta = date - today

        # print(f"===> Delta days: {delta.days}")

        return delta.days >= forward_days

    except TypeError:

        print(f"---> La fecha no es date type: {date}")

        return False

def get_date_from_weekday(input_date):

    '''Calculamos la fecha al dia de la semana'''

    days_of_week = {

        0: "monday",

        1: "tuesday",

        2: "wednesday",

        3: "thursday",

        4: "friday",

        5: "saturday",

        6: "sunday",

    }

    current_date = datetime.now().date()

    for i in range(6):

        current_date = current_date + timedelta(days=1)

        value = days_of_week[current_date.weekday()]

        if input_date.lower() == value:

            break

    return current_date

def normalize_date(input_date):

    '''Definir la función para normalizar fechas'''

    # print(f"===> input_date: [{input_date}]")

    if "today" in input_date.lower():

        return datetime.now().date()

    elif "tomorrow" in input_date.lower():

        return (datetime.now() + timedelta(days=1)).date()

    elif any(day in input_date.lower() for day in ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]):

        return get_date_from_weekday(input_date=input_date)

    try:

        # Cambiar el formato de fecha para omitir las comillas

        value = datetime.strptime(input_date, "%a, %b %d").date().replace(

            year=datetime.now().year).strftime("%Y-%m-%d")

        return datetime.strptime(value, "%Y-%m-%d").date()

    except ValueError:

        try:

            # Intentar convertir a formato de fecha directamente

            value = datetime.strptime(input_date, "%a, %d %b").date().replace(

                year=datetime.now().year).strftime("%Y-%m-%d")

            return datetime.strptime(value, "%Y-%m-%d").date()

            # return datetime.strptime(input_date, "%Y-%m-%d").date()

        except ValueError:

            # Devuelve la entrada original si no coincide con ninguno de los casos anteriores

            return input_date

def get_cat_desc_location(driver, event_url):

    '''Retorna la categorias, descriccion y locaccion del evento'''

    categoria = "n/a"

    description = "No hay descriccion"

    location = "No hay locaccion"

    if "URL de evento no disponible" not in event_url:

        # print(f"\n===> Event url: {event_url}")

        driver.get(event_url)

        # driver.implicitly_wait(10)

        page_source = driver.page_source

        WebDriverWait(driver, 10).until(

            EC.presence_of_element_located((By.CLASS_NAME, CLASS_SUMMARY)))

        soup_evento = BeautifulSoup(page_source, 'html.parser')

        summary_element = soup_evento.find("p", class_=CLASS_SUMMARY)

        description = summary_element.text.strip(

        ) if summary_element else NO_HAY_DESCRICCION

        location_element = soup_evento.find(

            "p", class_=CLASS_LOCATION)

        location = location_element.text.strip(

        ) if location_element else NO_HAY_LOCACCION

        address_element = soup_evento.find(

            "div", class_=CLASS_ADDRESS)

        address = address_element.text.strip(

        ) if address_element else NO_HAY_DIRECCION

        # Encontrar las categorias

        tags_element = soup_evento.findAll("a", class_=CLASS_TAGS)

        categorias = []

        for tag in tags_element:

            # print(f"tag: {tag.text}")

            categorias.append(tag.text)

        categoria = "|".join(categorias)

    return categoria, description, location, address

def main():

    # URL base de Eventbrite para eventos en Madrid

    # base_url = BASE_URL

    base_url = BASE_URL

    # Inicializa el controlador web de Selenium

    # Necesitas tener Chrome y chromedriver instalados

    driver = webdriver.Chrome()

    # options = Options()

    # options.headless = False

    # driver = webdriver.Firefox(options=options)

    # Número de páginas a buscar

    num_pages = NUMERO_DE_PAGINAS_A_BUSCAR

    # Dias en adelanto

    forward_days = DIAS_EN_ADELANTO

    # Conjunto para evitar eventos duplicados

    seen_events = set()

    # Lista para almacenar los datos de los eventos

    data = []

    for page_number in range(1, num_pages + 1):

        # Construye la URL de la página actual

        url = f"{base_url}{page_number}"

        print(f'\n\n===> url: {url}')

        # Realiza la solicitud HTTP para obtener la página

        driver.get(url)

        # Espera a que la página se cargue completamente (puedes ajustar el tiempo según sea necesario)

        driver.implicitly_wait(10)

        # WebDriverWait(driver, 10).until(

        #     EC.presence_of_element_located((By.CLASS_NAME, "Stack_root__1ksk7")))

        # Obtiene el contenido de la página después de que se haya ejecutado JavaScript

        page_source = driver.page_source

        # with open('output.txt', 'a') as f:

        #     f.write(page_source)

        # Parsea la página con BeautifulSoup

        soup = BeautifulSoup(page_source, 'html.parser')

        # Encuentra todos los elementos que contienen detalles de eventos

        event_elements = soup.find_all("div", class_=CLASS_EVENT_ELEMENT)

        print(f"====> Number of rows found: {len(event_elements)}")

        for event_element in event_elements:

            # Event name

            event_name_element = event_element.find(

                "h2", class_=CLASS_EVENT_NAME)

            event_name = event_name_element.text.strip(

            ) if event_name_element else TITULO_NO_DISPONIBLE

            if TITULO_NO_DISPONIBLE in event_name:

                continue

            # Event date and time

            date, time = get_event_date_time(

                event_element=event_element, event_name=event_name, forward_days=forward_days)

            if date is None:

                continue

            # IMAGEN

            image_element = event_element.find(

                "img", {"class": CLASS_IMAGE_EVENT})

            # Extracta la URL de la imagen

            image_url = image_element['src'] if image_element else URL_IMAGEN_NO_DISPONIBLE

            # print(image_url)

            # URL DEL EVENTO

            url_element = event_element.find("a", class_=CLASS_URL_EVENT)

            event_url = url_element['href'] if url_element else URL_EVENTO_NO_DISPONIBLE

            categoria, description, location, address = get_cat_desc_location(

                driver, event_url)

            # Verifica si el evento ya ha sido procesado

            if event_name not in seen_events:

                print(

                    f"===> Adding event name: [{event_name}] and date: [{date}]")

                # Agrega los datos a la lista y al conjunto

                data.append(

                    [event_name, image_url, event_url, location, address, date, time, description, categoria])

                seen_events.add(event_name)

            else:

                print(

                    f"----> Already added event name: [{event_name}] and date: [{date}]")

            print("\n ---")

    print(f"Seen events size: {len(seen_events)}")

    print(f"Number of events: {len(data)}")

    # Guardar datos en CSV

    with open('eventbrite_main_info.csv', 'w', newline='', encoding='utf-8') as csvfile:

        writer = csv.writer(csvfile)

        writer.writerow(["Name", "Image URL", "Event URL",

                        "Location", "Address", "Date", "Time", "Description", "Categoria"])

        for event in data:

            writer.writerow(event)

    print("Scraping completado. Los datos han sido guardados en eventbrite_main_info.csv.")

    # Cerrar el controlador de Selenium

    driver.quit()

# Comenzando a processar

if __name__ == "__main__":

    main()

from selenium import webdriver

from bs4 import BeautifulSoup

import csv

from dateutil import parser

from datetime import datetime, timedelta

from selenium.webdriver.support.wait import WebDriverWait

from selenium.webdriver.common.by import By

from selenium.webdriver.support import expected_conditions as EC

from selenium.webdriver.firefox.options import Options

NUMERO_DE_PAGINAS_A_BUSCAR = 1

DIAS_EN_ADELANTO = 4

BASE_URL = "https://www.eventbrite.com/d/spain--madrid/free--events/?page="

# BASE_URL = "https://www.eventbrite.com/d/spain--madrid/free--events--next-month/?page="

FECHA_NO_DISPONIBLE = "Fecha no disponible"

HORA_NO_DISPONIBLE = "Hora no disponible"

TITULO_NO_DISPONIBLE = "Título no disponible"

URL_IMAGEN_NO_DISPONIBLE = "URL de imagen no disponible"

URL_EVENTO_NO_DISPONIBLE = "URL de evento no disponible"

NO_HAY_DESCRICCION = "No hay descricion"

NO_HAY_LOCACCION = "No hay locaccion"

NO_HAY_DIRECCION = "No hay direccion"

CLASS_EVENT_NAME = "Typography_root__4bejd"

CLASS_URL_EVENT = "event-card-link"