Respaldar data y esquemas de PostgreSQL con Django

1. Respaldar data en un JSON.

$ python manage.py dumpdata --all > ./mydump.json

2. Respaldar los esquemas(schemas) en SQL.

$ python manage.py sqlflush > schema.sql

3. Creamos la base de datos nueva de no tenerla y nos conectamos a ella.

$ sudo -u postgres createdb db_nueva
$ sudo -u postgres psql db_nueva

4. Cargamos los schemas.

db_nueva=# \i schema.sql
db_nueva=# ctrl-d

5. Por último cargamos la data.

$ python manage.py loaddata ./mydump.json

Espero a alguien le sirva de algo.

Anuncios

Django + Backbone.js

Django

Backbone.js

 

 

Quiero compartir una pequeña aplicación de un “Simple Blog” que he estado haciendo para aprender Backbone.js utilizando Django.

¿Qué es Backbone.js?

Así lo explican en su página oficial:

Da estructura a las aplicaciones web al ofrecer modelos con la unión clavevalor y eventos personalizados, colecciones con una rica API de funciones enumerables, puntos de vista con evento declarativa manipulación, y lo conecta todo a su API existente sobre una interfaz JSON REST.

Para que se entienda mejor yo lo explico de esta manera:

Backbone.js es un Framework de Javascript que te permite crear aplicaciones usando el patrón de desarrollo MVC (Modelo-Vista-Controlador), es una líbrería OpenSource muy liviana con apenas unos 6.5Kb. Esta diseñada para hacer el desarrollo mucho mas facil de mantener en el tiempo y para desarrollar aplicaciones de una única página muy facilmente. Define un conjunto de estructuras de datos (Models y Collections) junto al manejo de la interfaz por medio de Vistas y URLs.

Sus únicas dependencias son JQuery para interactuar directamente con el DOM y el Sistema de Plantillas Underscore.js (>=1.5.0).

Para hacer mas facil la comunicación de Django con Backbone he utilizado la aplicación django-backbone la cual proporciona un API RESTful por JSON que es lo que necesita Backbone para hacer su trabajo. Es una aplicación muy sencilla y facil de aprender para empezar.

Bueno he aquí el enlace al proyecto para el que quiera probarlo o trabajar sobre el:
https://github.com/goidor/dj_backbone_ejm

Estamos a la orden para cualquier duda.

Como instalar PyQt4 en un entorno Virtualenv.

En este post quiero explicar como compilar y instalar PyQt4 y SIP en un entorno de desarrollo utilizando Virtualenv, en este caso utilizando Python 2.7.

Lo primero que debemos tener en cuenta es instalar las dependencias necesarias.

En Archlinux:

# pacman -Sy python2-pip python2 libxext python2-pyqt4 base-devel 

En Debian:

# apt-get install python-pip python2.7-dev libxext-dev python-qt4 qt4-dev-tools build-essential

Ya con eso debería bastar a la hora de compilar. En mi caso estoy utilizando ArchLinux y con esas dependencias fue suficiente.

En caso de no tener Virtualenv instalado ejecutamos:

# pacman -Sy python2-virtualenv

ó

# apt-get install python-virtualenv

Iniciamos el entorno de desarrollo en la ruta que deseamos.

$ virtualenv /home/usuario/virtualenv/nombre

Descargamos el código fuente de PyQt4 y SIP:

### Entramos a la carpeta y creamos el directorio build
$ cd /home/usuario/virtualenv/nombre && mkdir build
$ cd build
### Descargamos el código fuente. 
$ wget http://sourceforge.net/projects/pyqt/files/PyQt4/PyQt-4.11/PyQt-x11-gpl-4.11.tar.gz
$ wget http://sourceforge.net/projects/pyqt/files/sip/sip-4.16/sip-4.16.tar.gz
### Y descomprimimos.
$ tar xzvf PyQt-x11-gpl-4.11.tar.gz
$ tar xzvf sip-4.16.tar.gz

Activamos el entorno virtual:

$ source ~/virtualenv/nombre/bin/activate

Ahora compilamos, primero SIP y luego PyQt.

### Entramos a la carpeta y compilamos
(nombre)$ cd sip-4.16
(nombre)$ python configure.py
(nombre)$ make
### Instalamos como root en este caso si deseamos.
(nombre)$ sudo make install

### Entramos al directorio de PyQt y compilamos
(nombre)$ cd ../PyQt-x11-gpl-4.11/
### Debemos especificarle la ruta del qmake de la versión de Qt que vamos a compilar, en el caso de ArchLinux por ejemplo, tenemos que especificar.
(nombre)$ python ./configure.py -q /usr/bin/qmake-qt4

Nos preguntara si aceptamos los términos de la licencia y escribimos ‘yes‘. Después toca esperar que chequee y genere todos los módulos y el archivo Makefile.

### Ahora instalamos:
(nombre)$ sudo make install

En el caso de PyQt si es necesario ejecutarlo como root o con sudo porque el necesita tener acceso a copiar los archivos a la ruta del Python del sistema que por lo general se encuentran en /usr/lib/python2.7/ y luego crear las librerías en el site-packages de nuestro entorno virtual activo, también crear los binarios necesarios en el directorio ./bin/ del entorno virtual y instalar los módulos de PyQt en el entorno virtual en ./share/sip/PyQt4/ como por ejemplo QtOpenGL y QtGui.

Ya con eso deberíamos tener funcionando perfectamente PyQt4 en nuestro entorno virtual. Lo podemos comprobar en una shell de Python de la siguiente manera.

(nombre)$ python
>>> from PyQt4 import *
>>>

Si no muestra ningún error importando es porque todo esta perfecto.

Suerte.

Saludos, feliz desarrollo.

(Git) Herramientas gráficas y de Texto para GNU/Linux

  A veces resulta tedioso y poco vistoso usar la línea de comandos para revisar los logs de un proyecto desarrollado con GIT, hacer un diff, hacer un ‘commit‘, hacer un add, hacer push, entre muchas cosas que se pueden hacer con el versionador de código Git….

Es por ello que voy a listar algunas herramientas o aplicaciones útiles que he usado para esto:

  1. Gitg

Una Aplicación con una interfaz gráfica muy intuitiva, puedes hacer muchas cosas en ella como hacer commits, pushear, cambiar de rama, buscar ramas locales o remotas, revisar los logs súper detallados con gráfica de cambios de cada archivo, foto de la persona que hizo el commit, revisar el código del archivo con línea exacta, colores y símbolos, lo que ayuda bastante a la hora de detectar lo que buscas, revisas o quieres depurar.

Instalación: Debian/Mint/Ubuntu. Se puede hacer fácilmente con un:

# aptitude install gitg

Clonando el proyecto de aquí: http://git.gnome.org/browse/gitg/

o también descargandolo vía ftp desde: http://ftp.gnome.org/pub/GNOME/sources/gitg/

Interfaz de Gitg

2. Gitk

Una herramienta gráfica liviana hecha en C++ y GTK, con un poco menos de funciones que gitg pero también es muy útil para hacer una revisión rápida del log del proyecto, revisar ramas, commits, etc… Y puedes cambiar la interfaz de la app a tu gusto.

Instalación: Debian/Mint/Ubuntu desde la consola:

# aptitude install gitk

Descargar código fuente dese su sitio oficial en SourceForge:  http://sourceforge.net/projects/gitk/files/gitk-core/gitk-core-0.2.0/

gitk

3.  Git-cola

Es una app muy buena, liviana y con muchas funciones para manejar tus repositorios Git’s. La interfaz es intuitiva y fácil de usar.

Instalación: Debian/Mint/ubuntu:

# aptitude install git-cola

Enlace a su sitio oficial donde explica la instalación en distintos SO: http://git-cola.github.com/downloads.html

4. Tig

Herramienta desarrollada por los desarrolladores de ‘Gitk’, con una interfaz de terminal/consola es una app muy buena, rápida por supuesto para realizar muchas funciones en tus repositorios Git. Unas de sus funciones son: ver, revisar o buscar commits, hacer checkout a Ramas, hacer commits…

Instalción: Debian/Mint/Ubuntu:

# aptitude install tig

Clonar o descargar el proyecto: https://github.com/jonas/tig

Bueno existen muchas aplicaciones para esto pero para mí las mas destacadas son las antes mencionadas y a demás son las que me más me han gustado. 🙂

Saludos! Happy hacking.

Uso medio-avanzado de Git

Empezar a trabajar con Git en tu proyecto.

Lo primero que haríamos es crear un repositorio local en el que va a trabajar el git con (ojo debemos estar situados en la raíz del directorio del proyecto):

  • $git init

Con el comando anterior ya tendremos el repositorio creado; podemos verificarlo con: $ls -a si vemos el directorio (.git/) es porque se a creado corectamente nuestro repositorio local, ya con esto podemos crear commits y movernos por el historial.

Ahora debemos añadir todos nuestros archivos al repositorio creado para empezar a versionarlos.

  • $git add *

Ya tenemos todos los archivos añadidos para comprobarlo usamos el comando:

  • $git status

Ahora si para agregar todos los archivos al repositorio hacemos el commit.

  • $git commit -am “Empezando a versionar el proyecto”

Con esto ya tenemos todos los archivos guardados en un commit. Para comprobarlo vemos el historial de commits con:

  • $git log

Como respuesta deberiamos ver un unico commit que es el que acabamos de hacer.

Ahora si viene la mejor parte.

Configuración de git.

Vamos a configurar especificamente el proyecto actual.

Configurar el nombre: $git config user.name “Nombre Apellido”

Configurar correo: $git config user.email ejemplo.2@gmail.com

Activar el colores de los diff: $git config color.diff auto

gitignore

Como su nombre lo indica sirve para git ignore archivos que no queremos versionar en el proyecto. Debemos crear el archivo el directorio raíz del proyecto así por ejemplo: $vim .gitignore (así creara el archivo oculto).

Un ejemplo para archivo .gitignore puede ser el directorio nbproject que crear Netbeans cuando creamos un proyecto en el cual esta nuestra configuración local. Sino queremos versionar este directorio abrimos el archivo .gitignore y colocamos:

  • nbproject/*

Si queremos ignorar solo un archivo especificamos la ruta de ese archivo.

Manejo de ramas o branch

Crear una rama local.

  • $git branch nueva_rama

Cambiar a otra rama.

  • $git checkout nombre_rama

Crear una rama nueva y cambiarse a ella de una vez.

  • $git checkout -b nueva_rama

Crear una rama nueva que apunte a una remota y cambiar a ella de una vez.

  • $git checkout -b nueva_rama origin/rama_remota

Unir ramas: para unir ramas usamos merge nos localizamos en una rama y luego hacemos:

  • $git merge otra_rama

Subir una rama local al servidor remoto.

  • $git push origin rama_local

Listar ramas.

  • Locales: $git branch
  • Remotas: $git branch -r
  • Ambas: $git branch -a

Eliminar una rama local.

  • git branch -d rama_local

Eliminar rama remota.

  • $git push origin :nombre_rama

Crear un rama local que haga seguimiento a una remota.

  • $git branch –track nueva_rama origin/rama_remota

Manejo de archivos

Eliminar cambios de un archivo y regresar a la ultima versión:

  • $git checkout ruta_archivo

Volver a una versión estable de un archivo:

  • $git checkout HASH — ruta_archivo

Descartar ultimos commits hechos:

  • git reset –hard HEAD

Para forzar push en el repositorio remoto:

  • git push origin +master

Recuperar commits eliminados:

  • $git reflog # indentificamos el commit
  • $git reset –hard HEAD

Manipulación de commit

A veces queremos modificar el ultimo commit antes de hacer push para modificar la descripción sería:

  • git commit –amend

Unir varios commits en uno solo:

  • git rebase -i HEAD

Para el que quiera profundizar mucho más aqui les dejo un enlace de un Video toturial muy bueno:

http://www.youtube.com/watch?v=fxolktqi3Rs&feature=plcp&context=C3fbbfb4UDOEgsToPDskK2dKYHlQPAjIoVQnuHyyjE

Linux User = #533200