Iker Perez de Albeniz » google

Usar/Crear Filtros para las plantillas de django/Google App Engine

Iker — Thu, 11 Mar 2010 11:17:03 +0000

Una de los temas mas interesante en Google App Engine es la posibilidad de usar plantillas. En la página de GAE existen ejemplos sencillos de cómo utilizar plantillas.El problema empieza cuando dentro de esas plantillas quieres hacer tratamiento de los datos para mostrar los datos correctamente. En esta articulo intentaremos explicar como usar esos filtros y como crear propios.

Como habéis podido ver en el ejemplo de la pagina de GAE, la forma de mostrar un valor en la plantilla es usando la sintaxis {{ variable }}. En la mayoría de los casos dichas variables serán de tipo string o integer por lo que su visualización no tendrá mayor problema. Pero por ejemplo en el caso de variables tipo datetime u otro tipo de objeto propio, el sistema de plantillas no es capaz de mostrar el contenido de dichas variables, ya que solo es capaz de mostrar valores tipo string o integer.

Para los tipos de datos mas comunes existen ya filtros por defecto como es el caso de los valores datetime. La forma de aplicar un filtro es la siguiente:

{{variable|filtro}}

Y en algunos casos:

{{variable|filtro:argumento}}

En el caso de los valores datetime que hemos comentado antes, para mostrar un valor de fecha deberemos usar el filtro date de la siguiente manera:

{{mydatevar|date:"j"}}

Esto seria equivalente a ejecutar una función date(mydatevar,”j”) y lo que estoy haciendo es mostrar el día del mes (código %j) similar a como se hace en otros lenguajes de programación.

Aquí podéis encontrar un listado con los principales filtros predeterminados en django

El problema es cuando estas funciones no son suficientes para hacer lo que nosotros queremos, o queremos tratar tipos de objetos poco comunes o propios.

Por ejemplo imaginemos que queremos tenemos un libro de visitas donde los usuarios puede escribir entradas, e indican su dirección de correo. Pero no queremos que esa dirección de correo sea visible para que no pueda ser rastreada por spammers, por lo que optamos por mostrar solo los 5 primeros caracteres de el nombre de usuario de la cuenta de correo mas tres puntos suspensivos (algo parecido a lo que se hace en las listas de distribución). Es decir para estoesunaprueba@gmail.com nos generara una dirección del tipo estoe…@gmail.com.

Por tanto nuestra función en python seria algo así como:

def securemail (mail):

        return mail.split(‘@’)[0][:5]+”…@”+ mail.split(‘@’)[1]

Es decir, dividimos la dirección en usuario y dominio con la función split y el carácter @, y generamos una nueva dirección con los primeros 5 caracteres de el usuario mas tres puntos suspensivos la arroba y el dominio.

Para poder usar esta función en nuestras plantillas haremos lo siguiente. Crearemos un script customfilters.py donde guardaremos todas nuestros filtros. Dicho script tendrá la siguiente forma

from google.appengine.ext import webapp

from datetime import datetime

register = webapp.template.create_template_register()

def securemail (mail):

        return mail.split(‘@’)[0][:5]+”…@”+ mail.split(‘@’)[1]

register.filter(securemail)

Para importar los filtros en nuestra aplicación añadiremos la siguiente sentencia justo después de los imports.

webapp.template.register_template_library(‘customfilters’)

De esta forma podremos usar nuestro filtro de la siguiente manera:

{{mail|securemail}}

Imaginemos que damos la opción al usuario que la función securemail muestre su cuenta de dos modos, uno, el por defecto que es el funcionamiento explicado anteriormente, y otro, que hace que solo se muestre el usuario sin el dominio. Por tanto deberemos definir un parámetro en la función para poder elegir el tipo de ofuscación. La función en este caso nos quedaría así:

def securemail (mail,default=true):

        if default:

                return mail.split(‘@’)[0][:5]+”…@”+ mail.split(‘@’)[1]

        else:

                return mail.split(‘@’)[0]

Por tanto si la variable mail tomara el valor estoesunaprueba@gmail.com este seria el resultado para las diferentes expresiones:

{{mail|securemail}} #estoe…@gmail.com

{{mail|securemail:true}} #estoe…@gmail.com

{{mail|securemail:false}} #estoesunaprueba

De esta forma podemos controlar y procesar la información a mostrar en nuestra plantilla cuando esta se trata de un objeto no string (o integer).

Consulta tu PageRank de Google con Python

Iker — Fri, 05 Mar 2010 07:17:49 +0000

A todos los que os interese el SEO seguramente habréis consultado alguna vez el PageRank de vuestra pagina. La forma mas sencilla de obtenerlo es instalando la ToolBar de Google en vuestro navegador. Pero seguramente si queréis realizar un seguimiento de vuestra pagina a lo largo del tiempo necesitareis automatizar un proceso que consulte el PageRank. La API de acceso al PageRank de google no es abierta, pero googleando un poco (o con Wireshark) es posible obtener el modo de consultar este dato. Parece que Google no le interesa que consultemos este dato, por lo que modifica la API bastante a menudo. En este artículo, te muestro una implementación en Python de un cliente para consultar el PageRank de una pagina, usando la API mas actual.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# GPL (C) 2010 Iker Perez de Albeniz
# ported in Python from the Php code by HM2K (http://www.hm2k.com/projects/pagerank)
# http://www.ikeralbeniz.net/2010/03/05/contulta-tu-pagerank-de-google-con-python/
import sys

import urllib

from urllib import urlencode

from pprint import pprint
def strToNum(Str, Check, Magic):

        Int32Unit = 4294967296

        length = len(Str);

        for i in range(0,length):

            Check *= Magic;

            if (Check >= Int32Unit):

                Check = (Check – Int32Unit * int(Check/Int32Unit))

                if Check < -2147483648:

                    Check = Check + Int32Unit

            Check += ord(Str[i])

        return Check

def hashURL(string):

        check1 = strToNum(string, 0×1505, 0×21)

        check2 = strToNum(string, 0, 0×1003F)

        check1 >>= 2

        check1 = ((check1 >> 4) & 0×3FFFFC0 ) | (check1 & 0×3F)

        check1 = ((check1 >> 4) & 0×3FFC00 ) | (check1 & 0×3FF)

        check1 = ((check1 >> 4) & 0×3C000 ) | (check1 & 0×3FFF)

        T1 = ((((check1 & 0×3C0) << 4) | (check1 & 0×3C)) <<2 ) | (check2 & 0xF0F )

        T2 = ((((check1 & 0xFFFFC000) << 4) | (check1 & 0×3C00)) << 0xA) | (check2 & 0xF0F0000 )

        return (T1 | T2);

def checkHash(hashnum):

        checkByte = 0;

        flag = 0;

        HashStr = ‘%s’ % hashnum

        length = len(HashStr)

        for i in range(0,length):

            Re = int(HashStr[(length – 1)-i])

            if (1 == (flag % 2)):

                Re += Re

                Re = int((Re / 10) + (Re % 10))
            checkByte += int(Re)

            flag = flag + 1
        checkByte %= 10

        if (0 != checkByte):

            checkByte = 10 – checkByte

            if (1 == (flag % 2) ):

                if (1 == (checkByte % 2)):

                    checkByte += 9

                checkByte >>= 1

        return ‘7%s%s’ %(checkByte,HashStr)
def getCh(url):

    return checkHash(hashURL(url))
def main():

    response = "Error: No URL defined.\nUsage: googrng.py  [[proxyuser:proxypass@]proxyhost:poxyport]"

    if len(sys.argv) > 1:

        myurl = sys.argv[1]

        url = "http://toolbarqueries.google.es/search?features=Rank&sourceid=navclient-ff&client=navclient-auto-ff&googleip=O;208.117.235.17;97&iqrn=8VdB&querytime=4P&orig=0X557&swwk=-1&ch=%s&q=info:%s" %(getCh(myurl),urllib.quote_plus(myurl))

        if len(sys.argv) > 2:

                proxies = {‘http’: ‘http://’+sys.argv[1]}

                f = urllib.urlopen(url, proxies=proxies)

        else:

                f = urllib.urlopen(url)

        response = f.read()

        f.close()

    print response
if __name__ == "__main__":

    main()

Primeros pasos con Buzz

Iker — Thu, 11 Feb 2010 11:10:07 +0000

Ha llegado Buzz y a primera vista lo que parece es un Twitter avanzado o un Facebook simplificado, como se vea. Pero mas allá de esta primera aproximación, me interesaba concer que funcionalidades se escondian tras esta nueva funcionalidad de Google. Por tanto el mejor sitio para empezar a buscar es el propio Google y su portal de APIs.

http://code.google.com/intl/es-ES/apis/buzz/

Actualmente solo existen dos opciones de integración disponibles:

De Buzz a tu Web
De tu Web a Buzz

De Buzz a tu Web

Buzz permite generar un RSS con tus comentarios en Buzz con lo que es posible generar plugins al estilo Twitter para tu blog. La forma de acceder a dicho RSS es la siguiente:

http://buzz.googleapis.com/feeds/{user_id}/public/posted

El user id es posible obtenerlo dirigiéndote a “Perfil de Google”..

En mis caso la dirección de mi perfil es la:

http://www.google.com/profiles/111738004311961586383

Por lo que mi user_id es 111738004311961586383 y mi url de RSS

http://buzz.googleapis.com/feeds/111738004311961586383/public/posted

De tu Web a Buzz

Buzz automáticamente permite que se integren en Buzz tus aplicaciones de Google, es decir, se generará un comentario cada vez que añadas una imagen a Picasa o subas un video a Youtube..

Si quieres que se genere un comentario cada vez que añades una entrada a tu blog debes conectar tu blog y Buzz bidireccionalmente:

Por un lado debes añadir una etiqueta en la cabecera de tu pagina de la siguiente manera:

En mi caso será de la siguiente manera

Además debes añadir tu Web como Web de confianza, para ello dirígete a tu perfil de Google:

http://www.google.com/profiles/me/editprofile

y en la sección Enlaces añade un enlace a tu Web

Una vez terminado este proceso cada entrada nueva será comentada en tu Buzz.

Listo!

segunda parte »

Primeros pasos en ChromeOS (Parte II)

Iker — Sat, 28 Nov 2009 15:57:14 +0000

En el post anterior vimos como instalar ChromeOS en una maquina virtual VMWare. Los primeros que lo probasteis os daríais cuenta que el teclado y el idioma por defecto era ingles, haciendo incomodas numerosas acciones como la utilización de símbolos como la @. En el siguiente post indicaremos como cambiar el idioma de teclado y entorno a castellano.

Como comenté en el post anterior, ChromeOS se trata de una distribución tipo Debian, por lo que la forma de cambiar la configuración del teclado es acceder a la configuración de la xorgs. El primer paso es acceder a una shell de bash como root. Para lo cual una vez logeados, deberemos pulsar CTR+ALT+T y se nos mostrara un terminal.

Deberemos pasar a root usando sudo -s y para ello usaremos la contraseña de root “chronos”

$> sudo -s
password: chronos

El sistema raiz esta montado en modo solo lectura por lo que lo “remontaremos” con acceso a escritura

mount -o remount /

ya podemos editar cualquier archivo de conflagración. En nuestro caso editaremos el archivo /etc/X11/xrog.conf y editaremos los siguientes parámetros del apartado “Keyboard”

Option “XkbModel” “pc105″
Option “XkbLayout” “es”

De este modo indicaremos que nuestro teclado es un teclado estándar de 105 teclas y en español. Para que los cambios tengan efecto debereis reiniciar el sistema mediante el comando rebooot.

$> reboot

Pero mejor es dejar el reinicio para mas tarde y seguir configurando el sistema en castellano. Para lo cual deberemos cambiar las variables LANGUAGE y LANG a castellano editando el archivo /etc/enviroment

$> vi /etc/environment

LANGUAGE=”es_Es:es”
LANG=es_ES.UTF-8

Ahora ya podemos reiniciar el sistema y vereis como el teclado ya esta en castellano, por lo que sera mas cómodo manejarlo.

NOTA: Hasta cambiar el idioma, de cara a poder usar VI es importante tener en cuenta que los símbolos : y . están en la Ñ.

Primeros pasos en ChromeOS (Parte I)

Iker — Thu, 26 Nov 2009 14:15:55 +0000

La verdad es que hace unos días que ya estaba disponible el nuevo sistema operativo de Google, pero hasta hoy no me he puesto a probarlo y cacharrear con el. A primera vista decir que es un sistema operativo es un pelin exagerado ya que básicamente se trata de una distribución GNU/Linux, mas concretamente una Ubuntu, con las xorg y librerías GTK instaladas. Lo suficiente para lanzar el navegador Web de Google llamado, como no, Chrome. Básicamente podemos hacer los mismo instalando una Ubuntu Server, las xorg y añadir una línea en rc.local para que lance un navegador al iniciar la sesión. Aun así, en el caso de Chrome OS es algo un poco mas elaborado ya que dispone de un sistema de login que se autentica a través de http con Google usando tu cuenta de Google. Por tanto ChromeOS, como ya habian manifestado de de Google, es un sistema operativo basado en su navegador y en “aplicaciones en la nube”.

Manos a la obra

Para empezar lo mejor es instalar ChromeOs en una VMWare y hacer las pruebas desde la maquina virtual. Para lo cual podemos bajarnos una imagen desde:

http://gdgt.com/google/chrome-os/download/

Una vez descargada la imagen crearemos una nueva maquina virtual.

Crearemos una Maquina virtual típica y seleccionaremos “Instalare el sistema operativo mas tarde”. Como sistema operativo seleccionaremos Linux y la distribución UBUNTU.

En nuestro caso llamaremos a nuestra Maquina Virtual ChromeOS. Una vez creada descomprimiremos la imagen de Crome descargada anteriormente y la copiaremos dentro del directorio ChromeOS donde hemos creado la maquina virtual.

A continuación añadiremos la imagen descargada y la configuraremos como disco duro principal. Para lo cual iremos a configuración. En el listado de Hardware pulsaremos Añadir y elegiremos añadir un Disco Duro. En nuestro caso elegiremos usar una Imagen ya existente.

Por tanto seleccionaremos la imagen descargada y la añadiremos manteniendo el formato original. Una vez añadida la nueva imagen podemos eliminar la imagen creada por defecto.

Ya tenemos la Maquina Virtual instalada por lo que ya solo nos queda ejecutar la maquina virtual y empezar a usar ChromeOS.

Para logearnos deberemos usar nuestra cuenta de Google. En caso de tener problemas con la conexión aseguraros que la tarjeta de red esta en modo bridge.

Si aun así no conseguis logearos podéis usar el usuario local.

Username: chronos
Password:

En las próximas entradas explicare como acceder como root a la consola y configurar ChromeOS en Castellano y la posibilidad de conectarse a través de un Proxy.

Posibilidades de la nueva funcionalidad de Google Translate

Iker — Wed, 18 Nov 2009 14:16:03 +0000

Google ha actualizado su sistema de traducción con una nueva funcionalidad: es posible escuchar el texto y así comprobar la pronunciación. La verdad es que el resultado (probado en Ingles) es bastante bueno e imagino que dentro de algún tiempo estará disponible en castellano.

Por curiosidad he estado mirando como podría usarse esta funcionalidad por parte de aplicaciones de terceros y he obtenido que el audio se genera a partir de un script al que es posible llamar de la siguiente manera:

http://translate.google.com/translate_tts?q= &tl=

Donde es el texto a pronunciar codificado con la función URLEncode (que es posible encontrar en casi todos los lenguajes) y donde es el código del lenguaje en el que esta el texto (por ahora solo parece funcionar con Ingles “en”).

Un ejemplo de cómo quedaría seria el siguiente:

http://translate.google.com/translate_tts?q=This%20is%20a%20text%20in%20English%20that%20can%20be%20heard&tl=en

La forma de generar este tipo de URLs de forma dinámica en PHP seria la siguiente:

function getTranslatedSound($string){
$string=str_replace(” “,”%20″,$string);
$string = “?q=”.$string.”&tl=en”;
$string = “http://translate.google.com/translate_tts”.$string;
return $string;
}

$string = getTranslatedSound(“This is a text in English that can be heard”);
echo $string;
?>

Con lo que las posibilidades son enormes:

Adaptar páginas para ciegos

Crear Presentaciones Dinámicas con audio

Escuchar una conferencia en directo sin necesidad de streaming usando Twitter o similares.

Etc,…

Es decir, la combinación de esta funcionalidad con tecnologías como Ajax o Flash podría revolucionar muchos de los servicios actuales. Ahora toca correr a aquellas personas que quieran ser los primeros en dar ese servicio y colocarse en una posición dominante en el mercado.

Actualización [18/11/2009 16:33]

He añadido un ejemplo con javascript para crear un CHAT de voz.

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>

Instalando ANDROID + ECLIPSE en WINDOWS (2000 o XP)

Iker — Thu, 15 Nov 2007 10:37:34 +0000

En el artículo anterior explicábamos como instalar ANDROID y ECLIPSE en UBUNTU. Ahora toca el turno a Windows y puesto que la configuración de eclipse es la misma en ambos sistemas operativos solo se explicara como se instalan el SDK y ECILPSE en el ordenador.

El primer paso es instalar el SDK, para lo cual nos lo descargaremos de esta dirección:

http://dl.google.com/android/android_sdk_windows_m3-rc20a.zip

Una vez descargado y descomprimida cambiamos el nombre de la carpeta “android_sdk_windows_m3-rc20a” por “android_sdk” y la movemos a nuestro C:\Archivos de Programa\.

Para terminar la instalación solo falta añadir la ruta del SDK al path, para lo cual vamos a INICIO> Configuración > Panel de Control y entramos en Sistema.

Dentro del panel de Sistema vamos a la pestaña Opciones Avanzadas y pulsamos en Variables de Entorno

Se nos mostraran dos listas de variables: Variables de usuario para usuario y variables del sistema. En nuestro caso añadiremos una variable y cambiaremos el path en la lista de Variables del sistema para que todos los usuarios tengan acceso al SDK.

Por tanto pulsaremos en Nueva y nos aparecerá un cuadro de dialogo donde meteremos el nombre de la variable y su ruta. En el caso del SDK pondremos como nombre SDK_ROOT y la ruta C:\Archivos de Programa\android_sdk y pulsamos Aceptar. La nueva variable se añadirá a la lista.

Ya solo falta añadir la ruta al path, por tanto, buscamos la variable PATH de la lista de Variables del sistema, y pulsamos sobre ella dos veces. Se nos aparecerá el mismo cuadro de dialogo de antes peor esta vez completo con el nombre PATH un montón de rutas que están añadidas al path separadas por “;”. Por tanto añadiremos los siguiente al final del campo Valor de la variable: ;%SDK_ROOT%\tools

NOTA: no olvidar el “;” ni los “%”

Pulsamos Aceptar a todas las ventanas hasta cerrarlas todas y ya tenemos el SDK instalado.

Y asolo faltaría instalar Eclipse. Para instalar eclipse solo hay que descargarse eclipse del siguiente enlace, descomprimirlo y mover la carpeta a C:\Archivos de Programa\. (para que esté todo mas ordenado..)

A partir de aquí faltaría configurar y plugin de android para eclipse. Los pasos son idénticos que en Ubuntu así que podéis seguir los mismos pasos que se indican en el articulo anterior.