forked from AFPy/python-docs-fr
377 lines
15 KiB
Plaintext
377 lines
15 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2020-10-01 16:00+0200\n"
|
||
"PO-Revision-Date: 2019-05-08 16:44+0200\n"
|
||
"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 2.2.1\n"
|
||
|
||
#: library/email.parser.rst:2
|
||
msgid ":mod:`email.parser`: Parsing email messages"
|
||
msgstr ":mod:`email.parser` : Analyser des e-mails"
|
||
|
||
#: library/email.parser.rst:7
|
||
msgid "**Source code:** :source:`Lib/email/parser.py`"
|
||
msgstr "**Code source :** :source:`Lib/email/parser.py`"
|
||
|
||
#: library/email.parser.rst:11
|
||
msgid ""
|
||
"Message object structures can be created in one of two ways: they can be "
|
||
"created from whole cloth by creating an :class:`~email.message.EmailMessage` "
|
||
"object, adding headers using the dictionary interface, and adding payload(s) "
|
||
"using :meth:`~email.message.EmailMessage.set_content` and related methods, "
|
||
"or they can be created by parsing a serialized representation of the email "
|
||
"message."
|
||
msgstr ""
|
||
"Les instances de messages peuvent être créées de deux façons : elles peuvent "
|
||
"être créées de toutes pièces en créant un objet :class:`~email.message."
|
||
"message.EmailMessage`, en ajoutant des en-têtes en utilisant l'interface de "
|
||
"dictionnaire, et en ajoutant un ou plusieurs corps de message en utilisant :"
|
||
"meth:`~email.message.message.EmailMessage.set_content` et les méthodes "
|
||
"associées, ou ils peuvent être créées en analysant une représentation "
|
||
"sérialisée de l'e-mail."
|
||
|
||
#: library/email.parser.rst:18
|
||
msgid ""
|
||
"The :mod:`email` package provides a standard parser that understands most "
|
||
"email document structures, including MIME documents. You can pass the "
|
||
"parser a bytes, string or file object, and the parser will return to you the "
|
||
"root :class:`~email.message.EmailMessage` instance of the object structure. "
|
||
"For simple, non-MIME messages the payload of this root object will likely be "
|
||
"a string containing the text of the message. For MIME messages, the root "
|
||
"object will return ``True`` from its :meth:`~email.message.EmailMessage."
|
||
"is_multipart` method, and the subparts can be accessed via the payload "
|
||
"manipulation methods, such as :meth:`~email.message.EmailMessage.get_body`, :"
|
||
"meth:`~email.message.EmailMessage.iter_parts`, and :meth:`~email.message."
|
||
"EmailMessage.walk`."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:30
|
||
msgid ""
|
||
"There are actually two parser interfaces available for use, the :class:"
|
||
"`Parser` API and the incremental :class:`FeedParser` API. The :class:"
|
||
"`Parser` API is most useful if you have the entire text of the message in "
|
||
"memory, or if the entire message lives in a file on the file system. :class:"
|
||
"`FeedParser` is more appropriate when you are reading the message from a "
|
||
"stream which might block waiting for more input (such as reading an email "
|
||
"message from a socket). The :class:`FeedParser` can consume and parse the "
|
||
"message incrementally, and only returns the root object when you close the "
|
||
"parser."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:39
|
||
msgid ""
|
||
"Note that the parser can be extended in limited ways, and of course you can "
|
||
"implement your own parser completely from scratch. All of the logic that "
|
||
"connects the :mod:`email` package's bundled parser and the :class:`~email."
|
||
"message.EmailMessage` class is embodied in the :mod:`policy` class, so a "
|
||
"custom parser can create message object trees any way it finds necessary by "
|
||
"implementing custom versions of the appropriate :mod:`policy` methods."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:49
|
||
msgid "FeedParser API"
|
||
msgstr "API *FeedParser*"
|
||
|
||
#: library/email.parser.rst:51
|
||
msgid ""
|
||
"The :class:`BytesFeedParser`, imported from the :mod:`email.feedparser` "
|
||
"module, provides an API that is conducive to incremental parsing of email "
|
||
"messages, such as would be necessary when reading the text of an email "
|
||
"message from a source that can block (such as a socket). The :class:"
|
||
"`BytesFeedParser` can of course be used to parse an email message fully "
|
||
"contained in a :term:`bytes-like object`, string, or file, but the :class:"
|
||
"`BytesParser` API may be more convenient for such use cases. The semantics "
|
||
"and results of the two parser APIs are identical."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:60
|
||
msgid ""
|
||
"The :class:`BytesFeedParser`'s API is simple; you create an instance, feed "
|
||
"it a bunch of bytes until there's no more to feed it, then close the parser "
|
||
"to retrieve the root message object. The :class:`BytesFeedParser` is "
|
||
"extremely accurate when parsing standards-compliant messages, and it does a "
|
||
"very good job of parsing non-compliant messages, providing information about "
|
||
"how a message was deemed broken. It will populate a message object's :attr:"
|
||
"`~email.message.EmailMessage.defects` attribute with a list of any problems "
|
||
"it found in a message. See the :mod:`email.errors` module for the list of "
|
||
"defects that it can find."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:70
|
||
msgid "Here is the API for the :class:`BytesFeedParser`:"
|
||
msgstr "Voici l’API pour :class:`BytesFeedParser` :"
|
||
|
||
#: library/email.parser.rst:75
|
||
msgid ""
|
||
"Create a :class:`BytesFeedParser` instance. Optional *_factory* is a no-"
|
||
"argument callable; if not specified use the :attr:`~email.policy.Policy."
|
||
"message_factory` from the *policy*. Call *_factory* whenever a new message "
|
||
"object is needed."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:80
|
||
msgid ""
|
||
"If *policy* is specified use the rules it specifies to update the "
|
||
"representation of the message. If *policy* is not set, use the :class:"
|
||
"`compat32 <email.policy.Compat32>` policy, which maintains backward "
|
||
"compatibility with the Python 3.2 version of the email package and provides :"
|
||
"class:`~email.message.Message` as the default factory. All other policies "
|
||
"provide :class:`~email.message.EmailMessage` as the default *_factory*. For "
|
||
"more information on what else *policy* controls, see the :mod:`~email."
|
||
"policy` documentation."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:145
|
||
msgid ""
|
||
"Note: **The policy keyword should always be specified**; The default will "
|
||
"change to :data:`email.policy.default` in a future version of Python."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:122
|
||
msgid "Added the *policy* keyword."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:95
|
||
msgid "*_factory* defaults to the policy ``message_factory``."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:100
|
||
msgid ""
|
||
"Feed the parser some more data. *data* should be a :term:`bytes-like "
|
||
"object` containing one or more lines. The lines can be partial and the "
|
||
"parser will stitch such partial lines together properly. The lines can have "
|
||
"any of the three common line endings: carriage return, newline, or carriage "
|
||
"return and newline (they can even be mixed)."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:109
|
||
msgid ""
|
||
"Complete the parsing of all previously fed data and return the root message "
|
||
"object. It is undefined what happens if :meth:`~feed` is called after this "
|
||
"method has been called."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:116
|
||
msgid ""
|
||
"Works like :class:`BytesFeedParser` except that the input to the :meth:"
|
||
"`~BytesFeedParser.feed` method must be a string. This is of limited "
|
||
"utility, since the only way for such a message to be valid is for it to "
|
||
"contain only ASCII text or, if :attr:`~email.policy.Policy.utf8` is "
|
||
"``True``, no binary attachments."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:126
|
||
msgid "Parser API"
|
||
msgstr "API de *Parser*"
|
||
|
||
#: library/email.parser.rst:128
|
||
msgid ""
|
||
"The :class:`BytesParser` class, imported from the :mod:`email.parser` "
|
||
"module, provides an API that can be used to parse a message when the "
|
||
"complete contents of the message are available in a :term:`bytes-like "
|
||
"object` or file. The :mod:`email.parser` module also provides :class:"
|
||
"`Parser` for parsing strings, and header-only parsers, :class:"
|
||
"`BytesHeaderParser` and :class:`HeaderParser`, which can be used if you're "
|
||
"only interested in the headers of the message. :class:`BytesHeaderParser` "
|
||
"and :class:`HeaderParser` can be much faster in these situations, since they "
|
||
"do not attempt to parse the message body, instead setting the payload to the "
|
||
"raw body."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:141
|
||
msgid ""
|
||
"Create a :class:`BytesParser` instance. The *_class* and *policy* arguments "
|
||
"have the same meaning and semantics as the *_factory* and *policy* arguments "
|
||
"of :class:`BytesFeedParser`."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:148
|
||
msgid ""
|
||
"Removed the *strict* argument that was deprecated in 2.4. Added the "
|
||
"*policy* keyword."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:200 library/email.parser.rst:280
|
||
msgid "*_class* defaults to the policy ``message_factory``."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:156
|
||
msgid ""
|
||
"Read all the data from the binary file-like object *fp*, parse the resulting "
|
||
"bytes, and return the message object. *fp* must support both the :meth:`~io."
|
||
"IOBase.readline` and the :meth:`~io.IOBase.read` methods."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:161
|
||
msgid ""
|
||
"The bytes contained in *fp* must be formatted as a block of :rfc:`5322` (or, "
|
||
"if :attr:`~email.policy.Policy.utf8` is ``True``, :rfc:`6532`) style headers "
|
||
"and header continuation lines, optionally preceded by an envelope header. "
|
||
"The header block is terminated either by the end of the data or by a blank "
|
||
"line. Following the header block is the body of the message (which may "
|
||
"contain MIME-encoded subparts, including subparts with a :mailheader:"
|
||
"`Content-Transfer-Encoding` of ``8bit``)."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:169
|
||
msgid ""
|
||
"Optional *headersonly* is a flag specifying whether to stop parsing after "
|
||
"reading the headers or not. The default is ``False``, meaning it parses the "
|
||
"entire contents of the file."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:176
|
||
msgid ""
|
||
"Similar to the :meth:`parse` method, except it takes a :term:`bytes-like "
|
||
"object` instead of a file-like object. Calling this method on a :term:"
|
||
"`bytes-like object` is equivalent to wrapping *bytes* in a :class:`~io."
|
||
"BytesIO` instance first and calling :meth:`parse`."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:221
|
||
msgid "Optional *headersonly* is as with the :meth:`parse` method."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:188
|
||
msgid ""
|
||
"Exactly like :class:`BytesParser`, except that *headersonly* defaults to "
|
||
"``True``."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:196
|
||
msgid ""
|
||
"This class is parallel to :class:`BytesParser`, but handles string input."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:245 library/email.parser.rst:268
|
||
#: library/email.parser.rst:278
|
||
msgid "Removed the *strict* argument. Added the *policy* keyword."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:205
|
||
msgid ""
|
||
"Read all the data from the text-mode file-like object *fp*, parse the "
|
||
"resulting text, and return the root message object. *fp* must support both "
|
||
"the :meth:`~io.TextIOBase.readline` and the :meth:`~io.TextIOBase.read` "
|
||
"methods on file-like objects."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:210
|
||
msgid ""
|
||
"Other than the text mode requirement, this method operates like :meth:"
|
||
"`BytesParser.parse`."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:216
|
||
msgid ""
|
||
"Similar to the :meth:`parse` method, except it takes a string object instead "
|
||
"of a file-like object. Calling this method on a string is equivalent to "
|
||
"wrapping *text* in a :class:`~io.StringIO` instance first and calling :meth:"
|
||
"`parse`."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:226
|
||
msgid ""
|
||
"Exactly like :class:`Parser`, except that *headersonly* defaults to ``True``."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:230
|
||
msgid ""
|
||
"Since creating a message object structure from a string or a file object is "
|
||
"such a common task, four functions are provided as a convenience. They are "
|
||
"available in the top-level :mod:`email` package namespace."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:239
|
||
msgid ""
|
||
"Return a message object structure from a :term:`bytes-like object`. This is "
|
||
"equivalent to ``BytesParser().parsebytes(s)``. Optional *_class* and "
|
||
"*policy* are interpreted as with the :class:`~email.parser.BytesParser` "
|
||
"class constructor."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:252
|
||
msgid ""
|
||
"Return a message object structure tree from an open binary :term:`file "
|
||
"object`. This is equivalent to ``BytesParser().parse(fp)``. *_class* and "
|
||
"*policy* are interpreted as with the :class:`~email.parser.BytesParser` "
|
||
"class constructor."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:264
|
||
msgid ""
|
||
"Return a message object structure from a string. This is equivalent to "
|
||
"``Parser().parsestr(s)``. *_class* and *policy* are interpreted as with "
|
||
"the :class:`~email.parser.Parser` class constructor."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:274
|
||
msgid ""
|
||
"Return a message object structure tree from an open :term:`file object`. "
|
||
"This is equivalent to ``Parser().parse(fp)``. *_class* and *policy* are "
|
||
"interpreted as with the :class:`~email.parser.Parser` class constructor."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:283
|
||
msgid ""
|
||
"Here's an example of how you might use :func:`message_from_bytes` at an "
|
||
"interactive Python prompt::"
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:291
|
||
msgid "Additional notes"
|
||
msgstr "Notes complémentaires"
|
||
|
||
#: library/email.parser.rst:293
|
||
msgid "Here are some notes on the parsing semantics:"
|
||
msgstr "Voici des remarques sur la sémantique d'analyse :"
|
||
|
||
#: library/email.parser.rst:295
|
||
msgid ""
|
||
"Most non-\\ :mimetype:`multipart` type messages are parsed as a single "
|
||
"message object with a string payload. These objects will return ``False`` "
|
||
"for :meth:`~email.message.EmailMessage.is_multipart`, and :meth:`~email."
|
||
"message.EmailMessage.iter_parts` will yield an empty list."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:300
|
||
msgid ""
|
||
"All :mimetype:`multipart` type messages will be parsed as a container "
|
||
"message object with a list of sub-message objects for their payload. The "
|
||
"outer container message will return ``True`` for :meth:`~email.message."
|
||
"EmailMessage.is_multipart`, and :meth:`~email.message.EmailMessage."
|
||
"iter_parts` will yield a list of subparts."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:306
|
||
msgid ""
|
||
"Most messages with a content type of :mimetype:`message/\\*` (such as :"
|
||
"mimetype:`message/delivery-status` and :mimetype:`message/rfc822`) will also "
|
||
"be parsed as container object containing a list payload of length 1. Their :"
|
||
"meth:`~email.message.EmailMessage.is_multipart` method will return ``True``. "
|
||
"The single element yielded by :meth:`~email.message.EmailMessage.iter_parts` "
|
||
"will be a sub-message object."
|
||
msgstr ""
|
||
|
||
#: library/email.parser.rst:313
|
||
msgid ""
|
||
"Some non-standards-compliant messages may not be internally consistent about "
|
||
"their :mimetype:`multipart`\\ -edness. Such messages may have a :mailheader:"
|
||
"`Content-Type` header of type :mimetype:`multipart`, but their :meth:`~email."
|
||
"message.EmailMessage.is_multipart` method may return ``False``. If such "
|
||
"messages were parsed with the :class:`~email.parser.FeedParser`, they will "
|
||
"have an instance of the :class:`~email.errors."
|
||
"MultipartInvariantViolationDefect` class in their *defects* attribute list. "
|
||
"See :mod:`email.errors` for details."
|
||
msgstr ""
|