Please file new bugs on Launchpad: Invirt or XVM (if you're not sure which, just pick one)

Context Navigation

source: package_branches/invirt-web/ajaxterm-rebased/code/qweb.py @ 2748

Last change on this file since 2748 was 2747, checked in by broder, 15 years ago
Import upstream ajaxterm 0.10
File size: 49.1 KB

Line
1	#!/usr/bin/python2.3
2	#
3	# vim:set et ts=4 fdc=0 fdn=2 fdl=0:
4	#
5	# There are no blank lines between blocks beacause i use folding from:
6	# http://www.vim.org/scripts/script.php?script_id=515
7	#
8
9	"""= QWeb Framework =
10
11	== What is QWeb ? ==
12
13	QWeb is a python based [http://www.python.org/doc/peps/pep-0333/ WSGI]
14	compatible web framework, it provides an infratructure to quickly build web
15	applications consisting of:
16
17	* A lightweight request handler (QWebRequest)
18	* An xml templating engine (QWebXml and QWebHtml)
19	* A simple name based controler (qweb_control)
20	* A standalone WSGI Server (QWebWSGIServer)
21	* A cgi and fastcgi WSGI wrapper (taken from flup)
22	* A startup function that starts cgi, factgi or standalone according to the
23	evironement (qweb_autorun).
24
25	QWeb applications are runnable in standalone mode (from commandline), via
26	FastCGI, Regular CGI or by any python WSGI compliant server.
27
28	QWeb doesn't provide any database access but it integrates nicely with ORMs
29	such as SQLObject, SQLAlchemy or plain DB-API.
30
31	Written by Antony Lesuisse (email al AT udev.org)
32
33	Homepage: http://antony.lesuisse.org/qweb/trac/
34
35	Forum: [http://antony.lesuisse.org/qweb/forum/viewforum.php?id=1 Forum]
36
37	== Quick Start (for Linux, MacOS X and cygwin) ==
38
39	Make sure you have at least python 2.3 installed and run the following commands:
40
41	{{{
42	$ wget http://antony.lesuisse.org/qweb/files/QWeb-0.7.tar.gz
43	$ tar zxvf QWeb-0.7.tar.gz
44	$ cd QWeb-0.7/examples/blog
45	$ ./blog.py
46	}}}
47
48	And point your browser to http://localhost:8080/
49
50	You may also try AjaxTerm which uses qweb request handler.
51
52	== Download ==
53
54	* Version 0.7:
55	* Source [/qweb/files/QWeb-0.7.tar.gz QWeb-0.7.tar.gz]
56	* Python 2.3 Egg [/qweb/files/QWeb-0.7-py2.3.egg QWeb-0.7-py2.3.egg]
57	* Python 2.4 Egg [/qweb/files/QWeb-0.7-py2.4.egg QWeb-0.7-py2.4.egg]
58
59	* [/qweb/trac/browser Browse the source repository]
60
61	== Documentation ==
62
63	* [/qweb/trac/browser/trunk/README.txt?format=raw Read the included documentation]
64	* QwebTemplating
65
66	== Mailin-list ==
67
68	* Forum: [http://antony.lesuisse.org/qweb/forum/viewforum.php?id=1 Forum]
69	* No mailing-list exists yet, discussion should happen on: [http://mail.python.org/mailman/listinfo/web-sig web-sig] [http://mail.python.org/pipermail/web-sig/ archives]
70
71	QWeb Components:
72	----------------
73
74	QWeb also feature a simple components api, that enables developers to easily
75	produces reusable components.
76
77	Default qweb components:
78
79	- qweb_static:
80	A qweb component to serve static content from the filesystem or from
81	zipfiles.
82
83	- qweb_dbadmin:
84	scaffolding for sqlobject
85
86	License
87	-------
88	qweb/fcgi.py wich is BSD-like from saddi.com.
89	Everything else is put in the public domain.
90
91
92	TODO
93	----
94	Announce QWeb to python-announce-list@python.org web-sig@python.org
95	qweb_core
96	rename request methods into
97	request_save_files
98	response_404
99	response_redirect
100	response_download
101	request callback_generator, callback_function ?
102	wsgi callback_server_local
103	xml tags explicitly call render_attributes(t_att)?
104	priority form-checkbox over t-value (for t-option)
105
106	"""
107
108	import BaseHTTPServer,SocketServer,Cookie
109	import cgi,datetime,email,email.Message,errno,gzip,os,random,re,socket,sys,tempfile,time,types,urllib,urlparse,xml.dom
110	try:
111	import cPickle as pickle
112	except ImportError:
113	import pickle
114	try:
115	import cStringIO as StringIO
116	except ImportError:
117	import StringIO
118
119	#----------------------------------------------------------
120	# Qweb Xml t-raw t-esc t-if t-foreach t-set t-call t-trim
121	#----------------------------------------------------------
122	class QWebEval:
123	def __init__(self,data):
124	self.data=data
125	def __getitem__(self,expr):
126	if self.data.has_key(expr):
127	return self.data[expr]
128	r=None
129	try:
130	r=eval(expr,self.data)
131	except NameError,e:
132	pass
133	except AttributeError,e:
134	pass
135	except Exception,e:
136	print "qweb: expression error '%s' "%expr,e
137	if self.data.has_key("__builtins__"):
138	del self.data["__builtins__"]
139	return r
140	def eval_object(self,expr):
141	return self[expr]
142	def eval_str(self,expr):
143	if expr=="0":
144	return self.data[0]
145	if isinstance(self[expr],unicode):
146	return self[expr].encode("utf8")
147	return str(self[expr])
148	def eval_format(self,expr):
149	try:
150	return str(expr%self)
151	except:
152	return "qweb: format error '%s' "%expr
153	# if isinstance(r,unicode):
154	# return r.encode("utf8")
155	def eval_bool(self,expr):
156	if self.eval_object(expr):
157	return 1
158	else:
159	return 0
160	class QWebXml:
161	"""QWeb Xml templating engine
162
163	The templating engine use a very simple syntax, "magic" xml attributes, to
164	produce any kind of texutal output (even non-xml).
165
166	QWebXml:
167	the template engine core implements the basic magic attributes:
168
169	t-att t-raw t-esc t-if t-foreach t-set t-call t-trim
170
171	"""
172	def __init__(self,x=None,zipname=None):
173	self.node=xml.dom.Node
174	self._t={}
175	self._render_tag={}
176	prefix='render_tag_'
177	for i in [j for j in dir(self) if j.startswith(prefix)]:
178	name=i[len(prefix):].replace('_','-')
179	self._render_tag[name]=getattr(self.__class__,i)
180
181	self._render_att={}
182	prefix='render_att_'
183	for i in [j for j in dir(self) if j.startswith(prefix)]:
184	name=i[len(prefix):].replace('_','-')
185	self._render_att[name]=getattr(self.__class__,i)
186
187	if x!=None:
188	if zipname!=None:
189	import zipfile
190	zf=zipfile.ZipFile(zipname, 'r')
191	self.add_template(zf.read(x))
192	else:
193	self.add_template(x)
194	def register_tag(self,tag,func):
195	self._render_tag[tag]=func
196	def add_template(self,x):
197	if hasattr(x,'documentElement'):
198	dom=x
199	elif x.startswith("<?xml"):
200	import xml.dom.minidom
201	dom=xml.dom.minidom.parseString(x)
202	else:
203	import xml.dom.minidom
204	dom=xml.dom.minidom.parse(x)
205	for n in dom.documentElement.childNodes:
206	if n.nodeName=="t":
207	self._t[str(n.getAttribute("t-name"))]=n
208	def get_template(self,name):
209	return self._t[name]
210
211	def eval_object(self,expr,v):
212	return QWebEval(v).eval_object(expr)
213	def eval_str(self,expr,v):
214	return QWebEval(v).eval_str(expr)
215	def eval_format(self,expr,v):
216	return QWebEval(v).eval_format(expr)
217	def eval_bool(self,expr,v):
218	return QWebEval(v).eval_bool(expr)
219
220	def render(self,tname,v={},out=None):
221	if self._t.has_key(tname):
222	return self.render_node(self._t[tname],v)
223	else:
224	return 'qweb: template "%s" not found'%tname
225	def render_node(self,e,v):
226	r=""
227	if e.nodeType==self.node.TEXT_NODE or e.nodeType==self.node.CDATA_SECTION_NODE:
228	r=e.data.encode("utf8")
229	elif e.nodeType==self.node.ELEMENT_NODE:
230	pre=""
231	g_att=""
232	t_render=None
233	t_att={}
234	for (an,av) in e.attributes.items():
235	an=str(an)
236	if isinstance(av,types.UnicodeType):
237	av=av.encode("utf8")
238	else:
239	av=av.nodeValue.encode("utf8")
240	if an.startswith("t-"):
241	for i in self._render_att:
242	if an[2:].startswith(i):
243	g_att+=self._render_att[i](self,e,an,av,v)
244	break
245	else:
246	if self._render_tag.has_key(an[2:]):
247	t_render=an[2:]
248	t_att[an[2:]]=av
249	else:
250	g_att+=' %s="%s"'%(an,cgi.escape(av,1));
251	if t_render:
252	if self._render_tag.has_key(t_render):
253	r=self._render_tag[t_render](self,e,t_att,g_att,v)
254	else:
255	r=self.render_element(e,g_att,v,pre,t_att.get("trim",0))
256	return r
257	def render_element(self,e,g_att,v,pre="",trim=0):
258	g_inner=[]
259	for n in e.childNodes:
260	g_inner.append(self.render_node(n,v))
261	name=str(e.nodeName)
262	inner="".join(g_inner)
263	if trim==0:
264	pass
265	elif trim=='left':
266	inner=inner.lstrip()
267	elif trim=='right':
268	inner=inner.rstrip()
269	elif trim=='both':
270	inner=inner.strip()
271	if name=="t":
272	return inner
273	elif len(inner):
274	return "<%s%s>%s%s</%s>"%(name,g_att,pre,inner,name)
275	else:
276	return "<%s%s/>"%(name,g_att)
277
278	# Attributes
279	def render_att_att(self,e,an,av,v):
280	if an.startswith("t-attf-"):
281	att,val=an[7:],self.eval_format(av,v)
282	elif an.startswith("t-att-"):
283	att,val=(an[6:],self.eval_str(av,v))
284	else:
285	att,val=self.eval_object(av,v)
286	return ' %s="%s"'%(att,cgi.escape(val,1))
287
288	# Tags
289	def render_tag_raw(self,e,t_att,g_att,v):
290	return self.eval_str(t_att["raw"],v)
291	def render_tag_rawf(self,e,t_att,g_att,v):
292	return self.eval_format(t_att["rawf"],v)
293	def render_tag_esc(self,e,t_att,g_att,v):
294	return cgi.escape(self.eval_str(t_att["esc"],v))
295	def render_tag_escf(self,e,t_att,g_att,v):
296	return cgi.escape(self.eval_format(t_att["escf"],v))
297	def render_tag_foreach(self,e,t_att,g_att,v):
298	expr=t_att["foreach"]
299	enum=self.eval_object(expr,v)
300	if enum!=None:
301	var=t_att.get('as',expr).replace('.','_')
302	d=v.copy()
303	size=-1
304	if isinstance(enum,types.ListType):
305	size=len(enum)
306	elif isinstance(enum,types.TupleType):
307	size=len(enum)
308	elif hasattr(enum,'count'):
309	size=enum.count()
310	d["%s_size"%var]=size
311	d["%s_all"%var]=enum
312	index=0
313	ru=[]
314	for i in enum:
315	d["%s_value"%var]=i
316	d["%s_index"%var]=index
317	d["%s_first"%var]=index==0
318	d["%s_even"%var]=index%2
319	d["%s_odd"%var]=(index+1)%2
320	d["%s_last"%var]=index+1==size
321	if index%2:
322	d["%s_parity"%var]='odd'
323	else:
324	d["%s_parity"%var]='even'
325	if isinstance(i,types.DictType):
326	d.update(i)
327	else:
328	d[var]=i
329	ru.append(self.render_element(e,g_att,d))
330	index+=1
331	return "".join(ru)
332	else:
333	return "qweb: t-foreach %s not found."%expr
334	def render_tag_if(self,e,t_att,g_att,v):
335	if self.eval_bool(t_att["if"],v):
336	return self.render_element(e,g_att,v)
337	else:
338	return ""
339	def render_tag_call(self,e,t_att,g_att,v):
340	# TODO t-prefix
341	if t_att.has_key("import"):
342	d=v
343	else:
344	d=v.copy()
345	d[0]=self.render_element(e,g_att,d)
346	return self.render(t_att["call"],d)
347	def render_tag_set(self,e,t_att,g_att,v):
348	if t_att.has_key("eval"):
349	v[t_att["set"]]=self.eval_object(t_att["eval"],v)
350	else:
351	v[t_att["set"]]=self.render_element(e,g_att,v)
352	return ""
353
354	#----------------------------------------------------------
355	# QWeb HTML (+deprecated QWebFORM and QWebOLD)
356	#----------------------------------------------------------
357	class QWebURL:
358	""" URL helper
359	assert req.PATH_INFO== "/site/admin/page_edit"
360	u = QWebURL(root_path="/site/",req_path=req.PATH_INFO)
361	s=u.url2_href("user/login",{'a':'1'})
362	assert s=="../user/login?a=1"
363
364	"""
365	def __init__(self, root_path="/", req_path="/",defpath="",defparam={}):
366	self.defpath=defpath
367	self.defparam=defparam
368	self.root_path=root_path
369	self.req_path=req_path
370	self.req_list=req_path.split("/")[:-1]
371	self.req_len=len(self.req_list)
372	def decode(self,s):
373	h={}
374	for k,v in cgi.parse_qsl(s,1):
375	h[k]=v
376	return h
377	def encode(self,h):
378	return urllib.urlencode(h.items())
379	def request(self,req):
380	return req.REQUEST
381	def copy(self,path=None,param=None):
382	npath=self.defpath
383	if path:
384	npath=path
385	nparam=self.defparam.copy()
386	if param:
387	nparam.update(param)
388	return QWebURL(self.root_path,self.req_path,npath,nparam)
389	def path(self,path=''):
390	if not path:
391	path=self.defpath
392	pl=(self.root_path+path).split('/')
393	i=0
394	for i in range(min(len(pl), self.req_len)):
395	if pl[i]!=self.req_list[i]:
396	break
397	else:
398	i+=1
399	dd=self.req_len-i
400	if dd<0:
401	dd=0
402	return '/'.join(['..']*dd+pl[i:])
403	def href(self,path='',arg={}):
404	p=self.path(path)
405	tmp=self.defparam.copy()
406	tmp.update(arg)
407	s=self.encode(tmp)
408	if len(s):
409	return p+"?"+s
410	else:
411	return p
412	def form(self,path='',arg={}):
413	p=self.path(path)
414	tmp=self.defparam.copy()
415	tmp.update(arg)
416	r=''.join(['<input type="hidden" name="%s" value="%s"/>'%(k,cgi.escape(str(v),1)) for k,v in tmp.items()])
417	return (p,r)
418	class QWebField:
419	def __init__(self,name=None,default="",check=None):
420	self.name=name
421	self.default=default
422	self.check=check
423	# optional attributes
424	self.type=None
425	self.trim=1
426	self.required=1
427	self.cssvalid="form_valid"
428	self.cssinvalid="form_invalid"
429	# set by addfield
430	self.form=None
431	# set by processing
432	self.input=None
433	self.css=None
434	self.value=None
435	self.valid=None
436	self.invalid=None
437	self.validate(1)
438	def validate(self,val=1,update=1):
439	if val:
440	self.valid=1
441	self.invalid=0
442	self.css=self.cssvalid
443	else:
444	self.valid=0
445	self.invalid=1
446	self.css=self.cssinvalid
447	if update and self.form:
448	self.form.update()
449	def invalidate(self,update=1):
450	self.validate(0,update)
451	class QWebForm:
452	class QWebFormF:
453	pass
454	def __init__(self,e=None,arg=None,default=None):
455	self.fields={}
456	# all fields have been submitted
457	self.submitted=False
458	self.missing=[]
459	# at least one field is invalid or missing
460	self.invalid=False
461	self.error=[]
462	# all fields have been submitted and are valid
463	self.valid=False
464	# fields under self.f for convenience
465	self.f=self.QWebFormF()
466	if e:
467	self.add_template(e)
468	# assume that the fields are done with the template
469	if default:
470	self.set_default(default,e==None)
471	if arg!=None:
472	self.process_input(arg)
473	def __getitem__(self,k):
474	return self.fields[k]
475	def set_default(self,default,add_missing=1):
476	for k,v in default.items():
477	if self.fields.has_key(k):
478	self.fields[k].default=str(v)
479	elif add_missing:
480	self.add_field(QWebField(k,v))
481	def add_field(self,f):
482	self.fields[f.name]=f
483	f.form=self
484	setattr(self.f,f.name,f)
485	def add_template(self,e):
486	att={}
487	for (an,av) in e.attributes.items():
488	an=str(an)
489	if an.startswith("t-"):
490	att[an[2:]]=av.encode("utf8")
491	for i in ["form-text", "form-password", "form-radio", "form-checkbox", "form-select","form-textarea"]:
492	if att.has_key(i):
493	name=att[i].split(".")[-1]
494	default=att.get("default","")
495	check=att.get("check",None)
496	f=QWebField(name,default,check)
497	if i=="form-textarea":
498	f.type="textarea"
499	f.trim=0
500	if i=="form-checkbox":
501	f.type="checkbox"
502	f.required=0
503	self.add_field(f)
504	for n in e.childNodes:
505	if n.nodeType==n.ELEMENT_NODE:
506	self.add_template(n)
507	def process_input(self,arg):
508	for f in self.fields.values():
509	if arg.has_key(f.name):
510	f.input=arg[f.name]
511	f.value=f.input
512	if f.trim:
513	f.input=f.input.strip()
514	f.validate(1,False)
515	if f.check==None:
516	continue
517	elif callable(f.check):
518	pass
519	elif isinstance(f.check,str):
520	v=f.check
521	if f.check=="email":
522	v=r"/^[^@#!& ]+@[A-Za-z0-9-][.A-Za-z0-9-]{0,64}\.[A-Za-z]{2,5}$/"
523	if f.check=="date":
524	v=r"/^(19\|20)\d\d-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])$/"
525	if not re.match(v[1:-1],f.input):
526	f.validate(0,False)
527	else:
528	f.value=f.default
529	self.update()
530	def validate_all(self,val=1):
531	for f in self.fields.values():
532	f.validate(val,0)
533	self.update()
534	def invalidate_all(self):
535	self.validate_all(0)
536	def update(self):
537	self.submitted=True
538	self.valid=True
539	self.errors=[]
540	for f in self.fields.values():
541	if f.required and f.input==None:
542	self.submitted=False
543	self.valid=False
544	self.missing.append(f.name)
545	if f.invalid:
546	self.valid=False
547	self.error.append(f.name)
548	# invalid have been submitted and
549	self.invalid=self.submitted and self.valid==False
550	def collect(self):
551	d={}
552	for f in self.fields.values():
553	d[f.name]=f.value
554	return d
555	class QWebURLEval(QWebEval):
556	def __init__(self,data):
557	QWebEval.__init__(self,data)
558	def __getitem__(self,expr):
559	r=QWebEval.__getitem__(self,expr)
560	if isinstance(r,str):
561	return urllib.quote_plus(r)
562	else:
563	return r
564	class QWebHtml(QWebXml):
565	"""QWebHtml
566	QWebURL:
567	QWebField:
568	QWebForm:
569	QWebHtml:
570	an extended template engine, with a few utility class to easily produce
571	HTML, handle URLs and process forms, it adds the following magic attributes:
572
573	t-href t-action t-form-text t-form-password t-form-textarea t-form-radio
574	t-form-checkbox t-form-select t-option t-selected t-checked t-pager
575
576	# explication URL:
577	# v['tableurl']=QWebUrl({p=afdmin,saar=,orderby=,des=,mlink;meta_active=})
578	# t-href="tableurl?desc=1"
579	#
580	# explication FORM: t-if="form.valid()"
581	# Foreach i
582	# email: <input type="text" t-esc-name="i" t-esc-value="form[i].value" t-esc-class="form[i].css"/>
583	# <input type="radio" name="spamtype" t-esc-value="i" t-selected="i==form.f.spamtype.value"/>
584	# <option t-esc-value="cc" t-selected="cc==form.f.country.value"><t t-esc="cname"></option>
585	# Simple forms:
586	# <input t-form-text="form.email" t-check="email"/>
587	# <input t-form-password="form.email" t-check="email"/>
588	# <input t-form-radio="form.email" />
589	# <input t-form-checkbox="form.email" />
590	# <textarea t-form-textarea="form.email" t-check="email"/>
591	# <select t-form-select="form.email"/>
592	# <option t-value="1">
593	# <input t-form-radio="form.spamtype" t-value="1"/> Cars
594	# <input t-form-radio="form.spamtype" t-value="2"/> Sprt
595	"""
596	# QWebForm from a template
597	def form(self,tname,arg=None,default=None):
598	form=QWebForm(self._t[tname],arg,default)
599	return form
600
601	# HTML Att
602	def eval_url(self,av,v):
603	s=QWebURLEval(v).eval_format(av)
604	a=s.split('?',1)
605	arg={}
606	if len(a)>1:
607	for k,v in cgi.parse_qsl(a[1],1):
608	arg[k]=v
609	b=a[0].split('/',1)
610	path=''
611	if len(b)>1:
612	path=b[1]
613	u=b[0]
614	return u,path,arg
615	def render_att_url_(self,e,an,av,v):
616	u,path,arg=self.eval_url(av,v)
617	if not isinstance(v.get(u,0),QWebURL):
618	out='qweb: missing url %r %r %r'%(u,path,arg)
619	else:
620	out=v[u].href(path,arg)
621	return ' %s="%s"'%(an[6:],cgi.escape(out,1))
622	def render_att_href(self,e,an,av,v):
623	return self.render_att_url_(e,"t-url-href",av,v)
624	def render_att_checked(self,e,an,av,v):
625	if self.eval_bool(av,v):
626	return ' %s="%s"'%(an[2:],an[2:])
627	else:
628	return ''
629	def render_att_selected(self,e,an,av,v):
630	return self.render_att_checked(e,an,av,v)
631
632	# HTML Tags forms
633	def render_tag_rawurl(self,e,t_att,g_att,v):
634	u,path,arg=self.eval_url(t_att["rawurl"],v)
635	return v[u].href(path,arg)
636	def render_tag_escurl(self,e,t_att,g_att,v):
637	u,path,arg=self.eval_url(t_att["escurl"],v)
638	return cgi.escape(v[u].href(path,arg))
639	def render_tag_action(self,e,t_att,g_att,v):
640	u,path,arg=self.eval_url(t_att["action"],v)
641	if not isinstance(v.get(u,0),QWebURL):
642	action,input=('qweb: missing url %r %r %r'%(u,path,arg),'')
643	else:
644	action,input=v[u].form(path,arg)
645	g_att+=' action="%s"'%action
646	return self.render_element(e,g_att,v,input)
647	def render_tag_form_text(self,e,t_att,g_att,v):
648	f=self.eval_object(t_att["form-text"],v)
649	g_att+=' type="text" name="%s" value="%s" class="%s"'%(f.name,cgi.escape(f.value,1),f.css)
650	return self.render_element(e,g_att,v)
651	def render_tag_form_password(self,e,t_att,g_att,v):
652	f=self.eval_object(t_att["form-password"],v)
653	g_att+=' type="password" name="%s" value="%s" class="%s"'%(f.name,cgi.escape(f.value,1),f.css)
654	return self.render_element(e,g_att,v)
655	def render_tag_form_textarea(self,e,t_att,g_att,v):
656	type="textarea"
657	f=self.eval_object(t_att["form-textarea"],v)
658	g_att+=' name="%s" class="%s"'%(f.name,f.css)
659	r="<%s%s>%s</%s>"%(type,g_att,cgi.escape(f.value,1),type)
660	return r
661	def render_tag_form_radio(self,e,t_att,g_att,v):
662	f=self.eval_object(t_att["form-radio"],v)
663	val=t_att["value"]
664	g_att+=' type="radio" name="%s" value="%s"'%(f.name,val)
665	if f.value==val:
666	g_att+=' checked="checked"'
667	return self.render_element(e,g_att,v)
668	def render_tag_form_checkbox(self,e,t_att,g_att,v):
669	f=self.eval_object(t_att["form-checkbox"],v)
670	val=t_att["value"]
671	g_att+=' type="checkbox" name="%s" value="%s"'%(f.name,val)
672	if f.value==val:
673	g_att+=' checked="checked"'
674	return self.render_element(e,g_att,v)
675	def render_tag_form_select(self,e,t_att,g_att,v):
676	f=self.eval_object(t_att["form-select"],v)
677	g_att+=' name="%s" class="%s"'%(f.name,f.css)
678	return self.render_element(e,g_att,v)
679	def render_tag_option(self,e,t_att,g_att,v):
680	f=self.eval_object(e.parentNode.getAttribute("t-form-select"),v)
681	val=t_att["option"]
682	g_att+=' value="%s"'%(val)
683	if f.value==val:
684	g_att+=' selected="selected"'
685	return self.render_element(e,g_att,v)
686
687	# HTML Tags others
688	def render_tag_pager(self,e,t_att,g_att,v):
689	pre=t_att["pager"]
690	total=int(self.eval_str(t_att["total"],v))
691	start=int(self.eval_str(t_att["start"],v))
692	step=int(self.eval_str(t_att.get("step","100"),v))
693	scope=int(self.eval_str(t_att.get("scope","5"),v))
694	# Compute Pager
695	p=pre+"_"
696	d={}
697	d[p+"tot_size"]=total
698	d[p+"tot_page"]=tot_page=total/step
699	d[p+"win_start0"]=total and start
700	d[p+"win_start1"]=total and start+1
701	d[p+"win_end0"]=max(0,min(start+step-1,total-1))
702	d[p+"win_end1"]=min(start+step,total)
703	d[p+"win_page0"]=win_page=start/step
704	d[p+"win_page1"]=win_page+1
705	d[p+"prev"]=(win_page!=0)
706	d[p+"prev_start"]=(win_page-1)*step
707	d[p+"next"]=(tot_page>=win_page+1)
708	d[p+"next_start"]=(win_page+1)*step
709	l=[]
710	begin=win_page-scope
711	end=win_page+scope
712	if begin<0:
713	end-=begin
714	if end>tot_page:
715	begin-=(end-tot_page)
716	i=max(0,begin)
717	while i<=min(end,tot_page) and total!=step:
718	l.append( { p+"page0":i, p+"page1":i+1, p+"start":i*step, p+"sel":(win_page==i) })
719	i+=1
720	d[p+"active"]=len(l)>1
721	d[p+"list"]=l
722	# Update v
723	v.update(d)
724	return ""
725
726	#----------------------------------------------------------
727	# QWeb Simple Controller
728	#----------------------------------------------------------
729	def qweb_control(self,jump='main',p=[]):
730	""" qweb_control(self,jump='main',p=[]):
731	A simple function to handle the controler part of your application. It
732	dispatch the control to the jump argument, while ensuring that prefix
733	function have been called.
734
735	qweb_control replace '/' to '_' and strip '_' from the jump argument.
736
737	name1
738	name1_name2
739	name1_name2_name3
740
741	"""
742	jump=jump.replace('/','_').strip('_')
743	if not hasattr(self,jump):
744	return 0
745	done={}
746	todo=[]
747	while 1:
748	if jump!=None:
749	tmp=""
750	todo=[]
751	for i in jump.split("_"):
752	tmp+=i+"_";
753	if not done.has_key(tmp[:-1]):
754	todo.append(tmp[:-1])
755	jump=None
756	elif len(todo):
757	i=todo.pop(0)
758	done[i]=1
759	if hasattr(self,i):
760	f=getattr(self,i)
761	r=f(*p)
762	if isinstance(r,types.StringType):
763	jump=r
764	else:
765	break
766	return 1
767
768	#----------------------------------------------------------
769	# QWeb WSGI Request handler
770	#----------------------------------------------------------
771	class QWebSession(dict):
772	def __init__(self,environ,**kw):
773	dict.__init__(self)
774	default={
775	"path" : tempfile.gettempdir(),
776	"cookie_name" : "QWEBSID",
777	"cookie_lifetime" : 0,
778	"cookie_path" : '/',
779	"cookie_domain" : '',
780	"limit_cache" : 1,
781	"probability" : 0.01,
782	"maxlifetime" : 3600,
783	"disable" : 0,
784	}
785	for k,v in default.items():
786	setattr(self,'session_%s'%k,kw.get(k,v))
787	# Try to find session
788	self.session_found_cookie=0
789	self.session_found_url=0
790	self.session_found=0
791	self.session_orig=""
792	# Try cookie
793	c=Cookie.SimpleCookie()
794	c.load(environ.get('HTTP_COOKIE', ''))
795	if c.has_key(self.session_cookie_name):
796	sid=c[self.session_cookie_name].value[:64]
797	if re.match('[a-f0-9]+$',sid) and self.session_load(sid):
798	self.session_id=sid
799	self.session_found_cookie=1
800	self.session_found=1
801	# Try URL
802	if not self.session_found_cookie:
803	mo=re.search('&%s=([a-f0-9]+)'%self.session_cookie_name,environ.get('QUERY_STRING',''))
804	if mo and self.session_load(mo.group(1)):
805	self.session_id=mo.group(1)
806	self.session_found_url=1
807	self.session_found=1
808	# New session
809	if not self.session_found:
810	self.session_id='%032x'%random.randint(1,2**128)
811	self.session_trans_sid="&%s=%s"%(self.session_cookie_name,self.session_id)
812	# Clean old session
813	if random.random() < self.session_probability:
814	self.session_clean()
815	def session_get_headers(self):
816	h=[]
817	if (not self.session_disable) and (len(self) or len(self.session_orig)):
818	self.session_save()
819	if not self.session_found_cookie:
820	c=Cookie.SimpleCookie()
821	c[self.session_cookie_name] = self.session_id
822	c[self.session_cookie_name]['path'] = self.session_cookie_path
823	if self.session_cookie_domain:
824	c[self.session_cookie_name]['domain'] = self.session_cookie_domain
825	# if self.session_cookie_lifetime:
826	# c[self.session_cookie_name]['expires'] = TODO date localtime or not, datetime.datetime(1970, 1, 1)
827	h.append(("Set-Cookie", c[self.session_cookie_name].OutputString()))
828	if self.session_limit_cache:
829	h.append(('Cache-Control','no-store, no-cache, must-revalidate, post-check=0, pre-check=0'))
830	h.append(('Expires','Thu, 19 Nov 1981 08:52:00 GMT'))
831	h.append(('Pragma','no-cache'))
832	return h
833	def session_load(self,sid):
834	fname=os.path.join(self.session_path,'qweb_sess_%s'%sid)
835	try:
836	orig=file(fname).read()
837	d=pickle.loads(orig)
838	except:
839	return
840	self.session_orig=orig
841	self.update(d)
842	return 1
843	def session_save(self):
844	if not os.path.isdir(self.session_path):
845	os.makedirs(self.session_path)
846	fname=os.path.join(self.session_path,'qweb_sess_%s'%self.session_id)
847	try:
848	oldtime=os.path.getmtime(fname)
849	except OSError,IOError:
850	oldtime=0
851	dump=pickle.dumps(self.copy())
852	if (dump != self.session_orig) or (time.time() > oldtime+self.session_maxlifetime/4):
853	tmpname=os.path.join(self.session_path,'qweb_sess_%s_%x'%(self.session_id,random.randint(1,2**32)))
854	f=file(tmpname,'wb')
855	f.write(dump)
856	f.close()
857	if sys.platform=='win32' and os.path.isfile(fname):
858	os.remove(fname)
859	os.rename(tmpname,fname)
860	def session_clean(self):
861	t=time.time()
862	try:
863	for i in [os.path.join(self.session_path,i) for i in os.listdir(self.session_path) if i.startswith('qweb_sess_')]:
864	if (t > os.path.getmtime(i)+self.session_maxlifetime):
865	os.unlink(i)
866	except OSError,IOError:
867	pass
868	class QWebSessionMem(QWebSession):
869	def session_load(self,sid):
870	global _qweb_sessions
871	if not "_qweb_sessions" in globals():
872	_qweb_sessions={}
873	if _qweb_sessions.has_key(sid):
874	self.session_orig=_qweb_sessions[sid]
875	self.update(self.session_orig)
876	return 1
877	def session_save(self):
878	global _qweb_sessions
879	if not "_qweb_sessions" in globals():
880	_qweb_sessions={}
881	_qweb_sessions[self.session_id]=self.copy()
882	class QWebSessionService:
883	def __init__(self, wsgiapp, url_rewrite=0):
884	self.wsgiapp=wsgiapp
885	self.url_rewrite_tags="a=href,area=href,frame=src,form=,fieldset="
886	def __call__(self, environ, start_response):
887	# TODO
888	# use QWebSession to provide environ["qweb.session"]
889	return self.wsgiapp(environ,start_response)
890	class QWebDict(dict):
891	def __init__(self,*p):
892	dict.__init__(self,*p)
893	def __getitem__(self,key):
894	return self.get(key,"")
895	def int(self,key):
896	try:
897	return int(self.get(key,"0"))
898	except ValueError:
899	return 0
900	class QWebListDict(dict):
901	def __init__(self,*p):
902	dict.__init__(self,*p)
903	def __getitem__(self,key):
904	return self.get(key,[])
905	def appendlist(self,key,val):
906	if self.has_key(key):
907	self[key].append(val)
908	else:
909	self[key]=[val]
910	def get_qwebdict(self):
911	d=QWebDict()
912	for k,v in self.items():
913	d[k]=v[-1]
914	return d
915	class QWebRequest:
916	"""QWebRequest a WSGI request handler.
917
918	QWebRequest is a WSGI request handler that feature GET, POST and POST
919	multipart methods, handles cookies and headers and provide a dict-like
920	SESSION Object (either on the filesystem or in memory).
921
922	It is constructed with the environ and start_response WSGI arguments:
923
924	req=qweb.QWebRequest(environ, start_response)
925
926	req has the folowing attributes :
927
928	req.environ standard WSGI dict (CGI and wsgi ones)
929
930	Some CGI vars as attributes from environ for convenience:
931
932	req.SCRIPT_NAME
933	req.PATH_INFO
934	req.REQUEST_URI
935
936	Some computed value (also for convenience)
937
938	req.FULL_URL full URL recontructed (http://host/query)
939	req.FULL_PATH (URL path before ?querystring)
940
941	Dict constructed from querystring and POST datas, PHP-like.
942
943	req.GET contains GET vars
944	req.POST contains POST vars
945	req.REQUEST contains merge of GET and POST
946	req.FILES contains uploaded files
947	req.GET_LIST req.POST_LIST req.REQUEST_LIST req.FILES_LIST multiple arguments versions
948	req.debug() returns an HTML dump of those vars
949
950	A dict-like session object.
951
952	req.SESSION the session start when the dict is not empty.
953
954	Attribute for handling the response
955
956	req.response_headers dict-like to set headers
957	req.response_cookies a SimpleCookie to set cookies
958	req.response_status a string to set the status like '200 OK'
959
960	req.write() to write to the buffer
961
962	req itselfs is an iterable object with the buffer, it will also also call
963	start_response automatically before returning anything via the iterator.
964
965	To make it short, it means that you may use
966
967	return req
968
969	at the end of your request handling to return the reponse to any WSGI
970	application server.
971	"""
972	#
973	# This class contains part ripped from colubrid (with the permission of
974	# mitsuhiko) see http://wsgiarea.pocoo.org/colubrid/
975	#
976	# - the class HttpHeaders
977	# - the method load_post_data (tuned version)
978	#
979	class HttpHeaders(object):
980	def __init__(self):
981	self.data = [('Content-Type', 'text/html')]
982	def __setitem__(self, key, value):
983	self.set(key, value)
984	def __delitem__(self, key):
985	self.remove(key)
986	def __contains__(self, key):
987	key = key.lower()
988	for k, v in self.data:
989	if k.lower() == key:
990	return True
991	return False
992	def add(self, key, value):
993	self.data.append((key, value))
994	def remove(self, key, count=-1):
995	removed = 0
996	data = []
997	for _key, _value in self.data:
998	if _key.lower() != key.lower():
999	if count > -1:
1000	if removed >= count:
1001	break
1002	else:
1003	removed += 1
1004	data.append((_key, _value))
1005	self.data = data
1006	def clear(self):
1007	self.data = []
1008	def set(self, key, value):
1009	self.remove(key)
1010	self.add(key, value)
1011	def get(self, key=False, httpformat=False):
1012	if not key:
1013	result = self.data
1014	else:
1015	result = []
1016	for _key, _value in self.data:
1017	if _key.lower() == key.lower():
1018	result.append((_key, _value))
1019	if httpformat:
1020	return '\n'.join(['%s: %s' % item for item in result])
1021	return result
1022	def load_post_data(self,environ,POST,FILES):
1023	length = int(environ['CONTENT_LENGTH'])
1024	DATA = environ['wsgi.input'].read(length)
1025	if environ.get('CONTENT_TYPE', '').startswith('multipart'):
1026	lines = ['Content-Type: %s' % environ.get('CONTENT_TYPE', '')]
1027	for key, value in environ.items():
1028	if key.startswith('HTTP_'):
1029	lines.append('%s: %s' % (key, value))
1030	raw = '\r\n'.join(lines) + '\r\n\r\n' + DATA
1031	msg = email.message_from_string(raw)
1032	for sub in msg.get_payload():
1033	if not isinstance(sub, email.Message.Message):
1034	continue
1035	name_dict = cgi.parse_header(sub['Content-Disposition'])[1]
1036	if 'filename' in name_dict:
1037	# Nested MIME Messages are not supported'
1038	if type([]) == type(sub.get_payload()):
1039	continue
1040	if not name_dict['filename'].strip():
1041	continue
1042	filename = name_dict['filename']
1043	# why not keep all the filename? because IE always send 'C:\documents and settings\blub\blub.png'
1044	filename = filename[filename.rfind('\\') + 1:]
1045	if 'Content-Type' in sub:
1046	content_type = sub['Content-Type']
1047	else:
1048	content_type = None
1049	s = { "name":filename, "type":content_type, "data":sub.get_payload() }
1050	FILES.appendlist(name_dict['name'], s)
1051	else:
1052	POST.appendlist(name_dict['name'], sub.get_payload())
1053	else:
1054	POST.update(cgi.parse_qs(DATA,keep_blank_values=1))
1055	return DATA
1056
1057	def __init__(self,environ,start_response,session=QWebSession):
1058	self.environ=environ
1059	self.start_response=start_response
1060	self.buffer=[]
1061
1062	self.SCRIPT_NAME = environ.get('SCRIPT_NAME', '')
1063	self.PATH_INFO = environ.get('PATH_INFO', '')
1064	# extensions:
1065	self.FULL_URL = environ['FULL_URL'] = self.get_full_url(environ)
1066	# REQUEST_URI is optional, fake it if absent
1067	if not environ.has_key("REQUEST_URI"):
1068	environ["REQUEST_URI"]=urllib.quote(self.SCRIPT_NAME+self.PATH_INFO)
1069	if environ.get('QUERY_STRING'):
1070	environ["REQUEST_URI"]+='?'+environ['QUERY_STRING']
1071	self.REQUEST_URI = environ["REQUEST_URI"]
1072	# full quote url path before the ?
1073	self.FULL_PATH = environ['FULL_PATH'] = self.REQUEST_URI.split('?')[0]
1074
1075	self.request_cookies=Cookie.SimpleCookie()
1076	self.request_cookies.load(environ.get('HTTP_COOKIE', ''))
1077
1078	self.response_started=False
1079	self.response_gzencode=False
1080	self.response_cookies=Cookie.SimpleCookie()
1081	# to delete a cookie use: c[key]['expires'] = datetime.datetime(1970, 1, 1)
1082	self.response_headers=self.HttpHeaders()
1083	self.response_status="200 OK"
1084
1085	self.php=None
1086	if self.environ.has_key("php"):
1087	self.php=environ["php"]
1088	self.SESSION=self.php._SESSION
1089	self.GET=self.php._GET
1090	self.POST=self.php._POST
1091	self.REQUEST=self.php._ARG
1092	self.FILES=self.php._FILES
1093	else:
1094	if isinstance(session,QWebSession):
1095	self.SESSION=session
1096	elif session:
1097	self.SESSION=session(environ)
1098	else:
1099	self.SESSION=None
1100	self.GET_LIST=QWebListDict(cgi.parse_qs(environ.get('QUERY_STRING', ''),keep_blank_values=1))
1101	self.POST_LIST=QWebListDict()
1102	self.FILES_LIST=QWebListDict()
1103	self.REQUEST_LIST=QWebListDict(self.GET_LIST)
1104	if environ['REQUEST_METHOD'] == 'POST':
1105	self.DATA=self.load_post_data(environ,self.POST_LIST,self.FILES_LIST)
1106	self.REQUEST_LIST.update(self.POST_LIST)
1107	self.GET=self.GET_LIST.get_qwebdict()
1108	self.POST=self.POST_LIST.get_qwebdict()
1109	self.FILES=self.FILES_LIST.get_qwebdict()
1110	self.REQUEST=self.REQUEST_LIST.get_qwebdict()
1111	def get_full_url(environ):
1112	# taken from PEP 333
1113	if 'FULL_URL' in environ:
1114	return environ['FULL_URL']
1115	url = environ['wsgi.url_scheme']+'://'
1116	if environ.get('HTTP_HOST'):
1117	url += environ['HTTP_HOST']
1118	else:
1119	url += environ['SERVER_NAME']
1120	if environ['wsgi.url_scheme'] == 'https':
1121	if environ['SERVER_PORT'] != '443':
1122	url += ':' + environ['SERVER_PORT']
1123	else:
1124	if environ['SERVER_PORT'] != '80':
1125	url += ':' + environ['SERVER_PORT']
1126	if environ.has_key('REQUEST_URI'):
1127	url += environ['REQUEST_URI']
1128	else:
1129	url += urllib.quote(environ.get('SCRIPT_NAME', ''))
1130	url += urllib.quote(environ.get('PATH_INFO', ''))
1131	if environ.get('QUERY_STRING'):
1132	url += '?' + environ['QUERY_STRING']
1133	return url
1134	get_full_url=staticmethod(get_full_url)
1135	def save_files(self):
1136	for k,v in self.FILES.items():
1137	if not v.has_key("tmp_file"):
1138	f=tempfile.NamedTemporaryFile()
1139	f.write(v["data"])
1140	f.flush()
1141	v["tmp_file"]=f
1142	v["tmp_name"]=f.name
1143	def debug(self):
1144	body=''
1145	for name,d in [
1146	("GET",self.GET), ("POST",self.POST), ("REQUEST",self.REQUEST), ("FILES",self.FILES),
1147	("GET_LIST",self.GET_LIST), ("POST_LIST",self.POST_LIST), ("REQUEST_LIST",self.REQUEST_LIST), ("FILES_LIST",self.FILES_LIST),
1148	("SESSION",self.SESSION), ("environ",self.environ),
1149	]:
1150	body+='<table border="1" width="100%" align="center">\n'
1151	body+='<tr><th colspan="2" align="center">%s</th></tr>\n'%name
1152	keys=d.keys()
1153	keys.sort()
1154	body+=''.join(['<tr><td>%s</td><td>%s</td></tr>\n'%(k,cgi.escape(repr(d[k]))) for k in keys])
1155	body+='</table><br><br>\n\n'
1156	return body
1157	def write(self,s):
1158	self.buffer.append(s)
1159	def echo(self,*s):
1160	self.buffer.extend([str(i) for i in s])
1161	def response(self):
1162	if not self.response_started:
1163	if not self.php:
1164	for k,v in self.FILES.items():
1165	if v.has_key("tmp_file"):
1166	try:
1167	v["tmp_file"].close()
1168	except OSError:
1169	pass
1170	if self.response_gzencode and self.environ.get('HTTP_ACCEPT_ENCODING','').find('gzip')!=-1:
1171	zbuf=StringIO.StringIO()
1172	zfile=gzip.GzipFile(mode='wb', fileobj=zbuf)
1173	zfile.write(''.join(self.buffer))
1174	zfile.close()
1175	zbuf=zbuf.getvalue()
1176	self.buffer=[zbuf]
1177	self.response_headers['Content-Encoding']="gzip"
1178	self.response_headers['Content-Length']=str(len(zbuf))
1179	headers = self.response_headers.get()
1180	if isinstance(self.SESSION, QWebSession):
1181	headers.extend(self.SESSION.session_get_headers())
1182	headers.extend([('Set-Cookie', self.response_cookies[i].OutputString()) for i in self.response_cookies])
1183	self.start_response(self.response_status, headers)
1184	self.response_started=True
1185	return self.buffer
1186	def __iter__(self):
1187	return self.response().__iter__()
1188	def http_redirect(self,url,permanent=1):
1189	if permanent:
1190	self.response_status="301 Moved Permanently"
1191	else:
1192	self.response_status="302 Found"
1193	self.response_headers["Location"]=url
1194	def http_404(self,msg="<h1>404 Not Found</h1>"):
1195	self.response_status="404 Not Found"
1196	if msg:
1197	self.write(msg)
1198	def http_download(self,fname,fstr,partial=0):
1199	# allow fstr to be a file-like object
1200	# if parital:
1201	# say accept ranages
1202	# parse range headers...
1203	# if range:
1204	# header("HTTP/1.1 206 Partial Content");
1205	# header("Content-Range: bytes $offset-".($fsize-1)."/".$fsize);
1206	# header("Content-Length: ".($fsize-$offset));
1207	# fseek($fd,$offset);
1208	# else:
1209	self.response_headers["Content-Type"]="application/octet-stream"
1210	self.response_headers["Content-Disposition"]="attachment; filename=\"%s\""%fname
1211	self.response_headers["Content-Transfer-Encoding"]="binary"
1212	self.response_headers["Content-Length"]="%d"%len(fstr)
1213	self.write(fstr)
1214
1215	#----------------------------------------------------------
1216	# QWeb WSGI HTTP Server to run any WSGI app
1217	# autorun, run an app as FCGI or CGI otherwise launch the server
1218	#----------------------------------------------------------
1219	class QWebWSGIHandler(BaseHTTPServer.BaseHTTPRequestHandler):
1220	def log_message(self,*p):
1221	if self.server.log:
1222	return BaseHTTPServer.BaseHTTPRequestHandler.log_message(self,*p)
1223	def address_string(self):
1224	return self.client_address[0]
1225	def start_response(self,status,headers):
1226	l=status.split(' ',1)
1227	self.send_response(int(l[0]),l[1])
1228	ctype_sent=0
1229	for i in headers:
1230	if i[0].lower()=="content-type":
1231	ctype_sent=1
1232	self.send_header(*i)
1233	if not ctype_sent:
1234	self.send_header("Content-type", "text/html")
1235	self.end_headers()
1236	return self.write
1237	def write(self,data):
1238	try:
1239	self.wfile.write(data)
1240	except (socket.error, socket.timeout),e:
1241	print e
1242	def bufferon(self):
1243	if not getattr(self,'wfile_buf',0):
1244	self.wfile_buf=1
1245	self.wfile_bak=self.wfile
1246	self.wfile=StringIO.StringIO()
1247	def bufferoff(self):
1248	if self.wfile_buf:
1249	buf=self.wfile
1250	self.wfile=self.wfile_bak
1251	self.write(buf.getvalue())
1252	self.wfile_buf=0
1253	def serve(self,type):
1254	path_info, parameters, query = urlparse.urlparse(self.path)[2:5]
1255	environ = {
1256	'wsgi.version': (1,0),
1257	'wsgi.url_scheme': 'http',
1258	'wsgi.input': self.rfile,
1259	'wsgi.errors': sys.stderr,
1260	'wsgi.multithread': 0,
1261	'wsgi.multiprocess': 0,
1262	'wsgi.run_once': 0,
1263	'REQUEST_METHOD': self.command,
1264	'SCRIPT_NAME': '',
1265	'QUERY_STRING': query,
1266	'CONTENT_TYPE': self.headers.get('Content-Type', ''),
1267	'CONTENT_LENGTH': self.headers.get('Content-Length', ''),
1268	'REMOTE_ADDR': self.client_address[0],
1269	'REMOTE_PORT': str(self.client_address[1]),
1270	'SERVER_NAME': self.server.server_address[0],
1271	'SERVER_PORT': str(self.server.server_address[1]),
1272	'SERVER_PROTOCOL': self.request_version,
1273	# extention
1274	'FULL_PATH': self.path,
1275	'qweb.mode': 'standalone',
1276	}
1277	if path_info:
1278	environ['PATH_INFO'] = urllib.unquote(path_info)
1279	for key, value in self.headers.items():
1280	environ['HTTP_' + key.upper().replace('-', '_')] = value
1281	# Hack to avoid may TCP packets
1282	self.bufferon()
1283	appiter=self.server.wsgiapp(environ, self.start_response)
1284	for data in appiter:
1285	self.write(data)
1286	self.bufferoff()
1287	self.bufferoff()
1288	def do_GET(self):
1289	self.serve('GET')
1290	def do_POST(self):
1291	self.serve('GET')
1292	class QWebWSGIServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
1293	""" QWebWSGIServer
1294	qweb_wsgi_autorun(wsgiapp,ip='127.0.0.1',port=8080,threaded=1)
1295	A WSGI HTTP server threaded or not and a function to automatically run your
1296	app according to the environement (either standalone, CGI or FastCGI).
1297
1298	This feature is called QWeb autorun. If you want to To use it on your
1299	application use the following lines at the end of the main application
1300	python file:
1301
1302	if __name__ == '__main__':
1303	qweb.qweb_wsgi_autorun(your_wsgi_app)
1304
1305	this function will select the approriate running mode according to the
1306	calling environement (http-server, FastCGI or CGI).
1307	"""
1308	def __init__(self, wsgiapp, ip, port, threaded=1, log=1):
1309	BaseHTTPServer.HTTPServer.__init__(self, (ip, port), QWebWSGIHandler)
1310	self.wsgiapp = wsgiapp
1311	self.threaded = threaded
1312	self.log = log
1313	def process_request(self,*p):
1314	if self.threaded:
1315	return SocketServer.ThreadingMixIn.process_request(self,*p)
1316	else:
1317	return BaseHTTPServer.HTTPServer.process_request(self,*p)
1318	def qweb_wsgi_autorun(wsgiapp,ip='127.0.0.1',port=8080,threaded=1,log=1,callback_ready=None):
1319	if sys.platform=='win32':
1320	fcgi=0
1321	else:
1322	fcgi=1
1323	sock = socket.fromfd(0, socket.AF_INET, socket.SOCK_STREAM)
1324	try:
1325	sock.getpeername()
1326	except socket.error, e:
1327	if e[0] == errno.ENOTSOCK:
1328	fcgi=0
1329	if fcgi or os.environ.has_key('REQUEST_METHOD'):
1330	import fcgi
1331	fcgi.WSGIServer(wsgiapp,multithreaded=False).run()
1332	else:
1333	if log:
1334	print 'Serving on %s:%d'%(ip,port)
1335	s=QWebWSGIServer(wsgiapp,ip=ip,port=port,threaded=threaded,log=log)
1336	if callback_ready:
1337	callback_ready()
1338	try:
1339	s.serve_forever()
1340	except KeyboardInterrupt,e:
1341	sys.excepthook(*sys.exc_info())
1342
1343	#----------------------------------------------------------
1344	# Qweb Documentation
1345	#----------------------------------------------------------
1346	def qweb_doc():
1347	body=__doc__
1348	for i in [QWebXml ,QWebHtml ,QWebForm ,QWebURL ,qweb_control ,QWebRequest ,QWebSession ,QWebWSGIServer ,qweb_wsgi_autorun]:
1349	n=i.__name__
1350	d=i.__doc__
1351	body+='\n\n%s\n%s\n\n%s'%(n,'-'*len(n),d)
1352	return body
1353
1354	print qweb_doc()
1355
1356	#

Note: See TracBrowser for help on using the repository browser.

Download in other formats: