"""

 Web API (wrapper around WSGI)

 (from web.py)

 """

 __all__ = [

     "config",

     "header", "debug",

     "input", "data",

     "setcookie", "cookies",

     "ctx", 

     "HTTPError", 

     # 200, 201, 202

     "OK", "Created", "Accepted",    

     "ok", "created", "accepted",

     # 301, 302, 303, 304, 307

     "Redirect", "Found", "SeeOther", "NotModified", "TempRedirect", 

     "redirect", "found", "seeother", "notmodified", "tempredirect",

     # 400, 401, 403, 404, 405, 406, 409, 410, 412, 415

     "BadRequest", "Unauthorized", "Forbidden", "NotFound", "NoMethod", "NotAcceptable", "Conflict", "Gone", "PreconditionFailed", "UnsupportedMediaType",

     "badrequest", "unauthorized", "forbidden", "notfound", "nomethod", "notacceptable", "conflict", "gone", "preconditionfailed", "unsupportedmediatype",

     # 500

     "InternalError", 

     "internalerror",

 ]

 import sys, cgi, Cookie, pprint, urlparse, urllib

 from utils import storage, storify, threadeddict, dictadd, intget, safestr

 config = storage()

 config.__doc__ = """

 A configuration object for various aspects of web.py.

 `debug`

    : when True, enables reloading, disabled template caching and sets internalerror to debugerror.

 """

 class HTTPError(Exception):

     def __init__(self, status, headers={}, data=""):

         ctx.status = status

         for k, v in headers.items():

             header(k, v)

         self.data = data

         Exception.__init__(self, status)

 def _status_code(status, data=None, classname=None, docstring=None):

     if data is None:

         data = status.split(" ", 1)[1]

     classname = status.split(" ", 1)[1].replace(' ', '') # 304 Not Modified -> NotModified    

     docstring = docstring or '`%s` status' % status

     def __init__(self, data=data, headers={}):

         HTTPError.__init__(self, status, headers, data)

     # trick to create class dynamically with dynamic docstring.

     return type(classname, (HTTPError, object), {

         '__doc__': docstring,

         '__init__': __init__

     })

 ok = OK = _status_code("200 OK", data="")

 created = Created = _status_code("201 Created")

 accepted = Accepted = _status_code("202 Accepted")

 class Redirect(HTTPError):

     """A `301 Moved Permanently` redirect."""

     def __init__(self, url, status='301 Moved Permanently', absolute=False):

         """

         Returns a `status` redirect to the new URL. 

         `url` is joined with the base URL so that things like 

         `redirect("about") will work properly.

         """

         newloc = urlparse.urljoin(ctx.path, url)

         if newloc.startswith('/'):

             if absolute:

                 home = ctx.realhome

             else:

                 home = ctx.home

             newloc = home + newloc

         headers = {

             'Content-Type': 'text/html',

             'Location': newloc

         }

         HTTPError.__init__(self, status, headers, "")

 redirect = Redirect

 class Found(Redirect):

     """A `302 Found` redirect."""

     def __init__(self, url, absolute=False):

         Redirect.__init__(self, url, '302 Found', absolute=absolute)

 found = Found

 class SeeOther(Redirect):

     """A `303 See Other` redirect."""

     def __init__(self, url, absolute=False):

         Redirect.__init__(self, url, '303 See Other', absolute=absolute)

 seeother = SeeOther

 class NotModified(HTTPError):

     """A `304 Not Modified` status."""

     def __init__(self):

         HTTPError.__init__(self, "304 Not Modified")

 notmodified = NotModified

 class TempRedirect(Redirect):

     """A `307 Temporary Redirect` redirect."""

     def __init__(self, url, absolute=False):

         Redirect.__init__(self, url, '307 Temporary Redirect', absolute=absolute)

 tempredirect = TempRedirect

 class BadRequest(HTTPError):

     """`400 Bad Request` error."""

     message = "bad request"

     def __init__(self, message=None):

         status = "400 Bad Request"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, message or self.message)

 badrequest = BadRequest

 class Unauthorized(HTTPError):

     """`401 Unauthorized` error."""

     message = "unauthorized"

     def __init__(self):

         status = "401 Unauthorized"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 unauthorized = Unauthorized

 class Forbidden(HTTPError):

     """`403 Forbidden` error."""

     message = "forbidden"

     def __init__(self):

         status = "403 Forbidden"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 forbidden = Forbidden

 class _NotFound(HTTPError):

     """`404 Not Found` error."""

     message = "not found"

     def __init__(self, message=None):

         status = '404 Not Found'

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, message or self.message)

 def NotFound(message=None):

     """Returns HTTPError with '404 Not Found' error from the active application.

     """

     if message:

         return _NotFound(message)

     elif ctx.get('app_stack'):

         return ctx.app_stack[-1].notfound()

     else:

         return _NotFound()

 notfound = NotFound

 class NoMethod(HTTPError):

     """A `405 Method Not Allowed` error."""

     def __init__(self, cls=None):

         status = '405 Method Not Allowed'

         headers = {}

         headers['Content-Type'] = 'text/html'

         methods = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE']

         if cls:

             methods = [method for method in methods if hasattr(cls, method)]

         headers['Allow'] = ', '.join(methods)

         data = None

         HTTPError.__init__(self, status, headers, data)

 nomethod = NoMethod

 class NotAcceptable(HTTPError):

     """`406 Not Acceptable` error."""

     message = "not acceptable"

     def __init__(self):

         status = "406 Not Acceptable"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 notacceptable = NotAcceptable

 class Conflict(HTTPError):

     """`409 Conflict` error."""

     message = "conflict"

     def __init__(self):

         status = "409 Conflict"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 conflict = Conflict

 class Gone(HTTPError):

     """`410 Gone` error."""

     message = "gone"

     def __init__(self):

         status = '410 Gone'

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 gone = Gone

 class PreconditionFailed(HTTPError):

     """`412 Precondition Failed` error."""

     message = "precondition failed"

     def __init__(self):

         status = "412 Precondition Failed"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 preconditionfailed = PreconditionFailed

 class UnsupportedMediaType(HTTPError):

     """`415 Unsupported Media Type` error."""

     message = "unsupported media type"

     def __init__(self):

         status = "415 Unsupported Media Type"

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, self.message)

 unsupportedmediatype = UnsupportedMediaType

 class _InternalError(HTTPError):

     """500 Internal Server Error`."""

     message = "internal server error"

     def __init__(self, message=None):

         status = '500 Internal Server Error'

         headers = {'Content-Type': 'text/html'}

         HTTPError.__init__(self, status, headers, message or self.message)

 def InternalError(message=None):

     """Returns HTTPError with '500 internal error' error from the active application.

     """

     if message:

         return _InternalError(message)

     elif ctx.get('app_stack'):

         return ctx.app_stack[-1].internalerror()

     else:

         return _InternalError()

 internalerror = InternalError

 def header(hdr, value, unique=False):

     """

     Adds the header `hdr: value` with the response.

     If `unique` is True and a header with that name already exists,

     it doesn't add a new one. 

     """

     hdr, value = safestr(hdr), safestr(value)

     # protection against HTTP response splitting attack

     if '\n' in hdr or '\r' in hdr or '\n' in value or '\r' in value:

         raise ValueError, 'invalid characters in header'

     if unique is True:

         for h, v in ctx.headers:

             if h.lower() == hdr.lower(): return

     ctx.headers.append((hdr, value))

 def rawinput(method=None):

     """Returns storage object with GET or POST arguments.

     """

     method = method or "both"

     from cStringIO import StringIO

     def dictify(fs): 

         # hack to make web.input work with enctype='text/plain.

         if fs.list is None:

             fs.list = [] 

         return dict([(k, fs[k]) for k in fs.keys()])

     e = ctx.env.copy()

     a = b = {}

     if method.lower() in ['both', 'post', 'put']:

         if e['REQUEST_METHOD'] in ['POST', 'PUT']:

             if e.get('CONTENT_TYPE', '').lower().startswith('multipart/'):

                 # since wsgi.input is directly passed to cgi.FieldStorage, 

                 # it can not be called multiple times. Saving the FieldStorage

                 # object in ctx to allow calling web.input multiple times.

                 a = ctx.get('_fieldstorage')

                 if not a:

                     fp = e['wsgi.input']

                     a = cgi.FieldStorage(fp=fp, environ=e, keep_blank_values=1)

                     ctx._fieldstorage = a

             else:

                 fp = StringIO(data())

                 a = cgi.FieldStorage(fp=fp, environ=e, keep_blank_values=1)

             a = dictify(a)

     if method.lower() in ['both', 'get']:

         e['REQUEST_METHOD'] = 'GET'

         b = dictify(cgi.FieldStorage(environ=e, keep_blank_values=1))

     def process_fieldstorage(fs):

         if isinstance(fs, list):

             return [process_fieldstorage(x) for x in fs]

         elif fs.filename is None:

             return fs.value

         else:

             return fs

     return storage([(k, process_fieldstorage(v)) for k, v in dictadd(b, a).items()])

 def input(*requireds, **defaults):

     """

     Returns a `storage` object with the GET and POST arguments. 

     See `storify` for how `requireds` and `defaults` work.

     """

     _method = defaults.pop('_method', 'both')

     out = rawinput(_method)

     try:

         defaults.setdefault('_unicode', True) # force unicode conversion by default.

         return storify(out, *requireds, **defaults)

     except KeyError:

         raise badrequest()

 def data():

     """Returns the data sent with the request."""

     if 'data' not in ctx:

         cl = intget(ctx.env.get('CONTENT_LENGTH'), 0)

         ctx.data = ctx.env['wsgi.input'].read(cl)

     return ctx.data

 def setcookie(name, value, expires='', domain=None,

               secure=False, httponly=False, path=None):

     """Sets a cookie."""

     morsel = Cookie.Morsel()

     name, value = safestr(name), safestr(value)

     morsel.set(name, value, urllib.quote(value))

     if expires < 0:

         expires = -1000000000

     morsel['expires'] = expires

     morsel['path'] = path or ctx.homepath+'/'

     if domain:

         morsel['domain'] = domain

     if secure:

         morsel['secure'] = secure

     value = morsel.OutputString()

     if httponly:

         value += '; httponly'

     header('Set-Cookie', value)

 def decode_cookie(value):

     r"""Safely decodes a cookie value to unicode. 

     Tries us-ascii, utf-8 and io8859 encodings, in that order.

     >>> decode_cookie('')

     u''

     >>> decode_cookie('asdf')

     u'asdf'

     >>> decode_cookie('foo \xC3\xA9 bar')

     u'foo \xe9 bar'

     >>> decode_cookie('foo \xE9 bar')

     u'foo \xe9 bar'

     """

     try:

         # First try plain ASCII encoding

         return unicode(value, 'us-ascii')

     except UnicodeError:

         # Then try UTF-8, and if that fails, ISO8859

         try:

             return unicode(value, 'utf-8')

         except UnicodeError:

             return unicode(value, 'iso8859', 'ignore')

 def parse_cookies(http_cookie):

     r"""Parse a HTTP_COOKIE header and return dict of cookie names and decoded values.

     >>> sorted(parse_cookies('').items())

     []

     >>> sorted(parse_cookies('a=1').items())

     [('a', '1')]

     >>> sorted(parse_cookies('a=1%202').items())

     [('a', '1 2')]

     >>> sorted(parse_cookies('a=Z%C3%A9Z').items())

     [('a', 'Z\xc3\xa9Z')]

     >>> sorted(parse_cookies('a=1; b=2; c=3').items())

     [('a', '1'), ('b', '2'), ('c', '3')]

     >>> sorted(parse_cookies('a=1; b=w("x")|y=z; c=3').items())

     [('a', '1'), ('b', 'w('), ('c', '3')]

     >>> sorted(parse_cookies('a=1; b=w(%22x%22)|y=z; c=3').items())

     [('a', '1'), ('b', 'w("x")|y=z'), ('c', '3')]

     >>> sorted(parse_cookies('keebler=E=mc2').items())

     [('keebler', 'E=mc2')]

     >>> sorted(parse_cookies(r'keebler="E=mc2; L=\"Loves\"; fudge=\012;"').items())

     [('keebler', 'E=mc2; L="Loves"; fudge=\n;')]

     """

     #print "parse_cookies"

     if '"' in http_cookie:

         # HTTP_COOKIE has quotes in it, use slow but correct cookie parsing

         cookie = Cookie.SimpleCookie()

         try:

             cookie.load(http_cookie)

         except Cookie.CookieError:

             # If HTTP_COOKIE header is malformed, try at least to load the cookies we can by

             # first splitting on ';' and loading each attr=value pair separately

             cookie = Cookie.SimpleCookie()

             for attr_value in http_cookie.split(';'):

                 try:

                     cookie.load(attr_value)

                 except Cookie.CookieError:

                     pass

         cookies = dict((k, urllib.unquote(v.value)) for k, v in cookie.iteritems())

     else:

         # HTTP_COOKIE doesn't have quotes, use fast cookie parsing

         cookies = {}

         for key_value in http_cookie.split(';'):

             key_value = key_value.split('=', 1)

             if len(key_value) == 2:

                 key, value = key_value

                 cookies[key.strip()] = urllib.unquote(value.strip())

     return cookies

 def cookies(*requireds, **defaults):

     r"""Returns a `storage` object with all the request cookies in it.

     See `storify` for how `requireds` and `defaults` work.

     This is forgiving on bad HTTP_COOKIE input, it tries to parse at least

     the cookies it can.

     The values are converted to unicode if _unicode=True is passed.

     """

     # If _unicode=True is specified, use decode_cookie to convert cookie value to unicode 

     if defaults.get("_unicode") is True:

         defaults['_unicode'] = decode_cookie

     # parse cookie string and cache the result for next time.

     if '_parsed_cookies' not in ctx:

         http_cookie = ctx.env.get("HTTP_COOKIE", "")

         ctx._parsed_cookies = parse_cookies(http_cookie)

     try:

         return storify(ctx._parsed_cookies, *requireds, **defaults)

     except KeyError:

         badrequest()

         raise StopIteration

 def debug(*args):

     """

     Prints a prettyprinted version of `args` to stderr.

     """

     try: 

         out = ctx.environ['wsgi.errors']

     except: 

         out = sys.stderr

     for arg in args:

         print >> out, pprint.pformat(arg)

     return ''

 def _debugwrite(x):

     try: 

         out = ctx.environ['wsgi.errors']

     except: 

         out = sys.stderr

     out.write(x)

 debug.write = _debugwrite

 ctx = context = threadeddict()

 ctx.__doc__ = """

 A `storage` object containing various information about the request:

 `environ` (aka `env`)

    : A dictionary containing the standard WSGI environment variables.

 `host`

    : The domain (`Host` header) requested by the user.

 `home`

    : The base path for the application.

 `ip`

    : The IP address of the requester.

 `method`

    : The HTTP method used.

 `path`

    : The path request.

 `query`

    : If there are no query arguments, the empty string. Otherwise, a `?` followed

      by the query string.

 `fullpath`

    : The full path requested, including query arguments (`== path + query`).

 ### Response Data

 `status` (default: "200 OK")

    : The status code to be used in the response.

 `headers`

    : A list of 2-tuples to be used in the response.

 `output`

    : A string to be used as the response.

 """

 if __name__ == "__main__":

     import doctest

     doctest.testmod()