import os

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QLineEdit,
QPushButton
import asyncio
import aiohttp
import sqlite3
import urllib.robotparser
from bs4 import BeautifulSoup
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.probability import FreqDist
import celery
from celery import Celery
import redis

# Configuración de Celery
app = Celery('web_crawler', broker='redis://localhost:6379/0')

# Configuración de Redis
redis_client = redis.Redis(host='localhost', port=6379, db=1)

class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Web Crawler")
self.setGeometry(100, 100, 400, 200)

self.label_keyword = QLabel("Palabra clave:", self)

self.label_keyword.setGeometry(50, 50, 100, 30)

self.line_edit_keyword = QLineEdit(self)
self.line_edit_keyword.setGeometry(150, 50, 150, 30)

self.button_start = QPushButton("Iniciar", self)

self.button_start.setGeometry(150, 100, 100, 30)
self.button_start.clicked.connect(self.start_crawler)

def start_crawler(self):
keyword = self.line_edit_keyword.text()
# Llamada a la función para iniciar el rastreo con la palabra clave
ingresada
start_web_crawler(keyword)

def start_web_crawler(keyword):
loop = asyncio.get_event_loop()
loop.run_until_complete(run_crawler(keyword))

async def run_crawler(keyword):

# Configurar el cliente de aiohttp
async with aiohttp.ClientSession() as session:
# Configurar la base de datos SQLite
conn = sqlite3.connect('results.db')
cursor = conn.cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS results (url TEXT, line TEXT,
context TEXT)')
 # Crear el objeto RobotFileParser para el análisis de robots.txt
robot_parser = urllib.robotparser.RobotFileParser()
robot_parser.set_url('https://www.example.com/robots.txt')
robot_parser.read()

# Obtener las stopwords en español

stop_words = set(stopwords.words('spanish'))

# Iniciar el rastreo
await crawl_page('https://www.example.com', keyword, session, robot_parser,
cursor, stop_words)

# Cerrar la conexión con la base de datos

conn.close()

async def crawl_page(url, keyword, session, robot_parser, cursor, stop_words):

# Verificar la política de robots.txt
if not robot_parser.can_fetch('*', url):
return

# Realizar la solicitud GET a la URL

async with session.get(url) as response:
if response.status != 200:
return

# Obtener el contenido HTML de la respuesta

html = await response.text()

# Analizar el HTML con BeautifulSoup

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

# Verificar si la palabra clave está presente en el contenido de la página

if keyword and keyword.lower() in soup.get_text().lower():
# Obtener el contexto anterior y posterior
context_lines = 10
lines = soup.get_text().split('\n')
for i, line in enumerate(lines):
if keyword.lower() in line.lower():
start_line = max(0, i - context_lines)
end_line = min(len(lines), i + context_lines + 1)
context = '\n'.join(lines[start_line:end_line])
# Guardar los resultados en la base de datos
cursor.execute('INSERT INTO results VALUES (?, ?, ?)', (url,
line.strip(), context.strip()))

# Obtener los enlaces de la página

links = [a.get('href') for a in soup.find_all('a', href=True)]

# Filtrar los enlaces internos y únicos

internal_links = set([link for link in links if link.startswith('/') or
link.startswith(url)])

# Recorrer los enlaces internos y realizar el rastreo recursivo

for link in internal_links:
await crawl_page(link, keyword, session, robot_parser, cursor,
stop_words)
@app.task
def process_results():
conn = sqlite3.connect('results.db')
cursor = conn.cursor()

# Obtener los resultados de la base de datos

cursor.execute('SELECT * FROM results')
results = cursor.fetchall()

# Procesar los resultados

keyword_counts = {}
for result in results:
url, line, context = result
keyword = line.strip().lower()
if keyword in keyword_counts:
keyword_counts[keyword] += 1
else:
keyword_counts[keyword] = 1

# Guardar los resultados en Redis

for keyword, count in keyword_counts.items():
redis_client.set(keyword, count)

# Cerrar la conexión con la base de datos

conn.close()

if __name__ == '__main__':
app.start()
app.worker_main()

# Crear la aplicación de la interfaz de usuario

app = QApplication(sys.argv)
window = MainWindow()
window.show()

# Iniciar el bucle de la aplicación

sys.exit(app.exec_())