Daniel Maldonado

miércoles, 16 de diciembre de 2015

Mi primer modelo en #Django

En una de las últimas entrega sobre lo que estamos aprendiendo a trabajar con #Django mostramos como sincronizar las bases de datos con Django, a partir del lanzamiento de la versión 1.9 el comando:


$ ./manage.py dbsync

deja de estar en funcionamiento y en su remplazo podemos utilizar

$ ./manage.py migrate

Esto es para tenerlo en cuenta de aquí en adelante y saber el traspaso de algunas funcionalidades. Además cabe aclarar que el comando migrate es una simple sincronización de tus modelos hacia tu base de datos. Este comando examina todos los modelos en cada aplicación que figure en la variable de configuración INSTALLED_APPS del archivo settings.py

El siguiente paso es casi inevitable, comenzar a crear nuestro propio modelo de datos para la aplicación creada llamada cursos.

Para ello les propongo editar el archivo cursos/models.py y agregar la siguiente líneas:

from __future__ import unicode_literals

from django.db import models

class Profesor(models.Model):
        nombre = models.CharField(max_length=30)
        apellido = models.CharField(max_length=40)
        email = models.EmailField()

class Curso(models.Model):
        titulo = models.CharField(max_length=50)
        descripcion = models.CharField(max_length=100)
        fecha_inicio = models.DateField()

Como se observa, dos clases creadas Profesor y Curso con sus correspondientes atributos que la describen. Por el momento y solo por ahora vamos a dejar de lado las relaciones e ir siempre por lo más simple de entender y seguir avanzando.

Como información adicional, podemos recurrir a la documentación de Django para conocer todos los Fields que soporta y las características que pueden incluir.

Que es lo que pasa si ahora intentamos realizar nuevamente la migración?

$ ./manage.py migrate
Operations to perform:
  Apply all migrations: admin, contenttypes, auth, sessions
Running migrations:
  No migrations to apply.

Si fueron atentos a este punto, se habrán dado cuenta que nuestra aplicación cursos no se encuentra dentro de la variable de configuración INSTALLED_APPS y por esa razón al chequear el resto de las aplicaciones y notar que no existe un cambio no lo toma como tal.

Es por ello que agregamos nuestra apps a la variable de la siguiente forma:

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'cursos',
)

$ ./manage.py makemigrations
Migrations for 'cursos':
  0001_initial.py:
    - Create model Curso
    - Create model Profesor

Ahora bien, si ejecutamos el comando migrate todo puede resultar como lo esperamos.

$ ./manage.py migrate
Operations to perform:
  Apply all migrations: admin, cursos, contenttypes, auth, sessions
Running migrations:
  Rendering model states... DONE
  Applying cursos.0001_initial... OK

Dejamos hasta aquí así podemos apuntar a nuevos conceptos en las próximas entregas.

Saludos!

lunes, 14 de diciembre de 2015

Nuevo #WordPress 4.4 "Clifford"

Desde hace unos días, el equipo de desarrolladores de WordPress anunció que se encuentra disponible la nueva versión de WordPress 4.4 llamada "Clifford" en honor al trompetista de jazz Clifford Brown.


WordPress 4.4 introduce por defecto el Theme Twenty Sixteen, que no es más que una versión mederna del clásico theme de blogs.

Otra característica que se agrega son las de las Imágenes Responsivas, con la intención de que todas las imágenes que se visualizan desde WordPress tengan la capacidad de ser responsivas y verse bien desde el dispositivo que se visite, ajustándose automáticamente al tamaño que corresponda.


Finalmente cierra con dos características interesantes, la primera tiene que ver con la posibilidad de embeber contenidos de otras webs con simplemente ingresar una URL en el editor cuando vamos a publicar un post, incluyendo título, descripción, icono del sitio y enlace. La segunda es el nuevo WP REST API, tal y como indica la documentación, "esto indica una nueva era en el desarrollo de WordPress".

A pesar que pasaron unos días del lanzamiento, no podía dejar de recomendar que es posible comenzar a jugar ya con WordPress 4.4 "Clifford".

Saludos!

Enlace | WordPress 4.4 "Clifford"

jueves, 10 de diciembre de 2015

Se encuentra disponible #Django 1.9

A principios de Diciembre y luego de 10 meses y medio de trabajo, el equipo de Django anunció la versión final de Django 1.9


En la documentación del proyecto se encuentra en detalle las nuevas funcionalidades y todos los cambios con los que se encuentra esta versión.

Es por ello que desde nuestro punto de aprendizaje, alentamos a todos los usuarios a comenzar a utilizar esta nueva versión. Recuerden que su actualización por medio de pip resulta muy simple al usuario.

$ sudo pip install --upgrade Django
  Downloading Django-1.9-py2.py3-none-any.whl (6.6MB)
    100% |████████████████████████████████| 6.6MB 54kB/s 
Installing collected packages: Django
  Found existing installation: Django 1.8.7
    Uninstalling Django-1.8.7:
      Successfully uninstalled Django-1.8.7
Successfully installed Django-1.9

$ django-admin version
1.9

Django 1.9 junto a las próximas versiones con correcciones será mantenida hasta Abril del 2017, por otro lado hasta aquí se da por finalizado el soporte a Django 1.7, siendo la versión 1.7.11 la última versión correspondiente a la rama 1.7.x y se invita a los proyectos creados sobre esta versión a migrar a versiones 1.8 TLS o directamente a esta nueva versión 1.9

Saludos!

jueves, 3 de diciembre de 2015

Sincronizar las Bases de Datos en #Django

El próximo paso y siguiendo con el tutorial mientras aprendemos Django es aprovechar la configuración de nuestro proyecto con SQLite y crear por primera vez el archivo con la base de datos.

Figura 1: Sincronizar las Bases de Datos en Django

Esto lo podemos ejecutar de la siguiente forma.

$ ./manage.py dbsync

Figura 2: Ejecución del comando dbsync para la sincronización

Como es la primera vez que estamos sincronizando el esquema de base de datos o para nuestro caso creando el archivo de SQLite nos va a preguntar si queremos crear un superusuario con la posibilidad de administrar la plataforma.

Figura 3: Creación de un superusuario

Si listamos los archivos que generó, podemos ver que se encuentra creado en la raíz de nuestro proyecto un archivo llamado db.sqlite3 que es donde se encuentra el esquema creado.

Podemos realizar una consulta de la siguiente manera:

$ sqlite3 db.sqlite3 
SQLite version 3.7.17 2013-05-20 00:56:22
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Figura 4: Query ejecutada en SQLite

Como podemos observar, Django creo varias tablas e indices automáticamente, toda de las aplicaciones que incluye.

Si nuevamente vamos al archivo settings.py vamos a ver que aplicaciones está cargando nuestro proyecto:

# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
)

El próximo paso es crear un modelo para la aplicación que tenemos, cargarlo en esta configuración y volver a sincronizar nuestra base de datos.

Saludos!

miércoles, 2 de diciembre de 2015

#MongoDB Avanzado en la codemotion 2015

Uno de los videos que me estaba debiendo y que aprovecho la oportunidad para compartirlo a todos se realizó en la última codemotion 2015 los días 27 y 28 de Noviembre.


En esta conferencia, Victor Cuervo nos enseña muchas cosas interesantes sobre #MongoDB con ejemplos y algo de práctica. Otra de las cosas que me gustó mucho además de la dinámica de la charla es su forma de explicar como pasar un modelo relacional SQL a NoSQL. No se lo pierdan!


Saludos!

martes, 1 de diciembre de 2015

#Django y las Bases de Datos

Continuamos aprendiendo algunas cosas interesantes junto al Frameowork #Django, en esta oportunidad nos toca hablar un poco sobre las Bases de Datos.


Afortunadamente, es posible fusionar Django con cuasi cualquier motor de Base de Datos, o por lo menos los más reconocidos en el mercado, tales como MySQL, PosgreSQL, SQLite, SQL Server, Oracle, etc. y todo esto gracias a las implementaciones Modelo/Vista/Controlador en el cuál está creado este Framework.

En el momento que creamos nuestro primer proyecto, Django incluye una configuración básica para el pseudomotor de Base de Datos SQLIte3 y el mismo podemos verlo en el archivo settings.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

En estas configuraciones, podemos observar que ENGINE le indica a Django el motor de base de datos que vamos a estar utilizando, este puede variar de la siguiente forma:


  • django.db.backends.postgresql_psycopg2 (PostgreSQL)
  • django.db.backends.mysql (MySQL)
  • django.db.backends.sqlite3 (SQLite)
  • django.db.backends.oracle (Oracle)


Por otro lado, dentro de este archivo de configuración podemos incorporar más variables de configuración para nuestra base de datos:

NAME la indica a Django el nombre de tu base de datos. Si estás usando SQLite, especifica la ruta completo del sistema de archivos hacia el archivo de la base de datos (por ej. '/home/django/datos.db').

USER le indica a Django cual es el nombre de usuario a usar cuando se conecte con tu base de datos. Si estás usando SQLite, deja este en blanco.

PASSWORD le indica a Django cual es la contraseña a utilizar cuando se conecte con tu base de datos. Si estás utilizando SQLite o tienes una contraseña vacía, deja este en blanco.

HOST le indica a Django cual es el host a usar cuando se conecta a tu base de datos. Si tu base de datos está sobre la misma computadora que la instalación de Django (o sea localhost), deja este en blanco. Si estás usando SQLite, deja este en blanco

Es por ello que si están acostumbrado a trabajar con bases de datos, esto no es más que indicarle a nuestra aplicación las credenciales válidas para poder tener conexión con nuestra base de datos.

Saludos!

jueves, 26 de noviembre de 2015

Como actualizar #Django

Voy a aprovechar que hace unos días se corrigió una vulnerabilidad importante de seguridad en Django para mostrarle como podemos hacer para actualizarla si lo instalamos desde PIP.


Para conocer la información del paquete actual de Django podemos ejecutar el siguiente comando:

$ pip show Django
---
Metadata-Version: 2.0
Name: Django
Version: 1.8.6
Summary: A high-level Python Web framework that encourages rapid development and clean, pragmatic design.
Home-page: http://www.djangoproject.com/
Author: Django Software Foundation
Author-email: foundation@djangoproject.com
License: BSD
Location: /usr/local/lib/python2.7/dist-packages
Requires:

Actualmente ya se encuentra la versión 1.8.7 disponible tal y como fue anunciado en la web del proyecto.

Para lograr actualizarlo podemos ejecutar:

$ pip install --upgrade Django

Collecting Django
  Downloading Django-1.8.7-py2.py3-none-any.whl (6.2MB)
    100% |████████████████████████████████| 6.2MB 59kB/s 
Installing collected packages: Django
  Found existing installation: Django 1.8.6
    Uninstalling Django-1.8.6:
      Successfully uninstalled Django-1.8.6
Successfully installed Django-1.8.7

Y finalizamos el proceso cuando verificamos por medio de la consola interactiva de Python

$ python
Python 2.7.5+ (default, Feb 27 2014, 19:37:08) 
[GCC 4.8.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> print django.get_version()
1.8.7

Muy simple y gracias a las oportunidades que nos brinda pip de mantener nuestro entorno siempre actualizado.

Saludos!

miércoles, 25 de noviembre de 2015

Como crear una aplicación en #Django

Ahora que ya tenemos un proyecto creado en Django, es necesario comenzar a trabajar con Aplicaciones.


Este es un concepto que generalmente tienden a confundirse con los proyectos en Django. Una aplicación podemos definirla como un paquete creado para realizar una funcionalidad en particular dentro de nuestro proyecto, por otro lado un proyecto sería un conjunto de aplicaciones dentro de nuestra web.

A los que trabajamos con Symfony2 podemos hacer una comparativa de las Aplicaciones de Django con los Bundles.

Afortunadamente, Django cuenta con su generador tanto de archivos como de directorios para mantener siempre nuestros proyectos bien organizados y a esto lo podemos ejecutar de la siguiente manera:

$ ./manage.py startapp cursos -v 3

Rendering app template files with extensions: .py
Rendering app template files with filenames: 
Creating Proyectos/Django/elcodigok/cursos/models.py
Creating Proyectos/Django/elcodigok/cursos/tests.py
Creating Proyectos/Django/elcodigok/cursos/__init__.py
Creating Proyectos/Django/elcodigok/cursos/admin.py
Creating Proyectos/Django/elcodigok/cursos/views.py
Creating Proyectos/Django/elcodigok/cursos/migrations/__init__.py

La aplicación que creamos se llama cursos y como vimos, generó un directorio con el mismo nombre y algunos archivos más:

cursos/
    __init__.py
    admin.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py

Como podemos ver, en cada aplicaciones podemos definir las entidades con las que vamos a trabajas, las vistas, url, etc.

Para el próximo paso, vamos a comenzar a trabajar con bases de datos, definiendo los motores que Django soporta y algunos trabajos más con nuestro proyecto.

Saludos!

viernes, 20 de noviembre de 2015

Primeras pruebas con #Symfony 2.8.0-BETA1

Se que por el momento Symfony 2.8.0-BETA1 no es justamente una versión estable para iniciar con un proyecto desde cero, pero que más da, ya se encuentra para comenzar a jugar o por lo menos ir anticipándonos que es lo que la versión 2.8.x y 3.0.x nos va a traer en el futuro y con algo de maduración.


Por eso dije, hoy es el momento de probarlo y ver que encontramos de interesante.

Primero vamos a tener que descarga el instalador de Symfony2 tal y como se recomienda en la web oficial:

$ curl -LsS http://symfony.com/installer -o symfony
$ chmod +x symfony

Siempre es recomendable tener instalada la última versión del instalador

$ ./symfony -V
Symfony Installer version 1.3.3

Todo esta listo para descargar la versión 2.8.0-BETA1 de la siguiente forma

$ ./symfony new pruebaSymfony 2.8


Veamos que nos trae de nuevo los comandos de Symfony2

$ cd pruebaSymfony/
$ php app/console

Y lo que podemos hacer rápidamente es iniciar el servidor para ver el entorno de Dev y su nuevo profiler que Symfony2 nos tiene preparado.

$ php app/console server:run                                            
 [OK] Server running on http://127.0.0.1:8000



Bonito verdad? No dejen de probar sus generadores de Bundle, Entidades y todas las funcionalidades de Doctrine.

Saludos!

jueves, 19 de noviembre de 2015

Como configurar un proyecto de #Django y #Git

Ahora que creamos nuestro proyecto en #Django y estamos investigando es un buen momento para agregar e incorporar al trabajo un sistema de control de versiones como #Git


La idea es que en nuestro entorno de desarrollo tengamos git y de esta forma hacer uso de la siguiente manera:

$ cd elcodigok/
$ git init .
Initialized empty Git repository in /home/dmaldonado/Django/elcodigok/.git/

Sobre este directorio, podemos crear el archivo para que ignore el seguimiento de otros archivos. Si bien no encontré uno adecuado para proyectos en Django, les propongo utilizar uno muy simple para el lenguaje de Python.

$ vim .gitignore

y agregamos las siguientes líneas:

__pycache__/
*.py[cod]
*.log

Ahora bien, solo queda comenzar a realizar el tracking de nuestro proyecto

$ git add .
$ git commit -m "Inicio de un proyecto en Django."
[master (root-commit) cc8de61] Inicio de un proyecto en Django.
 6 files changed, 152 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 elcodigok/__init__.py
 create mode 100644 elcodigok/settings.py
 create mode 100644 elcodigok/urls.py
 create mode 100644 elcodigok/wsgi.py
 create mode 100755 manage.py

Para seguir consultando el árbol de cambios podemos ejecutar:

$ git log --graph --oneline 
* cc8de61 Inicio de un proyecto en Django.

Simple y rápido. Saludos!

miércoles, 18 de noviembre de 2015

La guía definitiva de #Django

Necesitan documentación y material para complementar cada una de las cosas que aprenden en #Django? Este libro es sin duda el indicado por la cantidad de información de calidad que podemos leer.


La guía definitiva de Django "Desarrolla aplicaciones Web de forma rápida y sencilla" excelente material para complementar todas el conocimiento en Django.

En este libro van a encontrar:

PARTE 1 Comenzando con lo básico

  • CAPITULO 1 Introducción a Django
  • CAPITULO 2 Empezando
  • CAPITULO 3 Los principios de las páginas Web dinámicas
  • CAPITULO 4 Plantillas
  • CAPITULO 5 Modelos
  • CAPITULO 6 El sitio de Administración Django
  • CAPITULO 7 Formularios


PARTE 2 Nivel avanzado

  • CAPITULO 8 Vistas avanzadas y URLconfs
  • CAPITULO 9 Plantillas Avanzadas
  • CAPITULO 10 Modelos Avanzados
  • CAPITULO 11 Vistas Genéricas
  • CAPITULO 12 Desplegar Django


PARTE 3 Baterías incluidas

  • CAPITULO 13 Generación de contenido no HTML
  • CAPITULO 14 Sesiones, usuario e inscripciones
  • CAPITULO 15 Cache
  • CAPITULO 16 django.contrib
  • CAPITULO 17 Middleware
  • CAPITULO 18 Integración con Base de datos y Aplicaciones
  • CAPITULO 19 Internacionalización
  • CAPITULO 20 Seguridad
Saludos!

martes, 17 de noviembre de 2015

Mi primer proyecto en #Django

Todo indica que es el momento de comenzar a jugar con Django y las cosas que nos tiene preparado, dijimos que vamos a comenzar a trabajar en un entorno de tipo LAMP donde luego vamos a mostrar como desplegar una app completa de Django. Por el momento vamos por el principio.


Les comentaba que framework como Symfony2, RoR e incluso Django tienen funcionalidades de generador de código por medio del uso de sus comandos.

La primera organización en Django es la creación de un proyecto, es por ello que vamos a buscar algún directorio de trabajo para crear el proyecto.

Para obtener ayuda, vimos que lo podemos hacer de la siguiente forma:

$ django-admin help startproject

usage: django-admin startproject [-h] [--version] [-v {0,1,2,3}]
                                 [--settings SETTINGS]
                                 [--pythonpath PYTHONPATH] [--traceback]
                                 [--no-color] [--template TEMPLATE]
                                 [--extension EXTENSIONS] [--name FILES]
                                 name [directory]

Creates a Django project directory structure for the given project name in the
current directory or optionally in the given directory.

positional arguments:
  name                  Name of the application or project.
  directory             Optional destination directory

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  -v {0,1,2,3}, --verbosity {0,1,2,3}
                        Verbosity level; 0=minimal output, 1=normal output,
                        2=verbose output, 3=very verbose output
  --settings SETTINGS   The Python path to a settings module, e.g.
                        "myproject.settings.main". If this isn't provided, the
                        DJANGO_SETTINGS_MODULE environment variable will be
                        used.
  --pythonpath PYTHONPATH
                        A directory to add to the Python path, e.g.
                        "/home/djangoprojects/myproject".
  --traceback           Raise on CommandError exceptions
  --no-color            Don't colorize the command output.
  --template TEMPLATE   The path or URL to load the template from.
  --extension EXTENSIONS, -e EXTENSIONS
                        The file extension(s) to render (default: "py").
                        Separate multiple extensions with commas, or use -e
                        multiple times.
  --name FILES, -n FILES
                        The file name(s) to render. Separate multiple
                        extensions with commas, or use -n multiple times.

De esta forma creamos nuestro primer proyecto con el nombre de elcodigok

$ django-admin startproject elcodigok -v 3

Rendering project template files with extensions: .py
Rendering project template files with filenames: 
Creating /home/dmaldonado/Proyectos/Django/elcodigok/manage.py
Creating /home/dmaldonado/Proyectos/Django/elcodigok/elcodigok/wsgi.py
Creating /home/dmaldonado/Proyectos/Django/elcodigok/elcodigok/settings.py
Creating /home/dmaldonado/Proyectos/Django/elcodigok/elcodigok/__init__.py
Creating /home/dmaldonado/Proyectos/Django/elcodigok/elcodigok/urls.py

Utilizamos el flag -v para activar el mayor modo verbose para conocer que es lo que está generando. Es así que crea un directorio con el nombre de nuestro proyecto y en el interior el siguiente arbol de directorio.

elcodigok
├───manage.py
└───elcodidok
        settings.py
        urls.py
        wsgi.py
        __init__.py

Anatomía de un proyecto en Django


  • manage.py es un script que ayuda con la administración del sitio. Con ello podremos iniciar un servidor web en nuestro ordenador sin necesidad de instalar nada más, entre otras cosas.
  • El archivo settings.py contiene la configuración de tu sitio web.
  • El archivo urls.py contiene una lista de los patrones utilizados por urlresolver.
  • Ignoremos los otros archivos por ahora - no los cambiaremos. ¡Lo único que debes recordar es no borrarlos por accidente!
Damos un paso más? gracias a la ayuda de manage.py podemos ejecutar nuestro servidor para desde el primer momento jugar con un servidor y esto de la siguiente manera:

$ ./manage.py runserver

Desde un navegador web tal y como o indica la salida del comando anterior podemos ingresar a la dirección http://127.0.0.1:8000/


Saludos!

lunes, 16 de noviembre de 2015

Novedades en Symfony

A pesar que comencé a estudiar algunas cosas con el framework Django como lo están leyendo en entradas anteriores, es prácticamente imposible dejar de lado todas las cosas que están pasando en Symfony.


Hoy nos encontramos con 2 novedades tal y como se estaba esperando, la publicación BETA-1 de las nuevas versiones 2.8.0-BETA1 y 3.0.0-BETA1

Haciendo un fuerte hincapié en la versión 2.8.0-BETA1 con la incorporación de nuevos componentes, mejoras en su gestor de vistas Twig, Inyección de dependencias, Seguridad, el rediseño del WebProfiler y un extenso listado de cambios que los puedes seguir desde aquí.


Por otro lado ya se encuentra disponible una guía de actualización, para saber si tu aplicación web creado con Symfony 2.7.x es compatible con Symfony 2.8 y todas las consideración a tener en cuenta.

Lo mismo pasa con la guía para ver la compatibilidad de Symfony 2.x a la versión Symfony 3.x

Mi recomendación es la siguiente: como vieron en el gráfico de Releases en Symfony las versiones 2.7 y 2.8 se van a extender hasta mediados y fines del 2018 un tiempo realmente extenso de soporte en esas versiones, es por ello que si ya tienen aplicaciones en producción sobre esas versiones a los sumo mi recomendación es pasarla a 2.8-FINAL pero con respecto a la versión 3.x además de que su tiempo va a ser muy corto para una aplicación "grande" podemos hacer varios laboratorios para ir aprendiendo las nuevas características y las cosas que va a traer de interesante.

Por esa razón, a revisar las compatibilidades de nuestros proyectos

miércoles, 11 de noviembre de 2015

#Django en la línea de comandos

Django al igual que otros frameworks como Ruby on Rails o Symfony2 generan código de forma automática y todo esto lo hacen gracias a sus herramientas en la línea de comandos. Maravilloso verdad?


Por ejemplo para tener nuestro primer acercamiento a los comandos de Django podemos escribir:

$ django-admin

Type 'django-admin help <subcommand>' for help on a specific subcommand.

Available subcommands:

[django]
    check
    compilemessages
    createcachetable
    dbshell
    diffsettings
    dumpdata
    flush
    inspectdb
    loaddata
    makemessages
    makemigrations
    migrate
    runfcgi
    runserver
    shell
    showmigrations
    sql
    sqlall
    sqlclear
    sqlcustom
    sqldropindexes
    sqlflush
    sqlindexes
    sqlmigrate
    sqlsequencereset
    squashmigrations
    startapp
    startproject
    syncdb
    test
    testserver
    validate

Mientas vallamos aprendiendo nuevas cosas dentro del framework, vamos a ir viendo todas, o por lo menos la mayoría de las opciones con las que cuenta Django.

En Symfony2, por ejemplo, sus comandos son bastantes similares y permiten la generación de proyecto, Bundle,  conexión con bases de datos, etc En Django a simple vista se puede ver que muchos sub-comandos tiene una funcionalidad similar a su nombre, que son muy descriptivos.

A los que utilizan servidores tipo UNIX quizás se ven más familiarizados a utilizar la línea de comandos, el secreto está simplemente en hacer uso e ir recordando poco a poco herramientas básicas para poder operar todo un sistema operativo desde allí.

Para obtener información adicional, lo primero que vamos a hacer es uso de help y eso se lo recomiendo siempre antes de ejecutarlo.

$ django-admin help

Veamos el siguiente ejemplo práctico:

$ django-admin help shell
usage: django-admin shell [-h] [--version] [-v {0,1,2,3}]
                          [--settings SETTINGS] [--pythonpath PYTHONPATH]
                          [--traceback] [--no-color] [--plain] [--no-startup]
                          [-i {ipython,bpython}]

Runs a Python interactive interpreter. Tries to use IPython or bpython, if one
of them is available.

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  -v {0,1,2,3}, --verbosity {0,1,2,3}
                        Verbosity level; 0=minimal output, 1=normal output,
                        2=verbose output, 3=very verbose output
  --settings SETTINGS   The Python path to a settings module, e.g.
                        "myproject.settings.main". If this isn't provided, the
                        DJANGO_SETTINGS_MODULE environment variable will be
                        used.
  --pythonpath PYTHONPATH
                        A directory to add to the Python path, e.g.
                        "/home/djangoprojects/myproject".
  --traceback           Raise on CommandError exceptions
  --no-color            Don't colorize the command output.
  --plain               Tells Django to use plain Python, not IPython or
                        bpython.
  --no-startup          When using plain Python, ignore the PYTHONSTARTUP
                        environment variable and ~/.pythonrc.py script.
  -i {ipython,bpython}, --interface {ipython,bpython}
                        Specify an interactive interpreter interface.
                        Available options: "ipython" and "bpython"

De esta manera, podemos combinarlo de la siguiente forma

$ django-admin shell --version
1.8.6

Al principio, estoy seguro que a muchos le puede resultar algo confuso y por momentos difícil, pero es cuestión de acostumbrarse un poco y dar algo de práctica.

Saludos!

martes, 10 de noviembre de 2015

Instalar #Django

El siguiente paso para comenzar a jugar con Django es instalar el framework en un entorno de Desarrollo, que como en mi caso es un Kubuntu 15.10 publicado hace muy poquitos días.


Nada mejor que instalar un paquete en Python que hacerlo con la herramienta pip.

pip Es un sistema de gestión de paquetes utilizado para instalar y administrar paquetes de software escritos en Python. Muchos paquetes pueden ser encontrados en el Índice de Paquete de la Python (PyPI). Python 2.7.9 y posteriores (en la serie python2), y Phyton 3.4 y posteriores incluyen pip (pip3 para Phyton3) por omisión.

Hacer uso de pip es sumamente simple, ya que nos permite buscar, instalar y desinstalar paquetes en Python resolviendo todas las dependencias necesarias.

$ pip search nombre-paquete

$ pip install nombre-paquete

$ pip uninstall nombre-paquete

Instalando Django


Lo más recomendable es utilizar pip para instalar Django, ya que nos va a permitir mantenerlo actualizado a la hora de desarrollar nuestros proyectos webs.

Con permisos de root podemos ejecutar el siguiente comando:

$ pip install Django 
Collecting Django
  Downloading Django-1.8.6-py2.py3-none-any.whl (6.2MB)
    100% |████████████████████████████████| 6.2MB 84kB/s 
Installing collected packages: Django
Successfully installed Django-1.8.6

Como se puede ver, pip se encargo de la descarga e instalación de Django en su versión estable 1.8.6, ahora les propongo verificar jugando con la consola de Python

$ python
Python 2.7.5+ (default, Feb 27 2014, 19:37:08) 
[GCC 4.8.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> print django.get_version()
1.8.6

Este es el momento en donde las primeras sonrisas comienzan a aparecer y nos preparamos para lo que va a venir.

Saludos!

lunes, 9 de noviembre de 2015

El Framework #Django

Luego de varias vueltas, decidí comenzar a estudiar en mis tiempos libres a Django un poco más en profundidad y aprovechar la oportunidad para compartir los primeros pasos con el framework.


En este último tiempo, como desarrollo web, utilicé Symfony2 como framework PHP5 y que estoy seguro que me va a servir de base para comprender no solamente el uso de algunos comandos dentro de Django sino también para comprender su modelo MVC y las diferentes capas.

Ahora bien, para comenzar a describir a Django de forma más técnica, se trata de un framework web de código abierto escrito en Python que permite construir aplicaciones web más rápido y con menos código.

Django fue inicialmente desarrollado para gestionar aplicaciones web de páginas orientadas a noticias de World Online, más tarde se liberó bajo licencia BSD. Django se centra en automatizar todo lo posible y se adhiere al principio DRY (Don't Repeat Yourself).

Otras características de Django son:

  • Un mapeador objeto-relacional.
  • Aplicaciones "enchufables" que pueden instalarse en cualquier página gestionada con Django.
  • Una API de base de datos robusta.
  • Un sistema incorporado de "vistas genéricas" que ahorra tener que escribir la lógica de ciertas tareas comunes.
  • Un sistema extensible de plantillas basado en etiquetas, con herencia de plantillas.
  • Un despachador de URLs basado en expresiones regulares.
  • Un sistema "middleware" para desarrollar características adicionales; por ejemplo, la distribución principal de Django incluye componentes middleware que proporcionan cacheo, compresión de la salida, normalización de URLs, protección CSRF y soporte de sesiones.
  • Soporte de internacionalización, incluyendo traducciones incorporadas de la interfaz de administración.
  • Documentación incorporada accesible a través de la aplicación administrativa (incluyendo documentación generada automáticamente de los modelos y las bibliotecas de plantillas añadidas por las aplicaciones).

Actualmente se encuentra en la versión estable Django 1.8.6 liberada en los primeros días de Noviembre de este año, corrigiendo algunos bugs de su versión anterior y dando soporte a Python 3.5

En las próximas entradas, seguramente van a estar relacionadas a Django y todo su ecosistema, desde la instalación básica como los primeros proyectos que se vallan creando.

Saludos!

martes, 27 de octubre de 2015

Kubuntu 15.10

Como era de esperar para este mes de Octubre, ya se encuentra entre nosotros la nueva versión de la distribución Kubuntu 15.10 para descargar e instalar.


Aquellas personas que me sigue, para mi Kubuntu es una gran distribución GNU/Linux basado en Ubuntu y con un entorno KDE muy amigable, evolucionado, fresco y que no solamente me permite trabajar a mi en mis estaciones de trabajo sino también a mi familia.

Los invito a repasar algunas características de este nuevo Kubuntu 15.10

Plasma 5 slick desktop

Considerado como la nueva generación en escritorios basados en KDE, y Kubuntu apuesta fuertemente en incluirlo en esta nueva versión.

KDE Application 15.08

Para los usuarios que estan acostumbrados a esta distribución, incorpora todas las aplicaciones de KDE 15.08 como ser Kontact, Dolphin, Ark, Amarok, Kopete, K3B y tantas otras herramientas que crecieron en la comunidad de KDE.

Sin duda, una nueva versión con muchas mejoras, muchas actualizaciones y que el tiempo le va a ir dando la razón a los aciertos o debilidades que el sistema tenga.


Mi proximo paso es mañana mismo comenzar a descargarlo para rápidamente instalarlo en mis estaciones de trabajo.

Saludos!

Enlace | Kubuntu 15.10

jueves, 20 de agosto de 2015

Nuevo WordPress 4.3 “Billie”

A solo un par de días de una importante actualización de seguridad dentro del core de WordPress, ya se encuentra la versión 4.3 "Billie" final.



Entre alguna de las novedades que encontramos:
  • Personalizador de Menús
  • Personalizador en la barra de herramientas
  • Identidad del sitio (favicon)
  • Páginas sin comentarios por defecto
  • singular.php
  • Se elimina el antiguo modo "sin distracción"
  • y muchas novedades más.
Lo recomendable y lo más sano es mantener todos tus proyectos de WordPress actualizado a esta versión estable y seguir disfrutando de un buen software como WordPress.

Saludos!

Enlace | WordPress 4.3 Billie

jueves, 30 de julio de 2015

Programación Recreativa por @lwayar

Están todos invitados para la presentación del libro "Programación Recreativa" escrito por Luis Wayar @lwayar, un amigo que admiro personal y profesionalmente.

La presentación del libro es el día Viernes 31 de Julio del 2015 a las 18hs en la Universidad Católica de Santiago del Estero D.A.S.S. - Jujuy - Argentina.

"Programación Recreativa" es una interesante obra no solamente de programación en C++ y de matemáticas, sino que además Luis escribió algunos cuentos cortos de lo más interesante.

Otra particularidad de esta obra es que se encuentra bajo licencia Creative Commons (by-sa) de acceso público, por esta razón desde su blog RetroNet está disponible para poder descargarlo!

Yo voy a estar acompañando esta presentación y les voy a compartir luego algunas fotos en este mismo post.

Saludos!

sábado, 11 de julio de 2015

Aprender #Redis en línea

Desde hace tiempo, tanto los lenguajes de programación como algunas de las librerías y bases de datos, adoptaron la posibilidad de probar sus productos en línea, sin la necesidad de instalar algún componente y utilizando una conexión a Internet junto a un simple navegador web.


Redis, en este sentido no es la excepción a la regla, y desde hace tiempo es posible probarlo y al mismo tiempo ir aprendiendo su manejo con una serie de ejemplos para seguir y completar de forma muy interactiva.


Claro que con estas facilidades no pretendan aprender todas las prestaciones que Redis tiene para mejorar los rendimientos ni para utilizar NoSQL, pero sin embargo para primeras pruebas es fantástico y se las recomiendo.

Saludos!

Enlace | Try Redis

viernes, 26 de junio de 2015

#Python y #Redis Cap 1

Redis, un motor de bases de datos NoSQL con todas las características que requiere una implementación de este tipo. Python, un lenguaje de programación soñado.


¿Como hacemos para conectar Python y Redis?

Para realizar este tipo de fusión, requerimos utilizar de un cliente en este caso, desde el lenguaje Python para conectarnos directamente con las keys de Redis, a esta sencilla tarea podemos hacerlo de la siguiente forma.

Lo primero que vamos a hacer es instalar el cliente llamado redis-py haciendo uso de easy_install:

$ easy_install redis

Esto va a llevar apenas unos minutos y nos va a dejar a disposición el módulo redis para poder utilizarlo desde nuestros script en Python.

Ahora queda iniciar Python y hacer uso del nuevo módulo:

$ python
>>> import redis
>>>
>>> dir(redis)
['AuthenticationError', 'Connection', 'ConnectionError', 'ConnectionPool', 'DataError', 'InvalidResponse', 'PubSubError', 'Redis', 'RedisError', 'ResponseError', 'StrictRedis', 'UnixDomainSocketConnection', 'VERSION', 'WatchError', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', '__version__', '_compat', 'client', 'connection', 'exceptions', 'from_url', 'utils']

Lo que podemos hacer ahora es instanciar un cliente de redis desde nuestro Python de la siguiente forma:

>>> cr = redis.Redis()
>>>
>>> dir(cr)
['RESPONSE_CALLBACKS', '__class__', '__contains__', '__delattr__', '__delitem__', '__dict__', '__doc__', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_zaggregate', 'append', 'bgrewriteaof', 'bgsave', 'bitcount', 'bitop', 'blpop', 'brpop', 'brpoplpush', 'client_kill', 'client_list', 'config_get', 'config_set', 'connection_pool', 'dbsize', 'debug_object', 'decr', 'delete', 'echo', 'eval', 'evalsha', 'execute_command', 'exists', 'expire', 'expireat', 'flushall', 'flushdb', 'from_url', 'get', 'getbit', 'getrange', 'getset', 'hdel', 'hexists', 'hget', 'hgetall', 'hincrby', 'hincrbyfloat', 'hkeys', 'hlen', 'hmget', 'hmset', 'hset', 'hsetnx', 'hvals', 'incr', 'incrbyfloat', 'info', 'keys', 'lastsave', 'lindex', 'linsert', 'llen', 'lock', 'lpop', 'lpush', 'lpushx', 'lrange', 'lrem', 'lset', 'ltrim', 'mget', 'move', 'mset', 'msetnx', 'object', 'parse_response', 'persist', 'pexpire', 'pexpireat', 'ping', 'pipeline', 'pttl', 'publish', 'pubsub', 'randomkey', 'register_script', 'rename', 'renamenx', 'response_callbacks', 'rpop', 'rpoplpush', 'rpush', 'rpushx', 'sadd', 'save', 'scard', 'script_exists', 'script_flush', 'script_kill', 'script_load', 'sdiff', 'sdiffstore', 'set', 'set_response_callback', 'setbit', 'setex', 'setnx', 'setrange', 'shutdown', 'sinter', 'sinterstore', 'sismember', 'slaveof', 'smembers', 'smove', 'sort', 'spop', 'srandmember', 'srem', 'strlen', 'substr', 'sunion', 'sunionstore', 'time', 'transaction', 'ttl', 'type', 'unwatch', 'watch', 'zadd', 'zcard', 'zcount', 'zincrby', 'zinterstore', 'zrange', 'zrangebyscore', 'zrank', 'zrem', 'zremrangebyrank', 'zremrangebyscore', 'zrevrange', 'zrevrangebyscore', 'zrevrank', 'zscore', 'zunionstore']

Finalmente para terminar este primer capítulo podemos consultar todas las keys del servidor redis de la siguiente manera:

>>> cr.keys()

La idea es seguir aprendiendo e implementando cosas interesantes que hoy por hoy las podemos ejecutar desde Python y jugar con motores como Redis.

Saludos!


viernes, 19 de junio de 2015

Como cerrar un issue en GitHub

GitHub en estos últimos años se convirtió en más que un sistema de control de versión, pasando a ser una completa plataforma colaborativa, donde verdaderamente podemos realizar todo el tracking junto al desarrollo de un sistema o la creación de una documentación.


Los issues son conocido como unidades de trabajo que normalmente se crean para contribuir a la mejora de un software o reportar algún tipo de problema.

Lo más interesante es que es posible desde un mensaje de un commit lograr cerrar un issue cuando subimos nuestros cambios a GitHub, y eso lo podemos hacer escribiendo las siguientes palabras:

  • close
  • closes
  • closed
  • fix
  • fixes
  • fixed
  • resolve
  • resolves
  • resolved

Para cerrar con un ejemplo, suponemos que estamos trabajando para cerrar un issue cuyo número es el 66, para ello podemos escribir el siguiente mensaje en el commit:

$ git commit -m "Nueva funcionalidad close #66"

y ahora cuando realicemos el correspondiente push, vamos a ver que ese issue automáticamente va a quedar cerrado.

$ git push origin master

Una funcionalidad muy simple y que podemos aplicarla en todo momento.

Saludos!

miércoles, 17 de junio de 2015

#Python - quitar los espacios en cadenas

Soluciones simples para problemas simples, esa es la filosofía del lenguaje Python y de muchos lenguajes de programación. Es que a estas alturas existe muchos problemas simples que ya tienen solución.


Para este caso, mientras trabajaba en unos scripts en Python, me resultaba muy cómodo poder limpiar unos string que recibía de una query y para ello nada mejor que hacerlo de la siguiente manera utilizando los métodos strip(), lstrip() y rstrip():

>>> texto = "  este es un texto con espacios  "
>>> texto.strip()
"este es un texto con espacios"

>>> texto.lstrip()
"este es un texto con espacios  "

>>> texto.rstrip()
"  este es un texto con espacios"

Esta es la forma como con Python las cosas son mucho más simples.

Saludos!

lunes, 15 de junio de 2015

¿Qué es REST?

Si estas en el mundo del desarrollo y diseño web, este es un concepto que no se te puede pasar por alto. No se trata de un concepto nuevo, ya que está con nosotros hace más de 15 años, sino que quizás es un concepto que se ha vuelto popular gracias a la utilización de algunos framework del lado del Frontend.

La Transferencia de Estado Representacional (Representational State Transfer) o REST es un estilo de arquitectura software para sistemas hipermedia distribuidos como la World Wide Web. El término se originó en el año 2000, en una tesis doctoral sobre la web escrita por Roy Fielding, uno de los principales autores de la especificación del protocolo HTTP y ha pasado a ser amplia mente utilizado por la comunidad de desarrollo.


Por otro lado, encontré un muy bonito recurso audiovisual de Jesús Conde, donde explica de forma tan simple REST y RESTful


Saludos!

Entradas populares