kaupisoft: febrero 2025

En Selenium, puedes localizar elementos usando diferentes estrategias además de By.XPATH. Aquí te dejo las alternativas y cómo obtenerlas en cada caso.

🔹 Alternativas a `By.XPATH` y cómo obtenerlas

Método	Descripción	Ejemplo
`By.ID`	Busca por el atributo `id` del elemento.	`By.ID, "miElemento"`
`By.NAME`	Busca por el atributo `name` del elemento.	`By.NAME, "usuario"`
`By.CLASS_NAME`	Busca por el atributo `class` del elemento.	`By.CLASS_NAME, "boton-login"`
`By.TAG_NAME`	Busca por el tipo de etiqueta HTML.	`By.TAG_NAME, "button"`
`By.LINK_TEXT`	Busca enlaces (`<a>`) por su texto exacto.	`By.LINK_TEXT, "Iniciar sesión"`
`By.PARTIAL_LINK_TEXT`	Busca enlaces por una parte del texto.	`By.PARTIAL_LINK_TEXT, "Iniciar"`
`By.CSS_SELECTOR`	Busca usando selectores CSS.	`By.CSS_SELECTOR, ".clase .subclase"`

✅ Ejemplo con cada alternativa:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Espera hasta que el elemento esté presente usando diferentes métodos
elemento_id = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "miElemento")))
elemento_name = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "usuario")))
elemento_class = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "boton-login")))
elemento_tag = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "button")))
elemento_link = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.LINK_TEXT, "Iniciar sesión")))
elemento_partial_link = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.PARTIAL_LINK_TEXT, "Iniciar")))
elemento_css = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, ".clase .subclase")))

🔹 ¿Cómo obtener estos valores en la web?

Puedes inspeccionar los elementos en el navegador (F12 → "Inspeccionar elemento") y obtenerlos de la siguiente manera:

ID → Busca id="miElemento" en el HTML.
NAME → Busca name="usuario".
CLASS_NAME → Usa .clase si tiene class="boton-login".
TAG_NAME → Usa button, input, div, etc.
LINK_TEXT → Usa el texto visible de un enlace (<a>).
PARTIAL_LINK_TEXT → Usa parte del texto del enlace.
CSS_SELECTOR → Usa selectores CSS como .clase, #id, [atributo="valor"], etc.

🔥 ¿Cuándo usar cada uno?

ID → La mejor opción si el elemento tiene un id único.
NAME → Útil si hay varios elementos con el mismo nombre (ejemplo: formularios).
CLASS_NAME → Bueno si la clase es específica y única.
TAG_NAME → Si buscas todos los elementos de un tipo (button, input).
LINK_TEXT → Si es un enlace (<a>) con texto fijo.
PARTIAL_LINK_TEXT → Si el enlace tiene texto variable.
CSS_SELECTOR → Más rápido que XPath en muchos casos, útil para estructuras complejas.
XPATH → Más flexible para navegar por estructuras complejas.

Si el id o name están disponibles, úsalos en lugar de XPATH para un mejor rendimiento. 🚀

find_element en Selenium no funciona: causas y soluciones

Si el botón existe pero el código no funciona, aquí hay varias razones posibles y soluciones:

1. El botón aún no está disponible en el DOM

Aunque el botón exista, puede que Selenium intente encontrarlo antes de que esté completamente cargado. Prueba usar WebDriverWait:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

elemento = WebDriverWait(self.driver, 10).until(
    EC.presence_of_element_located((By.XPATH, xpath_boton_login))
)

🔹 Esto espera hasta 10 segundos a que el botón aparezca en el DOM antes de continuar.

2. El botón no es interactuable

Puede que el botón esté en el DOM, pero todavía no sea clickeable. Usa element_to_be_clickable:

elemento = WebDriverWait(self.driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, xpath_boton_login))
)

🔹 Esto espera a que el botón sea interactuable antes de seleccionarlo.

3. Hay un iframe que lo bloquea

Si el botón está dentro de un iframe, necesitas cambiar el foco:

self.driver.switch_to.frame("id_del_iframe")
elemento = self.driver.find_element(By.XPATH, xpath_boton_login)
self.driver.switch_to.default_content()  # Volver al contexto principal si es necesario

4. El botón está oculto por otro elemento

Si el botón está en el DOM pero no visible, prueba hacer scroll hasta él:

from selenium.webdriver.common.action_chains import ActionChains

elemento = self.driver.find_element(By.XPATH, xpath_boton_login)
self.driver.execute_script("arguments[0].scrollIntoView();", elemento)

🔹 Esto lo lleva a la vista antes de intentar interactuar con él.

5. Hay múltiples elementos con el mismo XPath

Si xpath_boton_login selecciona varios elementos, find_element podría estar encontrando el incorrecto. Prueba find_elements:

elementos = self.driver.find_elements(By.XPATH, xpath_boton_login)
if elementos:
    elemento = elementos[0]  # Seleccionar el primero

presence_of_element_located

Para hacer que el programa espere hasta que el elemento esté presente en el DOM antes de continuar, usa WebDriverWait con presence_of_element_located.

✅ Código para esperar hasta que el elemento esté presente:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Esperar hasta que el elemento esté presente en el DOM (máximo 10 segundos)
elemento = WebDriverWait(self.driver, 10).until(
    EC.presence_of_element_located((By.XPATH, xpath_boton_login))
)

🔹 Explicación:

WebDriverWait(self.driver, 10): Espera hasta 10 segundos antes de lanzar una excepción.
until(EC.presence_of_element_located((By.XPATH, xpath_boton_login))):
- Verifica que el elemento esté en el DOM, pero no necesariamente visible o interactuable.

Si también necesitas que el botón sea clickeable antes de continuar, usa element_to_be_clickable en lugar de presence_of_element_located.

✅ Código para esperar hasta que sea clickeable:

elemento = WebDriverWait(self.driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, xpath_boton_login))
)

Este código espera que el botón esté en el DOM y listo para ser presionado.

Si el tiempo de espera se agota sin encontrar el elemento, lanzará un TimeoutException.

Cómo descargar videos de Facebook utilizando el inspector de código en Google Chrome

Cómo descargar videos de Facebook utilizando el inspector de código en Google Chrome

Accede al video en Facebook: Inicia sesión en tu cuenta de Facebook y navega hasta la publicación que contiene el video que deseas descargar.
Abre las herramientas de desarrollador: Haz clic derecho en cualquier parte de la página (preferiblemente sobre el video) y selecciona "Inspeccionar" en el menú desplegable. Alternativamente, puedes presionar Ctrl + Shift + I en Windows o Cmd + Option + I en Mac para abrir las herramientas de desarrollador.
Ve a la pestaña "Red": En la ventana de herramientas de desarrollador que se abre, selecciona la pestaña "Red" o "Network".
Filtra por contenido multimedia: Dentro de la pestaña "Red", encontrarás una opción para filtrar los tipos de archivos. Haz clic en "Medios" o "Media" para mostrar únicamente los archivos multimedia que se cargan en la página.
Reproduce el video: Vuelve a la página de Facebook y reproduce el video que deseas descargar. Mientras el video se reproduce, la pestaña "Red" comenzará a llenarse con diferentes archivos que se están cargando.
Identifica el archivo de video: Busca en la lista de archivos un elemento que tenga una extensión de video común, como .mp4. Este archivo suele ser el video que se está reproduciendo.
Copia la URL del video: Haz clic derecho en el archivo identificado y selecciona "Copiar URL" o "Copy URL".
Abre el video en una nueva pestaña: Abre una nueva pestaña en tu navegador, pega la URL copiada en la barra de direcciones y presiona Enter. El video debería cargarse y reproducirse en esta nueva pestaña.
Descarga el video: Haz clic derecho sobre el video en la nueva pestaña y selecciona "Guardar video como..." o "Save video as...". Elige la ubicación en tu computadora donde deseas guardar el archivo y confirma la descarga.
Puedes probar quitando "&bytestart=466691&byteend=581710" al final de la URL y pegandolo en una nueva pestaña.

01100110 01101001 01101110 00100000 01100100 01100101 00100000 01100011 01101111 01100100 01101001 01100111 01101111

RETURN

Crear el entorno virtual

Sí, es recomendable crear un entorno virtual para tu proyecto de Python antes de empaquetarlo. Esto te permite aislar las dependencias y asegurarte de que el ejecutable no tenga problemas al ejecutarse en otras computadoras.

1️⃣ Crear el entorno virtual

Ejecuta el siguiente comando en la terminal (CMD o PowerShell) dentro de la carpeta de tu proyecto:

python -m venv venv

py -3.8 -m venv venv (para python 3.8)

Esto creará una carpeta llamada venv que contendrá el entorno virtual.

2️⃣ Activar el entorno virtual

En Windows (CMD)

venv\Scripts\activate

En PowerShell

venv\Scripts\Activate.ps1

Si te da un error de permisos en PowerShell, prueba con:

Set-ExecutionPolicy Unrestricted -Scope Process

3️⃣ Instalar las dependencias

Ahora instala las librerías que usa tu programa. Por ejemplo:

pip install pyinstaller
pip install pyqt5

Si tienes un archivo requirements.txt con las dependencias, usa:

pip install -r requirements.txt

4️⃣ Empaquetar con PyInstaller

Una vez que tu entorno virtual está listo y tiene las dependencias, puedes crear el ejecutable con:

pyinstaller --noconsole --onefile --add-data "carpeta_datos;carpeta_datos" script.py

Esto generará un ejecutable en la carpeta dist/.

5️⃣ Desactivar el entorno virtual (opcional)

Si ya terminaste, puedes desactivar el entorno con:

deactivate

📌 ¿Por qué usar un entorno virtual?

✅ Asegura que tu programa use las versiones correctas de las librerías.
✅ Evita conflictos con otras instalaciones de Python en la PC.
✅ Permite empaquetar el ejecutable con PyInstaller sin problemas.

01100110 01101001 01101110 00100000 01100100 01100101 00100000 01100011 01101111 01100100 01101001 01100111 01101111

RETURN

Crear un instalador con Inno Script Studio (varios archivos)

Si tu programa depende de varios archivos, entonces lo mejor es crear un instalador con Inno Script Studio. Aquí te dejo los pasos detallados para lograrlo:

1️⃣ Generar los archivos ejecutables con PyInstaller

Antes de usar Inno Script Studio, debes convertir tu script de Python en un ejecutable.

🔹 Ejecuta este comando en la terminal (CMD o PowerShell) en la carpeta de tu script:

pyinstaller --noconsole --onefile --add-data "carpeta_datos;carpeta_datos" script.py

🔹 Explicación de las opciones:

--noconsole → Oculta la consola (ideal para programas con interfaz gráfica).
--onefile → Empaqueta todo en un solo .exe.
--add-data → Incluye archivos adicionales como imágenes, bases de datos, etc.

📌 Salida esperada:
Se creará una carpeta llamada dist/ donde estará tu ejecutable (script.exe).

2️⃣ Preparar la carpeta para el instalador

Crea una carpeta llamada Instalador y dentro coloca:
✅ El ejecutable (script.exe) de la carpeta dist/.
✅ Otras carpetas con archivos que necesite tu programa (imágenes, bases de datos, etc.).

📁 Estructura recomendada:

Instalador/
│── script.exe
│── datos/       # Carpeta con datos adicionales
│── config/      # Archivos de configuración
│── README.txt   # Instrucciones opcionales

3️⃣ Configurar Inno Script Studio

Ahora que tienes listos los archivos, abre Inno Script Studio y sigue estos pasos:

1. Crear un nuevo script

Abre Inno Script Studio y selecciona "Nuevo Proyecto".
Define el nombre de tu aplicación, versión, empresa y el nombre del instalador (setup.exe).

2. Agregar archivos al instalador

Ve a la pestaña "Files" y haz clic en "Add Files".
Selecciona script.exe y otros archivos/carpetas necesarias.
Asegúrate de que la ruta de instalación sea algo como:
```
{app}\MiPrograma
```

3. Configurar accesos directos

Ve a "Icons" → Agrega un acceso directo en el escritorio y en el menú inicio.
Define que el acceso directo apunte a {app}\MiPrograma\script.exe.

4. Configurar desinstalador

Ve a la pestaña "Uninstall" y marca la opción para agregar una entrada en "Agregar o quitar programas" de Windows.

5. Compilar el instalador

Presiona "Build" para generar el setup.exe.
El archivo de instalación estará en la carpeta de salida (Output).

4️⃣ Probar el instalador

🔹 Ejecuta setup.exe en una PC de prueba y verifica que:
✅ Se copien todos los archivos a C:\Program Files\MiPrograma.
✅ Se creen los accesos directos en el menú de inicio y escritorio.
✅ El programa se abra correctamente.
✅ Se pueda desinstalar desde "Agregar o quitar programas".

01100110 01101001 01101110 00100000 01100100 01100101 00100000 01100011 01101111 01100100 01101001 01100111 01101111

RETURN

Crear un instalador con Inno Script Studio

Cuando creas un instalador con Inno Script Studio, hay dos enfoques principales para distribuir tu programa en Windows:

Un solo ejecutable (.exe) portable
Un instalador que coloca varios archivos en el sistema

Cuándo usar solo un ejecutable (`.exe` portable)

Usar un solo .exe es útil cuando:
✅ Tu aplicación es sencilla y no requiere instalación.
✅ No depende de archivos externos (como librerías DLL, imágenes, configuraciones, bases de datos externas).
✅ No necesita accesos directos en el menú de inicio o en el escritorio.
✅ Quieres que el usuario pueda ejecutarlo sin permisos de administrador.

Ejemplo: Una calculadora simple hecha en Python que solo usa tkinter.

📌 Herramientas para crear un ejecutable portable:

pyinstaller --onefile script.py
auto-py-to-exe (interfaz gráfica de PyInstaller)

Cuándo usar un instalador (`setup.exe` con Inno Script Studio)

Debes usar un instalador cuando:
✅ Tu aplicación tiene múltiples archivos (DLLs, imágenes, bases de datos, configuraciones).
✅ Requiere dependencias específicas (como Python, librerías de terceros).
✅ Quieres que el usuario lo instale en C:\Program Files con accesos directos.
✅ Necesitas modificar el registro de Windows o crear servicios.

Ejemplo: Un programa que usa SQLite para guardar datos y necesita librerías externas como PyQt5.

📌 Proceso con Inno Script Studio:

Usa pyinstaller --noconsole --add-data "carpeta_datos;carpeta_datos" script.py
Empaqueta los archivos generados en un instalador con Inno Script Studio.
Configura accesos directos, desinstalador y permisos de instalación.

¿Cuál opción elegir?

Si tu programa es simple y autónomo, usa un solo .exe portable.
Si tu programa depende de varios archivos, usa un instalador con Inno Script Studio. (ir aca)

01100110 01101001 01101110 00100000 01100100 01100101 00100000 01100011 01101111 01100100 01101001 01100111 01101111

RETURN

🔹 Alternativas a By.XPATH y cómo obtenerlas

✅ Ejemplo con cada alternativa:

🔹 ¿Cómo obtener estos valores en la web?

🔥 ¿Cuándo usar cada uno?

1. El botón aún no está disponible en el DOM

2. El botón no es interactuable

3. Hay un iframe que lo bloquea

4. El botón está oculto por otro elemento

5. Hay múltiples elementos con el mismo XPath

presence_of_element_located

✅ Código para esperar hasta que el elemento esté presente:

🔹 Explicación:

✅ Código para esperar hasta que sea clickeable:

1️⃣ Crear el entorno virtual

2️⃣ Activar el entorno virtual

En Windows (CMD)

En PowerShell

3️⃣ Instalar las dependencias

4️⃣ Empaquetar con PyInstaller

5️⃣ Desactivar el entorno virtual (opcional)

📌 ¿Por qué usar un entorno virtual?

1️⃣ Generar los archivos ejecutables con PyInstaller

2️⃣ Preparar la carpeta para el instalador

3️⃣ Configurar Inno Script Studio

1. Crear un nuevo script

2. Agregar archivos al instalador

3. Configurar accesos directos

4. Configurar desinstalador

5. Compilar el instalador

4️⃣ Probar el instalador

Cuándo usar solo un ejecutable (.exe portable)

Cuándo usar un instalador (setup.exe con Inno Script Studio)

¿Cuál opción elegir?

🔹 Alternativas a `By.XPATH` y cómo obtenerlas

Cuándo usar solo un ejecutable (`.exe` portable)

Cuándo usar un instalador (`setup.exe` con Inno Script Studio)