"wsgiref" --- Implementação de referência e utilitários WSGI
************************************************************

**Código-fonte:** Lib/wsgiref

======================================================================

A Interface de Gateway para Servidor Web (em inglês, Web Server
Gateway Interface - WSGI) é uma interface padrão localizada entre
software de servidores web e aplicações web escritas em Python. Ter um
interface padrão torna mais fácil a utilização de uma aplicação que
suporta WSGI com inúmeros diferentes servidores web.

Apenas autores de servidores web e frameworks de programação
necessitam saber todos os detalhes e especificidades do design WSGI.
Você não precisa entender todos os detalhes do WSGI para apenas
instalar uma aplicação WSGI ou para escrever uma aplicação web usando
um framework existente.

"wsgiref" é uma implementação de referência da especificação WSGI que
pode ser utilizada para adicionar suporte WSGI em um servidor web ou
framework. Ele provê utilidades para manipulação de variáveis de
ambiente WSGI e cabeçalhos de respostas, classes base para
implementação de servidores WSGI, uma demo de um servidor HTTP que
serve aplicações WSGI, tipos para verificação de tipos estáticos e uma
ferramenta de validação que confere se servidores WSGI e aplicações
estão de acordo com a especificação WSGI (**PEP 3333**).

Veja wsgi.readthedocs.io para mais informações sobre WSGI, além de
links para tutoriais e outros recursos.


"wsgiref.util" -- Utilidades do ambiente WSGI
=============================================

Este módulo fornece uma variedade de funções de utilidade para
trabalhar com ambientes WSGI. Um ambiente WSGI é um dicionário
contendo variáveis de solicitação HTTP, conforme descrito na **PEP
3333**. Todas as funções que recebem um parâmetro *environ* esperam
que um dicionário compatível com WSGI seja fornecido; consulte a **PEP
3333** para uma especificação detalhada e "WSGIEnvironment" para um
apelido de tipo que pode ser usado em anotações de tipos.

wsgiref.util.guess_scheme(environ)

   Retorna uma sugestão sobre "wsgi.url_scheme" ser "http" ou "https"
   buscando por uma variável de ambiente "HTTPS" dentro do dicionário
   *environ*. O valor de retorno é uma string.

   Esta função é útil ao criar um gateway que encapsula CGI ou um
   protocolo semelhante a CGI, como FastCGI. Normalmente, servidores
   que fornecem tais protocolos incluirão uma variável "HTTPS" com um
   valor de "1", "yes" ou "on" quando uma solicitação é recebida via
   SSL. Então, esta função retorna "https" se tal valor for
   encontrado, e "http" caso contrário.

wsgiref.util.request_uri(environ, include_query=True)

   Retorna o URI de solicitação completo, opcionalmente incluindo a
   string de consulta, usando o algoritmo encontrado na seção "URL
   Reconstruction" da **PEP 3333**. Se *include_query* for falso, a
   string de consulta não será incluída no URI resultante.

wsgiref.util.application_uri(environ)

   Semelhante a "request_uri()", exceto que as variáveis "PATH_INFO" e
   "QUERY_STRING" são ignoradas. O resultado é o URI base do objeto da
   aplicação endereçado pela solicitação.

wsgiref.util.shift_path_info(environ)

   Desloca um único nome de "PATH_INFO" para "SCRIPT_NAME" e retorna o
   nome. O dicionário *environ* é *modificado* no local; use uma cópia
   se precisar manter o "PATH_INFO" ou "SCRIPT_NAME" original intacto.

   Se não houver segmentos de caminho restantes em "PATH_INFO", "None"
   será retornado.

   Normalmente, essa rotina é usada para processar cada porção de um
   caminho de URI de solicitação, por exemplo, para tratar o caminho
   como uma série de chaves de dicionário. Essa rotina modifica o
   ambiente passado para torná-lo adequado para invocar outra
   aplicação WSGI localizada no URI de destino. Por exemplo, se houver
   uma aplicação WSGI em "/foo", e o caminho de URI de solicitação for
   "/foo/bar/baz", e a aplicação WSGI em "/foo" chamar
   "shift_path_info()", ele receberá a string "bar", e o ambiente será
   atualizado para ser adequado para passar para uma aplicação WSGI em
   "/foo/bar". Ou seja, "SCRIPT_NAME" mudará de "/foo" para
   "/foo/bar", e "PATH_INFO" mudará de "/bar/baz" para "/baz".

   Quando "PATH_INFO" é apenas um "/", esta rotina retorna uma string
   vazia e acrescenta uma barra final a "SCRIPT_NAME", embora
   segmentos de caminho vazios sejam normalmente ignorados, e
   "SCRIPT_NAME" normalmente não termine em uma barra. Este é um
   comportamento intencional, para garantir que uma aplicação possa
   diferenciar URIs terminando em "/x" daqueles terminando em "/x/" ao
   usar esta rotina para fazer travessia de objetos.

wsgiref.util.setup_testing_defaults(environ)

   Atualiza *environ* com padrões triviais para fins de teste.

   Esta rotina adiciona vários parâmetros necessários para WSGI,
   incluindo "HTTP_HOST", "SERVER_NAME", "SERVER_PORT",
   "REQUEST_METHOD", "SCRIPT_NAME", "PATH_INFO" e todas as variáveis
   "wsgi.*" definidas pela **PEP 3333**. Ela fornece apenas valores
   padrão e não substitui nenhuma configuração existente para essas
   variáveis.

   Esta rotina tem como objetivo facilitar que testes unitários de
   servidores e aplicações WSGI configurem ambientes fictícios. Ela
   NÃO deve ser usada por servidores ou aplicações WSGI reais, pois os
   dados são falsos!

   Exemplo de uso (veja também "demo_app()" para outro exemplo):

      from wsgiref.util import setup_testing_defaults
      from wsgiref.simple_server import make_server

      # Uma aplicação WSGI relativamente simples. Vai exibir o dicionário
      # do ambiente após ser atualizada por setup_testing_defaults
      def simple_app(environ, start_response):
          setup_testing_defaults(environ)

          status = '200 OK'
          headers = [('Content-type', 'text/plain; charset=utf-8')]

          start_response(status, headers)

          ret = [("%s: %s\n" % (key, value)).encode("utf-8")
                 for key, value in environ.items()]
          return ret

      with make_server('', 8000, simple_app) as httpd:
          print("Serving on port 8000...")
          httpd.serve_forever()

Além das funções de ambiente acima, o módulo "wsgiref.util" também
fornece estes utilitários diversos:

wsgiref.util.is_hop_by_hop(header_name)

   Retorna "True" se 'header_name' for um cabeçalho HTTP/1.1 "Hop-by-
   Hop", conforme definido por **RFC 2616**.

class wsgiref.util.FileWrapper(filelike, blksize=8192)

   Uma implementação concreta do protocolo "wsgiref.types.FileWrapper"
   usado para converter um objeto arquivo ou similar em um *iterador*.
   Os objetos resultantes são *iteráveis*. Conforme o objeto é
   iterado, o parâmetro opcional *blksize* será repetidamente passado
   para o método "read()" do objeto *filelike* para obter bytestrings
   para produzir. Quando "read()" retorna uma string de bytes vazia, a
   iteração é encerrada e não pode ser retomada.

   Se *filelike* tiver um método "close()", o objeto retornado também
   terá um método "close()" e invocará o método "close()" do objeto
   *filelike* quando chamado.

   Exemplo de uso:

      from io import StringIO
      from wsgiref.util import FileWrapper

      # Estamos usando um StringIO-buffer como objeto arquivo ou similar
      filelike = StringIO("This is an example file-like object"*10)
      wrapper = FileWrapper(filelike, blksize=5)

      for chunk in wrapper:
          print(chunk)

   Alterado na versão 3.11: O suporte para o método "__getitem__()"
   foi removido


"wsgiref.headers" -- Ferramentas de cabeçalho de resposta WSGI
==============================================================

Este módulo fornece uma única classe, "Headers", para manipulação
conveniente de cabeçalhos de resposta WSGI usando uma interface
semelhante a mapeamento.

class wsgiref.headers.Headers([headers])

   Cria um objeto mapeamento envolvendo *headers*, que deve ser uma
   lista de tuplas de nome/valor de cabeçalho, conforme descrito na
   **PEP 3333**. O valor padrão de *headers* é uma lista vazia.

   Os objetos "Headers" oferecem suporte a operações de mapeamento
   típicas, incluindo "__getitem__()", "get()", "__setitem__()",
   "setdefault()", "__delitem__()" e "__contains__()". Para cada um
   desses métodos, a chave é o nome do cabeçalho (tratado sem
   distinção entre maiúsculas e minúsculas) e o valor é o primeiro
   valor associado a esse nome de cabeçalho. Definir um cabeçalho
   exclui quaisquer valores existentes para esse cabeçalho e, em
   seguida, adiciona um novo valor ao final da lista de cabeçalhos
   encapsulados. A ordem existente dos cabeçalhos geralmente é
   mantida, com novos cabeçalhos adicionados ao final da lista
   encapsulada.

   Diferentemente de um dicionário, objetos "Headers" não levantam um
   erro quando você tenta obter ou excluir uma chave que não está na
   lista de cabeçalhos encapsulados. Obter um cabeçalho inexistente
   retorna apenas "None", e excluir um cabeçalho inexistente não faz
   nada.

   Os objetos "Headers" também oferecem suporte aos métodos "keys()",
   "values()" e "items()". As listas retornadas por "keys()" e
   "items()" podem incluir a mesma chave mais de uma vez se houver um
   cabeçalho multivalorado. O "len()" de um objeto "Headers" é o mesmo
   que o comprimento de seus "items()", que é o mesmo que o
   comprimento da lista de cabeçalhos encapsulados. Na verdade, o
   método "items()" apenas retorna uma cópia da lista de cabeçalhos
   encapsulados.

   Chamar "bytes()" em um objeto "Headers" retorna uma bytestring
   formatada adequada para transmissão como cabeçalhos de resposta
   HTTP. Cada cabeçalho é colocado em uma linha com seu valor,
   separado por dois pontos e um espaço. Cada linha é terminada por um
   retorno de carro e uma quebra de linha, e a bytestring é terminada
   com uma linha em branco.

   Além de sua interface de mapeamento e recursos de formatação, os
   objetos "Headers" também têm os seguintes métodos para consultar e
   adicionar cabeçalhos multivalorados e para adicionar cabeçalhos com
   parâmetros MIME:

   get_all(name)

      Retorna uma lista de todos os valores para o cabeçalho nomeado.

      A lista retornada será classificada na ordem em que apareceu na
      lista de cabeçalho original ou foi adicionada a esta instância,
      e pode conter duplicatas. Quaisquer campos excluídos e
      reinseridos são sempre anexados à lista de cabeçalho. Se não
      houver campos com o nome fornecido, retorna uma lista vazia.

   add_header(name, value, **_params)

      Adiciona um cabeçalho (possivelmente multivalorado), com
      parâmetros MIME opcionais especificados por meio de argumentos
      nomeados.

      *name* é o campo de cabeçalho a ser adicionado. Argumentos
      nomeados podem ser usados para definir parâmetros MIME para o
      campo de cabeçalho. Cada parâmetro deve ser uma string ou
      "None". Sublinhados em nomes de parâmetros são convertidos em
      traços, já que traços são ilegais em identificadores Python, mas
      muitos nomes de parâmetros MIME incluem traços. Se o valor do
      parâmetro for uma string, ele será adicionado aos parâmetros de
      valor do cabeçalho no formato "name="value"". Se for "None",
      somente o nome do parâmetro será adicionado. (Isso é usado para
      parâmetros MIME sem um valor.) Exemplo de uso:

         h.add_header('content-disposition', 'attachment', filename='bud.gif')

      O exemplo acima adicionará um cabeçalho parecido com este:

         Content-Disposition: attachment; filename="bud.gif"

   Alterado na versão 3.5: o parâmetro *headers* é opcional.


"wsgiref.simple_server" -- um servidor HTTP WSGI simples
========================================================

Este módulo implementa um servidor HTTP simples (com base em
"http.server") que serve aplicações WSGI. Cada instância de servidor
serve uma única aplicação WSGI em um host e porta fornecidos. Se você
quiser servir várias aplicações em um único host e porta, você deve
criar uma aplicação WSGI que analise "PATH_INFO" para selecionar qual
aplicação invocar para cada solicitação. (Por exemplo, usando a função
"shift_path_info()" de "wsgiref.util".)

wsgiref.simple_server.make_server(host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler)

   Cria um novo servidor WSGI escutando em *host* e *port*, aceitando
   conexões para *app*. O valor de retorno é uma instância da
   *server_class* fornecida e processará solicitações usando a
   *handler_class* especificada. *app* deve ser um objeto de aplicação
   WSGI, conforme definido pela **PEP 3333**.

   Exemplo de uso:

      from wsgiref.simple_server import make_server, demo_app

      with make_server('', 8000, demo_app) as httpd:
          print("Serving HTTP on port 8000...")

          # Responde a solicitações até o processo ser encerrado
          httpd.serve_forever()

          # Alternativa: serve uma solicitação e então sai
          httpd.handle_request()

wsgiref.simple_server.demo_app(environ, start_response)

   Esta função é uma aplicação WSGI pequeno, mas completo, que retorna
   uma página de texto contendo a mensagem "Hello world!" e uma lista
   dos pares chave/valor fornecidos no parâmetro *environ*. É útil
   para verificar se um servidor WSGI (como "wsgiref.simple_server") é
   capaz de executar uma aplicação WSGI simples corretamente.

   O chamável *start_response* deve seguir o protocolo
   "StartResponse".

class wsgiref.simple_server.WSGIServer(server_address, RequestHandlerClass)

   Cria uma instância "WSGIServer". *server_address* deve ser uma
   tupla "(host,port)" e *RequestHandlerClass* deve ser a subclasse de
   "http.server.BaseHTTPRequestHandler" que será usada para processar
   solicitações.

   Normalmente você não precisa chamar esse construtor, pois a função
   "make_server()" pode cuidar de todos os detalhes para você.

   "WSGIServer" é uma subclasse de "http.server.HTTPServer", então
   todos os seus métodos (como "serve_forever()" e "handle_request()")
   estão disponíveis. "WSGIServer" também fornece estes métodos
   específicos do WSGI:

   set_app(application)

      Define o chamável *application* como a aplicação WSGI que
      receberá solicitações.

   get_app()

      Retorna o chamável da aplicação definido atualmente.

   Normalmente, no entanto, você não precisa usar esses métodos
   adicionais, pois "set_app()" é normalmente chamado por
   "make_server()", e "get_app()" existe principalmente para o
   benefício de instâncias do manipulador de solicitações.

class wsgiref.simple_server.WSGIRequestHandler(request, client_address, server)

   Cria um manipulador HTTP para *request* fornecido (isto é, um
   soquete), *client_address* (uma tupla "(host,port)") e *server*
   (instância "WSGIServer").

   Você não precisa criar instâncias desta classe diretamente; elas
   são criadas automaticamente conforme necessário pelos objetos
   "WSGIServer". Você pode, no entanto, estender esta classe e
   fornecê-la como uma *handler_class* para a função "make_server()".
   Alguns métodos possivelmente relevantes para substituir em
   subclasses:

   get_environ()

      Retorna um dicionário "WSGIEnvironment" para uma solicitação. A
      implementação padrão copia o conteúdo do atributo de dicionário
      "base_environ" do objeto "WSGIServer" e então adiciona vários
      cabeçalhos derivados da solicitação HTTP. Cada chamada para esse
      método deve retornar um novo dicionário contendo todas as
      variáveis de ambiente CGI relevantes conforme especificado na
      **PEP 3333**.

   get_stderr()

      Retorna o objeto que deve ser usado como o fluxo "wsgi.errors".
      A implementação padrão retorna apenas "sys.stderr".

   handle()

      Processa a solicitação HTTP. A implementação padrão cria uma
      instância manipuladora usando uma classe "wsgiref.handlers" para
      implementar a interface da aplicação WSGI.


"wsgiref.validate" --- Verificador de conformidade WSGI
=======================================================

Ao criar novos objetos de aplicação WSGI, frameworks, servidores ou
middleware, pode ser útil validar a conformidade do novo código usando
"wsgiref.validate". Este módulo fornece uma função que cria objetos de
aplicação WSGI que validam comunicações entre um servidor ou gateway
WSGI e um objeto de aplicação WSGI, para verificar ambos os lados
quanto à conformidade do protocolo.

Note que este utilitário não garante a conformidade completa com **PEP
3333**; uma ausência de erros deste módulo não significa
necessariamente que os erros não existam. No entanto, se este módulo
produzir um erro, então é virtualmente certo que o servidor ou a
aplicação não está 100% em conformidade.

Este módulo é baseado no módulo "paste.lint" da biblioteca "Python
Paste" de Ian Bicking.

wsgiref.validate.validator(application)

   Encapsula *application* e retorna um novo objeto de aplicação WSGI.
   A aplicação retornada encaminhará todas as solicitações para a
   *application* original e verificará se tanto a *application* quanto
   o servidor que o invoca estão em conformidade com a especificação
   WSGI e com **RFC 2616**.

   Qualquer falta de conformidade detectada resulta em uma
   "AssertionError" sendo levantado; note, entretanto, que a forma
   como esses erros são manipulados depende do servidor. Por exemplo,
   "wsgiref.simple_server" e outros servidores baseados em
   "wsgiref.handlers" (que não substituem os métodos de manipulação de
   erros para fazer outra coisa) simplesmente emitirão uma mensagem de
   que ocorreu um erro e despejarão o traceback para "sys.stderr" ou
   algum outro fluxo de erro.

   Este invólucro também pode gerar saída usando o módulo "warnings"
   para indicar comportamentos que são questionáveis, mas que podem
   não ser realmente proibidos por **PEP 3333**. A menos que sejam
   suprimidos usando opções de linha de comando do Python ou a API
   "warnings", quaisquer avisos serão gravados em "sys.stderr" (*não*
   "wsgi.errors", a menos que sejam o mesmo objeto).

   Exemplo de uso:

      from wsgiref.validate import validator
      from wsgiref.simple_server import make_server

      # Nosso objeto chamável que intencionalmente não está em
      # conformidade com o padrão, então o validador irá quebrar
      def simple_app(environ, start_response):
          status = '200 OK'  # HTTP Status
          headers = [('Content-type', 'text/plain')]  # HTTP Headers
          start_response(status, headers)

          # Isso vai quebrar porque precisamos retornar uma lista,
          # e o validador vai nos informar
          return b"Hello World"

      # Este é a aplicação encapsulada em um validador
      validator_app = validator(simple_app)

      with make_server('', 8000, validator_app) as httpd:
          print("Listening on port 8000....")
          httpd.serve_forever()


"wsgiref.handlers" -- classes base de servidor/gateway
======================================================

Este módulo fornece classes de manipulador base para implementar
servidores e gateways WSGI. Essas classes base lidam com a maior parte
do trabalho de comunicação com uma aplicação WSGI, desde que recebam
um ambiente semelhante ao CGI, junto com fluxos de entrada, saída e
erro.

class wsgiref.handlers.CGIHandler

   Invocação baseada em CGI via "sys.stdin", "sys.stdout",
   "sys.stderr" e "os.environ". Isso é útil quando você tem uma
   aplicação WSGI e quer executá-lo como um script CGI. Basta invocar
   "CGIHandler().run(app)", onde "app" é o objeto da aplicação WSGI
   que você deseja invocar.

   Esta classe é uma subclasse de "BaseCGIHandler" que define
   "wsgi.run_once" como true, "wsgi.multithread" como false e
   "wsgi.multiprocess" como true, e sempre usa "sys" e "os" para obter
   os fluxos CGI e o ambiente necessários.

class wsgiref.handlers.IISCGIHandler

   Uma alternativa especializada para "CGIHandler", para uso ao
   implantar no servidor web IIS da Microsoft, sem ter definido a
   opção de configuração allowPathInfo (IIS>=7) ou metabase
   allowPathInfoForScriptMappings (IIS<7).

   Por padrão, o IIS fornece um "PATH_INFO" que duplica o
   "SCRIPT_NAME" na frente, causando problemas para aplicações WSGI
   que desejam implementar roteamento. Este manipulador remove
   qualquer caminho duplicado.

   O IIS pode ser configurado para passar o "PATH_INFO" correto, mas
   isso causa outro bug onde "PATH_TRANSLATED" está errado.
   Felizmente, essa variável raramente é usada e não é garantida pelo
   WSGI. No IIS<7, no entanto, a configuração só pode ser feita em um
   nível de vhost, afetando todos os outros mapeamentos de script,
   muitos dos quais quebram quando expostos ao bug "PATH_TRANSLATED".
   Por esse motivo, o IIS<7 quase nunca é implantado com a correção
   (mesmo o IIS7 raramente a usa porque ainda não há uma UI para ela).

   Não há como o código CGI dizer se a opção foi definida, então uma
   classe de manipulador separada é fornecida. Ela é usada da mesma
   forma que "CGIHandler", ou seja, chamando
   "IISCGIHandler().run(app)", onde "app" é o objeto de aplicação WSGI
   que você deseja invocar.

   Adicionado na versão 3.2.

class wsgiref.handlers.BaseCGIHandler(stdin, stdout, stderr, environ, multithread=True, multiprocess=False)

   Similar to "CGIHandler", but instead of using the "sys" and "os"
   modules, the CGI environment and I/O streams are specified
   explicitly. The *multithread* and *multiprocess* values are used to
   set the "wsgi.multithread" and "wsgi.multiprocess" flags for any
   applications run by the handler instance.

   This class is a subclass of "SimpleHandler" intended for use with
   software other than HTTP "origin servers".  If you are writing a
   gateway protocol implementation (such as CGI, FastCGI, SCGI, etc.)
   that uses a "Status:" header to send an HTTP status, you probably
   want to subclass this instead of "SimpleHandler".

class wsgiref.handlers.SimpleHandler(stdin, stdout, stderr, environ, multithread=True, multiprocess=False)

   Similar to "BaseCGIHandler", but designed for use with HTTP origin
   servers.  If you are writing an HTTP server implementation, you
   will probably want to subclass this instead of "BaseCGIHandler".

   This class is a subclass of "BaseHandler".  It overrides the
   "__init__()", "get_stdin()", "get_stderr()", "add_cgi_vars()",
   "_write()", and "_flush()" methods to support explicitly setting
   the environment and streams via the constructor.  The supplied
   environment and streams are stored in the "stdin", "stdout",
   "stderr", and "environ" attributes.

   The "write()" method of *stdout* should write each chunk in full,
   like "io.BufferedIOBase".

class wsgiref.handlers.BaseHandler

   This is an abstract base class for running WSGI applications.  Each
   instance will handle a single HTTP request, although in principle
   you could create a subclass that was reusable for multiple
   requests.

   "BaseHandler" instances have only one method intended for external
   use:

   run(app)

      Run the specified WSGI application, *app*.

   All of the other "BaseHandler" methods are invoked by this method
   in the process of running the application, and thus exist primarily
   to allow customizing the process.

   The following methods MUST be overridden in a subclass:

   _write(data)

      Buffer the bytes *data* for transmission to the client.  It's
      okay if this method actually transmits the data; "BaseHandler"
      just separates write and flush operations for greater efficiency
      when the underlying system actually has such a distinction.

   _flush()

      Force buffered data to be transmitted to the client.  It's okay
      if this method is a no-op (i.e., if "_write()" actually sends
      the data).

   get_stdin()

      Return an object compatible with "InputStream" suitable for use
      as the "wsgi.input" of the request currently being processed.

   get_stderr()

      Return an object compatible with "ErrorStream" suitable for use
      as the "wsgi.errors" of the request currently being processed.

   add_cgi_vars()

      Insert CGI variables for the current request into the "environ"
      attribute.

   Here are some other methods and attributes you may wish to
   override. This list is only a summary, however, and does not
   include every method that can be overridden.  You should consult
   the docstrings and source code for additional information before
   attempting to create a customized "BaseHandler" subclass.

   Attributes and methods for customizing the WSGI environment:

   wsgi_multithread

      The value to be used for the "wsgi.multithread" environment
      variable.  It defaults to true in "BaseHandler", but may have a
      different default (or be set by the constructor) in the other
      subclasses.

   wsgi_multiprocess

      The value to be used for the "wsgi.multiprocess" environment
      variable.  It defaults to true in "BaseHandler", but may have a
      different default (or be set by the constructor) in the other
      subclasses.

   wsgi_run_once

      The value to be used for the "wsgi.run_once" environment
      variable.  It defaults to false in "BaseHandler", but
      "CGIHandler" sets it to true by default.

   os_environ

      The default environment variables to be included in every
      request's WSGI environment.  By default, this is a copy of
      "os.environ" at the time that "wsgiref.handlers" was imported,
      but subclasses can either create their own at the class or
      instance level.  Note that the dictionary should be considered
      read-only, since the default value is shared between multiple
      classes and instances.

   server_software

      If the "origin_server" attribute is set, this attribute's value
      is used to set the default "SERVER_SOFTWARE" WSGI environment
      variable, and also to set a default "Server:" header in HTTP
      responses.  It is ignored for handlers (such as "BaseCGIHandler"
      and "CGIHandler") that are not HTTP origin servers.

      Alterado na versão 3.3: O termo "Python" é substituído por
      termos específicos de implementação, como "CPython", "Jython"
      etc.

   get_scheme()

      Return the URL scheme being used for the current request.  The
      default implementation uses the "guess_scheme()" function from
      "wsgiref.util" to guess whether the scheme should be "http" or
      "https", based on the current request's "environ" variables.

   setup_environ()

      Set the "environ" attribute to a fully populated WSGI
      environment.  The default implementation uses all of the above
      methods and attributes, plus the "get_stdin()", "get_stderr()",
      and "add_cgi_vars()" methods and the "wsgi_file_wrapper"
      attribute.  It also inserts a "SERVER_SOFTWARE" key if not
      present, as long as the "origin_server" attribute is a true
      value and the "server_software" attribute is set.

   Methods and attributes for customizing exception handling:

   log_exception(exc_info)

      Log the *exc_info* tuple in the server log.  *exc_info* is a
      "(type, value, traceback)" tuple.  The default implementation
      simply writes the traceback to the request's "wsgi.errors"
      stream and flushes it.  Subclasses can override this method to
      change the format or retarget the output, mail the traceback to
      an administrator, or whatever other action may be deemed
      suitable.

   traceback_limit

      The maximum number of frames to include in tracebacks output by
      the default "log_exception()" method.  If "None", all frames are
      included.

   error_output(environ, start_response)

      This method is a WSGI application to generate an error page for
      the user.  It is only invoked if an error occurs before headers
      are sent to the client.

      This method can access the current error using
      "sys.exception()", and should pass that information to
      *start_response* when calling it (as described in the "Error
      Handling" section of **PEP 3333**). In particular, the
      *start_response* callable should follow the "StartResponse"
      protocol.

      The default implementation just uses the "error_status",
      "error_headers", and "error_body" attributes to generate an
      output page.  Subclasses can override this to produce more
      dynamic error output.

      Note, however, that it's not recommended from a security
      perspective to spit out diagnostics to any old user; ideally,
      you should have to do something special to enable diagnostic
      output, which is why the default implementation doesn't include
      any.

   error_status

      The HTTP status used for error responses.  This should be a
      status string as defined in **PEP 3333**; it defaults to a 500
      code and message.

   error_headers

      The HTTP headers used for error responses.  This should be a
      list of WSGI response headers ("(name, value)" tuples), as
      described in **PEP 3333**.  The default list just sets the
      content type to "text/plain".

   error_body

      The error response body.  This should be an HTTP response body
      bytestring. It defaults to the plain text, "A server error
      occurred.  Please contact the administrator."

   Methods and attributes for **PEP 3333**'s "Optional Platform-
   Specific File Handling" feature:

   wsgi_file_wrapper

      A "wsgi.file_wrapper" factory, compatible with
      "wsgiref.types.FileWrapper", or "None".  The default value of
      this attribute is the "wsgiref.util.FileWrapper" class.

   sendfile()

      Override to implement platform-specific file transmission.  This
      method is called only if the application's return value is an
      instance of the class specified by the "wsgi_file_wrapper"
      attribute.  It should return a true value if it was able to
      successfully transmit the file, so that the default transmission
      code will not be executed. The default implementation of this
      method just returns a false value.

   Miscellaneous methods and attributes:

   origin_server

      This attribute should be set to a true value if the handler's
      "_write()" and "_flush()" are being used to communicate directly
      to the client, rather than via a CGI-like gateway protocol that
      wants the HTTP status in a special "Status:" header.

      This attribute's default value is true in "BaseHandler", but
      false in "BaseCGIHandler" and "CGIHandler".

   http_version

      If "origin_server" is true, this string attribute is used to set
      the HTTP version of the response set to the client.  It defaults
      to ""1.0"".

wsgiref.handlers.read_environ()

   Transcode CGI variables from "os.environ" to **PEP 3333** "bytes in
   unicode" strings, returning a new dictionary.  This function is
   used by "CGIHandler" and "IISCGIHandler" in place of directly using
   "os.environ", which is not necessarily WSGI-compliant on all
   platforms and web servers using Python 3 -- specifically, ones
   where the OS's actual environment is Unicode (i.e. Windows), or
   ones where the environment is bytes, but the system encoding used
   by Python to decode it is anything other than ISO-8859-1 (e.g. Unix
   systems using UTF-8).

   If you are implementing a CGI-based handler of your own, you
   probably want to use this routine instead of just copying values
   out of "os.environ" directly.

   Adicionado na versão 3.2.


"wsgiref.types" -- WSGI types for static type checking
======================================================

This module provides various types for static type checking as
described in **PEP 3333**.

Adicionado na versão 3.11.

class wsgiref.types.StartResponse

   A "typing.Protocol" describing **start_response()** callables
   (**PEP 3333**).

wsgiref.types.WSGIEnvironment

   A type alias describing a WSGI environment dictionary.

wsgiref.types.WSGIApplication

   A type alias describing a WSGI application callable.

class wsgiref.types.InputStream

   A "typing.Protocol" describing a **WSGI Input Stream**.

class wsgiref.types.ErrorStream

   A "typing.Protocol" describing a **WSGI Error Stream**.

class wsgiref.types.FileWrapper

   A "typing.Protocol" describing a **file wrapper**. See
   "wsgiref.util.FileWrapper" for a concrete implementation of this
   protocol.


Exemplos
========

This is a working "Hello World" WSGI application, where the
*start_response* callable should follow the "StartResponse" protocol:

   """
   Every WSGI application must have an application object - a callable
   object that accepts two arguments. For that purpose, we're going to
   use a function (note that you're not limited to a function, you can
   use a class for example). The first argument passed to the function
   is a dictionary containing CGI-style environment variables and the
   second variable is the callable object.
   """
   from wsgiref.simple_server import make_server


   def hello_world_app(environ, start_response):
       status = "200 OK"  # HTTP Status
       headers = [("Content-type", "text/plain; charset=utf-8")]  # HTTP Headers
       start_response(status, headers)

       # The returned object is going to be printed
       return [b"Hello World"]

   with make_server("", 8000, hello_world_app) as httpd:
       print("Serving on port 8000...")

       # Serve until process is killed
       httpd.serve_forever()

Example of a WSGI application serving the current directory, accept
optional directory and port number (default: 8000) on the command
line:

   """
   Small wsgiref based web server. Takes a path to serve from and an
   optional port number (defaults to 8000), then tries to serve files.
   MIME types are guessed from the file names, 404 errors are raised
   if the file is not found.
   """
   import mimetypes
   import os
   import sys
   from wsgiref import simple_server, util


   def app(environ, respond):
       # Get the file name and MIME type
       fn = os.path.join(path, environ["PATH_INFO"][1:])
       if "." not in fn.split(os.path.sep)[-1]:
           fn = os.path.join(fn, "index.html")
       mime_type = mimetypes.guess_file_type(fn)[0]

       # Return 200 OK if file exists, otherwise 404 Not Found
       if os.path.exists(fn):
           respond("200 OK", [("Content-Type", mime_type)])
           return util.FileWrapper(open(fn, "rb"))
       else:
           respond("404 Not Found", [("Content-Type", "text/plain")])
           return [b"not found"]


   if __name__ == "__main__":
       # Get the path and port from command-line arguments
       path = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
       port = int(sys.argv[2]) if len(sys.argv) > 2 else 8000

       # Make and start the server until control-c
       httpd = simple_server.make_server("", port, app)
       print(f"Serving {path} on port {port}, control-C to stop")
       try:
           httpd.serve_forever()
       except KeyboardInterrupt:
           print("Shutting down.")
           httpd.server_close()
