the canonical import location for HTTP exceptions/responses is now pyramid.response

7 files changed, 124 insertions, 145 deletions

diff --git a/docs/narr/hooks.rst b/docs/narr/hooks.rst
index 7e3fe0a5c..d620b5672 100644
--- a/docs/narr/hooks.rst
+++ b/docs/narr/hooks.rst
@@ -21,7 +21,7 @@ configuration.
 
 The :term:`not found view` callable is a view callable like any other.  The
 :term:`view configuration` which causes it to be a "not found" view consists
-only of naming the :exc:`pyramid.exceptions.NotFound` class as the
+only of naming the :exc:`pyramid.response.HTTPNotFound` class as the
 ``context`` of the view configuration.
 
 If your application uses :term:`imperative configuration`, you can replace
@@ -31,9 +31,9 @@ method to register an "exception view":
 .. code-block:: python
    :linenos:
 
-   from pyramid.exceptions import NotFound
+   from pyramid.response import HTTPNotFound
    from helloworld.views import notfound_view
-   config.add_view(notfound_view, context=NotFound)
+   config.add_view(notfound_view, context=HTTPNotFound)
 
 Replace ``helloworld.views.notfound_view`` with a reference to the
 :term:`view callable` you want to use to represent the Not Found view.
@@ -42,7 +42,7 @@ Like any other view, the notfound view must accept at least a ``request``
 parameter, or both ``context`` and ``request``.  The ``request`` is the
 current :term:`request` representing the denied action.  The ``context`` (if
 used in the call signature) will be the instance of the
-:exc:`~pyramid.exceptions.NotFound` exception that caused the view to be
+:exc:`~pyramid.response.HTTPNotFound` exception that caused the view to be
 called.
 
 Here's some sample code that implements a minimal NotFound view callable:
@@ -50,25 +50,25 @@ Here's some sample code that implements a minimal NotFound view callable:
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import HTTPNotFound
+   from pyramid.response import HTTPNotFound
 
    def notfound_view(request):
        return HTTPNotFound()
 
 .. note:: When a NotFound view callable is invoked, it is passed a
-   :term:`request`.  The ``exception`` attribute of the request will
-   be an instance of the :exc:`~pyramid.exceptions.NotFound`
-   exception that caused the not found view to be called.  The value
-   of ``request.exception.args[0]`` will be a value explaining why the
-   not found error was raised.  This message will be different when
-   the ``debug_notfound`` environment setting is true than it is when
-   it is false.
+   :term:`request`.  The ``exception`` attribute of the request will be an
+   instance of the :exc:`~pyramid.response.HTTPNotFound` exception that
+   caused the not found view to be called.  The value of
+   ``request.exception.args[0]`` will be a value explaining why the not found
+   error was raised.  This message will be different when the
+   ``debug_notfound`` environment setting is true than it is when it is
+   false.
 
 .. warning:: When a NotFound view callable accepts an argument list as
    described in :ref:`request_and_context_view_definitions`, the ``context``
    passed as the first argument to the view callable will be the
-   :exc:`~pyramid.exceptions.NotFound` exception instance.  If available, the
-   resource context will still be available as ``request.context``.
+   :exc:`~pyramid.response.HTTPNotFound` exception instance.  If available,
+   the resource context will still be available as ``request.context``.
 
 .. index::
    single: forbidden view
@@ -85,7 +85,7 @@ the view which generates it can be overridden as necessary.
 
 The :term:`forbidden view` callable is a view callable like any other.  The
 :term:`view configuration` which causes it to be a "not found" view consists
-only of naming the :exc:`pyramid.exceptions.Forbidden` class as the
+only of naming the :exc:`pyramid.response.HTTPForbidden` class as the
 ``context`` of the view configuration.
 
 You can replace the forbidden view by using the
@@ -96,8 +96,8 @@ view":
    :linenos:
 
    from helloworld.views import forbidden_view
-   from pyramid.exceptions import Forbidden
-   config.add_view(forbidden_view, context=Forbidden)
+   from pyramid.response import HTTPForbidden
+   config.add_view(forbidden_view, context=HTTPForbidden)
 
 Replace ``helloworld.views.forbidden_view`` with a reference to the Python
 :term:`view callable` you want to use to represent the Forbidden view.
@@ -121,13 +121,13 @@ Here's some sample code that implements a minimal forbidden view:
        return Response('forbidden')
 
 .. note:: When a forbidden view callable is invoked, it is passed a
-   :term:`request`.  The ``exception`` attribute of the request will
-   be an instance of the :exc:`~pyramid.exceptions.Forbidden`
-   exception that caused the forbidden view to be called.  The value
-   of ``request.exception.args[0]`` will be a value explaining why the
-   forbidden was raised.  This message will be different when the
-   ``debug_authorization`` environment setting is true than it is when
-   it is false.
+   :term:`request`.  The ``exception`` attribute of the request will be an
+   instance of the :exc:`~pyramid.response.HTTPForbidden` exception that
+   caused the forbidden view to be called.  The value of
+   ``request.exception.args[0]`` will be a value explaining why the forbidden
+   was raised.  This message will be different when the
+   ``debug_authorization`` environment setting is true than it is when it is
+   false.
 
 .. index::
    single: request factory
diff --git a/docs/narr/renderers.rst b/docs/narr/renderers.rst
index c3533648b..c7a3d7837 100644
--- a/docs/narr/renderers.rst
+++ b/docs/narr/renderers.rst
@@ -73,30 +73,43 @@ When this configuration is added to an application, the
 which renders view return values to a :term:`JSON` response serialization.
 
 Other built-in renderers include renderers which use the :term:`Chameleon`
-templating language to render a dictionary to a response.
+templating language to render a dictionary to a response.  Additional
+renderers can be added by developers to the system as necessary (see
+:ref:`adding_and_overriding_renderers`).
+
+Views which use a renderer can vary non-body response attributes (such as
+headers and the HTTP status code) by attaching a property to the
+``request.response`` attribute See :ref:`request_response_attr`.
 
 If the :term:`view callable` associated with a :term:`view configuration`
 returns a Response object directly (an object with the attributes ``status``,
 ``headerlist`` and ``app_iter``), any renderer associated with the view
 configuration is ignored, and the response is passed back to :app:`Pyramid`
 unchanged.  For example, if your view callable returns an instance of the
-:class:`pyramid.httpexceptions.HTTPFound` class as a response, no renderer
-will be employed.
+:class:`pyramid.response.HTTPFound` class as a response, no renderer will be
+employed.
 
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import HTTPFound
+   from pyramid.response import HTTPFound
 
    def view(request):
        return HTTPFound(location='http://example.com') # any renderer avoided
 
-Views which use a renderer can vary non-body response attributes (such as
-headers and the HTTP status code) by attaching a property to the
-``request.response`` attribute See :ref:`request_response_attr`.
+Likewise for a "plain old response":
+
+.. code-block:: python
+   :linenos:
+
+   from pyramid.response import Response
+
+   def view(request):
+       return Response('OK') # any renderer avoided
 
-Additional renderers can be added by developers to the system as necessary
-(see :ref:`adding_and_overriding_renderers`).
+Mutations to ``request.response`` in views which return a Response object
+like this directly (unless that response *is* ``request.response``) will be
+ignored.
 
 .. index::
    single: renderers (built-in)
diff --git a/docs/narr/router.rst b/docs/narr/router.rst
index 11f84d4ea..44fa9835b 100644
--- a/docs/narr/router.rst
+++ b/docs/narr/router.rst
@@ -77,40 +77,37 @@ processing?
 #. A :class:`~pyramid.events.ContextFound` :term:`event` is
    sent to any subscribers.
 
-#. :app:`Pyramid` looks up a :term:`view` callable using the
-   context, the request, and the view name.  If a view callable
-   doesn't exist for this combination of objects (based on the type of
-   the context, the type of the request, and the value of the view
-   name, and any :term:`predicate` attributes applied to the view
-   configuration), :app:`Pyramid` raises a
-   :class:`~pyramid.exceptions.NotFound` exception, which is meant
-   to be caught by a surrounding exception handler.
+#. :app:`Pyramid` looks up a :term:`view` callable using the context, the
+   request, and the view name.  If a view callable doesn't exist for this
+   combination of objects (based on the type of the context, the type of the
+   request, and the value of the view name, and any :term:`predicate`
+   attributes applied to the view configuration), :app:`Pyramid` raises a
+   :class:`~pyramid.response.HTTPNotFound` exception, which is meant to be
+   caught by a surrounding exception handler.
 
 #. If a view callable was found, :app:`Pyramid` attempts to call
    the view function.
 
-#. If an :term:`authorization policy` is in use, and the view was
-   protected by a :term:`permission`, :app:`Pyramid` passes the
-   context, the request, and the view_name to a function which
-   determines whether the view being asked for can be executed by the
-   requesting user, based on credential information in the request and
-   security information attached to the context.  If it returns
-   ``True``, :app:`Pyramid` calls the view callable to obtain a
-   response.  If it returns ``False``, it raises a
-   :class:`~pyramid.exceptions.Forbidden` exception, which is meant
-   to be called by a surrounding exception handler.
+#. If an :term:`authorization policy` is in use, and the view was protected
+   by a :term:`permission`, :app:`Pyramid` passes the context, the request,
+   and the view_name to a function which determines whether the view being
+   asked for can be executed by the requesting user, based on credential
+   information in the request and security information attached to the
+   context.  If it returns ``True``, :app:`Pyramid` calls the view callable
+   to obtain a response.  If it returns ``False``, it raises a
+   :class:`~pyramid.response.HTTPForbidden` exception, which is meant to be
+   called by a surrounding exception handler.
 
 #. If any exception was raised within a :term:`root factory`, by
-   :term:`traversal`, by a :term:`view callable` or by
-   :app:`Pyramid` itself (such as when it raises
-   :class:`~pyramid.exceptions.NotFound` or
-   :class:`~pyramid.exceptions.Forbidden`), the router catches the
-   exception, and attaches it to the request as the ``exception``
-   attribute.  It then attempts to find a :term:`exception view` for
-   the exception that was caught.  If it finds an exception view
-   callable, that callable is called, and is presumed to generate a
-   response.  If an :term:`exception view` that matches the exception
-   cannot be found, the exception is reraised.
+   :term:`traversal`, by a :term:`view callable` or by :app:`Pyramid` itself
+   (such as when it raises :class:`~pyramid.response.HTTPNotFound` or
+   :class:`~pyramid.response.HTTPForbidden`), the router catches the
+   exception, and attaches it to the request as the ``exception`` attribute.
+   It then attempts to find a :term:`exception view` for the exception that
+   was caught.  If it finds an exception view callable, that callable is
+   called, and is presumed to generate a response.  If an :term:`exception
+   view` that matches the exception cannot be found, the exception is
+   reraised.
 
 #. The following steps occur only when a :term:`response` could be
    successfully generated by a normal :term:`view callable` or an
diff --git a/docs/narr/testing.rst b/docs/narr/testing.rst
index bd45388c2..862eda9f0 100644
--- a/docs/narr/testing.rst
+++ b/docs/narr/testing.rst
@@ -191,11 +191,11 @@ function.
    :linenos:
 
    from pyramid.security import has_permission
-   from pyramid.exceptions import Forbidden
+   from pyramid.response import HTTPForbidden
 
    def view_fn(request):
        if not has_permission('edit', request.context, request):
-           raise Forbidden
+           raise HTTPForbidden
        return {'greeting':'hello'}
 
 Without doing anything special during a unit test, the call to
@@ -207,7 +207,7 @@ application registry is not created and populated (e.g. by initializing the
 configurator with an authorization policy), like when you invoke application
 code via a unit test, :app:`Pyramid` API functions will tend to either fail
 or return default results.  So how do you test the branch of the code in this
-view function that raises :exc:`Forbidden`?
+view function that raises :exc:`HTTPForbidden`?
 
 The testing API provided by :app:`Pyramid` allows you to simulate various
 application registry registrations for use under a unit testing framework
@@ -230,16 +230,15 @@ without needing to invoke the actual application configuration implied by its
            testing.tearDown()
        
        def test_view_fn_forbidden(self):
-           from pyramid.exceptions import Forbidden
+           from pyramid.response import HTTPForbidden
            from my.package import view_fn
            self.config.testing_securitypolicy(userid='hank', 
                                               permissive=False)
            request = testing.DummyRequest()
            request.context = testing.DummyResource()
-           self.assertRaises(Forbidden, view_fn, request)
+           self.assertRaises(HTTPForbidden, view_fn, request)
 
        def test_view_fn_allowed(self):
-           from pyramid.exceptions import Forbidden
            from my.package import view_fn
            self.config.testing_securitypolicy(userid='hank', 
                                               permissive=True)
@@ -265,7 +264,7 @@ We call the function being tested with the manufactured request.  When the
 function is called, :func:`pyramid.security.has_permission` will call the
 "dummy" authentication policy we've registered through
 :meth:`~pyramid.config.Configuration.testing_securitypolicy`, which denies
-access.  We check that the view function raises a :exc:`Forbidden` error.
+access.  We check that the view function raises a :exc:`HTTPForbidden` error.
 
 The second test method, named ``test_view_fn_allowed`` tests the alternate
 case, where the authentication policy allows access.  Notice that we pass
diff --git a/docs/narr/urldispatch.rst b/docs/narr/urldispatch.rst
index 5df1eb3af..e5228b81e 100644
--- a/docs/narr/urldispatch.rst
+++ b/docs/narr/urldispatch.rst
@@ -917,7 +917,7 @@ the application's startup configuration, adding the following stanza:
    :linenos:
 
    config.add_view('pyramid.view.append_slash_notfound_view', 
-                   context='pyramid.exceptions.NotFound')
+                   context='pyramid.response.HTTPNotFound')
 
 See :ref:`view_module` and :ref:`changing_the_notfound_view` for more
 information about the slash-appending not found view and for a more general
@@ -945,14 +945,14 @@ view as the first argument to its constructor.  For instance:
 .. code-block:: python
      :linenos:
 
-     from pyramid.exceptions import NotFound
+     from pyramid.response import HTTPNotFound
      from pyramid.view import AppendSlashNotFoundViewFactory
 
      def notfound_view(context, request):
          return HTTPNotFound('It aint there, stop trying!')
 
      custom_append_slash = AppendSlashNotFoundViewFactory(notfound_view)
-     config.add_view(custom_append_slash, context=NotFound)
+     config.add_view(custom_append_slash, context=HTTPNotFound)
 
 The ``notfound_view`` supplied must adhere to the two-argument view callable
 calling convention of ``(context, request)`` (``context`` will be the
diff --git a/docs/narr/views.rst b/docs/narr/views.rst
index 66e9919e2..73a7c2e2a 100644
--- a/docs/narr/views.rst
+++ b/docs/narr/views.rst
@@ -233,7 +233,7 @@ implements the :term:`Response` interface is to return a
 You don't need to always use :class:`~pyramid.response.Response` to represent
 a response.  :app:`Pyramid` provides a range of different "exception" classes
 which can act as response objects too.  For example, an instance of the class
-:class:`pyramid.httpexceptions.HTTPFound` is also a valid response object
+:class:`pyramid.response.HTTPFound` is also a valid response object
 (see :ref:`http_exceptions` and ref:`http_redirect`).  A view can actually
 return any object that has the following attributes.
 
@@ -275,17 +275,18 @@ exist: internal exceptions and HTTP exceptions.
 Internal Exceptions
 ~~~~~~~~~~~~~~~~~~~
 
-:exc:`pyramid.exceptions.NotFound` and :exc:`pyramid.exceptions.Forbidden`
-are exceptions often raised by Pyramid itself when it (respectively) cannot
-find a view to service a request or when authorization was forbidden by a
-security policy.  However, they can also be raised by application developers.
+:exc:`pyramid.response.HTTPNotFound` and
+:exc:`pyramid.response.HTTPForbidden` are exceptions often raised by Pyramid
+itself when it (respectively) cannot find a view to service a request or when
+authorization was forbidden by a security policy.  However, they can also be
+raised by application developers.
 
-If :exc:`~pyramid.exceptions.NotFound` is raised within view code, the result
-of the :term:`Not Found View` will be returned to the user agent which
+If :exc:`~pyramid.response.HTTPNotFound` is raised within view code, the
+result of the :term:`Not Found View` will be returned to the user agent which
 performed the request.
 
-If :exc:`~pyramid.exceptions.Forbidden` is raised within view code, the result
-of the :term:`Forbidden View` will be returned to the user agent which
+If :exc:`~pyramid.response.HTTPForbidden` is raised within view code, the
+result of the :term:`Forbidden View` will be returned to the user agent which
 performed the request.
 
 Both are exception classes which accept a single positional constructor
@@ -298,13 +299,10 @@ An example:
 .. code-block:: python
    :linenos:
 
-    from pyramid.exceptions import NotFound
+    from pyramid.response import HTTPNotFound
 
     def aview(request):
-        raise NotFound('not found!')
-
-Internal exceptions may not be *returned* in order to generate a response,
-they must always be *raised*.
+        raise HTTPNotFound('not found!')
 
 .. index::
    single: HTTP exceptions
@@ -314,32 +312,33 @@ they must always be *raised*.
 HTTP Exceptions
 ~~~~~~~~~~~~~~~
 
-All exception classes documented in the :mod:`pyramid.httpexceptions` module
-implement the :term:`Response` interface; an instance of any of these classes
-can be returned or raised from within a view.  The instance will be used as
-as the view's response.
+All classes documented in the :mod:`pyramid.response` module as inheriting
+from the :class:`pryamid.response.Response` object implement the
+:term:`Response` interface; an instance of any of these classes can be
+returned or raised from within a view.  The instance will be used as as the
+view's response.
 
-For example, the :class:`pyramid.httpexceptions.HTTPUnauthorized` exception
+For example, the :class:`pyramid.response.HTTPUnauthorized` exception
 can be raised.  This will cause a response to be generated with a ``401
 Unauthorized`` status:
 
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import HTTPUnauthorized
+   from pyramid.response import HTTPUnauthorized
 
    def aview(request):
        raise HTTPUnauthorized()
 
 A shortcut for importing and raising an HTTP exception is the
-:func:`pyramid.httpexceptions.abort` function.  This function accepts an HTTP
+:func:`pyramid.response.abort` function.  This function accepts an HTTP
 status code and raises the corresponding HTTP exception.  For example, to
 raise HTTPUnauthorized, instead of the above, you could do:
 
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import abort
+   from pyramid.response import abort
 
    def aview(request):
        abort(401)
@@ -347,8 +346,8 @@ raise HTTPUnauthorized, instead of the above, you could do:
 This is the case because ``401`` is the HTTP status code for "HTTP
 Unauthorized".  Therefore, ``abort(401)`` is functionally equivalent to
 ``raise HTTPUnauthorized()``.  Other exceptions in
-:mod:`pyramid.httpexceptions` can be raised via
-:func:`pyramid.httpexceptions.abort` as well, as long as the status code
+:mod:`pyramid.response` can be raised via
+:func:`pyramid.response.abort` as well, as long as the status code
 associated with the exception is provided to the function.
 
 An HTTP exception, instead of being raised, can alternately be *returned*
@@ -357,18 +356,11 @@ An HTTP exception, instead of being raised, can alternately be *returned*
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import HTTPUnauthorized
+   from pyramid.response import HTTPUnauthorized
 
    def aview(request):
        return HTTPUnauthorized()
 
-Note that :class:`pyramid.exceptions.NotFound` is *not* the same as
-:class:`pyramid.httpexceptions.HTTPNotFound`.  If the latter is raised, the
-:term:`Not Found view` will *not* be called automatically.  Likewise,
-:class:`pyramid.exceptions.Forbidden` is not the same exception as
-:class:`pyramid.httpexceptions.HTTPForbidden`.  If the latter is raised, the
-:term:`Forbidden view` will not be called automatically.
-
 .. index::
    single: exception views
 
@@ -377,11 +369,11 @@ Note that :class:`pyramid.exceptions.NotFound` is *not* the same as
 Custom Exception Views
 ----------------------
 
-The machinery which allows :exc:`~pyramid.exceptions.NotFound`,
-:exc:`~pyramid.exceptions.Forbidden` and HTTP exceptions to be caught by
-specialized views as described in :ref:`special_exceptions_in_callables` can
-also be used by application developers to convert arbitrary exceptions to
-responses.
+The machinery which allows :exc:`~pyramid.response.HTTPNotFound`,
+:exc:`~pyramid.response.HTTPForbidden` and other responses to be used as
+exceptions and caught by specialized views as described in
+:ref:`special_exceptions_in_callables` can also be used by application
+developers to convert arbitrary exceptions to responses.
 
 To register a view that should be called whenever a particular exception is
 raised from with :app:`Pyramid` view code, use the exception class or one of
@@ -474,14 +466,14 @@ Short Form
 ~~~~~~~~~~
 
 You can issue an HTTP redirect from within a view callable by using the
-:func:`pyramid.httpexceptions.redirect` function.  This function raises an
-:class:`pyramid.httpexceptions.HTTPFound` exception (a "302"), which is
-caught by an exception handler and turned into a response.
+:func:`pyramid.response.redirect` function.  This function raises an
+:class:`pyramid.response.HTTPFound` exception (a "302"), which is caught by
+the default exception response handler and turned into a response.
 
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import redirect
+   from pyramid.response import redirect
 
    def myview(request):
        redirect('http://example.com')
@@ -490,16 +482,16 @@ Long Form
 ~~~~~~~~~
 
 You can issue an HTTP redirect from within a view "by hand" instead of
-relying on the :func:`pyramid.httpexceptions.redirect` function to do it for
+relying on the :func:`pyramid.response.redirect` function to do it for
 you.
 
-To do so, you can *return* a :class:`pyramid.httpexceptions.HTTPFound`
+To do so, you can *return* a :class:`pyramid.response.HTTPFound`
 instance.
 
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import HTTPFound
+   from pyramid.response import HTTPFound
 
    def myview(request):
        return HTTPFound(location='http://example.com')
@@ -510,7 +502,7 @@ one.
 .. code-block:: python
    :linenos:
 
-   from pyramid.httpexceptions import HTTPFound
+   from pyramid.response import HTTPFound
 
    def myview(request):
        raise HTTPFound(location='http://example.com')
diff --git a/docs/narr/webob.rst b/docs/narr/webob.rst
index 072ca1c74..6cd9418ce 100644
--- a/docs/narr/webob.rst
+++ b/docs/narr/webob.rst
@@ -362,11 +362,11 @@ To facilitate error responses like ``404 Not Found``, the module
 :mod:`webob.exc` contains classes for each kind of error response.  These
 include boring, but appropriate error bodies.  The exceptions exposed by this
 module, when used under :app:`Pyramid`, should be imported from the
-:mod:`pyramid.httpexceptions` "facade" module.  This import location is merely
-a facade for the original location of these exceptions: ``webob.exc``.
+:mod:`pyramid.response` module.  This import location contains subclasses and
+replacements that mirror those in the original ``webob.exc``.
 
-Each class is named ``pyramid.httpexceptions.HTTP*``, where ``*`` is the reason
-for the error.  For instance, :class:`pyramid.httpexceptions.HTTPNotFound`.  It
+Each class is named ``pyramid.response.HTTP*``, where ``*`` is the reason for
+the error.  For instance, :class:`pyramid.response.HTTPNotFound`.  It
 subclasses :class:`pyramid.Response`, so you can manipulate the instances in
 the same way.  A typical example is:
 
@@ -374,40 +374,18 @@ the same way.  A typical example is:
 .. code-block:: python
     :linenos:
 
-    from pyramid.httpexceptions import HTTPNotFound
-    from pyramid.httpexceptions import HTTPMovedPermanently
+    from pyramid.response import HTTPNotFound
+    from pyramid.response import HTTPMovedPermanently
 
     response = HTTPNotFound('There is no such resource')
     # or:
     response = HTTPMovedPermanently(location=new_url)
 
-These are not exceptions unless you are using Python 2.5+, because
-they are new-style classes which are not allowed as exceptions until
-Python 2.5.  To get an exception object use ``response.exception``.
-You can use this like:
-
-.. code-block:: python
-   :linenos:
-
-   from pyramid.httpexceptions import HTTPException
-   from pyramid.httpexceptions import HTTPNotFound
-
-   def aview(request):
-       try:
-           # ... stuff ...
-           raise HTTPNotFound('No such resource').exception
-       except HTTPException, e:
-           return request.get_response(e)
-
-The exceptions are still WSGI applications, but you cannot set
-attributes like ``content_type``, ``charset``, etc. on these exception
-objects.
-
 More Details
 ++++++++++++
 
 More details about the response object API are available in the
 :mod:`pyramid.response` documentation.  More details about exception responses
-are in the :mod:`pyramid.httpexceptions` API documentation.  The `WebOb
+are in the :mod:`pyramid.response` API documentation.  The `WebOb
 documentation <http://pythonpaste.org/webob>`_ is also useful.