code/qweb.py

   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="&amp;%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 #