docs: def run_simple(hostname, port, application, use_reloader=False,
                 use_debugger=False, use_evalex=True,
                 extra_files=None, reloader_interval=1, threaded=False,
                 processes=1, request_handler=None, static_files=None,
                 passthrough_errors=False, ssl_context=None):
      """Start an application using wsgiref and with an optional reloader.  This
      wraps `wsgiref` to fix the wrong default reporting of the multithreaded
      WSGI variable and adds optional multithreading and fork support.
  
      This function has a command-line interface too::
  
          python -m werkzeug.serving --help
  
      .. versionadded:: 0.5
         `static_files` was added to simplify serving of static files as well
         as `passthrough_errors`.
  
      .. versionadded:: 0.6
         support for SSL was added.
  
      .. versionadded:: 0.8
         Added support for automatically loading a SSL context from certificate
         file and private key.
  
      .. versionadded:: 0.9
         Added command-line interface.
  
      :param hostname: The host for the application.  eg: ``'localhost'``
      :param port: The port for the server.  eg: ``8080``
      :param application: the WSGI application to execute
      :param use_reloader: should the server automatically restart the python
                           process if modules were changed?
      :param use_debugger: should the werkzeug debugging system be used?
      :param use_evalex: should the exception evaluation feature be enabled?
      :param extra_files: a list of files the reloader should watch
                          additionally to the modules.  For example configuration
                          files.
      :param reloader_interval: the interval for the reloader in seconds.
      :param threaded: should the process handle each request in a separate
                       thread?
      :param processes: if greater than 1 then handle each request in a new process
                        up to this maximum number of concurrent processes.
      :param request_handler: optional parameter that can be used to replace
                              the default one.  You can use this to replace it
                              with a different
                              :class:`~BaseHTTPServer.BaseHTTPRequestHandler`
                              subclass.
      :param static_files: a dict of paths for static files.  This works exactly
                           like :class:`SharedDataMiddleware`, it's actually
                           just wrapping the application in that middleware before
                           serving.
      :param passthrough_errors: 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.)
      :param ssl_context: an SSL context for the connection. Either an OpenSSL
                          context, 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).
      """
      if use_debugger:
          from werkzeug.debug import DebuggedApplication
          application = DebuggedApplication(application, use_evalex)
      if static_files:
          from werkzeug.wsgi import SharedDataMiddleware
          application = SharedDataMiddleware(application, static_files)
  
      def inner():
          make_server(hostname, port, application, threaded,
                      processes, request_handler,
                      passthrough_errors, ssl_context).serve_forever()
  
      if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
          display_hostname = hostname != '*' and hostname or 'localhost'
          if ':' in display_hostname:
              display_hostname = '[%s]' % display_hostname
          _log('info', ' * Running on %s://%s:%d/', ssl_context is None
               and 'http' or 'https', display_hostname, port)
      if use_reloader:
          # Create and destroy a socket so that any exceptions are raised before
          # we spawn a separate Python interpreter and lose this ability.
          address_family = select_ip_version(hostname, port)
          test_socket = socket.socket(address_family, socket.SOCK_STREAM)
          test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
          test_socket.bind((hostname, port))
          test_socket.close()
          run_with_reloader(inner, extra_files, reloader_interval)
      else:
          inner()