code.InteractiveInterpreter
werkzeug.debug.console._InteractiveConsole
- Undocumentedcollections.abc.Collection
werkzeug.datastructures.ETags
- A set that can be used to check if one etag is present in a collection of etags.collections.abc.MutableSet
werkzeug.datastructures.HeaderSet
- Similar to the :class:`ETags` class this implements a set-like structure. Unlike :class:`ETags` this is case insensitive and used for vary, allow, and content-language headers.dict
werkzeug.datastructures._CacheControl
- Subclass of a dict that stores values for a Cache-Control header. It has accessors for all the cache-control directives specified in RFC 2616. The class does not differentiate between request and response directives.werkzeug.datastructures.RequestCacheControl
- A cache control for requests. This is immutable and gives access to all the request-relevant cache control headers.werkzeug.datastructures.ResponseCacheControl
- A cache control for responses. Unlike :class:`RequestCacheControl` this is mutable and gives access to response-relevant cache control headers.werkzeug.datastructures.Authorization
- Represents an ``Authorization`` header sent by the client.werkzeug.datastructures.CallbackDict
- A dict that calls a function passed every time something is changed. The function is passed the dict instance.werkzeug.datastructures.ContentSecurityPolicy
- Subclass of a dict that stores values for a Content Security Policy header. It has accessors for all the level 3 policies.werkzeug.datastructures.ImmutableDict
- An immutable :class:`dict`.werkzeug.datastructures.TypeConversionDict
- Works like a regular dict but the :meth:`get` method can perform type conversions. :class:`MultiDict` and :class:`CombinedMultiDict` are subclasses of this class and provide the same feature.werkzeug.datastructures.ImmutableTypeConversionDict
- Works like a :class:`TypeConversionDict` but does not support modifications.werkzeug.datastructures.MultiDict
- 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 functions in the wrappers. This is necessary because some HTML form elements pass multiple values for the same key.werkzeug.datastructures.CombinedMultiDict
- A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict` instances as sequence and it will combine the return values of all wrapped dicts:werkzeug.datastructures.FileMultiDict
- A special :class:`MultiDict` that has convenience methods to add files to it. This is used for :class:`EnvironBuilder` and generally useful for unittesting.werkzeug.datastructures.ImmutableMultiDict
- An immutable :class:`MultiDict`.werkzeug.datastructures.OrderedMultiDict
- 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 :meth:`items` method and pass it ``multi=True``.werkzeug.datastructures.ImmutableOrderedMultiDict
- An immutable :class:`OrderedMultiDict`.werkzeug.datastructures.UpdateDictMixin
- Makes dicts call `self.on_update` on modifications.werkzeug.datastructures._CacheControl
- Subclass of a dict that stores values for a Cache-Control header. It has accessors for all the cache-control directives specified in RFC 2616. The class does not differentiate between request and response directives.werkzeug.datastructures.RequestCacheControl
- A cache control for requests. This is immutable and gives access to all the request-relevant cache control headers.werkzeug.datastructures.ResponseCacheControl
- A cache control for responses. Unlike :class:`RequestCacheControl` this is mutable and gives access to response-relevant cache control headers.werkzeug.datastructures.CallbackDict
- A dict that calls a function passed every time something is changed. The function is passed the dict instance.werkzeug.datastructures.ContentSecurityPolicy
- Subclass of a dict that stores values for a Content Security Policy header. It has accessors for all the level 3 policies.werkzeug.datastructures.WWWAuthenticate
- Provides simple access to `WWW-Authenticate` headers.werkzeug.datastructures.WWWAuthenticate
- Provides simple access to `WWW-Authenticate` headers.enum.Enum
werkzeug.http.COEP
- Cross Origin Embedder Policieswerkzeug.http.COOP
- Cross Origin Opener Policieswerkzeug.sansio.multipart.State
- UndocumentedException
werkzeug.exceptions.HTTPException
- 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 subclasses of it independently and render nicer error messages.werkzeug.exceptions._RetryAfter
- Adds an optional ``retry_after`` parameter which will set the ``Retry-After`` header. May be an :class:`int` number of seconds or a :class:`~datetime.datetime`.werkzeug.exceptions.ServiceUnavailable
- *503* `Service Unavailable`werkzeug.exceptions.TooManyRequests
- *429* `Too Many Requests`werkzeug.exceptions.BadGateway
- *502* `Bad Gateway`werkzeug.exceptions.BadRequest
- *400* `Bad Request`werkzeug.exceptions.BadHost
- Raised if the submitted host is badly formatted.werkzeug.exceptions.BadRequestKeyError
- An exception that is used to signal both a :exc:`KeyError` and a :exc:`BadRequest`. Used by many of the datastructures.werkzeug.exceptions.ClientDisconnected
- Internal exception that is raised if Werkzeug detects a disconnected client. Since the client is already gone at that point attempting to send the error message to the client might not work and might ultimately result in another exception in the server...werkzeug.exceptions.SecurityError
- Raised if something triggers a security error. This is otherwise exactly like a bad request error.werkzeug.routing.exceptions.WebsocketMismatch
- The only matched rule is either a WebSocket and the request is HTTP, or the rule is HTTP and the request is a WebSocket.werkzeug.exceptions.Conflict
- *409* `Conflict`werkzeug.exceptions.ExpectationFailed
- *417* `Expectation Failed`werkzeug.exceptions.FailedDependency
- *424* `Failed Dependency`werkzeug.exceptions.Forbidden
- *403* `Forbidden`werkzeug.exceptions.GatewayTimeout
- *504* `Gateway Timeout`werkzeug.exceptions.Gone
- *410* `Gone`werkzeug.exceptions.HTTPVersionNotSupported
- *505* `HTTP Version Not Supported`werkzeug.exceptions.ImATeapot
- *418* `I'm a teapot`werkzeug.exceptions.InternalServerError
- *500* `Internal Server Error`werkzeug.exceptions.LengthRequired
- *411* `Length Required`werkzeug.exceptions.Locked
- *423* `Locked`werkzeug.exceptions.MethodNotAllowed
- *405* `Method Not Allowed`werkzeug.exceptions.NotAcceptable
- *406* `Not Acceptable`werkzeug.exceptions.NotFound
- *404* `Not Found`werkzeug.exceptions.NotImplemented
- *501* `Not Implemented`werkzeug.exceptions.PreconditionFailed
- *412* `Precondition Failed`werkzeug.exceptions.PreconditionRequired
- *428* `Precondition Required`werkzeug.exceptions.RequestedRangeNotSatisfiable
- *416* `Requested Range Not Satisfiable`werkzeug.exceptions.RequestEntityTooLarge
- *413* `Request Entity Too Large`werkzeug.exceptions.RequestHeaderFieldsTooLarge
- *431* `Request Header Fields Too Large`werkzeug.exceptions.RequestTimeout
- *408* `Request Timeout`werkzeug.exceptions.RequestURITooLarge
- *414* `Request URI Too Large`werkzeug.exceptions.Unauthorized
- *401* ``Unauthorized``werkzeug.exceptions.UnavailableForLegalReasons
- *451* `Unavailable For Legal Reasons`werkzeug.exceptions.UnprocessableEntity
- *422* `Unprocessable Entity`werkzeug.exceptions.UnsupportedMediaType
- *415* `Unsupported Media Type`werkzeug.routing.exceptions.RequestRedirect
- Raise if the map requests a redirect. This is for example the case if `strict_slashes` are activated and an url that requires a trailing slash.werkzeug.routing.exceptions.NoMatch
- Undocumentedwerkzeug.routing.exceptions.RoutingException
- Special exceptions that require the application to redirect, notifying about missing urls, etc.werkzeug.routing.exceptions.BuildError
- Raised if the build system cannot find a URL for an endpoint with the values provided.werkzeug.routing.exceptions.RequestAliasRedirect
- This rule is an alias and wants to redirect to the canonical URL.werkzeug.routing.exceptions.RequestPath
- Internal exception.werkzeug.routing.exceptions.RequestRedirect
- Raise if the map requests a redirect. This is for example the case if `strict_slashes` are activated and an url that requires a trailing slash.werkzeug.routing.matcher.SlashRequired
- Undocumentedwerkzeug.test.ClientRedirectError
- If a redirect loop is detected when using follow_redirects=True with the :cls:`Client`, then this exception is raised.http.cookiejar.CookieJar
werkzeug.test._TestCookieJar
- A cookielib.CookieJar modified to inject and read cookie headers from and to wsgi environments, and wsgi application responses.http.server.BaseHTTPRequestHandler
werkzeug.serving.WSGIRequestHandler
- A request handler that implements WSGI dispatching.http.server.HTTPServer
werkzeug.serving.BaseWSGIServer
- A WSGI server that that handles one request at a time.werkzeug.serving.ForkingWSGIServer
- A WSGI server that handles concurrent requests in separate forked processes.werkzeug.serving.ThreadedWSGIServer
- A WSGI server that handles concurrent requests in separate threads.ImportError
werkzeug.utils.ImportStringError
- Provides information about a failed :func:`import_string` attempt.io.IOBase
werkzeug.wsgi.LimitedStream
- 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_exhausted` is called which by default returns an empty string...io.RawIOBase
werkzeug.serving.DechunkedInput
- An input stream that handles Transfer-Encoding 'chunked'KeyError
werkzeug.exceptions.BadRequestKeyError
- An exception that is used to signal both a :exc:`KeyError` and a :exc:`BadRequest`. Used by many of the datastructures.list
werkzeug.datastructures.ImmutableList
- An immutable :class:`list`.werkzeug.datastructures.Accept
- An :class:`Accept` object is just a list subclass for lists of ``(value, quality)`` tuples. It is automatically sorted by specificity and quality.werkzeug.datastructures.CharsetAccept
- Like :class:`Accept` but with normalization for charsets.werkzeug.datastructures.LanguageAccept
- Like :class:`Accept` but with normalization for language tags.werkzeug.datastructures.MIMEAccept
- Like :class:`Accept` but with special methods and behavior for mimetypes.logging.StreamHandler
werkzeug._internal._ColorStreamHandler
- On Windows, wrap stream with Colorama for ANSI style support.LookupError
werkzeug.routing.exceptions.BuildError
- Raised if the build system cannot find a URL for an endpoint with the values provided.property
werkzeug.utils.cached_property
- A :func:`property` that is only evaluated once. Subsequent access returns the cached value. Setting the property sets the cached value. Deleting the property clears the cached value, accessing it again will evaluate it again.socketserver.ForkingMixIn
werkzeug.serving.ForkingWSGIServer
- A WSGI server that handles concurrent requests in separate forked processes.socketserver.ThreadingMixIn
werkzeug.serving.ThreadedWSGIServer
- A WSGI server that handles concurrent requests in separate threads.traceback.FrameSummary
werkzeug.debug.tbtools.DebugFrameSummary
- A :class:`traceback.FrameSummary` that can evaluate code in the frame's namespace.typing.Generic
werkzeug._internal._DictAccessorProperty
- Baseclass for `environ_property` and `header_property`.werkzeug.utils.environ_property
- Maps request attributes to environment variables. This works not only for the Werkzeug request object, but also any other class with an environ attribute:werkzeug.utils.header_property
- Like `environ_property` but for headers.werkzeug.local.LocalProxy
- 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 ``RuntimeError`` is raised.werkzeug.local.LocalStack
- Create a stack of context-local data. This wraps a :class:`ContextVar` containing a :class:`list` value.werkzeug.utils.cached_property
- A :func:`property` that is only evaluated once. Subsequent access returns the cached value. Setting the property sets the cached value. Deleting the property clears the cached value, accessing it again will evaluate it again.typing.NamedTuple
werkzeug.routing.rules.Weighting
- Undocumentedwerkzeug.urls._URLTuple
- Undocumentedwerkzeug.urls.BaseURL
- Superclass of :py:class:`URL` and :py:class:`BytesURL`.werkzeug.urls.BytesURL
- Represents a parsed URL in bytes.werkzeug.urls.URL
- Represents a parsed URL. This behaves like a regular tuple but also has some extra attributes that give further insight into the URL.typing.Protocol
werkzeug.formparser.TStreamFactory
- UndocumentedValueError
werkzeug.routing.converters.ValidationError
- Validation error. If a rule converter raises this exception the rule does not match the current URL and the next URL is tried.Warning
werkzeug.middleware.lint.HTTPWarning
- Warning class for HTTP warnings.werkzeug.middleware.lint.WSGIWarning
- Warning class for WSGI warnings.werkzeug._internal._Missing
- Undocumentedwerkzeug._reloader.ReloaderLoop
- No class docstring; 0/3 instance variable, 0/1 class variable, 5/8 methods documentedwerkzeug._reloader.StatReloaderLoop
- Undocumentedwerkzeug._reloader.WatchdogReloaderLoop
- Undocumentedwerkzeug.datastructures._omd_bucket
- Wraps values in the :class:`OrderedMultiDict`. This makes it possible to keep an order over multiple different keys. It requires a lot of extra memory and slows down access a lot, but makes it possible to access elements in O(1) and iterate in O(n).werkzeug.datastructures.ContentRange
- Represents the content range header.werkzeug.datastructures.FileStorage
- The :class:`FileStorage` class is a thin wrapper over incoming files. It is used by the request object to represent uploaded files. All the attributes of the wrapper stream are proxied by the file storage so it's possible to do ``storage...werkzeug.datastructures.Headers
- 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 ``(key, value)`` pairs instead of only keys.werkzeug.datastructures.EnvironHeaders
- Read only version of the headers from a WSGI environment. This provides the same interface as `Headers` and is constructed from a WSGI environment.werkzeug.datastructures.IfRange
- Very simple object that represents the `If-Range` header in parsed form. It will either have neither a etag or date or one of either but never both.werkzeug.datastructures.ImmutableDictMixin
- Makes a :class:`dict` immutable.werkzeug.datastructures.Authorization
- Represents an ``Authorization`` header sent by the client.werkzeug.datastructures.ImmutableDict
- An immutable :class:`dict`.werkzeug.datastructures.ImmutableMultiDictMixin
- Makes a :class:`MultiDict` immutable.werkzeug.datastructures.CombinedMultiDict
- A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict` instances as sequence and it will combine the return values of all wrapped dicts:werkzeug.datastructures.ImmutableMultiDict
- An immutable :class:`MultiDict`.werkzeug.datastructures.ImmutableOrderedMultiDict
- An immutable :class:`OrderedMultiDict`.werkzeug.datastructures.ImmutableTypeConversionDict
- Works like a :class:`TypeConversionDict` but does not support modifications.werkzeug.datastructures.RequestCacheControl
- A cache control for requests. This is immutable and gives access to all the request-relevant cache control headers.werkzeug.datastructures.ImmutableHeadersMixin
- Makes a :class:`Headers` immutable. We do not mark them as hashable though since the only usecase for this datastructure in Werkzeug is a view on a mutable structure.werkzeug.datastructures.EnvironHeaders
- Read only version of the headers from a WSGI environment. This provides the same interface as `Headers` and is constructed from a WSGI environment.werkzeug.datastructures.ImmutableListMixin
- Makes a :class:`list` immutable.werkzeug.datastructures.ImmutableList
- An immutable :class:`list`.werkzeug.datastructures.Accept
- An :class:`Accept` object is just a list subclass for lists of ``(value, quality)`` tuples. It is automatically sorted by specificity and quality.werkzeug.datastructures.CharsetAccept
- Like :class:`Accept` but with normalization for charsets.werkzeug.datastructures.LanguageAccept
- Like :class:`Accept` but with normalization for language tags.werkzeug.datastructures.MIMEAccept
- Like :class:`Accept` but with special methods and behavior for mimetypes.werkzeug.datastructures.Range
- Represents a ``Range`` header. All methods only support only bytes as the unit. Stores a list of ranges if given, but the methods only work if only one range is provided.werkzeug.debug._ConsoleFrame
- Helper class so that we can reuse the frame console code for the standalone console.werkzeug.debug.console._ConsoleLoader
- Undocumentedwerkzeug.debug.console.Console
- An interactive console.werkzeug.debug.console.HTMLStringO
- A StringO version that HTML escapes on write.werkzeug.debug.console.ThreadedStream
- Thread-local wrapper for sys.stdout for the interactive console.werkzeug.debug.DebuggedApplication
- Enables debugging support for a given application::werkzeug.debug.repr._Helper
- Displays an HTML version of the normal help, for the interactive debugger only because it requires a patched sys.stdout.werkzeug.debug.repr.DebugReprGenerator
- Undocumentedwerkzeug.debug.tbtools.DebugTraceback
- Undocumentedwerkzeug.exceptions.Aborter
- 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 integer it will be looked up in the mapping, if it's a WSGI application it will be raised in a proxy exception.werkzeug.formparser.FormDataParser
- This class implements parsing of form data for Werkzeug. By itself it can parse multipart and url encoded form data. It can be subclassed and extended but for most mimetypes it is a better idea to use the untouched stream and expose it as separate attributes on a request object.werkzeug.formparser.MultiPartParser
- Undocumentedwerkzeug.local._ProxyLookup
- Descriptor that handles proxied attribute lookup for :class:`LocalProxy`.werkzeug.local._ProxyIOp
- Look up an augmented assignment method on a proxied object. The method is wrapped to return the proxy instead of the object.werkzeug.local.Local
- Create a namespace of context-local data. This wraps a :class:`ContextVar` containing a :class:`dict` value.werkzeug.local.LocalManager
- Manage releasing the data for the current context in one or more :class:`Local` and :class:`LocalStack` objects.werkzeug.middleware.dispatcher.DispatcherMiddleware
- Combine multiple applications as a single WSGI application. Requests are dispatched to an application based on the path it is mounted under.werkzeug.middleware.http_proxy.ProxyMiddleware
- Proxy requests under a path to an external server, routing other requests to the app.werkzeug.middleware.lint.ErrorStream
- Undocumentedwerkzeug.middleware.lint.GuardedIterator
- Undocumentedwerkzeug.middleware.lint.GuardedWrite
- Undocumentedwerkzeug.middleware.lint.InputStream
- Undocumentedwerkzeug.middleware.lint.LintMiddleware
- Warns about common errors in the WSGI and HTTP behavior of the server and wrapped application. Some of the issues it checks are:werkzeug.middleware.profiler.ProfilerMiddleware
- Wrap a WSGI application and profile the execution of each request. Responses are buffered so that timings are more exact.werkzeug.middleware.proxy_fix.ProxyFix
- Adjust the WSGI environ based on ``X-Forwarded-`` that proxies in front of the application may set.werkzeug.middleware.shared_data.SharedDataMiddleware
- A WSGI middleware which provides static content for development environments or simple server setups. Its usage is quite simple::werkzeug.routing.converters.BaseConverter
- Base class for all converters.werkzeug.routing.converters.AnyConverter
- Matches one of the items provided. Items can either be Python identifiers or strings::werkzeug.routing.converters.NumberConverter
- Baseclass for `IntegerConverter` and `FloatConverter`.werkzeug.routing.converters.FloatConverter
- This converter only accepts floating point values::werkzeug.routing.converters.IntegerConverter
- This converter only accepts integer values::werkzeug.routing.converters.PathConverter
- Like the default :class:`UnicodeConverter`, but it also matches slashes. This is useful for wikis and similar applications::werkzeug.routing.converters.UnicodeConverter
- This converter is the default converter and accepts any string but only one path segment. Thus the string can not include a slash.werkzeug.routing.converters.UUIDConverter
- This converter only accepts UUID strings::werkzeug.routing.map.Map
- The map class stores all the URL rules and some configuration parameters. Some of the configuration values are only stored on the `Map` instance since those affect all rules, others are just defaults and can be overridden for each rule...werkzeug.routing.map.MapAdapter
- Returned by :meth:`Map.bind` or :meth:`Map.bind_to_environ` and does the URL matching and building based on runtime information.werkzeug.routing.matcher.State
- A representation of a rule state.werkzeug.routing.matcher.StateMachineMatcher
- Undocumentedwerkzeug.routing.rules.RuleFactory
- As soon as you have more complex URL setups it's a good idea to use rule factories to avoid repetitive tasks. Some of them are builtin, others can be added by subclassing `RuleFactory` and overriding `get_rules`.werkzeug.routing.rules.EndpointPrefix
- Prefixes all endpoints (which must be strings for this factory) with another string. This can be useful for sub applications::werkzeug.routing.rules.Rule
- 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. Note that besides the rule-string all arguments *must* be keyword arguments in order to not break the application on Werkzeug upgrades.werkzeug.routing.rules.RuleTemplateFactory
- A factory that fills in template variables into rules. Used by `RuleTemplate` internally.werkzeug.routing.rules.Subdomain
- All URLs provided by this factory have the subdomain set to a specific domain. For example if you want to use the subdomain for the current language this can be a good setup::werkzeug.routing.rules.Submount
- Like `Subdomain` but prefixes the URL rule with a given string::werkzeug.routing.rules.RulePart
- A part of a rule.werkzeug.routing.rules.RuleTemplate
- Returns copies of the rules wrapped and expands string templates in the endpoint, rule, defaults or subdomain sections.werkzeug.sansio.multipart.Event
- Undocumentedwerkzeug.sansio.multipart.Data
- Undocumentedwerkzeug.sansio.multipart.Epilogue
- Undocumentedwerkzeug.sansio.multipart.Field
- Undocumentedwerkzeug.sansio.multipart.File
- Undocumentedwerkzeug.sansio.multipart.NeedData
- Undocumentedwerkzeug.sansio.multipart.Preamble
- Undocumentedwerkzeug.sansio.multipart.MultipartDecoder
- Decodes a multipart message as bytes into Python events.werkzeug.sansio.multipart.MultipartEncoder
- Undocumentedwerkzeug.sansio.request.Request
- Represents the non-IO parts of a HTTP request, including the method, URL info, and headers.werkzeug.wrappers.request.Request
- Represents an incoming WSGI HTTP request, with headers and body taken from the WSGI environment. Has properties and methods for using the functionality defined by various HTTP specs. The data in requests object is read-only.werkzeug.sansio.response.Response
- Represents the non-IO parts of an HTTP response, specifically the status and headers but not the body.werkzeug.wrappers.response.Response
- Represents an outgoing WSGI HTTP response with body, status, and headers. Has properties and methods for using the functionality defined by various HTTP specs.werkzeug.test.TestResponse
- :class:`~werkzeug.wrappers.Response` subclass that provides extra information about requests made with the test :class:`Client`.werkzeug.test._TestCookieHeaders
- A headers adapter for cookielibwerkzeug.test._TestCookieResponse
- Something that looks like a httplib.HTTPResponse, but is actually just an adapter for our test responses to make them available for cookielib.werkzeug.test.Client
- This class allows you to send requests to a wrapped application.werkzeug.test.EnvironBuilder
- This class can be used to conveniently create a WSGI environment for testing purposes. It can be used to quickly create WSGI environments or request objects from arbitrary data.werkzeug.user_agent.UserAgent
- Represents a parsed user agent header value.werkzeug.wrappers.response.ResponseStream
- A file descriptor like object used by :meth:`Response.stream` to represent the body of the stream. It directly pushes into the response iterable of the response object.werkzeug.wsgi._RangeWrapper
- 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 until the underlying stream range is fully read. The yielded blocks will have a size that can't exceed the original iterator defined block size, but that can be smaller.werkzeug.wsgi.ClosingIterator
- The WSGI specification requires that all middlewares and gateways respect the `close` callback of the iterable returned by the application. Because it is useful to add another close action to a returned iterable and adding a custom iterable is a boring task this class can be used for that::...werkzeug.wsgi.FileWrapper
- This class can be used to convert a :class:`file`-like object into an iterable. It yields `buffer_size` blocks until the file is fully read.