Enviar correo electrónico con Python usando smtplib

8 comentarios

En este tutorial vamos a ver cómo enviar mensajes de correo electrónico usando la biblioteca smtplib. Además vamos a programar una interfaz gráfica que permita tomar el texto de una caja de entrada y enviarlo usando el smtplib.

Herramientas
Vamos a usar, en este tutorial:

  • Geany como IDE.
  • Python (por supuesto).
  • Una versión reciente de Glade (al menos 3.6).
  • Posiblemente haga falta una versión actual de pygtk también.
Uso de smtplib
Para comenzar, vamos a escribir un pequeño programa que sea capaz de enviar un mensaje de email usando una cuenta de Gmail.

Lo primero es importar la biblioteca smtplib:

import smtplib


Ahora generamos el mensaje. Primero pedimos el nombre del remitente, luego la dirección de destino y por último el mensaje en sí:

DE = raw_input("Remitente: ")
PARA = [raw_input("Destino: ")]
texto = """
%s""" % raw_input("Mensaje: ")


Analicemos cada línea: al pedir el remitente no hay nada de especial, cuando pedimos la dirección de destino hay que recordar que se debe guardar como una lista, y, por último, al pedir el texto hay que tener en cuenta que se envía desde la segunda línea para adelante.

Creamos un objeto al que llamamos "server" usando la clase smtplib.SMTP() de la biblioteca smtplib, nos autenticamos y enviamos el mensaje:

server = smtplib.SMTP("smtp.gmail.com:587")
server.starttls()
server.login("nombredeusuario", "contraseña")
server.sendmail(DE, PARA, texto)
server.quit()


Gráficamente
Vamos a crear una interfaz gráfica para el programa anterior.

Abrimos Glade y creamos una ventana con una caja horizontal de cuatro elementos. Le damos por nombre "ventanaprincipal" a nuestra ventana y le ponemos una anchura predeterminada de 400 y una altura predeterminada de 300 en sus propiedades (pestaña General):

En la parte superior de nuestra caja colocamos una vista de texto, en la segunda y en la tercera una entrada de texto, y en la cuarta una botonera de un solo elemento. Dentro de esa botonera colocamos un botón:

Le ponemos nombres a nuestros elementos: a nuestra vista de texto le ponemos "mensaje", a nuestras entradas de texto "remitente" y "destino" (además cambiamos su propiedad "Texto", en la pestaña General, por "Remitente" y "Destino", respectivamente), y a nuestro botón "botonenviar (y le ponemos en su propiedad Etiqueta la palabra "Enviar"):

Le damos el manipulador "on_botonenviar_clicked" a la señal Clicked de nuestro botón y el manipulador "on_ventanaprincipal_destroy" a la señal Destroy de nuestra ventana principal.

En la propiedad Modo de Ajuste de nuestra vista de texto (mensaje), seleccionamos "Palabra", de esta forma al encontrarse que una palabra no cabe en la vista, se baja a la siguiente línea automáticamente.

Vamos a la pestaña Empaquetado de nuestras propiedades y cambiamos la propiedad Expandir de las dos entradas de texto (remitente y destino) y de la botonera por "No". De esta forma todo el espacio de la ventana es reservado para nuestro mensaje, y los demás elementos sólo reciben el espacio necesario para ser visibles:

Guardamos el archivo como "Interfaz.xml".

Abrimos Geany (o cualquier otro IDE o editor de texto) y empezamos a escribir el programa. Primero importamos los módulos necesarios:

import smtplib
import pygtk
import gtk


Creamos la clase "enviaremail" y su constructor:

class enviaremail:
def __init__(self):

builder = gtk.Builder()
builder.add_from_file("interfaz.xml")

self.ventanaprincipal = builder.get_object("ventanaprincipal")
self.mensaje = builder.get_object("mensaje").get_buffer()
self.remitente = builder.get_object("remitente")
self.destino = builder.get_object("destino")
self.botonenviar = builder.get_object("botonenviar")

builder.connect_signals(self)

self.ventanaprincipal.show()


Lo acabamos de hacer fue simplemente crear el objeto "builder" y cargar los elementos que creamos desde el archivo "interfaz.xml". Luego autoconectar todas las señales y mostrar la ventana principal.

Ahora programamos el manipulador para la señal Clicked de nuestro botón (cuando se lo presiona):

def on_botonenviar_clicked(self, widget, data=None):
DE = self.remitente.get_text()
PARA = [self.destino.get_text()]

inicio, fin = self.mensaje.get_bounds()

texto = """
%s
""" % self.mensaje.get_text(inicio, fin)

server = smtplib.SMTP("smtp.gmail.com:587")
server.starttls()
server.login("nombredeusuario", "contraseña")
server.sendmail(DE, PARA, texto)
server.quit()


Como se puede ver, el código es el mismo del primer ejemplo, con algunas diferencias: ahora el destino y el remitente son el contenido de las entradas de texto destino y remitente, respectivamente.
Para el texto del mensaje en sí, la cosa es un poco más complicada. La forma de leer el texto de una vista de texto es estableciendo unas marcas en el inicio y el final del mismo, con la funcion get_bounds(). Éstas marcas se guardan en las variables inicio y fin, que luego se pasan a la función get_text() para conseguir el texto de la vista.

Para terminar creamos el manipulador para la señal Destroy de la ventana principal e iniciamos el programa:

def on_ventanaprincipal_destroy(self, widget, data=None):
gtk.main_quit()

enviaremail()
gtk.main()


Guardamos el archivo como "enviaremail.py" y lo ejecutamos:

ssms 0.4.4

0 comentarios

Versión 0.4.4 del conocido programa de envío de mensajes a teléfonos celulares.

Características:

  • Compañías soportadas: Tigo, Vox, Personal.
  • Agenda de contactos.
  • Liberado bajo licencia GPL.
  • Programado con Python y Gtk+.
  • Sólo para Linux.
  • Instalador gráfico.
Descarga
Página oficial
Página del proyecto en sourceforge

ssms 0.4.3

0 comentarios

Versión 0.4.3 del conocido programa de envío de mensajes a teléfonos celulares.

Características:

  • Compañías soportadas: Tigo, Vox, Personal.
  • Agenda de contactos.
  • Liberado bajo licencia GPL.
  • Programado con Python y Gtk+.
  • Sólo para Linux.
Descarga
Página oficial
Página del proyecto en sourceforge

"Hola Mundo" con Python y GtkBuilder

27 comentarios

Hola, este es el primer tutorial que publico, espero con el tiempo mejorar mi calidad de redacción. Ahí va:

Vamos a ver como crear un sencillo programa que muestre un botón y al hacer click en él despliegue el mensaje "Hola mundo". Con este ejemplo se podrán aprender los pasos que en general se van a aplicar a cualquier otro programa hecho en Python y GtkBuilder. Hacer click en las imágenes para verlas en tamaño completo.

Herramientas necesarias:
Para construir la interfaz gráfica, vamos a usar Glade, un constructor de interfaces Gtk+.

Luego, necesitamos Python y los bindings de Gtk+ para Python.

Para este tutorial vamos a usar un IDE llamado Geany, que destaca por lo liviano y rápido que resulta.

Para instalar todo esto de una vez, en Debian/Ubuntu, simplemente ejecutamos el comando "sudo apt-get install python python-gtk2 glade geany" (sin comillas) en una consola. En Arch: "sudo pacman -Sy python pygtk glade geany".

(Nota: si usás Debian, asegurate de tener Squeeze para adelante para que te sirva el tutorial. Debian Lenny tiene versiones muy antiguas de glade, python y python-gtk y algunas cosas podrían ser diferentes).

Diseño de la interfaz:
Luego de instalar todo lo necesario, vamos a diseñar la interfaz de usuario de nuestra aplicación. Para eso, abrimos Glade.

En esta ventana dejamos las opciones como en la imagen y damos click a Cerrar:

Ahora se nos presenta la pantalla principal de Glade:

Creamos la ventana principal para nuestro programa, para eso hacemos click en la herramienta Ventana, el resultado es el siguiente:

Ahora agregamos una botonera (el lugar en donde van los botones) de un solo elemento y dentro de el espacio que se crea en nuestra ventana principal agregamos un botón:

Seleccionamos el botón y en la caja de propiedades, bajo la pestaña General, le ponemos por nombre "boton" y luego buscamos la propiedad Etiqueta y le cambiamos lo que tenga por "Click aquí":
Como se puede ver, lo que vaya en la propiedad Etiqueta es el texto que va a tener el botón. El nombre que lo pusimos ("boton") nos va a servir para poder referirnos al boton y programarlo en el momento de escribir el código. Podemos ponerle cualquier nombre, lo que no es posible es dar a dos elementos distintos de la interfaz el mismo nombre.

Vamos a la pestaña Señales de las propiedades de nuestro botón, y en la señal "clicked" seleccionamos el manipulador "on_boton_clicked" (enseguida explico esto):

A continuación vamos a crear la ventana a mostrarse al hacer click en el botón. Para eso, creamos una nueva ventana de la misma manera en la que creamos la ventana principal y dentro de ella insertamos una etiqueta con la herramienta Etiqueta:
Cambiamos el texto de la propiedad Etiqueta de nuestra etiqueta por "Hola Mundo", bajo la pestaña General de sus propiedades:
Solo para hacer más fácilmente entendible todo, le cambiamos los nombres a las ventanas. Le ponemos "ventanaprincipal" a lo que era window1 y "ventanamensaje" a lo que era window2:
Por último, le damos el manipulador "on_ventanaprincipal_destroy" a la señal destroy de nuestra ventana principal:
Los manipuladores son la forma de llamar a las señales de cada elemento de nuestro programa a la hora de escribir el código. Por ejemplo, cuando programemos el manipulador "on_ventanaprincipal_destroy", estaremos dando las instrucciones a ser ejecutadas al momento de cerrar (destruir) la ventana principal de nuestro programa; cuando se cierre la ventana principal esta da la señal "destroy" y se ejecuta lo que hayamos programado en su manipulador. Lo mismo pasa con el boton, cuando se haga click en el este da la señal "clicked" y se ejecuta el código que escribamos en su manipulador. (Nota: esto es lo que aprendí y me funciona, y creo que se acerca mucho a lo que realmente sucede, pero podría no ser realmente la explicación más correcta sobre las señales y los manipuladores).

Antes de pasar al código en sí, guardamos nuestra interfaz como "mundo.xml" en el formato GtkBuilder. Para eso nos vamos a Archivo-Guardar Como y le damos "mundo.xml" como nombre a nuestro archivo, seleccionamos GtkBuilder en formato de archivo y damos click en Guardar.

Código del programa:
Ahora pasamos a la parte más importante de cualquier programa: su código.

Abrimos Geany:
Ahora comenzamos a escribir el código:

Primero importamos los módulos que vamos a utilizar:

import gtk
import pygtk

Ahora creamos una clase que llamaremos "mundo", que va a contener los elementos del programa y las instrucciones que le vamos a dar a cada uno de los manipuladores de las señales, y comenzamos a importar los elementos de nuestra interfaz gráfica:

class mundo:
   def __init__(self):
      b= gtk.Builder()
      b.add_from_file("mundo.xml")
      self.ventanaprincipal = b.get_object("ventanaprincipal")
      self.boton = b.get_object("boton")
      self.ventanamensaje = b.get_object("ventanamensaje")
      b.connect_signals(self)
      self.ventanaprincipal.show()

Explicando línea por línea: primero se crea la clase, luego se define el "constructor". Dentro del mismo, agregamos el archivo "mundo.xml" que habíamos creado, y empezamos a importar de ese archivo cada uno de los elementos de nuestra interfaz. Después eso se conectan las señales y se muestra la ventana principal.

Vamos a definir ahora qué se hace al dar click al botón:

   def on_boton_clicked(self, widget, data=None):
      self.ventanamensaje.show()

Simplemente se muestra la ventana "ventanamensaje", que contiene el texto "Hola Mundo" al hacer click en el botón.

Ahora definimos qué hacer cuando se cierre la ventana principal:

   def on_ventanaprincipal_destroy(self, widget, data=None):
      gtk.main_quit()

Esto indica que termina el programa.

Por último, iniciamos la clase y el método gtk.main(), que se encarga de recibir las señales de los elementos de nuestra interfaz. Con estas dos líneas se da inicio al programa:

mundo()
gtk.main()


Guardamos el archivo como "mundo.py" en la misma carpeta en la que está el archivo "mundo.xml" creado anteriormente y lo ejecutamos directamente desde Geany presionando F5:

Al ejecutar el programa aparece la ventana principal con un botón. Al presionar el botón aparece otra ventana con el texto "Hola Mundo". Todo tiene una apariencia bastante mala, y vamos a ver en el siguiente tutorial como mejorar ese aspecto.

¡Welcome!

5 comentarios

La intención de este blog es compartir lo que aprendí sobre Python y Gtk+ en una serie de tutoriales.

Fui prácticamente autodidacta en programación -lo que se nota bastante en mi forma de programar- y me queda muchísimo por aprender, así que mis tutoriales no van a ser de un nivel avanzado (al menos no en un principio), y estoy abierto a todas las críticas/comentarios/sugerencias que pueden surgir.