Webware for Python

Is there a way to use PSP without buying into the rest of Webware?  I
have my own home grown template library I've been using for the last
while, and it has come up that people want to butcher my nice templates
by loading them into GoLive and such; some experimentation has shown
that ASP syntax is less likely to be butchered out of hand.

BTW, while I think Webware looks great, I'd rather it get a little more
mature before I buy into it; the recent memory leaks come to mind.
--=20
Graham Hughes <graham@...>
GNUPG fingerprint: 5A6B 3786 6722 6897 7118  00E4 FFE6 3360 D2D7 5CDF

I've added Webware/MiscUtils/DataTable.py for the first time. I use this 
class quite a bit when I develop web sites to store data and configuration 
information in comma-separated-value files. These files can then be edited 
to affect the web site by people who don't necessarily know Python (or even 
HTML).

There is substantial and interesting documentation at the top of the file.

-Chuck

As most of you know, for WebKit there is always an adapter that resides 
between the web server and the app server. It accepts raw requests in a CGI 
like format and sends them to the app server which eventually sends back a 
raw response to the adapter.

(I use the term 'raw' to emphasize that these are not the request and 
response Python objects used inside the app server during the transaction's 
life cycle.)

The current format for a raw response is a dictionary which gets mashalled 
over a socket (marshalling is a more primitive and faster form of 
pickling). As someone pointed out, the entire raw response has to be read 
by the adapter before it can be fed to the web server. For longer requests, 
it would be beneficial to be able to piece-meal the response.

So we need a "naked text" format. I propose that the format just be the 
final response form: a series of headers separated by newlines followed by 
an extra newline and the content.

Some adapters can just pass this through. Other adapters, like mod_python, 
may need to parse the header information. No matter what format we go with 
there is going to be some kind of parsing for adapters that want to 
"understand" the headers. I figure we might as well go with a format that 
can often be passed straight to the web server with no interpretation.

Comments and questions are welcome before I proceed...

-Chuck

Consider the following test:

one.py:
	globals = {'x': 0}
	execfile('two.py', globals)

two.py:
	print 'globals =', globals().keys()

output:
	globals = ['x', '__builtins__']


This looks perfect to me. one.py executes two.py and passes it 'x' which is 
obviously received as evidenced by the print statement.


Now in Webware/WebKit/ServletFactory.py we have the following snippet:

	globals = {}
	execfile(path, globals)

I changed globals to {'x': 0} and put a print statement at the top of 
servlet file. The servlet reports it's globals as:

['__doc__', '__file__', '__name__', '__builtins__']


The 'x' doesn't show up and can't be used. Also, there are some extra 
globals ('__doc__', '__file__', '__name__') that don't show up in the first 
example. In fact, they remind me of modules, but I'm using execfile() not 
one of the import functions or statements.

One other difference that comes to mind is that the ServletFactory resides 
in a Python package and the my example one.py does not.

I'm using the latest CVS.


Anybody have any ideas on what gives?


My ultimate goal is to pass the transaction object into the servlet script 
upon loading in case it needs access to special objects (like the 
application or app server) at load time in order to initialize itself. This 
is a nice, easy hook that could come in handy.  Like in my current 
project.  :-)

-Chuck