python
diff --git a/‎library/fcntl.po
Lines changed: 29 additions & 7 deletions b/‎library/fcntl.po
Lines changed: 29 additions & 7 deletions
diff --git a/‎library/itertools.po
Lines changed: 104 additions & 1 deletion b/‎library/itertools.po
Lines changed: 104 additions & 1 deletion
@@ -292,8 +292,8 @@ msgid ""
 msgstr ""
 "Este é essencialmente um invólucro em torno das chamadas de trava :func:"
 "`~fcntl.fcntl`. *fd* é o descritor de arquivo (objetos arquivo que fornecem "
-"um método :meth:`~io.IOBase.fileno` também são aceitos) do arquivo a ser "
-"travado ou destravado, e *cmd* é um dos seguintes valores:"
+"um método :meth:`~io.IOBase.fileno` também são aceitos) do arquivo para "
+"travar ou destravar, e *cmd* é um dos seguintes valores:"
 
 #: ../../library/fcntl.rst:160
 msgid "Release an existing lock."
@@ -312,6 +312,8 @@ msgid ""
 "Bitwise OR with any of the other three ``LOCK_*`` constants to make the "
 "request non-blocking."
 msgstr ""
+"Aplica OU (OR) bit a bit com qualquer uma das outras três constantes "
+"``LOCK_*`` para tornar a solicitação não bloqueante."
 
 #: ../../library/fcntl.rst:175
 msgid ""
@@ -335,25 +337,31 @@ msgid ""
 "the lock starts, relative to *whence*, and *whence* is as with :func:`io."
 "IOBase.seek`, specifically:"
 msgstr ""
+"*len* é o número de bytes para travar, *start* é o deslocamento de bytes em "
+"que a trava começa, em relação a *whence*, e *whence* é como em :func:`io."
+"IOBase.seek`, especificamente:"
 
 #: ../../library/fcntl.rst:186
 msgid "``0`` -- relative to the start of the file (:const:`os.SEEK_SET`)"
-msgstr ""
+msgstr "``0`` -- relativo ao início do arquivo (:const:`os.SEEK_SET`)"
 
 #: ../../library/fcntl.rst:187
 msgid "``1`` -- relative to the current buffer position (:const:`os.SEEK_CUR`)"
-msgstr ""
+msgstr "``1`` -- relativo à posição atual do buffer (:const:`os.SEEK_CUR`)"
 
 #: ../../library/fcntl.rst:188
 msgid "``2`` -- relative to the end of the file (:const:`os.SEEK_END`)"
-msgstr ""
+msgstr "``2`` -- relativo ao fim do arquivo (:const:`os.SEEK_END`)"
 
 #: ../../library/fcntl.rst:190
 msgid ""
 "The default for *start* is 0, which means to start at the beginning of the "
 "file. The default for *len* is 0 which means to lock to the end of the "
 "file.  The default for *whence* is also 0."
 msgstr ""
+"O padrão para *start* é 0, o que significa iniciar no início do arquivo. O "
+"padrão para *len* é 0, o que significa travar no final do arquivo. O padrão "
+"para *whence* também é 0."
 
 #: ../../library/fcntl.rst:194
 msgid ""
@@ -365,7 +373,7 @@ msgstr ""
 
 #: ../../library/fcntl.rst:196
 msgid "Examples (all on a SVR4 compliant system)::"
-msgstr ""
+msgstr "Exemplos (todos em um sistema compatível com SVR4)::"
 
 #: ../../library/fcntl.rst:198
 msgid ""
@@ -377,6 +385,13 @@ msgid ""
 "lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)\n"
 "rv = fcntl.fcntl(f, fcntl.F_SETLKW, lockdata)"
 msgstr ""
+"import struct, fcntl, os\n"
+"\n"
+"f = open(...)\n"
+"rv = fcntl.fcntl(f, fcntl.F_SETFL, os.O_NDELAY)\n"
+"\n"
+"lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)\n"
+"rv = fcntl.fcntl(f, fcntl.F_SETLKW, lockdata)"
 
 #: ../../library/fcntl.rst:206
 msgid ""
@@ -385,6 +400,10 @@ msgid ""
 "The structure lay-out for the *lockdata* variable is system dependent --- "
 "therefore using the :func:`flock` call may be better."
 msgstr ""
+"Observe que, no primeiro exemplo, a variável de valor de retorno *rv* "
+"conterá um valor inteiro; no segundo exemplo, ela conterá um objeto :class:"
+"`bytes`. O layout da estrutura da variável *lockdata* depende do sistema --- "
+"portanto, usar a chamada :func:`flock` pode ser melhor."
 
 #: ../../library/fcntl.rst:214
 msgid "Module :mod:`os`"
@@ -396,14 +415,17 @@ msgid ""
 "present in the :mod:`os` module (on BSD only), the :func:`os.open` function "
 "provides an alternative to the :func:`lockf` and :func:`flock` functions."
 msgstr ""
+"Se os sinalizadores de trava :const:`~os.O_SHLOCK` e :const:`~os.O_EXLOCK` "
+"estiverem presentes no módulo :mod:`os` (somente no BSD), a função :func:`os."
+"open` fornece uma alternativa às funções :func:`lockf` e :func:`flock`."
 
 #: ../../library/fcntl.rst:10
 msgid "UNIX"
 msgstr "UNIX"
 
 #: ../../library/fcntl.rst:10
 msgid "file control"
-msgstr ""
+msgstr "controle de arquivo"
 
 #: ../../library/fcntl.rst:10
 msgid "I/O control"
 
@@ -11,7 +11,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.12\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-02-21 14:51+0000\n"
+"POT-Creation-Date: 2025-04-11 14:54+0000\n"
 "PO-Revision-Date: 2024-05-11 00:33+0000\n"
 "Last-Translator: Rafael Fontenelle <[email protected]>, 2025\n"
 "Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
@@ -889,6 +889,9 @@ msgid ""
 "each.  When the iterable is exhausted, return elements from the saved copy.  "
 "Repeats indefinitely.  Roughly equivalent to::"
 msgstr ""
+"Crie um iterador que devolve elementos do *iterable* assim como salva uma "
+"cópia de cada um. Quando o iterável é esgotado, devolve elementos da cópia "
+"salva. Repete indefinidamente. Aproximadamente equivalente a::"
 
 #: ../../library/itertools.rst:346
 msgid ""
@@ -908,13 +911,17 @@ msgid ""
 "This itertool may require significant auxiliary storage (depending on the "
 "length of the iterable)."
 msgstr ""
+"Esta itertool pode exigir armazenamento auxiliar significativo (dependendo "
+"do comprimento do iterável)."
 
 #: ../../library/itertools.rst:362
 msgid ""
 "Make an iterator that drops elements from the *iterable* while the "
 "*predicate* is true and afterwards returns every element.  Roughly "
 "equivalent to::"
 msgstr ""
+"Cria um iterador que remove elementos do *iterable* enquanto o *predicate* "
+"for verdadeiro e, em seguida, retorna todos os elementos. Equivalente a:"
 
 #: ../../library/itertools.rst:366
 msgid ""
@@ -930,19 +937,35 @@ msgid ""
 "    for x in iterator:\n"
 "        yield x"
 msgstr ""
+"def dropwhile(predicate, iterable):\n"
+"    # dropwhile(lambda x: x<5, [1,4,6,3,8]) → 6 3 8\n"
+"\n"
+"    iterator = iter(iterable)\n"
+"    for x in iterator:\n"
+"        if not predicate(x):\n"
+"            yield x\n"
+"            break\n"
+"\n"
+"    for x in iterator:\n"
+"        yield x"
 
 #: ../../library/itertools.rst:378
 msgid ""
 "Note this does not produce *any* output until the predicate first becomes "
 "false, so this itertool may have a lengthy start-up time."
 msgstr ""
+"Observe que isso não produz *nenhuma* saída até que o predicado se torne "
+"falso, portanto, esta itertool pode ter um longo tempo de inicialização."
 
 #: ../../library/itertools.rst:384
 msgid ""
 "Make an iterator that filters elements from the *iterable* returning only "
 "those for which the *predicate* returns a false value.  If *predicate* is "
 "``None``, returns the items that are false.  Roughly equivalent to::"
 msgstr ""
+"Cria um iterador que filtre elementos do *iterable*, retornando apenas "
+"aqueles para os quais o *predicate* retorna um valor falso. Se o *predicate* "
+"for ``None``, retorna os itens que são falsos. Equivalente aproximadamente a:"
 
 #: ../../library/itertools.rst:389
 msgid ""
@@ -963,6 +986,11 @@ msgid ""
 "returns the element unchanged.  Generally, the iterable needs to already be "
 "sorted on the same key function."
 msgstr ""
+"Cria um iterador que retorna chaves e grupos consecutivos do *iterable*. A "
+"*key* é uma função que calcula um valor-chave para cada elemento. Se não for "
+"especificado ou for ``None``, *key* assume como padrão uma função de "
+"identidade e retorna o elemento inalterado. Geralmente, o iterável precisa "
+"já estar ordenado na mesma função chave."
 
 #: ../../library/itertools.rst:406
 msgid ""
@@ -972,6 +1000,11 @@ msgid ""
 "the same key function).  That behavior differs from SQL's GROUP BY which "
 "aggregates common elements regardless of their input order."
 msgstr ""
+"O funcionamento de :func:`groupby` é semelhante ao filtro ``uniq`` no Unix. "
+"Ele gera uma quebra ou um novo grupo sempre que o valor da função da tecla "
+"muda (razão pela qual geralmente é necessário ordenar os dados usando a "
+"mesma função da tecla). Esse comportamento difere do GROUP BY do SQL, que "
+"agrega elementos comuns independentemente da ordem de entrada."
 
 #: ../../library/itertools.rst:412
 msgid ""
@@ -980,6 +1013,11 @@ msgid ""
 "`groupby` object is advanced, the previous group is no longer visible.  So, "
 "if that data is needed later, it should be stored as a list::"
 msgstr ""
+"O grupo retornado é, ele próprio, um iterador que compartilha o iterável "
+"subjacente com :func:`groupby`. Como a origem é compartilhada, quando o "
+"objeto :func:`groupby` avança, o grupo anterior não fica mais visível. "
+"Portanto, se esses dados forem necessários posteriormente, eles devem ser "
+"armazenados como uma lista:"
 
 #: ../../library/itertools.rst:417
 msgid ""
@@ -990,6 +1028,13 @@ msgid ""
 "    groups.append(list(g))      # Store group iterator as a list\n"
 "    uniquekeys.append(k)"
 msgstr ""
+"groups = []\n"
+"uniquekeys = []\n"
+"data = sorted(data, key=keyfunc)\n"
+"for k, g in groupby(data, keyfunc):\n"
+"    groups.append(list(g))      # armazena um iterador de grupo como uma "
+"lista\n"
+"    uniquekeys.append(k)"
 
 #: ../../library/itertools.rst:424
 msgid ":func:`groupby` is roughly equivalent to::"
@@ -1029,19 +1074,55 @@ msgid ""
 "            for _ in curr_group:\n"
 "                pass"
 msgstr ""
+"def groupby(iterable, key=None):\n"
+"    # [k for k, g in groupby('AAAABBBCCDAABBB')] → A B C D A B\n"
+"    # [list(g) for k, g in groupby('AAAABBBCCD')] → AAAA BBB CC D\n"
+"\n"
+"    keyfunc = (lambda x: x) if key is None else key\n"
+"    iterator = iter(iterable)\n"
+"    exhausted = False\n"
+"\n"
+"    def _grouper(target_key):\n"
+"        nonlocal curr_value, curr_key, exhausted\n"
+"        yield curr_value\n"
+"        for curr_value in iterator:\n"
+"            curr_key = keyfunc(curr_value)\n"
+"            if curr_key != target_key:\n"
+"                return\n"
+"            yield curr_value\n"
+"        exhausted = True\n"
+"\n"
+"    try:\n"
+"        curr_value = next(iterator)\n"
+"    except StopIteration:\n"
+"        return\n"
+"    curr_key = keyfunc(curr_value)\n"
+"\n"
+"    while not exhausted:\n"
+"        target_key = curr_key\n"
+"        curr_group = _grouper(target_key)\n"
+"        yield curr_key, curr_group\n"
+"        if curr_key == target_key:\n"
+"            for _ in curr_group:\n"
+"                pass"
 
 #: ../../library/itertools.rst:462
 msgid ""
 "Make an iterator that returns selected elements from the iterable. Works "
 "like sequence slicing but does not support negative values for *start*, "
 "*stop*, or *step*."
 msgstr ""
+"Cria um iterador que retorna os elementos selecionados do iterável. Funciona "
+"como o fatiamento de sequência, mas não oferece suporte a valores negativos "
+"para *start*, *stop* ou *step*."
 
 #: ../../library/itertools.rst:466
 msgid ""
 "If *start* is zero or ``None``, iteration starts at zero.  Otherwise, "
 "elements from the iterable are skipped until *start* is reached."
 msgstr ""
+"Se *start* for zero ou ``None``, a iteração começa em zero. Caso contrário, "
+"os elementos do iterável são pulados até que *start* seja alcançado."
 
 #: ../../library/itertools.rst:469
 msgid ""
@@ -1055,6 +1136,9 @@ msgid ""
 "consecutively unless *step* is set higher than one which results in items "
 "being skipped."
 msgstr ""
+"Se *step* for ``None``, o padrão do passo é 1. Os elementos são retornados "
+"consecutivamente, a menos que *step* seja definido como maior que um, o que "
+"resulta na omissão de itens."
 
 #: ../../library/itertools.rst:478
 msgid ""
@@ -1078,6 +1162,25 @@ msgid ""
 "            yield element\n"
 "            next_i += step"
 msgstr ""
+"def islice(iterable, *args):\n"
+"    # islice('ABCDEFG', 2) → A B\n"
+"    # islice('ABCDEFG', 2, 4) → C D\n"
+"    # islice('ABCDEFG', 2, None) → C D E F G\n"
+"    # islice('ABCDEFG', 0, None, 2) → A C E G\n"
+"\n"
+"    s = slice(*args)\n"
+"    start = 0 if s.start is None else s.start\n"
+"    stop = s.stop\n"
+"    step = 1 if s.step is None else s.step\n"
+"    if start < 0 or (stop is not None and stop < 0) or step <= 0:\n"
+"        raise ValueError\n"
+"\n"
+"    indices = count() if stop is None else range(max(start, stop))\n"
+"    next_i = start\n"
+"    for i, element in zip(indices, iterable):\n"
+"        if i == next_i:\n"
+"            yield element\n"
+"            next_i += step"
 
 #: ../../library/itertools.rst:501
 msgid "Return successive overlapping pairs taken from the input *iterable*."