werkzeug.serving

module documentation

A WSGI and HTTP server for use during development only. This server is convenient to use, but is not designed to be particularly stable, secure, or efficient. Use a dedicate WSGI server and HTTP server when deploying to production.

It provides features like interactive debugging and code reloading. Use run_simple to start the server. Put this in a run.py script:

from myapp import create_app
from werkzeug import run_simple

Class	`BaseWSGIServer`	Simple single-threaded, single-process WSGI server.
Class	`DechunkedInput`	An input stream that handles Transfer-Encoding 'chunked'
Class	`ForkingWSGIServer`	A WSGI server that does forking.
Class	`ThreadedWSGIServer`	A WSGI server that does threading.
Class	`WSGIRequestHandler`	A request handler that implements WSGI dispatching.
Function	`generate_adhoc_ssl_context`	Generates an adhoc SSL context for the development server.
Function	`generate_adhoc_ssl_pair`	Undocumented
Function	`get_interface_ip`	Get the IP address of an external interface. Used when binding to 0.0.0.0 or ::1 to show a more useful URL.
Function	`get_sockaddr`	Return a fully qualified socket address that can be passed to `socket.bind`.
Function	`is_running_from_reloader`	Checks if the application is running from within the Werkzeug reloader subprocess.
Function	`is_ssl_error`	Checks if the given error (or the current one) is an SSL error.
Function	`load_ssl_context`	Loads SSL context from cert/private key files and optional protocol. Many parameters are directly taken from the API of `ssl.SSLContext`.
Function	`main`	A simple command-line interface for `run_simple`.
Function	`make_server`	Create a new server instance that is either threaded, or forks or just processes one request after another.
Function	`make_ssl_devcert`	No summary
Function	`run_simple`	Start a WSGI application. Optional features include a reloader, multithreading and fork support.
Function	`run_with_reloader`	Run a process with the reloader. This is not a public API, do not use this function.
Function	`select_address_family`	Return `AF_INET4`, `AF_INET6`, or `AF_UNIX` depending on the host and port.
Constant	`LISTEN_QUEUE`	Undocumented
Variable	`af_unix`	Undocumented
Variable	`can_fork`	Undocumented
Variable	`can_open_by_fd`	Undocumented
Variable	`ssl`	Undocumented
Class	`_SslDummy`	Undocumented
Function	`_ansi_style`	Undocumented
Variable	`_log_add_style`	Undocumented
Variable	`_TSSLContextArg`	Undocumented

def generate_adhoc_ssl_context():

Generates an adhoc SSL context for the development server.

Returns
`ssl.SSLContext`	Undocumented

def generate_adhoc_ssl_pair(cn=None):

Undocumented

Parameters
cn:`t.Optional[str]`	Undocumented
Returns
`t.Tuple[Certificate, RSAPrivateKeyWithSerialization]`	Undocumented

def get_interface_ip(family):

Get the IP address of an external interface. Used when binding to 0.0.0.0 or ::1 to show a more useful URL.

Parameters
family:`socket.AddressFamily`	Undocumented
Returns
`str`	Undocumented
Unknown Field: meta
private

def get_sockaddr(host, port, family):

Return a fully qualified socket address that can be passed to socket.bind.

Parameters
host:`str`	Undocumented
port:`int`	Undocumented
family:`socket.AddressFamily`	Undocumented
Returns
`t.Union[t.Tuple[str, int], str]`	Undocumented

def is_running_from_reloader():

Checks if the application is running from within the Werkzeug reloader subprocess.

New in version 0.10.

Returns
`bool`	Undocumented

def is_ssl_error(error=None):

Checks if the given error (or the current one) is an SSL error.

Parameters
error:`t.Optional[Exception]`	Undocumented
Returns
`bool`	Undocumented

def load_ssl_context(cert_file, pkey_file=None, protocol=None):

Loads SSL context from cert/private key files and optional protocol. Many parameters are directly taken from the API of ssl.SSLContext.

Parameters
cert_file:`str`	Path of the certificate to use.
pkey_file:`t.Optional[str]`	Path of the private key to use. If not given, the key will be obtained from the certificate file.
protocol:`t.Optional[int]`	A `PROTOCOL` constant from the `ssl` module. Defaults to `ssl.PROTOCOL_TLS_SERVER`.
Returns
`ssl.SSLContext`	Undocumented

def main():

A simple command-line interface for run_simple.

def make_server(host, port, app, threaded=False, processes=1, request_handler=None, passthrough_errors=False, ssl_context=None, fd=None):

Create a new server instance that is either threaded, or forks or just processes one request after another.

Parameters
host:`str`	Undocumented
port:`int`	Undocumented
app:`WSGIApplication`	Undocumented
threaded:`bool`	Undocumented
processes:`int`	Undocumented
request_handler:`t.Optional[t.Type[WSGIRequestHandler]]`	Undocumented
passthrough_errors:`bool`	Undocumented
ssl_context:`t.Optional[_TSSLContextArg]`	Undocumented
fd:`t.Optional[int]`	Undocumented
Returns
`BaseWSGIServer`	Undocumented

def make_ssl_devcert(base_path, host=None, cn=None):

Creates an SSL key for development. This should be used instead of the 'adhoc' key which generates a new cert on each server start. It accepts a path for where it should store the key and cert and either a host or CN. If a host is given it will use the CN *.host/CN=host.

For more information see run_simple.

New in version 0.9.

Parameters
base_path:`str`	the path to the certificate and key. The extension `.crt` is added for the certificate, `.key` is added for the key.
host:`t.Optional[str]`	the name of the host. This can be used as an alternative for the `cn`.
cn:`t.Optional[str]`	the `CN` to use.
Returns
`t.Tuple[str, str]`	Undocumented

def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, exclude_patterns=None, reloader_interval=1, reloader_type='auto', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None):

Start a WSGI application. Optional features include a reloader, multithreading and fork support.

This function has a command-line interface too:

python -m werkzeug.serving --help

Changed in version 2.0: Added exclude_patterns parameter.

New in version 0.5: static_files was added to simplify serving of static files as well as passthrough_errors.

New in version 0.6: support for SSL was added.

New in version 0.8: Added support for automatically loading a SSL context from certificate file and private key.

New in version 0.9: Added command-line interface.

New in version 0.10: Improved the reloader and added support for changing the backend through the reloader_type parameter. See :ref:`reloader` for more information.

Changed in version 0.15: Bind to a Unix socket by passing a path that starts with unix:// as the hostname.

Parameters
hostname:`str`	The host to bind to, for example `'localhost'`. If the value is a path that starts with `unix://` it will bind to a Unix socket instead of a TCP socket..
port:`int`	The port for the server. eg: `8080`
application:`WSGIApplication`	the WSGI application to execute
use_reloader:`bool`	should the server automatically restart the python process if modules were changed?
use_debugger:`bool`	should the werkzeug debugging system be used?
use_evalex:`bool`	should the exception evaluation feature be enabled?
extra_files:`t.Optional[t.Iterable[str]]`	a list of files the reloader should watch additionally to the modules. For example configuration files.
exclude_patterns:`t.Optional[t.Iterable[str]]`	List of `fnmatch` patterns to ignore when running the reloader. For example, ignore cache files that shouldn't reload when updated.
reloader_interval:`int`	the interval for the reloader in seconds.
reloader_type:`str`	the type of reloader to use. The default is auto detection. Valid values are `'stat'` and `'watchdog'`. See :ref:`reloader` for more information.
threaded:`bool`	should the process handle each request in a separate thread?
processes:`int`	if greater than 1 then handle each request in a new process up to this maximum number of concurrent processes.
request_handler:`t.Optional[t.Type[WSGIRequestHandler]]`	optional parameter that can be used to replace the default one. You can use this to replace it with a different `~BaseHTTPServer.BaseHTTPRequestHandler` subclass.
static_files:`t.Optional[t.Dict[str, t.Union[str, t.Tuple[str, str]]]]`	a list or dict of paths for static files. This works exactly like `SharedDataMiddleware`, it's actually just wrapping the application in that middleware before serving.
passthrough_errors:`bool`	set this to `True` to disable the error catching. This means that the server will die on errors but it can be useful to hook debuggers in (pdb etc.)
ssl_context:`t.Optional[_TSSLContextArg]`	an SSL context for the connection. Either an `ssl.SSLContext`, a tuple in the form `(cert_file, pkey_file)`, the string `'adhoc'` if the server should automatically create one, or `None` to disable SSL (which is the default).

def run_with_reloader(*args, **kwargs):

Run a process with the reloader. This is not a public API, do not use this function.

Deprecated since version 2.0: Will be removed in Werkzeug 2.1.

Parameters
*args:`t.Any`	Undocumented
**kwargs:`t.Any`	Undocumented

def select_address_family(host, port):

Return AF_INET4, AF_INET6, or AF_UNIX depending on the host and port.

Parameters
host:`str`	Undocumented
port:`int`	Undocumented
Returns
`socket.AddressFamily`	Undocumented

LISTEN_QUEUE: int =

Undocumented

Value

af_unix =

Undocumented

can_fork =

Undocumented

can_open_by_fd =

Undocumented

ssl =

Undocumented

def _ansi_style(value, *styles):

Undocumented

Parameters
value:`str`	Undocumented
*styles:`str`	Undocumented
Returns
`str`	Undocumented

_log_add_style: bool =

Undocumented

_TSSLContextArg =

Undocumented