sync with cpython 0d5fe2c7

Author: github-actions[bot]

library/hashlib.po

@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.12\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2024-05-09 00:03+0000\n"
+"POT-Creation-Date: 2024-05-23 00:03+0000\n"
 "PO-Revision-Date: 2018-05-23 16:03+0000\n"
 "Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
 "Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
@@ -351,8 +351,9 @@ msgstr ""
 
 #: ../../library/hashlib.rst:331
 msgid ""
-"*dklen* is the length of the derived key. If *dklen* is ``None`` then the "
-"digest size of the hash algorithm *hash_name* is used, e.g. 64 for SHA-512."
+"*dklen* is the length of the derived key in bytes. If *dklen* is ``None`` "
+"then the digest size of the hash algorithm *hash_name* is used, e.g. 64 for "
+"SHA-512."
 msgstr ""
 
 #: ../../library/hashlib.rst:340
@@ -383,7 +384,7 @@ msgstr ""
 msgid ""
 "*n* is the CPU/Memory cost factor, *r* the block size, *p* parallelization "
 "factor and *maxmem* limits memory (OpenSSL 1.1.0 defaults to 32 MiB). "
-"*dklen* is the length of the derived key."
+"*dklen* is the length of the derived key in bytes."
 msgstr ""
 
 #: ../../library/hashlib.rst:366

library/threading.po

@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.12\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2024-05-09 00:03+0000\n"
+"POT-Creation-Date: 2024-05-23 00:03+0000\n"
 "PO-Revision-Date: 2018-05-23 16:12+0000\n"
 "Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
 "Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
@@ -696,7 +696,7 @@ msgid ""
 "by the platform."
 msgstr ""
 
-#: ../../library/threading.rst:541 ../../library/threading.rst:621
+#: ../../library/threading.rst:541 ../../library/threading.rst:632
 msgid "Acquire a lock, blocking or non-blocking."
 msgstr ""
 
@@ -728,8 +728,8 @@ msgid ""
 "if not (for example if the *timeout* expired)."
 msgstr ""
 
-#: ../../library/threading.rst:559 ../../library/threading.rst:643
-#: ../../library/threading.rst:890
+#: ../../library/threading.rst:559 ../../library/threading.rst:670
+#: ../../library/threading.rst:917
 msgid "The *timeout* parameter is new."
 msgstr ""
 
@@ -756,7 +756,7 @@ msgstr ""
 msgid "When invoked on an unlocked lock, a :exc:`RuntimeError` is raised."
 msgstr ""
 
-#: ../../library/threading.rst:578 ../../library/threading.rst:659
+#: ../../library/threading.rst:578 ../../library/threading.rst:686
 msgid "There is no return value."
 msgstr ""
 
@@ -779,70 +779,112 @@ msgstr ""
 
 #: ../../library/threading.rst:597
 msgid ""
-"To lock the lock, a thread calls its :meth:`~RLock.acquire` method; this "
-"returns once the thread owns the lock.  To unlock the lock, a thread calls "
-"its :meth:`~Lock.release` method. :meth:`~Lock.acquire`/:meth:`~Lock."
-"release` call pairs may be nested; only the final :meth:`~Lock.release` "
-"(the :meth:`~Lock.release` of the outermost pair) resets the lock to "
-"unlocked and allows another thread blocked in :meth:`~Lock.acquire` to "
-"proceed."
+"Threads call a lock's :meth:`~RLock.acquire` method to lock it, and its :"
+"meth:`~Lock.release` method to unlock it."
 msgstr ""
 
-#: ../../library/threading.rst:604
+#: ../../library/threading.rst:602
 msgid ""
-"Reentrant locks also support the :ref:`context management protocol <with-"
-"locks>`."
+"Reentrant locks support the :ref:`context management protocol <with-locks>`, "
+"so it is recommended to use :keyword:`with` instead of manually calling :"
+"meth:`~RLock.acquire` and :meth:`~RLock.release` to handle acquiring and "
+"releasing the lock for a block of code."
 msgstr ""
 
-#: ../../library/threading.rst:609
+#: ../../library/threading.rst:607
+msgid ""
+"RLock's :meth:`~RLock.acquire`/:meth:`~RLock.release` call pairs may be "
+"nested, unlike Lock's :meth:`~Lock.acquire`/:meth:`~Lock.release`. Only the "
+"final :meth:`~RLock.release` (the :meth:`~Lock.release` of the outermost "
+"pair) resets the lock to an unlocked state and allows another thread blocked "
+"in :meth:`~RLock.acquire` to proceed."
+msgstr ""
+
+#: ../../library/threading.rst:613
+msgid ""
+":meth:`~RLock.acquire`/:meth:`~RLock.release` must be used in pairs: each "
+"acquire must have a release in the thread that has acquired the lock. "
+"Failing to call release as many times the lock has been acquired can lead to "
+"deadlock."
+msgstr ""
+
+#: ../../library/threading.rst:620
 msgid ""
 "This class implements reentrant lock objects.  A reentrant lock must be "
 "released by the thread that acquired it.  Once a thread has acquired a "
 "reentrant lock, the same thread may acquire it again without blocking; the "
 "thread must release it once for each time it has acquired it."
 msgstr ""
 
-#: ../../library/threading.rst:614
+#: ../../library/threading.rst:625
 msgid ""
 "Note that ``RLock`` is actually a factory function which returns an instance "
 "of the most efficient version of the concrete RLock class that is supported "
 "by the platform."
 msgstr ""
 
-#: ../../library/threading.rst:623
+#: ../../library/threading.rst:636
+msgid ":ref:`Using RLock as a context manager <with-locks>`"
+msgstr ""
+
+#: ../../library/threading.rst:637
 msgid ""
-"When invoked without arguments: if this thread already owns the lock, "
-"increment the recursion level by one, and return immediately.  Otherwise, if "
-"another thread owns the lock, block until the lock is unlocked.  Once the "
-"lock is unlocked (not owned by any thread), then grab ownership, set the "
-"recursion level to one, and return.  If more than one thread is blocked "
-"waiting until the lock is unlocked, only one at a time will be able to grab "
-"ownership of the lock. There is no return value in this case."
+"Recommended over manual :meth:`!acquire` and :meth:`release` calls whenever "
+"practical."
 msgstr ""
 
-#: ../../library/threading.rst:631
+#: ../../library/threading.rst:641
 msgid ""
-"When invoked with the *blocking* argument set to ``True``, do the same thing "
-"as when called without arguments, and return ``True``."
+"When invoked with the *blocking* argument set to ``True`` (the default):"
+msgstr ""
+
+#: ../../library/threading.rst:643 ../../library/threading.rst:655
+msgid "If no thread owns the lock, acquire the lock and return immediately."
 msgstr ""
 
-#: ../../library/threading.rst:634
+#: ../../library/threading.rst:645
 msgid ""
-"When invoked with the *blocking* argument set to ``False``, do not block.  "
-"If a call without an argument would block, return ``False`` immediately; "
-"otherwise, do the same thing as when called without arguments, and return "
-"``True``."
+"If another thread owns the lock, block until we are able to acquire lock, or "
+"*timeout*, if set to a positive float value."
 msgstr ""
 
-#: ../../library/threading.rst:638
+#: ../../library/threading.rst:648
 msgid ""
-"When invoked with the floating-point *timeout* argument set to a positive "
-"value, block for at most the number of seconds specified by *timeout* and as "
-"long as the lock cannot be acquired.  Return ``True`` if the lock has been "
-"acquired, ``False`` if the timeout has elapsed."
+"If the same thread owns the lock, acquire the lock again, and return "
+"immediately. This is the difference between :class:`Lock` and :class:`!"
+"RLock`; :class:`Lock` handles this case the same as the previous, blocking "
+"until the lock can be acquired."
 msgstr ""
 
-#: ../../library/threading.rst:649
+#: ../../library/threading.rst:653
+msgid "When invoked with the *blocking* argument set to ``False``:"
+msgstr ""
+
+#: ../../library/threading.rst:657
+msgid "If another thread owns the lock, return immediately."
+msgstr ""
+
+#: ../../library/threading.rst:659
+msgid ""
+"If the same thread owns the lock, acquire the lock again and return "
+"immediately."
+msgstr ""
+
+#: ../../library/threading.rst:662
+msgid ""
+"In all cases, if the thread was able to acquire the lock, return ``True``. "
+"If the thread was unable to acquire the lock (i.e. if not blocking or the "
+"timeout was reached) return ``False``."
+msgstr ""
+
+#: ../../library/threading.rst:666
+msgid ""
+"If called multiple times, failing to call :meth:`~RLock.release` as many "
+"times may lead to deadlock. Consider using :class:`!RLock` as a context "
+"manager rather than calling acquire/release directly."
+msgstr ""
+
+#: ../../library/threading.rst:676
 msgid ""
 "Release a lock, decrementing the recursion level.  If after the decrement it "
 "is zero, reset the lock to unlocked (not owned by any thread), and if any "
@@ -851,25 +893,26 @@ msgid ""
 "is still nonzero, the lock remains locked and owned by the calling thread."
 msgstr ""
 
-#: ../../library/threading.rst:655
+#: ../../library/threading.rst:682
 msgid ""
 "Only call this method when the calling thread owns the lock. A :exc:"
-"`RuntimeError` is raised if this method is called when the lock is unlocked."
+"`RuntimeError` is raised if this method is called when the lock is not "
+"acquired."
 msgstr ""
 
-#: ../../library/threading.rst:665
+#: ../../library/threading.rst:692
 msgid "Condition Objects"
 msgstr ""
 
-#: ../../library/threading.rst:667
+#: ../../library/threading.rst:694
 msgid ""
 "A condition variable is always associated with some kind of lock; this can "
 "be passed in or one will be created by default.  Passing one in is useful "
 "when several condition variables must share the same lock.  The lock is part "
 "of the condition object: you don't have to track it separately."
 msgstr ""
 
-#: ../../library/threading.rst:672
+#: ../../library/threading.rst:699
 msgid ""
 "A condition variable obeys the :ref:`context management protocol <with-"
 "locks>`: using the ``with`` statement acquires the associated lock for the "
@@ -878,7 +921,7 @@ msgid ""
 "associated lock."
 msgstr ""
 
-#: ../../library/threading.rst:678
+#: ../../library/threading.rst:705
 msgid ""
 "Other methods must be called with the associated lock held.  The :meth:"
 "`~Condition.wait` method releases the lock, and then blocks until another "
@@ -887,14 +930,14 @@ msgid ""
 "and returns.  It is also possible to specify a timeout."
 msgstr ""
 
-#: ../../library/threading.rst:684
+#: ../../library/threading.rst:711
 msgid ""
 "The :meth:`~Condition.notify` method wakes up one of the threads waiting for "
 "the condition variable, if any are waiting.  The :meth:`~Condition."
 "notify_all` method wakes up all threads waiting for the condition variable."
 msgstr ""
 
-#: ../../library/threading.rst:688
+#: ../../library/threading.rst:715
 msgid ""
 "Note: the :meth:`~Condition.notify` and :meth:`~Condition.notify_all` "
 "methods don't release the lock; this means that the thread or threads "
@@ -903,7 +946,7 @@ msgid ""
 "or :meth:`~Condition.notify_all` finally relinquishes ownership of the lock."
 msgstr ""
 
-#: ../../library/threading.rst:694
+#: ../../library/threading.rst:721
 msgid ""
 "The typical programming style using condition variables uses the lock to "
 "synchronize access to some shared state; threads that are interested in a "
@@ -915,7 +958,7 @@ msgid ""
 "situation with unlimited buffer capacity::"
 msgstr ""
 
-#: ../../library/threading.rst:714
+#: ../../library/threading.rst:741
 msgid ""
 "The ``while`` loop checking for the application's condition is necessary "
 "because :meth:`~Condition.wait` can return after an arbitrary long time, and "
@@ -925,7 +968,7 @@ msgid ""
 "checking, and eases the computation of timeouts::"
 msgstr ""
 
-#: ../../library/threading.rst:726
+#: ../../library/threading.rst:753
 msgid ""
 "To choose between :meth:`~Condition.notify` and :meth:`~Condition."
 "notify_all`, consider whether one state change can be interesting for only "
@@ -934,60 +977,60 @@ msgid ""
 "thread."
 msgstr ""
 
-#: ../../library/threading.rst:734
+#: ../../library/threading.rst:761
 msgid ""
 "This class implements condition variable objects.  A condition variable "
 "allows one or more threads to wait until they are notified by another thread."
 msgstr ""
 
-#: ../../library/threading.rst:737
+#: ../../library/threading.rst:764
 msgid ""
 "If the *lock* argument is given and not ``None``, it must be a :class:`Lock` "
 "or :class:`RLock` object, and it is used as the underlying lock.  Otherwise, "
 "a new :class:`RLock` object is created and used as the underlying lock."
 msgstr ""
 
-#: ../../library/threading.rst:741 ../../library/threading.rst:865
-#: ../../library/threading.rst:911 ../../library/threading.rst:963
-#: ../../library/threading.rst:1031
+#: ../../library/threading.rst:768 ../../library/threading.rst:892
+#: ../../library/threading.rst:938 ../../library/threading.rst:990
+#: ../../library/threading.rst:1058
 msgid "changed from a factory function to a class."
 msgstr ""
 
-#: ../../library/threading.rst:746
+#: ../../library/threading.rst:773
 msgid ""
 "Acquire the underlying lock. This method calls the corresponding method on "
 "the underlying lock; the return value is whatever that method returns."
 msgstr ""
 
-#: ../../library/threading.rst:751
+#: ../../library/threading.rst:778
 msgid ""
 "Release the underlying lock. This method calls the corresponding method on "
 "the underlying lock; there is no return value."
 msgstr ""
 
-#: ../../library/threading.rst:756
+#: ../../library/threading.rst:783
 msgid ""
 "Wait until notified or until a timeout occurs. If the calling thread has not "
 "acquired the lock when this method is called, a :exc:`RuntimeError` is "
 "raised."
 msgstr ""
 
-#: ../../library/threading.rst:760
+#: ../../library/threading.rst:787
 msgid ""
 "This method releases the underlying lock, and then blocks until it is "
 "awakened by a :meth:`notify` or :meth:`notify_all` call for the same "
 "condition variable in another thread, or until the optional timeout occurs.  "
 "Once awakened or timed out, it re-acquires the lock and returns."
 msgstr ""
 
-#: ../../library/threading.rst:765
+#: ../../library/threading.rst:792
 msgid ""
 "When the *timeout* argument is present and not ``None``, it should be a "
 "floating point number specifying a timeout for the operation in seconds (or "
 "fractions thereof)."
 msgstr ""
 
-#: ../../library/threading.rst:769
+#: ../../library/threading.rst:796
 msgid ""
 "When the underlying lock is an :class:`RLock`, it is not released using its :"
 "meth:`release` method, since this may not actually unlock the lock when it "
@@ -997,97 +1040,97 @@ msgid ""
 "used to restore the recursion level when the lock is reacquired."
 msgstr ""
 
-#: ../../library/threading.rst:777
+#: ../../library/threading.rst:804
 msgid ""
 "The return value is ``True`` unless a given *timeout* expired, in which case "
 "it is ``False``."
 msgstr ""
 
-#: ../../library/threading.rst:780 ../../library/threading.rst:996
+#: ../../library/threading.rst:807 ../../library/threading.rst:1023
 msgid "Previously, the method always returned ``None``."
 msgstr ""
 
-#: ../../library/threading.rst:785
+#: ../../library/threading.rst:812
 msgid ""
 "Wait until a condition evaluates to true.  *predicate* should be a callable "
 "which result will be interpreted as a boolean value. A *timeout* may be "
 "provided giving the maximum time to wait."
 msgstr ""
 
-#: ../../library/threading.rst:789
+#: ../../library/threading.rst:816
 msgid ""
 "This utility method may call :meth:`wait` repeatedly until the predicate is "
 "satisfied, or until a timeout occurs. The return value is the last return "
 "value of the predicate and will evaluate to ``False`` if the method timed "
 "out."
 msgstr ""
 
-#: ../../library/threading.rst:794
+#: ../../library/threading.rst:821
 msgid ""
 "Ignoring the timeout feature, calling this method is roughly equivalent to "
 "writing::"
 msgstr ""
 
-#: ../../library/threading.rst:800
+#: ../../library/threading.rst:827
 msgid ""
 "Therefore, the same rules apply as with :meth:`wait`: The lock must be held "
 "when called and is re-acquired on return.  The predicate is evaluated with "
 "the lock held."
 msgstr ""
 
-#: ../../library/threading.rst:808
+#: ../../library/threading.rst:835
 msgid ""
 "By default, wake up one thread waiting on this condition, if any.  If the "
 "calling thread has not acquired the lock when this method is called, a :exc:"
 "`RuntimeError` is raised."
 msgstr ""
 
-#: ../../library/threading.rst:812
+#: ../../library/threading.rst:839
 msgid ""
 "This method wakes up at most *n* of the threads waiting for the condition "
 "variable; it is a no-op if no threads are waiting."
 msgstr ""
 
-#: ../../library/threading.rst:815
+#: ../../library/threading.rst:842
 msgid ""
 "The current implementation wakes up exactly *n* threads, if at least *n* "
 "threads are waiting.  However, it's not safe to rely on this behavior. A "
 "future, optimized implementation may occasionally wake up more than *n* "
 "threads."
 msgstr ""
 
-#: ../../library/threading.rst:820
+#: ../../library/threading.rst:847
 msgid ""
 "Note: an awakened thread does not actually return from its :meth:`wait` call "
 "until it can reacquire the lock.  Since :meth:`notify` does not release the "
 "lock, its caller should."
 msgstr ""
 
-#: ../../library/threading.rst:826
+#: ../../library/threading.rst:853
 msgid ""
 "Wake up all threads waiting on this condition.  This method acts like :meth:"
 "`notify`, but wakes up all waiting threads instead of one. If the calling "
 "thread has not acquired the lock when this method is called, a :exc:"
 "`RuntimeError` is raised."
 msgstr ""
 
-#: ../../library/threading.rst:831
+#: ../../library/threading.rst:858
 msgid "The method ``notifyAll`` is a deprecated alias for this method."
 msgstr ""
 
-#: ../../library/threading.rst:837
+#: ../../library/threading.rst:864
 msgid "Semaphore Objects"
 msgstr ""
 
-#: ../../library/threading.rst:839
+#: ../../library/threading.rst:866
 msgid ""
 "This is one of the oldest synchronization primitives in the history of "
 "computer science, invented by the early Dutch computer scientist Edsger W. "
 "Dijkstra (he used the names ``P()`` and ``V()`` instead of :meth:`~Semaphore."
 "acquire` and :meth:`~Semaphore.release`)."
 msgstr ""
 
-#: ../../library/threading.rst:844
+#: ../../library/threading.rst:871
 msgid ""
 "A semaphore manages an internal counter which is decremented by each :meth:"
 "`~Semaphore.acquire` call and incremented by each :meth:`~Semaphore.release` "
@@ -1096,12 +1139,12 @@ msgid ""
 "meth:`~Semaphore.release`."
 msgstr ""
 
-#: ../../library/threading.rst:850
+#: ../../library/threading.rst:877
 msgid ""
 "Semaphores also support the :ref:`context management protocol <with-locks>`."
 msgstr ""
 
-#: ../../library/threading.rst:855
+#: ../../library/threading.rst:882
 msgid ""
 "This class implements semaphore objects.  A semaphore manages an atomic "
 "counter representing the number of :meth:`release` calls minus the number "
@@ -1110,28 +1153,28 @@ msgid ""
 "If not given, *value* defaults to 1."
 msgstr ""
 
-#: ../../library/threading.rst:861
+#: ../../library/threading.rst:888
 msgid ""
 "The optional argument gives the initial *value* for the internal counter; it "
 "defaults to ``1``. If the *value* given is less than 0, :exc:`ValueError` is "
 "raised."
 msgstr ""
 
-#: ../../library/threading.rst:870
+#: ../../library/threading.rst:897
 msgid "Acquire a semaphore."
 msgstr ""
 
-#: ../../library/threading.rst:872
+#: ../../library/threading.rst:899
 msgid "When invoked without arguments:"
 msgstr ""
 
-#: ../../library/threading.rst:874
+#: ../../library/threading.rst:901
 msgid ""
 "If the internal counter is larger than zero on entry, decrement it by one "
 "and return ``True`` immediately."
 msgstr ""
 
-#: ../../library/threading.rst:876
+#: ../../library/threading.rst:903
 msgid ""
 "If the internal counter is zero on entry, block until awoken by a call to :"
 "meth:`~Semaphore.release`.  Once awoken (and the counter is greater than 0), "
@@ -1140,32 +1183,32 @@ msgid ""
 "threads are awoken should not be relied on."
 msgstr ""
 
-#: ../../library/threading.rst:882
+#: ../../library/threading.rst:909
 msgid ""
 "When invoked with *blocking* set to ``False``, do not block.  If a call "
 "without an argument would block, return ``False`` immediately; otherwise, do "
 "the same thing as when called without arguments, and return ``True``."
 msgstr ""
 
-#: ../../library/threading.rst:886
+#: ../../library/threading.rst:913
 msgid ""
 "When invoked with a *timeout* other than ``None``, it will block for at most "
 "*timeout* seconds.  If acquire does not complete successfully in that "
 "interval, return ``False``.  Return ``True`` otherwise."
 msgstr ""
 
-#: ../../library/threading.rst:895
+#: ../../library/threading.rst:922
 msgid ""
 "Release a semaphore, incrementing the internal counter by *n*.  When it was "
 "zero on entry and other threads are waiting for it to become larger than "
 "zero again, wake up *n* of those threads."
 msgstr ""
 
-#: ../../library/threading.rst:899
+#: ../../library/threading.rst:926
 msgid "Added the *n* parameter to release multiple waiting threads at once."
 msgstr ""
 
-#: ../../library/threading.rst:905
+#: ../../library/threading.rst:932
 msgid ""
 "Class implementing bounded semaphore objects.  A bounded semaphore checks to "
 "make sure its current value doesn't exceed its initial value.  If it does, :"
@@ -1174,79 +1217,79 @@ msgid ""
 "times it's a sign of a bug.  If not given, *value* defaults to 1."
 msgstr ""
 
-#: ../../library/threading.rst:918
+#: ../../library/threading.rst:945
 msgid ":class:`Semaphore` Example"
 msgstr ":class:`Semaphore` 範例"
 
-#: ../../library/threading.rst:920
+#: ../../library/threading.rst:947
 msgid ""
 "Semaphores are often used to guard resources with limited capacity, for "
 "example, a database server.  In any situation where the size of the resource "
 "is fixed, you should use a bounded semaphore.  Before spawning any worker "
 "threads, your main thread would initialize the semaphore::"
 msgstr ""
 
-#: ../../library/threading.rst:929
+#: ../../library/threading.rst:956
 msgid ""
 "Once spawned, worker threads call the semaphore's acquire and release "
 "methods when they need to connect to the server::"
 msgstr ""
 
-#: ../../library/threading.rst:939
+#: ../../library/threading.rst:966
 msgid ""
 "The use of a bounded semaphore reduces the chance that a programming error "
 "which causes the semaphore to be released more than it's acquired will go "
 "undetected."
 msgstr ""
 
-#: ../../library/threading.rst:946
+#: ../../library/threading.rst:973
 msgid "Event Objects"
 msgstr ""
 
-#: ../../library/threading.rst:948
+#: ../../library/threading.rst:975
 msgid ""
 "This is one of the simplest mechanisms for communication between threads: "
 "one thread signals an event and other threads wait for it."
 msgstr ""
 
-#: ../../library/threading.rst:951
+#: ../../library/threading.rst:978
 msgid ""
 "An event object manages an internal flag that can be set to true with the :"
 "meth:`~Event.set` method and reset to false with the :meth:`~Event.clear` "
 "method.  The :meth:`~Event.wait` method blocks until the flag is true."
 msgstr ""
 
-#: ../../library/threading.rst:958
+#: ../../library/threading.rst:985
 msgid ""
 "Class implementing event objects.  An event manages a flag that can be set "
 "to true with the :meth:`~Event.set` method and reset to false with the :meth:"
 "`clear` method.  The :meth:`wait` method blocks until the flag is true. The "
 "flag is initially false."
 msgstr ""
 
-#: ../../library/threading.rst:968
+#: ../../library/threading.rst:995
 msgid "Return ``True`` if and only if the internal flag is true."
 msgstr ""
 
-#: ../../library/threading.rst:970
+#: ../../library/threading.rst:997
 msgid "The method ``isSet`` is a deprecated alias for this method."
 msgstr ""
 
-#: ../../library/threading.rst:974
+#: ../../library/threading.rst:1001
 msgid ""
 "Set the internal flag to true. All threads waiting for it to become true are "
 "awakened. Threads that call :meth:`wait` once the flag is true will not "
 "block at all."
 msgstr ""
 
-#: ../../library/threading.rst:980
+#: ../../library/threading.rst:1007
 msgid ""
 "Reset the internal flag to false. Subsequently, threads calling :meth:`wait` "
 "will block until :meth:`.set` is called to set the internal flag to true "
 "again."
 msgstr ""
 
-#: ../../library/threading.rst:986
+#: ../../library/threading.rst:1013
 msgid ""
 "Block as long as the internal flag is false and the timeout, if given, has "
 "not expired. The return value represents the reason that this blocking "
@@ -1255,26 +1298,26 @@ msgid ""
 "become true within the given wait time."
 msgstr ""
 
-#: ../../library/threading.rst:992
+#: ../../library/threading.rst:1019
 msgid ""
 "When the timeout argument is present and not ``None``, it should be a "
 "floating point number specifying a timeout for the operation in seconds, or "
 "fractions thereof."
 msgstr ""
 
-#: ../../library/threading.rst:1003
+#: ../../library/threading.rst:1030
 msgid "Timer Objects"
 msgstr ""
 
-#: ../../library/threading.rst:1005
+#: ../../library/threading.rst:1032
 msgid ""
 "This class represents an action that should be run only after a certain "
 "amount of time has passed --- a timer.  :class:`Timer` is a subclass of :"
 "class:`Thread` and as such also functions as an example of creating custom "
 "threads."
 msgstr ""
 
-#: ../../library/threading.rst:1009
+#: ../../library/threading.rst:1036
 msgid ""
 "Timers are started, as with threads, by calling their :meth:`Timer.start "
 "<Thread.start>` method.  The timer can be stopped (before its action has "
@@ -1283,32 +1326,32 @@ msgid ""
 "interval specified by the user."
 msgstr ""
 
-#: ../../library/threading.rst:1015
+#: ../../library/threading.rst:1042
 msgid "For example::"
 msgstr ""
 "舉例來說：\n"
 "\n"
 "::"
 
-#: ../../library/threading.rst:1026
+#: ../../library/threading.rst:1053
 msgid ""
 "Create a timer that will run *function* with arguments *args* and  keyword "
 "arguments *kwargs*, after *interval* seconds have passed. If *args* is "
 "``None`` (the default) then an empty list will be used. If *kwargs* is "
 "``None`` (the default) then an empty dict will be used."
 msgstr ""
 
-#: ../../library/threading.rst:1036
+#: ../../library/threading.rst:1063
 msgid ""
 "Stop the timer, and cancel the execution of the timer's action.  This will "
 "only work if the timer is still in its waiting stage."
 msgstr ""
 
-#: ../../library/threading.rst:1041
+#: ../../library/threading.rst:1068
 msgid "Barrier Objects"
 msgstr ""
 
-#: ../../library/threading.rst:1045
+#: ../../library/threading.rst:1072
 msgid ""
 "This class provides a simple synchronization primitive for use by a fixed "
 "number of threads that need to wait for each other.  Each of the threads "
@@ -1317,108 +1360,108 @@ msgid ""
 "calls. At this point, the threads are released simultaneously."
 msgstr ""
 
-#: ../../library/threading.rst:1051
+#: ../../library/threading.rst:1078
 msgid ""
 "The barrier can be reused any number of times for the same number of threads."
 msgstr ""
 
-#: ../../library/threading.rst:1053
+#: ../../library/threading.rst:1080
 msgid ""
 "As an example, here is a simple way to synchronize a client and server "
 "thread::"
 msgstr ""
 
-#: ../../library/threading.rst:1073
+#: ../../library/threading.rst:1100
 msgid ""
 "Create a barrier object for *parties* number of threads.  An *action*, when "
 "provided, is a callable to be called by one of the threads when they are "
 "released.  *timeout* is the default timeout value if none is specified for "
 "the :meth:`wait` method."
 msgstr ""
 
-#: ../../library/threading.rst:1080
+#: ../../library/threading.rst:1107
 msgid ""
 "Pass the barrier.  When all the threads party to the barrier have called "
 "this function, they are all released simultaneously.  If a *timeout* is "
 "provided, it is used in preference to any that was supplied to the class "
 "constructor."
 msgstr ""
 
-#: ../../library/threading.rst:1085
+#: ../../library/threading.rst:1112
 msgid ""
 "The return value is an integer in the range 0 to *parties* -- 1, different "
 "for each thread.  This can be used to select a thread to do some special "
 "housekeeping, e.g.::"
 msgstr ""
 
-#: ../../library/threading.rst:1094
+#: ../../library/threading.rst:1121
 msgid ""
 "If an *action* was provided to the constructor, one of the threads will have "
 "called it prior to being released.  Should this call raise an error, the "
 "barrier is put into the broken state."
 msgstr ""
 
-#: ../../library/threading.rst:1098
+#: ../../library/threading.rst:1125
 msgid "If the call times out, the barrier is put into the broken state."
 msgstr ""
 
-#: ../../library/threading.rst:1100
+#: ../../library/threading.rst:1127
 msgid ""
 "This method may raise a :class:`BrokenBarrierError` exception if the barrier "
 "is broken or reset while a thread is waiting."
 msgstr ""
 
-#: ../../library/threading.rst:1105
+#: ../../library/threading.rst:1132
 msgid ""
 "Return the barrier to the default, empty state.  Any threads waiting on it "
 "will receive the :class:`BrokenBarrierError` exception."
 msgstr ""
 
-#: ../../library/threading.rst:1108
+#: ../../library/threading.rst:1135
 msgid ""
 "Note that using this function may require some external synchronization if "
 "there are other threads whose state is unknown.  If a barrier is broken it "
 "may be better to just leave it and create a new one."
 msgstr ""
 
-#: ../../library/threading.rst:1114
+#: ../../library/threading.rst:1141
 msgid ""
 "Put the barrier into a broken state.  This causes any active or future calls "
 "to :meth:`wait` to fail with the :class:`BrokenBarrierError`.  Use this for "
 "example if one of the threads needs to abort, to avoid deadlocking the "
 "application."
 msgstr ""
 
-#: ../../library/threading.rst:1119
+#: ../../library/threading.rst:1146
 msgid ""
 "It may be preferable to simply create the barrier with a sensible *timeout* "
 "value to automatically guard against one of the threads going awry."
 msgstr ""
 
-#: ../../library/threading.rst:1125
+#: ../../library/threading.rst:1152
 msgid "The number of threads required to pass the barrier."
 msgstr ""
 
-#: ../../library/threading.rst:1129
+#: ../../library/threading.rst:1156
 msgid "The number of threads currently waiting in the barrier."
 msgstr ""
 
-#: ../../library/threading.rst:1133
+#: ../../library/threading.rst:1160
 msgid "A boolean that is ``True`` if the barrier is in the broken state."
 msgstr ""
 
-#: ../../library/threading.rst:1138
+#: ../../library/threading.rst:1165
 msgid ""
 "This exception, a subclass of :exc:`RuntimeError`, is raised when the :class:"
 "`Barrier` object is reset or broken."
 msgstr ""
 
-#: ../../library/threading.rst:1145
+#: ../../library/threading.rst:1172
 msgid ""
 "Using locks, conditions, and semaphores in the :keyword:`!with` statement"
 msgstr ""
 
-#: ../../library/threading.rst:1147
+#: ../../library/threading.rst:1174
 msgid ""
 "All of the objects provided by this module that have ``acquire`` and "
 "``release`` methods can be used as context managers for a :keyword:`with` "
@@ -1427,11 +1470,11 @@ msgid ""
 "following snippet::"
 msgstr ""
 
-#: ../../library/threading.rst:1156
+#: ../../library/threading.rst:1183
 msgid "is equivalent to::"
 msgstr ""
 
-#: ../../library/threading.rst:1164
+#: ../../library/threading.rst:1191
 msgid ""
 "Currently, :class:`Lock`, :class:`RLock`, :class:`Condition`, :class:"
 "`Semaphore`, and :class:`BoundedSemaphore` objects may be used as :keyword:"

whatsnew/3.12.po

@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.12\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2024-05-10 00:04+0000\n"
+"POT-Creation-Date: 2024-05-23 00:03+0000\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"
@@ -2759,7 +2759,7 @@ msgstr ""
 msgid ""
 "Undocumented :meth:`TestLoader.loadTestsFromModule <unittest.TestLoader."
 "loadTestsFromModule>` parameter *use_load_tests* (deprecated and ignored "
-"since Python 3.2)."
+"since Python 3.5)."
 msgstr ""
 
 #: ../../whatsnew/3.12.rst:1755