Jython

Consider I have code something like this:

  RuleScript getRuleObject( Node node, Rule rule )
  {
      // Load the previously compiled scripts
      py.exec( node.getNodeScriptCode() );   // load node script
      py.exec( rule.getRuleScriptCode() );   // load rule script

      // Create the device script object that wraps the Java "node"
      py.set( "core_node", node );
      py.exec( "node_script=3D" + node.getPythonClassName() +
"(core_node)" );

      // Create the RuleScript object that wraps the java rule and
device script
      py.set( "core_rule", this );
      PyObject pyo =3D py.eval( rule.getPythonClassName() +
"(core_rule,node_script)" );

      return (RuleScript)pyo.__tojava__( RuleScript.class );
  }

Where "py" is a singleton instance of a PythonInterpreter. Now, let's
say that I have this running in multiple threads. Obviously there is a
chance that the variables "rule" and "node" for one thread could be
overwritten by another thread before the py.eval() is called that uses
these variables.=20

Is there a way to do these operations atomically without having to
create an unique PythonInterpreter instance for each thread? Also, I'm
assuming I don't need the variables "node" and "rule" set after the call
to "py.eval".=20

Also, should I set "rule" and "node" to "null" after calling "py.eval"
so that they don't stay in memory after being passed to instances of the
two python classes?

Finally, is this the best way to construct two python objects and use
one in Java code that implements the RuleScript interface? Is there a
better way to do this? These script files contain no main or anything
like that. They are just class definitions that subclass some java
classes (and rule as you can see, wraps node). Is this the only way to
construct python classes in Java?

Thanks!

R.

I'm trying to make an easy-to-use TextArea-like component that does
some of the things that someone coming from Delphi would expect to
be there, such as managing its scrollbars and keeping track of
whether it's modified, using composition of a JTextArea and a
simple DocumentListener into a JScrollPane, the idea is to delegate
almost everything that the JScrollPane can't  do to the JTextArea,
the fun part of the code is:

class ScrollTextArea(JScrollPane)

    ...

    def __getattr__(self, attr):
        funcname = 'get%s'%capitalizeFirst(attr)
        try:
            func = getattr(JScrollPane, funcname)
            return apply(func, (self,))
        except AttributeError:
            pass
        func = getattr(JTextArea, funcname)
        return apply(func, (self.edit,))

    def __setattr__(self, attr, value):
        funcname = 'set%s'%capitalizeFirst(attr)
        try:
            func = getattr(JScrollPane, funcname)
            return apply(func, (self, value))
        except AttributeError:
            pass
        try:
            func = getattr(JTextArea, funcname)
            return apply(func, (self.edit, value))
        except AttributeError:
            self.__dict__[attr]=value

So question 1 is whether there is some easier and better way to do
the delegation, question 2 is whether there's some way to make
Jython's automatic conversions work; I find that

   editor.preferredSize=(600,200)

will fail, although

   editor.preferredSize=awt.Dimension(600,200)

works.  Obviously it would be possible to intercept and convert
some specific instances such as this one, but is there a more
general way to do it?