Cliente IMAP de Python: Una Guía Completa para la Recuperación de Correo Electrónico y la Gestión de Buzones

El correo electrónico sigue siendo una piedra angular de la comunicación digital para empresas e individuos en todo el mundo. Sin embargo, la gestión de un alto volumen de correos electrónicos puede ser una tarea repetitiva y que consume mucho tiempo. Desde el procesamiento de facturas y el filtrado de notificaciones hasta el archivo de conversaciones importantes, el esfuerzo manual puede volverse rápidamente abrumador. Aquí es donde brilla la automatización programática, y Python, con su rica biblioteca estándar, proporciona herramientas poderosas para tomar el control de su bandeja de entrada.

Esta guía completa lo guiará a través del proceso de creación de un cliente IMAP de Python desde cero utilizando la biblioteca integrada imaplib. Aprenderá no solo cómo recuperar correos electrónicos, sino también cómo analizar su contenido, descargar archivos adjuntos y administrar su buzón marcando mensajes como leídos, moviéndolos o eliminándolos. Al final de este artículo, estará equipado para automatizar sus tareas de correo electrónico más tediosas, ahorrándole tiempo y aumentando su productividad.

Comprendiendo los Protocolos: IMAP vs. POP3 vs. SMTP

Antes de sumergirse en el código, es esencial comprender los protocolos fundamentales que rigen el correo electrónico. A menudo escuchará tres acrónimos: SMTP, POP3 e IMAP. Cada uno tiene un propósito distinto.

• SMTP (Protocolo Simple de Transferencia de Correo): Este es el protocolo para enviar correo electrónico. Piense en SMTP como el servicio postal que recoge su carta y la entrega al servidor de buzón del destinatario. Cuando su script de Python envía un correo electrónico, está utilizando SMTP.
• POP3 (Protocolo de Oficina de Correos 3): Este es un protocolo para recuperar correo electrónico. POP3 está diseñado para conectarse a un servidor, descargar todos los mensajes nuevos a su cliente local y luego, de forma predeterminada, eliminarlos del servidor. Es como ir a la oficina de correos, recoger todo su correo y llevarlo a casa; una vez que está en su casa, ya no está en la oficina de correos. Este modelo es menos común hoy en día debido a sus limitaciones en un mundo de múltiples dispositivos.
• IMAP (Protocolo de Acceso a Mensajes de Internet): Este es el protocolo moderno para acceder y administrar correo electrónico. A diferencia de POP3, IMAP deja los mensajes en el servidor y sincroniza el estado (leído, no leído, marcado, eliminado) en todos los clientes conectados. Cuando lee un correo electrónico en su teléfono, aparece como leído en su computadora portátil. Este modelo centrado en el servidor es perfecto para la automatización porque su script puede interactuar con el buzón como otro cliente, y los cambios que realice se reflejarán en todas partes. Para esta guía, nos centraremos exclusivamente en IMAP.

Comenzando con imaplib de Python

La biblioteca estándar de Python incluye imaplib, un módulo que proporciona todas las herramientas necesarias para comunicarse con un servidor IMAP. No se requieren paquetes externos para comenzar.

Prerrequisitos

1. Python Instalado: Asegúrese de tener una versión reciente de Python (3.6 o más reciente) instalada en su sistema.
2. Una Cuenta de Correo Electrónico con IMAP Habilitado: La mayoría de los proveedores de correo electrónico modernos (Gmail, Outlook, Yahoo, etc.) admiten IMAP. Es posible que deba habilitarlo en la configuración de su cuenta.

La Seguridad Primero: Use Contraseñas de Aplicación, No Su Contraseña Principal

Este es el paso más crítico para la seguridad. No codifique de forma rígida la contraseña de su cuenta de correo electrónico principal en su script. Si su código se ve comprometido, toda su cuenta está en riesgo. La mayoría de los principales proveedores de correo electrónico que utilizan la autenticación de dos factores (2FA) requieren que genere una "Contraseña de Aplicación".

Una Contraseña de Aplicación es un código de acceso único de 16 dígitos que le da a una aplicación específica permiso para acceder a su cuenta sin necesidad de su contraseña principal o códigos 2FA. Puede generar uno y revocarlo en cualquier momento sin afectar su contraseña principal.

• Para Gmail: Vaya a la configuración de su Cuenta de Google -> Seguridad -> Verificación en dos pasos -> Contraseñas de aplicaciones.
• Para Outlook/Microsoft: Vaya al panel de seguridad de su Cuenta de Microsoft -> Opciones de seguridad avanzadas -> Contraseñas de aplicaciones.
• Para otros proveedores: Busque en su documentación "contraseña de aplicación" o "contraseña específica de la aplicación".

Una vez generada, trate esta Contraseña de Aplicación como cualquier otra credencial. Una buena práctica es almacenarla en una variable de entorno o en un sistema seguro de administración de secretos en lugar de directamente en su código fuente.

La Conexión Básica

Escribamos nuestro primer fragmento de código para establecer una conexión segura a un servidor IMAP, iniciar sesión y luego cerrar sesión con elegancia. Usaremos imaplib.IMAP4_SSL para asegurar que nuestra conexión esté encriptada.

            
import imaplib
import os

# --- Credenciales ---
# Es mejor cargar estas desde variables de entorno o un archivo de configuración
# Para este ejemplo, las definiremos aquí. Reemplace con sus detalles.
EMAIL_ACCOUNT = "your_email@example.com"
APP_PASSWORD = "your_16_digit_app_password"
IMAP_SERVER = "imap.example.com" # e.g., "imap.gmail.com"

# --- Conectar al servidor IMAP ---
# Usamos un bloque try...finally para asegurar que cerremos sesión con elegancia
conn = None
try:
    # Conectar usando SSL para una conexión segura
    conn = imaplib.IMAP4_SSL(IMAP_SERVER)
    
    # Iniciar sesión en la cuenta
    status, messages = conn.login(EMAIL_ACCOUNT, APP_PASSWORD)
    
    if status == 'OK':
        print("¡Sesión iniciada con éxito!")
        # Agregaremos más lógica aquí más adelante
    else:
        print(f"Error al iniciar sesión: {messages}")

finally:
    if conn:
        # Siempre cerrar sesión y cerrar la conexión
        conn.logout()
        print("Sesión cerrada y conexión cerrada.")

            

              
                Copy
              
            
          

Este script establece una base. El bloque try...finally es crucial porque garantiza que se llame a conn.logout(), cerrando la sesión con el servidor, incluso si ocurre un error durante nuestras operaciones.

Navegando Por Su Buzón

Una vez que haya iniciado sesión, puede comenzar a interactuar con los buzones (a menudo llamados carpetas) en su cuenta.

Listando Todos Los Buzones

Para ver qué buzones están disponibles, puede usar el método conn.list(). La salida puede ser un poco desordenada, por lo que se requiere un poco de análisis para obtener una lista limpia de nombres.

            
# Dentro del bloque 'try' después de un inicio de sesión exitoso:

status, mailbox_list = conn.list()
if status == 'OK':
    print("Buzones Disponibles:")
    for mailbox in mailbox_list:
        # La entrada del buzón sin formato es una cadena de bytes que necesita ser decodificada
        # A menudo tiene el formato: (\HasNoChildren) "/" "INBOX"
        # Podemos hacer un análisis básico para limpiarlo
        parts = mailbox.decode().split(' "/" ')
        if len(parts) == 2:
            mailbox_name = parts[1].strip('"')
            print(f"- {mailbox_name}")

            

              
                Copy
              
            
          

Esto imprimirá una lista como 'INBOX', 'Enviados', '[Gmail]/Spam', etc., dependiendo de su proveedor de correo electrónico.

Seleccionando Un Buzón

Antes de que pueda buscar o obtener correos electrónicos, debe seleccionar un buzón con el que trabajar. La opción más común es 'INBOX'. El método conn.select() activa un buzón. También puede abrirlo en modo de solo lectura si no tiene la intención de realizar cambios (como marcar los correos electrónicos como leídos).

            
# Seleccione la 'INBOX' para trabajar.
# Use readonly=True si no quiere cambiar las banderas del correo electrónico (p. ej., de UNSEEN a SEEN)
status, messages = conn.select('INBOX', readonly=False)

if status == 'OK':
    total_messages = int(messages[0])
    print(f"INBOX seleccionado. Mensajes totales: {total_messages}")
else:
    print(f"Error al seleccionar INBOX: {messages}")

            

              
                Copy
              
            
          

Cuando selecciona un buzón, el servidor devuelve el número total de mensajes que contiene. Todos los comandos posteriores para buscar y obtener se aplicarán a este buzón seleccionado.

Buscando y Obteniendo Correos Electrónicos

Este es el núcleo de la recuperación de correo electrónico. El proceso implica dos pasos: primero, buscar mensajes que coincidan con criterios específicos para obtener sus ID únicos, y segundo, obtener el contenido de esos mensajes usando sus ID.

El Poder de search()

El método search() es increíblemente versátil. No devuelve los correos electrónicos en sí, sino una lista de números de secuencia de mensajes (ID) que coinciden con su consulta. Estos ID son específicos de la sesión actual y el buzón seleccionado.

Aquí hay algunos de los criterios de búsqueda más comunes:

• 'ALL': Todos los mensajes en el buzón.
• 'UNSEEN': Mensajes que no se han leído todavía.
• 'SEEN': Mensajes que se han leído.
• 'FROM "sender@example.com"': Mensajes de un remitente específico.
• 'TO "recipient@example.com"': Mensajes enviados a un destinatario específico.
• 'SUBJECT "Your Subject Line"': Mensajes con un asunto específico.
• 'BODY "a keyword in the body"': Mensajes que contienen una cierta cadena en el cuerpo.
• 'SINCE "01-Jan-2024"': Mensajes recibidos en o después de una fecha específica.
• 'BEFORE "31-Jan-2024"': Mensajes recibidos antes de una fecha específica.

También puede combinar criterios. Por ejemplo, para encontrar todos los correos electrónicos no leídos de un remitente específico con un cierto asunto, buscaría '(UNSEEN FROM "alerts@example.com" SUBJECT "System Alert")'.

Veámoslo en acción:

            
# Buscar todos los correos electrónicos no leídos en la INBOX
status, message_ids = conn.search(None, 'UNSEEN')

if status == 'OK':
    # message_ids es una lista de cadenas de bytes, p. ej., [b'1 2 3']
    # Necesitamos dividirlo en ID individuales
    email_id_list = message_ids[0].split()
    if email_id_list:
        print(f"Se encontraron {len(email_id_list)} correos electrónicos no leídos.")
    else:
        print("No se encontraron correos electrónicos no leídos.")
else:
    print("Búsqueda fallida.")

            

              
                Copy
              
            
          

Obteniendo Contenido de Correo Electrónico con fetch()

Ahora que tiene los ID de los mensajes, puede usar el método fetch() para recuperar los datos reales del correo electrónico. Necesita especificar qué partes del correo electrónico desea.

• 'RFC822': Esto obtiene todo el contenido sin formato del correo electrónico, incluidos todos los encabezados y las partes del cuerpo. Es la opción más común y completa.
• 'BODY[]': Un sinónimo de `RFC822`.
• 'ENVELOPE': Obtiene información clave del encabezado como Fecha, Asunto, De, Para y En respuesta a. Esto es más rápido si solo necesita metadatos.
• 'BODY[HEADER]': Obtiene solo los encabezados.

Obtengamos el contenido completo del primer correo electrónico no leído que encontramos:

            
if email_id_list:
    first_email_id = email_id_list[0]
    
    # Obtener los datos del correo electrónico para el ID dado
    # 'RFC822' es un estándar que especifica el formato de los mensajes de texto
    status, msg_data = conn.fetch(first_email_id, '(RFC822)')
    
    if status == 'OK':
        for response_part in msg_data:
            # El comando fetch devuelve una tupla, donde la segunda parte es el contenido del correo electrónico
            if isinstance(response_part, tuple):
                raw_email = response_part[1]
                # Ahora tenemos los datos del correo electrónico sin formato como bytes
                # El siguiente paso es analizarlos
                print("Correo electrónico obtenido con éxito.")
                # Procesaremos `raw_email` en la siguiente sección
    else:
        print("Error al obtener.")

            

              
                Copy
              
            
          

Analizando Contenido de Correo Electrónico con el Módulo email

Los datos sin formato devueltos por fetch() son una cadena de bytes formateada de acuerdo con el estándar RFC 822. No es fácilmente legible. El módulo email integrado de Python está diseñado específicamente para analizar estos mensajes sin formato en una estructura de objetos fácil de usar.

Creando un Objeto Message

El primer paso es convertir la cadena de bytes sin formato en un objeto Message usando `email.message_from_bytes()`.

            
import email
from email.header import decode_header

# Suponiendo que `raw_email` contiene los datos de bytes del comando fetch
email_message = email.message_from_bytes(raw_email)

            

              
                Copy
              
            
          

Extrayendo Información Clave (Encabezados)

Una vez que tenga el objeto Message, puede acceder a sus encabezados como un diccionario.

            
# Obtener asunto, de, para y fecha
subject = email_message["Subject"]
from_ = email_message["From"]
to_ = email_message["To"]
date_ = email_message["Date"]

# Los encabezados de correo electrónico pueden contener caracteres no ASCII, por lo que necesitamos decodificarlos
def decode_email_header(header):
    decoded_parts = decode_header(header)
    header_str = ""
    for part, encoding in decoded_parts:
        if isinstance(part, bytes):
            # Si hay una codificación, úsela. De lo contrario, use utf-8 por defecto.
            header_str += part.decode(encoding or 'utf-8')
        else:
            header_str += part
    return header_str

subject = decode_email_header(subject)
from_ = decode_email_header(from_)

print(f"Asunto: {subject}")
print(f"De: {from_}")

            

              
                Copy
              
            
          

La función de ayuda decode_email_header es importante porque los encabezados a menudo se codifican para manejar conjuntos de caracteres internacionales. Simplemente acceder a email_message["Subject"] podría darle una cadena con secuencias de caracteres confusas si no la decodifica correctamente.

Manejo de Cuerpos de Correo Electrónico y Archivos Adjuntos

Los correos electrónicos modernos a menudo son "multipartes", lo que significa que contienen diferentes versiones del contenido (como texto plano y HTML) y también pueden incluir archivos adjuntos. Necesitamos recorrer estas partes para encontrar lo que estamos buscando.

El método msg.is_multipart() nos dice si un correo electrónico tiene múltiples partes, y `msg.walk()` proporciona una manera fácil de iterar a través de ellas.

            
def process_email_body(msg):
    body = ""
    attachments = []

    if msg.is_multipart():
        # Iterar a través de las partes del correo electrónico
        for part in msg.walk():
            content_type = part.get_content_type()
            content_disposition = str(part.get("Content-Disposition"))

            try:
                # Obtener el cuerpo del correo electrónico
                if content_type == "text/plain" and "attachment" not in content_disposition:
                    payload = part.get_payload(decode=True)
                    charset = part.get_content_charset() or 'utf-8'
                    body = payload.decode(charset)
                # Obtener archivos adjuntos
                elif "attachment" in content_disposition:
                    filename = part.get_filename()
                    if filename:
                        # Decodificar el nombre del archivo si es necesario
                        decoded_filename = decode_email_header(filename)
                        attachments.append({
                            'filename': decoded_filename,
                            'data': part.get_payload(decode=True)
                        })
            except Exception as e:
                print(f"Error al procesar la parte: {e}")
    else:
        # No es un mensaje multipart, simplemente obtener la carga útil
        payload = msg.get_payload(decode=True)
        charset = msg.get_content_charset() or 'utf-8'
        body = payload.decode(charset)
    
    return body, attachments

# Usando la función con nuestro mensaje obtenido
email_body, email_attachments = process_email_body(email_message)

print("\n--- Cuerpo del Correo Electrónico ---")
print(email_body)

if email_attachments:
    print("\n--- Archivos Adjuntos ---")
    for att in email_attachments:
        print(f"Nombre del archivo: {att['filename']}")
        # Ejemplo de guardar un archivo adjunto
        with open(att['filename'], 'wb') as f:
            f.write(att['data'])
        print(f"Archivo adjunto guardado: {att['filename']}")

            

              
                Copy
              
            
          

Esta función distingue inteligentemente entre el cuerpo de texto sin formato y los archivos adjuntos al inspeccionar los encabezados Content-Type y Content-Disposition de cada parte.

Gestión Avanzada de Buzones

Recuperar correos electrónicos es solo la mitad de la batalla. La verdadera automatización implica cambiar el estado de los mensajes en el servidor. El comando store() es su herramienta principal para esto.

Marcando Correos Electrónicos (Leídos, No Leídos, Marcados)

Puede agregar, eliminar o reemplazar banderas en un mensaje. La bandera más común es \Seen, que controla el estado de lectura/no lectura.

• Marcar como Leído: conn.store(msg_id, '+FLAGS', '\Seen')
• Marcar como No Leído: conn.store(msg_id, '-FLAGS', '\Seen')
• Marcar/Estrellar un Correo Electrónico: conn.store(msg_id, '+FLAGS', '\Flagged')
• Desmarcar un Correo Electrónico: conn.store(msg_id, '-FLAGS', '\Flagged')

Copiando y Moviendo Correos Electrónicos

No hay un comando "mover" directo en IMAP. Mover un correo electrónico es un proceso de dos pasos:

1. Copiar el mensaje al buzón de destino usando conn.copy().
2. Marcar el mensaje original para su eliminación usando la bandera \Deleted.

            
# Suponiendo que `msg_id` es el ID del correo electrónico a mover
# 1. Copiar al buzón 'Archive'
status, _ = conn.copy(msg_id, 'Archive')
if status == 'OK':
    print(f"Mensaje {msg_id.decode()} copiado a Archive.")
    # 2. Marcar el original para su eliminación
    conn.store(msg_id, '+FLAGS', '\Deleted')
    print(f"Mensaje {msg_id.decode()} marcado para su eliminación.")

            

              
                Copy
              
            
          

Eliminando Correos Electrónicos Permanentemente

Marcar un mensaje con \Deleted no lo elimina inmediatamente. Simplemente lo oculta a la vista en la mayoría de los clientes de correo electrónico. Para eliminar permanentemente todos los mensajes en el buzón seleccionado actualmente que están marcados para su eliminación, debe llamar al método expunge().

Advertencia: expunge() es irreversible. Una vez llamado, los datos se pierden para siempre.

            
# Esto eliminará permanentemente todos los mensajes con la bandera \Deleted
status, response = conn.expunge()
if status == 'OK':
    print(f"{len(response)} mensajes eliminados (eliminados permanentemente).")

            

              
                Copy
              
            
          

Un efecto secundario crucial de expunge() es que puede volver a numerar los ID de los mensajes para todos los mensajes subsiguientes en el buzón. Por esta razón, es mejor identificar todos los mensajes que desea procesar, realizar sus acciones (como copiar y marcar para su eliminación) y luego llamar a expunge() una vez al final de su sesión.

Poniéndolo Todo Junto: Un Ejemplo Práctico

Creemos un script completo que realice una tarea del mundo real: Escanear la bandeja de entrada en busca de correos electrónicos no leídos de "invoices@mycorp.com", descargar cualquier archivo adjunto PDF y mover el correo electrónico procesado a un buzón llamado "Processed-Invoices".

            
import imaplib
import email
from email.header import decode_header
import os

# --- Configuración ---
EMAIL_ACCOUNT = "your_email@example.com"
APP_PASSWORD = "your_16_digit_app_password"
IMAP_SERVER = "imap.gmail.com"
TARGET_SENDER = "invoices@mycorp.com"
DESTINATION_MAILBOX = "Processed-Invoices"
DOWNLOAD_DIR = "invoices"

# Crear directorio de descarga si no existe
if not os.path.isdir(DOWNLOAD_DIR):
    os.mkdir(DOWNLOAD_DIR)

def decode_email_header(header):
    # (Misma función definida anteriormente)
    decoded_parts = decode_header(header)
    header_str = ""
    for part, encoding in decoded_parts:
        if isinstance(part, bytes):
            header_str += part.decode(encoding or 'utf-8')
        else:
            header_str += part
    return header_str

conn = None
try:
    # --- Conectar e Iniciar Sesión ---
    conn = imaplib.IMAP4_SSL(IMAP_SERVER)
    conn.login(EMAIL_ACCOUNT, APP_PASSWORD)
    print("Inicio de sesión exitoso.")

    # --- Seleccionar INBOX ---
    conn.select('INBOX')
    print("INBOX seleccionada.")

    # --- Buscar correos electrónicos ---
    search_criteria = f'(UNSEEN FROM "{TARGET_SENDER}")'
    status, message_ids = conn.search(None, search_criteria)
    
    if status != 'OK':
        raise Exception("Búsqueda fallida")

    email_id_list = message_ids[0].split()
    if not email_id_list:
        print("No se encontraron nuevas facturas.")
    else:
        print(f"Se encontraron {len(email_id_list)} nuevas facturas para procesar.")

    # --- Procesar Cada Correo Electrónico ---
    for email_id in email_id_list:
        print(f"\nProcesando el ID del correo electrónico: {email_id.decode()}")
        
        # Obtener el correo electrónico
        status, msg_data = conn.fetch(email_id, '(RFC822)')
        if status != 'OK':
            print(f"Error al obtener el ID del correo electrónico {email_id.decode()}")
            continue
        
        raw_email = msg_data[0][1]
        email_message = email.message_from_bytes(raw_email)
        
        subject = decode_email_header(email_message["Subject"])
        print(f"  Asunto: {subject}")

        # Buscar archivos adjuntos
        for part in email_message.walk():
            if part.get_content_maintype() == 'multipart':
                continue
            if part.get('Content-Disposition') is None:
                continue
            
            filename = part.get_filename()
            if filename and filename.lower().endswith('.pdf'):
                decoded_filename = decode_email_header(filename)
                filepath = os.path.join(DOWNLOAD_DIR, decoded_filename)
                # Guardar el archivo adjunto
                with open(filepath, 'wb') as f:
                    f.write(part.get_payload(decode=True))
                print(f"  -> Archivo adjunto descargado: {decoded_filename}")

        # --- Mover el correo electrónico procesado ---
        # 1. Copiar al buzón de destino
        status, _ = conn.copy(email_id, DESTINATION_MAILBOX)
        if status == 'OK':
            # 2. Marcar el original para su eliminación
            conn.store(email_id, '+FLAGS', '\Deleted')
            print(f"  Correo electrónico movido a '{DESTINATION_MAILBOX}'.")

    # --- Expulsar y Limpiar ---
    if email_id_list:
        conn.expunge()
        print("\nCorreos electrónicos eliminados expulsados.")

except Exception as e:
    print(f"Ocurrió un error: {e}")
finally:
    if conn:
        conn.logout()
        print("Sesión cerrada.")


            

              
                Copy
              
            
          

Mejores Prácticas y Manejo de Errores

Al construir scripts de automatización robustos, considere las siguientes mejores prácticas:

• Manejo Robusto de Errores: Envuelva su código en bloques try...except para detectar posibles problemas como fallas de inicio de sesión (imaplib.IMAP4.error), problemas de red o errores de análisis.
• Gestión de la Configuración: Nunca codifique las credenciales de forma rígida. Use variables de entorno (os.getenv()), un archivo de configuración (p. ej., INI o YAML) o un administrador de secretos dedicado.
• Registro: En lugar de las declaraciones print(), use el módulo logging de Python. Le permite controlar la verbosidad de su salida, escribir en archivos y agregar marcas de tiempo, lo cual es invaluable para depurar scripts que se ejecutan sin supervisión.
• Limitación de Velocidad: Sea un buen ciudadano de Internet. No sondee el servidor de correo electrónico en exceso. Si necesita verificar si hay correo nuevo con frecuencia, considere intervalos de varios minutos en lugar de segundos.
• Codificaciones de Caracteres: El correo electrónico es un estándar global, y encontrará varias codificaciones de caracteres. Siempre trate de determinar el conjunto de caracteres de la parte del correo electrónico (part.get_content_charset()) y tenga una alternativa (como 'utf-8') para evitar UnicodeDecodeError.

Conclusión

Ahora ha viajado a través de todo el ciclo de vida de la interacción con un servidor de correo electrónico usando imaplib de Python. Hemos cubierto el establecimiento de una conexión segura, el listado de buzones, la realización de búsquedas potentes, la obtención y el análisis de correos electrónicos multipartes complejos, la descarga de archivos adjuntos y la gestión de los estados de los mensajes en el servidor.

El poder de este conocimiento es inmenso. Puede construir sistemas para categorizar automáticamente los tickets de soporte, analizar datos de informes diarios, archivar boletines informativos, desencadenar acciones basadas en correos electrónicos de alerta y mucho más. La bandeja de entrada, una vez una fuente de mano de obra manual, puede convertirse en una fuente de datos automatizada y poderosa para sus aplicaciones y flujos de trabajo.

¿Qué tareas de correo electrónico automatizará primero? Las posibilidades están limitadas solo por su imaginación. Comience poco a poco, construya sobre los ejemplos de esta guía y reclame su tiempo de las profundidades de su bandeja de entrada.