This class allows you to send requests to a wrapped application. The use_cookies parameter indicates whether cookies should be stored and sen

Represents an outgoing WSGI HTTP response with body, status, and headers. Has properties and methods for using the functionality defined by va

An object that stores some headers. It has a dict-like interface, but is ordered, can store the same key multiple times, and iterating yields

This class can be used to conveniently create a WSGI environment for testing purposes. It can be used to quickly create WSGI environments or

*404* `Not Found` Raise if a resource does not exist and never existed.

A Rule represents one URL pattern. There are some options for `Rule` that change the way it behaves and are passed to the `Rule` constructor.

A :class:`MultiDict` is a dictionary subclass customized to deal with multiple values for the same key which is for example used by the parsing

Represents an incoming WSGI HTTP request, with headers and body taken from the WSGI environment. Has properties and methods for using the func

Represents the non-IO parts of an HTTP response, specifically the status and headers but not the body. This class is not meant for general us

A WSGI middleware which provides static content for development environments or simple server setups. Its usage is quite simple:: import

The map class stores all the URL rules and some configuration parameters. Some of the configuration values are only stored on the `Map` insta

Encapsulates a WSGI response. Unlike the default response object werkzeug provides, this accepts a genshi stream and will automatically rend

The WSGI specification requires that all middlewares and gateways respect the `close` callback of the iterable returned by the application. Be

Warns about common errors in the WSGI and HTTP behavior of the server and wrapped application. Some of the issues it checks are: - invalid

Create a namespace of context-local data. This wraps a :class:`ContextVar` containing a :class:`dict` value. This may incur a performance pen

Manage releasing the data for the current context in one or more :class:`Local` and :class:`LocalStack` objects. This should not be needed fo

The :class:`FileStorage` class is a thin wrapper over incoming files. It is used by the request object to represent uploaded files. All the a

Represents the non-IO parts of a HTTP request, including the method, URL info, and headers. This class is not meant for general use. It shoul

*400* `Bad Request` Raise if the browser sends something to the application the application or server cannot handle.

Read only version of the headers from a WSGI environment. This provides the same interface as `Headers` and is constructed from a WSGI enviro

This class implements parsing of form data for Werkzeug. By itself it can parse multipart and url encoded form data. It can be subclassed an

A StringO version that HTML escapes on write.

Decodes a multipart message as bytes into Python events. The part data is returned as available to allow the caller to save the data from mem

Works like a regular :class:`MultiDict` but preserves the order of the fields. To convert the ordered multi dict into a list you can use the

An :class:`Accept` object is just a list subclass for lists of ``(value, quality)`` tuples. It is automatically sorted by specificity and qua

Represents an ``Authorization`` header sent by the client. This is returned by :func:`~werkzeug.http.parse_authorization_header`. It can be u

A dict that calls a function passed every time something is changed. The function is passed the dict instance.

A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict` instances as sequence and it will combine the return values of all wr

An interactive console.

Represents the content range header. .. versionadded:: 0.7

Subclass of a dict that stores values for a Content Security Policy header. It has accessors for all the level 3 policies. Because the csp di

Enables debugging support for a given application:: from werkzeug.debug import DebuggedApplication from myapp import app app

The base class for all HTTP exceptions. This exception can be called as a WSGI application to render a default error page or you can catch the sub

*500* `Internal Server Error` Raise if an internal server error occurred. This is a good fallback if an unknown error occurred in the dispat

Wraps a stream so that it doesn't read more than n bytes. If the stream is exhausted and the caller tries to get more bytes from it :func:`on

A proxy to the object bound to a context-local object. All operations on the proxy are forwarded to the bound object. If no object is bound, a

*405* `Method Not Allowed` Raise if the server used a method the resource does not handle. For example `POST` if the resource is view only.

*413* `Request Entity Too Large` The status code one should return if the data submitted exceeded a given limit.

The concrete response object for the WSGI application.

Represents one revision of a page. This is useful for editing particular revision of pages or creating new revisions. It's also used for

A part of a rule. Rules can be represented by parts as delimited by `/` with instances of this class representing those parts. The *content*

A representation of a rule state. This includes the *rules* that correspond to the state and the possible *static* and *dynamic* transitions

Like `Subdomain` but prefixes the URL rule with a given string:: url_map = Map([ Rule('/', endpoint='index'), Submoun

This class can be used to convert an iterable object into an iterable that will only yield a piece of the underlying content. It yields blocks

Like `environ_property` but for headers.

When passed a dict of code -> exception items it can be used as callable that raises exceptions. If the first argument to the callable is an

*502* `Bad Gateway` If you do proxying in your application you should return this status code if you received an invalid response from the up

Raised if the submitted host is badly formatted. .. versionadded:: 0.11.2

A WSGI server that that handles one request at a time. Use :func:`make_server` to create a server instance.

Raised if the build system cannot find a URL for an endpoint with the values provided.

Represents a parsed URL in bytes.

Cross Origin Embedder Policies

Cross Origin Opener Policies

Like :class:`Accept` but with normalization for charsets.

Internal exception that is raised if Werkzeug detects a disconnected client. Since the client is already gone at that point attempting to sen

If a redirect loop is detected when using follow_redirects=True with the :cls:`Client`, then this exception is raised.

The application class. It's passed a directory with configuration values.

A :class:`traceback.FrameSummary` that can evaluate code in the frame's namespace.

An input stream that handles Transfer-Encoding 'chunked

Combine multiple applications as a single WSGI application. Requests are dispatched to an application based on the path it is mounted under.

Prefixes all endpoints (which must be strings for this factory) with another string. This can be useful for sub applications:: url_map =

A WSGI server that handles concurrent requests in separate forked processes. Use :func:`make_server` to create a server instance.

An immutable :class:`dict`. .. versionadded:: 0.5

Provides information about a failed :func:`import_string` attempt.

Like :class:`Accept` but with normalization for language tags.

Like :class:`Accept` but with special methods and behavior for mimetypes.

Returned by :meth:`Map.bind` or :meth:`Map.bind_to_environ` and does the URL matching and building based on runtime information.