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)

<<          part = Part.get(request.db, selected_part['part_sbid'])
               try:
                   pdf_file = request.db.fetch_attachment(part._id, part.pdf_file['filename'], stream=True)
               except (couchdbkit.ResourceNotFound, AttributeError):
                   raise exceptions.NotFound()

>>  pdf_file = request.db.fetch_attachment(part._id, part.pdf_file['filename'], stream=True)

<<          name = url_quote(name, safe="")
      
               resp = self.res(docid).get(name, headers=headers)
               if stream:
                   return resp.body_stream()

>>  resp = self.res(docid).get(name, headers=headers)

<<          """
               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: