What it does is send a command string through the socket, the command gets executed on the other end and returns the answer.

import os
import socket
 
host = "127.0.0.1"
port = 1234
 
def execute(command):
    result = ""
    args = command.split(" ")
    if args[0] == "cd":
        os.chdir(args[1])
        return "Dir changed"
    pipe = os.popen(command, "r")
    for line in pipe.readlines():
        result += line
    return result
 
def get_and_obey():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    while True:
        command = ""
        while True:
            temp = s.recv(1024)
            command += temp
            if not temp or len(temp) < 1024:
	        break
	if command == "exit":
	    break
        result = execute(command)
	if not result:
	    result = "Error with command"
        s.send(result)
    s.close()
 
if __name__ == "__main__":
    get_and_obey()

import os
import socket
 
host = ''
port = 1234
 
def recv_and_command():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((host, port))
    s.listen(1)
    conn, addr = s.accept()
    print "Receiving and commmanding", addr
    while True:
        command = raw_input("remote>>")
        conn.send(command)
	if command == "exit": 
	    break
        result = ""
        while True:
            temp = conn.recv(1024)
	    result += temp
	    if not temp or len(temp) < 1024:
	        break
        print result
    s.close()
 
if __name__ == "__main__":
    recv_and_command()

I want to write a version that uses the http protocol, and maybe someday I’ll write my own http server

In this case we are simulating three devices:

• An internal memory, written in objective C.
• An LCD device, written in python.
• A joystick driver, written in python.

The interface to the programs is through the memory, and we can add the configuration through a simple file:

[dataflash0]
lib = at91sam9260
sym = dataflash
model = objc
base = 0
size = 2097152
 
[control1]
lib = at91sam9260
sym = Control
model = python
base = 8587830276
port = /dev/input/js0
 
[lcd]
lib = at91sam9260
sym = LcdMx
model = python
config = images.cfg
base = 4294963716

#include <controller.h>
#include <lcd.h>
 
void main() {
	unsigned char *lcd = (unsigned char *)4294963716;
	unsigned char *control1 = (unsigned char *)8587830276;
	unsigned char *control2 = (unsigned char *)8587830272;
	int i;
	char id1;
	char id2;
	char move1;
	char move2;
	id1 = createObject(lcd, 1, 1, 1);
	id2 = createObject(lcd, 2, 1, 1);
	put_char('0' + id1);
	put_char('\n');
	put_char('0' + id2);
	put_char('\n');
	while(1) {
		move1 = readControl(control1);
		move2 = readControl(control2);
		put_char('0' + move1);
		put_char(' ');
		put_char('0' + move2);
		put_char('\n');
		if(move1 != 8)
			move(lcd, id1, readControl(control1), 1);
		if(move2 != 8)
			move(lcd, id2, readControl(control2), 1);
	}
}

If you are interested in the project you can find info here

Ok, so first set up your virtualenv you can check how to do that on my last post if you don’t know (just follow it up to the “source sys/bin/activate”) command.

Now there are two ways to install repoze.bfg, the first one is:

easy_install -i http://dist.repoze.org/bfg/1.2/simple repoze.bfg.jinja2

and the second one is to install it from pypi which is almost the same:

easy_install repoze.bfg.jinja2

Cool isn’t it?

Now to create your repoze.bfg app use paster like this:

paster create -t bfg_jinja2_starter bfgapp

And set it up as a development egg

cd bfgapp
jython setup.py devel

You can test it if you want, running

paster serve bfgapp.ini

And that’s it!! Much easier isn’t it?

Now, let’s look how to put this inside our java webapp, for this we are going to use a WSGI java servlet which is included with jython, it’s called modjy.

First of all copy the jython.jar file inside your WEB-INF/lib directory.

Next add the servlet to your WEB-INF/web.xml file, here is my example web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name>BFGApp</display-name>
    <servlet>
        <servlet-name>modjy</servlet-name>
        <servlet-class>com.xhaus.modjy.ModjyJServlet</servlet-class>
        <init-param>
            <param-name>python.home</param-name>
            <param-value>/home/iamedu/BFG/sys</param-value>
        </init-param>
        <init-param>
            <param-name>cache_callables</param-name>
            <param-value>1</param-value>
        </init-param>
        <init-param>
            <param-name>reload_on_mod</param-name>
            <param-value>1</param-value>
        </init-param>
        <init-param>
            <param-name>log_level</param-name>
            <param-value>debug</param-value>
        </init-param>
        <init-param>
            <param-name>load_site_packages</param-name>
            <param-value>1</param-value>
        </init-param>
        <init-param>
            <param-name>python.executable</param-name>
            <param-value>/home/iamedu/BFG/sys/bin/jython</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>DefaultServlet</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>listings</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>modjy</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>DefaultServlet</servlet-name>
        <url-pattern>/static/*</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
</web-app>

Here there are two important initial parameters for the modjy servlet:

• python.home This one should point to your virtualenv
• python.executable This one should point to your virtualenv’s jython executable

You can see I also defined a “default” servlet, this is because there’s a problem with the modjy servlet managing static resources, and it’s probably faster to manage them directly with the default servlet.

Now to make the static resources accessible to the default servlet, just copy them from the templates/static directory in your BFG app to the web directory inside your java webapp, just copy the default.css file and the images directory don’t copy the whole static directory, unless you want to change your links to something like: “static/static/default.css”

Now we just need to add the wrapper between the modjy servlet and bfg, this is quite easy, create an application.py file inside your web directory with the following contents:

import site
from repoze.bfg.paster import get_app
 
handler = get_app('/home/iamedu/BFG/MyProject/MyProject.ini', 'main')

And now deploy your app and voila!, you have repoze.bfg on you favorite servlet container, you can call your java classes from bfg as it is running in the same Java VM.

We use import site, because the modjy servlet doesn’t load site-packages automatically, and it’s probably a bad idea to write the complete path in the get_app, you should copy it to your webapp’s web directory and get the current work directory.

If you want to package your bfg app inside your java webapp you can copy it to the web directory, everything inside that directory is also in your pythonpath.

Hope this helps somebody!

There must be a lot of java guys who think the same and there are projects like Groovy and Grails endorsed by Sun,  I was impressed to see even a Ruby container in glassfish v3.

I haven’t tried ruby yet so I cannot comment on that, and I wanted to try something simple with jython so I decided to try bfg, my first attempts didn’t work so I asked for help on the bfg developers list, and a loooot of help from Chris McDonough I got it working.

It isn’t soo nice yet, and zcml configuration doesn’t work but at least it’s usable.

Here is how to get it working, since some changes were just made by Chris on the development’s trunk you need subversion and mercurial to get the repos.

First of all get jython I tried this with 2.5.1, it is pretty simple to install it.

Next you need to get setuptools, you can get that from pypi make sure to download the source version (the one that ends with .tar.bz2)

To install it uncompress it, get into the directory and run:

${JYTHONDIR}/bin/jython setup.py install

Since we are going to be testing a lot it’s better to install virtualenv do it with

${JYTHONDIR}/bin/easy_install virtualenv

Now create a folder where you can start working, in this case I’ll assume it’s called BFG

Get into the BFG folder and create a virtual env.

cd BFG
${JYTHONDIR}/bin/virtualenv --no-site-packages sys
source sys/bin/activate

After this you’ll have you virtualenv’s jython and easy_install in your path.

It’s time to download latest versions from repos, and also http://pypi.python.org/packages/source/z/zope.schema/zope.schema-3.5.4.tar.gz this from pypi

svn co http://svn.repoze.org/repoze.bfg/trunk/ repoze.bfg
svn co http://svn.repoze.org/repoze.bfg.jinja2/trunk/ repoze.bfg.jinja2
hg clone http://dev.pocoo.org/hg/jinja2-main jinja2
tar xfvj zope.schema-3.5.4.tar.gz

Now we need to change a few things head into the zope.schema-3.5.4 folder and edit this file src/zope/schema/_bootstrapfields.py

In line 31 you should see something like:

class ValidatedProperty(object):
 
    def __init__(self, name, check=None):
        self._info = name, check
 
    def __set__(self, inst, value):
        name, check = self._info
        if value != inst.missing_value:
            if check is not None:
                check(inst, value)
            else:
                inst.validate(value)
        inst.__dict__[name] = value

Add a __get__ method like this:

class ValidatedProperty(object):
 
    def __init__(self, name, check=None):
        self._info = name, check
 
    def __set__(self, inst, value):
        name, check = self._info
        if value != inst.missing_value:
            if check is not None:
                check(inst, value)
            else:
                inst.validate(value)
        inst.__dict__[name] = value
    def __get__(self, inst, owner):
        name, check = self._info
        return inst.__dict__[name]

Now install zope.schema with:

jython setup.py install

Now get into the jinja2 directory, here you should patch your file with the patch provided below

patch -p1 < jinja2_jython.patch

Now for install jinja2, repoze.bfg and repoze.bfg.jinja2 in that order, for each package just go into the directory and run:

${JYTHONDIR}/bin/jython setup.py install

You can create a project with paster now, but it won’t work right away, because zcml doesn’t work with jython but you can get it working.

Here is a sample project tweaked to work, just download it and run:

paster serve MyProject.ini

I hope this works for you and that you find it useful

MyProject-jython.tar

jinja2_jython.patch

UPDATE Chris just told me that zope.schema now passes tests under jython, so it’s no longer necesarry to change the _bootstrapfields.py file.

Another thing, I forgot to mention that you need to run jython setup.py develop with the MyProject egg.

Ok, so today I needed to get the mexican states and municipalities to use in some Plone dictionaries, so I got that from the SEPOMEX site.

I processed it a little and I got a very simple python file.

I has two dictionaries, the first one called states has a dictionary of normalized id’s and names, for example:

from states import states
print states['distrito_federal']

and you’ll get something like:

Distrito Federal

The other dictionary is the one with the municipalities, you can use it like this:

from states import data
print data['distrito_federal']['miguel_hidalgo']

And you should get something like Miguel Hidalgo.

Of your you can traverse it with something like:

for m in data['distrito_federal'].keys():
    print m

That way you can get every municipality key.

And of course you know.. it’s python and it should be pretty simple to convert it to mysql, csv, or another format you might be using..

So have fun!

If you think that might be helpful you can download it here:

Mexican States and Municipalities

First start a plone instance in debug mode:

Now you have your python shell to play!
First of all you need a user, so let’s try the admin user:

As you probably guessed the first “admin” is the username, and the second one the password.
OK, now we have enough permissions to create our content let’s move on, imagine you have a
plone site called “development” and a folder called “test” in it.

Now you can go into your plone site, and you’ll have the new news, if you can’t see them try going to:

http://localhost:8080/development/test/new-news

Remember changing the url according to your own.

Hope this helps someone