Introduction to Jython, Part 2: Programming essentials

class name ( superclasses ):  statement

  -- or --

class name ( superclasses ): 
    assignment
     :

    function
     :

class MyClass:
    pass

x = MyClass()

x.attr1 = 1
x.attr2 = 2
  :
x.attrN = n

class MyClass:
    attr1 = 10        # class attributes
    attr2 = "hello"

    def method1(self):
        print MyClass.attr1   # reference the class attribute

    def method2(self, p1, p2):
        print MyClass.attr2   # reference the class attribute

    def method3(self, text):
        self.text = text    # instance attribute
        print text, self.text    # print my argument and my attribute

    method4 = method3       # make an alias for method3

class MyClass:
    __attr = 10               # private class attribute

    def method1(self):
        pass        

    def method2(self, p1, p2):
        pass       

    def __privateMethod(self, text):
        self.__text = text    # private attribute

class Class1:
    def __init__ (self):             # no arguments
        self.data = []               # set implicit data

class Class2:
    def __init__ (self, v1, v2):     # 2 required arguments
        self.v1 = v1                 # set data from parameters
        self.v2 = v2

class Class3:
    def __init__ (self, values=None): # 1 optional argument
        if values is None: values = []
        self.values = values          # set data from parameter

class Class:
    def __init__ (self, db):    
        self.connection = db.getConnection()    # establish a connection
        self.connection.open()

    def __del__ (self):                         # cleanup at death
        self.close()

    def close(self):                            # cleanup
        if not self.connection is None and self.connection.isOpen():
            self.connection.close()             # release connection
        self.connection = None

def instanceMaker(xclass, *args):
    return apply(xclass, args)

 :

x = instanceMaker(MyClass)   # same as: x = MyClass()

class Class1: pass                # no inheritance

class Class2: pass

class Class3(Class1): pass        # single inheritance

class Class4(Class3,Class2): pass # multiple inheritance

from java import awt
from java import io         

# inherit a Java class and interface and a Jython class
class MyPanel(awt.Panel, io.Serializable, Class2): 
    :

class Class1(SuperClass):
    def __init__ (self):               # no arguments
        SuperClass.__init__(self)      # init my super-class
        self.data = []                 # set implicit data

class Class2(SuperClass):
    def __init__ (self, v1, v2):       # 2 required arguments
        SuperClass.__init__(self, v1)  # init my super-class with v1
        self.v2 = v2

class Class1(Super1, Super2):
    def __init__ (self):               # no arguments
        Super1.__init__(self)          # init each super-class
        Super2.__init__(self)
        self.data = []                 # set implicit data

class Class2(Super1, Super2):
    def __init__ (self, v1, v2, v3):   # 3 required arguments
        # note you may do work before calling the super __init__ methods
        self.v3 = v3                   # set data from parameter
        Super1.__init__(self, v1)      # init each super-class
        Super2.__init__(self, v2)

class Class1:
    def method1 (self):             
        :

class Class2(Class1):
    def method1 (self):         # override method1
        :
        Class1.method1(self)    # call my super-class method
        :

    def method2 (self):             
        :

class Class3(Class2):
    def method1 (self):         # override method1
        :
        Class2.method1(self)    # call my super-class method
        :

    def method3 (self):             
        :

x = SomeClass()               
print isinstance(x, SomeClass)       # prints: 1 (true)
print isinstance(x, SomeOtherClass)  # prints: 0 (false)
 :
# change the class (that is, the type) of the instance here
x.__class__ = SomeOtherClass  
print isinstance(x, SomeClass)       # prints: 0 (false)
print isinstance(x, SomeOtherClass)  # prints: 1 (true)

y = SomeOtherClass()               
print x.__class__ == y.__class__     # prints: 1 (true)

__any__ = ['getMembers', 'printObject']

def addMember (list, item):
    if not item in list:
        list.append(item)

def getMembers (obj, memtype="attrs"):
    """ Get all the members (of memtype) of the object. """
    members = []
    for name, value in vars(obj).items():
        try:
            item = obj.__name__, name, value
        except:
            item = "<instance>", name, value
        if   memtype.lower().startswith("attr"):
            if not callable(value):
                addMember(members, item)
        elif memtype.lower().startswith("meth"):
            if callable(value):
               addMember(members, item)
        elif memtype.lower() == "all":
            addMember(members, item)
    try:
        for base in obj.__bases__:
            members.extend(getMembers(base, memtype))
    except:
        pass
    return members

import sys

def printObject (obj, stream=sys.stdout):
    """ Print all the members of the object. """
    members = getMembers(obj, "attrs")
    members.sort() 
    print >>stream, "Attributes:"
    for objname, memname, value in members:
        print >>stream, "  %s.%s" % (objname, memname)

    members = getMembers(obj, "methods")
    members.sort() 
    print >>stream, "Methods:"
    for objname, memname, value in members:
        print >>stream, "  %s.%s" % (objname, memname)

if __name__ == "__main__":

    from UserList import UserList
    
    class MyClass(UserList):
        def __init__ (self, x, y):
            UserList.__init__(self)
            self.__x = x
            self.__y = y
    
        def method1 (self):
            return self.x + self.y
    
        def method2 (self, x, y):
            return  self.x + self.y + x + y

    print "For class:", `MyClass`
    printObject(MyClass)
    print 

    aMyClass = MyClass(1, 2)
    aMyClass.extend([1,2,3,4])
    print "For instance:", `aMyClass`
    printObject(aMyClass)

For class: <class __main__.MyClass at 28921555>
Attributes:            Methods:                     
  MyClass.__doc__        MyClass.__init__         UserList.__len__            
  MyClass.__module__     MyClass.method1          UserList.__lt__             
  UserList.__doc__       MyClass.method2          UserList.__mul__            
  UserList.__module__    UserList._UserList__cast UserList.__ne__             
                         UserList.__add__         UserList.__radd__           
                         UserList.__cmp__         UserList.__repr__           
                         UserList.__contains__    UserList.__rmul__           
                         UserList.__delitem__     UserList.__setitem__        
                         UserList.__delslice__    UserList.__setslice__       
                         UserList.__eq__          UserList.append             
                         UserList.__ge__          UserList.count              
                         UserList.__getitem__     UserList.extend             
                         UserList.__getslice__    UserList.index              
                         UserList.__gt__          UserList.insert             
                         UserList.__iadd__        UserList.pop                
                         UserList.__imul__        UserList.remove             
                         UserList.__init__        UserList.reverse            
                         UserList.__le__          UserList.sort               

For instance: [1, 2, 3, 4]
Attributes:                    
  <instance>._MyClass__x
  <instance>._MyClass__y
  <instance>.data

Methods:

#-- empty start --
print "vars:", vars()
...vars: {'__doc__': None, '__name__': '__main__'}

x = 1
y = 2
z = 3
l = [x, y, z]
d = {x:"xxxx", y:"yyyy", z:"zzzz"}

#-- locals variables --
print x, y, z, l, d
...1 2 3 [1, 2, 3] {3: 'zzzz', 2: 'yyyy', 1: 'xxxx'}

#-- plus locals variables --
print "vars:", vars()
...vars: {'__name__': '__main__', 'x': 1, \
... 'd': {3: 'zzzz', 2: 'yyyy', 1: 'xxxx'}, '__doc__': None, \
... 'y': 2, 'l': [1, 2, 3], 'z': 3}

import sys

#-- plus import --
print "vars:", vars()
...vars: {'__name__': '__main__', 'z': 3, 'l': [1, 2, 3], \
... '__doc__': None, 'y': 2, 'x': 1, 'sys': sys module, \
... 'd': {3: 'zzzz', 2: 'yyyy', 1: 'xxxx'}}

#-- sys import --
print "vars sys:", vars(sys)  
...vars sys: {'classLoader': \
...     <beanProperty classLoader type: java.lang.ClassLoader at 31845755>, 
...     ... many values removed ...,
... 'warnoptions': <reflected field public static \
...     org.python.core.PyList \
...     org.python.core.PySystemState.warnoptions at 1024901>}

del x, y, z

#-- post delete --
print "vars:", vars()
...vars: {'__name__': '__main__', 'l': [1, 2, 3], '__doc__': None, \
... 'sys': sys module, 'd': {3: 'zzzz', 2: 'yyyy', 1: 'xxxx'}}

def func (x, y):
    return x, y

class MyClass ():
    def __init__ (self, x, y):
        self.__x = x
        self.__y = y

    def method1 (self):
        return self.x + self.y

    def method2 (self, x, y):
        return  self.x + self.y + x + y

#-- plus function and class --
print "vars:", vars()
....vars: {'func': <function func at 21569784>, '__name__': '__main__', \
...  'l': [1, 2, 3], '__doc__': None, \
.... 'MyClass': <class __main__.MyClass at 1279942>, \
...  'sys': sys module, 'd': {3: 'zzzz', 2: 'yyyy', 1: 'xxxx'}}

#-- function --
print "dir: ", dir(func)     # **** dir and vars different here ****
print "vars:", vars(func)
...dir:  ['__dict__', '__doc__', '__name__', 'func_closure', \
... 'func_code', 'func_defaults', 'func_doc', 'func_globals', 'func_name']
...vars: None

#-- class --
print "vars:", vars(MyClass)
...vars: {'__doc__': None, '__init__': <function __init__ at 17404503>, \
... 'method2': <function method2 at 23511968>, '__module__': '__main__', \
... 'method1': <function method1 at 28670096>}

myclass = MyClass(1, 2)

#-- instance --
print "myclass:", myclass
print "vars:", vars(myclass)
...myclass: <__main__.MyClass instance at 19014134>
...vars: {'_MyClass__y': 2, '_MyClass__x': 1}

class CommandProcessor:   # an abstract class
    """ Process Commands. """

    def __init__ (self):
        self.__history = []
        self.__redo = []

    def execute (self, cmdName, *args):
        """ Do some command """
        self.__history.append( (cmdName, args) )
        processor = getattr(self, "do_%s" % cmdName, None)
        if processor:
            return processor(*args)
        else:
            raise NameError, "cannot find do_%s" % cmdName

    def undo (self, count=1):
        """ Undo some (or all) commands in LIFO order """
        self.__redo = []
        while count > 0 and len(self.__history) > 0:
            cmdName, args = self.__history.pop()
            count -= 1
            processor = getattr(self, "undo_%s" % cmdName, None)
            if processor:
                self.__redo.append( (cmdName, args) )
                processor(*args)
            else:
                raise NameError, "cannot find undo_%s" % cmdName

    def redo (self, count=1):
        """ Redo some (or all) undone commands """
        while count > 0 and len(self.__redo) > 0:
            cmdName, args = self.__redo.pop()
            count -= 1
            processor = getattr(self, "do_%s" % cmdName, None)
            if processor:
                processor(*args)
            else:
                raise NameError, "cannot find do_%s" % cmdName

class MyProcessor (CommandProcessor):  # a concrete subclass
    def __init__ (self):
        CommandProcessor.__init__(self)

    def do_Cmd1 (self, args):
        print "Do Command 1:", args

    def do_Cmd2 (self, args):
        print "Do Command 2:", args

    def do_Cmd3 (self, args):
        print "Do Command 3:", args

    def undo_Cmd1 (self, args):
        print "Undo Command 1:", args

    def undo_Cmd2 (self, args):
        print "Undo Command 2:", args

    def undo_Cmd3 (self, args):
        print "Undo Command 3:", args

mp = MyProcessor()

print "execute:" ; mp.execute("Cmd1", None)
print "execute:" ; mp.execute("Cmd2", (1,2,3))
print "execute:" ; mp.execute("Cmd3", "Hello")
print "undo:   " ; mp.undo(2)
print "redo:   " ; mp.redo(2)

print "execute:", ;mp.execute("BadCmd", "Hello")

execute:
Do Command 1: None
execute:
Do Command 2: (1, 2, 3)
execute:
Do Command 3: Hello
undo:   
Undo Command 3: Hello
Undo Command 2: (1, 2, 3)
redo:   
Do Command 2: (1, 2, 3)
Do Command 3: Hello
execute:
Traceback (innermost last):
  File "cmdproc.py", line 63, in ?
  File "cmdproc.py", line 15, in execute
NameError: cannot find do_BadCmd

class UserList:
    def __init__(self, initlist=None):
        self.data = []
        if initlist is not None:
            if   type(initlist) == type(self.data):
                self.data[:] = initlist
            elif isinstance(initlist, UserList):
                self.data[:] = initlist.data[:]
            else:
                self.data = list(initlist)

    def __cast(self, other):
        if isinstance(other, UserList): return other.data
        else:                           return other

    #  `self`, repr(self)
    def __repr__(self): return repr(self.data)

    #  self < other
    def __lt__(self, other): return self.data <  self.__cast(other)

    #  self <= other
    def __le__(self, other): return self.data <= self.__cast(other)

    #  self == other
    def __eq__(self, other): return self.data == self.__cast(other)

    #  self != other, self <> other
    def __ne__(self, other): return self.data != self.__cast(other)

    #  self > other
    def __gt__(self, other): return self.data >  self.__cast(other)

    #  self >= other
    def __ge__(self, other): return self.data >= self.__cast(other)

    #  cmp(self, other)
    def __cmp__(self, other):
        raise RuntimeError, "UserList.__cmp__() is obsolete"

    #  item in self
    def __contains__(self, item): return item in self.data

    #  len(self)
    def __len__(self): return len(self.data)

    #  self[i]
    def __getitem__(self, i): return self.data[i]

    #  self[i] = item
    def __setitem__(self, i, item): self.data[i] = item

    #  del self[i]
    def __delitem__(self, i): del self.data[i]

    #  self[i:j]
    def __getslice__(self, i, j):
        i = max(i, 0); j = max(j, 0)
        return self.__class__(self.data[i:j])

    #  self[i:j] = other
    def __setslice__(self, i, j, other):
        i = max(i, 0); j = max(j, 0)
        if   isinstance(other, UserList):
            self.data[i:j] = other.data
        elif isinstance(other, type(self.data)):
            self.data[i:j] = other
        else:
            self.data[i:j] = list(other)

    #  del self[i:j]
    def __delslice__(self, i, j):
        i = max(i, 0); j = max(j, 0)
        del self.data[i:j]

    #  self + other   (join)
    def __add__(self, other):
        if   isinstance(other, UserList):
            return self.__class__(self.data + other.data)
        elif isinstance(other, type(self.data)):
            return self.__class__(self.data + other)
        else:
            return self.__class__(self.data + list(other))

    #  other + self   (join)
    def __radd__(self, other):
        if   isinstance(other, UserList):
            return self.__class__(other.data + self.data)
        elif isinstance(other, type(self.data)):
            return self.__class__(other + self.data)
        else:
            return self.__class__(list(other) + self.data)

    #  self += other  (join)
    def __iadd__(self, other):
        if   isinstance(other, UserList):
            self.data += other.data
        elif isinstance(other, type(self.data)):
            self.data += other
        else:
            self.data += list(other)
        return self

    #  self * other   (repeat)
    def __mul__(self, n):
        return self.__class__(self.data*n)
    __rmul__ = __mul__

    #  self *= other  (repeat)
    def __imul__(self, n):
        self.data *= n
        return self

    # implement "List" functions below:

    def append(self, item): self.data.append(item)

    def insert(self, i, item): self.data.insert(i, item)

    def pop(self, i=-1): return self.data.pop(i)

    def remove(self, item): self.data.remove(item)

    def count(self, item): return self.data.count(item)

    def index(self, item): return self.data.index(item)

    def reverse(self): self.data.reverse()

    def sort(self, *args): apply(self.data.sort, args)

    def extend(self, other):
        if isinstance(other, UserList):
            self.data.extend(other.data)
        else:
            self.data.extend(other)

class MyDataWrapper:
    class Data: pass    # inner data structure class

    def __init__ (self):
        self.data = Data()

    def set (self, name, value):
        setattr(self.data, name, value)

    def get (self, name, default=None):
        return getattr(self.data, name, default)

:
def myFunc(x):
    print "x at entry:", x
      :
    print "x at exit:", x
    return x
:

z = myFunc(20)

c:\>jython c:\jython-2.1\lib\pdb.py <test_module>.py

C:\Articles>jython \jython-2.1\lib\pdb.py factor.py
> C:\Articles\<string>(0)?()
(Pdb) step
> C:\Articles\<string>(1)?()
(Pdb) step
> C:\Articles\factor.py(0)?()
(Pdb) list 67
 62             try:
 63                 print "For", value, "result =", 
fac.calculate(value)
 64             except ValueError, e:
 65                 print "Exception -", e
 66
 67         doFac(-1)
 68         doFac(0)
 69         doFac(1)
 70         doFac(10)
 71         doFac(100)
 72         doFac(1000)
(Pdb) tbreak 67
Breakpoint 1 at C:\Articles\factor.py:67
(Pdb) continue
factor.py running...
Deleted breakpoint 1
> C:\Articles\factor.py(67)?()
-> doFac(-1)
(Pdb) next
For -1 result = Exception - only positive integers supported: -1
> C:\Articles\factor.py(68)?()
-> doFac(0)
(Pdb) next
For 0 result = 1
> C:\Articles\factor.py(69)?()
-> doFac(1)
(Pdb) next
For 1 result = 1
> C:\Articles\factor.py(70)?()
-> doFac(10)
(Pdb) next
For 10 result = 3628800
> C:\Articles\factor.py(71)?()
-> doFac(100)
(Pdb) next
For 100 result = 
93326215443944152681699238856266700490715968264381621468592963895217599
99322991560894146397615651828625
3697920827223758251185210916864000000000000000000000000
> C:\Articles\factor.py(72)?()
-> doFac(1000)
(Pdb) next
For 1000 result = 402387260077 ... many other digits deleted ...
0000000000000000000000
--Return--
> C:\Articles\factor.py(72)?()->None
-> doFac(1000)
(Pdb) next
--Return--
> C:\Articles\<string>(1)?()->None
(Pdb) next
C:\Articles>

c:\>jython \jython-2.1\lib\profile.py \articles\factor.py

\articles\factor.py running...
For -1 result = Exception - only positive integers supported: -1
For 0 result = 1
For 1 result = 1
For 10 result = 3628800
For 100 result = 
93326215443944152681699238856266700490715968264381621468592963895217599
99322991560894146397615651828625369792082722375825118521091686400000000
0000000000000000
For 1000 result = 402387260077 ... many other digits deleted ...
0000000000000000000000

         237 function calls (232 primitive calls) in 0.250 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.130    0.130    0.240    0.240 <string>:0(?)
        1    0.000    0.000    0.110    0.110 factor.py:0(?)
      220    0.010    0.000    0.010    0.000 \
factor.py:27(fireListeners)
        6    0.060    0.010    0.070    0.012 factor.py:34(calculate)
        1    0.000    0.000    0.000    0.000 factor.py:5(Factorial)
        1    0.000    0.000    0.000    0.000 factor.py:6(__init__)
      6/1    0.040    0.007    0.110    0.110 factor.py:61(doFac)
        1    0.010    0.010    0.250    0.250 \
profile:0(execfile('\\articles\\factor.py'))
        0    0.000             0.000          profile:0(profiler)

assert expression {, message}

:
def myFunc(x):
    assert x >= 0, "argument %r must be >= 0" % x
    return fac(x)
:
z = myFunc(20)          # no exception raised

z = myFunc(-1)          # AssertionError raised

from java import util
class MyArray(util.ArrayList):  # subclass a Java class
    :
    def get (self, index):      # override the get method
        "@sig public java.lang.Object get(int index)"
      if 0 <= index < self.size:  
            return util.ArrayList.get(self, index)
        return None             # OutOfBounds now returns null

from java.util import Date

 :

d = Date()   # now
print d, d.time, d.getTime()

Tue Dec 02 14:44:02 CST 2003 1070397842496 1070397842496

<type> get<name>()

-- and --

void set<name>(<type> value)

Wed Dec 31 18:01:40 CST 1969 100000 100000

1: from javax import swing 
2: import sys
3:
4: f = swing.JFrame(sys.argv[1], size=(200,200), 
5:                  defaultCloseOperation=swing.JFrame.EXIT_ON_CLOSE)
6: f.contentPane.add(swing.JLabel(sys.argv[2]))
7: f.visible = 1

"@sig public java.lang.Object get(int index)"

from java import io

class AlwaysBlank(io.InputStream):
    # covers all forms of read(...)
    def read(self, *args):
        if len(args) > 0: 
            # covers forms: int read(byte[])
            #               int read(byte[], int off, int len)
            return apply(io.InputStream.read, (self,) + args)
        else:
            # covers form: int read()
            return ord(' ')

from jarray import zeros, array
from java import util
from javax import swing

a1 = zeros(100, 'i')            # an array of 100 int 0s
a2 = array([1,2,10,-5,7], 'i')  # an array of ints as listed

# an array of doubles 0.0 to 49.0
a3 = array([i * 1.0 for i in range(50)], 'd')  

a4 = zeros(10, util.Map)        # an array of 10 null Maps
a5 = array((swing.JFrame("F1"), # an array of 3 JFrames
            swing.JFrame("F2"), 
            swing.JFrame("F3")), swing.JFrame)
a6 = array("Hello", 'c')        # an array of characters

start_new_thread(function, args)

-- and --

exit()

make_synchronized(function)

-- and --

apply_synchronized(syncobj, function, pargs {, kwargs})

from synchronize import *
from java import lang

# define synchronization helpers

def waitForSignal (monitor):
    """ Wait until the monitor is signaled. """
    lang.Object.wait(monitor)
# replace with synchronized version; syncs on 1st argument
waitForSignal = make_synchronized(waitForSignal)

def notifySignal (monitor):
    """ Signal monitor. """
    lang.Object.notifyAll(monitor)
# replace with synchronized version; syncs on 1st argument
notifySignal = make_synchronized(notifySignal)

class Gui:           # GUI support
    :
    def doExit (self):
        self.visible = 0
        notifySignal(self)

if __name__ == "__main__":     # main code
    : 
    gui = Gui()
    : 
    print "Waiting until GUI exit requested..."
    waitForSignal(gui)
    print "Done"

""" A Jython Thread Example. """

from java import lang 
from synchronize import *
from thread import start_new_thread
from sys import stdout

def __waitForSignal (monitor):
    apply_synchronized(monitor, lang.Object.wait, (monitor,))

def __signal (monitor):
    apply_synchronized(monitor, lang.Object.notifyAll, (monitor,))

def __xprint (stream, msg):
    print >>stream, msg

def xprint (msg, stream=stdout):
    """ Synchronized print. """
    apply_synchronized(stream, __xprint, (stream, msg))

class Buffer:
    """ A thread-safe buffer. """

    def __init__ (self, limit=-1):
        self.__limit = limit    # the max size of the buffer
        self.__data = []
        self.__added = ()       # used to signal data added
        self.__removed = ()     # used to signal data removed

    def __str__ (self):
        return "Buffer(%s,%i)" % (self.__data, self.__limit)

    def __len__ (self):
        return len(self.__data)

    def add (self, item):
        """ Add an item. Wait if full. """
        if self.__limit >= 0:
            while len(self.__data) > self.__limit:
                __waitForSignal(self.__removed)
        self.__data.append(item);
        xprint("Added: %s" % item)
        __signal(self.__added)

    def __get (self):
        item = self.__data.pop(0)
        __signal(self.__removed)
        return item

    def get (self, wait=1):
        """ Remove an item. Wait if empty. """
        item = None
        if wait:
            while len(self.__data) == 0:
                __waitForSignal(self.__added)
            item = self.__get()
        else:
            if len(self.__data) > 0: item = self.__get()
        xprint("Removed: %s" % item)
        return item
    get = make_synchronized(get)

class Producer:
    def __init__ (self, name, buffer):
        self.__name = name
        self.__buffer = buffer

    def __add (self, item):
        self.__buffer.add(item)

    def __produce (self, *args):
        for item in args:
            self.__add(item)

    def produce (self, items):
        start_new_thread(self.__produce, tuple(items))

class Consumer:
    def __init__ (self, name, buffer):
        self.__name = name
        self.__buffer = buffer

    def __remove (self):
        item = self.__buffer.get()
        return item

    def __consume (self, count):
        for i in range(count):
            self.__remove()

    def consume (self, count=1):
        start_new_thread(self.__consume, (count,))

# all producers and consumer share this one
buf = Buffer(5)    

p1 = Producer("P1", buf)
p2 = Producer("P2", buf)
p3 = Producer("P3", buf)
p4 = Producer("P4", buf)
c1 = Consumer("C1", buf)
c2 = Consumer("C2", buf)

# create 6 items
p1.produce(["P1 Message " + str(i) for i in range(3)])
p2.produce(["P2 Message " + str(i) for i in range(3)])

# consume 20 items
for i in range(5):
    c1.consume(2)
    c2.consume(2)

# create 20 more items
p3.produce(["P3 Message " + str(i) for i in range(10)])
p4.produce(["P4 Message " + str(i) for i in range(10)])

# consume 4 items
c1.consume(2)
c2.consume(2)

# let other threads run
lang.Thread.currentThread().sleep(5000)

xprint("Buffer has %i item(s)left" % len(buf))

Added: P1 Message 0       Added: P3 Message 7       
Added: P1 Message 1       Removed: P3 Message 7     
Added: P1 Message 2       Added: P3 Message 8       
Added: P2 Message 0       Removed: P3 Message 8     
Added: P2 Message 1       Added: P3 Message 9       
Added: P2 Message 2       Removed: P3 Message 9     
Removed: P1 Message 0     Added: P4 Message 0       
Removed: P1 Message 1     Removed: P4 Message 0     
Removed: P1 Message 2     Added: P4 Message 1       
Removed: P2 Message 0     Removed: P4 Message 1     
Removed: P2 Message 1     Added: P4 Message 2       
Removed: P2 Message 2     Removed: P4 Message 2     
Added: P3 Message 0       Added: P4 Message 3       
Removed: P3 Message 0     Removed: P4 Message 3     
Added: P3 Message 1       Added: P4 Message 4       
Removed: P3 Message 1     Added: P4 Message 5       
Added: P3 Message 2       Added: P4 Message 6       
Removed: P3 Message 2     Added: P4 Message 7       
Added: P3 Message 3       Added: P4 Message 8       
Removed: P3 Message 3     Added: P4 Message 9       
Added: P3 Message 4       Removed: P4 Message 4     
Removed: P3 Message 4     Removed: P4 Message 5     
Added: P3 Message 5       Removed: P4 Message 6     
Removed: P3 Message 5     Removed: P4 Message 7     
Added: P3 Message 6       Buffer has 2 item(s)left  
Removed: P3 Message 6

""" This module defines several functions to ease interfacing with Java code."""

from types import *

from java import lang
from java import util
from java import io

# only expose these
__all__ = ['loadProperties', 'getProperty', 
           'mapToJava', 'mapFromJava', 'parseArgs']

def loadProperties (source):
    """ Load a Java properties file into a Dictionary. """
    result = {}
    if type(source) == type(''):    # name provided, use file
        source = io.FileInputStream(source)
    bis = io.BufferedInputStream(source)
    props = util.Properties()
    props.load(bis) 
    bis.close()
    for key in props.keySet().iterator():
        result[key] = props.get(key)
    return result

def getProperty (properties, name, default=None):
    """ Gets a property. """
    return properties.get(name, default)

import sys
file = sys.argv[1]
props = loadProperties(file)
print "Properties file: %s, contents:" % file 
print props
print "Property %s = %i" % ('debug', int(getProperty(props, 'debug', '0')))

# This is a test properties file
debug = 1
error.level = ERROR
now.is.the.time = false

Properties file: test.properties, contents:
{'error.level': 'ERROR', 'debug': '1', 'now.is.the.time': 'false'}
Property debug = 1

def mapMapFromJava (map):
    """ Convert a Map to a Dictionary. """
    result = {}
    iter = map.keySet().iterator()
    while iter.hasNext():
        key = iter.next()
        result[mapFromJava(key)] = mapFromJava(map.get(key))
    return result

def mapCollectionFromJava (coll):
    """ Convert a Collection to a List. """
    result = []
    iter = coll.iterator();
    while iter.hasNext():
        result.append(mapFromJava(iter.next()))
    return result

def mapFromJava (object):
    """ Convert a Java type to a Jython type. """
    if object is None: return object
    if   isinstance(object, util.Map):        
        result = mapMapFromJava(object)
    elif isinstance(object, util.Collection): 
        result = mapCollectionFromJava(object)
    else:                                     
        result = object
    return result

def mapSeqToJava (seq):
    """ Convert a sequence to a Java ArrayList. """
    result = util.ArrayList(len(seq))
    for e in seq:
        result.add(mapToJava(e));
    return result

def mapDictToJava (dict):
    """ Convert a Dictionary to a Java HashMap. """
    result = util.HashMap()
    for key, value in dict.items():
        result.put(mapToJava(key), mapToJava(value))
    return result

def mapToJava (object):
    """ Convert a Jython type to a Java type. """
    if object is None: return object
    t = type(object)
    if   t == TupleType or t == ListType:  
        result = mapSeqToJava(object)
    elif t == DictType:  
        result = mapDictToJava(object)
    else:                
        result = object
    return result

data = (1,2,3, [1,2,3], [c for c in "Hello!"], "Hello!", {1:'one', 2:'two'})
print "data:", data
toJava = mapToJava(data)
print "toJava:", toJava
fromJava = mapFromJava(toJava)
print "fromJava:", fromJava

print

print "type(%s)=%s" % ("data", type(data))
print "type(%s)=%s" % ("toJava", type(toJava))
print "type(%s)=%s" % ("fromJava", type(fromJava))

data: (1, 2, 3, [1, 2, 3], ['H', 'e', 'l', 'l', 'o', '!'], 'Hello!', \
    {2: 'two', 1: 'one'})
toJava: [1, 2, 3, [1, 2, 3], [H, e, l, l, o, !], Hello!, {2=two, 1=one}]
fromJava: [1, 2, 3, [1, 2, 3], ['H', 'e', 'l', 'l', 'o', '!'], 'Hello!', \
    {2: 'two', 1: 'one'}]

type(data)=org.python.core.PyTuple
type(toJava)=org.python.core.PyJavaInstance
type(fromJava)=org.python.core.PyList

def parseArgs (args, validNames, nameMap=None):
    """ Do some simple command line parsing. """
    # validNames is a dictionary of valid switch names -
    #   the value (if any) is a conversion function
    switches = {}
    positionals = []
    for arg in args:
        if arg[0] == '-':               # a switch
            text = arg[1:]
            name = text; value = None
            posn = text.find(':')       # any value comes after a :
            if posn >= 0:
                name = text[:posn]
                value = text[posn + 1:]
            if nameMap is not None:     # a map of valid switch names
                name = nameMap.get(name, name)
            if validNames.has_key(name):   # or - if name in validNames:
                mapper = validNames[name]
                if mapper is None: switches[name] = value
                else:              switches[name] = mapper(value)
            else:
                print "Unknown switch ignored -", name

        else:                           # a positional argument
            positionals.append(arg)
    return positionals, switches

from sys import argv
from JavaUtils import parseArgs

switchDefs = {'s1':None, 's2':int, 's3':float, 's4':int}
args, switches = parseArgs(argv[1:], switchDefs)
print "args:", args
print "switches:", switches

args: ['1', '2', '3', 'ss']
switches: {'s4': 2, 's2': 1, 's1': None}

name ="Barry Feigenbaum"
addr = '12345 Any Street"
v1 = 100; v2 = v1 * 1.5; v3 = -v2; v4 = 1 / v2
s1 = "String 1"; s2 = "String 2"
sent = "The rain in Spain falls mainly on the plain."

print "abc" + "xyz"

if ' ' in name: print "space found"

-- or --

if 'q' not in sent: print "q not found"

if name.find(' ') >= 0: print "space found"

-- or --

if name.find("Jones") < 0: print "Jones not in name"

if  s1.lower() == s2.lower(): print "equal"

-- or --

newaddr = addr.replace("Street", "St.")

cmd = raw_input("Enter a command")
if cmd.lstrip.startswith("run "): 
    print "run command found"

words = sent.split(' ')   # use space to separate words
sent2 = ' '.join(words)   # use space between words

fname = "Barry"; lname = "Feigenbaum"
address = "1234 any St."
city = "Anytown"; state = "TX"; zip = "12345"
age = 30
children = 3
  :
print "Hello %(fname)s from %(city)s, %(state)s." % locals()

def printf(stream, format, *pargs, **kwargs):

                        # see Printing to files for more information
    if   pargs:
        print >>stream, format % pargs
    elif kwargs:
        print >>stream, format % kwargs
    else:
        print >>stream, format

from sys import stdout

printf(stdout, "%s is %.1f years old and has %i children", 
       fname, age, children)

printf(stdout, "The %(name)s building has %(floors)d floors", 
       floors=105, name="Empire State")

printf(stdout, "Hello World!")

Barry is 30.0 years old and has 3 children
The Empire State building has 105 floors
Hello World!

data = [[1,2,3], [4,5,6],{'1':'one', '2':'two'}, 
        "jsdlkjdlkadlkad", [i for i in xrange(10)]]
print "Unformatted:"; print data

print

from pprint import pformat
print "Formatted:"; print pformat(data)

Unformatted:
[[1, 2, 3], [4, 5, 6], {'2': 'two', '1': 'one'}, \
    'jsdlkjdlkadlkad', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]

Formatted:
[[1, 2, 3],
 [4, 5, 6],
 {'2': 'two', '1': 'one'},
 'jsdlkjdlkadlkad',
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]

import sys

def stripLines (lines):
    """ Removed extra whitespace (that is, newlines). """
    newlines = []
    for line in lines:
        line = line.strip()
        newlines.append(line)
    return newlines

def splitParagraphs (lines):
    """ Splits a set of lines into paragraphs.  """
    paras = []
    para = ""
    for line in lines:
        if len(line) > 0:       # in paragraph
            para += ' ' + line
        else:                   # between paragraphs
            para = para.strip()
            if len(para) > 0:
                paras.append(para)
                para = ""
    return paras

class Formatter:
    """ Formats and prints paragraphs.  """

    def __init__ (self, stream, pagelen=66, linewidth=85, 
                        lmargin=10, rmargin=10, pindent=5,
                        alignment="justify",
                        headers=None, footers=None):
        self.stream = stream        # stream to print on

        # format settings
        self.pagelen = pagelen 
        self.pindent = pindent 
        self.linewidth = linewidth  
        self.lmargin = lmargin    
        self.rmargin = rmargin    
        self.headers = headers    
        self.footers = footers    
        self.alignment = alignment

        self.pagecount = 1         # current page
        self.linecount = 0         # current line
    
    def genLine (self, line):
        print >>self.stream, line
        self.linecount += 1

    def outputLine (self, line):
        self.testEndPage()
        if not (self.linecount == 0 and len(line) == 0):
            self.genLine(line)
    
    def newPage (self):
        if self.headers:
            self.outputHeader()
    
    def padPage (self):
        while self.linecount < self.pagelen:
            self.genLine("")
    
    def endPage (self):
        if self.footers:
            if len(self.footers) + self.linecount < self.pagelen:
                self.padPage()
            self.outputFooter()
        else:
            if self.linecount < self.pagelen:
                self.padPage()
        self.linecount = 0
        self.pagecount += 1
        self.genLine('-' * 20)
    
    def testEndPage (self):
        if self.footers:
            if len(self.footers) + 1 + self.linecount >= self.pagelen:
                self.endPage()
                self.newPage()
        else:
            if self.linecount >= self.pagelen:
                self.endPage()
                self.newPage()

    def padLine (self, line, firstline=0, lastline=0):
        """ Add spaces as needed by alignment mode.  """

        if   self.alignment == "left":
            adjust = firstline * self.pindent
            #line = line

        elif self.alignment == "center":
            adjust = 0
            pad = self.linewidth - adjust - len(line)
            line = ' ' * (pad / 2) + line

        elif self.alignment == "right":
            adjust = 0
            pad = self.linewidth - adjust - len(line)
            line = ' ' * pad + line

        elif self.alignment == "justify":
            adjust = firstline * self.pindent
            pad = self.linewidth - adjust - len(line)
            line = ""

            # add 1+ spaces between words to extend line
            words = line.split()
            xpad = pad                       
            for word in words:
                line += word + ' '
                if not lastline and xpad > 0:
                    line += ' '  * (pad / len(words) + 1)
                    xpad -= 1
            line = line.strip()

        return ' ' * adjust + line 

    def format (self, line, firstline=0, lastline=0):
        # indent by left margin
        return ' ' * self.lmargin + \
               self.padLine(line.strip(), firstline, lastline)

    def formatParagraph (self, para):
        lcount = 0
        adjust = self.pindent
        line = ""

        # process by words
        words = para.split(' ')
        for word in words:
            line += ' '
            # about to get too long
            if len(line) + len(word) > self.linewidth - adjust:
                line = self.format(line, lcount == 0, 0)
                self.outputLine(line)
                line = "" 
                lcount += 1
                adjust = 0
            line += word
        # output last (only) line
        if len(line) > 0:
            line = self.format(line, lcount == 0, 1)
            self.outputLine(line)

    def outputHeader (self):
        for line in self.headers:
            self.genLine(' ' * self.lmargin + line.center(self.linewidth))
        self.genLine("")
    
    def outputFooter (self):
        self.genLine("")
        for line in self.footers:
            self.genLine(' ' * self.lmargin + line.center(self.linewidth))
    
    def outputPages (self, paras):
        """ Format and print the paragraphs. """
        self.newPage()
        for para in paras:
            self.formatParagraph(para)
            self.outputLine("")
        self.endPage()

import re

# do a fancy string match
if re.search(r"^\s*barry\s+feigenbaum\s*$", name, re.I):
   print "It's Barry alright"

# replace the first name with an initial
name2 = re.sub(r"(B|b)arry", "B.", name)

import re
patstr = r"\s*abc\s*"
pat = re.compile(patstr)
# print all lines matching patstr
for s in stringList:
    if pat.match(s, re.I): print "%r matches %r" % (s, patstr)

""" A simplified form of Grep. """

import sys, re

if len(sys.argv) != 3:
    print "Usage: jython grep.py <pattern> <file>"
else:
    # process the arguments
    pgm, patstr, filestr = sys.argv
    print "Grep - pattern: %r file: %s" % (patstr, filestr)
    pat = re.compile(patstr)  # prepare the pattern


                        # see File I/O in Jython
                     for more information
    file = open(filestr)      # access file for read
    lines = file.readlines()  # get the file
    file.close()

    count = 0
    # process each line
    for line in lines:
        match = pat.search(line)    # try a match
        if match:                   # got a match
            print line
            print "Matching groups: " + str(match.groups())
            count += 1
    print "%i match(es)" % count

C:\Articles>jython grep.py "(\w*)!" words.txt
Grep - pattern: '(\\w*)!' file: words.txt
How many times must I say it; Again! again! and again!

Matched on: ('Again',)
Singing in the rain! I'm singing in the rain! \
    Just singing, just singing, in the rain!

Matched on: ('rain',)
2 match(es)

file = open(path {, mode {, size}})

import sys

f = open(sys.argv[1], "rb")    # open binary for reading
bin = f.read()
f.close()
f = open(sys.argv[2], "wb")    # open binary (truncated) for write
f.write(bin)
f.close()

import sys

f = open(sys.argv[1], "r")    # read the file by lines
lines = f.readlines()
f.close()
lines.sort()                  # sort and print the lines
print "File %s sorted" % f.name
print lines

import sys

def clean (word):
    """ Remove any punctuation and map to a common case. """
    word = word.lower()
    # remove any special characters
    while word and word[-1] in ".,;!": word = word[:-1]
    while word and word[0] in ".,;!": word = word[1:]
    return word

words = {}  # set of unique words and counts

if len(sys.argv) != 2:
    print "Usage: jython wcount.py <file>"
else:
    file = open(sys.argv[1])  # access file for read
    lines = file.readlines()  # get the file
    file.close()

    # process each line
    for line in lines:
        # process each word in the line
        for word in line.split():
            word = clean(word)
            words[word] = words.get(word, 0) + 1   # update the count

    # report the results
    keys = words.keys()
    keys.sort()
    for word in keys:
        print "%-5i %s" % (words[word], word)

Now is the time for all good men to come to the aid of their country.
The rain in Spain falls mainly on the plain.
How many times must I say it; Again! again! and again!
Singing in the rain! I'm singing in the rain! \
    Just singing, just singing, in the rain!

3     again             1     many       
1     aid               1     men        
1     all               1     must       
1     and               1     now        
1     come              1     of         
1     country           1     on         
1     falls             1     plain      
1     for               4     rain       
1     good              1     say        
1     how               4     singing    
1     i                 1     spain      
1     i'm               7     the        
4     in                1     their      
1     is                1     time       
1     it                1     times      
2     just              2     to         
1     mainly

import java.io.*;
import java.util.*;
import java.text.*;

public class WordCounter
{
    protected static final String specials = ".,;!";

    /** Remove any punctuation and map to a common case. */
    protected static String clean(String word) {
        word = word.toLowerCase();
        // remove any special characters
        while (word.length() > 0 && 
               specials.indexOf(word.charAt(word.length() - 1)) >= 0) {
            word = word.substring(0, word.length() - 1);

        }
        while (word.length() > 0 && 
               specials.indexOf(word.charAt(0)) >= 0) {
            word = word.substring(1);
        }
        return word;
    }

    protected static Map words = new HashMap();

    public static void main(String[] args) throws IOException {
        if (args.length != 1) {
            System.out.println("Usage: java WordCounter <file>");
        }
        else {                               
            // access file for read
            FileInputStream fis = new FileInputStream(args[0]);
            DataInputStream dis = new DataInputStream(fis);
            List lines = new ArrayList();
            // get the file
            for (String line = dis.readLine(); 
                 line != null; 
                 line = dis.readLine()) {
                lines.add(line);  
            }
            dis.close();

            // process each line
            for (int i = 0; i < lines.size(); i++) {
                String line = (String)lines.get(i);
                System.out.println("Processing: " + line);
                String[] xwords = line.split("\\s+");
                for (int w = 0; w < xwords.length; w++) {
                    String word = clean(xwords[w]);
                    if (word.length() > 0) {
                        Integer count = (Integer)words.get(word);
                        if (count == null) {
                            count = new Integer(0);
                        }
                        // update the count
                        words.put(word, 
                                  new Integer(count.intValue() + 1));  
                    }
                }
            }

            // report the results
            String[] keys = (String[])words.keySet().
                                 toArray(new String[words.size()]);
            Arrays.sort(keys);

            MessageFormat form = new MessageFormat(
                            "{0,number, #########0} {1}");
            for (int i = 0; i < keys.length; i++) {
                System.out.println(form.format(
                          new Object[] {words.get(keys[i]), keys[i]}));
            }
        }
    }
}

print "Hello World!"

import sys
print >>sys.stdout, "Hello world!"

print >>sys.stderr, "Hello world!"

f = open("myfile", "w")
for i in range(10):
    print >>f, "Line", i
f.close()

f = open("myfile", "a")
print >>f, "Added line"
f.close()

import pickle

class Data:
    def __init__ (self, x, y):
        self.__x = x
        self.__y = y

    def __str__ (self):
        return "Data(%s,%s)" % (self.__x, self.__y)

    def __eq__ (self, other):
        return self.__x == other.__x and self.__y == other.__y


data = Data(10, "hello")

file = open("data.pic", 'w')
pickle.dump(data, file)
file.close()

file = open("data.pic", 'r')
newdata = pickle.load(file)
file.close()

print "data:", data
print "newdata:", newdata
print "data is newdata:", data is newdata
print "data == newdata:", data == newdata

data: Data(10,hello)
newdata: Data(10,hello)
data is newdata: 0 (false)
data == newdata: 1 (true)

(i__main__
Data
p0
(dp1
S'_Data__y'
p2
S'hello'
p3
sS'_Data__x'
p4
I10
sb.

import shelve, sys

def printshelf (shelf, stream=sys.stdout):  # print the entries in a shelf
    for k in shelf.keys():
        print >>stream, k, '=', shelf[k]

def clearshelf (shelf):                     # remove all keys in the shelf
    for k in shelf.keys():
        del shelf[k]

# create shelf
shelf = shelve.open("test.shelf")
clearshelf(shelf)
shelf["x"] = [1,2,3,4]
shelf["y"] = {'a':1, 'b':2, 'c':3}
printshelf(shelf)
shelf.close()

print
# update shelf
shelf = shelve.open("test.shelf")
printshelf(shelf)
print
shelf["z"] = sys.argv[1]
printshelf(shelf)
shelf.close()

print
# verify shelf persistent
shelf = shelve.open("test.shelf")
printshelf(shelf)
shelf.close()

x = [1, 2, 3, 4]
y = {'b': 2, 'a': 1, 'c': 3}

x = [1, 2, 3, 4]
y = {'b': 2, 'a': 1, 'c': 3}

x = [1, 2, 3, 4]
z = This is a test string
y = {'b': 2, 'a': 1, 'c': 3}

x = [1, 2, 3, 4]
z = This is a test string
y = {'b': 2, 'a': 1, 'c': 3}

-- import the needed modules
import sys
import exceptions

-- create the Factorial class, a general purpose factorial calculation engine
class Factorial:
    """A general purpose factorial calculation engine"""

-- define the constructor
    def __init__ (self):
        self.__listeners = []
        self.__cancelled = 0

-- allow other classes to register event listeners; 
---    used to track calculation progress
-- A "listener" is a function that takes an integer % argument
    def addListener (self, listener):
        if listener not in self.__listeners:
            self.__listeners.append(listener)

    def addListeners (self, listeners):
        for l in listeners:
            self.addListener(l)

    def removeListener (self, listener):
        self.__listeners.remove(listener)

    def removeListeners (self, listeners):
        for l in listeners:
            self.removeListener(l)

    def fireListeners (self, value):  # notify all listeners
        for func in self.__listeners:
            func(value)

-- allow others to cancel a long running calculation
    def cancel (self):
        self.__cancelled = 1

-- perform the factorial calculation; 
--     may take a long time (many minutes) for big numbers
    def calculate (self, value):
        if type(value) != type(0) or value < 0:
            raise ValueError,  \
               "only positive integers supported: " + str(value)

        self.__cancelled = 0
        result = 1L
        self.fireListeners(0)   # 0% done
        # calculate factorial -- may take quite a while
        if value > 1:           # need to do calculation
            last = 0
            # using iteration (vs. recursion) to increase performance
            # and eliminate any stack overflow possibility
            for x in xrange(1, value + 1):
                if self.__cancelled: break  # early abort requested
                result = result * x         # calc next value
                next = x * 100 / value
                if next != last:            # signal progress 
                    self.fireListeners(next)
                    last = next
        self.fireListeners(100)  # 100% done
        if self.__cancelled: result = -1
        return result

# test case
if __name__ == "__main__":
    print sys.argv[0], "running..."
    fac = Factorial()

    def doFac (value):
        try:
            print "For", value, "result =", fac.calculate(value)
        except ValueError, e: 
            print "Exception -", e

    doFac(-1)
    doFac(0)
    doFac(1)
    doFac(10)
    doFac(100)
    doFac(1000)

-- import the needed modules
import sys
import string
from types import *

from java import lang
from java import awt
from java.awt import event as awtevent
from javax import swing

from factor import Factorial

-- PromptedValueLayout is a customized Java LayoutManager not discussed here 
--    but included with the resources
from com.ibm.articles import PromptedValueLayout as ValueLayout

-- support asynchronous processing
class LongRunningTask(lang.Thread):
    def __init__ (self, runner, param=None):
        self.__runner = runner   # function to run
        self.__param = param     # function parameter (if any)
        self.complete = 0
        self.running = 0

-- Java thread body
    def run (self):
        self.complete = 0; self.running = 1
        if self.__param is not None: 
            self.result = self.__runner(self.__param)
        else:
            self.result = self.__runner()
        self.complete = 1; self.running = 0

-- start a long running activity
def doAsync (func, param):
    LongRunningTask(func, param).start()

-- Swing GUI services must be called only on the AWT event thread,
class SwingNotifier(lang.Runnable):
    def __init__ (self, processor, param=None):
        self.__runner = processor  # function to do GUI updates
        self.__param = param       # function parameter (if any)

-- Java thread body
    def run (self):
        if self.__param is not None: self.__runner(self.__param)
        else:                        self.__runner()

    def execute (self):
        swing.SwingUtilities.invokeLater(self)

     -- define and construct a GUI for factorial calculation
class FactorialGui(swing.JPanel):
    """Create and process the GUI."""

    def __init__ (self, engine):
        swing.JPanel.__init__(self)
        self.__engine = engine
        engine.addListener(self.update)
        self.createGui()

    def update (self, value):          # do on AWT thread
        SwingNotifier(self.updateProgress, value).execute()

    def updateProgress (self, value):  # display progress updates
        self.__progressBar.value = value

-- Calculate button press handler
    def doCalc (self, event):          # request a factorial
        self.__outputArea.text = ""
        ivalue = self.__inputField.text # get value to calculate
        value = -1
        try: value = int(ivalue)        # convert it
        except: pass
        if value < 0:                   # verify it
           self.__statusLabel.text = \
               "Cannot make into a positive integer value: " + ivalue
        else:
            self.__calcButton.enabled = 0
            self.__cancelButton.enabled = 1
            msg = "Calculating factorial of %i..." % value
            if value > 25000: msg += \ 
                 "; May take a very long time to complete!"
            self.__statusLabel.text = msg  # tell user we're busy
            doAsync(self.calcFac, value)   # do the calculation

-- main calculation worker
    def calcFac (self, value): 
        stime = lang.System.currentTimeMillis()
        fac = self.__engine.calculate(value)   # time calculation
        etime = lang.System.currentTimeMillis()
        svalue = ""; order = 0
        if fac >= 0:          # we have a result, not cancelled
            svalue = str(fac); order = len(svalue) - 1
            formatted = ""
            while len(svalue) > 100:  # wrap long numbers
                formatted += svalue[0:100] + '\n'
                svalue = svalue[100:]
            formatted += svalue
            svalue = formatted
        ftime = lang.System.currentTimeMillis()

        SwingNotifier(self.setResult, \
          (svalue, order, ftime - stime, etime - stime)).execute()

-- display the result
    def setResult (self, values):
        svalue, order, ttime, ftime = values
        self.__cancelButton.enabled = 0
        if len(svalue) > 0:
            self.__statusLabel.text = \
               "Setting result - Order: 10**%i" % order
            self.__outputArea.text = svalue
            self.__statusLabel.text = \
                "Total time: %ims, Calc time: %ims, Order: 10**%i" % \
                      (ttime, ftime, order)
        else:
            self.__statusLabel.text = "Cancelled"

        self.__calcButton.enabled = 1

-- Cancel button press handler
    def doCancel (self, event):       # request a cancel
        self.__cancelButton.enabled = 0
        self.__engine.cancel()

-- create (layout) the GUI
    def createGui (self):             # build the GUI
        self.layout = awt.BorderLayout()

        progB = self.__progressBar = \
            swing.JProgressBar(0, 100, stringPainted=1);

        inf = self.__inputField = swing.JTextField(5)
        inl = swing.JLabel("Calculate value of:", swing.JLabel.RIGHT)
        inl.labelFor = inf

        outf = self.__outputArea = swing.JTextArea()
        outl = swing.JLabel("Result:", swing.JLabel.RIGHT)
        outl.labelFor = outf

        calcb = self.__calcButton = \
            swing.JButton("Calculate", actionPerformed=self.doCalc,
                          enabled=1, mnemonic=awtevent.KeyEvent.VK_C)
        cancelb = self.__cancelButton = \
             swing.JButton("Cancel", actionPerformed=self.doCancel,
                          enabled=0, mnemonic=awtevent.KeyEvent.VK_L)

        vl = ValueLayout(5, 5)
        inp = swing.JPanel(vl)
        vl.setLayoutAlignmentX(inp, 0.2)
        inp.add(inl); inp.add(inf, inl)
        self.add(inp, awt.BorderLayout.NORTH)

        vl = ValueLayout(5, 5)
        outp = swing.JPanel(vl)
        vl.setLayoutAlignmentX(outp, 0.2)
        outp.add(outl); outp.add(swing.JScrollPane(outf), outl)

        xoutp = swing.JPanel(awt.BorderLayout())
        xoutp.add(progB, awt.BorderLayout.NORTH)
        xoutp.add(outp, awt.BorderLayout.CENTER)

        self.add(xoutp, awt.BorderLayout.CENTER)

        sp = swing.JPanel(awt.BorderLayout())

        bp = swing.JPanel()
        bp.add(calcb)
        bp.add(cancelb)
        sp.add(bp, awt.BorderLayout.NORTH)

        sl = self.__statusLabel = swing.JLabel(" ")
        sp.add(sl, awt.BorderLayout.SOUTH)
        self.add(sp, awt.BorderLayout.SOUTH)

-- main entry point; launches the GUI in a frame
if __name__ == "__main__":
    print sys.argv[0], "running..."
    frame = swing.JFrame("Factorial Calculator",
                defaultCloseOperation=swing.JFrame.EXIT_ON_CLOSE)
    cp = frame.contentPane
    cp.layout = awt.BorderLayout()
    cp.add( FactorialGui(Factorial()) )
    frame.size = 900, 500
    frame.visible = 1

import org.python.core.*;

public class factor extends java.lang.Object {
     static String[] jpy$mainProperties =
         new String[] {"python.modules.builtin",
                       "exceptions:org.python.core.exceptions"};

     static String[] jpy$proxyProperties =
         new String[] {"python.modules.builtin",
                       "exceptions:org.python.core.exceptions",
                       "python.options.showJavaExceptions",
                       "true"};

     static String[] jpy$packages = new String[] {};

     public static class _PyInner extends PyFunctionTable
            implements PyRunnable {
         private static PyObject i$0;
         private static PyObject i$1;
         private static PyObject s$2;
         private static PyObject l$3;
         private static PyObject i$4;
         private static PyObject s$5;
         private static PyObject s$6;
         private static PyObject s$7;
         private static PyObject s$8;
         private static PyObject s$9;
         private static PyObject i$10;
         private static PyObject i$11;
         private static PyObject s$12;
         private static PyFunctionTable funcTable;
         private static PyCode c$0___init__;
         private static PyCode c$1_addListener;
         private static PyCode c$2_addListeners;
         private static PyCode c$3_removeListener;
         private static PyCode c$4_removeListeners;
         private static PyCode c$5_fireListeners;
         private static PyCode c$6_cancel;
         private static PyCode c$7_calculate;
         private static PyCode c$8_Factorial;
         private static PyCode c$9_doFac;
         private static PyCode c$10_main;
         private static void initConstants() {
             i$0 = Py.newInteger(0);
             i$1 = Py.newInteger(1);
             s$2 = Py.newString("only positive integers supported: ");
             l$3 = Py.newLong("1");
             i$4 = Py.newInteger(100);
             s$5 = Py.newString("__main__");
             s$6 = Py.newString("running...");
             s$7 = Py.newString("For");
             s$8 = Py.newString("result =");
             s$9 = Py.newString("Exception -");
             i$10 = Py.newInteger(10);
             i$11 = Py.newInteger(1000);
             s$12 = Py.newString("C:\\Articles\\factor.py");
             funcTable = new _PyInner();
             c$0___init__ = Py.newCode(1, new String[] {"self"},
                                       "C:\\Articles\\factor.py",
                                       "__init__", false, false,
                                       funcTable, 0,
                                       null, null, 0, 1);
             c$1_addListener = Py.newCode(2,
                                          new String[]
                                          {"self", "listener", "ll"},
                                          "C:\\Articles\\factor.py",
                                          "addListener", false,
                                          false, funcTable, 1,
                                          null, null, 0, 1);
             c$2_addListeners = Py.newCode(2,
                                          new String[]
                                          {"self", "listeners", "l"},
                                          "C:\\Articles\\factor.py",
                                          "addListeners", false,
                                          false, funcTable, 2,
                                          null, null, 0, 1);
             c$3_removeListener = Py.newCode(2,
                                          new String[]
                                          {"self", "listener", "ll"},
                                          "C:\\Articles\\factor.py",
                                          "removeListener", false,
                                          false, funcTable, 3,
                                          null, null, 0, 1);
             c$4_removeListeners = Py.newCode(2,
                                          new String[]
                                          {"self", "listeners", "l"},
                                          "C:\\Articles\\factor.py",
                                          "removeListeners", false,
                                          false, funcTable, 4,
                                           null, null, 0, 1);
             c$5_fireListeners = Py.newCode(2,
                                          new String[]
                                          {"self", "value", "func"},
                                          "C:\\Articles\\factor.py",
                                          "fireListeners", false,
                                          false, funcTable, 5,
                                          null, null, 0, 1);
             c$6_cancel = Py.newCode(1,
                                          new String[]
                                          {"self"},
                                          "C:\\Articles\\factor.py",
                                          "cancel", false,
                                          false, funcTable, 6,
                                          null, null, 0, 1);
             c$7_calculate = Py.newCode(2,
                                          new String[]
                                          {"self", "value", "next",
                                           "x", "last", "result"},
                                          "C:\\Articles\\factor.py",
                                          "calculate", false,
                                          false, funcTable, 7,
                                          null, null, 0, 1);
             c$8_Factorial = Py.newCode(0,
                                          new String[]
                                          {},
                                          "C:\\Articles\\factor.py",
                                          "Factorial", false,
                                          false, funcTable, 8,
                                          null, null, 0, 0);
             c$9_doFac = Py.newCode(1,
                                          new String[]
                                          {"value", "e"},
                                          "C:\\Articles\\factor.py",
                                          "doFac", false,
                                          false, funcTable, 9,
                                          null, null, 0, 1);
             c$10_main = Py.newCode(0,
                                          new String[] {},
                                          "C:\\Articles\\factor.py",
                                          "main", false,
                                          false, funcTable, 10,
                                          null, null, 0, 0);
         }


         public PyCode getMain() {
             if (c$10_main == null) _PyInner.initConstants();
             return c$10_main;
         }

         public PyObject call_function(int index, PyFrame frame) {
             switch (index){
                 case 0:
                 return _PyInner.__init__$1(frame);
                 case 1:
                 return _PyInner.addListener$2(frame);
                 case 2:
                 return _PyInner.addListeners$3(frame);
                 case 3:
                 return _PyInner.removeListener$4(frame);
                 case 4:
                 return _PyInner.removeListeners$5(frame);
                 case 5:
                 return _PyInner.fireListeners$6(frame);
                 case 6:
                 return _PyInner.cancel$7(frame);
                 case 7:
                 return _PyInner.calculate$8(frame);
                 case 8:
                 return _PyInner.Factorial$9(frame);
                 case 9:
                 return _PyInner.doFac$10(frame);
                 case 10:
                 return _PyInner.main$11(frame);
                 default:
                 return null;
             }
         }

         private static PyObject __init__$1(PyFrame frame) {
             frame.getlocal(0).__setattr__("_Factorial__listeners",
                            new PyList(new PyObject[] {}));
             frame.getlocal(0).__setattr__("_Factorial__cancelled", i$0);
             return Py.None;
         }

         private static PyObject addListener$2(PyFrame frame) {
             frame.setlocal(2,
                  frame.getlocal(0).__getattr__("_Factorial__listeners"));
             if (frame.getlocal(1)._notin(
                    frame.getlocal(2) ).__nonzero__()) {
                 frame.getlocal(2).invoke("append", frame.getlocal(1));
             }
             return Py.None;
         }

         private static PyObject addListeners$3(PyFrame frame) {
             // Temporary Variables
             int t$0$int;
             PyObject t$0$PyObject, t$1$PyObject;

             // Code
             t$0$int = 0;
             t$1$PyObject = frame.getlocal(1);
             while ((t$0$PyObject =
                    t$1$PyObject.__finditem__(t$0$int++)) != null) {
                 frame.setlocal(2, t$0$PyObject);
                 frame.getlocal(0).invoke("addListener",
                     frame.getlocal(2));
             }
             return Py.None;
         }

                       private static PyObject removeListener$4(PyFrame frame) {
             frame.setlocal(2,
    frame.getlocal(0).__getattr__("_Factorial__listeners"));
             frame.getlocal(2).invoke("remove", frame.getlocal(1));
             return Py.None;
         }

         private static PyObject removeListeners$5(PyFrame frame) {
             // Temporary Variables
             int t$0$int;
             PyObject t$0$PyObject, t$1$PyObject;

             // Code
             t$0$int = 0;
             t$1$PyObject = frame.getlocal(1);
             while ((t$0$PyObject =
     t$1$PyObject.__finditem__(t$0$int++)) != null) {
                 frame.setlocal(2, t$0$PyObject);
                 frame.getlocal(0).invoke("removeListener",
                        frame.getlocal(2));
             }
             return Py.None;
         }

         private static PyObject fireListeners$6(PyFrame frame) {
             // Temporary Variables
             int t$0$int;
             PyObject t$0$PyObject, t$1$PyObject;

             // Code
             t$0$int = 0;
             t$1$PyObject =
                frame.getlocal(0).__getattr__("_Factorial__listeners");
             while ((t$0$PyObject =
                     t$1$PyObject.__finditem__(t$0$int++)) != null) {
                 frame.setlocal(2, t$0$PyObject);
                 frame.getlocal(2).__call__(frame.getlocal(1));
             }
             return Py.None;
         }

         private static PyObject cancel$7(PyFrame frame) {
             frame.getlocal(0).__setattr__("_Factorial__cancelled", i$1);
             return Py.None;
         }

         private static PyObject calculate$8(PyFrame frame) {
             // Temporary Variables
             int t$0$int;
             PyObject t$0$PyObject, t$1$PyObject;

             // Code
             if (((t$0$PyObject = frame.getglobal("type").
                  __call__(frame.getlocal(1)).
                  _ne(frame.getglobal("types").
                  __getattr__("IntType"))).__nonzero__()
                ? t$0$PyObject
                : frame.getlocal(1)._lt(i$0)).__nonzero__()) {
                 throw Py.makeException(
                    frame.getglobal("ValueError"),
                    s$2._add(frame.getglobal("str").
                       __call__(frame.getlocal(1))));
             }
             frame.getlocal(0).__setattr__("_Factorial__cancelled", i$0);
             frame.setlocal(5, l$3);
             frame.getlocal(0).invoke("fireListeners", i$0);
             if (frame.getlocal(1)._le(i$1).__nonzero__()) {
                 frame.setlocal(5, l$3);
             }
             else {
                 frame.setlocal(4, i$0);
                 t$0$int = 0;
                 t$1$PyObject = frame.getglobal("range").
                   __call__(i$1,frame.getlocal(1)._add(i$1));
                 while ((t$0$PyObject = t$1$PyObject.
                           __finditem__(t$0$int++)) != null) {
                     frame.setlocal(3, t$0$PyObject);
                     if (frame.getlocal(0).
                         __getattr__("_Factorial__cancelled").__nonzero__()) {
                         break;
                     }
                     frame.setlocal(5,
                        frame.getlocal(5)._mul(frame.getlocal(3)));
                     frame.setlocal(2,
                        frame.getlocal(3)._mul(i$4)._div(frame.getlocal(1)));
                     if 
(frame.getlocal(2)._ne(frame.getlocal(4)).__nonzero__()) {
                         frame.getlocal(0).invoke("fireListeners",
                            frame.getlocal(2));
                         frame.setlocal(4, frame.getlocal(2));
                     }
                 }
             }
             frame.getlocal(0).invoke("fireListeners", i$4);
             if (frame.getlocal(0).
                 __getattr__("_Factorial__cancelled").__nonzero__()) {
                 frame.setlocal(5, i$1.__neg__());
             }
             return frame.getlocal(5);
         }

         private static PyObject Factorial$9(PyFrame frame) {
             frame.setlocal("__init__",
                 new PyFunction(frame.f_globals,
                                new PyObject[] {}, c$0___init__));
             frame.setlocal("addListener",
                 new PyFunction(frame.f_globals,
                                new PyObject[] {}, c$1_addListener));
             frame.setlocal("addListeners",
                 new PyFunction(frame.f_globals,
                                new PyObject[] {}, c$2_addListeners));
             frame.setlocal("removeListener",
                 new PyFunction(frame.f_globals,
                                new PyObject[] {}, c$3_removeListener));
             frame.setlocal("removeListeners",
                 new PyFunction(frame.f_globals,
                                new PyObject[] {}, c$4_removeListeners));
             frame.setlocal("fireListeners",
                new PyFunction(frame.f_globals,
                               new PyObject[] {}, c$5_fireListeners));
             frame.setlocal("cancel",
                new PyFunction(frame.f_globals,
                               new PyObject[] {}, c$6_cancel));
             frame.setlocal("calculate",
                new PyFunction(frame.f_globals,
                               new PyObject[] {}, c$7_calculate));
             return frame.getf_locals();
         }

         private static PyObject doFac$10(PyFrame frame) {
             // Temporary Variables
             PyException t$0$PyException;

             // Code
             try {
                 Py.printComma(s$7);
                 Py.printComma(frame.getlocal(0));
                 Py.printComma(s$8);
                 Py.println(frame.getglobal("fac").
                    invoke("calculate", frame.getlocal(0)));
             }
             catch (Throwable x$0) {
                 t$0$PyException = Py.setException(x$0, frame);
                 if (Py.matchException(t$0$PyException,
                                       frame.getglobal("ValueError"))) {
                     frame.setlocal(1, t$0$PyException.value);
                     Py.printComma(s$9);
                     Py.println(frame.getlocal(1));
                 }
                 else throw t$0$PyException;
             }
             return Py.None;
         }

         private static PyObject main$11(PyFrame frame) {
             frame.setglobal("__file__", s$12);

             frame.setlocal("sys",
                           org.python.core.imp.importOne("sys", frame));
             frame.setlocal("types",
                           org.python.core.imp.importOne("types", frame));
             frame.setlocal("exceptions",
                           org.python.core.imp.importOne("exceptions", frame));
             frame.setlocal("Factorial",
                           Py.makeClass("Factorial",
                                        new PyObject[] {}, 
c$8_Factorial, null));
             if (frame.getname("__name__")._eq(s$5).__nonzero__()) {
                 Py.printComma(frame.getname("sys").
                               __getattr__("argv").__getitem__(i$0));
                 Py.println(s$6);
                 frame.setlocal("fac",
                                frame.getname("Factorial").__call__());
                 frame.setlocal("doFac",
                                new PyFunction(frame.f_globals,
                                               new PyObject[] {}, c$9_doFac));
                 frame.getname("doFac").__call__(i$1.__neg__());
                 frame.getname("doFac").__call__(i$0);
                 frame.getname("doFac").__call__(i$1);
                 frame.getname("doFac").__call__(i$10);
                 frame.getname("doFac").__call__(i$4);
                 frame.getname("doFac").__call__(i$11);
             }
             return Py.None;
         }

     }
     public static void moduleDictInit(PyObject dict) {
         dict.__setitem__("__name__", new PyString("factor"));
         Py.runCode(new _PyInner().getMain(), dict, dict);
     }

     public static void main(String[] args) throws java.lang.Exception {
         String[] newargs = new String[args.length+1];
         newargs[0] = "factor";
         System.arraycopy(args, 0, newargs, 1, args.length);
         Py.runMain(factor._PyInner.class, newargs,
                    factor.jpy$packages,
                    factor.jpy$mainProperties, null,
                    new String[] {"factor"});
     }

}

    %{(key)}{flag}...{width}{.precision}x

print "%s is %i %s %s than %s!" % ("John", 5, "years", "older", "Mark")

print "Name: %(last)s, %(first)s" % \
	{'first':"Barry", 'last':"Feigenbaum", 'age':18}

John is 5 years older than Mark!
Name: Feigenbaum, Barry