socketserver.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
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2023-02-07 17:04+0100\n"
"Last-Translator: \n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.13.0\n"

#: ../Doc/library/socketserver.rst:2
msgid ":mod:`socketserver` --- A framework for network servers"
msgstr ":mod:`socketserver` --- Un framework para servidores de red"

#: ../Doc/library/socketserver.rst:7
msgid "**Source code:** :source:`Lib/socketserver.py`"
msgstr "**Código fuente:** :source:`Lib/socketserver.py`"

#: ../Doc/library/socketserver.rst:11
msgid ""
"The :mod:`socketserver` module simplifies the task of writing network "
"servers."
msgstr ""
"El módulo :mod:`socketserver` simplifica la tarea de escribir servidores de "
"red."

#: ../Doc/includes/wasm-notavail.rst:3
#, fuzzy
msgid ":ref:`Availability <availability>`: not Emscripten, not WASI."
msgstr ":ref:`Disponibilidad <availability>`: no Emscripten, no WASI."

#: ../Doc/includes/wasm-notavail.rst:5
msgid ""
"This module does not work or is not available on WebAssembly platforms "
"``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for "
"more information."
msgstr ""
"Este módulo no funciona o no está disponible en las plataformas WebAssembly "
"``wasm32-emscripten`` y ``wasm32-wasi``. Consulte :ref:`wasm-availability` "
"para mas información."

#: ../Doc/library/socketserver.rst:15
msgid "There are four basic concrete server classes:"
msgstr "Hay cuatro clases básicas de servidores concretos:"

#: ../Doc/library/socketserver.rst:20
msgid ""
"This uses the internet TCP protocol, which provides for continuous streams "
"of data between the client and server. If *bind_and_activate* is true, the "
"constructor automatically attempts to invoke :meth:`~BaseServer.server_bind` "
"and :meth:`~BaseServer.server_activate`.  The other parameters are passed to "
"the :class:`BaseServer` base class."
msgstr ""
"Esto utiliza el protocolo TCP de Internet, que proporciona flujos continuos "
"de datos entre el cliente y el servidor. Si *bind_and_activate* es "
"verdadero, el constructor intenta invocar automáticamente :meth:`~BaseServer."
"server_bind` y :meth:`~BaseServer.server_activate`. Los otros parámetros se "
"pasan a la clase base :class:`BaseServer`."

#: ../Doc/library/socketserver.rst:30
msgid ""
"This uses datagrams, which are discrete packets of information that may "
"arrive out of order or be lost while in transit.  The parameters are the "
"same as for :class:`TCPServer`."
msgstr ""
"Esto utiliza datagramas, que son paquetes discretos de información que "
"pueden llegar fuera de servicio o perderse durante el tránsito. Los "
"parámetros son los mismos que para :class:`TCPServer`."

#: ../Doc/library/socketserver.rst:38
msgid ""
"These more infrequently used classes are similar to the TCP and UDP classes, "
"but use Unix domain sockets; they're not available on non-Unix platforms.  "
"The parameters are the same as for :class:`TCPServer`."
msgstr ""
"Estas clases que se usan con menos frecuencia son similares a las clases TCP "
"y UDP, pero usan sockets de dominio Unix; no están disponibles en "
"plataformas que no sean Unix. Los parámetros son los mismos que para :class:"
"`TCPServer`."

#: ../Doc/library/socketserver.rst:44
msgid ""
"These four classes process requests :dfn:`synchronously`; each request must "
"be completed before the next request can be started.  This isn't suitable if "
"each request takes a long time to complete, because it requires a lot of "
"computation, or because it returns a lot of data which the client is slow to "
"process.  The solution is to create a separate process or thread to handle "
"each request; the :class:`ForkingMixIn` and :class:`ThreadingMixIn` mix-in "
"classes can be used to support asynchronous behaviour."
msgstr ""
"Estas cuatro clases procesan solicitudes :dfn:`sincrónicamente`; cada "
"solicitud debe completarse antes de que se pueda iniciar la siguiente. Esto "
"no es adecuado si cada solicitud tarda mucho en completarse, porque requiere "
"mucho cálculo o porque retorna muchos datos que el cliente tarda en "
"procesar. La solución es crear un proceso o hilo independiente para manejar "
"cada solicitud; las clases mixtas :class:`ForkingMixIn` y :class:"
"`ThreadingMixIn` pueden usarse para soportar el comportamiento asincrónico."

#: ../Doc/library/socketserver.rst:52
msgid ""
"Creating a server requires several steps.  First, you must create a request "
"handler class by subclassing the :class:`BaseRequestHandler` class and "
"overriding its :meth:`~BaseRequestHandler.handle` method; this method will "
"process incoming requests.  Second, you must instantiate one of the server "
"classes, passing it the server's address and the request handler class. It "
"is recommended to use the server in a :keyword:`with` statement. Then call "
"the :meth:`~BaseServer.handle_request` or :meth:`~BaseServer.serve_forever` "
"method of the server object to process one or many requests.  Finally, call :"
"meth:`~BaseServer.server_close` to close the socket (unless you used a :"
"keyword:`!with` statement)."
msgstr ""
"La creación de un servidor requiere varios pasos. Primero, debes crear una "
"clase de controlador de solicitudes subclasificando la clase :class:"
"`BaseRequestHandler` y anulando su método :meth:`~BaseRequestHandler."
"handle`; este método procesará las solicitudes entrantes. En segundo lugar, "
"debe crear una instancia de una de las clases de servidor, pasándole la "
"dirección del servidor y la clase del controlador de solicitudes. Se "
"recomienda utilizar el servidor en una declaración :keyword:`with`. Luego "
"llame al método :meth:`~BaseServer.handle_request` o :meth:`~BaseServer."
"serve_forever` del objeto de servidor para procesar una o muchas "
"solicitudes. Finalmente, llame a :meth:`~BaseServer.server_close` para "
"cerrar el socket (a menos que haya usado una :keyword:`!with` declaración)."

#: ../Doc/library/socketserver.rst:64
msgid ""
"When inheriting from :class:`ThreadingMixIn` for threaded connection "
"behavior, you should explicitly declare how you want your threads to behave "
"on an abrupt shutdown.  The :class:`ThreadingMixIn` class defines an "
"attribute *daemon_threads*, which indicates whether or not the server should "
"wait for thread termination.  You should set the flag explicitly if you "
"would like threads to behave autonomously; the default is :const:`False`, "
"meaning that Python will not exit until all threads created by :class:"
"`ThreadingMixIn` have exited."
msgstr ""
"Al heredar de :class:`ThreadingMixIn` para el comportamiento de la conexión "
"con subprocesos, debe declarar explícitamente cómo desea que se comporten "
"sus subprocesos en un cierre abrupto. La clase :class:`ThreadingMixIn` "
"define un atributo *daemon_threads*, que indica si el servidor debe esperar "
"o no la terminación del hilo. Debe establecer la bandera explícitamente si "
"desea que los subprocesos se comporten de forma autónoma; el valor "
"predeterminado es :const:`False`, lo que significa que Python no se cerrará "
"hasta que todos los hilos creados por :class:`ThreadingMixIn` hayan salido."

#: ../Doc/library/socketserver.rst:73
msgid ""
"Server classes have the same external methods and attributes, no matter what "
"network protocol they use."
msgstr ""
"Las clases de servidor tienen los mismos métodos y atributos externos, "
"independientemente del protocolo de red que utilicen."

#: ../Doc/library/socketserver.rst:78
msgid "Server Creation Notes"
msgstr "Notas de creación del servidor"

#: ../Doc/library/socketserver.rst:80
msgid ""
"There are five classes in an inheritance diagram, four of which represent "
"synchronous servers of four types::"
msgstr ""
"Hay cinco clases en un diagrama de herencia, cuatro de las cuales "
"representan servidores síncronos de cuatro tipos:"

#: ../Doc/library/socketserver.rst:97
#, fuzzy
msgid ""
"Note that :class:`UnixDatagramServer` derives from :class:`UDPServer`, not "
"from :class:`UnixStreamServer` --- the only difference between an IP and a "
"Unix server is the address family."
msgstr ""
"Tenga en cuenta que :class:`UnixDatagramServer` deriva de :class:"
"`UDPServer`, no de :class:`UnixStreamServer` --- la única diferencia entre "
"una IP y un servidor de flujo Unix es la familia de direcciones, que "
"simplemente se repite en ambos Clases de servidor Unix."

#: ../Doc/library/socketserver.rst:105
msgid ""
"Forking and threading versions of each type of server can be created using "
"these mix-in classes.  For instance, :class:`ThreadingUDPServer` is created "
"as follows::"
msgstr ""
"Se pueden crear versiones de Forking y threading de cada tipo de servidor "
"utilizando estas clases mixtas. Por ejemplo, :class:`ThreadingUDPServer` se "
"crea de la siguiente manera:"

#: ../Doc/library/socketserver.rst:112
msgid ""
"The mix-in class comes first, since it overrides a method defined in :class:"
"`UDPServer`.  Setting the various attributes also changes the behavior of "
"the underlying server mechanism."
msgstr ""
"La clase de mezcla es lo primero, ya que anula un método definido en :class:"
"`UDPServer`. La configuración de los distintos atributos también cambia el "
"comportamiento del mecanismo del servidor subyacente."

#: ../Doc/library/socketserver.rst:116
msgid ""
":class:`ForkingMixIn` and the Forking classes mentioned below are only "
"available on POSIX platforms that support :func:`~os.fork`."
msgstr ""
":class:`ForkingMixIn` y las clases de Forking mencionadas a continuación "
"solo están disponibles en plataformas POSIX que admiten :func:`os.fork`."

#: ../Doc/library/socketserver.rst:119
msgid ""
":meth:`socketserver.ForkingMixIn.server_close` waits until all child "
"processes complete, except if :attr:`socketserver.ForkingMixIn."
"block_on_close` attribute is false."
msgstr ""
":meth:`socketserver.ForkingMixIn.server_close` espera hasta que se completen "
"todos los procesos secundarios, excepto si :attr:`socketserver.ForkingMixIn."
"block_on_close` atributo es falso."

#: ../Doc/library/socketserver.rst:123
msgid ""
":meth:`socketserver.ThreadingMixIn.server_close` waits until all non-daemon "
"threads complete, except if :attr:`socketserver.ThreadingMixIn."
"block_on_close` attribute is false. Use daemonic threads by setting :data:"
"`ThreadingMixIn.daemon_threads` to ``True`` to not wait until threads "
"complete."
msgstr ""
":meth:`socketserver.ThreadingMixIn.server_close` espera hasta que se "
"completen todos los subprocesos que no son demonios, excepto si el atributo :"
"attr:`socketserver.ThreadingMixIn.block_on_close` es falso. Use subprocesos "
"demoníacos configurando :data:`ThreadingMixIn.daemon_threads` en "
"``Verdadero`` para no esperar hasta que se completen los subprocesos."

#: ../Doc/library/socketserver.rst:132
msgid ""
":meth:`socketserver.ForkingMixIn.server_close` and :meth:`socketserver."
"ThreadingMixIn.server_close` now waits until all child processes and non-"
"daemonic threads complete. Add a new :attr:`socketserver.ForkingMixIn."
"block_on_close` class attribute to opt-in for the pre-3.7 behaviour."
msgstr ""
":meth:`socketserver.ForkingMixIn.server_close` y :meth:`socketserver."
"ThreadingMixIn.server_close` ahora espera hasta que se completen todos los "
"procesos secundarios y los subprocesos no demoníacos. Agregue un nuevo "
"atributo de clase :attr:`socketserver.ForkingMixIn.block_on_close` para "
"optar por el comportamiento anterior a 3.7."

#: ../Doc/library/socketserver.rst:148
msgid "These classes are pre-defined using the mix-in classes."
msgstr "Estas clases están predefinidas utilizando las clases mixtas."

#: ../Doc/library/socketserver.rst:150
msgid ""
"The ``ForkingUnixStreamServer`` and ``ForkingUnixDatagramServer`` classes "
"were added."
msgstr ""

#: ../Doc/library/socketserver.rst:154
msgid ""
"To implement a service, you must derive a class from :class:"
"`BaseRequestHandler` and redefine its :meth:`~BaseRequestHandler.handle` "
"method. You can then run various versions of the service by combining one of "
"the server classes with your request handler class.  The request handler "
"class must be different for datagram or stream services.  This can be hidden "
"by using the handler subclasses :class:`StreamRequestHandler` or :class:"
"`DatagramRequestHandler`."
msgstr ""
"Para implementar un servicio, debes derivar una clase de :class:"
"`BaseRequestHandler` y redefinir su método :meth:`~BaseRequestHandler."
"handle`. Luego, puede ejecutar varias versiones del servicio combinando una "
"de las clases de servidor con su clase de controlador de solicitudes. La "
"clase del controlador de solicitudes debe ser diferente para los servicios "
"de datagramas o flujos. Esto se puede ocultar usando las subclases del "
"controlador :class:`StreamRequestHandler` o :class:`DatagramRequestHandler`."

#: ../Doc/library/socketserver.rst:162
msgid ""
"Of course, you still have to use your head!  For instance, it makes no sense "
"to use a forking server if the service contains state in memory that can be "
"modified by different requests, since the modifications in the child process "
"would never reach the initial state kept in the parent process and passed to "
"each child.  In this case, you can use a threading server, but you will "
"probably have to use locks to protect the integrity of the shared data."
msgstr ""
"Por supuesto, ¡todavía tienes que usar la cabeza! Por ejemplo, no tiene "
"sentido usar un servidor de bifurcación si el servicio contiene un estado en "
"la memoria que puede ser modificado por diferentes solicitudes, ya que las "
"modificaciones en el proceso hijo nunca alcanzarían el estado inicial que se "
"mantiene en el proceso padre y se pasa a cada hijo. En este caso, puede usar "
"un servidor de subprocesos, pero probablemente tendrá que usar bloqueos para "
"proteger la integridad de los datos compartidos."

#: ../Doc/library/socketserver.rst:169
msgid ""
"On the other hand, if you are building an HTTP server where all data is "
"stored externally (for instance, in the file system), a synchronous class "
"will essentially render the service \"deaf\" while one request is being "
"handled -- which may be for a very long time if a client is slow to receive "
"all the data it has requested.  Here a threading or forking server is "
"appropriate."
msgstr ""
"Por otro lado, si está creando un servidor HTTP donde todos los datos se "
"almacenan externamente (por ejemplo, en el sistema de archivos), una clase "
"síncrona esencialmente hará que el servicio sea \"sordo\" mientras se maneja "
"una solicitud, que puede ser durante mucho tiempo si un cliente tarda en "
"recibir todos los datos que ha solicitado. Aquí es apropiado un servidor de "
"enhebrado o bifurcación."

#: ../Doc/library/socketserver.rst:175
msgid ""
"In some cases, it may be appropriate to process part of a request "
"synchronously, but to finish processing in a forked child depending on the "
"request data.  This can be implemented by using a synchronous server and "
"doing an explicit fork in the request handler class :meth:"
"`~BaseRequestHandler.handle` method."
msgstr ""
"En algunos casos, puede ser apropiado procesar parte de una solicitud de "
"forma síncrona, pero para finalizar el procesamiento en un hijo bifurcado "
"según los datos de la solicitud. Esto se puede implementar usando un "
"servidor sincrónico y haciendo un fork explicito en la clase del controlador "
"de solicitudes el método :meth:`~BaseRequestHandler.handle`."

#: ../Doc/library/socketserver.rst:180
#, fuzzy
msgid ""
"Another approach to handling multiple simultaneous requests in an "
"environment that supports neither threads nor :func:`~os.fork` (or where "
"these are too expensive or inappropriate for the service) is to maintain an "
"explicit table of partially finished requests and to use :mod:`selectors` to "
"decide which request to work on next (or whether to handle a new incoming "
"request).  This is particularly important for stream services where each "
"client can potentially be connected for a long time (if threads or "
"subprocesses cannot be used)."
msgstr ""
"Otro enfoque para manejar múltiples solicitudes simultáneas en un entorno "
"que no admite subprocesos ni :func:`~os.fork` (o donde estos son demasiado "
"costosos o inapropiados para el servicio) es mantener una tabla explícita de "
"solicitudes parcialmente terminadas y utilizar :mod:`selectors` para decidir "
"en qué solicitud trabajar a continuación (o si manejar una nueva solicitud "
"entrante). Esto es particularmente importante para los servicios de "
"transmisión en los que cada cliente puede potencialmente estar conectado "
"durante mucho tiempo (si no se pueden utilizar subprocesos o subprocesos). "
"Consulte :mod:`asyncore` para ver otra forma de gestionar esto."

#: ../Doc/library/socketserver.rst:193
msgid "Server Objects"
msgstr "Objetos de servidor"

#: ../Doc/library/socketserver.rst:197
msgid ""
"This is the superclass of all Server objects in the module.  It defines the "
"interface, given below, but does not implement most of the methods, which is "
"done in subclasses.  The two parameters are stored in the respective :attr:"
"`server_address` and :attr:`RequestHandlerClass` attributes."
msgstr ""
"Esta es la superclase de todos los objetos de servidor en el módulo. Define "
"la interfaz, que se indica a continuación, pero no implementa la mayoría de "
"los métodos, que se realiza en subclases. Los dos parámetros se almacenan en "
"los atributos respectivos :attr:`server_address` y :attr:"
"`RequestHandlerClass`."

#: ../Doc/library/socketserver.rst:205
msgid ""
"Return an integer file descriptor for the socket on which the server is "
"listening.  This function is most commonly passed to :mod:`selectors`, to "
"allow monitoring multiple servers in the same process."
msgstr ""
"Retorna un descriptor de archivo entero para el socket en el que escucha el "
"servidor. Esta función se pasa comúnmente a :mod:`selectors`, para permitir "
"monitorear múltiples servidores en el mismo proceso."

#: ../Doc/library/socketserver.rst:212
msgid ""
"Process a single request.  This function calls the following methods in "
"order: :meth:`get_request`, :meth:`verify_request`, and :meth:"
"`process_request`.  If the user-provided :meth:`~BaseRequestHandler.handle` "
"method of the handler class raises an exception, the server's :meth:"
"`handle_error` method will be called.  If no request is received within :"
"attr:`timeout` seconds, :meth:`handle_timeout` will be called and :meth:"
"`handle_request` will return."
msgstr ""
"Procese una sola solicitud. Esta función llama a los siguientes métodos en "
"orden: :meth:`get_request`, :meth:`verify_request`, y :meth:"
"`process_request`. Si el método proporcionado por el usuario :meth:"
"`~BaseRequestHandler.handle` de la clase del controlador lanza una "
"excepción, se llamará al método :meth:`handle_error` del servidor. Si no se "
"recibe ninguna solicitud en :attr:`timeout` segundos, se llamará a :meth:"
"`handle_timeout` y :meth:`handle_request` regresará."

#: ../Doc/library/socketserver.rst:224
msgid ""
"Handle requests until an explicit :meth:`shutdown` request.  Poll for "
"shutdown every *poll_interval* seconds. Ignores the :attr:`timeout` "
"attribute.  It also calls :meth:`service_actions`, which may be used by a "
"subclass or mixin to provide actions specific to a given service.  For "
"example, the :class:`ForkingMixIn` class uses :meth:`service_actions` to "
"clean up zombie child processes."
msgstr ""
"Manejar solicitudes hasta una solicitud explícita :meth:`shutdown`. Sondeo "
"de apagado cada *poll_interval* segundos. Ignora el atributo :attr:"
"`timeout`. También llama :meth:`service_actions`, que puede ser utilizado "
"por una subclase o mixin para proporcionar acciones específicas para un "
"servicio dado. Por ejemplo, la clase :class:`ForkingMixIn` usa :meth:"
"`service_actions` para limpiar procesos secundarios zombies."

#: ../Doc/library/socketserver.rst:232
msgid "Added ``service_actions`` call to the ``serve_forever`` method."
msgstr "Se agregó la llamada ``service_actions`` al método ``serve_forever``."

#: ../Doc/library/socketserver.rst:238
msgid ""
"This is called in the :meth:`serve_forever` loop. This method can be "
"overridden by subclasses or mixin classes to perform actions specific to a "
"given service, such as cleanup actions."
msgstr ""
"Esto se llama en el ciclo :meth:`serve_forever`. Este método puede ser "
"reemplazado por subclases o clases mixtas para realizar acciones específicas "
"para un servicio dado, como acciones de limpieza."

#: ../Doc/library/socketserver.rst:246
msgid ""
"Tell the :meth:`serve_forever` loop to stop and wait until it does. :meth:"
"`shutdown` must be called while :meth:`serve_forever` is running in a "
"different thread otherwise it will deadlock."
msgstr ""
"Dile al bucle :meth:`serve_forever` que se detenga y espere hasta que lo "
"haga. :meth:`shutdown` debe llamarse mientras :meth:`serve_forever` se está "
"ejecutando en un hilo diferente, de lo contrario, se bloqueará."

#: ../Doc/library/socketserver.rst:253
msgid "Clean up the server. May be overridden."
msgstr "Limpiar el servidor. Puede ser sobrescrito."

#: ../Doc/library/socketserver.rst:258
msgid ""
"The family of protocols to which the server's socket belongs. Common "
"examples are :const:`socket.AF_INET` and :const:`socket.AF_UNIX`."
msgstr ""
"La familia de protocolos a la que pertenece el socket del servidor. Algunos "
"ejemplos comunes son :const:`socket.AF_INET` y :const:`socket.AF_UNIX`."

#: ../Doc/library/socketserver.rst:264
msgid ""
"The user-provided request handler class; an instance of this class is "
"created for each request."
msgstr ""
"La clase de controlador de solicitudes proporcionada por el usuario; se crea "
"una instancia de esta clase para cada solicitud."

#: ../Doc/library/socketserver.rst:270
msgid ""
"The address on which the server is listening.  The format of addresses "
"varies depending on the protocol family; see the documentation for the :mod:"
"`socket` module for details.  For internet protocols, this is a tuple "
"containing a string giving the address, and an integer port number: "
"``('127.0.0.1', 80)``, for example."
msgstr ""
"La dirección en la que escucha el servidor. El formato de las direcciones "
"varía según la familia de protocolos; consulte la documentación del módulo :"
"mod:`socket` para obtener más detalles. Para los protocolos de Internet, "
"esta es una tupla que contiene una cadena que da la dirección y un número de "
"puerto entero: ``('127.0.0.1', 80)``, por ejemplo."

#: ../Doc/library/socketserver.rst:279
msgid ""
"The socket object on which the server will listen for incoming requests."
msgstr ""
"El objeto de socket en el que el servidor escuchará las solicitudes "
"entrantes."

#: ../Doc/library/socketserver.rst:282
msgid "The server classes support the following class variables:"
msgstr "Las clases de servidor admiten las siguientes variables de clase:"

#: ../Doc/library/socketserver.rst:288
msgid ""
"Whether the server will allow the reuse of an address.  This defaults to :"
"const:`False`, and can be set in subclasses to change the policy."
msgstr ""
"Si el servidor permitirá la reutilización de una dirección. Este valor "
"predeterminado es :const:`False`, y se puede establecer en subclases para "
"cambiar la política."

#: ../Doc/library/socketserver.rst:294
msgid ""
"The size of the request queue.  If it takes a long time to process a single "
"request, any requests that arrive while the server is busy are placed into a "
"queue, up to :attr:`request_queue_size` requests.  Once the queue is full, "
"further requests from clients will get a \"Connection denied\" error.  The "
"default value is usually 5, but this can be overridden by subclasses."
msgstr ""
"El tamaño de la cola de solicitudes. Si toma mucho tiempo procesar una sola "
"solicitud, cualquier solicitud que llegue mientras el servidor está ocupado "
"se coloca en una cola, hasta :attr:`request_queue_size`. Una vez que la cola "
"está llena, más solicitudes de clientes obtendrán un error de \"Conexión "
"denegada\". El valor predeterminado suele ser 5, pero las subclases pueden "
"anularlo."

#: ../Doc/library/socketserver.rst:303
msgid ""
"The type of socket used by the server; :const:`socket.SOCK_STREAM` and :"
"const:`socket.SOCK_DGRAM` are two common values."
msgstr ""
"El tipo de socket utilizado por el servidor; :const:`socket.SOCK_STREAM` y :"
"const:`socket.SOCK_DGRAM` son dos valores comunes."

#: ../Doc/library/socketserver.rst:309
msgid ""
"Timeout duration, measured in seconds, or :const:`None` if no timeout is "
"desired.  If :meth:`handle_request` receives no incoming requests within the "
"timeout period, the :meth:`handle_timeout` method is called."
msgstr ""
"Duración del tiempo de espera, medida en segundos, o :const:`None` si no se "
"desea un tiempo de espera. Si :meth:`handle_request` no recibe solicitudes "
"entrantes dentro del período de tiempo de espera, se llama al método :meth:"
"`handle_timeout`."

#: ../Doc/library/socketserver.rst:314
msgid ""
"There are various server methods that can be overridden by subclasses of "
"base server classes like :class:`TCPServer`; these methods aren't useful to "
"external users of the server object."
msgstr ""
"Hay varios métodos de servidor que pueden ser anulados por subclases de "
"clases de servidor base como :class:`TCPServer`; estos métodos no son útiles "
"para los usuarios externos del objeto de servidor."

#: ../Doc/library/socketserver.rst:323
msgid ""
"Actually processes the request by instantiating :attr:`RequestHandlerClass` "
"and calling its :meth:`~BaseRequestHandler.handle` method."
msgstr ""
"En realidad, procesa la solicitud creando instancias :attr:"
"`RequestHandlerClass` y llamando a su método :meth:`~BaseRequestHandler."
"handle`."

#: ../Doc/library/socketserver.rst:329
msgid ""
"Must accept a request from the socket, and return a 2-tuple containing the "
"*new* socket object to be used to communicate with the client, and the "
"client's address."
msgstr ""
"Debe aceptar una solicitud del socket y retornar una tupla de 2 que contenga "
"el objeto de socket *nuevo* que se utilizará para comunicarse con el cliente "
"y la dirección del cliente."

#: ../Doc/library/socketserver.rst:336
msgid ""
"This function is called if the :meth:`~BaseRequestHandler.handle` method of "
"a :attr:`RequestHandlerClass` instance raises an exception.  The default "
"action is to print the traceback to standard error and continue handling "
"further requests."
msgstr ""
"Esta función se llama si el método :meth:`~BaseRequestHandler.handle` de una "
"instancia :attr:`RequestHandlerClass` lanza una excepción. La acción "
"predeterminada es imprimir el rastreo al error estándar y continuar "
"manejando más solicitudes."

#: ../Doc/library/socketserver.rst:341
msgid "Now only called for exceptions derived from the :exc:`Exception` class."
msgstr ""
"Ahora solo se solicitan excepciones derivadas de la clase :exc:`Exception`."

#: ../Doc/library/socketserver.rst:348
msgid ""
"This function is called when the :attr:`timeout` attribute has been set to a "
"value other than :const:`None` and the timeout period has passed with no "
"requests being received.  The default action for forking servers is to "
"collect the status of any child processes that have exited, while in "
"threading servers this method does nothing."
msgstr ""
"Esta función se llama cuando el atributo :attr:`timeout` se ha establecido "
"en un valor distinto de :const:`None` y el tiempo de espera ha pasado sin "
"que se reciban solicitudes. La acción predeterminada para los servidores de "
"forking es recopilar el estado de cualquier proceso hijo que haya salido, "
"mientras que en los servidores de threading este método no hace nada."

#: ../Doc/library/socketserver.rst:357
msgid ""
"Calls :meth:`finish_request` to create an instance of the :attr:"
"`RequestHandlerClass`.  If desired, this function can create a new process "
"or thread to handle the request; the :class:`ForkingMixIn` and :class:"
"`ThreadingMixIn` classes do this."
msgstr ""
"Llama a :meth:`finish_request` para crear una instancia de :attr:"
"`RequestHandlerClass`. Si lo desea, esta función puede crear un nuevo "
"proceso o hilo para manejar la solicitud; las clases :class:`ForkingMixIn` "
"y :class:`ThreadingMixIn` hacen esto."

#: ../Doc/library/socketserver.rst:369
msgid ""
"Called by the server's constructor to activate the server.  The default "
"behavior for a TCP server just invokes :meth:`~socket.socket.listen` on the "
"server's socket.  May be overridden."
msgstr ""
"Lo llama el constructor del servidor para activar el servidor. El "
"comportamiento predeterminado para un servidor TCP simplemente invoca :meth:"
"`~socket.socket.listen` en el socket del servidor. Puede anularse."

#: ../Doc/library/socketserver.rst:376
msgid ""
"Called by the server's constructor to bind the socket to the desired "
"address. May be overridden."
msgstr ""
"Lo llama el constructor del servidor para vincular el socket a la dirección "
"deseada. Puede anularse."

#: ../Doc/library/socketserver.rst:382
msgid ""
"Must return a Boolean value; if the value is :const:`True`, the request will "
"be processed, and if it's :const:`False`, the request will be denied.  This "
"function can be overridden to implement access controls for a server. The "
"default implementation always returns :const:`True`."
msgstr ""
"Debe retornar un valor booleano; si el valor es :const:`True`, la solicitud "
"se procesará, y si es :const:`False`, la solicitud será denegada. Esta "
"función se puede anular para implementar controles de acceso para un "
"servidor. La implementación predeterminada siempre retorna :const:`True`."

#: ../Doc/library/socketserver.rst:388
msgid ""
"Support for the :term:`context manager` protocol was added.  Exiting the "
"context manager is equivalent to calling :meth:`server_close`."
msgstr ""
"Se agregó soporte para el protocolo :term:`context manager`. Salir del "
"administrador de contexto es equivalente a llamar a :meth:`server_close`."

#: ../Doc/library/socketserver.rst:394
msgid "Request Handler Objects"
msgstr "Solicitar objetos de controlador"

#: ../Doc/library/socketserver.rst:398
msgid ""
"This is the superclass of all request handler objects.  It defines the "
"interface, given below.  A concrete request handler subclass must define a "
"new :meth:`handle` method, and can override any of the other methods.  A new "
"instance of the subclass is created for each request."
msgstr ""
"Esta es la superclase de todos los objetos de manejo de solicitudes. Define "
"la interfaz, que se muestra a continuación. Una subclase de controlador de "
"solicitudes concreta debe definir un nuevo método :meth:`handle` y puede "
"anular cualquiera de los otros métodos. Se crea una nueva instancia de la "
"subclase para cada solicitud."

#: ../Doc/library/socketserver.rst:407
msgid ""
"Called before the :meth:`handle` method to perform any initialization "
"actions required.  The default implementation does nothing."
msgstr ""
"Se llama antes del método :meth:`handle` para realizar las acciones de "
"inicialización necesarias. La implementación predeterminada no hace nada."

#: ../Doc/library/socketserver.rst:413
msgid ""
"This function must do all the work required to service a request.  The "
"default implementation does nothing.  Several instance attributes are "
"available to it; the request is available as :attr:`self.request`; the "
"client address as :attr:`self.client_address`; and the server instance as :"
"attr:`self.server`, in case it needs access to per-server information."
msgstr ""
"Esta función debe realizar todo el trabajo necesario para atender una "
"solicitud. La implementación predeterminada no hace nada. Dispone de varios "
"atributos de instancia; la solicitud está disponible como :attr:`self."
"request`; la dirección del cliente como :attr:`self.client_address`; y la "
"instancia del servidor como :attr:`self.server`, en caso de que necesite "
"acceder a la información por servidor."

#: ../Doc/library/socketserver.rst:419
msgid ""
"The type of :attr:`self.request` is different for datagram or stream "
"services.  For stream services, :attr:`self.request` is a socket object; for "
"datagram services, :attr:`self.request` is a pair of string and socket."
msgstr ""
"El tipo de :attr:`self.request` es diferente para datagramas o servicios de "
"flujo. Para los servicios de transmisión, :attr:`self.request` es un objeto "
"de socket; para servicios de datagramas, :attr:`self.request` es un par de "
"string y socket."

#: ../Doc/library/socketserver.rst:426
msgid ""
"Called after the :meth:`handle` method to perform any clean-up actions "
"required.  The default implementation does nothing.  If :meth:`setup` raises "
"an exception, this function will not be called."
msgstr ""
"Se llama después del método :meth:`handle` para realizar las acciones de "
"limpieza necesarias. La implementación predeterminada no hace nada. Si :meth:"
"`setup` lanza una excepción, no se llamará a esta función."

#: ../Doc/library/socketserver.rst:434
#, fuzzy
msgid ""
"These :class:`BaseRequestHandler` subclasses override the :meth:"
"`~BaseRequestHandler.setup` and :meth:`~BaseRequestHandler.finish` methods, "
"and provide :attr:`self.rfile` and :attr:`self.wfile` attributes. The :attr:"
"`self.rfile` and :attr:`self.wfile` attributes can be read or written, "
"respectively, to get the request data or return data to the client. The :"
"attr:`!rfile` attributes support the :class:`io.BufferedIOBase` readable "
"interface, and :attr:`!wfile` attributes support the :class:`!io."
"BufferedIOBase` writable interface."
msgstr ""
"Estas subclases :class:`BaseRequestHandler` anulan los métodos :meth:"
"`~BaseRequestHandler.setup` y :meth:`~BaseRequestHandler.finish`, y "
"proporcionan :attr:`self.rfile` y :attr:`self.wfile` atributos. Los "
"atributos :attr:`self.rfile` y :attr:`self.wfile` se pueden leer o escribir, "
"respectivamente, para obtener los datos de la solicitud o retornar los datos "
"al cliente."

#: ../Doc/library/socketserver.rst:443
msgid ""
":attr:`StreamRequestHandler.wfile` also supports the :class:`io."
"BufferedIOBase` writable interface."
msgstr ""
":attr:`StreamRequestHandler.wfile` también admite la interfaz de escritura :"
"class:`io.BufferedIOBase`."

#: ../Doc/library/socketserver.rst:449
msgid "Examples"
msgstr "Ejemplos"

#: ../Doc/library/socketserver.rst:452
msgid ":class:`socketserver.TCPServer` Example"
msgstr ":class:`socketserver.TCPServer` Ejemplo"

#: ../Doc/library/socketserver.rst:454 ../Doc/library/socketserver.rst:553
msgid "This is the server side::"
msgstr "Este es el lado del servidor:"

#: ../Doc/library/socketserver.rst:484
msgid ""
"An alternative request handler class that makes use of streams (file-like "
"objects that simplify communication by providing the standard file "
"interface)::"
msgstr ""
"Una clase de controlador de solicitudes alternativa que hace uso de "
"secuencias (objetos similares a archivos que simplifican la comunicación al "
"proporcionar la interfaz de archivo estándar):"

#: ../Doc/library/socketserver.rst:499
msgid ""
"The difference is that the ``readline()`` call in the second handler will "
"call ``recv()`` multiple times until it encounters a newline character, "
"while the single ``recv()`` call in the first handler will just return what "
"has been sent from the client in one ``sendall()`` call."
msgstr ""
"La diferencia es que la llamada ``readline()`` en el segundo controlador "
"llamará a ``recv()`` varias veces hasta que encuentre un carácter de nueva "
"línea, mientras que la llamada única ``recv()`` en el primer controlador "
"simplemente retornará lo que se ha enviado desde el cliente en una llamada "
"``sendall()`` ."

#: ../Doc/library/socketserver.rst:505 ../Doc/library/socketserver.rst:577
msgid "This is the client side::"
msgstr "Este es el lado del cliente:"

#: ../Doc/library/socketserver.rst:526 ../Doc/library/socketserver.rst:652
msgid "The output of the example should look something like this:"
msgstr "La salida del ejemplo debería verse así:"

#: ../Doc/library/socketserver.rst:528
msgid "Server:"
msgstr "Servidor:"

#: ../Doc/library/socketserver.rst:538
msgid "Client:"
msgstr "Cliente:"

#: ../Doc/library/socketserver.rst:551
msgid ":class:`socketserver.UDPServer` Example"
msgstr ":class:`socketserver.UDPServer` Ejemplo"

#: ../Doc/library/socketserver.rst:596
msgid ""
"The output of the example should look exactly like for the TCP server "
"example."
msgstr ""
"La salida del ejemplo debería verse exactamente como en el ejemplo del "
"servidor TCP."

#: ../Doc/library/socketserver.rst:600
msgid "Asynchronous Mixins"
msgstr "Mixins asincrónicos"

#: ../Doc/library/socketserver.rst:602
msgid ""
"To build asynchronous handlers, use the :class:`ThreadingMixIn` and :class:"
"`ForkingMixIn` classes."
msgstr ""
"Para construir controladores asincrónicos, use las clases :class:"
"`ThreadingMixIn` y :class:`ForkingMixIn`."

#: ../Doc/library/socketserver.rst:605
msgid "An example for the :class:`ThreadingMixIn` class::"
msgstr "Un ejemplo para la clase :class:`ThreadingMixIn` class ::"

#: ../Doc/library/socketserver.rst:663
msgid ""
"The :class:`ForkingMixIn` class is used in the same way, except that the "
"server will spawn a new process for each request. Available only on POSIX "
"platforms that support :func:`~os.fork`."
msgstr ""
"La clase :class:`ForkingMixIn` se usa de la misma manera, excepto que el "
"servidor generará un nuevo proceso para cada solicitud. Disponible solo en "
"plataformas POSIX que admitan :func:`~os.fork`."

#~ msgid ""
#~ "The :attr:`rfile` attributes of both classes support the :class:`io."
#~ "BufferedIOBase` readable interface, and :attr:`DatagramRequestHandler."
#~ "wfile` supports the :class:`io.BufferedIOBase` writable interface."
#~ msgstr ""
#~ "Los atributos :attr:`rfile` de ambas clases admiten la interfaz legible :"
#~ "class:`io.BufferedIOBase`, y :attr:`DatagramRequestHandler.wfile` admite "
#~ "la :class:`io.BufferedIOBase` interfaz de escritura."