forked from AFPy/python-docs-fr
774 lines
29 KiB
Plaintext
774 lines
29 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 1990-2016, Python Software Foundation
|
|
# This file is distributed under the same license as the Python package.
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
#
|
|
#, fuzzy
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 2.7\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
#: ../Doc/library/wsgiref.rst:2
|
|
msgid ":mod:`wsgiref` --- WSGI Utilities and Reference Implementation"
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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:`333`)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:29
|
|
msgid ""
|
|
"See https://wsgi.readthedocs.org/ for more information about WSGI, and links "
|
|
"to tutorials and other resources."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:36
|
|
msgid ":mod:`wsgiref.util` -- WSGI environment utilities"
|
|
msgstr ""
|
|
|
|
#: ../Doc/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:`333`. All of the functions taking an "
|
|
"*environ* parameter expect a WSGI-compliant dictionary to be supplied; "
|
|
"please see :pep:`333` for a detailed specification."
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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:`333`. If "
|
|
"*include_query* is false, the query string is not included in the resulting "
|
|
"URI."
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:82
|
|
msgid ""
|
|
"If there are no remaining path segments in ``PATH_INFO``, ``None`` is "
|
|
"returned."
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:105
|
|
msgid "Update *environ* with trivial defaults for testing purposes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/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:`333`\\ -defined ``wsgi."
|
|
"*`` variables. It only supplies default values, and does not replace any "
|
|
"existing settings for these variables."
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:117 ../Doc/library/wsgiref.rst:164
|
|
#: ../Doc/library/wsgiref.rst:281 ../Doc/library/wsgiref.rst:413
|
|
msgid "Example usage::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:141
|
|
msgid ""
|
|
"In addition to the environment functions above, the :mod:`wsgiref.util` "
|
|
"module also provides these miscellaneous utilities:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/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 strings to "
|
|
"yield. When :meth:`read` returns an empty string, iteration is ended and is "
|
|
"not resumable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:179
|
|
msgid ":mod:`wsgiref.headers` -- WSGI response header tools"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:185
|
|
msgid ""
|
|
"This module provides a single class, :class:`Headers`, for convenient "
|
|
"manipulation of WSGI response headers using a mapping-like interface."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:191
|
|
msgid ""
|
|
"Create a mapping-like object wrapping *headers*, which must be a list of "
|
|
"header name/value tuples as described in :pep:`333`. Any changes made to "
|
|
"the new :class:`Headers` object will directly update the *headers* list it "
|
|
"was created with."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:196
|
|
msgid ""
|
|
":class:`Headers` objects support typical mapping operations including :meth:"
|
|
"`__getitem__`, :meth:`get`, :meth:`__setitem__`, :meth:`setdefault`, :meth:"
|
|
"`__delitem__`, :meth:`__contains__` and :meth:`has_key`. 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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:205
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:210
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:217
|
|
msgid ""
|
|
"Calling ``str()`` on a :class:`Headers` object returns a formatted string "
|
|
"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 string is terminated "
|
|
"with a blank line."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:223
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:230
|
|
msgid "Return a list of all the values for the named header."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:232
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:240
|
|
msgid ""
|
|
"Add a (possibly multi-valued) header, with optional MIME parameters "
|
|
"specified via keyword arguments."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:243
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:253
|
|
msgid "The above will add a header that looks like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:259
|
|
msgid ":mod:`wsgiref.simple_server` -- a simple WSGI HTTP server"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:265
|
|
msgid ""
|
|
"This module implements a simple HTTP server (based on :mod:`BaseHTTPServer`) "
|
|
"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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:276
|
|
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:`333`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:297
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:306
|
|
msgid ""
|
|
"Create a :class:`WSGIServer` instance. *server_address* should be a ``(host,"
|
|
"port)`` tuple, and *RequestHandlerClass* should be the subclass of :class:"
|
|
"`BaseHTTPServer.BaseHTTPRequestHandler` that will be used to process "
|
|
"requests."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:311
|
|
msgid ""
|
|
"You do not normally need to call this constructor, as the :func:"
|
|
"`make_server` function can handle all the details for you."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:314
|
|
msgid ""
|
|
":class:`WSGIServer` is a subclass of :class:`BaseHTTPServer.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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:321
|
|
msgid ""
|
|
"Sets the callable *application* as the WSGI application that will receive "
|
|
"requests."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:327
|
|
msgid "Returns the currently-set application callable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:329
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:336
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:339
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:348
|
|
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:`333`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:358
|
|
msgid ""
|
|
"Return the object that should be used as the ``wsgi.errors`` stream. The "
|
|
"default implementation just returns ``sys.stderr``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:364
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:370
|
|
msgid ":mod:`wsgiref.validate` --- WSGI conformance checker"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:376
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:383
|
|
msgid ""
|
|
"Note that this utility does not guarantee complete :pep:`333` 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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:388
|
|
msgid ""
|
|
"This module is based on the :mod:`paste.lint` module from Ian Bicking's "
|
|
"\"Python Paste\" library."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:394
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:399
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:406
|
|
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:`333`. 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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:438
|
|
msgid ":mod:`wsgiref.handlers` -- server/gateway base classes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:444
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:452
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:457
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:465
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:471
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:480
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:484
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:494
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:498
|
|
msgid ""
|
|
":class:`BaseHandler` instances have only one method intended for external "
|
|
"use:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:503
|
|
msgid "Run the specified WSGI application, *app*."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:505
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:509
|
|
msgid "The following methods MUST be overridden in a subclass:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:514
|
|
msgid ""
|
|
"Buffer the string *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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:522
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:528
|
|
msgid ""
|
|
"Return an input stream object suitable for use as the ``wsgi.input`` of the "
|
|
"request currently being processed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:534
|
|
msgid ""
|
|
"Return an output stream object suitable for use as the ``wsgi.errors`` of "
|
|
"the request currently being processed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:540
|
|
msgid ""
|
|
"Insert CGI variables for the current request into the :attr:`environ` "
|
|
"attribute."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:542
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:548
|
|
msgid "Attributes and methods for customizing the WSGI environment:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:553
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:560
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:567
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:574
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:584
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:593
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:601
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:608
|
|
msgid "Methods and attributes for customizing exception handling:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:613
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:622
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:628
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:631
|
|
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:`333`)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:635
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:639
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:647
|
|
msgid ""
|
|
"The HTTP status used for error responses. This should be a status string as "
|
|
"defined in :pep:`333`; it defaults to a 500 code and message."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:653
|
|
msgid ""
|
|
"The HTTP headers used for error responses. This should be a list of WSGI "
|
|
"response headers (``(name, value)`` tuples), as described in :pep:`333`. "
|
|
"The default list just sets the content type to ``text/plain``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:660
|
|
msgid ""
|
|
"The error response body. This should be an HTTP response body string. It "
|
|
"defaults to the plain text, \"A server error occurred. Please contact the "
|
|
"administrator.\""
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:664
|
|
msgid ""
|
|
"Methods and attributes for :pep:`333`'s \"Optional Platform-Specific File "
|
|
"Handling\" feature:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:670
|
|
msgid ""
|
|
"A ``wsgi.file_wrapper`` factory, or ``None``. The default value of this "
|
|
"attribute is the :class:`FileWrapper` class from :mod:`wsgiref.util`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:676
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:683
|
|
msgid "Miscellaneous methods and attributes:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:688
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:693
|
|
msgid ""
|
|
"This attribute's default value is true in :class:`BaseHandler`, but false "
|
|
"in :class:`BaseCGIHandler` and :class:`CGIHandler`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:699
|
|
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 ""
|
|
|
|
#: ../Doc/library/wsgiref.rst:704
|
|
msgid "Examples"
|
|
msgstr "Exemples"
|
|
|
|
#: ../Doc/library/wsgiref.rst:706
|
|
msgid "This is a working \"Hello World\" WSGI application::"
|
|
msgstr ""
|