AutOmatizacionEs
Esta colección de scripts y herramientas de automatización es una iniciativa en desarrollo para automatizar procesos en diversas etapas del diseño y desarrollo web. Cada script ha sido creado combinando el uso de ChatGPT, Python y Google Colab
Prompt engineering
IA
Automatización
Desarrollo web
Diseño UX/UI
Diseño de producto
1. Procesador de imágenes en lote
Este script capaz de procesar cientos de archivos en segundos, es ideal para estandarizar imágenes en lote de manera automatizada en proyectos donde se requieren especificaciones uniformes, como en catálogos de productos, galerías web o bases de datos visuales.
Funcionamiento
El script procesa imágenes en una carpeta de entrada en Google Drive (input) para ajustarlas a un formato cuadrado (1:1) con fondo blanco, cumpliendo especificaciones de tamaño y peso. Luego, guarda las imágenes procesadas en una carpeta de salida (output) y verifica que todas las imágenes hayan sido convertidas correctamente.
- Preparación:
- Monta Google Drive en Google Colab.
- Define las carpetas de entrada (
input_folder) y salida (output_folder). - Configura parámetros clave:
- Dimensiones máximas: 1500×1500 píxeles.
- Tamaño máximo: 300 KB.
- Calidad mínima: 50.
- Procesamiento de Imágenes:
- Convierte todas las imágenes al formato .jpg.
- Redimensiona las imágenes para encajar dentro de un lienzo cuadrado de 1500×1500 píxeles:
- Las imágenes se centran en un lienzo blanco sin deformarlas.
- Ajusta la calidad de las imágenes para cumplir con el límite de peso (300 KB).
- Verificación:
- Compara los archivos en la carpeta de entrada (
input) con los procesados en la salida (output). - Muestra un resumen indicando si todos los archivos se procesaron correctamente:
- Si faltan archivos, lista los nombres de los archivos que no fueron procesados.
- Compara los archivos en la carpeta de entrada (
Código
import os
from PIL import Image, ImageFile
from google.colab import drive
# Permitir la carga de archivos grandes
ImageFile.LOAD_TRUNCATED_IMAGES = True
Image.MAX_IMAGE_PIXELS = None
# Montar Google Drive
drive.mount('/content/drive')
# Rutas de las carpetas
input_folder = '/content/drive/My Drive/fotos_para_procesar/input'
output_folder = '/content/drive/My Drive/fotos_para_procesar/output'
# Crear carpeta de salida si no existe
os.makedirs(output_folder, exist_ok=True)
# Parámetros
output_size = (1500, 1500) # Tamaño final de la imagen
max_file_size_kb = 300 # Tamaño máximo en KB
min_quality = 50 # Calidad mínima
def process_image_to_square(image_path, output_path):
"""Procesa una imagen para ajustarla a un formato 1:1 con fondo blanco."""
with Image.open(image_path) as img:
# Convertir a RGB si no lo es
if img.mode != 'RGB':
img = img.convert('RGB')
# Crear lienzo blanco cuadrado
square_image = Image.new("RGB", output_size, (255, 255, 255))
img.thumbnail(output_size, Image.Resampling.LANCZOS)
# Calcular la posición para centrar la imagen en el lienzo
offset_x = (output_size[0] - img.size[0]) // 2
offset_y = (output_size[1] - img.size[1]) // 2
square_image.paste(img, (offset_x, offset_y))
# Guardar la imagen con compresión ajustando la calidad
quality = 95
while True:
square_image.save(output_path, "JPEG", quality=quality)
if os.path.getsize(output_path) / 1024 <= max_file_size_kb:
break
quality -= 5
if quality < min_quality:
break # Evitar calidad muy baja
# Procesar todas las imágenes en la carpeta de entrada
for filename in os.listdir(input_folder):
if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')):
input_path = os.path.join(input_folder, filename)
output_filename = os.path.splitext(filename)[0] + '.jpg'
output_path = os.path.join(output_folder, output_filename)
# Procesar la imagen
process_image_to_square(input_path, output_path)
# Verificar la correspondencia de archivos entre input y output
input_files = set(f for f in os.listdir(input_folder) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')))
output_files = set(os.path.splitext(f)[0] + '.jpg' for f in os.listdir(output_folder) if f.lower().endswith('.jpg'))
# Comparación de nombres
missing_files = input_files - output_files
print("\n--- Comparación de Archivos ---")
print(f"Archivos en input: {len(input_files)}")
print(f"Archivos en output: {len(output_files)}")
if not missing_files:
print("¡Todos los archivos fueron convertidos correctamente!")
else:
print("Los siguientes archivos no fueron procesados:")
for file in missing_files:
print(f"- {file}")
2. Benchmark web (MVP en proceso)
Este script de benchmarking de competidores está diseñado para analizar rápidamente una lista de sitios web y generar un reporte básico que permita evaluar la estructura y el contenido de cada página. Su enfoque principal es proporcionar información clave sobre cómo están organizados y presentados los contenidos en los sitios web de competidores.
Este MVP es la base para un análisis más profundo, escalable y personalizado con inteligencia artificial y filtros avanzados.
Funcionamiento
El código toma una lista de URLs de competidores y analiza cada una para extraer información clave sobre su contenido y estructura. Utiliza la librería (requests) para obtener el HTML de cada página y (BeautifulSoup) para procesar ese HTML, extrayendo texto visible (de etiquetas <p>) y encabezados (<h1>, <h2>, <h3>). Posteriormente, analiza las palabras más frecuentes en el texto utilizando collections.Counter para identificar los temas predominantes. Finalmente, compila toda esta información en un archivo CSV que incluye la URL, los encabezados detectados y las palabras clave más repetidas, proporcionando un reporte básico para comparar y evaluar a los competidores.
- Preparación y configuración:
- Carga el modelo de procesamiento de lenguaje natural (NLP) de
spaCypara inglés (en_core_web_sm) y español (es_core_news_sm). - Importa las bibliotecas necesarias para realizar peticiones HTTP (
requests), analizar HTML (BeautifulSoup), contar palabras (Counter), y manejar URLs (urllib.parse). - Define una lista explícita de stopwords personalizadas (
stop_words_manual), que contiene palabras comunes que deben ser excluidas del análisis de texto (como artículos, preposiciones y pronombres).
- Carga el modelo de procesamiento de lenguaje natural (NLP) de
- Función
fetch_html(url):- Realiza una petición HTTP a una URL utilizando la librería
requestscon un encabezado de usuario (User-Agent) para simular una solicitud de navegador. - Si la respuesta es exitosa (código 200), devuelve el contenido HTML de la página. Si no, imprime un error y retorna
None.
- Realiza una petición HTTP a una URL utilizando la librería
- Función
analyze_structure(html):- Analiza la estructura del HTML utilizando
BeautifulSoup. - Extrae los encabezados (
h1,h2,h3) y cuenta la cantidad de cada tipo de encabezado, además de crear una lista numerada de los encabezados encontrados. - Retorna un diccionario con los encabezados y su cantidad.
- Analiza la estructura del HTML utilizando
- Función
analyze_seo(html):- Extrae el título de la página (
<title>) y la descripción meta (<meta name="description">). - Retorna un diccionario con el título y la meta descripción de la página, que son elementos clave para el SEO.
- Extrae el título de la página (
- Función
analyze_multimedia(html):- Busca las etiquetas
<img>y<video>dentro del HTML para contar cuántas imágenes y videos existen en la página. - También cuenta cuántas imágenes tienen un atributo
alt(texto alternativo) asociado. - Retorna un diccionario con la cantidad total de imágenes, videos y las imágenes que tienen texto alternativo.
- Busca las etiquetas
- Función
analyze_links(html, base_url):- Busca todos los enlaces (
<a href="...">) en la página y construye URLs absolutas utilizandourljoinpara asegurar que los enlaces internos estén bien formados. - Filtra y devuelve solo los enlaces internos, evitando los enlaces duplicados.
- Retorna un diccionario con el número total de enlaces internos y una lista de esos enlaces.
- Busca todos los enlaces (
- Función
analyze_content(html):- Extrae el texto de la página utilizando
BeautifulSoup. - Procesa el texto con el modelo de
spaCypara realizar el análisis lingüístico. - Filtra las palabras funcionales (stopwords, puntuación, y palabras no alfabéticas) utilizando tanto las stopwords de
spaCycomo las personalizadas. - Calcula las frecuencias de las palabras restantes y retorna los 10 términos más frecuentes, junto con el conteo total de palabras.
- Extrae el texto de la página utilizando
- Función
analyze_url(url):- Llama a las funciones anteriores para analizar una URL dada y obtener datos sobre la estructura, SEO, multimedia, enlaces y contenido.
- Retorna un diccionario con la información extraída de la página.
- Función
generate_report(urls):- Itera sobre una lista de URLs, analiza cada una y agrega los resultados al reporte.
- Guarda los resultados del análisis en un archivo JSON (
benchmark_report.json).
- Función
main():- Define una lista de URLs para analizar (en este caso, solo una URL de ejemplo:
https://www.marca.com/). - Llama a
generate_report(urls)para generar el reporte. - Al finalizar, imprime el contenido del archivo JSON con el reporte.
- Define una lista de URLs para analizar (en este caso, solo una URL de ejemplo:
- Impresión del reporte:
- Después de generar el reporte, se lee el archivo JSON y se imprime de manera formateada en la consola.
Código
!python -m spacy download es_core_news_sm
import requests
from bs4 import BeautifulSoup
from collections import Counter
import json
import re
from urllib.parse import urljoin
import spacy
# Load the spaCy English model
nlp = spacy.load("en_core_web_sm")
# Load the spaCy Spanish model
nlp_es = spacy.load("es_core_news_sm")
# Function to fetch the HTML content of a page
def fetch_html(url):
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
return response.text
else:
print(f"Failed to fetch {url}: {response.status_code}")
return None
# Function to get total count and enumerated headings for h1, h2, and h3 tags
def analyze_structure(html):
soup = BeautifulSoup(html, 'html.parser')
headings = {}
for tag in ["h1", "h2", "h3"]:
elements = soup.find_all(tag)
headings[tag] = {
"total_count": len(elements),
"headings_list": [{"text": element.text, "index": index + 1} for index, element in enumerate(elements)]
}
return {"headings": headings}
# Function to analyze basic SEO
def analyze_seo(html):
soup = BeautifulSoup(html, 'html.parser')
title = soup.find('title').text if soup.find('title') else None
meta_description = soup.find('meta', attrs={'name': 'description'})
meta_description_content = meta_description['content'] if meta_description and 'content' in meta_description.attrs else None
return {"title": title, "meta_description": meta_description_content}
'''
# Function to analyze main CTAs
def analyze_ctas(html):
soup = BeautifulSoup(html, 'html.parser')
ctas = []
for tag in soup.find_all(['a', 'button']):
text = tag.text.strip()
if text and any(keyword in text.lower() for keyword in ["comprar ahora", "más información", "buy now", "learn more"]): # Keywords for CTAs
ctas.append({"text": text, "location": tag.name}) # Add location (a or button)
return {"ctas": ctas}
'''
# Function to analyze multimedia usage
def analyze_multimedia(html):
soup = BeautifulSoup(html, 'html.parser')
images = soup.find_all("img")
videos = soup.find_all("video")
images_with_alt = len([img for img in images if img.get("alt")])
return {"images_count": len(images), "videos_count": len(videos), "images_with_alt": images_with_alt}
# Function to analyze links and pages
def analyze_links(html, base_url):
soup = BeautifulSoup(html, 'html.parser')
links = []
for a_tag in soup.find_all('a', href=True):
absolute_url = urljoin(base_url, a_tag['href'])
if absolute_url.startswith(base_url) and absolute_url not in links: # Only internal and unique links
links.append(absolute_url)
return {"total_links": len(links), "links_list": links}
# Explicit list of custom stopwords
stop_words_manual = set([
'el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas', 'del', 'de la', 'a la', 'al', 'yo', 'tú', 'él',
'ella', 'nosotros', 'nosotras', 'vosotros', 'vosotras', 'ellos', 'ellas', 'me', 'te', 'lo', 'la', 'le',
'nos', 'os', 'les', 'se', 'mi', 'tu', 'su', 'nuestro', 'vuestra', 'estas', 'esas', 'aquellas', 'quien',
'quienes', 'a', 'ante', 'bajo', 'con', 'contra', 'de', 'desde', 'en', 'entre', 'hacia', 'hasta', 'para',
'por', 'según', 'sin', 'sobre', 'tras', 'durante', 'a través de', 'en frente de', 'y', 'o', 'pero', 'sino',
'aunque', 'porque', 'pues', 'ni', 'cuando', 'como', 'que', 'si', 'además', 'ya que', 'entonces', 'mientras',
'para que', 'muy', 'bien', 'mal', 'tanto', 'poco', 'mucho', 'más', 'menos', 'ya', 'aquí', 'allí', 'ahora',
'entonces', 'nunca', 'siempre', 'casi', 'todo', 'algo', 'ser', 'estar', 'haber', 'tener', 'hacer', 'poder',
'deber', 'venir', 'ir', 'lo', 'la', 'las', 'los', 'esto', 'eso', 'aquello', 'cuál', 'quien', 'cuya', 'cuyas',
'todos', 'todas', 'alguno', 'alguna', 'algunos', 'algunas', 'sus', 'está', 'están', 'es'
])
# Function to analyze content and extract key concepts
def analyze_content(html):
soup = BeautifulSoup(html, 'html.parser')
text = soup.get_text()
# Detect language
try:
language = detect(text)
except:
language = 'es' # Default to Spanish if detection fails
# Choose the appropriate spaCy model
nlp = nlp_es if language == 'es' else nlp_en
# Process the text with spaCy
doc = nlp(text)
# Filter out stop words, punctuation, and functional words
filtered_words = [
token.text.lower() for token in doc
if token.is_alpha and not token.is_stop and token.text.lower() not in stop_words_manual
]
# Calculate keyword frequencies
keyword_counts = Counter(filtered_words)
# Get top 10 most frequent keywords
top_keywords = keyword_counts.most_common(10)
return {"word_count": len(doc), "top_keywords": top_keywords}
# Function to analyze a single URL (modified)
def analyze_url(url):
html = fetch_html(url)
if not html:
return None
structure = analyze_structure(html)
seo = analyze_seo(html)
#ctas = analyze_ctas(html)
multimedia = analyze_multimedia(html)
readability = analyze_content(html) # Call the modified analyze_content function
links = analyze_links(html, url) # Analyze links and pages
return {
"url": url,
"structure": structure,
"seo": seo,
#"ctas": ctas,
"multimedia": multimedia,
"readability": readability, # Updated readability section
"links": links # Added links section
}
# Function to analyze multiple URLs and generate a report
def generate_report(urls):
report = []
for url in urls:
print(f"Analyzing {url}...")
result = analyze_url(url)
if result:
report.append(result)
# Save report to JSON
with open("benchmark_report.json", "w", encoding="utf-8") as f:
json.dump(report, f, ensure_ascii=False, indent=4)
print("Report generated: benchmark_report.json")
# Main function to execute the script
def main():
urls = [
"https://www.marca.com/"
] # Replace with your list of URLs
generate_report(urls)
if __name__ == "__main__":
main()
# Main function to execute the script
def main():
urls = [
"https://www.marca.com/"
] # Replace with your list of URLs
generate_report(urls)
if __name__ == "__main__":
main()
with open('benchmark_report.json', 'r', encoding='utf-8') as f:
data = json.load(f)
# Imprime el contenido formateado:
print(json.dumps(data, indent=4, ensure_ascii=False))
próximos pasos
- Análisis más detallado y profundo:
- Análisis de rendimiento: Medir tiempos de carga de páginas y tiempos de respuesta para generar reportes sobre el rendimiento del sitio web.
- SEO más avanzado: Ampliar el análisis de SEO, como la estructura de las URLs, el uso de palabras clave, la velocidad de carga, los enlaces rotos y la accesibilidad web.
- Análisis de accesibilidad: Integrar herramientas que revisen aspectos generales de accesibilidad en los sitios web, como el contraste de colores, el uso de texto alternativo en imágenes, etc.
- Escalabilidad en la recolección de datos:
- Batch processing: Implementar la capacidad de analizar múltiples URLs de manera simultánea o en lotes para poder manejar un mayor volumen de páginas y sitios web.
- Base de datos para almacenamiento: Usar una base de datos para almacenar resultados de análisis y permitir consultas e informes más flexibles a medida que se acumulan más datos.
- Interfaz de usuario (UI/UX) y reporte mejorado:
- Dashboard visual: Desarrollar una interfaz donde los usuarios puedan cargar URLs, ver los resultados de los análisis en tiempo real y generar informes visuales.
- Generación automática de informes: Ampliar la funcionalidad de los informes generados (en formato PDF, HTML o Excel) para incluir gráficos y análisis detallados.