Hace poco vi un tuit (o cómo se diga ahora) de Screaming Frog referenciando este artículo de Ana Pérez Botella para automatizar interlinks con un script en Google Colab aprovechando la función de extracción de texto de la rana.
¿El problema? Como estaba exportando grandes cantidades de HTML de cada URL de un blog, la separación por comas rompía el archivo y lo hacía inconsistente. Tras darle bastantes vueltas decidí probar una aproximación diferente que he podido aplicar en mis proyectos.
Cuando son documentos muy pesados y con mucho texto Colab me ha cascado en otras ocasiones antes de terminar la acción. Así que trabajo con PyCharm que podéis descargar desde aquí.
Creamos el Custom JavaScript en Screaming Frog
El primer paso es exportar un CSV que podamos manejar. Para eso, en lugar que el custom extraction usamos la función de Custom JavaScript.
Como comentaba Ana, debemos seleccionar el Xpath del texto a extraer, en este ejemplo usamos: //div[@class=’entry-content clear
El gran problema eran los elementos HTML que rompían el CSV, así que aquí extraemos texto limpio pero manteniendo los enlaces, que necesitaremos para el paso posterior.
Os dejo aquí el código para Screaming Frog:
var content = document.evaluate("//div[@class='entry-content clear']", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
if (content) {
var text = content.innerText; // Extraer texto plano
var links = [...content.querySelectorAll('a')].map(a => a.href); // Extraer enlaces
return seoSpider.data({ text: text, links: links });
} else {
return seoSpider.data({ text: 'No se encontró contenido', links: [] });
}Exportación y columnas
Para el script en PyCharm modificamos un poco el código de Ana. Recuerda instalar las librerías necesarias en la sección de Python Packages.
Para instalar las librerías, abre PyCharm y navega a File > Settings > Project: [tu_proyecto] > Python Interpreter. Desde ahí, instala las librerías que necesitas como pandas, BeautifulSoup4 y scikit-learn (las cuales vamos a usar en el script).
Luego, creamos el script en PyCharm para:
- Leer el CSV exportado de Screaming Frog.
- Limpiar el contenido para que el texto y los enlaces queden bien organizados.
- Generar recomendaciones de interlinks basadas en la similitud semántica entre el contenido de diferentes URLs.
Aquí el código que debes usar en PyCharm:
import pandas as pd
import re
from bs4 import BeautifulSoup
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
# Ruta del archivo CSV original (en la raíz del proyecto)
file_path = 'custom_extraction_full_text.csv'
# Leer el archivo completo línea por línea
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
# Limpiar las líneas eliminando caracteres innecesarios como puntos y comas
cleaned_lines = [line.replace(';', '').strip() for line in lines]
# Filtrar solo las líneas que contienen contenido válido, es decir, que empiezan con {text=
patterns_found = [line for line in cleaned_lines if 'text=' in line]
# Función para extraer el contenido entre '{text=' y '}'
def extract_text_content(line):
match = re.search(r'{text=(.*)', line) # Buscar desde '{text=' hasta el final
return match.group(1) if match else None
# Procesamos cada línea para extraer las URLs y el contenido
processed_data = []
for line in patterns_found:
# Dividimos la línea por comas, capturando la URL y el estado
parts = line.split(',', 3) # Evitar dividir el contenido
if len(parts) == 4:
address = parts[0].strip('"')
status_code = parts[1].strip('"')
content = extract_text_content(parts[3]) # Extraemos el contenido
if content:
processed_data.append([address, status_code, content])
# Convertir los datos procesados en un DataFrame
df_cleaned_content = pd.DataFrame(processed_data, columns=['address', 'status_code', 'content'])
# Función para encontrar oportunidades de interlinking basadas en la similitud de contenido
def find_internal_link_opportunities(df):
contents = df['content'].tolist() # Contenidos
vectorizer = TfidfVectorizer().fit_transform(contents) # Convertir a vectores TF-IDF
vectors = vectorizer.toarray()
csim = cosine_similarity(vectors) # Calcular la similitud de coseno
return csim
# Función para extraer enlaces desde el contenido HTML de la columna 'content'
def extract_links_from_content(text):
soup = BeautifulSoup(text, 'html.parser')
links = [a['href'] for a in soup.find_all('a', href=True)]
return links
# Función para generar oportunidades de interlinking
def generate_interlink_recommendations(df, csim, threshold=0.3): # Umbral reducido a 0.3
recommendations = []
for idx in range(len(df)):
row = df.iloc[idx]
current_links = extract_links_from_content(row['content']) # Enlaces actuales en la página
similar_indices = [i for i, score in enumerate(csim[idx]) if score > threshold and i != idx]
possible_links = []
for i in similar_indices:
candidate_url = df.iloc[i]['address']
if candidate_url not in current_links:
possible_links.append(f"{candidate_url} (Similitud: {csim[idx][i]:.2f})")
if possible_links:
recommendations.append({
'address': row['address'],
'recommended_links': ', '.join(possible_links)
})
return pd.DataFrame(recommendations)
# Calcular similitud y generar interlinks
csim = find_internal_link_opportunities(df_cleaned_content)
df_recommendations = generate_interlink_recommendations(df_cleaned_content, csim)
# Guardar las oportunidades de interlinking en un archivo CSV
output_path = 'interlink_recommendations_final.csv'
df_recommendations.to_csv(output_path, index=False)
print(f"Oportunidades de interlinking guardadas en: {output_path}")
Con este script ejecutado en PyCharm, podrás generar un archivo CSV con recomendaciones de enlaces internos basados en la relación semántica entre el contenido de las diferentes URLs. ¡Así de fácil puedes optimizar el enlazado interno de tu sitio!
Si tienes algún problema con la ejecución, asegúrate de tener bien configurada tu ruta de archivos y haber instalado las librerías necesarias.
