Mostrando postagens com marcador Python. Mostrar todas as postagens
Mostrando postagens com marcador Python. Mostrar todas as postagens

sexta-feira, 24 de janeiro de 2025

Subindo um servidor http local para listar e mostrar arquivos de um diretório em python

 INTRODUÇÃO

Em muitas aplicações e testes na programação de aplicações ou integração de sistemas, as vezes, necessitamos subir um servidor http num diretório especifico. E ao chamar esse servidor web no browser, queremos ver a lista de arquivos no diretório e clicar nos links para baixar os próprios arquivos do diretório que foi mapeado pelo web server.

Mas, para um usuário comum, isso seria meio que "ridículo", pois no próprio sistema operacional (OS), seja Windows, Linux ou Mac, o próprio OS mostra isso na sua própria interface. Porém quando estamos fazendo integrações entre sistemas e queremos otimizar tarefas, para o sistema em si, é mais prático usar a mesma arquitetura de comunicação (via WEB) pois a aplicação já deve chamar outros endpoints em REST/JSON, SOAP/XML e essa integração seria mais fácil tendo esse servidor mapeando diretórios.

Por outro lado, a aplicação em qualquer linguagem, pode acessar o sistema de arquivos (File System) do próprio OS para ler esses diretórios, mas vamos adotar uma arquitetura única de comunicação usando WEB. Para isso, podemos subir um servidor em várias linguagens, mas vamos mostrar uma ferramenta em python para subir em pouquissimos minutos.


DESENVOLVIMENTO

Entre no console/terminal em linha de comando, acesse a pasta desejada (comandos como cd, ls, pwd). Na pasta desejada execute o seguinte comando:

python -m http.server

ou

python3 -m http.server


RESULTADOS

O comando anterior vai abrir um servidor web em python e ficará disponível na porta 8000.

Para isso, basta acessar o browser e digitar 

http://localhost:8000/

O resultado deverá mostrar a lista de arquivos daquele diretório desejado.

Para finalizar o servidor é só dar CTRL+C ou fechar o terminal que o servidor web será finalizado.


MAIS CONFIGURAÇÕES

Para poder mudar a porta e mais configurações, execute o comando de ajuda abaixo:

python -m http.server --help


CONCLUSÃO

Conseguimos subir um servidor web em python de forma rápida para testes. Além do python, podemos usar também configurar um agente no Apache Flume em https://logging.apache.org/flume/

Mas esse projeto da Apache será movido para: https://logging.apache.org/dormant.html


domingo, 15 de agosto de 2010

Distribuindo Aplicação Java usando linguagem de script

Nesse artigo, explicaremos como criar uma aplicação Java, usar uma linguagem de script embutida através do uso da JSR-223 e distribui-la junto com as suas dependências, como arquivos ".jar", scripts e outros recursos para que possa ser uma aplicação standalone.

Primeiramente, vamos usar o IDE Eclipse Helios (versão 3.6) com o suporte a Python instalado. Criamos um Projeto Java com o nome de "JavaScriptEmbedded" como mostram as figuras a seguir:





Agora criaremos o arquivo Test.java para poder acessar os scripts das linguagens de scripts como mostra abaixo:

Arquivo Test.java
----------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;


public class Test {

/**
* @param args
*/
public static void main(String... args) {

if(args.length < 2) {
throw new IllegalArgumentException("Precisa fornecer a linguagem de script usada e o arquivo do script!");
}

ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager.getEngineByName(args[0]);

if(scriptEngine == null) {
throw new IllegalArgumentException("Suporte para a linguagem de script " + args[0] + " inexistente");
}

String script = buildScript(args[1]);

List doubleList = new ArrayList(args.length - 2);
for (int i = 2; i < args.length; i++) {
doubleList.add(Double.parseDouble(args[i]));
}

scriptEngine.put("doubleList", doubleList);

try {
scriptEngine.eval(script);

} catch (ScriptException e) {
e.printStackTrace();
}
}

public static String buildScript(String file) {
try {
Reader reader = new BufferedReader(new FileReader(file));

return getString(reader);

} catch (FileNotFoundException e) {
e.printStackTrace();

} catch (IOException e) {
e.printStackTrace();
}

return "";
}

public static String getString(Reader reader) throws IOException {
int read = reader.read();
Collection charList = new LinkedList();

while (read != -1) {
charList.add((char) read);
read = reader.read();
}

StringBuffer strBuffer = new StringBuffer(charList.size());

for (Character character : charList) {
strBuffer.append(character);
}

return strBuffer.toString();
}
}

----------------------------------------------------------------------------

A idéia principal desse arquivo ".java" é o usuário fornecer dois parâmetros na linha de comando, um indica o nome da engine da linguagem de script usada e o arquivo da linguagem de script usado.
Esse nome é obtido pelo método "getEngineName()" do objeto da classe ScriptEngineFactory que por sua ver, é uma das fabricas de engines que são obtidas pelo método "getEngineFactories()" do objeto da classe ScriptEngineManager. Mais informações, veja no seguinte artigo desse mesmo blog:
http://josepojr.blogspot.com/2010/01/introducao-java-scripting-api-jsr-223.html

Por exemplo, para a linguagem Python teriamos os seguintes argumentos:
Argumento 1 - "python"
Argumento 2 - "scripts/Script.py"

No projeto Java criado, vamos criar um diretório chamado "scripts" aonde estarão os scripts a serem executados pela JSR-223. Nesse artigo, vamos trabalhar com a linguagem Python, portanto, criamos o arquivo "script.py" para a linguagem Python. Para mais detalhes veja a figura a seguir:




Além dos dois parâmetros fornecidos ao programa Java em linha de comando, os demais parâmetros que devem ser númericos, serão usados para o cálculo da média pelo script.

Arquivo - Script.py
----------------------------------------------------------------------------

auxList = list(doubleList)

sum = 0

for num in auxList:
sum += num

if(len(auxList) > 0):
print u'A média: ' + str(sum/len(auxList))
----------------------------------------------------------------------------

Configuração da Execução de Aplicação Java

O objetivo dessa etapa é construir uma configuração que será usada dentro do Eclipse para executar o programa Java criado e também, para numa outra etapa ser usado na exportação do programa Java em arquivo Jar. Nas figuras a seguir, veremos como construir a configuração de execução de programas Java no Eclipse.














Exportando aplicação Java em arquivo Jar


Nessa etapa, vamos configurar e exportar o projeto Java para um arquivo Jar, como mostram as figuras a seguir:









Agora que temos o arquivo Test.jar gerado e armazenado no diretório /home/user/JavaExport conforme foi descrito nas figuras anteriores, precisamos copiar os seguintes diretórios dentro do diretório raiz da instalação Jython para o diretório /home/user/JavaExport

- Lib
- extlibs


A pasta scripts também deve ser copiada para /home/user/JavaExport, lembrando que dentro dessa pasta de scripts deve estar o arquivo Script.py.

Agora, vamos criar o arquivo run.sh (para Linux) ou run.bat (para Windows). O conteúdo do arquivo run.sh (ou run.bat) será o seguinte comando:

java -jar Test.jar python scripts/Script.py 10 20 30 40 50

Também, o arquivo run.sh deve possuir permissão para ser executado, para isso, execute o seguinte comando:

chmod a+x run.sh

Esse comando diz que todos (proprietário, membro do grupo e outros) terão permissão para executar run.sh.

Para executar o arquivo run.sh digite o seguinte comando:

./run.sh


Se ocorrer algum erro, pode usar a opção -verbose para listar todas as classes carregadas, como mostra abaixo:

java -verbose -jar Test.jar python scripts/Script.py 10 20 30 40 50


Com as pastas Lib, extlibs, scripts e arquivos Test.jar, run.sh e run.bat dentro do diretório /home/user/JavaExport, podemos distribuir a aplicação Java sempre transportando todo o conteúdo da pasta JavaExport.


Referências:

Linguagem Python:
http://www.python.org/

Plugin Python para Eclipse:
http://pydev.org/

sábado, 20 de fevereiro de 2010

Embutindo Python em Aplicação C - Exemplo Simples

Nesse artigo mostraremos como embutir uma aplicação python no código C. Para isso, usamos o IDE Eclipse 3.4 (GANYMEDE) com o CDT (Plugin do eclipse para trabalhar com a linguagem C/C++) instalado. Também, estamos usando o python versão 2.6.4. O python possui uma ferramenta chamada "python-config" que permite simplificar a compilação e linkagem de código C/C++ junto com os cabeçalhos e bibliotecas C do python.
Para usar o eclipse, crie um projeto em linguagem C, depois, selecione o projeto criado na visão "Project Explorer" e clique com o botão direito e assim aparecerá um menu de opções. Nesse menu selecione "Properties" ou pode-se usar o atalho "ALT+ENTER" apartir do projeto C selecionado.
Veja na figura abaixo a configuração do cabeçalho para compilar o projeto C com os cabeçalhos da API C do python.



Veja na figura abaixo a configuração das bibliotecas para linkar o projeto C com as bibliotecas da API C do python.



Depois disso, crie um arquivo ".c" (no projeto C criado) que está mostrado abaixo:
----------------------------------------------------------------------------------------

/*
============================================================================
Name : PythonEmbeded.c
Author : user
Version :
Copyright : Your copyright notice
Description : Hello World in C, Ansi-style
============================================================================
*/

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <python.h>


int main(int argc, char *argv[]) {

Py_Initialize();

PyObject* modname_main = PyString_FromString("__main__");

PyObject* main_module = PyImport_Import(modname_main);

PyObject* globals = PyModule_GetDict(main_module);

PyObject* locals = PyDict_Copy(globals);

PyRun_String("import __main__\nprint dir(__main__)\nprint 'Hello python!!'\n", Py_file_input, globals, locals);

Py_Finalize();

return 0;
}

----------------------------------------------------------------------------------------


Depois disso, compile e ligue ("linkagem") do programa C e execute normalmente.

Para iniciar o interpretador do python, é feita a chamada a função Py_Initialize() e para finalizar a execução do interpretador é chamado a função Py_Finalize(). Entre essas chamadas (de inicializar e finalizar interpretador python) podemos executar o código python através do uso da função PyRun_String, cujo argumento do tipo char * é uma string (estilo C) representando o código python a ser executado.

sábado, 30 de janeiro de 2010

Invocação de funções e métodos do Python no Java (JSR-223)

Funções e métodos definidos no python podem ser invocados através da interface javax.script.Invocable. No Jython, essa interface é implementada também na mesma classe que implementa as interfaces javax.script.ScriptEngine e javax.script.Compilable. Portanto, é só chamar a fábrica de ScriptEngine para o python e obtendo uma instância de javax.script.ScriptEngine, fazer uma coerção para javax.script.Invocable. Abaixo temos dois exemplos para invocação de função definida no código fonte python no Java.

Observação: Se a função / método invocado não existirem no código python executado, será lançada um exceção java.lang.NoSuchMethodException indicando que não existe a função / método invocado.


Primeiro exemplo - Invocando função python que foi executado pelo método "eval" de javax.script.ScriptEngine
--------------------------------------------------------------------------------
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class PythonInvocableTest {

/**
* @param args
* @throws
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager
.getEngineByName("python");

if (scriptEngine != null) {

try {
scriptEngine
.eval("def imprimeTest(str): \n return str + u' Método invocado!' ");
} catch (ScriptException e) {
e.printStackTrace();
}

if (scriptEngine instanceof Invocable) {
Invocable invocable = (Invocable) scriptEngine;

Object object = null;

try {
object = invocable.invokeFunction("imprimeTest",
"oi jython!!");

} catch (ScriptException e1) {
e1.printStackTrace();

} catch (NoSuchMethodException e1) {
e1.printStackTrace();
}

if (object instanceof String) {
String str = (String) object;
System.out.println("Retorno do método: " + str);
}
}
}

System.out.println("Terminado com sucesso!!");
}
}

--------------------------------------------------------------------------------


Segundo exemplo - Invocando função python que foi executado pelo método "eval" de javax.script.Compilable
--------------------------------------------------------------------------------
import javax.script.Compilable;
import javax.script.CompiledScript;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class PythonInvocableTest2 {

/**
* @param args
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager
.getEngineByName("python");

if (scriptEngine != null) {

if (scriptEngine instanceof Compilable) {
Compilable compilable = (Compilable) scriptEngine;

CompiledScript compiledScript = null;

try {
compiledScript = compilable
.compile("def imprimeTest(str): \n return str + u' Método invocado!'");

} catch (ScriptException e) {
e.printStackTrace();
}

if (compiledScript != null) {

try {
compiledScript.eval();

} catch (ScriptException e) {
e.printStackTrace();
}
}
}

if (scriptEngine instanceof Invocable) {
Invocable invocable = (Invocable) scriptEngine;

Object object = null;

try {
object = invocable.invokeFunction("imprimeTest",
"oi jython!!");

} catch (ScriptException e1) {
e1.printStackTrace();

} catch (NoSuchMethodException e1) {
e1.printStackTrace();
}

if (object instanceof String) {
String str = (String) object;
System.out.println("Retorno do método: " + str);
}
}
}

System.out.println("Terminado com sucesso!!");
}
}

--------------------------------------------------------------------------------


Terceiro exemplo - Invocando método da classe "A" definido no código python usando um objeto python.
--------------------------------------------------------------------------------
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class PythonInvocableTest3 {

/**
* @param args
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager
.getEngineByName("python");

if (scriptEngine != null) {

try {
scriptEngine
.eval("class A:\n def imprimeTest(self, str): \n return str + u' Método invocado!' + unicode(self.__class__()) \na = A()");
} catch (ScriptException e) {
e.printStackTrace();
}

if (scriptEngine instanceof Invocable) {
Invocable invocable = (Invocable) scriptEngine;

Object objectPython = scriptEngine.get("a");

Object object = null;

try {
object = invocable.invokeMethod(objectPython,
"imprimeTest", "oi jython!!");

} catch (ScriptException e1) {
e1.printStackTrace();

} catch (NoSuchMethodException e1) {
e1.printStackTrace();
}

if (object instanceof String) {
String str = (String) object;
System.out.println("Retorno do método: " + str);
}
}
}

System.out.println("Terminado com sucesso!!");
}
}

--------------------------------------------------------------------------------

Executando código compilado Python no Java (JSR-223)

A biblioteca Jython implementa as especificações da API Java Scripting (JSR-223) e por isso, permite compilar código python para execução futura. Para isso, a implementação da interface javax.script.ScriptEngine fornecida pela Jython também implementa a interface javax.script.Compilable que fornece dois métodos para compilar o código fonte python que são:

public CompiledScript compile(String script) throws ScriptException;
public CompiledScript compile(Reader script) throws ScriptException;

Esses dois métodos permite compilar um código fonte em forma de java.lang.String ou java.io.Reader e com isso, retorna-se um objeto da classe abstrata javax.script.CompiledScript que permite fazer as chamadas aos métodos para executar o código compilado fonte como os seguintes métodos:

public Object eval() throws ScriptException
public Object eval(Bindings bindings) throws ScriptException
public abstract Object eval(ScriptContext context) throws ScriptException

Abaixo temos um código exemplo de como funciona a compilação de código fonte Python no Java.

---------------------------------------------------------------------------------------

import javax.script.Compilable;
import javax.script.CompiledScript;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class PythonCompileTest {

/**
* @param args
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager
.getEngineByName("python");

if (scriptEngine != null) {

if (scriptEngine instanceof Compilable) {
Compilable compilable = (Compilable) scriptEngine;

CompiledScript compiledScript = null;

try {
compiledScript = compilable
.compile("a = [] \nprint 'oi jython!!!'");

} catch (ScriptException e) {
e.printStackTrace();
}

if (compiledScript != null) {

try {
compiledScript.eval();

} catch (ScriptException e) {
e.printStackTrace();
}
}
}
}

System.out.println("Terminado com sucesso!!");
}
}

---------------------------------------------------------------------------------------

sábado, 23 de janeiro de 2010

Acessando variáveis do Java no Python

Podemos "enviar" os objetos do Java para o Python e através desse, podemos usar objetos Java como se fossem objetos do Python. Para isso, basicamente usamos o método "put" da interface javax.script.ScriptEngine. Nesse método, passamos o primeiro parâmetro o nome (java.lang.String) e o segundo parâmetro, passamos um objeto (java.lang.Object). Esse nome (primeiro parâmetro) será usado no python para acessar o objeto passado no segundo parâmetro.

Execute o exemplo abaixo:

--------------------------------------------------------------------------------------

import java.util.ArrayList;
import java.util.HashMap;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

/**
*
*/
public class JavaToPython {

/**
* @param args Argumentos.
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager.getEngineByName("python");

if(scriptEngine != null) {
Object object[] = new Integer[3];
object[0] = new Integer(3);
object[1] = new Integer(4);
object[2] = new Integer(5);


scriptEngine.put("a", new Integer(3));
scriptEngine.put("b", new Double(3.45));
scriptEngine.put("c", new String("hello jython"));
scriptEngine.put("d", object);
scriptEngine.put("e", new ArrayList());
scriptEngine.put("f", new HashMap());

try {

scriptEngine.eval("print type(a), a");
scriptEngine.eval("print type(b), b");
scriptEngine.eval("print type(c), c");
scriptEngine.eval("print type(d), tuple(d)");
scriptEngine.eval("print type(e), list(e)");
scriptEngine.eval("print type(f), dict(f)");

} catch (ScriptException e) {
e.printStackTrace();
}
}
}
}

--------------------------------------------------------------------------------------

O objeto de nome "a" passado no método "put" é do tipo java.lang.Integer que no python equivale ao tipo "int".

O objeto de nome "b" passado no método "put" é do tipo java.lang.Double que no python equivale ao tipo "float".

O objeto de nome "c" passado no método "put" é do tipo java.lang.String que no python equivale ao tipo "unicode".

O objeto de nome "d" passado no método "put" é um array do tipo java.lang.Integer que no python equivale ao tipo "array.array". Mas no exemplo, podemos transformar o tipo "array.array" no tipo "tuple" que é um tipo mais usual no python.

O objeto de nome "e" passado no método "put" é do tipo java.util.ArrayList que no python equivale ao tipo "java.util.ArrayList". Mas no exemplo, podemos transformar o tipo "java.util.ArrayList" no tipo "list" que é um tipo mais usual no python.

O objeto de nome "f" passado no método "put" é do tipo java.util.HashMap que no python equivale ao tipo "java.util.HashMap". Mas no exemplo, podemos transformar o tipo "java.util.HashMap" no tipo "dict" que é um tipo mais usual no python.

Acessando variáveis do Python no Java

Para acessar variáveis do Python no Java basicamente usamos o método "get" da interface javax.script.ScriptEngine. Esse método, retorna um java.lang.Object cujo tipo está relacionado ao tipo usado no Python. Veja o exemplo abaixo:

-----------------------------------------------------------------------------------

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

/**
*
*/
public class PythonToJava {

/**
* @param args Array de argumentos.
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager.getEngineByName("python");

if(scriptEngine != null) {

try {
scriptEngine.eval("a=3 \nb=3.45 \nc=u'hello jython' \nd=3, 4, 5 \ne=[] \nf={}");

} catch (ScriptException e) {
e.printStackTrace();
}

Object object[] = new Object[6];

object[0] = scriptEngine.get("a");
object[1] = scriptEngine.get("b");
object[2] = scriptEngine.get("c");
object[3] = scriptEngine.get("d");
object[4] = scriptEngine.get("e");
object[5] = scriptEngine.get("f");

for (int i = 0; i < object.length; i++) {
System.out.println("object[" + i + "]: " + object[i].getClass());
}
}

System.out.println("Terminado com sucesso!!");
}
}

-----------------------------------------------------------------------------------

Se o Jython, Java e Python estiverem instalados corretamente, veremos a seguinte saída no console:


-----------------------------------------------------------------------------------
object[0]: class java.lang.Integer
object[1]: class java.lang.Double
object[2]: class java.lang.String
object[3]: class org.python.core.PyTuple
object[4]: class org.python.core.PyList
object[5]: class org.python.core.PyDictionary
Terminado com sucesso!!
-----------------------------------------------------------------------------------

O objeto "object[0]" retornado equivale ao tipo java.lang.Integer que é uma classe empacotadora de inteiros.

O objeto "object[1]" retornado equivale ao tipo java.lang.Double que é uma classe empacotadora de número de ponto flutuante de precisão dupla.

O objeto "object[2]" retornado equivale ao tipo java.lang.String que é uma cadeia de caracteres unicode.

O objeto "object[3]" retornado equivale ao tipo org.python.core.PyTuple que é uma classe que implementa a interface java.util.List. Mas, lembrando que esse tipo equivale ao tipo "tuple" no Python que é uma lista somente no modo leitura. Portanto, ao usar os métodos "add", "addAll", "clear", "remove", "removeAll", "retainAll" e "set" da interface java.util.List sobre a implementação org.python.core.PyTuple, retorna uma exceção java.lang.UnsupportedOperationException indicando que a operação não é suportada, pois tenta alterar a lista (org.python.core.PyTuple). Portanto, só deve ser usado os métodos de "leitura" da classe java.util.List.

O objeto "object[4]" retornado equivale ao tipo org.python.core.PyList que é uma classe que implementa a interface java.util.List.

O objeto "object[5]" retornado equivale ao tipo org.python.core.PyDictionary que é uma classe que implementa a interface java.util.concurrent.ConcurrentMap que por sua vez implementa a interface java.util.Map.


Veja na figura abaixo o mapeamento dos objetos Python para o Java.

Usando o Jython com a Java Scripting API (JSR-223)

O Jython permite usar o Python no Java e vice-versa. Permite rodar script em python usando a máquina virtual do Java.


INSTALAÇÃO


Primeiramente, precisa estar instalado o JDK 6 e o Python.
Para isso, acesse:

http://www.python.org/
E baixe a última versão do python (2.6.4 a última versão desde na edição desse artigo) e depois faça a instalação.

http://java.sun.com/javase/downloads/index.jsp

Baixe a última versão da versão 6 do Java (1.6.18 a última versão na edição desse artigo) e depois faça a instalação.


Tendo os ambientes de desenvolvimento Java e Python instalados, agora prosseguimos com a instalação de Jython. Para isso, acesse o site: http://www.jython.org/ e baixe a última versão (2.5.1 na edição desse artigo).

Depois feita a instalação, precisamos referenciar Jython no PATH, lembrando que o PATH para a execução de programas utilitários do Jython estão dentro da pasta bin do diretório raiz de instalação do Jython. Assim, se o Jython foi instalado no diretório /usr/local/jython2.5, então o caminho a ser usado no PATH do sistema operacional é /usr/local/jython2.5/bin.

Da mesma maneira, precisamos referenciar o arquivo "jython.jar" que está no diretório raiz da instalação do Jython no CLASSPATH. Por exemplo, se o Jython foi instalado no diretório /usr/local/jython2.5.1, o caminho a ser usado no CLASSPATH é /usr/local/jython2.5.1/jython.jar.


EXEMPLO

Depois de instalado o JDK 6, Python e Jython, execute o exemplo abaixo:

-----------------------------------------------------------------------------------------

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

/**
*
*/
public class PythonTest {

/**
* @param args
*/
public static void main(String[] args) {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager.getEngineByName("python");

if(scriptEngine != null) {

try {
scriptEngine.eval("a = [] \nprint 'oi jython!!!' ");

} catch (ScriptException e) {
e.printStackTrace();
}

}

System.out.println("Terminado com sucesso!!");
}
}

--------------------------------------------------------------------------------------
Se tudo estiver corretamente instalado, o resultado que será mostrado no console deverar ser:

oi jython!!!
Terminado com sucesso!!