# 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: 2019-05-06 11:59-0400\n"

"PO-Revision-Date: 2020-08-25 07:58-0500\n"

"Language-Team: python-doc-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"

"Last-Translator: Adolfo Hristo David Roque Gámez <hristo.roqueg@gmail.com>\n"

"Language: es_AR\n"

"X-Generator: Poedit 2.4\n"

#: ../Doc/library/email.policy.rst:2

msgid ":mod:`email.policy`: Policy Objects"

msgstr ":mod:`email.policy`: Objetos *Policy*"

#: ../Doc/library/email.policy.rst:12

msgid "**Source code:** :source:`Lib/email/policy.py`"

msgstr "**Código fuente:** :source:`Lib/email/policy.py`"

#: ../Doc/library/email.policy.rst:16

msgid ""

"The :mod:`email` package's prime focus is the handling of email messages as "

"described by the various email and MIME RFCs. However, the general format "

"of email messages (a block of header fields each consisting of a name "

"followed by a colon followed by a value, the whole block followed by a blank "

"line and an arbitrary 'body'), is a format that has found utility outside of "

"the realm of email. Some of these uses conform fairly closely to the main "

"email RFCs, some do not. Even when working with email, there are times when "

"it is desirable to break strict compliance with the RFCs, such as generating "

"emails that interoperate with email servers that do not themselves follow "

"the standards, or that implement extensions you want to use in ways that "

"violate the standards."

msgstr ""

"El enfoque principal del paquete :mod:`email` es la gestión de mensajes de "

"correo electrónico como se describe por los varios RFC de correos "

"electrónicos y MIME. Sin embargo, el formato general de los mensajes de "

"correo electrónico (un bloque de campos de cabecera cada uno consistiendo en "

"un nombre seguido de dos puntos seguido de un valor, el bloque entero "

"seguido por una línea blanca y un 'cuerpo' arbitrario), es un formato que ha "

"encontrado utilidad fuera del campo de correos electrónicos. Algunos de "

"estos usos cumplen bastante cerca los RFC de correos electrónicos "

"principales, alguno no. Incluso cuando se trabajo con correos electrónicos, "

"hay veces cuando es deseable romper la estricta conformidad con los RFC, tal "

"como generar correos electrónicos que se integran con servidores de correos "

"electrónicos que no siguen los estándares, o que implementan extensiones que "

"quieres usar en formas que violan los estándares."

#: ../Doc/library/email.policy.rst:28

msgid ""

"Policy objects give the email package the flexibility to handle all these "

"disparate use cases."

msgstr ""

"Los objetos *policy* dan al paquete de correos electrónicos la flexibilidad "

"de manejar todos estos casos de uso diversos."

#: ../Doc/library/email.policy.rst:31

msgid ""

"A :class:`Policy` object encapsulates a set of attributes and methods that "

"control the behavior of various components of the email package during use. :"

"class:`Policy` instances can be passed to various classes and methods in the "

"email package to alter the default behavior. The settable values and their "

"defaults are described below."

msgstr ""

"Un objeto :class:`Policy` encapsula un conjunto de atributos y métodos que "

"controlan el comportamiento de varios componentes del paquete de correos "

"electrónicos durante el uso. Las instancias :class:`Policy` pueden ser "

"pasadas a varias clases y métodos en el paquete de correos electrónicos para "

"alterar el comportamiento por defecto. Los valores que se pueden configurar "

"y sus valores por defecto se describen abajo."

#: ../Doc/library/email.policy.rst:37

msgid ""

"There is a default policy used by all classes in the email package. For all "

"of the :mod:`~email.parser` classes and the related convenience functions, "

"and for the :class:`~email.message.Message` class, this is the :class:"

"`Compat32` policy, via its corresponding pre-defined instance :const:"

"`compat32`. This policy provides for complete backward compatibility (in "

"some cases, including bug compatibility) with the pre-Python3.3 version of "

"the email package."

msgstr ""

"Hay una *policy* por defecto usada por todas las clases en el paquete de "

"correos electrónicos. Para todos las clases :mod:`~email.Parser` y las "

"funciones de conveniencia relacionadas, y para la clase :class:`~email."

"message.Message`, esta es una *policy* :class:`Compat32`, a través de sus "

"correspondientes instancias :const:`compat32` pre-definidas. Esta política "

"mantiene una compatibilidad (en algunos casos, compatibilidad con los bugs) "

"con el paquete de correos electrónicos de las versiones anteriores de "

"Python3.3."

#: ../Doc/library/email.policy.rst:44

msgid ""

"This default value for the *policy* keyword to :class:`~email.message."

"EmailMessage` is the :class:`EmailPolicy` policy, via its pre-defined "

"instance :data:`~default`."

msgstr ""

"El valor por defecto para la palabra clave *policy* de :class:`~email."

"message.EmailMessage` es la *policy* :class:`EmailPolicy`, a través de su "

"instancia pre-definida :data:`~default`."

#: ../Doc/library/email.policy.rst:48

msgid ""

"When a :class:`~email.message.Message` or :class:`~email.message."

"EmailMessage` object is created, it acquires a policy. If the message is "

"created by a :mod:`~email.parser`, a policy passed to the parser will be the "

"policy used by the message it creates. If the message is created by the "

"program, then the policy can be specified when it is created. When a "

"message is passed to a :mod:`~email.generator`, the generator uses the "

"policy from the message by default, but you can also pass a specific policy "

"to the generator that will override the one stored on the message object."

msgstr ""

"Cuando un objeto :class:`~email.message.Message` o :class:`~email.message."

"EmailMessage` es creado, adquiere un *policy*. Si el mensaje es creado por "

"un :mod:`~email.parser`, un *policy* pasado al analizador será el *policy* "

"usado por el mensaje que cree. Si el mensaje es creado por el programa, "

"entonces el *policy* puede ser especificado cuando sea creado. Cuando un "

"mensaje es pasado a un :mod:`~email.generator`, el generador usa el *policy* "

"del mensaje por defecto, pero también puedes pasar un *policy* específico al "

"generador que anulará el que está guardado en el objeto mensaje."

#: ../Doc/library/email.policy.rst:57

msgid ""

"The default value for the *policy* keyword for the :mod:`email.parser` "

"classes and the parser convenience functions **will be changing** in a "

"future version of Python. Therefore you should **always specify explicitly "

"which policy you want to use** when calling any of the classes and functions "

"described in the :mod:`~email.parser` module."

msgstr ""

"El valor por defecto del argumento por palabra clave *policy* para las "

"clases :mod:`email.parser` y las funciones de conveniencia del analizador "

"**se cambiarán** en una futura versión de Python. Por consiguiente, "

"**siempre debes especificar explícitamente qué policy quieres usar** cuando "

"se llama a cualquiera de las clases y funciones descritas en el módulo :mod:"

"`~email.parser`."

#: ../Doc/library/email.policy.rst:63

msgid ""

"The first part of this documentation covers the features of :class:`Policy`, "

"an :term:`abstract base class` that defines the features that are common to "

"all policy objects, including :const:`compat32`. This includes certain hook "

"methods that are called internally by the email package, which a custom "

"policy could override to obtain different behavior. The second part "

"describes the concrete classes :class:`EmailPolicy` and :class:`Compat32`, "

"which implement the hooks that provide the standard behavior and the "

"backward compatible behavior and features, respectively."

msgstr ""

"La primera parte de esta documentación cubre las características de :class:"

"`Policy`, un :term:`abstract base class` que define las características que "

"son comunes a todos los objetos *policy*, incluyendo :const:`compat32`. "

"Esto incluye ciertos métodos gancho (*hook*) que son llamados internamente "

"por el paquete de correos electrónicos, que un *policy* personalizado puede "

"invalidar para obtener un comportamiento diferente. La segunda parte "

"describe las clases concretas :class:`EmailPolicy` y :class:`Compat32`, que "

"implementan los ganchos (*hooks*) que proporcionan el comportamiento "

"estándar y el comportamiento y características compatibles hacia atrás, "

"respectivamente."

#: ../Doc/library/email.policy.rst:72

msgid ""

":class:`Policy` instances are immutable, but they can be cloned, accepting "

"the same keyword arguments as the class constructor and returning a new :"

"class:`Policy` instance that is a copy of the original but with the "

"specified attributes values changed."

msgstr ""

"Las instancias :class:`Policy` son inmutables, pero pueden ser clonadas, "

"aceptando los mismos argumentos de palabra clave que el constructor de clase "

"y retorna una nueva instancia :class:`Policy` que es una copia del original "

"pero con los valores de atributos específicos cambiados."

#: ../Doc/library/email.policy.rst:77

msgid ""

"As an example, the following code could be used to read an email message "

"from a file on disk and pass it to the system ``sendmail`` program on a Unix "

"system:"

msgstr ""

"Como un ejemplo, el siguiente código puede ser usado para leer un mensaje de "

"correo electrónico de un archivo en disco y pasarlo al programa de sistema "

"``sendmail`` en un sistema Unix:"

#: ../Doc/library/email.policy.rst:113

msgid ""

"Here we are telling :class:`~email.generator.BytesGenerator` to use the RFC "

"correct line separator characters when creating the binary string to feed "

"into ``sendmail's`` ``stdin``, where the default policy would use ``\\n`` "

"line separators."

msgstr ""

"Aquí le estamos diciendo a :class:`~email.generator.BytesGenerator` que use "

"los caracteres de separación de línea correctos de RFC cuando crea la cadena "

"binaria para alimentar a ``stding`` de ``sendmail`` (``sendmails's`` "

"``stdin``), donde el *policy* por defecto usaría separadores de línea ``"

"\\n``."

#: ../Doc/library/email.policy.rst:118

msgid ""

"Some email package methods accept a *policy* keyword argument, allowing the "

"policy to be overridden for that method. For example, the following code "

"uses the :meth:`~email.message.Message.as_bytes` method of the *msg* object "

"from the previous example and writes the message to a file using the native "

"line separators for the platform on which it is running::"

msgstr ""

"Algunos métodos del paquete de correos electrónicos aceptan un argumento de "

"palabra clave *policy*, permitiendo que el *policy* pueda ser anulado para "

"ese método. Por ejemplo, el siguiente código usa el método :meth:`~email."

"message.Message.as_bytes` del objeto *msg* del ejemplo anterior y escribe el "

"mensaje en un archivo usando los separadores de línea nativos para la "

"plataforma en el que esté corriendo::"

#: ../Doc/library/email.policy.rst:129

msgid ""

"Policy objects can also be combined using the addition operator, producing a "

"policy object whose settings are a combination of the non-default values of "

"the summed objects::"

msgstr ""

"Los objetos *policy* puede ser combinados usando el operador de adición, "

"produciendo un objeto *policy* cuya configuración es una combinación de los "

"valores que de los objetos sumados::"

#: ../Doc/library/email.policy.rst:137

msgid ""

"This operation is not commutative; that is, the order in which the objects "

"are added matters. To illustrate::"

msgstr ""

"Esta operación no es conmutativa; es decir, el orden en el que los objetos "

"son añadidos importa. Para ilustrar::"

#: ../Doc/library/email.policy.rst:152

msgid ""

"This is the :term:`abstract base class` for all policy classes. It provides "

"default implementations for a couple of trivial methods, as well as the "

"implementation of the immutability property, the :meth:`clone` method, and "

"the constructor semantics."

msgstr ""

"Este es el :term:`abstract base class` para todas las clases *policy*. "

"Proporciona las implementaciones por defecto para un par de métodos "

"triviales, también como la implementación de las propiedades de "

"inmutabilidad, el método :meth:`clone`, y las semánticas del constructor."

#: ../Doc/library/email.policy.rst:157

msgid ""

"The constructor of a policy class can be passed various keyword arguments. "

"The arguments that may be specified are any non-method properties on this "

"class, plus any additional non-method properties on the concrete class. A "

"value specified in the constructor will override the default value for the "

"corresponding attribute."

msgstr ""

"Se pueden pasar varios argumentos de palabra clave al constructor de una "

"clase *policy*. Los argumentos que pueden ser especificados son cualquier "

"propiedad que no sea método en esta clase, además de cualquier otra "

"propiedad adicional que no sea método en la clase concreta. Un valor "

"especificado en el constructor anulará el valor por defecto para los "

"atributos correspondientes."

#: ../Doc/library/email.policy.rst:163

msgid ""

"This class defines the following properties, and thus values for the "

"following may be passed in the constructor of any policy class:"

msgstr ""

"Esta clase define las siguientes propiedades, y por consiguiente los valores "

"a continuación pueden ser pasados al constructor de cualquier clase *policy*:"

#: ../Doc/library/email.policy.rst:169

msgid ""

"The maximum length of any line in the serialized output, not counting the "

"end of line character(s). Default is 78, per :rfc:`5322`. A value of ``0`` "

"or :const:`None` indicates that no line wrapping should be done at all."

msgstr ""

"El tamaño máximo de cualquier línea en la salida serializada, sin contar el "

"fin de la línea de carácter(res). Por defecto es 78, por el :rfc:`5322`. Un "

"valor de ``0`` o :const:`None` indica que ningún envolvimiento de líneas "

"puede ser hecha en lo más mínimo."

#: ../Doc/library/email.policy.rst:177

msgid ""

"The string to be used to terminate lines in serialized output. The default "

"is ``\\n`` because that's the internal end-of-line discipline used by "

"Python, though ``\\r\\n`` is required by the RFCs."

msgstr ""

"La cadena de caracteres a ser usada para terminar las líneas en una salida "

"serializada. El valor por defecto es ``\\n`` porque esa es la disciplina "

"del fin de línea interna usada por Python, aunque ``\\r\\n`` es requerida "

"por los RFCs."

#: ../Doc/library/email.policy.rst:184

msgid ""

"Controls the type of Content Transfer Encodings that may be or are required "

"to be used. The possible values are:"

msgstr ""

"Controla el tipo de Codificaciones de Transferencia de Contenido que pueden "

"ser o son necesarios para ser usados. Los valores posibles son:"

#: ../Doc/library/email.policy.rst:190

msgid "``7bit``"

msgstr "``7bit``"

#: ../Doc/library/email.policy.rst:190

msgid ""

"all data must be \"7 bit clean\" (ASCII-only). This means that where "

"necessary data will be encoded using either quoted-printable or base64 "

"encoding."

msgstr ""

"todos los datos deben ser \"compatibles con 7 bit (*7 bit clean*)\" (ASCII-"

"only). Esto significa que donde sea necesario, los datos serán codificados "

"usando o codificación imprimible entre comillas o base64."

#: ../Doc/library/email.policy.rst:194

msgid "``8bit``"

msgstr "``8bit``"

#: ../Doc/library/email.policy.rst:194

msgid ""

"data is not constrained to be 7 bit clean. Data in headers is still "

"required to be ASCII-only and so will be encoded (see :meth:`fold_binary` "

"and :attr:`~EmailPolicy.utf8` below for exceptions), but body parts may use "

"the ``8bit`` CTE."

msgstr ""

"los datos no son limitados a ser compatibles con 7 bits (*7 bit clean*). Se "

"requiere que los datos en las cabeceras todavía sean sólo ASCII y por lo "

"tanto estarán codificadas (véase :meth:`fold_binary` y :attr:`~EmailPolicy."

"utf8` abajo por las excepciones), pero las partes del cuerpo pueden usar "

"``8bit`` CTE."

#: ../Doc/library/email.policy.rst:200

msgid ""

"A ``cte_type`` value of ``8bit`` only works with ``BytesGenerator``, not "

"``Generator``, because strings cannot contain binary data. If a "

"``Generator`` is operating under a policy that specifies ``cte_type=8bit``, "

"it will act as if ``cte_type`` is ``7bit``."

msgstr ""

"Un valor ``cte_type`` de ```8bit`` sólo trabaja con ``BytesGenerator``, no "

"``Generator``, porque las cadenas no pueden contener datos binarios. Si un "

"``Generator`` está operando bajo un *policy* que especifica "

"``cte_type=8bit``, actuará como si ``cte_type`` fuese ``7bit``."

#: ../Doc/library/email.policy.rst:208

msgid ""

"If :const:`True`, any defects encountered will be raised as errors. If :"

"const:`False` (the default), defects will be passed to the :meth:"

"`register_defect` method."

msgstr ""

"Si es :const:`True`, cualquier defecto encontrado será lanzado como error. "

"Si es :const:`False` (el valor por defecto), los defectos serán pasados al "

"método :meth:`register_defect`."

#: ../Doc/library/email.policy.rst:215

msgid ""

"If :const:`True`, lines starting with *\"From \"* in the body are escaped by "

"putting a ``>`` in front of them. This parameter is used when the message is "

"being serialized by a generator. Default: :const:`False`."

msgstr ""

"Si es :const:`True`, las líneas empezando con *\"From \"* en el cuerpo son "

"saltados al poner un ``>`` en frente de ellos. Este parámetro es usado "

"cuando el mensaje está siendo serializado por un generador. El valor por "

"defecto es: :const:`False`."

#: ../Doc/library/email.policy.rst:220

msgid "The *mangle_from_* parameter."

msgstr "El parámetro *mangle_from_*."

#: ../Doc/library/email.policy.rst:226

msgid ""

"A factory function for constructing a new empty message object. Used by the "

"parser when building messages. Defaults to ``None``, in which case :class:"

"`~email.message.Message` is used."

msgstr ""

"Una función de fábrica para construir un nuevo objeto mensaje vacío. Usado "

"por el analizador cuando construye mensajes. Por defecto es ``None``, en "

"cuyo caso :class:`~email.message.Message` es usado."

#: ../Doc/library/email.policy.rst:232

msgid ""

"The following :class:`Policy` method is intended to be called by code using "

"the email library to create policy instances with custom settings:"

msgstr ""

"El siguiente método de :class:`Policy` está destinado a ser llamado por "

"código usando la librería de correos electrónicos para crear instancias de "

"*policy* con configuraciones personalizadas:"

#: ../Doc/library/email.policy.rst:238

msgid ""

"Return a new :class:`Policy` instance whose attributes have the same values "

"as the current instance, except where those attributes are given new values "

"by the keyword arguments."

msgstr ""

"Retorna una nueva instancia de :class:`Policy` cuyos atributos tienen los "

"mismos valores que la instancia actual, excepto donde se le dan, a esos "

"atributos, nuevos valores por los argumentos de palabra clave."

#: ../Doc/library/email.policy.rst:243

msgid ""

"The remaining :class:`Policy` methods are called by the email package code, "

"and are not intended to be called by an application using the email package. "

"A custom policy must implement all of these methods."

msgstr ""

"Los métodos de :class:`Policy` restantes son llamados por el código de "

"paquete de correos electrónicos, y no están destinados a ser llamados por "

"una aplicación usando el paquete de correos electrónicos. Un *policy* "

"personalizado debe implementar todos estos métodos."

#: ../Doc/library/email.policy.rst:250

msgid ""

"Handle a *defect* found on *obj*. When the email package calls this method, "

"*defect* will always be a subclass of :class:`~email.errors.Defect`."

msgstr ""

"Trata un *defect* encontrado en *obj*. Cuando el paquete de correos "

"electrónicos llama a este método, *defect* siempre será una subclase de :"

"class:`~email.errors.Defect`."

#: ../Doc/library/email.policy.rst:254

msgid ""

"The default implementation checks the :attr:`raise_on_defect` flag. If it "

"is ``True``, *defect* is raised as an exception. If it is ``False`` (the "

"default), *obj* and *defect* are passed to :meth:`register_defect`."

msgstr ""

"La implementación por defecto verifica la bandera :attr:`raise_on_defect`. "

"Si es ``True``, *defect* es lanzado como una excepción. Si es ``False`` (el "

"valor por defecto), *obj* y *defect* son pasados a :meth:`register_defect`."

#: ../Doc/library/email.policy.rst:261

msgid ""

"Register a *defect* on *obj*. In the email package, *defect* will always be "

"a subclass of :class:`~email.errors.Defect`."

msgstr ""

"Registra un *defect* en *obj*. En el paquete de correos electrónicos, "

"*defect* será siempre una subclase de :class:`~email.errors.Defect`."

#: ../Doc/library/email.policy.rst:264

msgid ""

"The default implementation calls the ``append`` method of the ``defects`` "

"attribute of *obj*. When the email package calls :attr:`handle_defect`, "

"*obj* will normally have a ``defects`` attribute that has an ``append`` "

"method. Custom object types used with the email package (for example, "

"custom ``Message`` objects) should also provide such an attribute, otherwise "

"defects in parsed messages will raise unexpected errors."

msgstr ""

"La implementación por defecto llama al método ``append`` del atributo "

"``defects`` de *obj*. Cuando un paquete de correos electrónicos llama a :"

"attr:`handle_defect`, *obj* normalmente tendrá un atributo ``defects`` que "

"tiene un método ``append``. Los tipos de objetos personalizados usados con "

"el paquete de correos electrónicos (por ejemplo, objetos ``Message`` "

"personalizados) también deben proporcionar tal atributo, de otro modo, los "

"defectos en los mensajes analizados levantarán errores no esperados."

#: ../Doc/library/email.policy.rst:274

msgid "Return the maximum allowed number of headers named *name*."

msgstr "Retorna el máximo número permitido de cabeceras llamadas *name*."

#: ../Doc/library/email.policy.rst:276

msgid ""

"Called when a header is added to an :class:`~email.message.EmailMessage` or :"

"class:`~email.message.Message` object. If the returned value is not ``0`` "

"or ``None``, and there are already a number of headers with the name *name* "

"greater than or equal to the value returned, a :exc:`ValueError` is raised."

msgstr ""

"Llamado cuando una cabecera es añadida a un objeto :class:`~email.message."

"EmailMessage` o :class:`~email.message.Message`. Si el valor retornado no "

"es ``0`` o ``None``, y ya hay un número de cabeceras con el nombre *name* "

"mayor o igual que el valor retornado, un :exc:`ValueError` es lanzado."

#: ../Doc/library/email.policy.rst:282

msgid ""

"Because the default behavior of ``Message.__setitem__`` is to append the "

"value to the list of headers, it is easy to create duplicate headers without "

"realizing it. This method allows certain headers to be limited in the "

"number of instances of that header that may be added to a ``Message`` "

"programmatically. (The limit is not observed by the parser, which will "

"faithfully produce as many headers as exist in the message being parsed.)"

msgstr ""

"Porque el comportamiento por defecto de ``Message.__setitem__`` es agregar "

"el valor a la lista de cabeceras, es fácil crear cabeceras duplicadas sin "

"darse cuenta. Este método permite que ciertas cabeceras sean limitadas en "

"el número de instancias de esa cabecera que puede ser agregada a ``Message`` "

"programáticamente. (El límite no es observado por el analizador, que "

"fielmente producirá tantas cabeceras como existen en el mensaje siendo "

"analizado.)"

#: ../Doc/library/email.policy.rst:290

msgid "The default implementation returns ``None`` for all header names."

msgstr ""

"La implementación por defecto retorna ``None`` para todos los nombres de "

"cabeceras."

#: ../Doc/library/email.policy.rst:295

msgid ""

"The email package calls this method with a list of strings, each string "

"ending with the line separation characters found in the source being "

"parsed. The first line includes the field header name and separator. All "

"whitespace in the source is preserved. The method should return the "

"``(name, value)`` tuple that is to be stored in the ``Message`` to represent "

"the parsed header."

msgstr ""

"El paquete de correos electrónicos llama a este método con una lista de "

"cadenas de caracteres, cada terminación de cadena con los caracteres de "

"separación de línea encontrada en la fuente siendo analizada. La primera "

"línea incluye el campo del nombre de cabecera y el separador. Todos los "

"espacios en blanco en la fuente son preservados. El método debe retornar la "

"tupla ``(name,value)`` que va a ser guardada en el ``Message`` para "

"representar la cabecera analizada."

#: ../Doc/library/email.policy.rst:302

msgid ""

"If an implementation wishes to retain compatibility with the existing email "

"package policies, *name* should be the case preserved name (all characters "

"up to the '``:``' separator), while *value* should be the unfolded value "

"(all line separator characters removed, but whitespace kept intact), "

"stripped of leading whitespace."

msgstr ""

"Si una implementación desea mantener compatibilidad con los *policy* del "

"paquete de correos electrónicos existentes, *name* debe ser el nombre con "

"las letras preservadas (todos los caracteres hasta el separador '``:``'), "

"mientras que *value* debe ser el valor desdoblado (todos los caracteres de "

"separación de líneas eliminados, pero los espacios en blanco intactos), "

"privado de espacios en blanco al comienzo."

#: ../Doc/library/email.policy.rst:308

msgid "*sourcelines* may contain surrogateescaped binary data."

msgstr "*sourcelines* puede contener datos binarios *surrogateescaped*."

#: ../Doc/library/email.policy.rst:310 ../Doc/library/email.policy.rst:326

#: ../Doc/library/email.policy.rst:342

msgid "There is no default implementation"

msgstr "No hay implementación por defecto"

#: ../Doc/library/email.policy.rst:315

msgid ""

"The email package calls this method with the name and value provided by the "

"application program when the application program is modifying a ``Message`` "

"programmatically (as opposed to a ``Message`` created by a parser). The "

"method should return the ``(name, value)`` tuple that is to be stored in the "

"``Message`` to represent the header."

msgstr ""

"El paquete de correos electrónicos llama a este método con el nombre y valor "

"proporcionados por el programa de aplicación cuando la aplicación está "

"modificando un ``Message`` programáticamente (en lugar de un ``Message`` "

"creado por un analizador). El método debe retornar la tupla ``(name,value)`` "

"que va a ser almacenada en el ``Message`` para representar la cabecera."

#: ../Doc/library/email.policy.rst:321

msgid ""

"If an implementation wishes to retain compatibility with the existing email "

"package policies, the *name* and *value* should be strings or string "

"subclasses that do not change the content of the passed in arguments."

msgstr ""

"Si una implementación desea retener compatibilidad con los *policy* del "

"paquete de correos electrónicos existentes, el *name* y *value* deben ser "

"cadenas de caracteres o subclases de cadenas que no cambien el contenido de "

"los pasados en los argumentos."

#: ../Doc/library/email.policy.rst:331

msgid ""

"The email package calls this method with the *name* and *value* currently "

"stored in the ``Message`` when that header is requested by the application "

"program, and whatever the method returns is what is passed back to the "

"application as the value of the header being retrieved. Note that there may "

"be more than one header with the same name stored in the ``Message``; the "

"method is passed the specific name and value of the header destined to be "

"returned to the application."

msgstr ""

"El paquete de correos electrónicos llama a este método con el *name* y "

"*valor* actualmente guardados en ``Message`` (el mensaje) cuando la cabecera "

"es solicitada por el programa de aplicación, y lo que sea que el método "

"retorne es lo que es pasado de vuelta a la aplicación como el valor de la "

"cabecera siendo recuperado. Note que puede haber más de una cabecera con el "

"mismo nombre guardado en ``Message``; el método es pasado al nombre "

"específico y valor de la cabecera destinado a ser retornado a la aplicación."

#: ../Doc/library/email.policy.rst:339

msgid ""

"*value* may contain surrogateescaped binary data. There should be no "

"surrogateescaped binary data in the value returned by the method."

msgstr ""

"*value* puede contener datos binarios *surrogateescaped*. No debe haber "

"datos binarios *surrogateescaped* en el valor retornado por el método."

#: ../Doc/library/email.policy.rst:347

msgid ""

"The email package calls this method with the *name* and *value* currently "

"stored in the ``Message`` for a given header. The method should return a "

"string that represents that header \"folded\" correctly (according to the "

"policy settings) by composing the *name* with the *value* and inserting :"

"attr:`linesep` characters at the appropriate places. See :rfc:`5322` for a "

"discussion of the rules for folding email headers."

msgstr ""

"El paquete de correos electrónicos llama a este método con los *name* y "

"*value* actualmente guardados en ``Message`` para una cabecera dada. El "

"método debe retornar una cadena de caracteres que represente esa cabecera "

"\"doblada\" correctamente (de acuerdo a los ajustes del *policy*) al "

"componer *name* con *value* e insertar caracteres :attr:`linesep` en los "

"lugares apropiados. Véase :rfc:`5322` para una discusión de las reglas para "

"doblar cabeceras de correos electrónicos."

#: ../Doc/library/email.policy.rst:354

msgid ""

"*value* may contain surrogateescaped binary data. There should be no "

"surrogateescaped binary data in the string returned by the method."

msgstr ""

"*value* puede contener datos binarios *surrogateescaped*. No debe haber "

"datos binarios *surrogateescaped* en la cadena de caracteres retornada por "

"el método."

#: ../Doc/library/email.policy.rst:360

msgid ""

"The same as :meth:`fold`, except that the returned value should be a bytes "

"object rather than a string."

msgstr ""

"Igual que :meth:`fold`, excepto que el valor retornado debe ser un objeto "

"bytes en vez de una cadena de caracteres."

#: ../Doc/library/email.policy.rst:363

msgid ""

"*value* may contain surrogateescaped binary data. These could be converted "

"back into binary data in the returned bytes object."

msgstr ""

"*value* puede contener datos binarios *surrogateescaped*. Estos pueden ser "

"convertidos de vuelta a datos binarios en el objeto de bytes retornado."

#: ../Doc/library/email.policy.rst:370

msgid ""

"This concrete :class:`Policy` provides behavior that is intended to be fully "

"compliant with the current email RFCs. These include (but are not limited "

"to) :rfc:`5322`, :rfc:`2047`, and the current MIME RFCs."

msgstr ""

"Este :class:`Policy` concreto proporciona el comportamiento que sirve para "

"cumplir con los RFCs actuales para correos electrónicos. Estos incluyen "

"(pero no están limitados a) :rfc:`5322`, :rfc:`2047`, y los actuales RFCs "

"MIME."

#: ../Doc/library/email.policy.rst:374

msgid ""

"This policy adds new header parsing and folding algorithms. Instead of "

"simple strings, headers are ``str`` subclasses with attributes that depend "

"on the type of the field. The parsing and folding algorithm fully "

"implement :rfc:`2047` and :rfc:`5322`."

msgstr ""

"Esta *policy* incorpora nuevos analizadores de cabeceras y algoritmos de "

"doblado. En vez de cadenas de caracteres simples, las cabeceras son "

"subclases de ``str`` con atributos que dependen del tipo del campo. El "

"analizado y algoritmo de doblado implementan los :rfc:`2047` y :rfc:`5322` "

"por completo."

#: ../Doc/library/email.policy.rst:379

msgid ""

"The default value for the :attr:`~email.policy.Policy.message_factory` "

"attribute is :class:`~email.message.EmailMessage`."

msgstr ""

"El valor por defecto para el atributo :attr:`~email.policy.Policy."

"message_factory` es :class:`~email.message.EmailMessage`."

#: ../Doc/library/email.policy.rst:382

msgid ""

"In addition to the settable attributes listed above that apply to all "

"policies, this policy adds the following additional attributes:"

msgstr ""

"Además de los atributos que se pueden configurar listados arriba que aplican "

"a todas los *policies*, este *policy* añade los siguientes atributos "

"adicionales:"

#: ../Doc/library/email.policy.rst:385

msgid "[1]_"

msgstr "[1]_"

#: ../Doc/library/email.policy.rst:390

msgid ""

"If ``False``, follow :rfc:`5322`, supporting non-ASCII characters in headers "

"by encoding them as \"encoded words\". If ``True``, follow :rfc:`6532` and "

"use ``utf-8`` encoding for headers. Messages formatted in this way may be "

"passed to SMTP servers that support the ``SMTPUTF8`` extension (:rfc:`6531`)."

msgstr ""

"Si es ``False``, se sigue el :rfc:`5322`, siendo compatible con caracteres "

"non-ASCII en las cabeceras al codificarlas como \"palabras codificadas\". "

"Si es ``True``, sigue el :rfc:`6532` y usa el formato de codificación "

"``utf-8`` para las cabeceras. Los mensajes formateados de esta manera puede "

"ser pasados a servidores SMTP que admitan la extensión ``SMTPUTF8`` (:rfc:"

"`6531`)."

#: ../Doc/library/email.policy.rst:399

msgid ""

"If the value for a header in the ``Message`` object originated from a :mod:"

"`~email.parser` (as opposed to being set by a program), this attribute "

"indicates whether or not a generator should refold that value when "

"transforming the message back into serialized form. The possible values are:"

msgstr ""

"Si el valor para una cabecera en el objeto ``Message`` se originó de un :mod:"

"`~email.parser` (en lugar de ser establecido por el programa), este atributo "

"indica tanto si un generador debe redoblar ese valor cuando se transforma al "

"mensaje de vuelta a la forma serializada o no. Los valores posibles son:"

#: ../Doc/library/email.policy.rst:406

msgid "``none``"

msgstr "``none``"

#: ../Doc/library/email.policy.rst:406

msgid "all source values use original folding"

msgstr "todos los valores de la fuente usan el doblamiento original"

#: ../Doc/library/email.policy.rst:408

msgid "``long``"

msgstr "``long``"

#: ../Doc/library/email.policy.rst:408

msgid ""

"source values that have any line that is longer than ``max_line_length`` "

"will be refolded"

msgstr ""

"los valores de la fuente que tengan una línea que sea más grande que "

"``max_line_length`` serán redoblados"

#: ../Doc/library/email.policy.rst:411

msgid "``all``"

msgstr "``all``"

#: ../Doc/library/email.policy.rst:411

msgid "all values are refolded."

msgstr "todos los valores son redoblados."

#: ../Doc/library/email.policy.rst:414

msgid "The default is ``long``."

msgstr "El valor por defecto es ``long``."

#: ../Doc/library/email.policy.rst:419

msgid ""

"A callable that takes two arguments, ``name`` and ``value``, where ``name`` "

"is a header field name and ``value`` is an unfolded header field value, and "

"returns a string subclass that represents that header. A default "

"``header_factory`` (see :mod:`~email.headerregistry`) is provided that "

"supports custom parsing for the various address and date :RFC:`5322` header "

"field types, and the major MIME header field stypes. Support for additional "

"custom parsing will be added in the future."

msgstr ""

"Un invocable que toma dos argumentos, ``name`` y ``value``, donde ``name`` "

"es un nombre de campo de cabecera y ``value`` es un valor del campo de la "

"cabecera no doblado, y retorna una subclase de cadenas de caracteres que "

"representan la cabecera. Un valor por defecto ``header_factory`` (véase :"

"mod:`~email.headerregistry`) es proporcionado que admite el análisis "

"personalizado para los varios tipos de cabecera :RFC:`5322` de direcciones y "

"fechas, y los tipos del cabeceras MIME principales. La compatibilidad de "

"analizadores personalizados adicionales será agregada en el futuro."

#: ../Doc/library/email.policy.rst:430

msgid ""

"An object with at least two methods: get_content and set_content. When the :"

"meth:`~email.message.EmailMessage.get_content` or :meth:`~email.message."

"EmailMessage.set_content` method of an :class:`~email.message.EmailMessage` "

"object is called, it calls the corresponding method of this object, passing "

"it the message object as its first argument, and any arguments or keywords "

"that were passed to it as additional arguments. By default "

"``content_manager`` is set to :data:`~email.contentmanager.raw_data_manager`."

msgstr ""

"Un objeto con al menos dos métodos: get_content and set_content. Cuando los "

"métodos :meth:`~email.message.EmailMessage.get_content` o :meth:`~email."

"message.EmailMessage.set_content` del objeto :class:`~email."

"messageEmailMessage` son llamados, llama al método correspondiente de este "

"objeto, pasándole el mensaje objeto como su primer argumento, y cualquier "

"argumento o palabra clave que fuese pasado como un argumento adicional. Por "

"defecto ``content_manager`` se pone a :data:`~email.contentmanager."

"raw_data_manager`."

#: ../Doc/library/email.policy.rst:442 ../Doc/library/email.policy.rst:600

msgid ""

"The class provides the following concrete implementations of the abstract "

"methods of :class:`Policy`:"

msgstr ""

"La clase proporciona las siguientes implementaciones concretas de los "

"métodos abstractos de :class:`Policy`:"

#: ../Doc/library/email.policy.rst:448

msgid ""

"Returns the value of the :attr:`~email.headerregistry.BaseHeader.max_count` "

"attribute of the specialized class used to represent the header with the "

"given name."

msgstr ""

"Retorna el valor del atributo :attr:`~email.headerregistry.BaseHeader."

"max_count` de la clase especializada usada para representar la cabecera con "

"el nombre dado."

#: ../Doc/library/email.policy.rst:456 ../Doc/library/email.policy.rst:606

msgid ""

"The name is parsed as everything up to the '``:``' and returned unmodified. "

"The value is determined by stripping leading whitespace off the remainder of "

"the first line, joining all subsequent lines together, and stripping any "

"trailing carriage return or linefeed characters."

msgstr ""

"El nombre es analizado como todo hasta el '``:``' y retornado inalterado. "

"El valor es determinado al remover los espacios en blanco al principio del "

"resto de la primera línea, juntando todas las subsecuentes líneas, y "

"removiendo cualquier carácter CR o LF."

#: ../Doc/library/email.policy.rst:464

msgid ""

"The name is returned unchanged. If the input value has a ``name`` attribute "

"and it matches *name* ignoring case, the value is returned unchanged. "

"Otherwise the *name* and *value* are passed to ``header_factory``, and the "

"resulting header object is returned as the value. In this case a "

"``ValueError`` is raised if the input value contains CR or LF characters."

msgstr ""

"El nombre es retornado inalterado. Si el valor de la entrada tiene un "

"atributo ``name`` y coincide con *name* ignorando mayúsculas y minúsculas, "

"el valor es retornado inalterado. Si no, el *name* y *value* son pasados a "

"``header_factory`` , y el objeto cabecera resultante es retornado como el "

"valor. En este caso un ``ValueError`` es lanzado si el valor de la entrada "

"contiene caracteres CR o LF."

#: ../Doc/library/email.policy.rst:474

msgid ""

"If the value has a ``name`` attribute, it is returned to unmodified. "

"Otherwise the *name*, and the *value* with any CR or LF characters removed, "

"are passed to the ``header_factory``, and the resulting header object is "

"returned. Any surrogateescaped bytes get turned into the unicode unknown-"

"character glyph."

msgstr ""

"Si el valor tiene un atributo ``name``, es retornado inalterado. De otra "

"manera el *name*, y el *value* con cualquier carácter CR o LF eliminado, son "

"pasados a la ``header_factory``, y el objeto cabecera resultante es "

"retornado. Cualquier byte *surrogateescaped* es convertido al glifo de "

"carácter desconocido de unicode."

#: ../Doc/library/email.policy.rst:483

msgid ""

"Header folding is controlled by the :attr:`refold_source` policy setting. A "

"value is considered to be a 'source value' if and only if it does not have a "

"``name`` attribute (having a ``name`` attribute means it is a header object "

"of some sort). If a source value needs to be refolded according to the "

"policy, it is converted into a header object by passing the *name* and the "

"*value* with any CR and LF characters removed to the ``header_factory``. "

"Folding of a header object is done by calling its ``fold`` method with the "

"current policy."

msgstr ""

"El doblamiento de la cabecera es controlado por la configuración de "

"*policy* :attr:`refold_source`. Se considera que un valor es `source value` "

"(valor fuente) si y sólo si no tiene un atributo ``name```(tener un atributo "

"``name`` significa que es un objeto cabecera de algún tipo). Si un valor "

"fuente necesita ser redoblado de acuerdo a la política, es convertido en un "

"objeto cabecera al pasarle el *name* y *value* con cualquier carácter CR y "

"LF eliminado al ``header_factory``. El doblamiento de un objeto cabecera es "

"hecho al llamar a su método ``fold`` con el *policy* actual."

#: ../Doc/library/email.policy.rst:492

msgid ""

"Source values are split into lines using :meth:`~str.splitlines`. If the "

"value is not to be refolded, the lines are rejoined using the ``linesep`` "

"from the policy and returned. The exception is lines containing non-ascii "

"binary data. In that case the value is refolded regardless of the "

"``refold_source`` setting, which causes the binary data to be CTE encoded "

"using the ``unknown-8bit`` charset."

msgstr ""

"Los valores fuente son separadas en líneas usando el método :meth:`~str."

"splitlines`. Si el valor no va a ser redoblado, las líneas son unidas de "

"nuevo usando el ``linesep`` del *policy* y retornadas. La excepción son las "

"líneas que contienen datos binarios non-ascii. En ese caso el valor es "

"redoblado a pesar de la configuración de ``refold_source``, que causa que "

"los datos binarios sean codificados CTE usando el juego de caracteres "

"(charset) ``unknown-8bit``."

#: ../Doc/library/email.policy.rst:502

msgid ""

"The same as :meth:`fold` if :attr:`~Policy.cte_type` is ``7bit``, except "

"that the returned value is bytes."

msgstr ""

"Igual que :meth:`fold` si :attr:`~Policy.cte_type` fuese ``7bit``, excepto "

"que el valor retornado son bytes."

#: ../Doc/library/email.policy.rst:505

msgid ""

"If :attr:`~Policy.cte_type` is ``8bit``, non-ASCII binary data is converted "

"back into bytes. Headers with binary data are not refolded, regardless of "

"the ``refold_header`` setting, since there is no way to know whether the "

"binary data consists of single byte characters or multibyte characters."

msgstr ""

"Si :attr:`~Policy.cte_type` es ``8bit``, los datos binarios non-ASCII son "

"convertidos de vuelta a bytes. Las cabeceras con datos binarios son "

"redoblados, sin considerar la configuración de ``refold_header``, ya que no "

"hay forma de saber si los datos binarios consisten en caracteres de un sólo "

"byte o caracteres con múltiples bytes."

#: ../Doc/library/email.policy.rst:512

msgid ""

"The following instances of :class:`EmailPolicy` provide defaults suitable "

"for specific application domains. Note that in the future the behavior of "

"these instances (in particular the ``HTTP`` instance) may be adjusted to "

"conform even more closely to the RFCs relevant to their domains."

msgstr ""

"Las siguientes instancias de :class:`EmailPolicy` proporcionan valores por "

"defecto apropiados para dominios de aplicaciones específicas. Note que en "

"el futuro el comportamiento de estas instancias (en particular la instancia "

"``HTTP``) puede ser ajustado para cumplir incluso más de cerca a los RFC "

"relevantes a sus dominios."

#: ../Doc/library/email.policy.rst:520

msgid ""

"An instance of ``EmailPolicy`` with all defaults unchanged. This policy "

"uses the standard Python ``\\n`` line endings rather than the RFC-correct ``"

"\\r\\n``."

msgstr ""

"Una instancia de ``EmailPolicy`` con todos los valores por defecto sin "

"cambiar. Este *policy* usa la terminación de línea ``\\n`` estándar de "

"Python en vez de correcto por el RFC ``\\r\\n``."

#: ../Doc/library/email.policy.rst:527

msgid ""

"Suitable for serializing messages in conformance with the email RFCs. Like "

"``default``, but with ``linesep`` set to ``\\r\\n``, which is RFC compliant."

msgstr ""

"Apropiado para la serialización de mensajes en cumplimiento con los RFC de "

"correos electrónicos. Como ``default``, pero con ``linesep`` puesto en ``\\r"

"\\n``, que es conforme con el RFC."

#: ../Doc/library/email.policy.rst:534

msgid ""

"The same as ``SMTP`` except that :attr:`~EmailPolicy.utf8` is ``True``. "

"Useful for serializing messages to a message store without using encoded "

"words in the headers. Should only be used for SMTP transmission if the "

"sender or recipient addresses have non-ASCII characters (the :meth:`smtplib."

"SMTP.send_message` method handles this automatically)."

msgstr ""

"Igual que ``SMTP`` excepto que :attr:`~EmailPolicy.utf8` es ``True``. Útil "

"para serializar mensajes a un almacén de mensajes sin usar palabras "

"codificadas en las cabeceras. Sólo debe ser utilizada para transmisiones "

"por SMTP si las direcciones del remitente o recipiente tienen caracteres non-"

"ASCII (el método :meth:`smtplib.SMTP.send_message` gestiona esto "

"automáticamente)."

#: ../Doc/library/email.policy.rst:543

msgid ""

"Suitable for serializing headers with for use in HTTP traffic. Like "

"``SMTP`` except that ``max_line_length`` is set to ``None`` (unlimited)."

msgstr ""

"Apropiado para serializar cabeceras con uso en tráfico de HTTP. Como "

"``SMTP`` excepto que ``max_line_length`` es puesto en ``None`` (ilimitado)."

#: ../Doc/library/email.policy.rst:549

msgid ""

"Convenience instance. The same as ``default`` except that "

"``raise_on_defect`` is set to ``True``. This allows any policy to be made "

"strict by writing::"

msgstr ""

"Instancias de conveniencia. Igual que ``default`` excepto que "

"``raise_of_defect`` es puesto en ``True``. Esto permite que cualquier "

"*policy* sea hecho estricto al escribir::"

#: ../Doc/library/email.policy.rst:556

msgid ""

"With all of these :class:`EmailPolicies <.EmailPolicy>`, the effective API "

"of the email package is changed from the Python 3.2 API in the following "

"ways:"

msgstr ""

"Con todos estos :class:`EmailPolicies <.EmailPolicy>`, el API efectivo del "

"paquete de correos electrónicos es cambiado del API de Python 3.2 en las "

"siguientes maneras:"

#: ../Doc/library/email.policy.rst:559

msgid ""

"Setting a header on a :class:`~email.message.Message` results in that header "

"being parsed and a header object created."

msgstr ""

"Estableciendo una cabecera en una :class:`~email.message.Message` resulta en "

"que la cabecera sea analizada y un objeto cabecera sea creado."

#: ../Doc/library/email.policy.rst:562

msgid ""

"Fetching a header value from a :class:`~email.message.Message` results in "

"that header being parsed and a header object created and returned."

msgstr ""

"Buscar una valor de cabecera de un :class:`~email.message.Message` resulta "

"en que la cabecera sea analizada y un objeto cabecera sea creado y retornado."

#: ../Doc/library/email.policy.rst:566

msgid ""

"Any header object, or any header that is refolded due to the policy "

"settings, is folded using an algorithm that fully implements the RFC folding "

"algorithms, including knowing where encoded words are required and allowed."

msgstr ""

"Cualquier objeto cabecera, o cualquier cabecera que sea redoblada debido a "

"las configuraciones del *policy*, es doblado usando un algoritmo que "

"implementa el algoritmo de doblado del RFC por completo, incluyendo saber "

"dónde las palabras codificadas son requeridas y permitidas."

#: ../Doc/library/email.policy.rst:571

msgid ""

"From the application view, this means that any header obtained through the :"

"class:`~email.message.EmailMessage` is a header object with extra "

"attributes, whose string value is the fully decoded unicode value of the "

"header. Likewise, a header may be assigned a new value, or a new header "

"created, using a unicode string, and the policy will take care of converting "

"the unicode string into the correct RFC encoded form."

msgstr ""

"Desde la vista de la aplicación, significa que cualquier cabecera obtenida a "

"través de :class:`~email.message.EmailMessage` es un objeto cabecera con "

"atributos extra, cuyo valor de cadena es el valor Unicode de la cabecera "

"completamente decodificada. Asimismo, se le puede asignar un nuevo valor a "

"una cabecera, o a una nueva cabecera creada, usando una cadena de caracteres "

"Unicode, y el *policy* se ocupará de convertir la cadena Unicode en la forma "

"decodificada correcta según el RFC."