Dia de la Llibertat del Programari al Centre Cívic de Les Corts (BCN)

Avui, dissabte 21 de setembre, és el Software Freedom Day, Dia de la Llibertat del Programari, en català. A Barcelona, com ve sent costum, per aquest motiu es realitzaran diverses conferències i activitats al centre Cívic de les Corts organitzades per Caliu, el Catalan Linux Users goup. Wiki del DLP.

També al Prat de Llobregat es fan actes a l’Uikú Coworking (facebook).

Un altre dels llocs “calents” va ser ¡, ahir, Santa Coloma de Cervelló on “La Komfraria de la Vila del Pingüí” fa diverses activitats avui. Vet aquí el programa. Els “komfrares” fan l’acte un dia abans per a poder participar avui als actes de Barcelona.

És una trobada d’activistes i gent interessada en el programari lliure. Vet aquí la nota de premsa (de la wiki del DLP)que anuncia la diada:

DIA DE LA LLIBERTAT DEL PROGRAMARI A CATALUNYA

“El proper dissabte 21 de setembre se celebra a més de 270 països de tot el món el Dia de la Llibertat del Programari o Software Freedom Day, diada que compta amb lideratge de la Digital Freedom Foundation i el suport d’empreses i organitzacions com Google, Canonical, la Free Software Foundation, Joomla!, FreeBSD o Creative Commons, entre d’altres. En aquesta edició hi haurà sis esdeveniments a Espanya, repartits entre Catalunya (2), Madrid (1), Andalusia (2) i Galícia (1).

La celebració que s’inicià l’any 2004, es realitza any rere any a Catalunya des del 2005 de la mà de Caliu[3], i l’any 2011 s’hi va afegir la Konfraria[4] permetent que la cel·lebració s’allargués en el temps. Com cada any a Catalunya ho celebrarem, i aquest cop començarem divendres 20 per la tarda a La Palma de Cervelló, al Teatre Societat Aliança Palmarenca, i continuarem dissabte 21 a Barcelona, al Centre Cívic de Les Corts. S’ofereixen xerrades, tallers, festa d’instal·lació on usuaris avançats i experts en GNU/Linux oferiran ajuda en instal·lacions de programari lliure i respondran dubtes. Consulteu els enllaços per veure les activitats programades a cada lloc.

El divendres 20 de setembre començarà la celebració a la Palma de Cervelló (Baix Llobregat) a partir de les 17h de la tarda i en diferents indrets: Teatre Aliança Palmarenca, PuntTIC i Biblioteca Municipal (on recentment han migrat els ordinadors del telecentre al sistema operatiu lliure Ubuntu) amb tallers, xerrades i demostracions. La jornada conclourà amb un sopar de germanor. La cel·lebració continuarà el dissabte 21 de setembre a Barcelona al Centre Cívic de les Corts, amb un conjunt de xerrades diverses que ocuparan tota la jornada des de les 10h del matí i fins a les 19h de la tarda. Usuaris avançats i experts en GNU/Linux oferiran ajuda en instal·lacions de programari lliure i respondran dubtes.

Podeu veure totes les activitats a: http://wiki.caliu.cat/index.php/DLP2013 i http://www.konfraria.org/dlp2013/
El Dia de la Llibertat del Programari és una celebració mundial del programari lliure. L’objectiu d’aquesta celebració anual és d’educar el públic general sobre els beneficis d’usar programari lliure d’alta qualitat en l’educació, el govern, a casa, i a les empreses, és a dir, arreu! Imagineu que, després d’uns pocs anys, la tesi que tant de temps us va portar de fer no fos llegible, o que els vostres vídeos familiars no es puguin veure. Si us queixeu a l’empresa de programari, us diran que us gasteu encara més diners en una «actualització», que només resulta ser més lenta i amb més defectes que l’anterior versió. Fins i tot un nou reproductor de música, només per trobar que refusa la música que abans podíeu escoltar en el reproductor antic? Malauradament, la majoria de gent viu en aquest món avui.

El Dia de la Llibertat del Programari existeix per mostrar el públic en general que hi ha una manera de sortir d’aquest cercle viciós. Mitjançant l’ús del programari lliure, obteniu el control sobre el vostre ordinador i les vostres dades. Cada persona té la llibertat de participar i d’usar el programari lliure, ja sigui usant un sistema operatiu completament lliure com el GNU/Linux o una plataforma no-lliure com Windows o Mac OS usant-hi programes lliures.

El Programari Lliure es defineix per les següents llibertats:

0.- La llibertat d’utilitzar el programari per a qualsevol ús.
1.- La llibertat d’estudiar el funcionament del programari, i adaptar-lo a les nostres necessitats. L’accés al codi font és necessari per tal de gaudir d’aquesta llibertat.
2.- La llibertat de redistribuir les còpies.
3.- La llibertat de millorar el programari i de distribuir aquestes millores, de manera que tothom se’n pugui beneficiar. L’accés al codi font és necessari per tal de gaudir d’aquesta llibertat.

Aquestes quatre llibertats que Richard Stallman va escriure l’any 1986 permeten la participació igualitària en l’era de la informació. Un bon exemple n’és la presència de llengües minoritàries en moltes aplicacions de programari lliure.”

#dlp2013

Anuncis

Jython, scripting Python per a la JVM

Introducció

Jython permet executar Python sobre la màquina virtual Java. Jython és Python. Si coneixes Python saps (gairebé) tot el que cal sobre la sintaxi de Jython.

En aquest post parlaré de com fer servir Jython combinat amb Java.

Es pot fer servir Jython amb Java de dues formes principalment:

– Executar Jython des d’aplicacions Java. Aleshores es pot emprar Jython com a llenguatge d’scripting per a les aplicacions Java. L’aplicació Java podrà veure i actuar sobre el objectes de l’interpret Jython que estiguin visibles en l’àmbit.

– Executar classes Java des d’scripts Jython. Jython pot utilitzar tota la immensa quantitat de llibreries i packages java disponibles. Jython a més poder d’importar els packages propis inclosos a la versió 2.5 (o 2.7), pràcticament els mateixos que els disponibles a les versions equivalents de Python, també pot importar packages de java.

Jython afegeix Python a la llista de llenguatges d’scripting per a la Màquina Virtual Java (JVM), juntament amb BeanShell, Groovy, Scala, Clojure, JRuby, Jacl o Rhino (javascript). Jython ofereix un sabor diferent. És un llenguatge amb sintaxi neta i concisa i que ajuda a “fer les coses bé”.

En el post d’avui, provaré els dos camins assenyalats abans:
– com executar jython dins d’aplicacions java
– com executar classes java dins d’un script jython.

Instal·lar Jython

Abans de res, cal tenir instal·lat el Jython. A la distribució de Linux que he fet servir hi ha disponible un paquet .deb (instal·lar amb: sudo apt-get install jython), però que proporciona la versió 2.2 de Jython. He preferit descarregar el paquet jython-installer-2.5.3.jar de http://www.jython.org i instal·lar-lo amb java -jar ython-installer-2.5.3.jar que em proporciona la versió 2.5.3.

A la web de Jython (http://jyhton.org), secció downloads podrem trobar més descàrregues: Actualment la versió estable és la Jython 2.5.3, que correspon a la versió CPyhton 2.5. Hi ha, a més, la beta de Jython 2.7 que correspon a CPython 2.7 i la release candidate de Jython 2.5.4. De moment no està a la vista una versió que correspongui a CPython 3.x.

També és una bona idea descarregar el javadoc.

Com executar Jython dins de Java

Com executar scripts python dins d’aplicacions java? Cap novetat, es tracta d’incloure el jar de Jython i incorporar-lo al classpath.

Un exemple. Primer de tot, creo un projecte java, amb l’estructura:

/home
    /albert
        /workspace
            /prova-jython
                /bin
                /src
                /lib
                /py
                /jar 
                /db

bin: conté les classes Java compilades
src: packages de codi font Java. Conté el package com.fossbcn i la classe ProvaJython.
lib: llibreria, hi poso el jython-2.5.3.jar i el driver jdbc d’SQLite
py: scripts python a executar
jar: el paquet jar amb l’exemple.
db: hi posaré una base de dades sqlite de prova

Anem al codi. Vet aquí la classe java: fa la importació de PythonInterpreter i instancia l’interpret de Jython passant el nom de l’script al paràmetre filename.

package com.fossbcn;

import org.python.util.PythonInterpreter;

public class ProvaJython {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new ProvaJython(args[0]);
    }

    public ProvaJython(String filename) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.execfile(filename);
    }
}

L’script jython és un “hello world” i un llaç for entre 1 i 10. Destacar que cal posar el coding UTF-8 per a poder utilitzar accents i grafismes catalans.

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

print "Hola, això és una prova"
for i in range(1,10):
    print i

Compilo el Java i genero el jar amb el següent build.xml d’ant.

<project name="prova-jython" default="jar" basedir=".">
	<description>
		interfície java-python amb jython
	</description>
	
	<!-- set global properties for this build -->
	<property name="src" value="src" />
	<property name="bin" value="bin" />
	<property name="lib" value="lib" />
	<property name="jar" value="jar" />
	<property name="jarname" value="prova-jython.jar" />
	<property name="MainClass" value="com.fossbcn.ProvaJython" />
	<property name="pythonjar" value="jython-2.5.3.jar" />
	
	<target name="init" depends="clean">
		<!-- Create the time stamp -->
	<tstamp />
	
	<!-- Create the build directory structure used by compile -->
		<mkdir dir="${bin}" />
		<mkdir dir="${jar}" />
	</target>
	
	<target name="compile" depends="init" description="compile the source ">
		<!-- Compile the java code from ${src} into ${bin} -->
		<javac srcdir="${src}" destdir="${bin}" >
			<classpath>
				<fileset dir="lib">
					<include name="**/*.jar" />
				</fileset>
			</classpath>
		</javac>
	</target>
	
	<target name="jar" depends="compile" description="generate the distribution">
		<!-- Put everything in ${bin} into the .jar file -->
		<jar jarfile="${jar}/${jarname}" basedir="${bin}">
			<manifest>
				<attribute name="Main-Class" value="${MainClass}" />
			</manifest>
		</jar>
	</target>
	
	<target name="clean" description="clean up">
		<delete dir="${bin}" />
		<delete dir="${jar}" />
	</target>
</project>

Executant l’ant obtinc a la carpeta jar el fitxer prova-jython.jar.

Per a provar-lo, em situo a la carpeta del projecte, en el meu cas /home/albert/workspace/prova-jython, i faig servir el següent script de bash. Fixar-se que cal posar jython-2.5.3.jar al classpath:

#!/usr/bin/env bash
java -cp jar/prova-jython.jar:lib/jython-2.5.3.jar com.fossbcn.ProvaJython py/hello.py

El resultat de l’execució és:

albert@athena:~/workspace/prova-jython$ prova1.sh 
Hola, això és una prova
1
2
3
4
5
6
7
8
9
albert@athena:~/workspace/prova-jython$ 

Amplio la classe java de prova: en comptes d’executar un script sencer puc executar instruccions de Jython. Al constructor de la classe ProvaJython afegeixo les línies següents:

    public ProvaJython(String filename) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.execfile(filename);

	// afegeixo aquest bloc
        interpreter.exec("print 'al constructor de ProvaJython'");
        interpreter.exec("a = 10");
        interpreter.exec("b = 20");
        interpreter.exec("c = a + b");
        interpreter.exec("print 'a = %d; b = %d; c = %d' % (a,b,c)");
    }

Obtinc el següent:

albert@athena:~/jython/proves-java-jython$ prova1.sh
Hola, això és una prova
1
2
3
4
5
6
7
8
9
al constructor de ProvaJython
a = 10; b = 20; c = 30

També puc recuperar el valor d’una variable de l’intèrpret Jython. Per exemple, per recuperar la variable “c” des del programa Java afegeixo aquest codi:

        int java_var_c = interpreter.get("c").asInt();
        System.out.println("La variable c de jython val: " +  java_var_c);

És dir, Java obté la variable local de l’intèrpret Jython amb “get”. Obté un PyObject i aplica un mètode asInt per transformar al tipus int de Java.

Hi ha un grup de mètodes que permeten convertir les variables locals de l’intèrpret Jython, del tipus PyObject, a tipus propis de Java. Cal consultar al javadoc.

EL camí invers: com estableixo una nova variable entera a l’interpret Jython des de java? amb “set” i la classe PyInteger, que deriva de PyObject. Hi han vàries classes derivades de PyObject que encapsulen els tipus utilitzats dins l’interpret de Jython i que puc utilitzar des del programa java. Com abans, cal tenir a ma el javadoc de Jython.

Vet aquí el codi:

        interpreter.set("d", new PyInteger(1234));
        interpreter.exec("c = a + b + d");
        interpreter.exec("print 'a = %d; b = %d; c = %d; d = %d' % (a,b,c,d)");

i el resultat de l’execució:

albert@athena:~/jython/proves-java-jython$ prova1.sh 
Hola, això és una prova
1
2
3
4
5
6
7
8
9
al constructor de ProvaJython
a = 10; b = 20; c = 30
La variable c de jython val: 30
a = 10; b = 20; c = 1264; d = 1234

Dins l’intèrpret Jython TOT és un objecte. Com que tot és un objecte, tot és una instància de PyObject (o d’una classe derivada de PyObject).

Si vull passar tipus complexos, com instàncies de classes entre l’intèrpret i l’aplicació Java em cal tenir en compte que tot és un PyObject.

Puc seguir el següent esquema per a utilitzar classes Jython des de l’aplicació java.

1. Definir quins mètodes (la interface) ha d’implementar la classe Jython.
Per exemple: una classe Jython “JyPunt”, que permeti establir-ne i obtenir la “posició” expressada amb les coordenades X i Y; i un valor “pes”.

2. Expressar amb una interface java la interface de la classe Jython. Seguint l’exemple, creo el fitxer IPunt.java i el deso a la carpeta src/com/fossbcn/.

package com.fossbcn;

public interface IPunt {
    public void setX(float x);
    public void setY(float y);
    public float getX();
    public float getY();
    public void setMass(float mass);
    public float getMass();
}

3. A continuació, creo una classe Jython que implementi la interface Java que he creat. Com? Jython tracta els packages Java com si fossin mòduls propis de Jython; i permet utilitzar-ne les classes igual com amb Java, però amb les regles de Python.

Tenint en compte això, puc crear una classe Jython que implementi IPunt: JyPunt. Poso aquesta classe en un fitxer que anomeno JyPunt.py (Per conveniència meva. És python i, per tant, no cal que el nom de la classe coincideixi amb el fitxer) i el deso a la carpeta py.

from com.fossbcn import IPunt

class JyPunt(IPunt):
    x = 0
    y = 0
    mass = 0

    def __init__(self, x, y, mass):
	self.x = x
	self.y = y
	self.mass = mass

    def setX(self, x):
        self.x = x
        
    def setY(self, y):
	self.y = y    

    def getX(self):
        return self.x

    def getY(self):
        return self.y
    
    def setMass(self, mass):
        self.mass = mass

    def getMass(self):
        return self.mass

#instancia un objecte de la classe
PuntInterpret = JyPunt(12,24,2000)

4. Obtinc les referències als objectes que viuen a l’intèrpret amb get. La clau: tot és un PyObject.

Al codi de l’aplicació Java primer de tot executo JyPunt.py i, a continuació, obtinc amb get l’objecte PuntInterpret (un PyObject). El darrer pas és transformar el PyObject en un objecte Java amb el mètode tojava.

Un cop l’objecte Jython ha promocionat a objecte Java, el puc fer servir com qualsevol altre.

        // executa l'script Jython que conté la definició de la classe python JyPunt
        interpreter.execfile("/home/albert/jython/proves-java-jython/py/JyPunt.py");
 
        // puc agafar una instància directament de l'interpret
        
        // obtinc la instància JyPunt
        PyObject jyPuntObject2 = interpreter.get("PuntInterpret");
        
        // transformo la instància jython en instància Java
        IPunt puntJava2 = (IPunt) jyPuntObject2.__tojava__(IPunt.class);  
        
        // i en faig servir els mètodes
        System.out.println("\n\nPunt 2");
        System.out.println("PosX: " + puntJava2.getX());
        System.out.println("PosY: " + puntJava2.getY());
        System.out.println("Mass: " + puntJava2.getMass());

Encara més: des de l’aplicació Java puc instanciar la classe Jython i fer-la servir des de Java.

Faig un get de la classe jyPunt i invoco el constructor amb el mètode call.

Passo els arguments del constructor de JyPunt, que també són del tipus PyObject, fent servir les classes derivades adequades al tipus intern de Jython que efectivament es fa servir, en l’exemple, PyInteger.

Un cop he instanciat la classe Jython la puc transformar a objecte Java mitjançant el mètode tojava.

        // obtinc la classe python JyPunt
        PyObject jyPuntClass = interpreter.get("JyPunt");
        
        // instancio la classe Jython des de Java
        PyObject jyPuntObject = jyPuntClass.__call__(new PyInteger(10),   // x
                                                     new PyInteger(45),   // y
                                                     new PyInteger(100)); // mass
        // transformo la instància jython en instància Java
        IPunt puntJava = (IPunt) jyPuntObject.__tojava__(IPunt.class);
        
        // i en faig servir els mètodes
        System.out.println("\n\nPunt 1");
        System.out.println("PosX: " + puntJava.getX());
        System.out.println("PosY: " + puntJava.getY());
        System.out.println("Mass: " + puntJava.getMass())

La classe, finalment queda

package com.fossbcn;

import org.python.util.PythonInterpreter;
import org.python.core.PyObject;
import org.python.core.PyInteger;
import com.fossbcn.IPunt;


public class ProvaJython {
    /**
     * @param args
     */
    public static void main(String[] args) {
        new ProvaJython(args[0]);
    }

    public ProvaJython(String filename) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.execfile(filename);

        interpreter.exec("print 'al constructor de ProvaJython'");
        interpreter.exec("a = 10");
        interpreter.exec("b = 20");
        interpreter.exec("c = a + b");
        interpreter.exec("print 'a = %d; b = %d; c = %d' % (a,b,c)");

        int java_var_c = interpreter.get("c").asInt();
        System.out.println("La variable c de jython val: " +  java_var_c);

        interpreter.set("d", new PyInteger(1234));
        interpreter.exec("c = a + b + d");
        interpreter.exec("print 'a = %d; b = %d; c = %d; d = %d' % (a,b,c,d)");
        
        // executa l'script Jython que conté la definició de la classe python JyPunt
        interpreter.execfile("/home/albert/jython/proves-java-jython/py/JyPunt.py");
 
         // puc agafar una instància directament de l'interpret
        
        // obtinc la instància JyPunt
        PyObject jyPuntObject2 = interpreter.get("PuntInterpret");
        
        // transformo la instància jython en instància Java
        IPunt puntJava2 = (IPunt) jyPuntObject2.__tojava__(IPunt.class);  
        
        // i en faig servir els mètodes
        System.out.println("\n\nPunt 2");
        System.out.println("PosX: " + puntJava2.getX());
        System.out.println("PosY: " + puntJava2.getY());
        System.out.println("Mass: " + puntJava2.getMass());
 
        
        // obtinc la classe python JyPunt
        PyObject jyPuntClass = interpreter.get("JyPunt");
        
        // instancio la classe Jython des de Java
        PyObject jyPuntObject = jyPuntClass.__call__(new PyInteger(10),  // x
                                                     new PyInteger(45),  // y
                                                     new PyInteger(100)); // mass
        // transformo la instància jython en instància Java
        IPunt puntJava = (IPunt) jyPuntObject.__tojava__(IPunt.class);
        
        // i en faig servir els mètodes
        System.out.println("\n\nPunt 1");
        System.out.println("PosX: " + puntJava.getX());
        System.out.println("PosY: " + puntJava.getY());
        System.out.println("Mass: " + puntJava.getMass());    
    }
}

Si compilo i executo amb

java -cp jar/prova-jython.jar:lib/jython-2.5.3.jar com.fossbcn.ProvaJython py/hello.py

Obtinc:

albert@athena:~/jython/proves-java-jython$ prova1.sh 
Hola, això és una prova
1
2
3
4
5
6
7
8
9
al constructor de ProvaJython
a = 10; b = 20; c = 30
La variable c de jython val: 30
a = 10; b = 20; c = 1264; d = 1234


Punt 2
PosX: 12.0
PosY: 24.0
Mass: 2000.0


Punt 1
PosX: 10.0
PosY: 45.0
Mass: 100.0

Utilitzar classes java des de Jython. Un frame Swing.

Ja està dit: Jython tracta els packages Java com si fossin mòduls propis de Jython; i permet utilitzar-ne les classes directament fent servir la sintaxi de Python. Ho he utilitzat abans per importar la interface IPunt i implementar-la amb JyPunt.

Si vull fer una aplicació gràfica, disposo de swing adaptat a la sintaxi de Jython.
Per a desenvolupar l’exemple m’he basat en http://www.jython.org/jythonbook/en/1.0/GUIApplications.html

Es tracta d’un JFrame, amb dos JTextField i dos JButton, en un layout vertical (Y_AXIS).
Un botó copia el contingut del camp de text 1 al camp de text 2; l’altre botó fa el contrari.

Vet aquí el codi, l’he adaptat d’un petita prova que tenia escrita en beanshell:

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

# http://www.jython.org/jythonbook/en/1.0/GUIApplications.html

from javax.swing import JTextField, JButton, JFrame, BoxLayout, WindowConstants

class Gui():
	frame = JFrame("Frame de prova",
	                defaultCloseOperation = WindowConstants.EXIT_ON_CLOSE)
	text1 = JTextField()
	text2 = JTextField()
	button1 = JButton()
	button2 = JButton()

	def txt1_txt2(self, event):
		self.text2.setText(self.text1.getText())
		self.text1.setText("")

	def txt2_txt1(self, event): 
		self.text1.setText(self.text2.getText())
		self.text2.setText("")

	def __init__(self):
		self.button1 = JButton("de text1 a text2", actionPerformed = self.txt1_txt2)
		self.button2 = JButton("de text2 a text1", actionPerformed = self.txt2_txt1)

		pane = self.frame.getContentPane()
		pane.setLayout(BoxLayout(pane, BoxLayout.Y_AXIS))
		pane.add(self.text1)
		pane.add(self.text2)
		pane.add(self.button1)
		pane.add(self.button2)

		self.frame.pack()
		self.frame.visible = True


# inici de l'aplicació
app = Gui()

Executo amb aquesta línia de comandes a la carpeta prova-jython.

jython py/prova-swing.py

o també puc fer servir el jar jython-2.5.3.jar invocat amb java.

java -jar lib/jython-2.5.3.jar py/prova-swing.py

Obtinc aquesta mini aplicació gràfica:

frame

Per acabar aquest punt, crec que pot ser interessant comparar amb el programa original en BeanShell, molt similar a l’equivalent Java. Crida l’atenció com amb Jython m’he estalviat d’implementar la interface ActionListener.

Es pot dir, doncs, que amb Jython “és més senzill” d’implementar.

Jython es pot utilitzar raonablement per a fer prototips ràpids d’aplicacions.

En tot cas, un IDE en condicions (PyDev + Eclipse, per exemple) és imprescindible.

#!/usr/bin/bsh

import javax.swing.*;
import java.awt.event.*;

public class MiniApp implements ActionListener{
    frame = new JFrame("Frame de prova");
    text1 = new JTextField();
    text2 = new JTextField();
    button1 = new JButton("de text1 a text2");
    button2 = new JButton("de text2 a text1");

    public void actionPerformed(ActionEvent e) {
        print("Action performed\n");
        ActionCommand = e.getActionCommand();
        if ("txt1_txt2".equals(ActionCommand)) {
            text2.setText(text1.getText());
            text1.setText("");
        } 

        if ("txt2_txt1".equals(ActionCommand)) {
            text1.setText(text2.getText());
            text2.setText("");
        } 
    } 

    public MiniApp() {
        button1.setActionCommand("txt1_txt2");
        button2.setActionCommand("txt2_txt1");
        button1.addActionListener(this);    
        button2.addActionListener(this);        
        pane = frame.getContentPane();
        pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS));
        pane.add(text1);
        pane.add(text2);
        pane.add(button1);
        pane.add(button2);
        frame.pack();
        frame.setVisible(true);
    }
}

// inici de l'aplicació
new MiniApp();

Utilitzar classes java des de Jython. Taules SQLite.

Si vull accedir a una base de dades, puc fer servir JDBC i els drivers java.

Exemple: He creat una petita base de dades SQLite a la carpeta db, amb una taula diccionari de tres columnes: id numeric; key text; i value text. He posat un parell de files de prova.

He descarregat el driver JDBC d’SQLite3 de https://bitbucket.org/xerial/sqlite-jdbc i l’he desat a la carpeta lib.

Algunes remarques sobre l’script jython de prova:
– Us de from java.lang import Class, per poder utilitzar Class.forName per a la càrrega del driver.
– L’operativa de JDBC replica exactament el que faria amb Java.
– A Python (i Jython) es fa servir None, en comptes de Null

Vet aquí l’script:

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

from java.sql import *  # import JDBC classes
from java.lang import Class

jdbc_url = "jdbc:sqlite:/home/albert/jython/proves-java-jython/db/prova.db"

 # import Sqlite 3 JDBC driver
Class.forName("org.sqlite.JDBC")

# connection, statement, resultset ...
connection = DriverManager.getConnection(jdbc_url)
statement = connection.createStatement()

statement.executeUpdate("drop table if exists person")
statement.executeUpdate("create table person (id integer, name string)")
statement.executeUpdate("insert into person values(1, 'albert')")
statement.executeUpdate("insert into person values(2, 'montse')")
statement.executeUpdate("insert into person values(3, 'artiom')")
rs = statement.executeQuery("select * from person")

print "\n\ntable person:\n"
while rs.next():
    # read the result set
    print "id = %d; name = %s" % (rs.getInt("id"), rs.getString("name"))

rs = statement.executeQuery("select * from dictionary")

print "\n\ntable dictionary:\n"
while rs.next():
    # read the result set
    print "id = %d; key = %s; value = %s" % (rs.getInt("id"), rs.getString("key"), rs.getString("value"))

if not (connection is None):
    connection.close()

Invoco l’execució amb la següent línia de comandes. Al classpath indico el driver de l’SQLite i també el jar de Jython. Remarcar que executo l’interpret de jython amb la classe org.python.util.jython, que rep py/prova-jdbc.py com argument.

#!/usr/bin/env bash
java -cp lib/sqlite-jdbc-3.7.2.jar:lib/jython-2.5.3.jar org.python.util.jython py/prova-jdbc-2.py

El resultat

albert@athena:~/jython/proves-java-jython$ prova3.sh


table person:

id = 1; name = albert
id = 2; name = montse
id = 3; name = artiom


table dictionary:

id = 1; key = key1; value = value1
id = 2; key = key2; value = value2
albert@athena:~/jython/proves-java-jython$ 

Per saber-ne més

La web de Jython és la referència fonamental per estar al dia de les novetats. Com era d’esperar, té un apartat de documentació.

A la mateixa web podem trobar en línia el llibre “The definitive guide to Jython”, que també es pot comprar en paper.

I imprescindible: La Javadoc a la web de Jython