Heme aqui escribiendo este post desde el hospital hehe. A la niora la van a operar y estare aqui al menos tres dias, por lo que me estoy dando  la tarea de limpiar y actualizar el codigo del kubuntero.com ya que por fin tengo algo de tiempo (maldito geek). En fin, me propuse buscar un buen IDE para hacer las paginas, pero, habiendo ya probado con anterioridad la mayoria, me quedare con el buen editor kate. No se si hay algo malo o estupido en mi que simplemente no entiendo a los IDE. He probado  Netbeans, Aptana, Kompozer y Dreamweaver, pero no son precisamente excelentes a la hora de querer hacer algo fuera de una tabla o introducir tags, en el caso de Django... asi que tendre que aprender HTML bien... maldicion... si algun curioso se ha tomado la molestia de ver el codigo fuente de la pagina, se dara cuenta que no es muy profesional que digamos, pero esperen un poco muahahaha y vendran las mejoras. Por una parte me deshare de los comments de facebook he implementare los propios (aunque nada de lo que pongo es lo suficientemente novedoso o interesante como para comentar), y espero corregir los links para que muestren un texto relacionado en vez de numeros :S y quiza, si ando de buenas, implementare mejor compatibilidad con IE.

Pues asi es, no sabia como poner el titulo en español (maldita sea, me estoy volviendo un pocho) pero aqui esta, como generar una lista  "random" de un queryset. He aqui la funcion:

def get_random(queryset):
	""" Returns a randomized queryset for the main profile view."""
	
	randomized = []
	total = queryset.count()
	
	for items in queryset:
		
		try:
			profile = queryset.get(id=random.randrange(1,total))
			randomized.append(profile)
		
		except:
			continue
	
	return randomized

Quiubole que! Solo recuerden que utiliza el modulo random.

Pues resulta que esta vez ando trabajando en un proyectillo que requiere subir archivos creando directorios segun el usuario. La documentacion de Django indica que esto se puede lograr usando un metodo al cual se le pasaran las variables instance y filename. El instance incluye todas las caracteristicas de un objeto que ya ha sido guardado en la base de datos, por lo que se puede usar el id, (errrrr, negativo, como todavia no ha sido guardado en la base de datos, el id no esta disponible ;) ). Lo unico que necesitan es crear su funcion y llamarla en la opcion 'upload_to' del modelo:

def upload_path(instance, filename):
	directorio = instance.Chica.Nombre.lower() + '_%d' % instance.id
	
	return os.path.join('imagenes', directorio, filename)


def thumb_path(instance, filename):
	directorio = instance.Chica.Nombre.lower() + '_%d' % instance.id
	
	return os.path.join('thumbs', directorio, filename)
	
	
	
class Imagen(models.Model):
	Chica = models.ForeignKey(Chica)
	Foto = models.ImageField(upload_to=upload_path, help_text="Presiona el boton para subir una nueva foto a tu perfil.")
	Thumb = models.ImageField(upload_to=thumb_path, editable=False, null=True)
	Etiqueta = models.CharField(max_length=200, blank=True, help_text="Escribe una etiqueta para esta foto (opcional).")
	Cover = models.BooleanField(help_text="Marca este recuadro si deseas utilizar esta foto como presentacion en la pagina principal.")

Pues aqui esta parte del codigo que use para registrar el numero de visitas que tengo asi como sus respectivos IP's muahahahaha. Ahi si alguien tiene una mejora me la hacen saber. Use la base de datos GeoIP... creo (por dios! ya no me acuerdo ni como se llama!) en fin, necesitan instalar el api de dicha base de datos. Por lo demas, todo esta bastante entendible, cada view pasa la funcion client_record, y aunque es demasiado rustico (esto lo debi haber hecho como un "custom middleware") funciona, sin embargo es mejor que utilizen este codigo donde corresponde (MIDDLEWAREEE!!)  Provecho!

from datetime import datetime, timedelta
from kubuntero.clients.models import *

def client_record(ipaddress, url, obj):

	now = datetime.now()
	defurl, new_url = Url.objects.get_or_create(path=url)
	history, created = Client.objects.get_or_create(address=ipaddress)
  
	if (now - history.date) > timedelta(minutes = 2) or (defurl.path not in history.visited_sites.values_list('path', flat=True)):
		history.date = now
		history.visited_sites.add(defurl.id)
		history.save()
		
		try:
			for post in obj:
				new_count = int(post.view_count) + 1
				post.view_count = new_count
				post.save()
		
		except TypeError:
			
			new_count = int(obj.view_count) + 1
			obj.view_count = new_count
			obj.save()

Ya en mi views.py, hago lo siguiente:

client_record(request.META['REMOTE_ADDR'], request.path, show.object_list)

donde show.object_list es el resultado de un queryset usando django-pagination, pero pueden usar una sola instancia tambien... pfft, ahora que lo veo, que feo codigo :S

Bueno raza, aqui les traigo una simple clase de daemon que pueden utilizar para hacer sus propios daemons facilmente. Esta basado en el de este camarada, yo solo le agregue la integracion con signals para que cuando se mate el servicio de la forma kill pid hiciera el proceso normal de limpieza y removiera el archivo pid. A continuacion la clase:

#!/usr/bin/env python

import sys, os, time, atexit
from signal import SIGTERM 

class Daemon:
	"""
	A generic daemon class.
	
	Usage: subclass the Daemon class and override the run() method
	"""
	def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
		self.stdin = stdin
		self.stdout = stdout
		self.stderr = stderr
		self.pidfile = pidfile
	
	def daemonize(self):
		"""
		do the UNIX double-fork magic, see Stevens' "Advanced 
		Programming in the UNIX Environment" for details (ISBN 0201563177)
		http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
		"""
		try: 
			pid = os.fork() 
			if pid > 0:
				# exit first parent
				sys.exit(0) 
		except OSError, e: 
			sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
			sys.exit(1)
	
		# decouple from parent environment
		os.chdir("/") 
		os.setsid() 
		os.umask(0) 
	
		# do second fork
		try: 
			pid = os.fork() 
			if pid > 0:
				# exit from second parent
				sys.exit(0) 
		except OSError, e: 
			sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
			sys.exit(1) 
	
		# redirect standard file descriptors
		sys.stdout.flush()
		sys.stderr.flush()
		si = file(self.stdin, 'r')
		so = file(self.stdout, 'a+')
		se = file(self.stderr, 'a+', 0)
		os.dup2(si.fileno(), sys.stdin.fileno())
		os.dup2(so.fileno(), sys.stdout.fileno())
		os.dup2(se.fileno(), sys.stderr.fileno())
	
		# write pidfile
		atexit.register(self.delpid)
		pid = str(os.getpid())
		file(self.pidfile,'w+').write("%s\n" % pid)
	
	def delpid(self):
		os.remove(self.pidfile)

	def start(self):
		"""
		Start the daemon
		"""
		# Check for a pidfile to see if the daemon already runs
		try:
			pf = file(self.pidfile,'r')
			pid = int(pf.read().strip())
			pf.close()
		except IOError:
			pid = None
	
		if pid:
			message = "pidfile %s already exist. Daemon already running?\n"
			sys.stderr.write(message % self.pidfile)
			sys.exit(1)
		
		# Start the daemon
		self.daemonize()
		self.run()

	def stop(self, signum=None, frame=None):
		"""
		Stop the daemon
		"""
		# Get the pid from the pidfile
		try:
			pf = file(self.pidfile,'r')
			pid = int(pf.read().strip())
			pf.close()
		except IOError:
			pid = None
	
		if not pid:
			message = "pidfile %s does not exist. Daemon not running?\n"
			sys.stderr.write(message % self.pidfile)
			return # not an error in a restart

		# Try killing the daemon process	
		try:
			while 1:
				os.kill(pid, SIGTERM)
				time.sleep(0.1)
		except OSError, err:
			err = str(err)
			if err.find("No such process") > 0:
				if os.path.exists(self.pidfile):
					os.remove(self.pidfile)
			else:
				print str(err)
				sys.exit(1)

	def restart(self):
		"""
		Restart the daemon
		"""
		self.stop()
		self.start()
		
		

	def run(self):
		"""
		You should override this method when you subclass Daemon. It will be called after the   process has been
		daemonized by start() or restart().
		"""

Con esto solo tienen que crear su servicio anulando el metodo run y agregando el modulo signals para atrapar SIGTERM:

 #!/usr/bin/env python

import sys, time, signal, os
from daemon import Daemon
	
	
class MyDaemon(Daemon):

	def run(self):
               
		signal.signal(signal.SIGTERM, self.stop)

		while True:
			
			print 'A la verga todo'

			time.sleep(1)

  

if __name__ == "__main__":

	daemon = MyDaemon('/tmp/daemon.pid')

	if len(sys.argv) == 2:

		if 'start' == sys.argv[1]:

			daemon.start()

		elif 'stop' == sys.argv[1]:

			daemon.stop()

		elif 'restart' == sys.argv[1]:

			daemon.restart()

		else:

			print "Unknown command"

			sys.exit(2)

		sys.exit(0)

	else:

		print "usage: %s start|stop|restart" % sys.argv[0]

		sys.exit(2)