forked from AFPy/python-docs-fr
1037 lines
40 KiB
Plaintext
1037 lines
40 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 1990-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 2.7\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/library/pickle.rst:2
|
||
msgid ":mod:`pickle` --- Python object serialization"
|
||
msgstr ":mod:`pickle` --- Module de sérialisation d'objets Python"
|
||
|
||
#: ../Doc/library/pickle.rst:17
|
||
msgid ""
|
||
"The :mod:`pickle` module implements a fundamental, but powerful algorithm "
|
||
"for serializing and de-serializing a Python object structure. \"Pickling\" "
|
||
"is the process whereby a Python object hierarchy is converted into a byte "
|
||
"stream, and \"unpickling\" is the inverse operation, whereby a byte stream "
|
||
"is converted back into an object hierarchy. Pickling (and unpickling) is "
|
||
"alternatively known as \"serialization\", \"marshalling,\" [#]_ or "
|
||
"\"flattening\", however, to avoid confusion, the terms used here are "
|
||
"\"pickling\" and \"unpickling\"."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:25
|
||
msgid ""
|
||
"This documentation describes both the :mod:`pickle` module and the :mod:"
|
||
"`cPickle` module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:30
|
||
msgid ""
|
||
"The :mod:`pickle` module is not secure against erroneous or maliciously "
|
||
"constructed data. Never unpickle data received from an untrusted or "
|
||
"unauthenticated source."
|
||
msgstr ""
|
||
"Le module :mod:`pickle` n'est pas sécurisé contre les données erronées et "
|
||
"malicieusement construites. Ne jamais *unpickle* la donnée reçue à partir "
|
||
"d'une source non fiable ou non authentifiée."
|
||
|
||
#: ../Doc/library/pickle.rst:36
|
||
msgid "Relationship to other Python modules"
|
||
msgstr "Relations aux autres modules python"
|
||
|
||
#: ../Doc/library/pickle.rst:38
|
||
msgid ""
|
||
"The :mod:`pickle` module has an optimized cousin called the :mod:`cPickle` "
|
||
"module. As its name implies, :mod:`cPickle` is written in C, so it can be "
|
||
"up to 1000 times faster than :mod:`pickle`. However it does not support "
|
||
"subclassing of the :func:`Pickler` and :func:`Unpickler` classes, because "
|
||
"in :mod:`cPickle` these are functions, not classes. Most applications have "
|
||
"no need for this functionality, and can benefit from the improved "
|
||
"performance of :mod:`cPickle`. Other than that, the interfaces of the two "
|
||
"modules are nearly identical; the common interface is described in this "
|
||
"manual and differences are pointed out where necessary. In the following "
|
||
"discussions, we use the term \"pickle\" to collectively describe the :mod:"
|
||
"`pickle` and :mod:`cPickle` modules."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:49
|
||
msgid ""
|
||
"The data streams the two modules produce are guaranteed to be "
|
||
"interchangeable."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:51
|
||
msgid ""
|
||
"Python has a more primitive serialization module called :mod:`marshal`, but "
|
||
"in general :mod:`pickle` should always be the preferred way to serialize "
|
||
"Python objects. :mod:`marshal` exists primarily to support Python's :file:`."
|
||
"pyc` files."
|
||
msgstr ""
|
||
"Python possède un module de bas niveau en sérialisation appelé :mod:"
|
||
"`marshal`, mais en général il est préférable d'utiliser :mod:`pickle` pour "
|
||
"sérialiser des objets Python. :mod:`marshal` existe principalement pour "
|
||
"gérer les fichiers Python en :file:`.pyc`."
|
||
|
||
#: ../Doc/library/pickle.rst:56
|
||
msgid ""
|
||
"The :mod:`pickle` module differs from :mod:`marshal` in several significant "
|
||
"ways:"
|
||
msgstr ""
|
||
"Le module :mod:`pickle` diffère du module :mod:`marshal` sur plusieurs "
|
||
"aspects :"
|
||
|
||
#: ../Doc/library/pickle.rst:58
|
||
msgid ""
|
||
"The :mod:`pickle` module keeps track of the objects it has already "
|
||
"serialized, so that later references to the same object won't be serialized "
|
||
"again. :mod:`marshal` doesn't do this."
|
||
msgstr ""
|
||
"Le module :mod:`pickle` garde la trace des objets qu'il a déjà sérialisés, "
|
||
"pour faire en sorte que les prochaines références à cet objet ne soient pas "
|
||
"sérialisées à nouveau. :mod:`marshal` ne le fait pas."
|
||
|
||
#: ../Doc/library/pickle.rst:62
|
||
msgid ""
|
||
"This has implications both for recursive objects and object sharing. "
|
||
"Recursive objects are objects that contain references to themselves. These "
|
||
"are not handled by marshal, and in fact, attempting to marshal recursive "
|
||
"objects will crash your Python interpreter. Object sharing happens when "
|
||
"there are multiple references to the same object in different places in the "
|
||
"object hierarchy being serialized. :mod:`pickle` stores such objects only "
|
||
"once, and ensures that all other references point to the master copy. "
|
||
"Shared objects remain shared, which can be very important for mutable "
|
||
"objects."
|
||
msgstr ""
|
||
"Ça a des implications sur les objets partagés et les objets récursifs. Les "
|
||
"objets récursifs sont des objets qui contiennent des références à eux-mêmes. "
|
||
"Ceux-ci ne sont pas gérées par marshal : lui donner un objet récursif va le "
|
||
"faire planter. Un objet est partagé lorsque que plusieurs références "
|
||
"pointent dessus, depuis différents endroits dans la hiérarchie sérialisée. "
|
||
"Le module :mod:`pickle` repère ces partages et ne stocke ces objets qu'une "
|
||
"seule fois. Les objets partagés restent ainsi partagés, ce qui peut être "
|
||
"très important pour les objets muables."
|
||
|
||
#: ../Doc/library/pickle.rst:71
|
||
msgid ""
|
||
":mod:`marshal` cannot be used to serialize user-defined classes and their "
|
||
"instances. :mod:`pickle` can save and restore class instances "
|
||
"transparently, however the class definition must be importable and live in "
|
||
"the same module as when the object was stored."
|
||
msgstr ""
|
||
":mod:`marshal` ne peut être utilisé pour la sérialisation et l'instanciation "
|
||
"de classes définies par les utilisateurs. :mod:`pickle` peut sauvegarder et "
|
||
"restaurer les instances de classes de manière transparente. Cependant la "
|
||
"définition de classe doit être importable et lancée dans le même module et "
|
||
"de la même manière que lors de son importation."
|
||
|
||
#: ../Doc/library/pickle.rst:76
|
||
msgid ""
|
||
"The :mod:`marshal` serialization format is not guaranteed to be portable "
|
||
"across Python versions. Because its primary job in life is to support :file:"
|
||
"`.pyc` files, the Python implementers reserve the right to change the "
|
||
"serialization format in non-backwards compatible ways should the need arise. "
|
||
"The :mod:`pickle` serialization format is guaranteed to be backwards "
|
||
"compatible across Python releases."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:83
|
||
msgid ""
|
||
"Note that serialization is a more primitive notion than persistence; "
|
||
"although :mod:`pickle` reads and writes file objects, it does not handle the "
|
||
"issue of naming persistent objects, nor the (even more complicated) issue of "
|
||
"concurrent access to persistent objects. The :mod:`pickle` module can "
|
||
"transform a complex object into a byte stream and it can transform the byte "
|
||
"stream into an object with the same internal structure. Perhaps the most "
|
||
"obvious thing to do with these byte streams is to write them onto a file, "
|
||
"but it is also conceivable to send them across a network or store them in a "
|
||
"database. The module :mod:`shelve` provides a simple interface to pickle "
|
||
"and unpickle objects on DBM-style database files."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:96
|
||
msgid "Data stream format"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:102
|
||
msgid ""
|
||
"The data format used by :mod:`pickle` is Python-specific. This has the "
|
||
"advantage that there are no restrictions imposed by external standards such "
|
||
"as XDR (which can't represent pointer sharing); however it means that non-"
|
||
"Python programs may not be able to reconstruct pickled Python objects."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:107
|
||
msgid ""
|
||
"By default, the :mod:`pickle` data format uses a printable ASCII "
|
||
"representation. This is slightly more voluminous than a binary "
|
||
"representation. The big advantage of using printable ASCII (and of some "
|
||
"other characteristics of :mod:`pickle`'s representation) is that for "
|
||
"debugging or recovery purposes it is possible for a human to read the "
|
||
"pickled file with a standard text editor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:113
|
||
msgid ""
|
||
"There are currently 3 different protocols which can be used for pickling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:115
|
||
msgid ""
|
||
"Protocol version 0 is the original ASCII protocol and is backwards "
|
||
"compatible with earlier versions of Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:118
|
||
msgid ""
|
||
"Protocol version 1 is the old binary format which is also compatible with "
|
||
"earlier versions of Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:121
|
||
msgid ""
|
||
"Protocol version 2 was introduced in Python 2.3. It provides much more "
|
||
"efficient pickling of :term:`new-style class`\\es."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:124
|
||
msgid "Refer to :pep:`307` for more information."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:126
|
||
msgid ""
|
||
"If a *protocol* is not specified, protocol 0 is used. If *protocol* is "
|
||
"specified as a negative value or :const:`HIGHEST_PROTOCOL`, the highest "
|
||
"protocol version available will be used."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:130 ../Doc/library/pickle.rst:176
|
||
#: ../Doc/library/pickle.rst:252
|
||
msgid "Introduced the *protocol* parameter."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:133
|
||
msgid ""
|
||
"A binary format, which is slightly more efficient, can be chosen by "
|
||
"specifying a *protocol* version >= 1."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:138
|
||
msgid "Usage"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:140
|
||
msgid ""
|
||
"To serialize an object hierarchy, you first create a pickler, then you call "
|
||
"the pickler's :meth:`dump` method. To de-serialize a data stream, you first "
|
||
"create an unpickler, then you call the unpickler's :meth:`load` method. "
|
||
"The :mod:`pickle` module provides the following constant:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:148
|
||
msgid ""
|
||
"The highest protocol version available. This value can be passed as a "
|
||
"*protocol* value."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:155
|
||
msgid ""
|
||
"Be sure to always open pickle files created with protocols >= 1 in binary "
|
||
"mode. For the old ASCII-based pickle protocol 0 you can use either text mode "
|
||
"or binary mode as long as you stay consistent."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:159
|
||
msgid ""
|
||
"A pickle file written with protocol 0 in binary mode will contain lone "
|
||
"linefeeds as line terminators and therefore will look \"funny\" when viewed "
|
||
"in Notepad or other editors which do not support this format."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:163
|
||
msgid ""
|
||
"The :mod:`pickle` module provides the following functions to make the "
|
||
"pickling process more convenient:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:169
|
||
msgid ""
|
||
"Write a pickled representation of *obj* to the open file object *file*. "
|
||
"This is equivalent to ``Pickler(file, protocol).dump(obj)``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:172 ../Doc/library/pickle.rst:205
|
||
#: ../Doc/library/pickle.rst:248
|
||
msgid ""
|
||
"If the *protocol* parameter is omitted, protocol 0 is used. If *protocol* is "
|
||
"specified as a negative value or :const:`HIGHEST_PROTOCOL`, the highest "
|
||
"protocol version will be used."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:179
|
||
msgid ""
|
||
"*file* must have a :meth:`write` method that accepts a single string "
|
||
"argument. It can thus be a file object opened for writing, a :mod:`StringIO` "
|
||
"object, or any other custom object that meets this interface."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:186
|
||
msgid ""
|
||
"Read a string from the open file object *file* and interpret it as a pickle "
|
||
"data stream, reconstructing and returning the original object hierarchy. "
|
||
"This is equivalent to ``Unpickler(file).load()``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:190 ../Doc/library/pickle.rst:304
|
||
msgid ""
|
||
"*file* must have two methods, a :meth:`read` method that takes an integer "
|
||
"argument, and a :meth:`readline` method that requires no arguments. Both "
|
||
"methods should return a string. Thus *file* can be a file object opened for "
|
||
"reading, a :mod:`StringIO` object, or any other custom object that meets "
|
||
"this interface."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:196
|
||
msgid ""
|
||
"This function automatically determines whether the data stream was written "
|
||
"in binary mode or not."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:202
|
||
msgid ""
|
||
"Return the pickled representation of the object as a string, instead of "
|
||
"writing it to a file."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:209
|
||
msgid "The *protocol* parameter was added."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:215
|
||
msgid ""
|
||
"Read a pickled object hierarchy from a string. Characters in the string "
|
||
"past the pickled object's representation are ignored."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:218
|
||
msgid "The :mod:`pickle` module also defines three exceptions:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:223
|
||
msgid ""
|
||
"A common base class for the other exceptions defined below. This inherits "
|
||
"from :exc:`Exception`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:229
|
||
msgid ""
|
||
"This exception is raised when an unpicklable object is passed to the :meth:"
|
||
"`dump` method."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:235
|
||
msgid ""
|
||
"This exception is raised when there is a problem unpickling an object. Note "
|
||
"that other exceptions may also be raised during unpickling, including (but "
|
||
"not necessarily limited to) :exc:`AttributeError`, :exc:`EOFError`, :exc:"
|
||
"`ImportError`, and :exc:`IndexError`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:240
|
||
msgid ""
|
||
"The :mod:`pickle` module also exports two callables [#]_, :class:`Pickler` "
|
||
"and :class:`Unpickler`:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:246
|
||
msgid ""
|
||
"This takes a file-like object to which it will write a pickle data stream."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:255
|
||
msgid ""
|
||
"*file* must have a :meth:`write` method that accepts a single string "
|
||
"argument. It can thus be an open file object, a :mod:`StringIO` object, or "
|
||
"any other custom object that meets this interface."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:259
|
||
msgid ":class:`Pickler` objects define one (or two) public methods:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:264
|
||
msgid ""
|
||
"Write a pickled representation of *obj* to the open file object given in the "
|
||
"constructor. Either the binary or ASCII format will be used, depending on "
|
||
"the value of the *protocol* argument passed to the constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:271
|
||
msgid ""
|
||
"Clears the pickler's \"memo\". The memo is the data structure that "
|
||
"remembers which objects the pickler has already seen, so that shared or "
|
||
"recursive objects pickled by reference and not by value. This method is "
|
||
"useful when re-using picklers."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:278
|
||
msgid ""
|
||
"Prior to Python 2.3, :meth:`clear_memo` was only available on the picklers "
|
||
"created by :mod:`cPickle`. In the :mod:`pickle` module, picklers have an "
|
||
"instance variable called :attr:`memo` which is a Python dictionary. So to "
|
||
"clear the memo for a :mod:`pickle` module pickler, you could do the "
|
||
"following::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:285
|
||
msgid ""
|
||
"Code that does not need to support older versions of Python should simply "
|
||
"use :meth:`clear_memo`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:288
|
||
msgid ""
|
||
"It is possible to make multiple calls to the :meth:`dump` method of the "
|
||
"same :class:`Pickler` instance. These must then be matched to the same "
|
||
"number of calls to the :meth:`load` method of the corresponding :class:"
|
||
"`Unpickler` instance. If the same object is pickled by multiple :meth:"
|
||
"`dump` calls, the :meth:`load` will all yield references to the same object. "
|
||
"[#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:294
|
||
msgid ":class:`Unpickler` objects are defined as:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:299
|
||
msgid ""
|
||
"This takes a file-like object from which it will read a pickle data stream. "
|
||
"This class automatically determines whether the data stream was written in "
|
||
"binary mode or not, so it does not need a flag as in the :class:`Pickler` "
|
||
"factory."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:310
|
||
msgid ":class:`Unpickler` objects have one (or two) public methods:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:315
|
||
msgid ""
|
||
"Read a pickled object representation from the open file object given in the "
|
||
"constructor, and return the reconstituted object hierarchy specified therein."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:319
|
||
msgid ""
|
||
"This method automatically determines whether the data stream was written in "
|
||
"binary mode or not."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:325
|
||
msgid ""
|
||
"This is just like :meth:`load` except that it doesn't actually create any "
|
||
"objects. This is useful primarily for finding what's called \"persistent ids"
|
||
"\" that may be referenced in a pickle data stream. See section :ref:`pickle-"
|
||
"protocol` below for more details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:330
|
||
msgid ""
|
||
"**Note:** the :meth:`noload` method is currently only available on :class:"
|
||
"`Unpickler` objects created with the :mod:`cPickle` module. :mod:`pickle` "
|
||
"module :class:`Unpickler`\\ s do not have the :meth:`noload` method."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:337
|
||
msgid "What can be pickled and unpickled?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:339
|
||
msgid "The following types can be pickled:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:341
|
||
msgid "``None``, ``True``, and ``False``"
|
||
msgstr "``None``, ``True``, and ``False``"
|
||
|
||
#: ../Doc/library/pickle.rst:343
|
||
msgid "integers, long integers, floating point numbers, complex numbers"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:345
|
||
msgid "normal and Unicode strings"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:347
|
||
msgid "tuples, lists, sets, and dictionaries containing only picklable objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:349
|
||
msgid "functions defined at the top level of a module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:351
|
||
msgid "built-in functions defined at the top level of a module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:353
|
||
msgid "classes that are defined at the top level of a module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:355
|
||
msgid ""
|
||
"instances of such classes whose :attr:`~object.__dict__` or the result of "
|
||
"calling :meth:`__getstate__` is picklable (see section :ref:`pickle-"
|
||
"protocol` for details)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:359
|
||
msgid ""
|
||
"Attempts to pickle unpicklable objects will raise the :exc:`PicklingError` "
|
||
"exception; when this happens, an unspecified number of bytes may have "
|
||
"already been written to the underlying file. Trying to pickle a highly "
|
||
"recursive data structure may exceed the maximum recursion depth, a :exc:"
|
||
"`RuntimeError` will be raised in this case. You can carefully raise this "
|
||
"limit with :func:`sys.setrecursionlimit`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:366
|
||
msgid ""
|
||
"Note that functions (built-in and user-defined) are pickled by \"fully "
|
||
"qualified\" name reference, not by value. This means that only the function "
|
||
"name is pickled, along with the name of the module the function is defined "
|
||
"in. Neither the function's code, nor any of its function attributes are "
|
||
"pickled. Thus the defining module must be importable in the unpickling "
|
||
"environment, and the module must contain the named object, otherwise an "
|
||
"exception will be raised. [#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:373
|
||
msgid ""
|
||
"Similarly, classes are pickled by named reference, so the same restrictions "
|
||
"in the unpickling environment apply. Note that none of the class's code or "
|
||
"data is pickled, so in the following example the class attribute ``attr`` is "
|
||
"not restored in the unpickling environment::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:383
|
||
msgid ""
|
||
"These restrictions are why picklable functions and classes must be defined "
|
||
"in the top level of a module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:386
|
||
msgid ""
|
||
"Similarly, when class instances are pickled, their class's code and data are "
|
||
"not pickled along with them. Only the instance data are pickled. This is "
|
||
"done on purpose, so you can fix bugs in a class or add methods to the class "
|
||
"and still load objects that were created with an earlier version of the "
|
||
"class. If you plan to have long-lived objects that will see many versions "
|
||
"of a class, it may be worthwhile to put a version number in the objects so "
|
||
"that suitable conversions can be made by the class's :meth:`__setstate__` "
|
||
"method."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:398
|
||
msgid "The pickle protocol"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:402
|
||
msgid ""
|
||
"This section describes the \"pickling protocol\" that defines the interface "
|
||
"between the pickler/unpickler and the objects that are being serialized. "
|
||
"This protocol provides a standard way for you to define, customize, and "
|
||
"control how your objects are serialized and de-serialized. The description "
|
||
"in this section doesn't cover specific customizations that you can employ to "
|
||
"make the unpickling environment slightly safer from untrusted pickle data "
|
||
"streams; see section :ref:`pickle-sub` for more details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:414
|
||
msgid "Pickling and unpickling normal class instances"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:418
|
||
msgid ""
|
||
"When a pickled class instance is unpickled, its :meth:`__init__` method is "
|
||
"normally *not* invoked. If it is desirable that the :meth:`__init__` method "
|
||
"be called on unpickling, an old-style class can define a method :meth:"
|
||
"`__getinitargs__`, which should return a *tuple* containing the arguments to "
|
||
"be passed to the class constructor (:meth:`__init__` for example). The :"
|
||
"meth:`__getinitargs__` method is called at pickle time; the tuple it returns "
|
||
"is incorporated in the pickle for the instance."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:428
|
||
msgid ""
|
||
"New-style types can provide a :meth:`__getnewargs__` method that is used for "
|
||
"protocol 2. Implementing this method is needed if the type establishes some "
|
||
"internal invariants when the instance is created, or if the memory "
|
||
"allocation is affected by the values passed to the :meth:`__new__` method "
|
||
"for the type (as it is for tuples and strings). Instances of a :term:`new-"
|
||
"style class` ``C`` are created using ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:437
|
||
msgid ""
|
||
"where *args* is the result of calling :meth:`__getnewargs__` on the original "
|
||
"object; if there is no :meth:`__getnewargs__`, an empty tuple is assumed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:442
|
||
msgid ""
|
||
"Classes can further influence how their instances are pickled; if the class "
|
||
"defines the method :meth:`__getstate__`, it is called and the return state "
|
||
"is pickled as the contents for the instance, instead of the contents of the "
|
||
"instance's dictionary. If there is no :meth:`__getstate__` method, the "
|
||
"instance's :attr:`~object.__dict__` is pickled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:450
|
||
msgid ""
|
||
"Upon unpickling, if the class also defines the method :meth:`__setstate__`, "
|
||
"it is called with the unpickled state. [#]_ If there is no :meth:"
|
||
"`__setstate__` method, the pickled state must be a dictionary and its items "
|
||
"are assigned to the new instance's dictionary. If a class defines both :"
|
||
"meth:`__getstate__` and :meth:`__setstate__`, the state object needn't be a "
|
||
"dictionary and these methods can do what they want. [#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:459
|
||
msgid ""
|
||
"For :term:`new-style class`\\es, if :meth:`__getstate__` returns a false "
|
||
"value, the :meth:`__setstate__` method will not be called."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:464
|
||
msgid ""
|
||
"At unpickling time, some methods like :meth:`__getattr__`, :meth:"
|
||
"`__getattribute__`, or :meth:`__setattr__` may be called upon the instance. "
|
||
"In case those methods rely on some internal invariant being true, the type "
|
||
"should implement either :meth:`__getinitargs__` or :meth:`__getnewargs__` to "
|
||
"establish such an invariant; otherwise, neither :meth:`__new__` nor :meth:"
|
||
"`__init__` will be called."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:473
|
||
msgid "Pickling and unpickling extension types"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:477
|
||
msgid ""
|
||
"When the :class:`Pickler` encounters an object of a type it knows nothing "
|
||
"about --- such as an extension type --- it looks in two places for a hint of "
|
||
"how to pickle it. One alternative is for the object to implement a :meth:"
|
||
"`__reduce__` method. If provided, at pickling time :meth:`__reduce__` will "
|
||
"be called with no arguments, and it must return either a string or a tuple."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:484
|
||
msgid ""
|
||
"If a string is returned, it names a global variable whose contents are "
|
||
"pickled as normal. The string returned by :meth:`__reduce__` should be the "
|
||
"object's local name relative to its module; the pickle module searches the "
|
||
"module namespace to determine the object's module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:489
|
||
msgid ""
|
||
"When a tuple is returned, it must be between two and five elements long. "
|
||
"Optional elements can either be omitted, or ``None`` can be provided as "
|
||
"their value. The contents of this tuple are pickled as normal and used to "
|
||
"reconstruct the object at unpickling time. The semantics of each element "
|
||
"are:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:495
|
||
msgid ""
|
||
"A callable object that will be called to create the initial version of the "
|
||
"object. The next element of the tuple will provide arguments for this "
|
||
"callable, and later elements provide additional state information that will "
|
||
"subsequently be used to fully reconstruct the pickled data."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:500
|
||
msgid ""
|
||
"In the unpickling environment this object must be either a class, a callable "
|
||
"registered as a \"safe constructor\" (see below), or it must have an "
|
||
"attribute :attr:`__safe_for_unpickling__` with a true value. Otherwise, an :"
|
||
"exc:`UnpicklingError` will be raised in the unpickling environment. Note "
|
||
"that as usual, the callable itself is pickled by name."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:506
|
||
msgid "A tuple of arguments for the callable object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:508
|
||
msgid "Formerly, this argument could also be ``None``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:511
|
||
msgid ""
|
||
"Optionally, the object's state, which will be passed to the object's :meth:"
|
||
"`__setstate__` method as described in section :ref:`pickle-inst`. If the "
|
||
"object has no :meth:`__setstate__` method, then, as above, the value must be "
|
||
"a dictionary and it will be added to the object's :attr:`~object.__dict__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:517
|
||
msgid ""
|
||
"Optionally, an iterator (and not a sequence) yielding successive list "
|
||
"items. These list items will be pickled, and appended to the object using "
|
||
"either ``obj.append(item)`` or ``obj.extend(list_of_items)``. This is "
|
||
"primarily used for list subclasses, but may be used by other classes as long "
|
||
"as they have :meth:`append` and :meth:`extend` methods with the appropriate "
|
||
"signature. (Whether :meth:`append` or :meth:`extend` is used depends on "
|
||
"which pickle protocol version is used as well as the number of items to "
|
||
"append, so both must be supported.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:526
|
||
msgid ""
|
||
"Optionally, an iterator (not a sequence) yielding successive dictionary "
|
||
"items, which should be tuples of the form ``(key, value)``. These items "
|
||
"will be pickled and stored to the object using ``obj[key] = value``. This is "
|
||
"primarily used for dictionary subclasses, but may be used by other classes "
|
||
"as long as they implement :meth:`__setitem__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:534
|
||
msgid ""
|
||
"It is sometimes useful to know the protocol version when implementing :meth:"
|
||
"`__reduce__`. This can be done by implementing a method named :meth:"
|
||
"`__reduce_ex__` instead of :meth:`__reduce__`. :meth:`__reduce_ex__`, when "
|
||
"it exists, is called in preference over :meth:`__reduce__` (you may still "
|
||
"provide :meth:`__reduce__` for backwards compatibility). The :meth:"
|
||
"`__reduce_ex__` method will be called with a single integer argument, the "
|
||
"protocol version."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:542
|
||
msgid ""
|
||
"The :class:`object` class implements both :meth:`__reduce__` and :meth:"
|
||
"`__reduce_ex__`; however, if a subclass overrides :meth:`__reduce__` but "
|
||
"not :meth:`__reduce_ex__`, the :meth:`__reduce_ex__` implementation detects "
|
||
"this and calls :meth:`__reduce__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:547
|
||
msgid ""
|
||
"An alternative to implementing a :meth:`__reduce__` method on the object to "
|
||
"be pickled, is to register the callable with the :mod:`copy_reg` module. "
|
||
"This module provides a way for programs to register \"reduction functions\" "
|
||
"and constructors for user-defined types. Reduction functions have the same "
|
||
"semantics and interface as the :meth:`__reduce__` method described above, "
|
||
"except that they are called with a single argument, the object to be pickled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:554
|
||
msgid ""
|
||
"The registered constructor is deemed a \"safe constructor\" for purposes of "
|
||
"unpickling as described above."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:559
|
||
msgid "Pickling and unpickling external objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:565
|
||
msgid ""
|
||
"For the benefit of object persistence, the :mod:`pickle` module supports the "
|
||
"notion of a reference to an object outside the pickled data stream. Such "
|
||
"objects are referenced by a \"persistent id\", which is just an arbitrary "
|
||
"string of printable ASCII characters. The resolution of such names is not "
|
||
"defined by the :mod:`pickle` module; it will delegate this resolution to "
|
||
"user defined functions on the pickler and unpickler. [#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:572
|
||
msgid ""
|
||
"To define external persistent id resolution, you need to set the :attr:"
|
||
"`~Pickler.persistent_id` attribute of the pickler object and the :attr:"
|
||
"`~Unpickler.persistent_load` attribute of the unpickler object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:576
|
||
msgid ""
|
||
"To pickle objects that have an external persistent id, the pickler must have "
|
||
"a custom :func:`~Pickler.persistent_id` method that takes an object as an "
|
||
"argument and returns either ``None`` or the persistent id for that object. "
|
||
"When ``None`` is returned, the pickler simply pickles the object as normal. "
|
||
"When a persistent id string is returned, the pickler will pickle that "
|
||
"string, along with a marker so that the unpickler will recognize the string "
|
||
"as a persistent id."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:584
|
||
msgid ""
|
||
"To unpickle external objects, the unpickler must have a custom :func:"
|
||
"`~Unpickler.persistent_load` function that takes a persistent id string and "
|
||
"returns the referenced object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:588
|
||
msgid "Here's a silly example that *might* shed more light::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:636
|
||
msgid ""
|
||
"In the :mod:`cPickle` module, the unpickler's :attr:`~Unpickler."
|
||
"persistent_load` attribute can also be set to a Python list, in which case, "
|
||
"when the unpickler reaches a persistent id, the persistent id string will "
|
||
"simply be appended to this list. This functionality exists so that a pickle "
|
||
"data stream can be \"sniffed\" for object references without actually "
|
||
"instantiating all the objects in a pickle. [#]_ Setting :attr:`~Unpickler."
|
||
"persistent_load` to a list is usually used in conjunction with the :meth:"
|
||
"`~Unpickler.noload` method on the Unpickler."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:654
|
||
msgid "Subclassing Unpicklers"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:660
|
||
msgid ""
|
||
"By default, unpickling will import any class that it finds in the pickle "
|
||
"data. You can control exactly what gets unpickled and what gets called by "
|
||
"customizing your unpickler. Unfortunately, exactly how you do this is "
|
||
"different depending on whether you're using :mod:`pickle` or :mod:`cPickle`. "
|
||
"[#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:665
|
||
msgid ""
|
||
"In the :mod:`pickle` module, you need to derive a subclass from :class:"
|
||
"`Unpickler`, overriding the :meth:`load_global` method. :meth:`load_global` "
|
||
"should read two lines from the pickle data stream where the first line will "
|
||
"the name of the module containing the class and the second line will be the "
|
||
"name of the instance's class. It then looks up the class, possibly "
|
||
"importing the module and digging out the attribute, then it appends what it "
|
||
"finds to the unpickler's stack. Later on, this class will be assigned to "
|
||
"the :attr:`__class__` attribute of an empty class, as a way of magically "
|
||
"creating an instance without calling its class's :meth:`__init__`. Your job "
|
||
"(should you choose to accept it), would be to have :meth:`load_global` push "
|
||
"onto the unpickler's stack, a known safe version of any class you deem safe "
|
||
"to unpickle. It is up to you to produce such a class. Or you could raise an "
|
||
"error if you want to disallow all unpickling of instances. If this sounds "
|
||
"like a hack, you're right. Refer to the source code to make this work."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:680
|
||
msgid ""
|
||
"Things are a little cleaner with :mod:`cPickle`, but not by much. To control "
|
||
"what gets unpickled, you can set the unpickler's :attr:`~Unpickler."
|
||
"find_global` attribute to a function or ``None``. If it is ``None`` then "
|
||
"any attempts to unpickle instances will raise an :exc:`UnpicklingError`. If "
|
||
"it is a function, then it should accept a module name and a class name, and "
|
||
"return the corresponding class object. It is responsible for looking up the "
|
||
"class and performing any necessary imports, and it may raise an error to "
|
||
"prevent instances of the class from being unpickled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:689
|
||
msgid ""
|
||
"The moral of the story is that you should be really careful about the source "
|
||
"of the strings your application unpickles."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:696
|
||
msgid "Example"
|
||
msgstr "Exemple"
|
||
|
||
#: ../Doc/library/pickle.rst:698
|
||
msgid ""
|
||
"For the simplest code, use the :func:`dump` and :func:`load` functions. "
|
||
"Note that a self-referencing list is pickled and restored correctly. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:720
|
||
msgid ""
|
||
"The following example reads the resulting pickled data. When reading a "
|
||
"pickle-containing file, you should open the file in binary mode because you "
|
||
"can't be sure if the ASCII or binary format was used. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:736
|
||
msgid ""
|
||
"Here's a larger example that shows how to modify pickling behavior for a "
|
||
"class. The :class:`TextReader` class opens a text file, and returns the line "
|
||
"number and line contents each time its :meth:`!readline` method is called. "
|
||
"If a :class:`TextReader` instance is pickled, all attributes *except* the "
|
||
"file object member are saved. When the instance is unpickled, the file is "
|
||
"reopened, and reading resumes from the last location. The :meth:"
|
||
"`__setstate__` and :meth:`__getstate__` methods are used to implement this "
|
||
"behavior. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:776
|
||
msgid "A sample usage might be something like this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:789
|
||
msgid ""
|
||
"If you want to see that :mod:`pickle` works across Python processes, start "
|
||
"another Python session, before continuing. What follows can happen from "
|
||
"either the same process or a new process. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:802
|
||
msgid "Module :mod:`copy_reg`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:802
|
||
msgid "Pickle interface constructor registration for extension types."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:805
|
||
msgid "Module :mod:`shelve`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:805
|
||
msgid "Indexed databases of objects; uses :mod:`pickle`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:808
|
||
msgid "Module :mod:`copy`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:808
|
||
msgid "Shallow and deep object copying."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:810
|
||
msgid "Module :mod:`marshal`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:811
|
||
msgid "High-performance serialization of built-in types."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:815
|
||
msgid ":mod:`cPickle` --- A faster :mod:`pickle`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:825
|
||
msgid ""
|
||
"The :mod:`cPickle` module supports serialization and de-serialization of "
|
||
"Python objects, providing an interface and functionality nearly identical to "
|
||
"the :mod:`pickle` module. There are several differences, the most important "
|
||
"being performance and subclassability."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:830
|
||
msgid ""
|
||
"First, :mod:`cPickle` can be up to 1000 times faster than :mod:`pickle` "
|
||
"because the former is implemented in C. Second, in the :mod:`cPickle` "
|
||
"module the callables :func:`Pickler` and :func:`Unpickler` are functions, "
|
||
"not classes. This means that you cannot use them to derive custom pickling "
|
||
"and unpickling subclasses. Most applications have no need for this "
|
||
"functionality and should benefit from the greatly improved performance of "
|
||
"the :mod:`cPickle` module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:837
|
||
msgid ""
|
||
"The pickle data stream produced by :mod:`pickle` and :mod:`cPickle` are "
|
||
"identical, so it is possible to use :mod:`pickle` and :mod:`cPickle` "
|
||
"interchangeably with existing pickles. [#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:841
|
||
msgid ""
|
||
"There are additional minor differences in API between :mod:`cPickle` and :"
|
||
"mod:`pickle`, however for most applications, they are interchangeable. More "
|
||
"documentation is provided in the :mod:`pickle` module documentation, which "
|
||
"includes a list of the documented differences."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:847
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: ../Doc/library/pickle.rst:848
|
||
msgid "Don't confuse this with the :mod:`marshal` module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:850
|
||
msgid ""
|
||
"In the :mod:`pickle` module these callables are classes, which you could "
|
||
"subclass to customize the behavior. However, in the :mod:`cPickle` module "
|
||
"these callables are factory functions and so cannot be subclassed. One "
|
||
"common reason to subclass is to control what objects can actually be "
|
||
"unpickled. See section :ref:`pickle-sub` for more details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:856
|
||
msgid ""
|
||
"*Warning*: this is intended for pickling multiple objects without "
|
||
"intervening modifications to the objects or their parts. If you modify an "
|
||
"object and then pickle it again using the same :class:`Pickler` instance, "
|
||
"the object is not pickled again --- a reference to it is pickled and the :"
|
||
"class:`Unpickler` will return the old value, not the modified one. There are "
|
||
"two problems here: (1) detecting changes, and (2) marshalling a minimal set "
|
||
"of changes. Garbage Collection may also become a problem here."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:864
|
||
msgid ""
|
||
"The exception raised will likely be an :exc:`ImportError` or an :exc:"
|
||
"`AttributeError` but it could be something else."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:867
|
||
msgid "These methods can also be used to implement copying class instances."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:869
|
||
msgid ""
|
||
"This protocol is also used by the shallow and deep copying operations "
|
||
"defined in the :mod:`copy` module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:872
|
||
msgid ""
|
||
"The actual mechanism for associating these user defined functions is "
|
||
"slightly different for :mod:`pickle` and :mod:`cPickle`. The description "
|
||
"given here works the same for both implementations. Users of the :mod:"
|
||
"`pickle` module could also use subclassing to effect the same results, "
|
||
"overriding the :meth:`persistent_id` and :meth:`persistent_load` methods in "
|
||
"the derived classes."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:879
|
||
msgid ""
|
||
"We'll leave you with the image of Guido and Jim sitting around sniffing "
|
||
"pickles in their living rooms."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:882
|
||
msgid ""
|
||
"A word of caution: the mechanisms described here use internal attributes and "
|
||
"methods, which are subject to change in future versions of Python. We "
|
||
"intend to someday provide a common interface for controlling this behavior, "
|
||
"which will work in either :mod:`pickle` or :mod:`cPickle`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:887
|
||
msgid ""
|
||
"Since the pickle data format is actually a tiny stack-oriented programming "
|
||
"language, and some freedom is taken in the encodings of certain objects, it "
|
||
"is possible that the two modules produce different data streams for the same "
|
||
"input objects. However it is guaranteed that they will always be able to "
|
||
"read each other's data streams."
|
||
msgstr ""
|