required Python version: 2.4
required cherrypy version: 2.1

The state of the code is very pre alpha.
At the moment, it will run out of the box on localhost:8080
The 'localhost:8080' is hardcoded into the JsonRpc examples.
If you need to change this, edit the
'BASEURL' variable in 'application.py'.

Everything looks quite ugly. I just didn't have the nerve left, to do something nice looking :)

There is nearly no documentation available. The JavaScript library AKit (download from same page) does contain some docs and 
examples.

The important bits and pieces
-----------------------------
I like Cheetah. What I like most about Cheetah is the possibility to tell a template, what namespaces are available for name
searching. The DOMElement objects of Element.py will marry a TALesque way of creating elements with the namespace idea (and
of course the 'widget' idea from normal GUI development).
All of this is really nothing new and probably done in a similar way by anybody who likes to reinvent the wheel.
What goes a bit further, is the possibility to represent the resulting DOM fragment not only as HTML/XML text, but also
in a JSON compatible format. This JSON compatible format can be used when getting Widgets by a JSON-RPC request.
So, the important bit is (at least for me), that the DOM Fragments (or Widgets) can have different representations and the
functions/methods that have to build a widget, don't need to know, which representation is used.

The AKit JavaScript library contains some stuff I missed in MochiKit. Most importantly, the JsonRpc client code.
Since MochiKit works with deferreds, a call to a jsonrpc client method returns a deferred as well. To keep the code
a bit more localized, one can tell the client objects what callbacks are to stick onto the returned deferreds.
Guess this sounds more complicated that it is.
The shortest example is 'ElementTunneling' and it contains everything that is important here.

So, coming back to what I asked on the Web-Sig mailing list, what I'd like to discuss are ways, to put all
these things together and create an interface that hides all the gory details. As an implementor of web applications,
I really don't want to see any JavaScript in my code (and actually, I don't want to see any HTML as well).
In short, I want to abstract everything away. The look should be hidden behind abstract Widgets and the actions
should be implemented as Python methods.






Element.py
----------
contains Html + Widget code.
The idea is that the elements can be rendered as html, if they are rendered by the server side, 
or in json, if they are transfered to the client and rendered there.

Widgets.py
----------
Some Widgets that are used in the examples

jsonrpcfilter.py
----------------
well, this is the json-rpc filter for cherrypy (surprise, surprise!!!!)

minjson.py
----------
Jim Washington's minjson.py

script/MochiKit.js
------------------
packed version of MochiKit

script/AKit.js
--------------
packed version of AKit

application.py
--------------
the cherrypy server

config.cfg
----------
the cherrypy server configuration