Fondo de escritorio cambiantes para ubuntu

El otro día convencí a un amigo para que se pasara a linux y entre las muchas preguntas que me empezaron a llegar por parte de él (todo sea por la causa), una era sobre como hacer un fondo de pantalla como esos que trae por defecto Ubuntu que cambian cada cierto tiempo, me dio mucha pena el no poder responder en el momento ya que no tenia ni idea de como funcionaba, así que me puse a la tarea y la verdad no era nada del otro mundo, solo un pequeño archivo xml que describe las transiciones de las imágenes; para ver como se estructura el archivo podemos ojear el que se encuentra en /usr/share/backgrounds/cosmos/background-1.xml.

Ahora que ya sabia como crear mis propios sliders, solo faltaba automatizar el proceso (flojo que soy), y como decidí hacer de python mi lenguaje por defecto XD, pues me puse a trabajar y esto fue lo que me salio, no es el súper programa pero intente hacerlo lo mas pythonista que pude, por favor si alguien lee esto y tiene mas conocimientos de python, se le agradecerán todos las criticas que me ayuden a mejorar u_u

view plainprint?

1. #!/usr/bin/python  
2. # -*- coding: UTF-8 -*-  
3.   
4. # Por: Jhonatan sneyder Salguero Villa (sney2002@gmail.com)  
5. # Crear fondos de escritorio cambiantes  
6. import sys, os  
7.   
8. FORMAT = """ <static> 
9.   <duration>%(static_time).1f</duration> 
10.   <file>%(current)s</file> 
11.  </static> 
12.  <transition> 
13.   <duration>%(transition_time).1f</duration> 
14.   <from>%(current)s</from> 
15.   <to>%(next)s</to> 
16.  </transition>"""  
17.    
18.    
19. class BackgroundSlider():  
20.  EXTENSIONS = [".jpg", ".jpeg", ".png"]  
21.    
22.  def __init__(self, static_time = 1200):  
23.   self.xml_parts       = ["<background>"]  
24.   self.static_time     = static_time  
25.   self.path = os.getcwd()  
26.   
27.  def get_images(self, ext=EXTENSIONS):  
28.   """ Guardar archivos con extencion (jpg, jpeg, png) en self.images """  
29.   # Se puede especificar los archivos como argumentos  
30.   files = sys.argv[1:] or os.listdir(".")  
31.   # Filtrar imágenes  
32.   self.images = [os.path.join(os.getcwd(), img) for img in files if os.path.splitext(img)[1].lower() in ext]  
33.   
34.   
35.  def add_image(self, current, next, static_time, transition_time = 5):  
36.   """ Adicionar imagen al slider """  
37.   self.xml_parts.append( FORMAT % locals() )  
38.   
39.   
40.  def make_slider(self):  
41.   """ Crear archivo xml que define el slider """  
42.   images = self.images  
43.   
44.   # Todo termina donde empiesa U_U  
45.   images.append( images[0] )  
46.   
47.   for i in range( len(images)-1 ):  
48.    self.add_image(images[i], images[i+1], self.static_time)  
49.     
50.   self.xml_parts.append("</background>")  
51.   
52.   
53.  def save(self, filename = "background" ):  
54.   """ Guardar el slider """  
55.   
56.   xml = file(filename + ".xml", 'w')  
57.   
58.   try:  
59.    xml.write( "\n".join(self.xml_parts) )  
60.   
61.   except IOError:  
62.    print "Error al Guardar el archivo. Intente de Nuevo"  
63.     
64.   finally:  
65.    xml.close()  
66.   
67.   
68. if __name__ == "__main__":  
69.  slider = BackgroundSlider()  
70.   
71.  slider.get_images()  
72.   
73.  slider.make_slider()  
74.   
75.  slider.save()  

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# Por: Jhonatan sneyder Salguero Villa (sney2002@gmail.com)
# Crear fondos de escritorio cambiantes
import sys, os

FORMAT = """ 
  %(static_time).1f
  %(current)s
 
 
  %(transition_time).1f
  %(current)s
  %(next)s
 """
 
 
class BackgroundSlider():
 EXTENSIONS = [".jpg", ".jpeg", ".png"]
 
 def __init__(self, static_time = 1200):
  self.xml_parts       = [""]
  self.static_time     = static_time
  self.path = os.getcwd()

 def get_images(self, ext=EXTENSIONS):
  """ Guardar archivos con extencion (jpg, jpeg, png) en self.images """
  # Se puede especificar los archivos como argumentos
  files = sys.argv[1:] or os.listdir(".")
  # Filtrar imágenes
  self.images = [os.path.join(os.getcwd(), img) for img in files if os.path.splitext(img)[1].lower() in ext]


 def add_image(self, current, next, static_time, transition_time = 5):
  """ Adicionar imagen al slider """
  self.xml_parts.append( FORMAT % locals() )


 def make_slider(self):
  """ Crear archivo xml que define el slider """
  images = self.images

  # Todo termina donde empiesa U_U
  images.append( images[0] )

  for i in range( len(images)-1 ):
   self.add_image(images[i], images[i+1], self.static_time)
  
  self.xml_parts.append("")


 def save(self, filename = "background" ):
  """ Guardar el slider """

  xml = file(filename + ".xml", 'w')

  try:
   xml.write( "\n".join(self.xml_parts) )

  except IOError:
   print "Error al Guardar el archivo. Intente de Nuevo"
  
  finally:
   xml.close()


if __name__ == "__main__":
 slider = BackgroundSlider()

 slider.get_images()

 slider.make_slider()

 slider.save()

Luego puse este archivo con los demás script de nautilus (~/.gnome2/nautilus-scripts) y ahora mi amigo cuando quiera un fondo de escritorio, solo selecciona las imágenes, click derecho crear wallpaper y listo. Si les interesa pueden bajar el script de este enlace:

• Crear Wallpaper

Saltándose los captchas de Megaupload con python

Como todo buen gorrón me gusta las cosas gratis y fáciles, sobre todo cuando se tiene una serie de 24 capítulos que se quiere descargar sin estar pendiente rellenando captchas, y aunque las cuentas premiun no son tan caras, la verdad no me apetece gastarme una platica en algo que voy a utilizar muy rara vez, así que hice lo que cualquier persona normal haría, juntar un montón de software libre y pegarlos con un poco de python y voila mi propio gestor de descarga con reconocimiento de captchas (solo megaupload), ya se que hay muchos programas que hacen lo mismo y ademas libres (Tucan por ejemplo), pero usarlos no seria tan divertido, así que me puse a recolectar los materiales para mi "manualidad". Gestor de descargas ya tenia y no podía ser mejor que wget, solo faltaba el reconocimiento de caracteres, ocr que llaman; después de un poco de búsqueda apareció tesseract que sin lugar a dudas es el mejor programa de reconocimiento de caracteres que haya visto hasta el momento. Solo faltaban algunas librerías como pytesser para "comunicarse" con tesseract y  libxml2dom (requiere libxml2) para consultar el dom en documentos aun cuando estos estén mal formados.

Como ven, lo bonito del software libre es que con tan solo una búsqueda nos encontramos con programas maravillosos, los cuales podemos utilizar sin ninguna restricción (sí, ya se que esto no es completamente cierto). Ahora si, con ustedes el script:

view plainprint?

1. import libxml2dom  
2. import urllib2  
3. import urllib  
4. import pytesser  
5. import Image  
6.   
7. MAX_TRY = 5 # intentos antes de rendirse  
8. WAIT_TIME = 45 # tiempo de espera en segundos  
9. CAPTCHA_INPUT_NAME = "captcha"  
10. TEMP_FILE_NAME   = "tempImg.gif"  
11. ID_DOWNLOAD_LINK = "downloadlink"  
12.   
13. def urlopen(url, data={}):  
14.  """Abrir un recurso remoto, si se pasa data se envía por POST"""  
15.  req = urllib2.Request(url, urllib.urlencode(data) if data else None)  
16.  try:  
17.   sock = urllib2.urlopen(req)  
18.   try:  
19.    data = sock.read()  
20.   finally:  
21.    sock.close()  
22.  except IOError:  
23.   print "el archivo no existe"  
24.  else:  
25.   return data  
26.   
27. def html2dom(page):  
28.  """Retornar representación DOM de un documento html"""  
29.  dom = libxml2dom.parseString(page, html=1)  
30.  return dom  
31.   
32. def tag(elem, tag):  
33.  """Encontrar descendientes de un elementos por su tag"""  
34.  elements = elem.getElementsByTagName(tag)  
35.  return elements[0] if len(elements) == 1 else elements  
36.    
37. def id(elem, Id):  
38.  return elem.getElementById(Id)  
39.    
40. def attr(elem, attr):  
41.  """Retornar atributo de un elemento"""  
42.  return elem.getAttribute(attr)  
43.   
44. def save_img(uri):  
45.  """Guardar imagen en local"""  
46.  data = urlopen(uri)  
47.  temp = file(TEMP_FILE_NAME, 'wb')  
48.  temp.write(data)  
49.  temp.close()  
50.   
51. def resolver_captcha():  
52.  """Resolver captcha"""  
53.  data = Image.open(TEMP_FILE_NAME)  
54.  return pytesser.image_to_string(data)[:4]  
55.   
56. def fill_form(page):  
57.  """Recolectar datos de formulario"""  
58.  try:  
59.   form = tag(page, 'form')  
60.   img = tag(form, 'img')  
61.   
62.   save_img(attr(img, "src"))  
63.    
64.   # crear diccionario valores a enviar  
65.   data = dict([(attr(i, 'name'),attr(i, 'value')) for i in tag(form, 'input')])  
66.   
67.   # "rellenar" campo captcha  
68.   captcha = resolver_captcha()  
69.   data[CAPTCHA_INPUT_NAME] = captcha  
70.  except:  
71.   return None  
72.  else:  
73.   return (data, captcha)  
74.   
75. # Donde la magia sucede XD  
76. def get(url):  
77.  """Descargar archivo"""  
78.  times = 1  
79.   
80.  # solo links de megaupload  
81.  if url.find('http://www.megaupload.com/') != 0:  
82.   print "%s no es un link de megaupload" % url  
83.   return 0  
84.     
85.  # Abrir pagina de formulario  
86.  page = html2dom( urlopen(url) )  
87.   
88.  while True:  
89.   # llenamos el formulario  
90.   data, captcha = fill_form(page)  
91.     
92.   if not data or times == MAX_TRY:  
93.    print "Error al abrir %s, puede que el link haya sido deshabilitado" % url  
94.    return 0  
95.   
96.   print "%s ==> intento %d\ncaptcha = %s" % (url, times, captcha)  
97.   times += 1  
98.   
99.   # Enviamos formulario por POST  
100.   page = html2dom( urlopen(url, data) )  
101.     
102.   # Si el captcha esta correcto obtenemos la página de descarga  
103.   download_page = id(page, ID_DOWNLOAD_LINK)  
104.     
105.   if download_page:  
106.    download_link = tag( download_page , 'a' )  
107.    import subprocess, time  
108.      
109.    # please wait.... XD  
110.    time.sleep(WAIT_TIME)  
111.   
112.    args = ['wget', '-c', attr(download_link, 'href')]  
113.      
114.    # empezamos a descargar ^_^  
115.    proc = subprocess.Popen(args)  
116.    retcode = proc.wait()  
117.    return 1  
118.      
119. def get_from_file(file_path):  
120.  """descargar múltiples archivos leyendo urls almacenadas en un archivo"""  
121.  try:  
122.   sock = file(file_path)  
123.   try:  
124.    lines = sock.readlines()  
125.   finally:  
126.    sock.close()  
127.  except IOError:  
128.   print "el archivo %s no existe" % file_path  
129.  else:  
130.   for line in lines:  
131.    url = line.strip()  
132.    if url:  
133.     get( url )  
134.   
135. if __name__ == "__main__":  
136.  import sys  
137.   
138.  arg = sys.argv[1:]  
139.    
140.  if arg[0] == "-f":  
141.   get_from_file(arg[1])  
142.  elif "http" in arg[0]:  
143.   get(arg[0])  
144.  else:  
145.   print "uso:\nmget link_descarga\nmget -f /ruta/archivo/links_descarga\n"   

import libxml2dom
import urllib2
import urllib
import pytesser
import Image

MAX_TRY = 5 # intentos antes de rendirse
WAIT_TIME = 45 # tiempo de espera en segundos
CAPTCHA_INPUT_NAME = "captcha"
TEMP_FILE_NAME   = "tempImg.gif"
ID_DOWNLOAD_LINK = "downloadlink"

def urlopen(url, data={}):
 """Abrir un recurso remoto, si se pasa data se envía por POST"""
 req = urllib2.Request(url, urllib.urlencode(data) if data else None)
 try:
  sock = urllib2.urlopen(req)
  try:
   data = sock.read()
  finally:
   sock.close()
 except IOError:
  print "el archivo no existe"
 else:
  return data

def html2dom(page):
 """Retornar representación DOM de un documento html"""
 dom = libxml2dom.parseString(page, html=1)
 return dom

def tag(elem, tag):
 """Encontrar descendientes de un elementos por su tag"""
 elements = elem.getElementsByTagName(tag)
 return elements[0] if len(elements) == 1 else elements
 
def id(elem, Id):
 return elem.getElementById(Id)
 
def attr(elem, attr):
 """Retornar atributo de un elemento"""
 return elem.getAttribute(attr)

def save_img(uri):
 """Guardar imagen en local"""
 data = urlopen(uri)
 temp = file(TEMP_FILE_NAME, 'wb')
 temp.write(data)
 temp.close()

def resolver_captcha():
 """Resolver captcha"""
 data = Image.open(TEMP_FILE_NAME)
 return pytesser.image_to_string(data)[:4]

def fill_form(page):
 """Recolectar datos de formulario"""
 try:
  form = tag(page, 'form')
  img = tag(form, 'img')

  save_img(attr(img, "src"))
 
  # crear diccionario valores a enviar
  data = dict([(attr(i, 'name'),attr(i, 'value')) for i in tag(form, 'input')])

  # "rellenar" campo captcha
  captcha = resolver_captcha()
  data[CAPTCHA_INPUT_NAME] = captcha
 except:
  return None
 else:
  return (data, captcha)

# Donde la magia sucede XD
def get(url):
 """Descargar archivo"""
 times = 1

 # solo links de megaupload
 if url.find('http://www.megaupload.com/') != 0:
  print "%s no es un link de megaupload" % url
  return 0
  
 # Abrir pagina de formulario
 page = html2dom( urlopen(url) )

 while True:
  # llenamos el formulario
  data, captcha = fill_form(page)
  
  if not data or times == MAX_TRY:
   print "Error al abrir %s, puede que el link haya sido deshabilitado" % url
   return 0

  print "%s ==> intento %d\ncaptcha = %s" % (url, times, captcha)
  times += 1

  # Enviamos formulario por POST
  page = html2dom( urlopen(url, data) )
  
  # Si el captcha esta correcto obtenemos la página de descarga
  download_page = id(page, ID_DOWNLOAD_LINK)
  
  if download_page:
   download_link = tag( download_page , 'a' )
   import subprocess, time
   
   # please wait.... XD
   time.sleep(WAIT_TIME)

   args = ['wget', '-c', attr(download_link, 'href')]
   
   # empezamos a descargar ^_^
   proc = subprocess.Popen(args)
   retcode = proc.wait()
   return 1
   
def get_from_file(file_path):
 """descargar múltiples archivos leyendo urls almacenadas en un archivo"""
 try:
  sock = file(file_path)
  try:
   lines = sock.readlines()
  finally:
   sock.close()
 except IOError:
  print "el archivo %s no existe" % file_path
 else:
  for line in lines:
   url = line.strip()
   if url:
    get( url )

if __name__ == "__main__":
 import sys

 arg = sys.argv[1:]
 
 if arg[0] == "-f":
  get_from_file(arg[1])
 elif "http" in arg[0]:
  get(arg[0])
 else:
  print "uso:\nmget link_descarga\nmget -f /ruta/archivo/links_descarga\n" 

Claro que le hacen falta algunas funcionalidades, pero para lo que lo necesito me basta y me sobra, ademas como ya dije existe una gran variedad de programas que hacen lo mismo. Si lo desean pueden descargar los archivos desde el siguiente enlace:

• mget

P.D.: Se aceptan criticas, solo no sean tan duros XD