jueves, 23 de diciembre de 2010

wxPython: Crear un editor simple, en Python

Hola. En este post os presento un editor de texto básico escrito en Python y wxPython, para que veáis el funcionamiento, cómo se heredan clases de las wx, así como el uso de la impresión en wxPython.

El código, como siempre, se puede descargar del repositorio de este blog, en:

https://sites.google.com/site/elviajedelnavegante/codigo

Fichero editor_ejemplo.zip.

Estamos hablando de un editor de texto, no de un procesador de texto, por tanto no podemos incluir texto enriquecido ni nada parecido. Es lo más parecido al bloc de notas de Windows, pero escrito en Python y wxPython.

Se implementa un sistema de impresión, en donde podemos encontrar la configuración de página, vista preliminar de impresión e impresión directa.

Algunas capturas de pantalla de la aplicación a continuación:





































Cosas que faltan...

En la impresión, no se hace un wrapper del texto, es decir, no se tienen en cuenta los márgenes, por lo que si no se incluyen retornos de línea (Enter) el texto se saldrá del área de impresión. Esto habría que arreglarlo...

Saludos.

pyLorca en pruebas...

Hola. Esta tarde he publicado pyLorca, un software para crear clases Python a partir de sintaxis Yaml. Bien, este programa está en fase de desarrollo, y dicho desarrollo lo he hecho en Windows. Se supone que Python funciona bien tanto en Windows como en Linux, sin apenas hacer cambios.

Hay veces que hay que hacer cambios...

He tenido un primer problema con las codificaciones, ya que en Windows tenía una estructura de constantes de cadenas con la u delante y en Linux me ha dicho que nada de nada. El problema surge al pedir la ayuda de la aplicación, mediante python pyLorca.py -h. En principio, para Linux, da un problema de codificación.

¿Dónde lo arreglamos?



Simplemente omitiendo las u:


Ahora ya funciona la ayuda:


El problema está en Windows, donde si no ponemos la u, salen caracteres extraños, aunque tengamos utf-8 configurado en el módulo y en el sitecustomize.py. La verdad que no se donde puede estar el fallo (...bueno, sí que lo sé, es de Microsoft).

Si eres usuario de Linux y no te funciona la ayuda por un tema de codificación, únicamente tienes que hacer los cambios que he comentado.

Saludos.

pyLorca: Diseño y diagrama de clases, en Python

Hola. En este post os presento una pequeña aplicación, desarrollada en Python, para diseñar clases en Python de manera rápida, mediante sintaxis Yaml, y con la opción de poder visualizarlo gráficamente, al estilo UML, aunque no es UML. Este software se puede descargar del site de El viaje del navegante:

https://sites.google.com/site/elviajedelnavegante/codigo

Los requisitos para que funcione pyLorca (a día de hoy) es tener instalado pyYAML, que podéis descargar desde su página web, http://pyyaml.org/. Opcionalmente, si se quiere utilizar el entorno gráfico, se ha de tener instalado wxPython, que se puede conseguir en http://www.wxpython.org/.

Al grano...

Con pyLorca de lo que se trata es crear código ó partes de código que normalmente se repiten a la hora de crear clases bases, de las cuales más tarde se heredará (o no). La cuestión es crear, en un fichero Yaml, las especificaciones de las clases y opcionalmente sus atributos, métodos y propiedades, así como comentarios. Automáticamente se generará un fichero Python con el código resultado de dicha especificación.

¿Por qué Yaml? Pues porque tiene una sintaxis fácil de leer y comprensible, apta para poder ser manipulada de manera rápida. Esta es la principal baza de crear scripts en Yaml: poder diseñar jerarquías de clases de manera sencilla y muy rápida.

Un ejemplo sencillo...

Imagina que estás diseñando un problema... defines ciertas clases e identificas sus atributos. Claro, a dichos atributos se les tiene que poder asignar un valor y devolver dicho valor. Bien, podríamos utilizar propiedades en este caso. Otros atributos quizás no interese que sean propiedades, pero como buen programador quieres que sean atributos ocultos. Evidentemente, las clases tienen métodos. ¿La mejor manera de representar esta información? Vamos a verlo...

Se nos plantea un problema que está definido por una clase, padre, que tiene ciertos atributos que podrían accederse como propiedades, esto es, se les aplicará un get y un set. Hay otra clase, hijo, que hereda de la clase padre, y que tiene propiedades suyas. Podríamos escribirlo tal que así:

clase: padre
propiedades: 
  - altura
  - peso
  - edad
  - etnia
clase: hijo
hereda_de: padre
propiedades:
  - color_ojos

Bien, si esto lo escribimos en código Python tendríamos algo parecido a esto:

class padre(object):


    # Constructor
    def __init__(self):
        self.__altura = None
        self.__peso = None
        self.__edad = None
        self.__etnia = None


    # Getters
    def __getAltura(self):
        return self.__altura
    def __getPeso(self):
        return self.__peso
    def __getEdad(self):
        return self.__edad
    def __getEtnia(self):
        return self.__etnia


    # Setters
    def __setAltura(self, altura):
        self.__altura = altura
    def __setPeso(self, peso):
        self.__peso = peso
    def __setEdad(self, edad):
        self.__edad = edad
    def __setEtnia(self, etnia):
        self.__etnia = etnia


    # Properties
    altura = property(fget = __getAltura,fset = __setAltura)
    peso = property(fget = __getPeso,fset = __setPeso)
    edad = property(fget = __getEdad,fset = __setEdad)
    etnia = property(fget = __getEtnia,fset = __setEtnia)


class hijo(padre):


    # Constructor
    def __init__(self):
        padre.__init__(self)
        self.__color_ojos = None


    # Getters
    def __getColor_ojos(self):
        return self.__color_ojos


    # Setters
    def __setColor_ojos(self, color_ojos):
        self.__color_ojos = color_ojos


    # Properties
    color_ojos = property(fget = __getColor_ojos,fset = __setColor_ojos)

Bien, como podemos observar hay una pequeña diferencia de número de líneas de código entre la notación de arriba y la de abajo, en Python. Pues bien, la primera notación es sintaxis Yaml.


pyLorca lo que hace es, a partir de un fichero con la notación Yaml, generar en un fichero Python (.py) el segundo código expuesto.

Un ejemplo algo más completo

El fichero de configuración Yaml tiene dos secciones diferenciadas, una para la configuración del código que se genera en el fichero .py y otra compuesta por un conjunto de documentos que identifican a cada una de las clases que estamos definiendo. ¿Difícil? Más sencillo ahora...

Fichero Yaml con todos los parámetros posibles:

# YAML
fichero_python_a_generar:
comentario:
indentacion:
prefijo_clases:
---
clase:
hereda_de:
propiedades:
atributos:
metodos:
comentario:
...

La primera sección, como podemos ver, sirve para configurar el nombre del fichero Python que se generará, un comentario que se incluirá al principio del módulo, el nivel de indentación que se quiere para el código y un prefijo que se puede incluir en el nombre de las clases cuando se generan.

La segunda sección se denomina conjuntos de documentos. Vemos que podemos definir el nombre de la clase, de qué clase ó clases hereda, la lista de propiedades, la lista de atributos, la lista de métodos y un comentario sobre lo que hace dicha clase.

Si queremos definir 2 clases, tendremos que tener dos documentos:

---
clase:
hereda_de:
propiedades:
atributos:
metodos:
comentario:
---
clase:
hereda_de:
propiedades:
atributos:
metodos:
comentario:
...

Fijarse que un documento (definición de clase) se separa de otro mediante tres guiones ---. Además, para terminar se los documentos utilizamos tres puntos ....

Ahora que sabemos la teoría vamos a crear el mismo ejemplo de antes, pero algo más completo. Decir que no es necesario escribir todos los elementos ó campos Yaml, aunque sí que es obligatorio escribir al menos un elemento para definir las dos secciones.

Fichero ejemplo_navegante.yaml:

# YAML
fichero_python_a_generar: ejemplo_navegante.py
comentario: |
  Este es el módulo de prueba de pyLorca, 
  escrito para el blog de El viaje del navegante.
indentacion: 6
prefijo_clases: base
---
clase: padre
propiedades:
  - altura
  - peso
  - edad
  - etnia
comentario: |
  Esta es la clase padre, de la cual
  hereda la clase hijo.
---
clase: hijo
hereda_de: padre
propiedades:
  - color_ojos
comentario: | 
  Este es un ejemplo de una clase que hereda
  de otra clase.
...

Código generado en el fichero ejemplo_navegante.py:

# -*- coding: utf-8 -*-

'''
Código generado por pyLorca v0.0.1
Fecha creación: 2010-12-23
Definición: Este es el módulo de prueba de pyLorca, 
escrito para el blog de El viaje del navegante.
'''

class base_padre(object):
      '''
      Esta es la clase padre, de la cual
      hereda la clase hijo.
      '''

      # Constructor

      def __init__(self):
            self.__altura = None
            self.__peso = None
            self.__edad = None
            self.__etnia = None

      # Getters

      def __getAltura(self):
            return self.__altura

      def __getPeso(self):
            return self.__peso

      def __getEdad(self):
            return self.__edad

      def __getEtnia(self):
            return self.__etnia

      # Setters

      def __setAltura(self, altura):
            self.__altura = altura

      def __setPeso(self, peso):
            self.__peso = peso

      def __setEdad(self, edad):
            self.__edad = edad

      def __setEtnia(self, etnia):
            self.__etnia = etnia

      # Properties

      altura = property(fget = __getAltura,fset = __setAltura)
      peso = property(fget = __getPeso,fset = __setPeso)
      edad = property(fget = __getEdad,fset = __setEdad)
      etnia = property(fget = __getEtnia,fset = __setEtnia)

class base_hijo(base_padre):
      '''
      Este es un ejemplo de una clase que hereda
      de otra clase.
      '''

      # Constructor

      def __init__(self):
            base_padre.__init__(self)

            self.__color_ojos = None

      # Getters

      def __getColor_ojos(self):
            return self.__color_ojos

      # Setters

      def __setColor_ojos(self, color_ojos):
            self.__color_ojos = color_ojos

      # Properties

      color_ojos = property(fget = __getColor_ojos,fset = __setColor_ojos)

Vale... comentamos lo que hemos hecho. En el fichero Yaml hemos indicado que queríamos que el código Python tuviera una indentación de código de 6 espacios en blanco, que las clases tuvieran un prefijo con el vocablo "base", y que al principio del módulo incluyese un comentario: "Este es el módulo de prueba de pyLorca, escrito para el blog de El viaje del navegante." Ver también que se incluye en el fichero .py el tipo de codificación utf-8, así como una reseña que el código ha sido generado por pyLorca y la fecha de generación.

Con respecto a la definición de las clases, hace exactamente lo que hemos indicado. La clase padre tiene una serie de propiedades (get y set) que hemos diseñado y se ha generado todo el código correspondiente para su utilización, además de un comentario al principio de la clase. La clase hijo, tal como se ha especificado, hereda de la clase padre (mira el __init__), además de tener otras propiedades suyas (...decir propiedades propias suena redundante...).

Sintaxis Yaml

La sintaxis Yaml es muy sencilla, es por ello que he escogido este sistema para definir las clases y no otros, como XML, que resulta algo más tedioso de leer y escribir. Con Yaml es como si hiciéramos la lista de la compra. En San Google hay multitud de manuales sobre Yaml, pero aquí os indico cómo definir ficheros Yaml para pyLorca, que de verdad que es muy fácil.

En el inicio del fichero Yaml incluir la etiqueta siguiente:
#YAML

Una cadena de información es una etiqueta, dos puntos, espacio y el valor de esa etiqueta.
etiqueta: información de la etiqueta

Una lista de parámetros es una etiqueta y dos puntos, y en las líneas siguientes, dos espacios, guion, espacio, elemento de la lista:
lista:
  - elemento1
  - elemento2

Un comentario es una etiqueta con dos puntos, espacio, carácter |, y en las líneas siguientes, dos espacios y el comentario, que se puede dividir en varias líneas, pero al iniciar cada línea, siempre con dos espacios en blanco.
comentario: |
  Comentario de El viaje del navegante
  para los usuarios de Python.

Cosas a tener en cuenta. Mucho cuidado con los espacios en blanco, hay que dejarlos tal como comento, ya que de lo contrario Yaml no funciona, es muy estricto en este tema, al igual que Python con la indentación de código.

Bien, en pyLorca, los elementos propiedades, atributos y metodos son listas. Los elementos comentario son comentarios. Los demás son elementos de cadena.

NOTA IMPORTANTE: Para gente que ya conozca Yaml puede resultar extraño cómo me refiero a algunos elementos, pero este post está orientado al público en general. Perdonad mi simpleza...

Más cosas...

En la definición del fichero Yaml hay elementos que puedes obviar ó no. Por ejemplo, si defines una clase que no hereda de nadie, no es necesario incluir hereda_de:. Aunque si o haces no pasa nada. Incluso si escribes hereda_de: object sigue sin pasar nada. Con esto quiero decir que pyLorca es flexible a la hora de buscar información, pero ten en cuenta que lo que escribas tiene que ir en perfecta sintaxis Yaml.

El ejemplo más completo, herencia múltiple, ¡¡¡más madera!!!

Ahora vamos a incluir todos los parámetros de configuración en un ejemplo y además, vamos a incluir otra clase, para comprobar que pyLorca soporta herencia múltiple.

El fichero Yaml tiene el siguiente contenido:

# YAML
fichero_python_a_generar: ejemplo_navegante.py
comentario: |
  Este es el módulo de prueba de pyLorca, 
  escrito para el blog de El viaje del navegante.
indentacion: 6
prefijo_clases: base
---
clase: padre
propiedades:
  - altura
  - peso
  - etnia
atributos:
  - dinero
metodos:
  - jugar_con_peque
comentario: |
  Esta es la clase padre, de la cual
  hereda la clase hijo.
---
clase: madre
hereda_de: object
propiedades:
  - nivel_inteligencia
atributos:
  - saber_estar
  - cordura
metodos:
  - trabajar
  - amar
comentario: |
  Clase que define a la madre
  que es la reina.
---
clase: hijo
hereda_de: padre, madre
propiedades:
  - color_ojos
atributos:
  - edad
metodos:
  - jugar_con_osito 
comentario: | 
  Esta clase hereda de papá y mamá
  y se hará mayor y grande.
...
Y pyLorca lo interpreta y genera dentro del fichero ejemplo_navegante.py lo siguiente:

# -*- coding: utf-8 -*-

'''
Código generado por pyLorca v0.0.1
Fecha creación: 2010-12-23
Definición: Este es el módulo de prueba de pyLorca, 
escrito para el blog de El viaje del navegante.
'''

class base_padre(object):
      '''
      Esta es la clase padre, de la cual
      hereda la clase hijo.
      '''

      # Constructor

      def __init__(self):
            self.__altura = None
            self.__peso = None
            self.__etnia = None

            self.__dinero = None

      # Métodos

      def jugar_con_peque(self): pass

      # Getters

      def __getAltura(self):
            return self.__altura

      def __getPeso(self):
            return self.__peso

      def __getEtnia(self):
            return self.__etnia

      # Setters

      def __setAltura(self, altura):
            self.__altura = altura

      def __setPeso(self, peso):
            self.__peso = peso

      def __setEtnia(self, etnia):
            self.__etnia = etnia

      # Properties

      altura = property(fget = __getAltura,fset = __setAltura)
      peso = property(fget = __getPeso,fset = __setPeso)
      etnia = property(fget = __getEtnia,fset = __setEtnia)

class base_madre(object):
      '''
      Clase que define a la madre
      que es la reina.
      '''

      # Constructor

      def __init__(self):
            self.__nivel_inteligencia = None

            self.__saber_estar = None
            self.__cordura = None

      # Métodos

      def trabajar(self): pass
      def amar(self): pass

      # Getters

      def __getNivel_inteligencia(self):
            return self.__nivel_inteligencia

      # Setters

      def __setNivel_inteligencia(self, nivel_inteligencia):
            self.__nivel_inteligencia = nivel_inteligencia

      # Properties

      nivel_inteligencia = property(fget = __getNivel_inteligencia,fset = __setNivel_inteligencia)

class base_hijo(base_padre,base_madre):
      '''
      Esta clase hereda de papá y mamá
      y se hará mayor y grande.
      '''

      # Constructor

      def __init__(self):
            base_padre.__init__(self)
            base_madre.__init__(self)

            self.__color_ojos = None

            self.__edad = None

      # Métodos

      def jugar_con_osito(self): pass

      # Getters

      def __getColor_ojos(self):
            return self.__color_ojos

      # Setters

      def __setColor_ojos(self, color_ojos):
            self.__color_ojos = color_ojos

      # Properties

      color_ojos = property(fget = __getColor_ojos,fset = __setColor_ojos)

¿Cómo llamar a pyLorca?

pyLorca funciona en modo texto, simplemente escribiendo python pylorca.py -h tendremos la ayuda en línea de cómo funciona. Si ya tenemos creado nuestro fichero Yaml, python pylorca.py fichero.yaml y genera el fichero Python descrito dentro del fichero Yaml. Si queremos que pyLorca nos genere de forma automática una plantilla, python pylorca.py -p fichero.yaml. Más información en la ayuda.






 pyLorca en modo gráfico... 

pyLorca también tiene la posibilidad de trabajar en modo gráfico, si se tiene instalado wxPython 2.8.11 ó versión compatible. Se invoca mediante python pylorca.py -g.


El funcionamiento gráfico es mucho más intuitivo, si cabe, que en modo texto. Podemos cargar ficheros Yaml desde el botón de que vemos abajo (Fichero conf. YAML). Una vez cargado podemos generar el diagrama gráficamente (botón Generar diagrama) y/o generar el código Python (botón Generar código Python), el cual podemos previsualizar una vez generado. También podemos editar el código Yaml haciendo click en el botón Editor. Como se puede observar podemos imprimir los diagramas que hagamos (botones de impresión).




Una última consideración... ó dos...

Hay veces en las cuales el atributo (no propiedad) de una clase es una instanciación de otra clase. pyLorca lo contempla. Es más, se pueden inicializar los atributos ó propiedades en el propio fichero Yaml. Así por ejemplo, para el siguiente fichero Yaml tenemos:

# YAML
fichero_python_a_generar: ejemplo2.py
---
clase: ubicacion
propiedades:
  - direccion
  - poblacion
  - provincia
  - cp
---
clase: persona
atributos:
  - nombre
  - apellidos
  - nif
---
clase: usuario
hereda_de: persona
propiedades:
  - clave_acceso = 123456
atributos:
  - direccion = ubicacion()
...

Darse cuenta del atributo direccion de la clase persona, el cual está inicializado con una instanciación de la clase ubicacion. Gráficamente pyLorca lo representa de la siguiente forma:


El código Python, generado en el fichero ejemplo2.py, es el siguiente:

# -*- coding: utf-8 -*-

'''
Código generado por pyLorca v0.0.1
Fecha creación: 2010-12-23
'''

class ubicacion(object):

    # Constructor

    def __init__(self):
        self.__direccion = None
        self.__poblacion = None
        self.__provincia = None
        self.__cp = None

    # Getters

    def __getDireccion(self):
        return self.__direccion

    def __getPoblacion(self):
        return self.__poblacion

    def __getProvincia(self):
        return self.__provincia

    def __getCp(self):
        return self.__cp

    # Setters

    def __setDireccion(self, direccion):
        self.__direccion = direccion

    def __setPoblacion(self, poblacion):
        self.__poblacion = poblacion

    def __setProvincia(self, provincia):
        self.__provincia = provincia

    def __setCp(self, cp):
        self.__cp = cp

    # Properties

    direccion = property(fget = __getDireccion,fset = __setDireccion)
    poblacion = property(fget = __getPoblacion,fset = __setPoblacion)
    provincia = property(fget = __getProvincia,fset = __setProvincia)
    cp = property(fget = __getCp,fset = __setCp)

class persona(object):

    # Constructor

    def __init__(self):

        self.__nombre = None
        self.__apellidos = None
        self.__nif = None

class usuario(persona):

    # Constructor

    def __init__(self):
        persona.__init__(self)

        self.__clave_acceso = 123456

        self.direccion = ubicacion()

    # Getters

    def __getClave_acceso(self):
        return self.__clave_acceso

    # Setters

    def __setClave_acceso(self, clave_acceso):
        self.__clave_acceso = clave_acceso

    # Properties

    clave_acceso = property(fget = __getClave_acceso,fset = __setClave_acceso)

¿Cómo se ha programado pyLorca?

pyLorca era al inicio un conjunto de ficheros, donde cada módulo desempeñaba su papel: vista, pyyaml,  tratamiento de sintaxis, editor. Lo he juntado todo en un único fichero por simple comodidad por parte del usuario.

La parte gráfica de pyLorca, escrita en wxPython, utiliza OGL para el diseño de las cajas divididas. Las rutinas de impresión las he sacado de la Demo de wxPython. Es más, si entráis en el código veréis algunas partes (muy pocas) comentadas en inglés, y es porque las he sacado iguales a las originales. Lo importante de aprender wxPython es fijarse en el código, ver y comprender cómo funciona, para poder modificarlo y hacer lo que nosotros queremos que haga.

Mejoras...

Esta aplicación debe de tener muchos bugs, que conforme pase el tiempo iré detectando y corrigiendo. Como mejoras para la siguiente versión caben destacar:
- Creación gráfica de clases.
- Creación gráfica de relaciones entre clases.
- Generación de código Yaml a partir de la creación gráfica de clases.
- Wrapper a la impresión de texto y gráficos, ya que no se controlan los márgenes.

CONCLUSIONES

pyLorca es una aplicación escrita en Python, para crear scripts Python, que utiliza ficheros de sintaxis Yaml para generarlos. Sirve para diseñar con muy pocas líneas de código y en una sintaxis muy fácil, clases y relaciones, para generar el consiguiente código Python.

Saludos.

miércoles, 22 de diciembre de 2010

wxPython: herencia, parámetros y otras hierbas con wxFormBuilder, en español

Hola. Continuando con la serie de posts sobre wxPython y wxFormBuilder vamos a ver ahora cómo pasar información entre widgets, así como la utilización de la herencia entre objetos y otras cosas. El ejemplo completo (muy comentado) está en el repositorio de El viaje del navegante:


El fichero es Gestión de almacén.zip.

Lo que vamos a construir es una pequeña aplicación que va a simular un gestor de almacén específico, con familias, modelos y submodelos de productos. Además se incluye un sistema de reports (informes) en HTML. La aplicación es muy sencilla, lo que da mucho juego a la hora de completarla. Es más, incluso para guardar los datos en disco se utiliza la persistencia de datos, para ser lo más aséptico posible, y que el propio lector pueda comprender y asimilar lo verdaderamente importante, el uso de los widgets en wxPython y el paso de información entre los mismos. Para ello, hay que tener muy claro el concepto de herencia, ya que para utilizar wxPython es indispensable.

Esta aplicación es para aprender, ya que le faltan muchas cosas, pero lo básico lo tiene. Faltaría por ejemplo estadísticas, control de stock, relación de lotes con sus correspondientes albaranes de entrada, y un sin fin más. La búsqueda de información se podría hacer implementando reports para tal uso, parametrizando la llamada de los mismos. Se deja al lector esta tarea. Aquí únicamente se muestra el camino.

IMPORTANTE: Decir que el ejemplo está muy comentado, por lo que es muy conveniente descargarse el código, para leer los comentarios y poder saber el porqué hago lo que hago.

¿Qué compone el proyecto? De las siguientes partes:

MODELO DE DATOS

clases_gestion_almacen.py: Código generado con pyLorca, una aplicación (escrita por mí) para crear a partir de ficheros Yaml, módulos de clases bases, con propiedades, métodos y atributos.


gestion_almacen_modelo.py: Este módulo contiene las clases que contendrán la información que se guardará en disco y algunas funciones más que nos serán de ayuda. Este modelo importa clases_gestion_almacen.py.

VISTA

gestion_almacen_vista.py: Código generado automáticamente por wxFormBuilder (a través del fichero de proyecto gestion_almacen.fbp), en donde se diseña por completo todo el frontend gráfico de la aplicación. 

APLICACIÓN

gestion_almacen.py: Este módulo importa clases de los demás módulos y es la aplicación principal. Junta el modelo de datos con la vista.

¿Cómo funciona?

Se ejecuta con: python gestion_almacen.py.


Lo primero es crear familias, modelos y submodelos. Nos vamos al menú Clasificación y a insertar datos...


Podemos incluir tantos elementos como queramos. El único requisito es que no pueden repetirse, ya que el sistema no lo permite (un requisito para no tener problemas de duplicidades...).  

Importante: Siempre dar al botón Guardar.

Podemos ver los datos incluidos en el wx.Choice...


Mediante la referencia entre widgets, dichos elementos pasan al frame principal...


También hay que crear los almacenes... Si queremos crear un producto hay que dar valores a todos los campos, y a continuación darle al botón Guardar...


Podemos ver lo que hemos hecho en los informes...


Este tipo de informe es una página html...


¿Dónde se guardan los datos? He utilizado persistencia de datos con cPickle. Se nos generarán los siguientes ficheros...



CONCLUSIONES

En este post se ha presentado un ejemplo para ver cómo se pasan parámetros (información) entre widgets (wx.Choice, etc.). Se ha utilizado pyLorca para la generación de las clases bases, así como wxFormBuilder para la generación íntegra del entorno gráfico. Si no disponemos de un sistema de reports siempre podemos utilizar páginas web para lanzar informes. Se deja al lector la parametrización de los mismos para implementar un sistema de búsqueda. Por último decir que se ha utilizado el módulo cPickle para la persistencia de datos.

Saludos.

martes, 21 de diciembre de 2010

Recursos documentales en la red, y 4

Hola. Como viene siendo habitual en este blog, cada cierto tiempo hago una recopilación de sitios en donde he estado y que me han servido para algo. Fiel a mi costumbre de compartirlo todo (...mmm casi todo), os dejo enlaces en donde encontraréis cosas curiosas (ó no) relacionadas con Python y otras hierbas.

Como siempre, hago una distinción por áreas, para que sea más fácil ir a buscar lo que se quiere encontrar, cosa que no siempre se puede esperar.


PYTHON


Índice de paquetes para Python: Lugar donde se pueden encontrar el listado oficial de paquetes disponibles para Python (módulos de extensión).

Tutoriales de programación y ejemplos de código fuente: Sitio de lo más interesante, ya que no solamente se habla de Python, sino de una gran variedad de lenguajes de programación. Lo bueno de esta web es la cantidad de ejemplos que hay, algo a tener muy en cuenta, ya que para aprender Python, y cualquier lenguaje en general, es necesario ver ejemplos de código reales. Dentro de este sitio podemos encontrar:
Herramientas de desarrollo para Python: Lista de herramientas para desarrollar en Python, esto es, editores, gui's e ide's, del sitio oficial de Python, www.python.org.

Recursos documentales para Python en español: Material, webs y blogs de recursos documentales sobre Python, en español.
Tutoriales para Python - Centro de aprendizaje: Sitio web, en inglés, en donde podemos encontrar recursos para aprender Python, inlcuyendo niveles básico y avanzado.

Tutorial Python: Tutorial, en español, de Python. Creado por PyAr.

El blog de Jesse Noller: Blog de programación Python. Está en inglés, pero este hombre cuenta cosas muy interesantes.

El blog de Mike Driscoll: Blog de un gurú de Python, también en inglés. Muy buenos posts sobre todo lo que escribe Mike. Gracias a monoBOT, ¡por mostrarme el camino del samurai!, supe de la existencia de Mike Driscoll.

Página de Spinecho: Código fuente de aplicaciones Python. Para aprender.

Linux Plátanos: Sitio web en donde encontrar temática GNU y Python.

El libro de Django: Pues eso, el libro online de Django. En inglés.


RAD ESCRITORIO

DABO: Sitio en donde nos encontramos el software Dabo, para crear de manera rápida aplicaciones de escritorio en Python y wxPython.

CAMELOT: Sitio en donde nos encontramos el software Camelot, para crear de manera rápida aplicaciones de escritorio en Python, Qt y SQLAlchemy.

WXPYTHON

Tutorial de sizers: Tutorial, en inglés, de uso de sizers (algoritmo de posicionamiento de widgets) en wxPython. Muy interesante.

La web de Andrea Gavanna: Sitio de Andrea Gavanna, uno de los desarrolladores de widgets para wxPython. Muy buena la sección de software.

Python en un minuto: Blog donde explica muy bien como crear una aplicación wxPython.

INGENIERÍA DEL SOFTWARE

Web de Andy Bulka: Software de patrones de diseño y UML.Cabe destacar la aplicación PyNsource, que crea un diseño gráfico UML a partir de código Python.

Tigris: Herramientas de ingeniería del software de código abierto.

Case Tools: Sitio web en donde se pueden encontrar cantidad de herramientas CASE.

Pymerase: Herramienta para diseño de modelo de objetos, en Python.

Modeling Languages: Sitio web de analistas, diseñadores y arquitectos de software. Muy interesante e instructivo. En español. Recomendado. Me quedo con la cita del principio de esta página web:
Se supone que el Modelado de Software es una de las actividades más importantes en cualquier proceso de desarrollo del software. Al menos esta es la creencia entre la comunidad científica de ingeniería del software. Sin embargo, en la práctica del día a día la modelización está considerada, básicamente, una pérdida de tiempo.
SERVICIOS WEB


IMÁGENES

Open Clip Art: Librería de imágenes libre. Muy buena.

Icons Pedia: Librería excepcional de iconos, con varios tamaños. Realmente buena.

Theme world: Sitio web sobre temas de escritorio y wallpapers.

MISCELÁNEA

Comparativas entre lenguajes de programación: Artículo muy bueno de Jason Voegele, sobre una comparativa técnica de los lenguajes de programación actuales, incluido Python, por supuesto. En inglés. Muy bueno. 

Packt Publishing: Editorial técnica de informática. Sección sobre Python impresionante. Muy recomendado.

Small Basic: Proyecto de Microsoft para enseñar/aprender a programar. Bastante interesante.

Proyecto Euler: Conjunto de problemas matemáticos, para ser resueltos mediante algoritmos. Se puede utilizar Python para resolver dichos ejercicios y practicar para aprender. monoBOT así lo ha hecho (y sigue haciendo). Gracias de nuevo Héctor.

Dilandau: Búsqueda y descarga (mp3) de música en Internet.


Saludos.

JUPP: joe de Linux para Windows


Hola. Como ya he comentado en más de una ocasión, trabajo en entornos Windows XP (aunque prefiero Linux Ubuntu). En mi linux siempre he trabajado con el editor de textos joe, y en Windows evidentemente no... sin embargo hace unos meses descubrí JUPP.

JUPP es la versión portable de Joe's Own Editor (joe), uno de los editores de texto-ASCII más antiguos de sistemas Linux. En los tiempos en los que yo programaba en C, en vez de utilizar Emacs ó vi, usaba joe, sobretodo por la utilización de teclas imitando a WordStar, un procesador de textos de los años 80 y 90, que sucumbió, como no, a la serie Office de Microsoft, como tantos otros (WordPerfect, etc).

JUPP es software libre, así que se puede distribuir y modificar bajo los términos de la GNU GPL.

JUPPjoe para Linux) es un editor de texto para consola, donde prima mucho la utilización de teclas para operar sobre bloques de texto. Si eres de mi época, seguro que te acuerdas de las guerras entre los procesadores de textos WordStar, WordPerfect, un tal Word que asomaba la cabeza... y todo en un fantástico entorno MS-DOS (yo utilizaba DR-DOS, de Digital Research, adquirido luego por Novell).

JUPP no es lo ideal para programar, aunque se puede hacer perfectamente (es un editor para programación), no es el ideal para escribir textos y documentación, pero se puede realizar, ... JUPP e simplemente uno de los editores más fáciles de utilizar, donde prima la rapidez, sin complicaciones.

En Linux, solo con invocar joe ya entramos en el editor. Con las conbinaciones de teclas Ctrl+K+H obtenemos la ayuda, que es un cuadro situado arriba de la pantalla. En JUPP, si quieres que aparezca la ayuda tienes que ejecutar en el intérprete de comandos (cmd.exe), jupp -help.


Como se puede observar, con JUPP (joe) podemos operar sobre bloques de código, ir a posiciones a partir del cursor, línea ó fichero , búsqueda, etcétera. Es decir, lo mínimo, utilizando combinaciones de teclas Ctrl+..., rápido y sencillo.

Una de las cosas que tiene realmente buenas JUPP (joe) es que es muy configurable, donde podemos cambiar la matoría de los parámetros en su fichero de configuración jupprc. Más información sobre esto en su ayuda (manpages en Linux, y html en Windows).


INSTALAR JUPP EN WINDOWS

En la página web de jupp podemos encontrar, para entornos Microsoft, dos versiones, una para MS-DOS (jupp 2.8) y otra para Windows (jupp 3.1). Si queremos que jupp reconozca sintaxis Python tendremos que instalar la versión para Windows.

En Linux, joe funciona perfectamente. En Windows hay que hacer algunas cosas. Se descarga desde la siguiente URL:


Nos vamos a la etiqueta Binaries, en el punto jupp 3.x for Unix, sección JOE 3.1jupp14 for Windows. Descargamos el fichero JWIN31E.EXE.


Lo ejecutamos, y se descomprime el ejecutable en una carpeta JWIN31.EXE:


Nos ponemos encima del fichero SETUP.INF, botón derecho y seleccionamos del menú emergente Instalar.


El programa se instala en C:\WINDOWS\system32\joe. Para ejecutarlo hay que ir al intérprete de comandos (cmd.exe) y escribir jupp32.


Esta versión de jupp soporta sintaxis Python, que está en un fichero de configuración joe (JFS), y que se puede encontrar en C:\WINDOWS\system32\joe\syntax\python.jfs. Se puede modificar dicho fichero. Por ejemplo, si se dispone de una versión Python con palabras clave nuevas, se pueden agregar.


También se puede cambiar tanto la indentación, como la codificación  y otros valores en el fichero de configuración jupp32rc, en la sección de Python:


NOTA: Si se te da el caso que trabajando con ficheros .py no puedes escribir acentos, eñes y demás caracteres latinos, prueba a cambiar la codificación en jupp32rc, cambiando utf8 por iso8859, tal que así:


...resumiendo

Gracias a Joseph H. Allen por este programa, tan pequeño, con el que se pueden hacer cosas tan grandes.

La nostalgia y los buenos recuerdos programando en este editor me han hecho escribir este post.

Saludos.