Update translation

Co-Authored-By: Adorilson Bezerra <adorilson@gmail.com>

Author: github-actions[bot]

glossary.po

@@ -13,7 +13,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.14\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-02-21 14:20+0000\n"
+"POT-Creation-Date: 2026-02-23 14:42+0000\n"
 "PO-Revision-Date: 2025-09-16 00:00+0000\n"
 "Last-Translator: Adorilson Bezerra <adorilson@gmail.com>, 2026\n"
 "Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
@@ -989,6 +989,15 @@ msgid ""
 "only happen in native code, but that :term:`native code` might be exposed in "
 "a Python API.  See also :term:`race condition` and :term:`thread-safe`."
 msgstr ""
+"Uma situação em que várias threads acessam simultaneamente o mesmo local da "
+"memória, pelo menos um dos acessos é uma gravação e as threads não utilizam "
+"qualquer sincronização para controlar o seu acesso. As corridas de dados "
+"levam a um comportamento :term:`não determinístico` e podem causar corrupção "
+"de dados. O uso adequado de :term:`travas <lock>` e outras :term:`primitivas "
+"de sincronização <synchronization primitive>` evita corridas de dados. "
+"Observe que as corridas de dados só podem ocorrer em código nativo, mas que "
+"o :term:`código nativo` pode estar exposto em uma API Python. Veja também :"
+"term:`condição de corrida` e :term:`seguro para threads`."
 
 #: ../../glossary.rst:400
 msgid "deadlock"
@@ -1006,6 +1015,15 @@ msgid ""
 "`locks <lock>` in a consistent order.  See also :term:`lock` and :term:"
 "`reentrant`."
 msgstr ""
+"Uma situação em que duas ou mais tarefas (threads, processos ou corrotinas) "
+"esperam indefinidamente umas pelas outras para liberar recursos ou concluir "
+"ações, impedindo que qualquer uma delas avance. Por exemplo, se a thread A "
+"mantém a trava 1 e espera pela trava 2, enquanto a thread B mantém a trava 2 "
+"e espera pela trava 1, ambas as threads ficarão à espera indefinidamente. Em "
+"Python, isto geralmente ocorre devido à aquisição de várias travas em ordens "
+"conflitantes ou a dependências circulares de join/await. Os impasses podem "
+"ser evitados adquirindo várias :term:`travas <lock>` sempre em uma ordem "
+"consistente. Veja também :term:`trava` e :term:`reentrante`."
 
 #: ../../glossary.rst:411
 msgid "decorator"
@@ -1911,7 +1929,7 @@ msgstr ""
 "exemplo, como uma chave num dicionário. Os objetos imutáveis são "
 "inerentemente :term:`thread-safe` porque o seu estado não pode ser "
 "modificado após a criação, eliminando preocupações com :term:`modificações "
-"simultâneas` sincronizadas incorretamente."
+"simultâneas <concurrent modification>` sincronizadas incorretamente."
 
 #: ../../glossary.rst:773
 msgid "import path"
@@ -2251,6 +2269,13 @@ msgid ""
 "lookup. This issue can be solved with :term:`locks <lock>` or by using the :"
 "term:`EAFP` approach.  See also :term:`thread-safe`."
 msgstr ""
+"Em um ambiente multithread, a abordagem LBYL pode correr o risco de "
+"introduzir uma :term:`condição de corrida` entre \"a pesquisa\" e \"o "
+"salto\". Por exemplo, o código ``if key in mapping: return mapping[key]`` "
+"pode falhar se outra thread remover *key* de *mapping* após o teste, mas "
+"antes da pesquisa. Este problema pode ser resolvido com :term:`travas "
+"<lock>` ou usando a abordagem :term:`EAFP`. Veja também :term:`seguro para "
+"thread`."
 
 #: ../../glossary.rst:923
 msgid "lexical analyzer"
@@ -2311,6 +2336,18 @@ msgid ""
 "patterns, and thread-local state. See also :term:`deadlock`, and :term:"
 "`reentrant`."
 msgstr ""
+"Uma :term:`primitiva de sincronização` que permite que apenas um segmento de "
+"execução acesse um recurso compartilhado de cada vez. Um segmento de "
+"execução deve adquirir uma trava antes de acessar o recurso protegido e "
+"liberá-lo depois. Se um segmento de execução tentar adquirir uma trava já na "
+"posse de outro segmento de execução, ele ficará bloqueado até que a trava "
+"fique disponível. O módulo :mod:`threading` do Python fornece :class:"
+"`~threading.Lock` (uma trava básica) e :class:`~threading.RLock` (uma trava :"
+"term:`reentrante`). As travas são usadas para evitar :term:`condições de "
+"corrida <race condition>` e garantir o acesso :term:`seguro para threads` a "
+"dados compartilhados. Existem padrões de projeto alternativos às travas, "
+"como filas, padrões produtor/consumidor e estado local da thread. Veja "
+"também :term:`impasse` e :term:`reentrante`."
 
 #: ../../glossary.rst:953
 msgid "lock-free"
@@ -2691,6 +2728,12 @@ msgid ""
 "Rust or Fortran code in :term:`extension modules <extension module>` that "
 "can be called from Python.  See also :term:`extension module`."
 msgstr ""
+"Código que é compilado em instruções de máquina e executado diretamente no "
+"processador, em oposição ao código que é interpretado ou executado numa "
+"máquina virtual. No contexto do Python, código nativo normalmente refere-se "
+"ao código C, C++, Rust ou Fortran em :term:`módulos de extensão <extension "
+"module>` que podem ser chamados a partir do Python. Veja também :term:"
+"`módulo de extensão`."
 
 #: ../../glossary.rst:1111
 msgid "nested scope"
@@ -2743,6 +2786,13 @@ msgid ""
 "using :term:`locks <lock>` and other :term:`synchronization primitives "
 "<synchronization primitive>` helps ensure deterministic behavior."
 msgstr ""
+"Comportamento em que o resultado de um programa pode variar entre execuções "
+"com as mesmas entradas. Em programas multithread, o comportamento não "
+"determinístico geralmente resulta de :term:`condições de corrida <race "
+"condition>`, em que o tempo relativo ou o intercalamento de threads afeta o "
+"resultado. A sincronização adequada usando :term:`bloqueios <lock>` e "
+"outras :term:`primitivas de sincronização <synchronization primitive>` ajuda "
+"a garantir um comportamento determinístico."
 
 #: ../../glossary.rst:1136
 msgid "object"
@@ -3284,6 +3334,16 @@ msgid ""
 "threaded code.  Using :term:`locks <lock>` and other :term:`synchronization "
 "primitives <synchronization primitive>` helps prevent race conditions."
 msgstr ""
+"Condição de um programa em que o seu comportamento depende do tempo relativo "
+"ou da ordem dos eventos, particularmente em programas multithread. As "
+"condições de corrida podem levar a um comportamento :term:`não "
+"determinístico` e a bugs difíceis de reproduzir. Uma :term:`corrida de "
+"dados` é um tipo específico de condição de corrida que envolve acesso não "
+"sincronizado a uma memória compartilhada. O estilo de codificação :term:"
+"`LBYL` é particularmente suscetível a condições de corrida em código "
+"multithread. O uso de :term:`travas <lock>` e de outras :term:`primitivas de "
+"sincronização <synchronization primitive>` ajuda a evitar condições de "
+"corrida."
 
 #: ../../glossary.rst:1372
 msgid "reference count"
@@ -3336,14 +3396,17 @@ msgstr "Veja também :term:`pacote de espaço de nomes`."
 
 #: ../../glossary.rst:1393
 msgid "reentrant"
-msgstr ""
+msgstr "reentrante"
 
 #: ../../glossary.rst:1395
 msgid ""
 "A property of a function or :term:`lock` that allows it to be called or "
 "acquired multiple times by the same thread without causing errors or a :term:"
 "`deadlock`."
 msgstr ""
+"Uma propriedade de uma função ou :term:`trava` que permite que ela seja "
+"chamada ou adquirida várias vezes pela mesma thread sem causar erros ou um :"
+"term:`deadlock`."
 
 #: ../../glossary.rst:1399
 msgid ""
@@ -3353,6 +3416,12 @@ msgid ""
 "functions may be :term:`non-deterministic` if they're called reentrantly in "
 "a multithreaded program."
 msgstr ""
+"Para funções, reentrância significa que a função pode ser chamada novamente "
+"com segurança antes que uma invocação anterior tenha sido concluída, o que é "
+"importante quando as funções podem ser chamadas recursivamente ou a partir "
+"de manipuladores de sinal. Funções não seguras para threads podem ser :term:"
+"`não determinísticas` se forem chamadas de forma reentrante em um programa "
+"multithreaded."
 
 #: ../../glossary.rst:1405
 msgid ""
@@ -3361,10 +3430,15 @@ msgid ""
 "blocking.  In contrast, :class:`threading.Lock` is not reentrant - "
 "attempting to acquire it twice from the same thread will cause a deadlock."
 msgstr ""
+"Para travas, o :class:`threading.RLock` (bloqueio reentrante) do Python é "
+"reentrante, o que significa que uma thread que já possui a trava pode "
+"adquiri-la novamente sem bloquear. Em contrapartida, o :class:`threading."
+"Lock` não é reentrante: tentar adquiri-lo duas vezes na mesma thread causará "
+"um deadlock."
 
 #: ../../glossary.rst:1411
 msgid "See also :term:`lock` and :term:`deadlock`."
-msgstr ""
+msgstr "Consulte também :term:`trava` e :term:`deadlock`."
 
 #: ../../glossary.rst:1412
 msgid "REPL"
@@ -3636,7 +3710,7 @@ msgstr ""
 
 #: ../../glossary.rst:1525
 msgid "synchronization primitive"
-msgstr ""
+msgstr "primitiva de sincronização"
 
 #: ../../glossary.rst:1527
 msgid ""
@@ -3651,6 +3725,16 @@ msgid ""
 "conditions <race condition>` and coordinate thread execution.  See also :"
 "term:`lock`."
 msgstr ""
+"Um bloco de construção básico para coordenar (sincronizar) a execução de "
+"múltiplas threads, garantindo acesso :term:` seguro para thread <thread-"
+"safe>` a recursos partilhados. O módulo :mod:`threading` do Python fornece "
+"várias primitivas de sincronização, incluindo :class:`~threading.Lock`, :"
+"class:`~threading.RLock`, :class:`~threading.Semaphore`, :class:`~threading. "
+"Condition`, :class:`~threading.Event` e :class:`~threading.Barrier`. Além "
+"disso, o módulo :mod:`queue` fornece filas com vários produtores e "
+"consumidores, especialmente úteis em programas multithread. Estas primitivas "
+"ajudam a evitar :term:`condições de corrida <race condition>` e coordenar a "
+"execução de threads. Veja também :term:`trava`."
 
 #: ../../glossary.rst:1537
 msgid "t-string"
@@ -3801,6 +3885,17 @@ msgid ""
 "experience :term:`race conditions <race condition>` and :term:`data races "
 "<data race>` when used in multi-threaded programs."
 msgstr ""
+"Um módulo, função ou classe que se comporta corretamente quando usado por "
+"várias threads simultaneamente. O código seguro para threads usa :term:"
+"`primitivas de sincronização<synchronization primitive>` apropriadas, como :"
+"term:`travas <lock>`, para proteger o estado mutável compartilhado, ou é "
+"projetado para evitar completamente o estado mutável compartilhado. Na "
+"compilação :term:`com threads livres <free threading>`, tipos integrados "
+"como :class:`dict`, :class:`list` e :class:`set` utilizam travas internas "
+"para tornar muitas operações seguras para threads, embora a segurança para "
+"threads não seja necessariamente garantida. O código que não é seguro para "
+"threads pode sofrer :term:`condições de corrida <race condition>` e :term:"
+"`corridas de dados <data race>` quando usado em programas multithreaded."
 
 #: ../../glossary.rst:1602
 msgid "token"

potodo.md

@@ -1,7 +1,7 @@
-1 directory  60.97% done
-└── 3.14/  60.97% done
+1 directory  61.01% done
+└── 3.14/  61.01% done
     ├── bugs.po                           96.0% translated   30/31
-    ├── glossary.po                       94.0% translated 467/493
+    ├── glossary.po                       97.0% translated 482/493
     ├── c-api/  54.10% done
     │   ├── call.po                       97.0% translated   97/99
     │   ├── conversion.po                 89.0% translated   49/55
@@ -268,7 +268,7 @@
     ├── using/  97.77% done
     │   ├── configure.po                  99.0% translated 465/466
     │   └── windows.po                    97.0% translated 534/549
-    └── whatsnew/  50.47% done
+    └── whatsnew/  50.46% done
         ├── 2.3.po                        83.0% translated 325/387
         ├── 2.4.po                        83.0% translated 266/319
         ├── 2.5.po                        85.0% translated 388/452
@@ -284,4 +284,4 @@
         ├── 3.5.po                        22.0% translated 128/578
         ├── 3.6.po                        42.0% translated 232/544
         ├── 3.7.po                        43.0% translated 249/568
-        └── changelog.po                  25.0% translated 3487/13863
+        └── changelog.po                  25.0% translated 3487/13866

stats.json

@@ -1 +1 @@
-{"completion": "60.97%", "translated": 53556, "entries": 82418, "updated_at": "2026-02-22T23:12:19+00:00Z"}
+{"completion": "61.01%", "translated": 53571, "entries": 82421, "updated_at": "2026-02-23T23:19:10+00:00Z"}