# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-10-01 16:00+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: library/wsgiref.rst:2
msgid ":mod:`wsgiref` --- WSGI Utilities and Reference Implementation"
msgstr ":mod:`wsgiref` — Outils et implémentation de référence de WSGI"

#: library/wsgiref.rst:12
msgid ""
"The Web Server Gateway Interface (WSGI) is a standard interface between web "
"server software and web applications written in Python. Having a standard "
"interface makes it easy to use an application that supports WSGI with a "
"number of different web servers."
msgstr ""
"WSGI (*Web Server Gateway Interface*) est une interface standard entre le "
"serveur web et une application web écrite en Python. Avoir une interface "
"standardisée permet de faciliter l'usage de ces applications avec un certain "
"nombre de serveurs web différents."

#: library/wsgiref.rst:17
msgid ""
"Only authors of web servers and programming frameworks need to know every "
"detail and corner case of the WSGI design.  You don't need to understand "
"every detail of WSGI just to install a WSGI application or to write a web "
"application using an existing framework."
msgstr ""
"Seules les personnes programmant des serveurs web et des cadriciels ont "
"besoin de connaître les détails d'implémentation et les cas particuliers de "
"l'architecture de WSGI. En tant qu'utilisateur WSGI vous avez uniquement "
"besoin d'installer WSGI ou d'utiliser un cadriciel existant."

#: library/wsgiref.rst:22
msgid ""
":mod:`wsgiref` is a reference implementation of the WSGI specification that "
"can be used to add WSGI support to a web server or framework.  It provides "
"utilities for manipulating WSGI environment variables and response headers, "
"base classes for implementing WSGI servers, a demo HTTP server that serves "
"WSGI applications, and a validation tool that checks WSGI servers and "
"applications for conformance to the WSGI specification (:pep:`3333`)."
msgstr ""
":mod:`wsgiref` est une implémentation de référence de la spécification WSGI "
"qui peut être utilisée pour ajouter la prise en charge de WSGI par un "
"serveur web ou par un cadriciel. Elle fournit des outils pour manipuler les "
"variables d'environnement WSGI, les en-têtes de réponse, les classes de base "
"pour implémenter des serveurs WSGI, un serveur de démonstration "
"d'application WSGI et un outil de validation qui vérifie que les serveurs et "
"les applications WSGI sont conformes à la spécification WSGI (:pep:`3333`)."

#: library/wsgiref.rst:29
msgid ""
"See `wsgi.readthedocs.io <https://wsgi.readthedocs.io/>`_ for more "
"information about WSGI, and links to tutorials and other resources."
msgstr ""
"Voir `wsgi.readthedocs.io <https://wsgi.readthedocs.io/>`_ pour plus "
"d'informations à propos de WSGI ainsi que des liens vers des tutoriels et "
"d'autres ressources."

#: library/wsgiref.rst:36
msgid ":mod:`wsgiref.util` -- WSGI environment utilities"
msgstr ":mod:`wsgiref.util` — outils pour les environnements WSGI"

#: library/wsgiref.rst:42
msgid ""
"This module provides a variety of utility functions for working with WSGI "
"environments.  A WSGI environment is a dictionary containing HTTP request "
"variables as described in :pep:`3333`.  All of the functions taking an "
"*environ* parameter expect a WSGI-compliant dictionary to be supplied; "
"please see :pep:`3333` for a detailed specification."
msgstr ""
"Ce module fournit un certain nombre de fonctions pour manipuler des "
"environnements WSGI. Un environnement WSGI est un dictionnaire contenant les "
"variables de la requête HTTP comme décrit dans la :pep:`3333`. Toutes les "
"fonctions ayant comme argument *environ* s'attendent à ce qu'un dictionnaire "
"compatible WSGI soit fourni ; voir la :pep:`3333` pour la spécification "
"détaillée."

#: library/wsgiref.rst:51
msgid ""
"Return a guess for whether ``wsgi.url_scheme`` should be \"http\" or \"https"
"\", by checking for a ``HTTPS`` environment variable in the *environ* "
"dictionary.  The return value is a string."
msgstr ""
"Tente de déterminer s'il faut assigner \"http\" ou \"https\" à ``wsgi."
"url_sheme``, en vérifiant si une variable d'environnement ``HTTPS`` est dans "
"le dictionnaire *environ*. La valeur renvoyée est une chaîne de caractères."

#: library/wsgiref.rst:55
msgid ""
"This function is useful when creating a gateway that wraps CGI or a CGI-like "
"protocol such as FastCGI.  Typically, servers providing such protocols will "
"include a ``HTTPS`` variable with a value of \"1\", \"yes\", or \"on\" when "
"a request is received via SSL.  So, this function returns \"https\" if such "
"a value is found, and \"http\" otherwise."
msgstr ""

#: library/wsgiref.rst:64
msgid ""
"Return the full request URI, optionally including the query string, using "
"the algorithm found in the \"URL Reconstruction\" section of :pep:`3333`.  "
"If *include_query* is false, the query string is not included in the "
"resulting URI."
msgstr ""

#: library/wsgiref.rst:71
msgid ""
"Similar to :func:`request_uri`, except that the ``PATH_INFO`` and "
"``QUERY_STRING`` variables are ignored.  The result is the base URI of the "
"application object addressed by the request."
msgstr ""

#: library/wsgiref.rst:78
msgid ""
"Shift a single name from ``PATH_INFO`` to ``SCRIPT_NAME`` and return the "
"name. The *environ* dictionary is *modified* in-place; use a copy if you "
"need to keep the original ``PATH_INFO`` or ``SCRIPT_NAME`` intact."
msgstr ""

#: library/wsgiref.rst:82
msgid ""
"If there are no remaining path segments in ``PATH_INFO``, ``None`` is "
"returned."
msgstr ""

#: library/wsgiref.rst:84
msgid ""
"Typically, this routine is used to process each portion of a request URI "
"path, for example to treat the path as a series of dictionary keys. This "
"routine modifies the passed-in environment to make it suitable for invoking "
"another WSGI application that is located at the target URI. For example, if "
"there is a WSGI application at ``/foo``, and the request URI path is ``/foo/"
"bar/baz``, and the WSGI application at ``/foo`` calls :func:"
"`shift_path_info`, it will receive the string \"bar\", and the environment "
"will be updated to be suitable for passing to a WSGI application at ``/foo/"
"bar``.  That is, ``SCRIPT_NAME`` will change from ``/foo`` to ``/foo/bar``, "
"and ``PATH_INFO`` will change from ``/bar/baz`` to ``/baz``."
msgstr ""

#: library/wsgiref.rst:95
msgid ""
"When ``PATH_INFO`` is just a \"/\", this routine returns an empty string and "
"appends a trailing slash to ``SCRIPT_NAME``, even though empty path segments "
"are normally ignored, and ``SCRIPT_NAME`` doesn't normally end in a slash.  "
"This is intentional behavior, to ensure that an application can tell the "
"difference between URIs ending in ``/x`` from ones ending in ``/x/`` when "
"using this routine to do object traversal."
msgstr ""

#: library/wsgiref.rst:105
msgid "Update *environ* with trivial defaults for testing purposes."
msgstr ""
"Met à jour *environ* avec des valeurs par défaut pour des cas de tests."

#: library/wsgiref.rst:107
msgid ""
"This routine adds various parameters required for WSGI, including "
"``HTTP_HOST``, ``SERVER_NAME``, ``SERVER_PORT``, ``REQUEST_METHOD``, "
"``SCRIPT_NAME``, ``PATH_INFO``, and all of the :pep:`3333`\\ -defined ``wsgi."
"*`` variables.  It only supplies default values, and does not replace any "
"existing settings for these variables."
msgstr ""
"Cette fonction ajoute des paramètres requis pour WSGI, en particulier "
"``HTTP_HOST``, ``SERVER_NAME``, ``SERVER_PORT``, ``REQUEST_METHOD``, "
"``SCRIPT_NAME``, ``PATH_INFO`` et toutes les autres variables WSGI définies "
"dans la :pep:`3333`. Elle ne fournit que des valeurs par défaut sans toucher "
"aux valeurs déjà définies de ces variables."

#: library/wsgiref.rst:113
msgid ""
"This routine is intended to make it easier for unit tests of WSGI servers "
"and applications to set up dummy environments.  It should NOT be used by "
"actual WSGI servers or applications, since the data is fake!"
msgstr ""
"Cette fonction a pour but de faciliter les tests unitaires des serveurs et "
"des applications WSGI dans des environnements factices. Elle ne devrait pas "
"être utilisée dans une application ou un serveur WSGI, étant donné que les "
"données sont factices !"

#: library/wsgiref.rst:164 library/wsgiref.rst:418
msgid "Example usage::"
msgstr "Exemple d'utilisation ::"

#: library/wsgiref.rst:141
msgid ""
"In addition to the environment functions above, the :mod:`wsgiref.util` "
"module also provides these miscellaneous utilities:"
msgstr ""

#: library/wsgiref.rst:147
msgid ""
"Return ``True`` if 'header_name' is an HTTP/1.1 \"Hop-by-Hop\" header, as "
"defined by :rfc:`2616`."
msgstr ""

#: library/wsgiref.rst:153
msgid ""
"A wrapper to convert a file-like object to an :term:`iterator`.  The "
"resulting objects support both :meth:`__getitem__` and :meth:`__iter__` "
"iteration styles, for compatibility with Python 2.1 and Jython. As the "
"object is iterated over, the optional *blksize* parameter will be repeatedly "
"passed to the *filelike* object's :meth:`read` method to obtain bytestrings "
"to yield.  When :meth:`read` returns an empty bytestring, iteration is ended "
"and is not resumable."
msgstr ""

#: library/wsgiref.rst:160
msgid ""
"If *filelike* has a :meth:`close` method, the returned object will also have "
"a :meth:`close` method, and it will invoke the *filelike* object's :meth:"
"`close` method when called."
msgstr ""

#: library/wsgiref.rst:176
msgid "Support for :meth:`sequence protocol <__getitem__>` is deprecated."
msgstr ""

#: library/wsgiref.rst:181
msgid ":mod:`wsgiref.headers` -- WSGI response header tools"
msgstr ""

#: library/wsgiref.rst:187
msgid ""
"This module provides a single class, :class:`Headers`, for convenient "
"manipulation of WSGI response headers using a mapping-like interface."
msgstr ""

#: library/wsgiref.rst:193
msgid ""
"Create a mapping-like object wrapping *headers*, which must be a list of "
"header name/value tuples as described in :pep:`3333`. The default value of "
"*headers* is an empty list."
msgstr ""

#: library/wsgiref.rst:197
msgid ""
":class:`Headers` objects support typical mapping operations including :meth:"
"`__getitem__`, :meth:`get`, :meth:`__setitem__`, :meth:`setdefault`, :meth:"
"`__delitem__` and :meth:`__contains__`.  For each of these methods, the key "
"is the header name (treated case-insensitively), and the value is the first "
"value associated with that header name.  Setting a header deletes any "
"existing values for that header, then adds a new value at the end of the "
"wrapped header list.  Headers' existing order is generally maintained, with "
"new headers added to the end of the wrapped list."
msgstr ""

#: library/wsgiref.rst:206
msgid ""
"Unlike a dictionary, :class:`Headers` objects do not raise an error when you "
"try to get or delete a key that isn't in the wrapped header list. Getting a "
"nonexistent header just returns ``None``, and deleting a nonexistent header "
"does nothing."
msgstr ""

#: library/wsgiref.rst:211
msgid ""
":class:`Headers` objects also support :meth:`keys`, :meth:`values`, and :"
"meth:`items` methods.  The lists returned by :meth:`keys` and :meth:`items` "
"can include the same key more than once if there is a multi-valued header.  "
"The ``len()`` of a :class:`Headers` object is the same as the length of its :"
"meth:`items`, which is the same as the length of the wrapped header list.  "
"In fact, the :meth:`items` method just returns a copy of the wrapped header "
"list."
msgstr ""

#: library/wsgiref.rst:218
msgid ""
"Calling ``bytes()`` on a :class:`Headers` object returns a formatted "
"bytestring suitable for transmission as HTTP response headers.  Each header "
"is placed on a line with its value, separated by a colon and a space. Each "
"line is terminated by a carriage return and line feed, and the bytestring is "
"terminated with a blank line."
msgstr ""

#: library/wsgiref.rst:224
msgid ""
"In addition to their mapping interface and formatting features, :class:"
"`Headers` objects also have the following methods for querying and adding "
"multi-valued headers, and for adding headers with MIME parameters:"
msgstr ""

#: library/wsgiref.rst:231
msgid "Return a list of all the values for the named header."
msgstr "Renvoie une liste de toutes les valeurs pour l'en-tête *name*."

#: library/wsgiref.rst:233
msgid ""
"The returned list will be sorted in the order they appeared in the original "
"header list or were added to this instance, and may contain duplicates.  Any "
"fields deleted and re-inserted are always appended to the header list.  If "
"no fields exist with the given name, returns an empty list."
msgstr ""

#: library/wsgiref.rst:241
msgid ""
"Add a (possibly multi-valued) header, with optional MIME parameters "
"specified via keyword arguments."
msgstr ""

#: library/wsgiref.rst:244
msgid ""
"*name* is the header field to add.  Keyword arguments can be used to set "
"MIME parameters for the header field.  Each parameter must be a string or "
"``None``. Underscores in parameter names are converted to dashes, since "
"dashes are illegal in Python identifiers, but many MIME parameter names "
"include dashes.  If the parameter value is a string, it is added to the "
"header value parameters in the form ``name=\"value\"``. If it is ``None``, "
"only the parameter name is added. (This is used for MIME parameters without "
"a value.)  Example usage::"
msgstr ""

#: library/wsgiref.rst:254
msgid "The above will add a header that looks like this::"
msgstr "Le code ci-dessus ajoute un en-tête qui ressemble à ceci ::"

#: library/wsgiref.rst:259
msgid "*headers* parameter is optional."
msgstr "Le paramètre *headers* est optionnel."

#: library/wsgiref.rst:264
msgid ":mod:`wsgiref.simple_server` -- a simple WSGI HTTP server"
msgstr ""

#: library/wsgiref.rst:270
msgid ""
"This module implements a simple HTTP server (based on :mod:`http.server`) "
"that serves WSGI applications.  Each server instance serves a single WSGI "
"application on a given host and port.  If you want to serve multiple "
"applications on a single host and port, you should create a WSGI application "
"that parses ``PATH_INFO`` to select which application to invoke for each "
"request.  (E.g., using the :func:`shift_path_info` function from :mod:"
"`wsgiref.util`.)"
msgstr ""

#: library/wsgiref.rst:281
msgid ""
"Create a new WSGI server listening on *host* and *port*, accepting "
"connections for *app*.  The return value is an instance of the supplied "
"*server_class*, and will process requests using the specified "
"*handler_class*.  *app* must be a WSGI application object, as defined by :"
"pep:`3333`."
msgstr ""

#: library/wsgiref.rst:302
msgid ""
"This function is a small but complete WSGI application that returns a text "
"page containing the message \"Hello world!\" and a list of the key/value "
"pairs provided in the *environ* parameter.  It's useful for verifying that a "
"WSGI server (such as :mod:`wsgiref.simple_server`) is able to run a simple "
"WSGI application correctly."
msgstr ""

#: library/wsgiref.rst:311
msgid ""
"Create a :class:`WSGIServer` instance.  *server_address* should be a ``(host,"
"port)`` tuple, and *RequestHandlerClass* should be the subclass of :class:"
"`http.server.BaseHTTPRequestHandler` that will be used to process requests."
msgstr ""

#: library/wsgiref.rst:316
msgid ""
"You do not normally need to call this constructor, as the :func:"
"`make_server` function can handle all the details for you."
msgstr ""

#: library/wsgiref.rst:319
msgid ""
":class:`WSGIServer` is a subclass of :class:`http.server.HTTPServer`, so all "
"of its methods (such as :meth:`serve_forever` and :meth:`handle_request`) "
"are available. :class:`WSGIServer` also provides these WSGI-specific methods:"
msgstr ""

#: library/wsgiref.rst:326
msgid ""
"Sets the callable *application* as the WSGI application that will receive "
"requests."
msgstr ""

#: library/wsgiref.rst:332
msgid "Returns the currently-set application callable."
msgstr ""

#: library/wsgiref.rst:334
msgid ""
"Normally, however, you do not need to use these additional methods, as :meth:"
"`set_app` is normally called by :func:`make_server`, and the :meth:`get_app` "
"exists mainly for the benefit of request handler instances."
msgstr ""

#: library/wsgiref.rst:341
msgid ""
"Create an HTTP handler for the given *request* (i.e. a socket), "
"*client_address* (a ``(host,port)`` tuple), and *server* (:class:"
"`WSGIServer` instance)."
msgstr ""

#: library/wsgiref.rst:344
msgid ""
"You do not need to create instances of this class directly; they are "
"automatically created as needed by :class:`WSGIServer` objects.  You can, "
"however, subclass this class and supply it as a *handler_class* to the :func:"
"`make_server` function.  Some possibly relevant methods for overriding in "
"subclasses:"
msgstr ""

#: library/wsgiref.rst:353
msgid ""
"Returns a dictionary containing the WSGI environment for a request.  The "
"default implementation copies the contents of the :class:`WSGIServer` "
"object's :attr:`base_environ` dictionary attribute and then adds various "
"headers derived from the HTTP request.  Each call to this method should "
"return a new dictionary containing all of the relevant CGI environment "
"variables as specified in :pep:`3333`."
msgstr ""

#: library/wsgiref.rst:363
msgid ""
"Return the object that should be used as the ``wsgi.errors`` stream. The "
"default implementation just returns ``sys.stderr``."
msgstr ""

#: library/wsgiref.rst:369
msgid ""
"Process the HTTP request.  The default implementation creates a handler "
"instance using a :mod:`wsgiref.handlers` class to implement the actual WSGI "
"application interface."
msgstr ""

#: library/wsgiref.rst:375
msgid ":mod:`wsgiref.validate` --- WSGI conformance checker"
msgstr ""

#: library/wsgiref.rst:381
msgid ""
"When creating new WSGI application objects, frameworks, servers, or "
"middleware, it can be useful to validate the new code's conformance using :"
"mod:`wsgiref.validate`.  This module provides a function that creates WSGI "
"application objects that validate communications between a WSGI server or "
"gateway and a WSGI application object, to check both sides for protocol "
"conformance."
msgstr ""

#: library/wsgiref.rst:388
msgid ""
"Note that this utility does not guarantee complete :pep:`3333` compliance; "
"an absence of errors from this module does not necessarily mean that errors "
"do not exist.  However, if this module does produce an error, then it is "
"virtually certain that either the server or application is not 100% "
"compliant."
msgstr ""

#: library/wsgiref.rst:393
msgid ""
"This module is based on the :mod:`paste.lint` module from Ian Bicking's "
"\"Python Paste\" library."
msgstr ""

#: library/wsgiref.rst:399
msgid ""
"Wrap *application* and return a new WSGI application object.  The returned "
"application will forward all requests to the original *application*, and "
"will check that both the *application* and the server invoking it are "
"conforming to the WSGI specification and to :rfc:`2616`."
msgstr ""

#: library/wsgiref.rst:404
msgid ""
"Any detected nonconformance results in an :exc:`AssertionError` being "
"raised; note, however, that how these errors are handled is server-"
"dependent.  For example, :mod:`wsgiref.simple_server` and other servers "
"based on :mod:`wsgiref.handlers` (that don't override the error handling "
"methods to do something else) will simply output a message that an error has "
"occurred, and dump the traceback to ``sys.stderr`` or some other error "
"stream."
msgstr ""

#: library/wsgiref.rst:411
msgid ""
"This wrapper may also generate output using the :mod:`warnings` module to "
"indicate behaviors that are questionable but which may not actually be "
"prohibited by :pep:`3333`.  Unless they are suppressed using Python command-"
"line options or the :mod:`warnings` API, any such warnings will be written "
"to ``sys.stderr`` (*not* ``wsgi.errors``, unless they happen to be the same "
"object)."
msgstr ""

#: library/wsgiref.rst:443
msgid ":mod:`wsgiref.handlers` -- server/gateway base classes"
msgstr ""

#: library/wsgiref.rst:449
msgid ""
"This module provides base handler classes for implementing WSGI servers and "
"gateways.  These base classes handle most of the work of communicating with "
"a WSGI application, as long as they are given a CGI-like environment, along "
"with input, output, and error streams."
msgstr ""

#: library/wsgiref.rst:457
msgid ""
"CGI-based invocation via ``sys.stdin``, ``sys.stdout``, ``sys.stderr`` and "
"``os.environ``.  This is useful when you have a WSGI application and want to "
"run it as a CGI script.  Simply invoke ``CGIHandler().run(app)``, where "
"``app`` is the WSGI application object you wish to invoke."
msgstr ""

#: library/wsgiref.rst:462
msgid ""
"This class is a subclass of :class:`BaseCGIHandler` that sets ``wsgi."
"run_once`` to true, ``wsgi.multithread`` to false, and ``wsgi.multiprocess`` "
"to true, and always uses :mod:`sys` and :mod:`os` to obtain the necessary "
"CGI streams and environment."
msgstr ""

#: library/wsgiref.rst:470
msgid ""
"A specialized alternative to :class:`CGIHandler`, for use when deploying on "
"Microsoft's IIS web server, without having set the config allowPathInfo "
"option (IIS>=7) or metabase allowPathInfoForScriptMappings (IIS<7)."
msgstr ""

#: library/wsgiref.rst:474
msgid ""
"By default, IIS gives a ``PATH_INFO`` that duplicates the ``SCRIPT_NAME`` at "
"the front, causing problems for WSGI applications that wish to implement "
"routing. This handler strips any such duplicated path."
msgstr ""

#: library/wsgiref.rst:478
msgid ""
"IIS can be configured to pass the correct ``PATH_INFO``, but this causes "
"another bug where ``PATH_TRANSLATED`` is wrong. Luckily this variable is "
"rarely used and is not guaranteed by WSGI. On IIS<7, though, the setting can "
"only be made on a vhost level, affecting all other script mappings, many of "
"which break when exposed to the ``PATH_TRANSLATED`` bug. For this reason "
"IIS<7 is almost never deployed with the fix (Even IIS7 rarely uses it "
"because there is still no UI for it.)."
msgstr ""

#: library/wsgiref.rst:486
msgid ""
"There is no way for CGI code to tell whether the option was set, so a "
"separate handler class is provided.  It is used in the same way as :class:"
"`CGIHandler`, i.e., by calling ``IISCGIHandler().run(app)``, where ``app`` "
"is the WSGI application object you wish to invoke."
msgstr ""

#: library/wsgiref.rst:496
msgid ""
"Similar to :class:`CGIHandler`, but instead of using the :mod:`sys` and :mod:"
"`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."
msgstr ""

#: library/wsgiref.rst:502
msgid ""
"This class is a subclass of :class:`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 :class:`SimpleHandler`."
msgstr ""

#: library/wsgiref.rst:511
msgid ""
"Similar to :class:`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 :class:`BaseCGIHandler`."
msgstr ""

#: library/wsgiref.rst:515
msgid ""
"This class is a subclass of :class:`BaseHandler`.  It overrides the :meth:"
"`__init__`, :meth:`get_stdin`, :meth:`get_stderr`, :meth:`add_cgi_vars`, :"
"meth:`_write`, and :meth:`_flush` methods to support explicitly setting the "
"environment and streams via the constructor.  The supplied environment and "
"streams are stored in the :attr:`stdin`, :attr:`stdout`, :attr:`stderr`, "
"and :attr:`environ` attributes."
msgstr ""

#: library/wsgiref.rst:522
msgid ""
"The :meth:`~io.BufferedIOBase.write` method of *stdout* should write each "
"chunk in full, like :class:`io.BufferedIOBase`."
msgstr ""

#: library/wsgiref.rst:528
msgid ""
"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."
msgstr ""

#: library/wsgiref.rst:532
msgid ""
":class:`BaseHandler` instances have only one method intended for external "
"use:"
msgstr ""

#: library/wsgiref.rst:537
msgid "Run the specified WSGI application, *app*."
msgstr ""

#: library/wsgiref.rst:539
msgid ""
"All of the other :class:`BaseHandler` methods are invoked by this method in "
"the process of running the application, and thus exist primarily to allow "
"customizing the process."
msgstr ""

#: library/wsgiref.rst:543
msgid "The following methods MUST be overridden in a subclass:"
msgstr ""

#: library/wsgiref.rst:548
msgid ""
"Buffer the bytes *data* for transmission to the client.  It's okay if this "
"method actually transmits the data; :class:`BaseHandler` just separates "
"write and flush operations for greater efficiency when the underlying system "
"actually has such a distinction."
msgstr ""

#: library/wsgiref.rst:556
msgid ""
"Force buffered data to be transmitted to the client.  It's okay if this "
"method is a no-op (i.e., if :meth:`_write` actually sends the data)."
msgstr ""

#: library/wsgiref.rst:562
msgid ""
"Return an input stream object suitable for use as the ``wsgi.input`` of the "
"request currently being processed."
msgstr ""

#: library/wsgiref.rst:568
msgid ""
"Return an output stream object suitable for use as the ``wsgi.errors`` of "
"the request currently being processed."
msgstr ""

#: library/wsgiref.rst:574
msgid ""
"Insert CGI variables for the current request into the :attr:`environ` "
"attribute."
msgstr ""

#: library/wsgiref.rst:576
msgid ""
"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 :class:"
"`BaseHandler` subclass."
msgstr ""

#: library/wsgiref.rst:582
msgid "Attributes and methods for customizing the WSGI environment:"
msgstr ""

#: library/wsgiref.rst:587
msgid ""
"The value to be used for the ``wsgi.multithread`` environment variable.  It "
"defaults to true in :class:`BaseHandler`, but may have a different default "
"(or be set by the constructor) in the other subclasses."
msgstr ""

#: library/wsgiref.rst:594
msgid ""
"The value to be used for the ``wsgi.multiprocess`` environment variable.  It "
"defaults to true in :class:`BaseHandler`, but may have a different default "
"(or be set by the constructor) in the other subclasses."
msgstr ""

#: library/wsgiref.rst:601
msgid ""
"The value to be used for the ``wsgi.run_once`` environment variable.  It "
"defaults to false in :class:`BaseHandler`, but :class:`CGIHandler` sets it "
"to true by default."
msgstr ""

#: library/wsgiref.rst:608
msgid ""
"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 :"
"mod:`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."
msgstr ""

#: library/wsgiref.rst:618
msgid ""
"If the :attr:`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 :class:`BaseCGIHandler` and :class:`CGIHandler`) that "
"are not HTTP origin servers."
msgstr ""

#: library/wsgiref.rst:624
msgid ""
"The term \"Python\" is replaced with implementation specific term like "
"\"CPython\", \"Jython\" etc."
msgstr ""

#: library/wsgiref.rst:630
msgid ""
"Return the URL scheme being used for the current request.  The default "
"implementation uses the :func:`guess_scheme` function from :mod:`wsgiref."
"util` to guess whether the scheme should be \"http\" or \"https\", based on "
"the current request's :attr:`environ` variables."
msgstr ""

#: library/wsgiref.rst:638
msgid ""
"Set the :attr:`environ` attribute to a fully-populated WSGI environment.  "
"The default implementation uses all of the above methods and attributes, "
"plus the :meth:`get_stdin`, :meth:`get_stderr`, and :meth:`add_cgi_vars` "
"methods and the :attr:`wsgi_file_wrapper` attribute.  It also inserts a "
"``SERVER_SOFTWARE`` key if not present, as long as the :attr:`origin_server` "
"attribute is a true value and the :attr:`server_software` attribute is set."
msgstr ""

#: library/wsgiref.rst:645
msgid "Methods and attributes for customizing exception handling:"
msgstr ""

#: library/wsgiref.rst:650
msgid ""
"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."
msgstr ""

#: library/wsgiref.rst:659
msgid ""
"The maximum number of frames to include in tracebacks output by the default :"
"meth:`log_exception` method.  If ``None``, all frames are included."
msgstr ""

#: library/wsgiref.rst:665
msgid ""
"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."
msgstr ""

#: library/wsgiref.rst:668
msgid ""
"This method can access the current error information using ``sys."
"exc_info()``, and should pass that information to *start_response* when "
"calling it (as described in the \"Error Handling\" section of :pep:`3333`)."
msgstr ""

#: library/wsgiref.rst:672
msgid ""
"The default implementation just uses the :attr:`error_status`, :attr:"
"`error_headers`, and :attr:`error_body` attributes to generate an output "
"page.  Subclasses can override this to produce more dynamic error output."
msgstr ""

#: library/wsgiref.rst:676
msgid ""
"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."
msgstr ""

#: library/wsgiref.rst:684
msgid ""
"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."
msgstr ""

#: library/wsgiref.rst:690
msgid ""
"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``."
msgstr ""

#: library/wsgiref.rst:697
msgid ""
"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.\""
msgstr ""

#: library/wsgiref.rst:701
msgid ""
"Methods and attributes for :pep:`3333`'s \"Optional Platform-Specific File "
"Handling\" feature:"
msgstr ""

#: library/wsgiref.rst:707
msgid ""
"A ``wsgi.file_wrapper`` factory, or ``None``.  The default value of this "
"attribute is the :class:`wsgiref.util.FileWrapper` class."
msgstr ""

#: library/wsgiref.rst:713
msgid ""
"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 :attr:`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."
msgstr ""

#: library/wsgiref.rst:720
msgid "Miscellaneous methods and attributes:"
msgstr ""

#: library/wsgiref.rst:725
msgid ""
"This attribute should be set to a true value if the handler's :meth:`_write` "
"and :meth:`_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."
msgstr ""

#: library/wsgiref.rst:730
msgid ""
"This attribute's default value is true in :class:`BaseHandler`, but false "
"in :class:`BaseCGIHandler` and :class:`CGIHandler`."
msgstr ""

#: library/wsgiref.rst:736
msgid ""
"If :attr:`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\"``."
msgstr ""

#: library/wsgiref.rst:742
msgid ""
"Transcode CGI variables from ``os.environ`` to :pep:`3333` \"bytes in unicode"
"\" strings, returning a new dictionary.  This function is used by :class:"
"`CGIHandler` and :class:`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)."
msgstr ""

#: library/wsgiref.rst:751
msgid ""
"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."
msgstr ""

#: library/wsgiref.rst:759
msgid "Examples"
msgstr "Exemples"

#: library/wsgiref.rst:761
msgid "This is a working \"Hello World\" WSGI application::"
msgstr ""

#: library/wsgiref.rst:786
msgid ""
"Example of a WSGI application serving the current directory, accept optional "
"directory and port number (default: 8000) on the command line:"
msgstr ""
