How to use the werkzeug.exceptions.HTTPException function in Werkzeug

def dispatch_request(self, request):
        adapter = self.urls.bind_to_environ(request.environ)

        try:
            endpoint, values = adapter.match()
            return getattr(self, 'view_' + endpoint)(request, **values)
        except HTTPException, e:
            return e

def allowed_methods(self, path_info=None):
        """Returns the valid methods that match for a given path.

        .. versionadded:: 0.7
        """
        try:
            self.match(path_info, method='--')
        except MethodNotAllowed as e:
            return e.valid_methods
        except HTTPException as e:
            pass
        return []

def task(app, rq):
            """ Run the decorated route function in a new thread """
            this_task = _tasks[task_id]
            # Pretty ugly hack, but no better solution is apparent:
            # Create a fresh Flask RequestContext object, wrapping our
            # custom _RequestProxy object that can be safely passed between threads
            with RequestContext(app, rq.environ, request=rq):
                try:
                    # Run the original route function and record
                    # the response (return value)
                    rq.set_progress_func(progress)
                    this_task["rv"] = f(*args, **kwargs)
                except HTTPException as e:
                    this_task["rv"] = current_app.handle_http_exception(e)
                except Exception as e:
                    # The function raised an exception, so we set a 500 error
                    this_task["rv"] = InternalServerError()
                    if current_app.debug:
                        # We want to find out if something happened, so reraise
                        raise
                finally:
                    # We record the time of the response, to help in garbage
                    # collecting old tasks
                    this_task["t"] = datetime.utcnow()

if isinstance(response, Exception):
                    exception = response
                else:
                    # if parent excplicitely returns a plain response, then we don't touch it
                    return response
            except Exception as e:
                if 'werkzeug' in config['dev_mode'] and (not isinstance(exception, QWebException) or not exception.qweb.get('cause')):
                    raise
                exception = e

            values = dict(
                exception=exception,
                traceback=traceback.format_exc(),
            )

            if isinstance(exception, werkzeug.exceptions.HTTPException):
                if exception.code is None:
                    # Hand-crafted HTTPException likely coming from abort(),
                    # usually for a redirect response -> return it directly
                    return exception
                else:
                    code = exception.code

            if isinstance(exception, flectra.exceptions.AccessError):
                code = 403

            if isinstance(exception, QWebException):
                values.update(qweb_exception=exception)
                if isinstance(exception.qweb.get('cause'), flectra.exceptions.AccessError):
                    code = 403

            if code == 500:

def add_epic_pid(rec, recid, checksum):
    """ Adds EPIC PID to the record. If registration fails, can
    also fail the request if CFG_FAIL_ON_MISSING_PID is set to True"""
    from invenio.legacy.bibrecord import record_add_field
    CFG_SITE_SECURE_URL = current_app.config.get("CFG_SITE_SECURE_URL")
    location = CFG_SITE_SECURE_URL + '/record/' + str(recid)
    try:
        pid = createHandle(location, checksum)
        record_add_field(rec, '024', ind1='7',
                         subfields=[('2', 'PID'), ('a', pid)])
    except HTTPException as e:
        # If CFG_FAIL_ON_MISSING_PID is not found in invenio-local.conf,
        # default is to assume False
        try:
            from config import CFG_FAIL_ON_MISSING_PID
            fail = bool(CFG_FAIL_ON_MISSING_PID)
        except ImportError:
            fail = False

        current_app.logger.error(
            "Unable to obtain PID from EPIC server {0} {1}: {2}".
            format(e.code, e.name, e))
        if fail:
            raise e

optional exception context to start the response.
        """
        cleanup = True
        try:
            request = self.request_class(environ)
            self.set_locals(request)

            if request.method not in ALLOWED_METHODS:
                abort(501)

            match = self.router.match(request)
            response = self.router.dispatch(self, request, match)
        except Exception, e:
            try:
                response = self.handle_exception(request, e)
            except HTTPException, e:
                response = self.make_response(e)
            except:
                if self.debug:
                    cleanup = False
                    raise

                # We only log unhandled non-HTTP exceptions. Users should
                # take care of logging in custom error handlers.
                logging.exception(e)
                response = self.make_response(InternalServerError())
        finally:
            if cleanup:
                self.clear_locals()

        return response(environ, start_response)

# it thinks a CherryPy request is available, so we just set it here to 
    # avoid AttributeErrors in that code (since we really aren't inside 
    # a CherryPy request at this point).
    import cherrypy
    try:
        cherrypy.request.tg_template_enginename = 'kid'
    except AttributeError:
        pass
    return render(data, template_name)

# Error handling helpers that play nice with the Beaker CLI.
# These report HTTP errors as plain text responses containing just the
# error message details, which the client then intercepts and displays as
# the error message for a failed command.

class PlainTextHTTPException(HTTPException):
    """A base class for returning error details as plain text"""
    def get_body(self, environ):
        return self.description
    def get_headers(self, environ):
        return [('Content-Type', 'text/plain; charset=UTF-8')]

class BadRequest400(PlainTextHTTPException):
    code = 400

class Unauthorised401(PlainTextHTTPException):
    code = 401

class Forbidden403(PlainTextHTTPException):
    code = 403
    def get_body(self, environ):
        return ("Insufficient permissions: " + self.description)

def json_error_page(error):
    err_msg = error.description if isinstance(error, HTTPException) else unicode(error)
    resp = Response(json.dumps({'error': err_msg}), mimetype=mime_types.JSON)
    resp.status_code = (error.code if isinstance(error, HTTPException) else 500)
    return resp

for attr in addr['attrs']:
                    if attr[0] == 'IFLA_IFNAME':
                        return attr[1]
        except Exception as e:
            LOG.info('Unable to find interface with MAC: %s, rescanning '
                     'and returning 404. Reported error: %s', mac, str(e))

        # Poke the kernel to re-enumerate the PCI bus.
        # We have had cases where nova hot plugs the interface but
        # the kernel doesn't get the memo.
        filename = '/sys/bus/pci/rescan'
        flags = os.O_WRONLY
        if os.path.isfile(filename):
            with os.fdopen(os.open(filename, flags), 'w') as rescan_file:
                rescan_file.write('1')
        raise exceptions.HTTPException(
            response=webob.Response(json=dict(
                details="No suitable network interface found"), status=404))

def make_json_error(ex):
        response = jsonify(message=str(ex))
        response.status_code = (ex.code if isinstance(ex, HTTPException) else 500)
        return response