deancos.com

Muchos usuarios al actualizar su distribución Ubuntu hacia la versión 13.04 han visto como los panales de Unity desaparecieron como por arte de magia, yo lamentablemente fui uno de ellos. Cuando actualice mi distribución quise instalar los drivers de mi tarjeta gráfica y esto provoco lo anteriormente comentado. Rápidamente busque alguna solución y después de un par de hora de búsquedas en launchpad descubrí que no era al único que le había pasado algo parecido y que probablemente se debía a un bug.

Lo mejor de todo esto es que tiene solución, he aquí:

El primer paso es borrar la configuración antigua de compiz:

$ rm -rf ~/.config/compiz-1

Acto seguido deberemos reiniciar la configuración por defecto:

$ dconf reset -f /org/compiz/

Ya solo nos queda reiniciar y todo debería estar ya es su sitio.

Para mas información sobre este bug os hago referencia al lugar del bug en launchpad: https://bugs.launchpad.net/ubuntu/+source/unity/+bug/1128348

Nota: Para los que no puedan abrir un terminal pueden probar a lanzarlo mediante shortcuts, Control + Alt + t

En este breve articulo explicare como instalar y configurar rápidamente MongoDB en un entorno Ubuntu 12.10 desde los repositorios oficiales de 10gen la empresa desarrolladora de MongoDB.

Lo primero que debemos hacer es conseguir las llaves publicas del repositorio oficial de 10gen: “`shellsudo apt-key adv –keyserver keyserver.ubuntu.com –recv 7F0CEB10[/shell] Cuando termina el proceso anterior debemos crear el fichero /etc/apt/sources.list.d/10gen.list y añadir la siguiente linea deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen.

Para a continuación actualizar nuestra lista de repositorios:

$ sudo apt-get update

Ahora solo queda instalar el paquete de MongoDB:

$ sudo apt-get install mongodb-10gen

Una vez termine el proceso de instalación de la ultima versión estable de MongoDB podemos probarla para constatar que todo ha ido correctamente. Para ello basta con lanzar el cliente de mongodb.

$ mongo
MongoDB shell version: 2.2.2
connecting to: test
Welcome to the MongoDB shell.
For interactive help, type 'help'.
For more comprehensive documentation, see

http://docs.mongodb.org/

Questions? Try the support group

http://groups.google.com/group/mongodb-user

> use test
switched to db test
> db.coleccion.save({'nombre':'Samuel de Ancos', 'url':'http://www.deancos.com'})
> db.coleccion.find()
{ '_id' : ObjectId('5103cc7cd36f372a94dfe038'), 'nombre' : 'Samuel de Ancos', 'url' : 'http://www.deancos.com' }
> exit
bye

Cuando MongoDB se instala por este procedimiento automáticamente podrás controlarlo como cualquier proceso del sistema:

$ sudo service mongodb start
$ sudo service mongodb stop
$ sudo service mongodb restart

Si necesitas cambiar alguna configuración podrás encontrar el fichero de configuración en /etc/mongodb.conf, en el podrás comprobar por ejemplo donde se encuentra el store de base de datos o la ruta de los logs:

dbpath=/var/lib/mongodb

#where to log
logpath=/var/log/mongodb/mongodb.log

Últimamente el termino IoT esta en boca de todos, parece ser que en este año y los venideros veremos por fin el establecimiento real del concepto "Todo conectado". Internet Of Things es un paso mas allá en el mundo de las comunicaciones, es el siguiente paso.

Existen varias plataformas sobre las que construir este avance, una de ellas es Carriots. Para seguir este mini-tutorial es necesario tener un cuenta en la plataforma: http://carriots.com/joinus

Bueno pues vamos al trapo, os presento aquí un pequeño script en python capaz de mandar un stream de datos a la plataforma Carriots.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import urllib2
import time, datetime
import json

class Client (object):
    api_url = 'http://api.carriots.com/streams'

    def __init__ (self, api_key = None, client_type = "json"):
            self.client_type = client_type
            self.api_key = api_key
            self.content_type = 'application/vnd.carriots.api.v2+%s' % (self.client_type)
            self.headers = {"User-Agent": "Python-Client-Carriots",
                            "Content-Type": self.content_type,
                            "Accept": self.content_type,
                            "Carriots.apikey": self.api_key}

    def send (self, data):
            self.data = json.dumps(data)
            request = urllib2.Request(Client.api_url, self.data, self.headers)
            self.response = urllib2.urlopen(request)
            return self.response

def main():
    client_carriots = Client ('TU APIKEY')
    data = {'protocol': 'v2',
            'device': 'TU DEVICE',
            'at': int(time.mktime(datetime.datetime.utcnow().timetuple())),
            'data': {'TUDATO':'VALOR DATO'}
            }
    carriots_response = client_carriots.send(data)
    return 0

if __name__ == "__main__":
    main()

Simplemente deberías cambiar los datos con los tuyos de tu cuenta de Carriots y a jugar!

Si necesitas mas información sobre Carriots: http://carriots.com/documentation

Continuamos con las nuevas características de la versión 5.4 de PHP. En esta ocasión trataremos las nuevas funcionalidades de los arrays: la sintaxis corta y la derreferenciación.

La sintaxis corta, acerca el lenguaje PHP a otros como PYTHON o RUBY. Si conocéis algo de estos lenguajes podréis comprobar que ahora declarar un array en PHP es igual de sencillo:

$ php -a

php > $my_array = ["uno", "dos"];
php > var_dump($my_array);
array(2) {
  [0]=>
  string(3) "uno"
  [1]=>
  string(3) "dos"
}

php > $my_array_assoc = ["key_uno" => "value_uno", "key_dos" => "value_dos"];
php > var_dump($my_array_assoc);
array(2) {
  ["key_uno"]=>
  string(9) "value_uno"
  ["key_dos"]=>
  string(9) "value_dos"
}

El concepto de derreferenciación o simplemente referencia consiste en la posibilidad de referenciar, nunca mejor dicho, un array, directamente de una llamada a una función o a un método de un objeto.

$ php -a

php > function getListaCompra() {
php { return ["Patatas", "Lechugas"];
php { }
php > echo getListaCompra()[0];
Patatas
php > echo getListaCompra()[1];
Lechugas
php > var_dump(getListaCompra());
array(2) {
  [0]=>
  string(7) "Patatas"
  [1]=>
  string(8) "Lechugas"
}

Estas nuevas funcionalidades demuestran que PHP sigue por el buen camino implementando características de otros lenguajes.

Hace ya varios meses que se publico la versión 5.4 del lenguaje de programación por antonomasia de la web: PHP. Una de las nuevas y flamantes funcionalidades que incluye esta release son los Traits.

Según la propia documentación de la pagina oficial de PHP; los Traits son un mecanismo de reutilización de código en lenguajes de herencia simple.

Gracias a los Traits podemos reutilizar métodos en clases PHP. Es una implementación de herencia múltiple y reutilización de código muy peculiar. Un trait en si mismo es una clase pero que tiene la peculiaridad de que no se puede instanciar pero sin embargo se puede utilizar en otras clases. Veamos un ejemplo sencillo:

trait miPrimerTrait {
    public function miMetodoTrait() {
        return "MiMetodoTrait";
    }
}

class miClase {
    use miPrimerTrait;

    public function miMetodo() {
        return "MiMetodo";
    }
}

$objeto = new miClase();

$string =  $objeto->miMetodo();
$string2 = $objeto->miMetodoTrait();

echo $string;
echo $string2;

Como podemos observar en el ejemplo declarar Traits y utilizarlos es muy sencillo. Se pueden utilizar varios traits en una misma clase:

class miOtraClase {
    use miPrimerTrait, miOtroTrait
    ...
}

Este es un ejemplo sencillo de la funcional que nos ofrecen los Traits en PHP 5.4, si necesitas mas información no dudes en acudir a la documentación oficial: http://php.net/manual/es/language.oop5.traits.php

Composer es una de las ultimas herramientas que estan consiguiendo reinventar la manera de trabajar con el lenguaje de programación PHP.

Como su propia pagina oficial indica: "Composer es una herramienta para manejar dependencias en PHP".

Su funcionamiento es muy sencillo; simplemente basta conseguir la herramienta de la pagina web oficial del proyecto: http://getcomposer.org/download/ y definir un fichero de dependencias escrito en json: composer.json.

He aquí un ejemplo de composer.json:

{ "require":  
 {
 "php" : ">=5.3.3",
 "twig/twig" : "1.*",
 "monolog/monolog": "1.0.*",
 "nategood/httpful": "*"
 }
}

La mayoría de herramientas y librerías modernas escritas en PHP soportan el sistema de instalación por medio de Composer.

El framework Symfony2 y su hermano pequeño Silex utilizan Composer como sistema de instalación de Bundles y Componentes.

Existe un catalogo web, Packagist, donde se pueden encontrar paquetes que soportan Composer: http://packagist.org/

Se puede encontrar mas información en la pagina de documentacion del proyecto: http://getcomposer.org/doc/

Sin lugar a dudas Composer a conseguido que la utilización de componentes de terceros en proyectos PHP sea mucho mas fácil de integrar.

El modulo random de la librería estándar de python como su propia documentación indica: Implementa un generador de números pseudo-aleatorios.

El ejemplo mas sencillo para ilustrar el funcionamiento del modulo podría ser:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random

def main():
    random_number = random.random()
    return random_number

if __name__ == "__main__":
    print main()

El ejemplo anterior imprimiría un numero pseudo-aleatorio entre [0.0 … 1.0].

Pero la cosa no se queda en eso pues también se adapta según el tipo de dato en el cual lo utilicemos. Así por ejemplo podemos utilizarlo en secuencias para seleccionar elementos aleatoriamente. Por ejemplo:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random

def main():
    una_lista = ["ElementoUno", "ElementoDos", "ElementoTres"]
    element_random = random.shuffle(una_lista)
    return element_random

if __name__ == "__main__":
    print main()

También podemos utilizarlo para generar números aleatorios dentro de un rango de enteros predefinido:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random

def main():
    number_random_int = random.randint(1, 30)
    return number_random_int

if __name__ == "__main__":
    print main()

Como podemos observar conocer en profundidad el modulo random nos puede ayudar a generar contenido aleatorio de manera rápida y sencilla.

Para terminar quiero mostrar un ejemplo de creación de strings aleatorio utilizando el modulo random y el modulo string ambos incluidos en la librería estándar de python:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
import string

def main(number):
    random_string = "".join(random.choice(string.letters) for x in range(number))
    return random_string

if __name__ == "__main__":
    print main(10)

Podemos encontrar mas información sobre este modulo y los métodos que implementa en la documentación oficial de la librería estándar de python: http://docs.python.org/library/random.html

Hace poco mas de un mes os hablaba sobre la librería Request para python; la cual nos facilitaba enormemente el manejo de peticiones http. Hoy quiero presentar un homologo pero esta vez escrito en PHP: HTTPFUL.

Podemos encontrar información sobre esta librería en su pagina principal: http://phphttpclient.com/

Podemos descargar la librería con un archivo PHAR o utilizando el sistema de paquetes composer.

PHAR: https://github.com/downloads/nategood/httpful/httpful-0.2.0.phar

Si utilizas composer solo deberías añadir la librería a tu fichero composer.json: “nategood/httpful”

Con httpful podemos hacer peticiones fácilmente, he aquí un ejemplo sencillo de petición GET:

$uri = "http://blog.deancos.com";
$response = Request::get($uri)->send();
echo $response->body;

Ejemplo de peticion POST envio de json:

$response = Request::post($uri)
    ->sendsJson()
    ->body({"clave":"valor"})
    ->send();

Bueno como se puede comprobar es bastante sencilla de utilizar la librería y muy cómoda sobre todo para trabajar sobre api rest.

Si se necesita profundizar mas; se puede encontrar información en su pagina web sobre como utilizarla.

Espero que a partir de ahora cuando trabajéis con api rest en php el trabajo sea menos laborioso y mucho mas provechoso y ágil.

Os traigo una pequeña función en python , que utilizo normalmente para imprimir por consola listas anidadas.

Dada una lista:

[“Campo1”, [“Anidado1”, “Anidado2”, [“TercerNivel”, “T2”], “Anidado3”], “Campo3”]

Imprimiría por consola:

Campo1
   Anidado1
   Anidado2
     TercerNivel
     T2
   Anidado3
Campo3

Código de la función:

def print_list(alist, level = 0):
  for element in alist:
    if isinstance(element, list):
      print_list(element, level + 1)
    else:
      print 't' * level + element

def main():
  lista = ['Campo1', ['Anidado1', 'Anidado2', ['TercerNivel', 'T2'], 'Anidado3'], 'Campo3']
  print_list(lista)
  return 0

if __name__ == "__main__":
  main()

Es una función muy sencilla y útil a la vez. Espero que sirva de ayuda y aprendizaje sobre el lenguaje de programación python.

En el ultimo post hable sobre la librería Request, una librería escrita en Python para manejar peticiones http desde tus aplicaciones o scripts escritos en python. Hoy quiero profundizar un poco mas en la librera explicando de manera sencilla la utilización de un servidor proxy para mandar peticiones.

He aquí el script de ejemplo (la ip del servidor proxie es de ejemplo y no funcional):

#!/usr/bin/env python

import requests

def main():
  proxy_diccionario = { "http" : "10.10.10.10" }
  response = requests.get("http://blog.deancos.com",
                          proxies=proxy_diccionario,
                          timeout=5)
  return response

if __name__ == "__main__":
  response = main()
  print response.status_code
  print response.headers["content-type"]
  print response.text

En el anterior ejemplo se puede apreciar que hemos declarado un diccionario con la clave http y un valor que corresponde con la ip del servidor proxy que queremos utilizar. En este caso la petición se hace a través del protocolo http aunque también se puede utilizar https:

proxy_diccionario = { "https": "10.10.10.10" }

En la petición get hemos añadido el parámetro proxies y allí hemos incluido nuestro diccionario. También hemos añadido el parámetro timeout, que es bastante auto-descriptivo, en segundos.

Es un ejemplo sencillo pero muestra la facilidad que nos da la librería Requests para poder utilizar un servidor proxy en nuestras peticiones http.