python-docs-fr/library/weakref.po

# 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: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\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"

#: library/weakref.rst:4
msgid ":mod:`weakref` --- Weak references"
msgstr ""

#: library/weakref.rst:14
msgid "**Source code:** :source:`Lib/weakref.py`"
msgstr "**Code source :** :source:`Lib/weakref.py`"

#: library/weakref.rst:18
msgid ""
"The :mod:`weakref` module allows the Python programmer to create :dfn:`weak "
"references` to objects."
msgstr ""

#: library/weakref.rst:24
msgid ""
"In the following, the term :dfn:`referent` means the object which is "
"referred to by a weak reference."
msgstr ""

#: library/weakref.rst:27
msgid ""
"A weak reference to an object is not enough to keep the object alive: when "
"the only remaining references to a referent are weak references, :term:"
"`garbage collection` is free to destroy the referent and reuse its memory "
"for something else.  However, until the object is actually destroyed the "
"weak reference may return the object even if there are no strong references "
"to it."
msgstr ""

#: library/weakref.rst:33
msgid ""
"A primary use for weak references is to implement caches or mappings holding "
"large objects, where it's desired that a large object not be kept alive "
"solely because it appears in a cache or mapping."
msgstr ""

#: library/weakref.rst:37
msgid ""
"For example, if you have a number of large binary image objects, you may "
"wish to associate a name with each.  If you used a Python dictionary to map "
"names to images, or images to names, the image objects would remain alive "
"just because they appeared as values or keys in the dictionaries.  The :"
"class:`WeakKeyDictionary` and :class:`WeakValueDictionary` classes supplied "
"by the :mod:`weakref` module are an alternative, using weak references to "
"construct mappings that don't keep objects alive solely because they appear "
"in the mapping objects.  If, for example, an image object is a value in a :"
"class:`WeakValueDictionary`, then when the last remaining references to that "
"image object are the weak references held by weak mappings, garbage "
"collection can reclaim the object, and its corresponding entries in weak "
"mappings are simply deleted."
msgstr ""

#: library/weakref.rst:50
msgid ""
":class:`WeakKeyDictionary` and :class:`WeakValueDictionary` use weak "
"references in their implementation, setting up callback functions on the "
"weak references that notify the weak dictionaries when a key or value has "
"been reclaimed by garbage collection.  :class:`WeakSet` implements the :"
"class:`set` interface, but keeps weak references to its elements, just like "
"a :class:`WeakKeyDictionary` does."
msgstr ""

#: library/weakref.rst:57
msgid ""
":class:`finalize` provides a straight forward way to register a cleanup "
"function to be called when an object is garbage collected. This is simpler "
"to use than setting up a callback function on a raw weak reference, since "
"the module automatically ensures that the finalizer remains alive until the "
"object is collected."
msgstr ""

#: library/weakref.rst:63
msgid ""
"Most programs should find that using one of these weak container types or :"
"class:`finalize` is all they need -- it's not usually necessary to create "
"your own weak references directly.  The low-level machinery is exposed by "
"the :mod:`weakref` module for the benefit of advanced uses."
msgstr ""

#: library/weakref.rst:68
msgid ""
"Not all objects can be weakly referenced. Objects which support weak "
"references include class instances, functions written in Python (but not in "
"C), instance methods, sets, frozensets, some :term:`file objects <file "
"object>`, :term:`generators <generator>`, type objects, sockets, arrays, "
"deques, regular expression pattern objects, and code objects."
msgstr ""

#: library/weakref.rst:74
msgid "Added support for thread.lock, threading.Lock, and code objects."
msgstr ""

#: library/weakref.rst:77
msgid ""
"Several built-in types such as :class:`list` and :class:`dict` do not "
"directly support weak references but can add support through subclassing::"
msgstr ""

#: library/weakref.rst:87
msgid ""
"Other built-in types such as :class:`tuple` and :class:`int` do not support "
"weak references even when subclassed."
msgstr ""

#: library/weakref.rst:90
msgid ""
"Extension types can easily be made to support weak references; see :ref:"
"`weakref-support`."
msgstr ""

#: library/weakref.rst:93
msgid ""
"When ``__slots__`` are defined for a given type, weak reference support is "
"disabled unless a ``'__weakref__'`` string is also present in the sequence "
"of strings in the ``__slots__`` declaration. See :ref:`__slots__ "
"documentation <slots>` for details."
msgstr ""

#: library/weakref.rst:100
msgid ""
"Return a weak reference to *object*.  The original object can be retrieved "
"by calling the reference object if the referent is still alive; if the "
"referent is no longer alive, calling the reference object will cause :const:"
"`None` to be returned.  If *callback* is provided and not :const:`None`, and "
"the returned weakref object is still alive, the callback will be called when "
"the object is about to be finalized; the weak reference object will be "
"passed as the only parameter to the callback; the referent will no longer be "
"available."
msgstr ""

#: library/weakref.rst:108
msgid ""
"It is allowable for many weak references to be constructed for the same "
"object. Callbacks registered for each weak reference will be called from the "
"most recently registered callback to the oldest registered callback."
msgstr ""

#: library/weakref.rst:112
msgid ""
"Exceptions raised by the callback will be noted on the standard error "
"output, but cannot be propagated; they are handled in exactly the same way "
"as exceptions raised from an object's :meth:`__del__` method."
msgstr ""

#: library/weakref.rst:116
msgid ""
"Weak references are :term:`hashable` if the *object* is hashable.  They will "
"maintain their hash value even after the *object* was deleted.  If :func:"
"`hash` is called the first time only after the *object* was deleted, the "
"call will raise :exc:`TypeError`."
msgstr ""

#: library/weakref.rst:121
msgid ""
"Weak references support tests for equality, but not ordering.  If the "
"referents are still alive, two references have the same equality "
"relationship as their referents (regardless of the *callback*).  If either "
"referent has been deleted, the references are equal only if the reference "
"objects are the same object."
msgstr ""

#: library/weakref.rst:126
msgid "This is a subclassable type rather than a factory function."
msgstr ""

#: library/weakref.rst:130
msgid ""
"This read-only attribute returns the callback currently associated to the "
"weakref.  If there is no callback or if the referent of the weakref is no "
"longer alive then this attribute will have value ``None``."
msgstr ""

#: library/weakref.rst:134
msgid "Added the :attr:`__callback__` attribute."
msgstr ""

#: library/weakref.rst:140
msgid ""
"Return a proxy to *object* which uses a weak reference.  This supports use "
"of the proxy in most contexts instead of requiring the explicit "
"dereferencing used with weak reference objects.  The returned object will "
"have a type of either ``ProxyType`` or ``CallableProxyType``, depending on "
"whether *object* is callable.  Proxy objects are not :term:`hashable` "
"regardless of the referent; this avoids a number of problems related to "
"their fundamentally mutable nature, and prevents their use as dictionary "
"keys.  *callback* is the same as the parameter of the same name to the :func:"
"`ref` function."
msgstr ""

#: library/weakref.rst:149
msgid ""
"Accessing an attribute of the proxy object after the referent is garbage "
"collected raises :exc:`ReferenceError`."
msgstr ""

#: library/weakref.rst:152
msgid ""
"Extended the operator support on proxy objects to include the matrix "
"multiplication operators ``@`` and ``@=``."
msgstr ""

#: library/weakref.rst:159
msgid ""
"Return the number of weak references and proxies which refer to *object*."
msgstr ""

#: library/weakref.rst:164
msgid ""
"Return a list of all weak reference and proxy objects which refer to "
"*object*."
msgstr ""

#: library/weakref.rst:169
msgid ""
"Mapping class that references keys weakly.  Entries in the dictionary will "
"be discarded when there is no longer a strong reference to the key.  This "
"can be used to associate additional data with an object owned by other parts "
"of an application without adding attributes to those objects.  This can be "
"especially useful with objects that override attribute accesses."
msgstr ""

#: library/weakref.rst:175
msgid ""
"Note that when a key with equal value to an existing key (but not equal "
"identity) is inserted into the dictionary, it replaces the value but does "
"not replace the existing key. Due to this, when the reference to the "
"original key is deleted, it also deletes the entry in the dictionary::"
msgstr ""

#: library/weakref.rst:188
msgid "A workaround would be to remove the key prior to reassignment::"
msgstr ""

#: library/weakref.rst:199
msgid "Added support for ``|`` and ``|=`` operators, specified in :pep:`584`."
msgstr ""
"Ajout de la gestion des opérateurs ``|`` et ``|=`` tels que définis dans :"
"pep:`584`."

#: library/weakref.rst:202
msgid ""
":class:`WeakKeyDictionary` objects have an additional method that exposes "
"the internal references directly.  The references are not guaranteed to be "
"\"live\" at the time they are used, so the result of calling the references "
"needs to be checked before being used.  This can be used to avoid creating "
"references that will cause the garbage collector to keep the keys around "
"longer than needed."
msgstr ""

#: library/weakref.rst:212
msgid "Return an iterable of the weak references to the keys."
msgstr ""

#: library/weakref.rst:217
msgid ""
"Mapping class that references values weakly.  Entries in the dictionary will "
"be discarded when no strong reference to the value exists any more."
msgstr ""

#: library/weakref.rst:220
msgid ""
"Added support for ``|`` and ``|=`` operators, as specified in :pep:`584`."
msgstr ""

#: library/weakref.rst:223
msgid ""
":class:`WeakValueDictionary` objects have an additional method that has the "
"same issues as the :meth:`keyrefs` method of :class:`WeakKeyDictionary` "
"objects."
msgstr ""

#: library/weakref.rst:230
msgid "Return an iterable of the weak references to the values."
msgstr ""

#: library/weakref.rst:235
msgid ""
"Set class that keeps weak references to its elements.  An element will be "
"discarded when no strong reference to it exists any more."
msgstr ""

#: library/weakref.rst:241
msgid ""
"A custom :class:`ref` subclass which simulates a weak reference to a bound "
"method (i.e., a method defined on a class and looked up on an instance). "
"Since a bound method is ephemeral, a standard weak reference cannot keep "
"hold of it.  :class:`WeakMethod` has special code to recreate the bound "
"method until either the object or the original function dies::"
msgstr ""

#: library/weakref.rst:265
msgid ""
"*callback* is the same as the parameter of the same name to the :func:`ref` "
"function."
msgstr ""

#: library/weakref.rst:271
msgid ""
"Return a callable finalizer object which will be called when *obj* is "
"garbage collected. Unlike an ordinary weak reference, a finalizer will "
"always survive until the reference object is collected, greatly simplifying "
"lifecycle management."
msgstr ""

#: library/weakref.rst:276
msgid ""
"A finalizer is considered *alive* until it is called (either explicitly or "
"at garbage collection), and after that it is *dead*.  Calling a live "
"finalizer returns the result of evaluating ``func(*arg, **kwargs)``, whereas "
"calling a dead finalizer returns :const:`None`."
msgstr ""

#: library/weakref.rst:281
msgid ""
"Exceptions raised by finalizer callbacks during garbage collection will be "
"shown on the standard error output, but cannot be propagated.  They are "
"handled in the same way as exceptions raised from an object's :meth:"
"`__del__` method or a weak reference's callback."
msgstr ""

#: library/weakref.rst:287
msgid ""
"When the program exits, each remaining live finalizer is called unless its :"
"attr:`atexit` attribute has been set to false.  They are called in reverse "
"order of creation."
msgstr ""

#: library/weakref.rst:291
msgid ""
"A finalizer will never invoke its callback during the later part of the :"
"term:`interpreter shutdown` when module globals are liable to have been "
"replaced by :const:`None`."
msgstr ""

#: library/weakref.rst:297
msgid ""
"If *self* is alive then mark it as dead and return the result of calling "
"``func(*args, **kwargs)``.  If *self* is dead then return :const:`None`."
msgstr ""

#: library/weakref.rst:303
msgid ""
"If *self* is alive then mark it as dead and return the tuple ``(obj, func, "
"args, kwargs)``.  If *self* is dead then return :const:`None`."
msgstr ""

#: library/weakref.rst:309
msgid ""
"If *self* is alive then return the tuple ``(obj, func, args, kwargs)``.  If "
"*self* is dead then return :const:`None`."
msgstr ""

#: library/weakref.rst:314
msgid "Property which is true if the finalizer is alive, false otherwise."
msgstr ""

#: library/weakref.rst:318
msgid ""
"A writable boolean property which by default is true.  When the program "
"exits, it calls all remaining live finalizers for which :attr:`.atexit` is "
"true.  They are called in reverse order of creation."
msgstr ""

#: library/weakref.rst:325
msgid ""
"It is important to ensure that *func*, *args* and *kwargs* do not own any "
"references to *obj*, either directly or indirectly, since otherwise *obj* "
"will never be garbage collected.  In particular, *func* should not be a "
"bound method of *obj*."
msgstr ""

#: library/weakref.rst:335
msgid "The type object for weak references objects."
msgstr ""

#: library/weakref.rst:340
msgid "The type object for proxies of objects which are not callable."
msgstr ""

#: library/weakref.rst:345
msgid "The type object for proxies of callable objects."
msgstr ""

#: library/weakref.rst:350
msgid ""
"Sequence containing all the type objects for proxies.  This can make it "
"simpler to test if an object is a proxy without being dependent on naming "
"both proxy types."
msgstr ""

#: library/weakref.rst:358
msgid ":pep:`205` - Weak References"
msgstr ""

#: library/weakref.rst:358
msgid ""
"The proposal and rationale for this feature, including links to earlier "
"implementations and information about similar features in other languages."
msgstr ""

#: library/weakref.rst:365
msgid "Weak Reference Objects"
msgstr "Objets à références faibles"

#: library/weakref.rst:367
msgid ""
"Weak reference objects have no methods and no attributes besides :attr:`ref."
"__callback__`. A weak reference object allows the referent to be obtained, "
"if it still exists, by calling it:"
msgstr ""

#: library/weakref.rst:381
msgid ""
"If the referent no longer exists, calling the reference object returns :"
"const:`None`:"
msgstr ""

#: library/weakref.rst:388
msgid ""
"Testing that a weak reference object is still live should be done using the "
"expression ``ref() is not None``.  Normally, application code that needs to "
"use a reference object should follow this pattern::"
msgstr ""

#: library/weakref.rst:401
msgid ""
"Using a separate test for \"liveness\" creates race conditions in threaded "
"applications; another thread can cause a weak reference to become "
"invalidated before the weak reference is called; the idiom shown above is "
"safe in threaded applications as well as single-threaded applications."
msgstr ""

#: library/weakref.rst:406
msgid ""
"Specialized versions of :class:`ref` objects can be created through "
"subclassing. This is used in the implementation of the :class:"
"`WeakValueDictionary` to reduce the memory overhead for each entry in the "
"mapping.  This may be most useful to associate additional information with a "
"reference, but could also be used to insert additional processing on calls "
"to retrieve the referent."
msgstr ""

#: library/weakref.rst:412
msgid ""
"This example shows how a subclass of :class:`ref` can be used to store "
"additional information about an object and affect the value that's returned "
"when the referent is accessed::"
msgstr ""

#: library/weakref.rst:439
msgid "Example"
msgstr "Exemple"

#: library/weakref.rst:441
msgid ""
"This simple example shows how an application can use object IDs to retrieve "
"objects that it has seen before.  The IDs of the objects can then be used in "
"other data structures without forcing the objects to remain alive, but the "
"objects can still be retrieved by ID if they do."
msgstr ""

#: library/weakref.rst:466
msgid "Finalizer Objects"
msgstr ""

#: library/weakref.rst:468
msgid ""
"The main benefit of using :class:`finalize` is that it makes it simple to "
"register a callback without needing to preserve the returned finalizer "
"object.  For instance"
msgstr ""

#: library/weakref.rst:482
msgid ""
"The finalizer can be called directly as well.  However the finalizer will "
"invoke the callback at most once."
msgstr ""

#: library/weakref.rst:498
msgid ""
"You can unregister a finalizer using its :meth:`~finalize.detach` method.  "
"This kills the finalizer and returns the arguments passed to the constructor "
"when it was created."
msgstr ""

#: library/weakref.rst:512
msgid ""
"Unless you set the :attr:`~finalize.atexit` attribute to :const:`False`, a "
"finalizer will be called when the program exits if it is still alive.  For "
"instance"
msgstr ""

#: library/weakref.rst:527
msgid "Comparing finalizers with :meth:`__del__` methods"
msgstr ""

#: library/weakref.rst:529
msgid ""
"Suppose we want to create a class whose instances represent temporary "
"directories.  The directories should be deleted with their contents when the "
"first of the following events occurs:"
msgstr ""

#: library/weakref.rst:533
msgid "the object is garbage collected,"
msgstr ""

#: library/weakref.rst:534
msgid "the object's :meth:`remove` method is called, or"
msgstr ""

#: library/weakref.rst:535
msgid "the program exits."
msgstr ""

#: library/weakref.rst:537
msgid ""
"We might try to implement the class using a :meth:`__del__` method as "
"follows::"
msgstr ""

#: library/weakref.rst:556
msgid ""
"Starting with Python 3.4, :meth:`__del__` methods no longer prevent "
"reference cycles from being garbage collected, and module globals are no "
"longer forced to :const:`None` during :term:`interpreter shutdown`. So this "
"code should work without any issues on CPython."
msgstr ""

#: library/weakref.rst:561
msgid ""
"However, handling of :meth:`__del__` methods is notoriously implementation "
"specific, since it depends on internal details of the interpreter's garbage "
"collector implementation."
msgstr ""

#: library/weakref.rst:565
msgid ""
"A more robust alternative can be to define a finalizer which only references "
"the specific functions and objects that it needs, rather than having access "
"to the full state of the object::"
msgstr ""

#: library/weakref.rst:581
msgid ""
"Defined like this, our finalizer only receives a reference to the details it "
"needs to clean up the directory appropriately. If the object never gets "
"garbage collected the finalizer will still be called at exit."
msgstr ""

#: library/weakref.rst:585
msgid ""
"The other advantage of weakref based finalizers is that they can be used to "
"register finalizers for classes where the definition is controlled by a "
"third party, such as running code when a module is unloaded::"
msgstr ""

#: library/weakref.rst:597
msgid ""
"If you create a finalizer object in a daemonic thread just as the program "
"exits then there is the possibility that the finalizer does not get called "
"at exit.  However, in a daemonic thread :func:`atexit.register`, ``try: ... "
"finally: ...`` and ``with: ...`` do not guarantee that cleanup occurs either."
msgstr ""