Server Error 5l7051

<<              __traceback_supplement__ = Supplement, self, environ
                   sr_checker = ResponseStartChecker(start_response)
                   app_iter = self.application(environ, sr_checker)
                   return self.make_catching_iter(app_iter, environ, sr_checker)
               except:

>>  app_iter = self.application(environ, sr_checker)

<<              try:
                       response = self.handle_request(request)
                       has_listeners and notify(NewResponse(request, response))

>>  response = self.handle_request(request)

<<          attrs = request.__dict__
               try:
                   response = handler(request)
               except Exception as exc:
                   # WARNING: do not assign the result of sys.exc_info() to a

>>  response = handler(request)

<<              raise HTTPNotFound(msg)
               else:
                   response = view_callable(context, request)
      
               return response

>>  response = view_callable(context, request)

<<          registry = self.registry
               def viewresult_to_response(context, request):
                   result = view(context, request)
                   response = registry.queryAdapterOrSelf(result, IResponse)
                   if response is None:

>>  result = view(context, request)

<<          def _requestonly_view(context, request):
                   if attr is None:
                       response = view(request)
                   else:
                       response = getattr(view, attr)(request)

>>  response = view(request)

<<      req_part = request.matchdict['part'].split('-')
      
           monograph = Monograph.get(request.db, sbid)
           if len(req_part) == 2:

>>  monograph = Monograph.get(request.db, sbid)

<<      @classmethod
           def get(cls, db, doc_id, controls=True):
               doc = db.get(doc_id)
               couchdocument = cls.from_python(doc)

>>  doc = db.get(doc_id)

<<          docid = resource.escape_docid(docid)
               doc = self.res.get(docid, **params).json_body
               if wrapper is not None:
                   if not callable(wrapper):

>>  doc = self.res.get(docid, **params).json_body

<<          """
               return self.request("GET", path=path, headers=headers,
                       params_dict=params_dict, **params)
      
           def head(self, path=None, headers=None, params_dict=None, **params):

>>  params_dict=params_dict, **params)

<<          try:
                   resp = Resource.request(self, method, path=path,
                                    payload=payload, headers=headers, **params)
                                   
               except ResourceError, e:

>>  payload=payload, headers=headers, **params)

<<             
                   resp = self.client.request(uri, method=method, body=payload,
                               headers=self.make_headers(headers))
                  
                   if resp is None:

<<          # no response has been provided, do the request
               self._nb_redirections = self.max_follow_redirect
               return self.perform(request)
      
           def redirect(self, location, request):

>>  return self.perform(request)

<<                      conn.send(msg)
      
                       return self.get_response(request, conn)
                   except socket.gaierror, e:
                       if conn is not None:

>>  return self.get_response(request, conn)

<<              log.debug("headers: [%s]" % p.headers())
      
               location = p.headers().get('location')
      
               if self.follow_redirect:

>>  location = p.headers().get('location')

<<          OrderedDict that allows you to get value using insensitive
               keys."""
               self._check_headers_complete()
               return self.parser.get_headers()

<<          while True:
                   try:
                       data = self.next()
                   except StopIteration:
                       if self.parser.is_headers_complete():

>>  data = self.next()

<<          if nparsed != recved and not self.parser.is_message_complete():
                   raise ParserError("nparsed != recved (%s != %s)" % (nparsed,
                       recved))
      
               if recved == 0: