wsgiref.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
# Ignasi Fosch <natx@y10k.ws>, 2020.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2022-11-26 19:11-0300\n"
"Last-Translator: Sofía Denner <sofi.denner@gmail.com>\n"
"Language-Team: Spanish - Spain <natx@y10k.ws>\n"
"Language: es_ES\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.10.3\n"
"X-Generator: Poedit 3.2\n"

#: ../Doc/library/wsgiref.rst:2
msgid ":mod:`wsgiref` --- WSGI Utilities and Reference Implementation"
msgstr ":mod:`wsgiref` --- Utilidades WSGI e implementación de referencia"

#: ../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 ""
"La Interfaz de Pasarela del Servidor Web, o *Web Server Gateway Interface* "
"en inglés (WSGI), es una interfaz estándar entre el servidor web y "
"aplicaciones web escritas en Python. Con una interfaz estándar es más "
"sencillo usar una aplicación que soporte WSGI con diferentes servidores web."

#: ../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 ""
"Sólo los autores de servidores y frameworks web necesitan conocer cada "
"detalle y caso límite del diseño WSGI. No es necesario conocer cada detalle "
"de WSGI sólo para instalar o escribir una aplicación web usando un "
"*framework* existente."

#: ../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, types for static type checking, and a validation tool "
"that checks WSGI servers and applications for conformance to the WSGI "
"specification (:pep:`3333`)."
msgstr ""
":mod:`wsgiref` es una implementación de referencia de la especificación WSGI "
"que se puede usar para añadir soporte WSGI a un servidor o *framework* web. "
"Este módulo provee utilidades para manipular las variables de entorno WSGI y "
"las cabeceras de respuesta, clases base para implementar servidores WSGI, un "
"servidor HTTP de demostración que sirve aplicaciones WSGI, tipos para "
"validadores estáticos de tipos, y una herramienta de validación que "
"comprueba la compatibilidad de servidores y aplicaciones WSGI en base a la "
"especificación :pep:`3333`."

#: ../Doc/library/wsgiref.rst:30
msgid ""
"See `wsgi.readthedocs.io <https://wsgi.readthedocs.io/>`_ for more "
"information about WSGI, and links to tutorials and other resources."
msgstr ""
"Vea `wsgi.readthedocs.io <https://wsgi.readthedocs.io/>`_ para más "
"información sobre WSGI, así como enlaces a tutoriales y otros recursos."

#: ../Doc/library/wsgiref.rst:37
msgid ":mod:`wsgiref.util` -- WSGI environment utilities"
msgstr ":mod:`wsgiref.util` -- Utilidades de entorno WSGI"

#: ../Doc/library/wsgiref.rst:43
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 and :data:`~wsgiref."
"types.WSGIEnvironment` for a type alias that can be used in type annotations."
msgstr ""
"Este módulo ofrece una variedad de funciones útiles para trabajar con "
"entornos WSGI. Un entorno WSGI es un diccionario que contiene variables de "
"la petición HTTP, descrito en :pep:`3333`. Todas las funciones que aceptan "
"un parámetro *environ* esperan un diccionario compatible con WSGI. Por "
"favor, consulte la especificación detallada en :pep:`3333`, y los alias de "
"tipos que pueden usarse en las anotaciones de tipo en :data:`~wsgiref.types."
"WSGIEnvironment`."

#: ../Doc/library/wsgiref.rst:54
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 ""
"Retorna una deducción del valor para ``wsgi.url_scheme`` que debería ser "
"\"http\" o \"https\", buscando la variable de entorno ``HTTPS`` en el "
"diccionario *environ*. El valor de retorno es una cadena."

#: ../Doc/library/wsgiref.rst:58
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 ""
"Esta función es útil al crear un *gateway* que envuelve CGI o un protocolo "
"similar como FastCGI. Habitualmente, los servidores que ofrecen estos "
"protocolos incluyen una variable ``HTTPS`` con el valor \"1\", \"yes\", o "
"\"on\" cuando reciben una petición vía SSL. Así, esta función retorna "
"\"https\" si encuentra ese valor, o \"http\", en caso contrario."

#: ../Doc/library/wsgiref.rst:67
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 ""
"Retorna la URI completa de la petición, opcionalmente la cadena de consulta, "
"usando el algoritmo encontrado en la sección \"URL Reconstruction\" de :pep:"
"`3333`. Si *include_query* es falso, la cadena de consulta no se incluye en "
"la URI resultante."

#: ../Doc/library/wsgiref.rst:74
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 ""
"Similar a :func:`request_uri` excepto que se ignoran las variables "
"``PATH_INFO`` y ``QUERY_STRING``. El resultado es la URI base del objeto de "
"aplicación indicado en la petición."

#: ../Doc/library/wsgiref.rst:81
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 ""
"Desplaza un solo nombre de ``PATH_INFO`` a ``SCRIPT_NAME`` y retorna el "
"nombre. Se modifica el diccionario *environ*, por lo que se deberá usar una "
"copia si se quiere mantener ``PATH_INFO`` o ``SCRIPT_NAME`` intactos."

#: ../Doc/library/wsgiref.rst:85
msgid ""
"If there are no remaining path segments in ``PATH_INFO``, ``None`` is "
"returned."
msgstr "Si no quedan segmentos en ``PATH_INFO``, retornará ``None``."

#: ../Doc/library/wsgiref.rst:87
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 ""
"Habitualmente, esta rutina se usa para procesar cada porción de la ruta del "
"URI de la petición, por ejemplo, para usar la ruta como una serie de claves "
"en un diccionario. Esta rutina modifica el entorno pasado para permitir "
"invocar otra aplicación WSGI que esté localizada en la URI objetivo. Por "
"ejemplo, si hay una aplicación WSGI en ``/foo``, y la ruta es ``/foo/bar/"
"baz``, y la aplicación WSGI en ``/foo`` llama a :func:`shift_path_info`, "
"recibirá la cadena \"bar\", y se actualizará el entorno para pasarlo a una "
"aplicación WSGI en ``/foo/bar``. Es decir, ``SCRIPT_NAME`` cambiará de ``/"
"foo`` a ``/foo/bar`` y ``PATH_INFO`` cambiará de ``/bar/baz`` a ``/baz``."

#: ../Doc/library/wsgiref.rst:98
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 ""
"Cuando ``PATH_INFO`` es únicamente \"/\", esta rutina retornará una cadena "
"vacía y añadirá una barra final a ``SCRIPT_NAME``, incluso cuando "
"normalmente los segmentos de ruta vacíos se ignoran y ``SCRIPT_NAME`` no "
"acaba con una barra. Este comportamiento es intencional, para asegurar que "
"una aplicación puede diferenciar entre URIs que acaban en ``/x`` de las que "
"acaban en ``/x/`` cuando usan esta rutina para atravesar objetos."

#: ../Doc/library/wsgiref.rst:108
msgid "Update *environ* with trivial defaults for testing purposes."
msgstr ""
"Actualiza *environ* con valores por defecto triviales con propósito de "
"prueba."

#: ../Doc/library/wsgiref.rst:110
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 ""
"Esta rutina añade varios parámetros requeridos por WSGI, incluyendo "
"``HTTP_POST``, ``SERVER_NAME``, ``SERVER_PORT``, ``REQUEST_METHOD``, "
"``SCRIPT_NAME``, ``PATH_INFO``, y todas las variables ``wsgi.*`` definidas "
"en :pep:`3333`. Sólo ofrece valores por defecto y no reemplaza ningún valor "
"existente en esas variables."

#: ../Doc/library/wsgiref.rst:116
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 ""
"Esta rutina pretende facilitar la preparación de entornos ficticios para "
"pruebas unitarias de servidores y aplicaciones WSGI. NO debería usarse en "
"servidores y aplicaciones WSGI reales, ya que los valores son ficticios!"

#: ../Doc/library/wsgiref.rst:120 ../Doc/library/wsgiref.rst:168
#: ../Doc/library/wsgiref.rst:290 ../Doc/library/wsgiref.rst:423
msgid "Example usage::"
msgstr "Ejemplo de uso::"

#: ../Doc/library/wsgiref.rst:144
msgid ""
"In addition to the environment functions above, the :mod:`wsgiref.util` "
"module also provides these miscellaneous utilities:"
msgstr ""
"Además de las funciones de entorno previas, el módulo :mod:`wsgiref.util` "
"también ofrece las siguientes utilidades varias:"

#: ../Doc/library/wsgiref.rst:150
msgid ""
"Return ``True`` if 'header_name' is an HTTP/1.1 \"Hop-by-Hop\" header, as "
"defined by :rfc:`2616`."
msgstr ""
"Retorna ``True`` si 'header_name' es una cabecera \"Hop-by-Hop\" HTTP/1.1, "
"como se define en :rfc:`2616`."

#: ../Doc/library/wsgiref.rst:156
msgid ""
"A concrete implementation of the :class:`wsgiref.types.FileWrapper` protocol "
"used to convert a file-like object to an :term:`iterator`. The resulting "
"objects are :term:`iterable`\\ s. 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 ""
"Una implementación concreta del protocolo :class:`wsgiref.types.FileWrapper` "
"usado para convertir objetos de tipo archivo en un :term:`iterator`. Los "
"objetos resultantes son :term:`iterable`\\ s. A medida que se itera sobre el "
"objeto, el parámetro opcional *blksize* se pasará repetidamente al método :"
"meth:`read` del objeto archivo para obtener cadenas de bytes para entregar. "
"Cuando :meth:`read` retorna una cadena de bytes vacía, la iteración "
"finalizará y no se podrá reiniciar."

#: ../Doc/library/wsgiref.rst:164
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 ""
"Si *filelike* tiene un método :meth:`close`, el objeto retornado también "
"tendrá un método :meth:`close` que llamará al método :meth:`close` del "
"objeto archivo subyacente."

#: ../Doc/library/wsgiref.rst:180
msgid "Support for :meth:`__getitem__` method has been removed."
msgstr ""
"Se ha quitado el soporte para el método :meth:`sequence protocol "
"<__getitem__>`."

#: ../Doc/library/wsgiref.rst:185
msgid ":mod:`wsgiref.headers` -- WSGI response header tools"
msgstr ""
":mod:`wsgiref.headers` -- Herramientas para cabeceras de respuesta WSGI"

#: ../Doc/library/wsgiref.rst:191
msgid ""
"This module provides a single class, :class:`Headers`, for convenient "
"manipulation of WSGI response headers using a mapping-like interface."
msgstr ""
"Este módulo ofrece una sola clase, :class:`Headers`, para la manipulación de "
"cabeceras de respuesta WSGI usando un interfaz de mapa."

#: ../Doc/library/wsgiref.rst:197
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 ""
"Crea un objeto con interfaz de mapa envolviendo *headers*, que debe ser una "
"lista de tuplas nombre/valor de las cabeceras, como se describe en :pep:"
"`3333`. El valor por defecto de *headers* es una lista vacía."

#: ../Doc/library/wsgiref.rst:201
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 ""
"Los objetos :class:`Headers` soportan las operaciones de mapa habituales "
"incluyendo :meth:`__getitem__`, :meth:`get`, :meth:`__setitem__`, :meth:"
"`setdefault`, :meth:`__delitem__` y :meth:`__contains__`. Para cada uno de "
"esos métodos, la clave es el nombre de la cabecera, sin distinción entre "
"mayúsculas y minúsculas, y el valor es el primer valor asociado con el "
"nombre de la cabecera. Establecer una cabecera borra cualquier valor "
"previamente existente y añade un nuevo valor al final de la lista de "
"cabeceras. En general, el orden de las cabeceras existentes se mantiene, con "
"las nuevas cabeceras añadidas al final de la lista de cabeceras."

#: ../Doc/library/wsgiref.rst:210
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 ""
"A diferencia de un diccionario, los objetos :class:`Headers` no lanzan un "
"error cuando se intenta obtener o eliminar una clave que no está en la lista "
"de cabeceras subyacente. Al intentar obtener una clave inexistente "
"simplemente se retornará ``None``, mientras que el intento de eliminación de "
"una cabecera inexistente simplemente no tendrá ningún efecto."

#: ../Doc/library/wsgiref.rst:215
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 ""
"Los objetos :class:`Headers` también soportan los métodos :meth:`keys`, :"
"meth:`values`, y :meth:`items`. Las listas retornadas por :meth:`keys` y :"
"meth:`items` pueden incluir la misma clave más de una vez si se trata de una "
"cabecera de valor múltiple. La ``len()`` de un objeto :class:`Headers` es la "
"misma que la longitud de sus :meth:`items`, que es la misma que la longitud "
"de la lista de cabeceras envuelta. De hecho, el método :meth:`items` "
"simplemente retorna una copia de la lista de cabeceras."

#: ../Doc/library/wsgiref.rst:222
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 ""
"La llamada ``bytes()`` sobre un objeto :class:`Headers` retorna una cadena "
"de bytes formateada y lista para su transmisión como cabeceras de respuesta "
"HTTP. Cada cabecera se ubica en una línea con su valor separado por dos "
"puntos y un espacio. Cada línea finaliza con un retorno de carro y un salto "
"de línea, y la cadena de bytes finaliza con una línea en blanco."

#: ../Doc/library/wsgiref.rst:228
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 ""
"Además de la interfaz de mapa y las funcionalidades de formateado, los "
"objetos :class:`Headers` también ofrecen los siguientes métodos para "
"consultar y añadir cabeceras con múltiples valores, y para añadir cabeceras "
"con parámetros MIME:"

#: ../Doc/library/wsgiref.rst:235
msgid "Return a list of all the values for the named header."
msgstr "Retorna una lista de todos los valores para la cabecera indicada."

#: ../Doc/library/wsgiref.rst:237
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 ""
"La lista retornada tendrá los valores ordenados según la lista de cabeceras "
"original o según se hayan añadido a esta instancia, y podrá contener "
"duplicados. Cualquier campo eliminado y añadido de nuevo estará al final de "
"la lista. Si no existen campos con el nombre indicado, retornará una lista "
"vacía."

#: ../Doc/library/wsgiref.rst:245
msgid ""
"Add a (possibly multi-valued) header, with optional MIME parameters "
"specified via keyword arguments."
msgstr ""
"Añade una cabecera, posiblemente de valor múltiple, con los parámetros MIME "
"opcionales especificados vía argumentos por palabra clave."

#: ../Doc/library/wsgiref.rst:248
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 ""
"*name* es el nombre de la cabecera a añadir. Se pueden usar argumentos por "
"palabra clave para establecer parámetros MIME para la cabecera. Cada "
"parámetro debe ser una cadena o ``None``. Todos los guiones bajos en los "
"nombres de parámetros se convierten en guiones, dado que los guiones son "
"inválidos en identificadores Python y muchos parámetros MIME incluyen "
"guiones. Si el valor del parámetro es una cadena, se añade a los parámetros "
"del valor de la cabecera con la forma ``nombre=valor``. Si es ``None``, sólo "
"se añade el nombre del parámetro, para reflejar parámetros MIME sin valor. "
"Ejemplo de uso::"

#: ../Doc/library/wsgiref.rst:258
msgid "The above will add a header that looks like this::"
msgstr "El código anterior añadirá una cabecera como la siguiente::"

#: ../Doc/library/wsgiref.rst:263
msgid "*headers* parameter is optional."
msgstr "El parámetro *headers* es opcional."

#: ../Doc/library/wsgiref.rst:268
msgid ":mod:`wsgiref.simple_server` -- a simple WSGI HTTP server"
msgstr ":mod:`wsgiref.simple_server`-- Un servidor HTTP WSGI simple"

#: ../Doc/library/wsgiref.rst:274
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 ""
"Este módulo implementa un servidor HTTP simple, basado en :mod:`http."
"server`, que sirve aplicaciones WSGI. Cada instancia del servidor sirve una "
"aplicación WSGI simple en una máquina y puerto dados. Si se quiere servir "
"múltiples aplicaciones en una misma máquina y puerto, se deberá crear una "
"aplicación WSGI que analiza ``PATH_INFO`` para seleccionar qué aplicación "
"invocar para cada petición. Por ejemplo, usando la función :func:"
"`shift_path_info` de :mod:`wsgiref.util`."

#: ../Doc/library/wsgiref.rst:285
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 ""
"Crea un nuevo servidor WSGI que sirve en *host* y *port*, aceptando "
"conexiones para *app*. El valor de retorno es una instancia de "
"*server_class* y procesará peticiones usando *handler_class*. *app* debe ser "
"un objeto aplicación WSGI, como se define en :pep:`3333`."

#: ../Doc/library/wsgiref.rst:306
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 ""
"Esta función es una pequeña pero completa aplicación WSGI que retorna una "
"página de texto con el mensaje \"Hello world!\" y una lista de pares clave/"
"valor obtenida del parámetro *environ*. Es útil para verificar que un "
"servidor WSGI, como :mod:`wsgiref.simple_server`, es capaz de ejecutar una "
"aplicación WSGI simple correctamente."

#: ../Doc/library/wsgiref.rst:315
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 ""
"Crea una instancia de :class:`WSGIServer`. *server_address* debe ser una "
"tupla ``(máquina,puerto)`` y *RequestHandlerClass* debe ser la subclase de :"
"class:`http.server.BaseHTTPRequestHandler` que se usará para procesar "
"peticiones."

#: ../Doc/library/wsgiref.rst:320
msgid ""
"You do not normally need to call this constructor, as the :func:"
"`make_server` function can handle all the details for you."
msgstr ""
"Normalmente, no es necesario invocar este constructor, ya que la función :"
"func:`make_server` puede gestionar todos los detalles."

#: ../Doc/library/wsgiref.rst:323
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 ""
":class:`WSGIServer` es una subclase de :class:`http.server.HTTPServer`, por "
"lo que todos sus métodos, como :meth:`serve_forever` y :meth:"
"`handle_request`, están disponibles. :class:`WSGIServer` también ofrece los "
"siguientes métodos específicos de WSGI:"

#: ../Doc/library/wsgiref.rst:330
msgid ""
"Sets the callable *application* as the WSGI application that will receive "
"requests."
msgstr ""
"Establece el invocable *application* como la aplicación WSGI que recibirá "
"las peticiones."

#: ../Doc/library/wsgiref.rst:336
msgid "Returns the currently set application callable."
msgstr "Retorna la aplicación invocable actualmente establecida."

#: ../Doc/library/wsgiref.rst:338
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 ""
"Habitualmente, sin embargo, no es necesario usar estos métodos adicionales, "
"ya que :meth:`set_app` se llama desde :func:`make_server` y :meth:`get_app` "
"existe sobretodo para el beneficio de instancias del gestor de peticiones."

#: ../Doc/library/wsgiref.rst:345
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 ""
"Crea un gestor HTTP para la *request* indicada (es decir un socket), "
"*client_address (una tupla ``(máquina,puerto)``), y *server* (una instancia :"
"class:`WSGIServer`)."

#: ../Doc/library/wsgiref.rst:348
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 ""
"No es necesario crear instancias de esta clase directamente. Se crean "
"automáticamente bajo demanda por objetos :class:`WSGIServer`. Sin embargo, "
"se pueden crear subclases de esta clase y proveerlas como *handler_class* a "
"la función :func:`make_server`. Algunos métodos posiblemente relevantes para "
"sobreescribir en estas subclases:"

#: ../Doc/library/wsgiref.rst:357
msgid ""
"Return a :data:`~wsgiref.types.WSGIEnvironment` dictionary 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 ""
"Retorna un diccionario :data:`~wsgiref.types.WSGIEnvironment` para una "
"petición. La implementación por defecto copia el contenido del diccionario "
"atributo :attr:`base_environ` del objeto :class:`WSGIserver` y añade varias "
"cabeceras derivadas de la petición HTTP. Cada llamada a este método debe "
"retornar un nuevo diccionario con todas las variables de entorno CGI "
"relevantes especificadas en :pep:`3333`."

#: ../Doc/library/wsgiref.rst:368
msgid ""
"Return the object that should be used as the ``wsgi.errors`` stream. The "
"default implementation just returns ``sys.stderr``."
msgstr ""
"Retorna el objeto que debe usarse como el flujo de ``wsgi.errors``. La "
"implementación por defecto retorna simplemente ``sys.stderr``."

#: ../Doc/library/wsgiref.rst:374
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 ""
"Procesa la petición HTTP. La implementación por defecto crea una instancia "
"gestora usando una clase :mod:`wsgiref.handlers` para implementar la "
"interfaz de aplicación WSGI real."

#: ../Doc/library/wsgiref.rst:380
msgid ":mod:`wsgiref.validate` --- WSGI conformance checker"
msgstr ":mod:`wsgiref.validate` --- Verificador de compatibilidad WSGI"

#: ../Doc/library/wsgiref.rst:386
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 ""
"Al crear nuevos objetos aplicación WSGI, *frameworks*, servidores, o "
"*middleware*, puede ser útil validar la compatibilidad del nuevo código "
"usando :mod:`wsgiref.validate`. Este módulo ofrece una función que crea "
"objetos de aplicación WSGI que validan las comunicaciones entre un servidor "
"o *gateway* WSGI y un objeto de aplicación WSGI, para comprobar la "
"compatibilidad del protocolo en ambos lados."

#: ../Doc/library/wsgiref.rst:393
#, python-format
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 ""
"Hay que observar que esta utilidad no garantiza compatibilidad completa con :"
"pep:`3333`. La ausencia de errores usando este módulo no implica que no "
"existan errores. Sin embargo, si este módulo produce errores, implica que o "
"el servidor o la aplicación no son 100% compatibles."

#: ../Doc/library/wsgiref.rst:398
msgid ""
"This module is based on the :mod:`paste.lint` module from Ian Bicking's "
"\"Python Paste\" library."
msgstr ""
"Este módulo se basa en el módulo :mod:`paste.lint` de la librería *Python "
"Paste* de *Ian Bicking*."

#: ../Doc/library/wsgiref.rst:404
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 ""
"Envuelve *application* y retorna un nuevo objeto de aplicación WSGI. La "
"aplicación retornada reenviará todas las peticiones a la *application* "
"original y comprobará que tanto la *application* como el servidor que la "
"llama son compatibles con la especificación WSGI y con :rfc:`2616`."

#: ../Doc/library/wsgiref.rst:409
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 ""
"Cualquier incompatibilidad detectada provocará el lanzamiento de un :exc:"
"`AssertionError`. Nótese que, sin embargo, cómo se gestionan estos errores "
"depende del servidor. Por ejemplo, :mod:`wsgiref.simple_server` y otros "
"servidores basados en :mod:`wsgiref.handlers`, que no sobreescriben los "
"métodos de gestión de errores para hacer otras cosas, simplemente escribirán "
"un mensaje de que el error ha ocurrido y volcarán la traza de error en ``sys."
"stderr`` o algún otro flujo de errores."

#: ../Doc/library/wsgiref.rst:416
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 ""
"Este *wrapper* puede también generar salidas usando el módulo :mod:"
"`warnings` para señalar comportamientos que son cuestionables pero que no "
"están realmente prohibidos por :pep:`3333`. A no ser que se suprima esta "
"salida usando opciones de línea de comandos de Python o la API de :mod:"
"`warnings`, cualquier aviso se escribirá en ``sys.stderr``, en lugar de en "
"``wsgi.errors``, aunque sean el mismo objeto."

#: ../Doc/library/wsgiref.rst:448
msgid ":mod:`wsgiref.handlers` -- server/gateway base classes"
msgstr ":mod:`wsgiref.handlers` -- Clases base servidor/*gateway*"

#: ../Doc/library/wsgiref.rst:454
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 ""
"Este módulo ofrece clases gestoras base para implementar servidores y "
"*gateways* WSGI. Estas clases base gestionan la mayoría del trabajo de "
"comunicarse con una aplicación WSGI, siempre que se les dé un entorno CGI, "
"junto con una entrada, una salida, y un flujo de errores."

#: ../Doc/library/wsgiref.rst:462
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 ""
"Invocación basada en CGI vía ``sys.stdin``, ``sys.stdout``, ``sys.stderr`` y "
"``os.environ``. Esto es útil cuando se quiere ejecutar una aplicación WSGI "
"como un script CGI. Simplemente es necesario invocar ``CGIHandler()."
"run(app)``, donde ``app`` es el objeto de aplicación WSGI que se quiere "
"invocar."

#: ../Doc/library/wsgiref.rst:467
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 ""
"Esta clase es una subclase de :class:`BaseCGIHandler` que establece ``wsgi."
"run_once`` a cierto, ``wsgi.multithread`` a falso, y ``wsgi.multiprocess`` a "
"cierto, y siempre usa :mod:`sys` y :mod:`os` para obtener los flujos y "
"entorno CGI necesarios."

#: ../Doc/library/wsgiref.rst:475
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 ""
"Una alternativa especializada a :class:`CGIHandler`, para usar al desplegar "
"en servidores web Microsoft IIS, sin establecer la opción de configuración "
"``allowPathInfo`` (IIS>=7) o la meta-base ``allowPathInfoForScriptMappings`` "
"(IIS<7)."

#: ../Doc/library/wsgiref.rst:479
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 ""
"Por defecto, IIS entrega ``PATH_INFO`` que duplica ``SCRIPT_NAME`` al "
"principio, causando problemas con aplicaciones WSGI que implementan "
"enrutamiento. Este gestor elimina las partes duplicadas de la ruta."

#: ../Doc/library/wsgiref.rst:483
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 ""
"IIS se puede configurar para pasar el ``PATH_INFO`` correcto, pero esto "
"causa otro error donde ``PATH_TRANSLATED`` es incorrecto. Afortunadamente, "
"esta variable rara vez se usa y no está garantizada por WSGI. Sin embargo, "
"en IIS<7, la configuración solo se puede realizar en un nivel de vhost, lo "
"que afecta a todas las demás asignaciones de scripts, muchas de las cuales "
"se rompen cuando se exponen al error ``PATH_TRANSLATED``. Por esta razón, "
"IIS<7 casi nunca se implementa con la solución (incluso IIS7 rara vez lo usa "
"porque todavía no tiene una interfaz de usuario)."

#: ../Doc/library/wsgiref.rst:491
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 ""
"No hay forma de que el código CGI detecte cuándo la opción está activada, "
"por lo que se ofrece una clase gestora separada. Se usa de la misma forma "
"que :class:`CGIHandler`, p.e. llamando a ``IISCGIHandler().run(app)``, donde "
"``app`` es el objeto aplicación WSGI que se desea invocar."

#: ../Doc/library/wsgiref.rst:501
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 ""
"Similar a :class:`CGIHandler`, pero en lugar de usar los módulos :mod:`sys` "
"y :mod:`os`, el entorno CGI y los flujos de E/S se especifican "
"explícitamente. Los valores *multithread* y *multiprocess* se pasan a las "
"aplicaciones ejecutadas por la instancia de gestión como ``wsgi."
"multithread`` y ``wsgi.multiprocess``."

#: ../Doc/library/wsgiref.rst:507
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 ""
"Esta clase es una subclase de :class:`SimpleHandler` para usarse con "
"servidores HTTP que no reciben peticiones directas de Internet, *HTTP origin "
"servers*. Al escribir una implementación de un protocolo de pasarela, como "
"CGI, FastCGI, SCGI, etcétera, que use una cabecera ``Status:`` para enviar "
"un estado HTTP, probablemente sea adecuado heredar de esta clase, en lugar "
"de :class:`SimpleHandler`."

#: ../Doc/library/wsgiref.rst:516
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 ""
"Similar a :class:`BaseCGIHandler` pero diseñada para usarse con servidores "
"que reciban peticiones directamente de Internet, o *HTTP origin servers*. Al "
"escribir una implementación de un servidor HTTP, probablemente prefiera "
"heredar de esta clase en lugar de :class:`BaseCGIHandler`."

#: ../Doc/library/wsgiref.rst:520
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 ""
"Esta clase es una subclase de :class:`BaseHandler`. Sobreescribe los "
"métodos :meth:`__init__`, :meth:`get_stdin`, :meth:`get_stderr`, :meth:"
"`add_cgi_vars`, :meth:`_write` y :meth:`_flush` para soportar el uso "
"explícito del entorno y los flujos a partir del constructor. El entorno y "
"los flujos especificados se almacenan en los atributos :attr:`stdin`, :attr:"
"`stdout`, :attr:`stderr` y :attr:`environ`."

#: ../Doc/library/wsgiref.rst:527
msgid ""
"The :meth:`~io.BufferedIOBase.write` method of *stdout* should write each "
"chunk in full, like :class:`io.BufferedIOBase`."
msgstr ""
"El método :meth:`~io.BufferedIOBase.write` de *stdout* podría escribir cada "
"fragmento de información completamente, como :class:`io.BufferedIOBase`."

#: ../Doc/library/wsgiref.rst:533
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 ""
"Esta es una clase base abstracta para ejecutar aplicaciones WSGI. Cada "
"instancia gestionará una sola petición HTTP, aunque en principio se podría "
"crear una subclase reutilizable para múltiples peticiones."

#: ../Doc/library/wsgiref.rst:537
msgid ""
":class:`BaseHandler` instances have only one method intended for external "
"use:"
msgstr ""
"Las instancias de :class:`BaseHandler` tiene un sólo método para uso externo:"

#: ../Doc/library/wsgiref.rst:542
msgid "Run the specified WSGI application, *app*."
msgstr "Ejecuta la aplicación WSGI *app* indicada."

#: ../Doc/library/wsgiref.rst:544
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 ""
"Todos los otros métodos de :class:`BaseHandler` se invocan por este método "
"en el proceso de ejecutar la aplicación, es decir, existen principalmente "
"para permitir personalizar el proceso."

#: ../Doc/library/wsgiref.rst:548
msgid "The following methods MUST be overridden in a subclass:"
msgstr "Los métodos siguientes DEBEN sobrescribirse en una subclase:"

#: ../Doc/library/wsgiref.rst:553
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 ""
"Enviar los bytes *data* para la transmisión al cliente. Es correcto que este "
"método realmente transmita la información. La clase :class:`BaseHandler` "
"simplemente separa las operaciones de escritura y liberación para una mayor "
"eficiencia cuando el sistema subyacente realmente hace esa distinción."

#: ../Doc/library/wsgiref.rst:561
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 ""
"Forzar la transmisión de los datos en el búfer al cliente. Es correcto si "
"este método no es operativo, p.e., si :meth:`_write` realmente envía los "
"datos."

#: ../Doc/library/wsgiref.rst:567
msgid ""
"Return an object compatible with :class:`~wsgiref.types.InputStream` "
"suitable for use as the ``wsgi.input`` of the request currently being "
"processed."
msgstr ""
"Retorna un objeto compatible con :class:`~wsgiref.types.InputStream`, "
"apropiado para usar como ``wsgi.input`` de la petición en proceso "
"actualmente."

#: ../Doc/library/wsgiref.rst:574
msgid ""
"Return an object compatible with :class:`~wsgiref.types.ErrorStream` "
"suitable for use as the ``wsgi.errors`` of the request currently being "
"processed."
msgstr ""
"Retorna un objeto compatible con :class:`~wsgiref.types.ErrorStream`, "
"apropiado para usar como ``wsgi.errors`` de la petición en proceso "
"actualmente."

#: ../Doc/library/wsgiref.rst:581
msgid ""
"Insert CGI variables for the current request into the :attr:`environ` "
"attribute."
msgstr ""
"Inserta las variables CGI para la petición actual en el atributo :attr:"
"`environ`."

#: ../Doc/library/wsgiref.rst:583
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 ""
"A continuación se describen algunos métodos y atributos más que podría ser "
"interesante sobrescribir. Esta lista es sólo un sumario, sin embargo, y no "
"incluye cada método que puede ser sobrescrito. Conviene consultar las "
"docstrings y el código fuente para obtener información adicional antes de "
"intentar crear una subclase de :class:`BaseHandler` personalizada."

#: ../Doc/library/wsgiref.rst:589
msgid "Attributes and methods for customizing the WSGI environment:"
msgstr "Atributos y métodos para personalizar el entorno WSGI:"

#: ../Doc/library/wsgiref.rst:594
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 ""
"El valor a usar en la variable de entorno ``wsgi.multithread``. Por defecto "
"es cierto en :class:`BaseHandler`, pero puede tener un valor por defecto "
"distinto (o establecerse en el constructor) en otras subclases."

#: ../Doc/library/wsgiref.rst:601
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 ""
"El valor a usar en la variable de entorno ``wsgi.multiprocess``. Por defecto "
"es cierto en :class:`BaseHandler`, pero puede tener un valor por defecto "
"distinto (o establecerse en el constructor) en otras subclases."

#: ../Doc/library/wsgiref.rst:608
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 ""
"El valor a usar en la variable de entorno ``wsgi.run_once``. Por defecto es "
"falso en :class:`BaseHandler`, pero en :class:`CGIHandler` es cierto por "
"defecto."

#: ../Doc/library/wsgiref.rst:615
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 ""
"Las variables de entorno por defecto que se incluirán en el entorno WSGI de "
"cada petición. Por defecto, es una copia de ``os.environ`` cuando se "
"importa :mod:`wsgiref.handlers`, pero otras subclases pueden crear las suyas "
"propias a nivel de clase o de instancia. Se debe tener en cuenta que el "
"diccionario se debe considerar como de sólo lectura, ya que el valor por "
"defecto se comparte entre múltiples clases e instancias."

#: ../Doc/library/wsgiref.rst:625
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 ""
"Si el atributo :attr:`origin_server` tiene valor, éste se usa para "
"establecer el valor por defecto de la variable de entorno WSGI "
"``SERVER_SOFTWARE`` y un cabecera ``Server:`` por defecto en las respuestas "
"HTTP. Las clases gestoras que no son *HTTP origin servers*, como :class:"
"`BaseCGIHandler` y :class:`CGIHandler`, ignoran este atributo."

#: ../Doc/library/wsgiref.rst:631
msgid ""
"The term \"Python\" is replaced with implementation specific term like "
"\"CPython\", \"Jython\" etc."
msgstr ""
"El término \"Python\" se reemplaza con el término específico correspondiente "
"a la implementación del intérprete, como \"CPython\", \"Jython\", etc."

#: ../Doc/library/wsgiref.rst:637
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 ""
"Retorna el esquema usado en la URL para la petición actual. La "
"implementación por defecto utiliza la función :func:`guess_scheme` de :mod:"
"`wsgiref.util` para adivinar si el esquema debería ser \"http\" o \"https\", "
"basándose en las variables de :attr:`environ` de la petición actual."

#: ../Doc/library/wsgiref.rst:645
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 ""
"Establece el atributo :attr:`environ` a un entorno WSGI completo. La "
"implementación por defecto utiliza todos los métodos y atributos "
"anteriormente mencionados, más los métodos :meth:`get_stdin`, :meth:"
"`get_stderr` y :meth:`add_cgi_vars`, y el atributo :attr:"
"`wsgi_file_wrapper`. También incluye una clave ``SERVER_SOFTWARE`` si no "
"existe, siempre y cuando el atributo :attr:`origin_server` tiene un valor "
"válido y el atributo :attr:`server_software` está establecido."

#: ../Doc/library/wsgiref.rst:652
msgid "Methods and attributes for customizing exception handling:"
msgstr "Métodos y atributos para personalizar el manejo de excepciones:"

#: ../Doc/library/wsgiref.rst:657
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 ""
"Envía la tupla *exc_info* al registro del servidor. *exc_info* es un tupla "
"``(type, value, traceback)``. La implementación por defecto simplemente "
"escribe el seguimiento de la pila en el flujo ``wsgi.errors`` de la petición "
"y lo vacía. Las subclases pueden sobrescribir éste método para cambiar el "
"formato o redirigir la salida, enviar mensajes de correo con el seguimiento "
"de pila a un administrador o cualquier otra acción que se considere adecuada."

#: ../Doc/library/wsgiref.rst:666
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 ""
"El máximo número de marcos a incluir en la salida de seguimientos de pilas "
"por el método por defecto :meth:`log_exception`. Si vale ``None``, se "
"incluyen todos los marcos."

#: ../Doc/library/wsgiref.rst:672
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 ""
"Este método es una aplicación WSGI para generar una página de error para el "
"usuario. Sólo se invoca si un error ocurre antes de enviar las cabeceras al "
"cliente."

#: ../Doc/library/wsgiref.rst:675
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 ""
"Este método puede acceder a la información de error actual usando ``sys."
"exc_info()`` y debería pasar esa información a *start_response* cuando es "
"llamada, tal y como se describe en la sección \"Error Handling\" de :pep:"
"`3333`."

#: ../Doc/library/wsgiref.rst:679
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 ""
"La implementación por defecto sólo utiliza los atributos :attr:"
"`error_status`, :attr:`error_headers` y :attr:`error_body` para generar una "
"página de salida. Las subclases pueden sobrescribir éste para producir una "
"salida de error dinámica mejor."

#: ../Doc/library/wsgiref.rst:683
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 ""
"Hay que tener en cuenta, sin embargo, que no se recomienda, desde una "
"perspectiva de seguridad, mostrar información de diagnóstico a cualquier "
"usuario antiguo. Idealmente, se debería hacer algo especial para activar la "
"salida de información de diagnóstico, motivo por el que la implementación "
"por defecto no incluye ninguna."

#: ../Doc/library/wsgiref.rst:691
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 ""
"El estado HTTP utilizado para las respuestas de error. Se debería utilizar "
"una de las cadenas de estado definidas en :pep:`3333`. Por defecto es un "
"código 500 y un mensaje."

#: ../Doc/library/wsgiref.rst:697
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 ""
"Las cabeceras HTTP utilizadas por las respuestas de error. Debería tratarse "
"de una lista de cabeceras de respuesta WSGI (tuplas ``(name, value)``), tal "
"y como se describe en :pep:`3333`. La lista por defecto simplemente "
"establece el tipo de contenido a ``text/plain``."

#: ../Doc/library/wsgiref.rst:704
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 ""
"El cuerpo de la respuesta de error. Debería ser una cadena de bytes con el "
"cuerpo de la respuesta HTTP. Por defecto contiene el texto plano *A server "
"error occurred. Please contact the administrator.*"

#: ../Doc/library/wsgiref.rst:708
msgid ""
"Methods and attributes for :pep:`3333`'s \"Optional Platform-Specific File "
"Handling\" feature:"
msgstr ""
"Métodos y atributos para la funcionalidad \"Optional Platform-Specific File "
"Handling\" de :pep:`3333`:"

#: ../Doc/library/wsgiref.rst:714
msgid ""
"A ``wsgi.file_wrapper`` factory, compatible with :class:`wsgiref.types."
"FileWrapper`, or ``None``.  The default value of this attribute is the :"
"class:`wsgiref.util.FileWrapper` class."
msgstr ""
"Una fábrica ``wsgi.file_wrapper`` compatible con :class:`wsgiref.types."
"FileWrapper`, o ``None``. El valor por defecto de este atributo es la clase :"
"class:`wsgiref.util.FileWrapper`."

#: ../Doc/library/wsgiref.rst:721
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 ""
"Sobrescribir para implementar la transmisión de ficheros específica para la "
"plataforma. Este método se llama sólo si el valor de retorno de la "
"aplicación es una instancia de la clase especificada por el atributo :attr:"
"`wsgi_file_wrapper`. Debería retornar un valor cierto si fue capaz de "
"transmitir correctamente el fichero, de modo que el código por defecto de "
"transmisión no será ejecutado. La implementación por defecto de este método "
"simplemente retorna un valor falso."

#: ../Doc/library/wsgiref.rst:728
msgid "Miscellaneous methods and attributes:"
msgstr "Métodos y atributos varios:"

#: ../Doc/library/wsgiref.rst:733
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 ""
"Este atributo debería establecerse a cierto si los métodos :meth:`_write` y :"
"meth:`_flush` están siendo usados para comunicar directamente al cliente, en "
"lugar de usar un protocolo de pasarela CGI que requiere el estado HTTP en "
"una cabecera ``Status:`` especial."

#: ../Doc/library/wsgiref.rst:738
msgid ""
"This attribute's default value is true in :class:`BaseHandler`, but false "
"in :class:`BaseCGIHandler` and :class:`CGIHandler`."
msgstr ""
"El valor por defecto de este atributo es cierto en :class:`BaseHandler`, "
"pero en :class:`BaseCGIHandler` y :class:`CGIHandler` es falso."

#: ../Doc/library/wsgiref.rst:744
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 ""
"Si :attr:`origin_server` es cierto, este atributo de tipo cadena se usa para "
"establecer la versión HTTP de la respuesta enviada al cliente. Por defecto "
"es ``\"1.0\"``."

#: ../Doc/library/wsgiref.rst:750
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 ""
"Transcodifica las variables CGI de ``os.environ`` a cadenas \"bytes in "
"unicode\" definidas en :pep:`3333`, retornando un nuevo diccionario. Esta "
"función se usa en :class:`CGIHandler` y :class:`IISCGIHandler` en lugar de "
"usar directamente ``os.environ``, lo que no es necesariamente compatible con "
"EWGI en todas las plataformas y servidores web usando Python 3 -- "
"específicamente, aquellas en las que el entorno actual del sistema operativo "
"es Unicode, p.e. Windows, o en las que el entorno está en bytes, pero la "
"codificación del sistema usada por Python para descodificar lo es cualquier "
"otro que ISO-8859-1, por ejemplo, sistemas UNIX que usen UTF-8."

#: ../Doc/library/wsgiref.rst:759
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 ""
"Cuando se está implementando un gestor basado en CGI propio, probablemente "
"se requiera usar esta rutina en lugar de sólo copiar directamente los "
"valores de ``os.environ``."

#: ../Doc/library/wsgiref.rst:767
msgid ":mod:`wsgiref.types` -- WSGI types for static type checking"
msgstr ""
":mod:`wsgiref.types` --- Tipos de WSGI para validadores estáticos de tipos"

#: ../Doc/library/wsgiref.rst:773
msgid ""
"This module provides various types for static type checking as described in :"
"pep:`3333`."
msgstr ""
"Este módulo provee varios tipos para validadores estáticos de tipos, como se "
"describe en :pep:`3333`."

#: ../Doc/library/wsgiref.rst:781
msgid ""
"A :class:`typing.Protocol` describing `start_response() <https://peps.python."
"org/pep-3333/#the-start-response-callable>`_ callables (:pep:`3333`)."
msgstr ""
"Un :class:`typing.Protocol` que describe los invocables `start_response() "
"<https://peps.python.org/pep-3333/#the-start-response-callable>`_ (:pep:"
"`3333`)."

#: ../Doc/library/wsgiref.rst:787
msgid "A type alias describing a WSGI environment dictionary."
msgstr "Un alias de tipo que describe un diccionario de entorno WSGI."

#: ../Doc/library/wsgiref.rst:791
msgid "A type alias describing a WSGI application callable."
msgstr "Un alias de tipo que describe una aplicación WSGI invocable."

#: ../Doc/library/wsgiref.rst:795
msgid ""
"A :class:`typing.Protocol` describing a `WSGI Input Stream <https://peps."
"python.org/pep-3333/#input-and-error-streams>`_."
msgstr ""
"Un :class:`typing.Protocol` que describe un `flujo de entrada WSGI <https://"
"peps.python.org/pep-3333/#input-and-error-streams>`_."

#: ../Doc/library/wsgiref.rst:800
msgid ""
"A :class:`typing.Protocol` describing a `WSGI Error Stream <https://peps."
"python.org/pep-3333/#input-and-error-streams>`_."
msgstr ""
"Un :class:`typing.Protocol` que describe un `flujo de error WSGI <https://"
"peps.python.org/pep-3333/#input-and-error-streams>`_."

#: ../Doc/library/wsgiref.rst:805
msgid ""
"A :class:`typing.Protocol` describing a `file wrapper <https://peps.python."
"org/pep-3333/#optional-platform-specific-file-handling>`_. See :class:"
"`wsgiref.util.FileWrapper` for a concrete implementation of this protocol."
msgstr ""
"Un :class:`typing.Protocol` que describe un `envoltorio de archivo <https://"
"peps.python.org/pep-3333/#optional-platform-specific-file-handling>`_. Vea :"
"class:`wsgiref.util.FileWrapper` para una implementación concreta de este "
"protocolo."

#: ../Doc/library/wsgiref.rst:812
msgid "Examples"
msgstr "Ejemplos"

#: ../Doc/library/wsgiref.rst:814
msgid "This is a working \"Hello World\" WSGI application::"
msgstr "Ésta es una aplicación WSGI \"Hello World\" que funciona:"

#: ../Doc/library/wsgiref.rst:843
msgid ""
"Example of a WSGI application serving the current directory, accept optional "
"directory and port number (default: 8000) on the command line::"
msgstr ""
"Ejemplo de una aplicación WSGI que sirve el directorio actual, acepta un "
"directorio opcional y un número de puerto (default: 8000) en la línea de "
"comandos::"