xrefs para outros volumes resolvidas

Author: ramalho

print/xrefs/xvol_replacer.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import tempfile
+import shutil
+
+def load_replacements(mapping_file):
+    replacements = []
+    with open(mapping_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            old, new = line.split(maxsplit=1)
+            replacements.append((old, new))
+    return replacements
+
+def replace_in_file(file_path, replacements):
+    with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
+        temp_filename = temp_file.name
+        with open(file_path, 'r') as original_file:
+            content = original_file.read()
+            for old_text, new_text in replacements:
+                content = content.replace(old_text, new_text)
+            temp_file.write(content)
+    shutil.move(temp_filename, file_path)
+
+def main():
+    if len(sys.argv) < 3:
+        print("xvol_replacer.py mapping_file.tsv file1.txt file2.txt ...")
+        sys.exit(1)
+    
+    mapping_file = sys.argv[1]
+    target_files = sys.argv[2:]
+    
+    replacements = load_replacements(mapping_file)
+    
+    for file_path in target_files:
+        if os.path.exists(file_path) and not os.path.isdir(file_path):
+            replace_in_file(file_path, replacements)
+
+if __name__ == "__main__":
+    main()

vol1/cap01.adoc

@@ -324,7 +324,7 @@ startref="len01")))((("", startref="pycard01")))((("", startref="SMgetitem01")))
 Como foi implementado até aqui, um `FrenchDeck` não pode ser embaralhado,
 porque as cartas e suas posições não podem ser alteradas,
 exceto violando o encapsulamento e manipulando o atributo `_cards` diretamente.
-No <<ch_ifaces_prot_abc>> vamos corrigir isso acrescentando um método `+__setitem__+`
+No Capítulo 13 [vol.2, fpy.li/4q] vamos corrigir isso acrescentando um método `+__setitem__+`
 de uma linha.
 Você consegue imaginar como ele seria implementado?
 =====================================================================
@@ -380,7 +380,7 @@ Na próxima seção veremos alguns dos usos mais importantes dos métodos especi
 Vários((("special methods", "emulating numeric types", id="SMnumeric01")))((("numeric types",
 "emulating using special methods", id="NTemul01")))
 métodos especiais permitem que objetos criados pelo usuário respondam a operadores como `+`.
-Vamos tratar disso com mais detalhes no <<ch_op_overload>>.
+Vamos tratar disso com mais detalhes no Capítulo 16 [vol.2, fpy.li/4r].
 Aqui nosso objetivo é continuar ilustrando o uso dos métodos especiais, através de outro exemplo simples.
 
 Vamos((("vectors", "representing two-dimensional", id="Vtwo01"))) implementar uma classe para representar
@@ -391,7 +391,7 @@ vetores bi-dimensionais—isto é, vetores euclidianos como aqueles usados em ma
 ======
 O tipo embutido `complex` pode ser usado para representar vetores bi-dimensionais,
 mas nossa classe pode ser estendida para representar vetores N-dimensionais.
-Faremos isso em <<ch_generators>>.
+Faremos isso em Capítulo 17 [vol.3, fpy.li/4s].
 ======
 
 [[vectors_fig]]
@@ -459,14 +459,14 @@ para demonstrar o uso básico de `+__add__+` e `+__mul__+`.
 No dois casos, os métodos criam e devolvem uma nova instância de `Vector`,
 e não modificam nenhum dos operandos: `self` e `other` são apenas lidos.
 Esse é o comportamento esperado de operadores infixos: criar novos objetos e não tocar em seus operandos.
-Vou falar mais sobre esse tópico no <<ch_op_overload>>.
+Vou falar mais sobre esse tópico no Capítulo 16 [vol.2, fpy.li/4r].
 
 [WARNING]
 ====
 Da forma como está implementado, o <<ex_vector2d>> permite multiplicar um `Vector` por um número,
 mas não um número por um `Vector`,
 violando a propriedade comutativa da multiplicação escalar.
-Vamos consertar isso com o método especial `+__rmul__+` no <<ch_op_overload>>.
+Vamos consertar isso com o método especial `+__rmul__+` no Capítulo 16 [vol.2, fpy.li/4r].
 ====
 
 Nas seções seguintes vamos discutir os outros métodos especiais em
@@ -585,7 +585,7 @@ id="SMcollection01")))((("Collection API", id="Cspeical01")))((("ABCs (abstract
 as interfaces dos tipos de coleções essenciais na linguagem.
 Todas as classes no diagrama são ABCs—_classes base abstratas_
 (_ABC_ é sigla para _Abstract Base Class_).
-As ABCs e o módulo `collections.abc` são tratados no <<ch_ifaces_prot_abc>>.
+As ABCs e o módulo `collections.abc` são tratados no Capítulo 13 [vol.2, fpy.li/4q].
 O objetivo dessa pequena seção é dar uma visão panorâmica das interfaces das coleções mais importantes de Python,
 mostrando como elas são criadas a partir de métodos especiais.
 
@@ -670,7 +670,7 @@ Operadores infixos e numéricos são suportados pelos métodos especiais listado
 <<special_operators_tbl>>.
 Aqui os nomes mais recentes são `+__matmul__+`, `+__rmatmul__+`, e `+__imatmul__+`,
 adicionados no Python 3.5 para suportar o uso de `@` como operador de multiplicação de matrizes,
-como veremos no <<ch_op_overload>>.((("special methods", "special method names and symbols for operators")))
+como veremos no Capítulo 16 [vol.2, fpy.li/4r].((("special methods", "special method names and symbols for operators")))
 
 [[special_operators_tbl]]
 .Nomes e símbolos de métodos especiais para operadores
@@ -693,7 +693,7 @@ Python invoca um método especial de operador reverso no segundo argumento
 quando o método especial correspondente não pode ser usado no primeiro operando.
 Atribuições aumentadas são atalho combinando um operador infixo com uma atribuição de variável, por exemplo `a += b`.
 
-O <<ch_op_overload>> explica em detalhes os operadores reversos e a atribuição aumentada.((("", startref="PDMspmtov01")))
+O Capítulo 16 [vol.2, fpy.li/4r] explica em detalhes os operadores reversos e a atribuição aumentada.((("", startref="PDMspmtov01")))
 ====
 
 
@@ -741,14 +741,14 @@ uma para depuração e registro (_log_), outra para apresentar aos usuários fin
 Emular sequências, como mostrado com o exemplo do `FrenchDeck`, é um dos usos mais comuns dos métodos especiais.
 Por exemplo, bibliotecas de banco de dados frequentemente devolvem resultados de consultas na forma de coleções similares a sequências.
 Tirar o máximo proveito dos tipos de sequências existentes é o assunto do <<ch_sequences>>.
-Como implementar suas próprias sequências será visto no <<ch_seq_methods>>,
+Como implementar suas próprias sequências será visto no Capítulo 12 [vol.2, fpy.li/4t],
 onde criaremos uma extensão multidimensional da classe `Vector`.
 
 Graças à sobrecarga de operadores, Python oferece uma rica seleção de tipos numéricos,
 desde os tipos embutidos até `decimal.Decimal` e `fractions.Fraction`,
 todos eles suportando operadores aritméticos infixos.
 As bibliotecas de ciência de dados _NumPy_ suportam operadores infixos com matrizes e tensores.
-A implementação de operadores—incluindo operadores reversos e atribuição aumentada—será vista no <<ch_op_overload>>,
+A implementação de operadores—incluindo operadores reversos e atribuição aumentada—será vista no Capítulo 16 [vol.2, fpy.li/4r],
 usando melhorias do exemplo `Vector`.
 
 Também veremos o uso e a implementação da maioria dos outros métodos especiais do Modelo de Dados de Python ao longo deste livro.

vol1/cap02.adoc

@@ -29,7 +29,7 @@ desde a conhecida `list` até os tipos `str` e `bytes`, adicionados no Python 3.
 Tópicos específicos sobre listas, tuplas, arrays e filas também foram incluídos,
 mas os detalhes sobre strings Unicode e sequências de bytes são tratados no <<ch_str_bytes>>.
 Além disso, a ideia aqui é falar sobre os tipos de sequências prontas para usar.
-A criação de novos tipos de sequência é o tema do <<ch_seq_methods>>.
+A criação de novos tipos de sequência é o tema do Capítulo 12 [vol.2, fpy.li/4t].
 
 Os((("sequences", "topics covered"))) principais tópicos cobertos neste capítulo são:
 
@@ -118,7 +118,7 @@ A <<sequence_uml>> ajuda a visualizar como as sequências mutáveis herdam todos
 das sequências imutáveis e implementam vários métodos adicionais.
 Os tipos embutidos de sequências na verdade não são subclasses das classes base abstratas (ABCs)
 `Sequence` e `MutableSequence`, mas sim _subclasses virtuais_ registradas com aquelas
-ABCs—como veremos no <<ch_ifaces_prot_abc>>.
+ABCs—como veremos no Capítulo 13 [vol.2, fpy.li/4q].
 Por serem subclasses virtuais, `tuple` e `list` passam nesses testes:
 
 [source, python]
@@ -448,7 +448,7 @@ nunca é criada neste exemplo.
 
 [NOTE]
 ====
-O <<ch_generators>> explica em detalhes o funcionamento de geradoras.
+O Capítulo 17 [vol.3, fpy.li/4s] explica em detalhes o funcionamento de geradoras.
 A ideia aqui é apenas mostrar o uso de expressões geradores para inicializar sequências diferentes de listas,
 ou produzir uma saída que não precise ser mantida na memória.
 ====
@@ -662,7 +662,7 @@ Entretanto, `reversed(my_tuple)` funciona sem esse método; ele serve apenas par
 |         `+s.__len__()+` |   ●   |   ●   | `+len(s)+`—número de itens
 |        `+s.__mul__(n)+` |   ●   |   ●   | `+s * n+`—concatenação repetida
 |       `+s.__imul__(n)+` |   ●   |       | `+s *= n+`—concatenação repetida no mesmo lugar
-|       `+s.__rmul__(n)+` |   ●   |   ●   | `+n * s+`—concatenação repetida inversafootnote:[Operadores invertidos são explicados no <<ch_op_overload>>.]
+|       `+s.__rmul__(n)+` |   ●   |   ●   | `+n * s+`—concatenação repetida inversafootnote:[Operadores invertidos são explicados no Capítulo 16 [vol.2, fpy.li/4r].]
 |            `s.pop([p])` |   ●   |       | Remove e devolve o último item ou o item na posição opcional `p`
 |           `s.remove(e)` |   ●   |       | Remove o primeiro elemento de valor igual a `e`
 |           `s.reverse()` |   ●   |       | Reverte, no lugar, a ordem dos itens
@@ -893,7 +893,7 @@ Você pode querer ler aquela revisão rápida.
 Neste livro, dividi o tratamento do casamento de padrões em diferentes capítulos,
 dependendo dos tipos de padrão:
 na <<pattern_matching_mappings_sec>> e na <<pattern_instances_sec>>.
-E há um exemplo mais longo na <<pattern_matching_case_study_sec>>.
+E há um exemplo mais longo na Seção 18.3 [vol.3, fpy.li/22].
 ====
 
 Vamos ao primeiro exemplo do tratamento de sequências com `match/case`.
@@ -1146,7 +1146,7 @@ O corpo da função é a expressão `(* n 2)`.
 O resultado da chamada a uma função em Scheme é o valor da última expressão no corpo da função chamada.
 
 Nosso foco aqui é a desestruturação de sequências, então não vou explicar as ações do avaliador.
-Veja a <<pattern_matching_case_study_sec>> para aprender mais sobre o funcionamento do _lis.py_.
+Veja a Seção 18.3 [vol.3, fpy.li/22] para aprender mais sobre o funcionamento do _lis.py_.
 
 O <<ex_norvigs_eval>> mostra o avaliador de Norvig com algumas pequenas modificações,
 abreviado para mostrar apenas os padrões de sequência.
@@ -1299,7 +1299,7 @@ tenha convencido você que `match/case` pode tornar seu código mais legível e
 
 [NOTE]
 ====
-Veremos mais do _lis.py_ na <<pattern_matching_case_study_sec>>,
+Veremos mais do _lis.py_ na Seção 18.3 [vol.3, fpy.li/22],
 quando vamos revisar o exemplo completo de `match/case` em `evaluate`.
 Se você quiser aprender mais sobre o _lys.py_ de Norvig, leia seu maravilhoso post
 https://fpy.li/2-12["(How to Write a (Lisp) Interpreter (in Python))" _(Como Escrever um Interpretador (Lisp) em (Python))_].
@@ -1320,9 +1320,9 @@ recurso comum a `list`, `tuple`, `str`, e a todos os tipos de sequência em Pyth
 é o suporte a operações de fatiamento, que são mais potentes do que a maioria das pessoas percebe.
 
 Nesta seção descrevemos o _uso_ dessas formas avançadas de fatiamento.
-Sua implementação em uma classe definida pelo usuário será tratada no <<ch_seq_methods>>,
+Sua implementação em uma classe definida pelo usuário será tratada no Capítulo 12 [vol.2, fpy.li/4t],
 mantendo nossa filosofia de tratar de classes prontas para usar nessa parte do livro,
-e da criação de novas classes na <<classes_protocols_part>>.
+e da criação de novas classes na Parte III—Classes e protocolos [vol.2, fpy.li/4v].
 
 
 ==== Por que fatias e faixas excluem o último item?
@@ -1383,7 +1383,7 @@ Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]
 A notação `a:b:c` só é válida entre `[]` quando usada como operador de indexação ou de subscrição (_subscript_),
 e produz um objeto fatia (_slice object_): `slice(a, b, c)`.
 Para avaliar a expressão `seq[start:stop:step]`,
-o Python chama `+seq.__getitem__(slice(start, stop, step))+`, como veremos na <<how_slicing_works_sec>>.
+o Python chama `+seq.__getitem__(slice(start, stop, step))+`, como veremos na Seção 12.5.1 [vol.2, fpy.li/4w].
 Mesmo se você não for implementar seus próprios tipos de sequência, saber dos objetos fatia é útil,
 porque eles permitem que você atribua nomes às fatias, da mesma forma que planilhas permitem dar nomes a faixas de células.
 
@@ -1419,7 +1419,7 @@ Veja como isso torna legível o loop `for` no final do exemplo.
 ----
 ====
 
-Voltaremos aos objetos +slice+ quando formos discutir a criação de suas próprias coleções, na <<sliceable_sequence_sec>>.
+Voltaremos aos objetos +slice+ quando formos discutir a criação de suas próprias coleções, na Seção 12.5 [vol.2, fpy.li/4x].
 Enquanto isso, do ponto de vista do usuário, o fatiamento tem recursos adicionais,
 como fatias multidimensionais e a notação de reticências (`\...`).
 Siga comigo.
@@ -1651,7 +1651,7 @@ que `+=` acontece _in-place_.
 Para sequências imutáveis, obviamente isso não pode acontecer.
 
 O que acabei de escrever sobre `+=` também se aplica a `\*=`, que é implementado via `++__imul__++`.
-Os métodos especiais `++__iadd__++` e `++__imul__++` são tratados no <<ch_op_overload>>.
+Os métodos especiais `++__iadd__++` e `++__imul__++` são tratados no Capítulo 16 [vol.2, fpy.li/4r].
 
 Veja uma demonstração de `*=` com uma sequência mutável e depois com uma sequência imutável:
 
@@ -1822,7 +1822,7 @@ da Wikipedia em inglês para uma descrição mais detalhada deste tópico.
 ====
 
 A função embutida `sorted`, por outro lado, cria e devolve uma nova lista.
-Ela aceita qualquer objeto iterável como um argumento, incluindo sequências imutáveis e geradores (veja o <<ch_generators>>).
+Ela aceita qualquer objeto iterável como um argumento, incluindo sequências imutáveis e geradores (veja o Capítulo 17 [vol.3, fpy.li/4s]).
 Independente do tipo do iterável passado a `sorted`, ela sempre cria e devolve uma nova lista.
 
 Tanto `list.sort` quanto `sorted` podem receber dois argumentos nomeados opcionais:
@@ -2035,7 +2035,7 @@ comparando as características de `list` e `array.array`.
 |         `+s.__len__()+` |   ●   |   ●   | `++len(s)++`—número de itens
 |        `+s.__mul__(n)+` |   ●   |   ●   | `++s * n++`—concatenação repetida
 |       `+s.__imul__(n)+` |   ●   |   ●   | `++s *= n++`—concatenação repetida no mesmo lugar
-|       `+s.__rmul__(n)+` |   ●   |   ●   | ++n * s++—concatenação repetida invertidafootnote:[Operadores invertidos são explicados no <<ch_op_overload>>.]
+|       `+s.__rmul__(n)+` |   ●   |   ●   | ++n * s++—concatenação repetida invertidafootnote:[Operadores invertidos são explicados no Capítulo 16 [vol.2, fpy.li/4r].]
 |          `s.pop([p])` |   ●   |   ●   | Remove e devolve o item na posição `p` (default: o último)
 |         `s.remove(e)` |   ●   |       | Remove o primeiro elemento de valor igual a `e`
 |         `s.reverse()` |   ●   |   ●   | Reverte a ordem dos itens no mesmo lugar
@@ -2374,7 +2374,7 @@ então `deque` pode ser usado de forma segura como uma fila FIFO em aplicações
 |         `+s.__len__()+` |   ●   |   ●   | `++len(s)++`—número de itens
 |        `+s.__mul__(n)+` |   ●   |       | `++s * n++`—concatenação repetida
 |       `+s.__imul__(n)+` |   ●   |       | `++s *= n++`—concatenação repetida no mesmo lugar
-|       `+s.__rmul__(n)+` |   ●   |       | `++n * s`++—concatenação repetida invertidafootnote:[Operadores invertidos são explicados no <<ch_op_overload>>.]
+|       `+s.__rmul__(n)+` |   ●   |       | `++n * s`++—concatenação repetida invertidafootnote:[Operadores invertidos são explicados no Capítulo 16 [vol.2, fpy.li/4r].]
 |               `s.pop()` |   ●   |   ●   | Remove e devolve último itemfootnote:[`a_list.pop(p)` permite remover da posição `p`, mas `deque` não suporta essa opção.]
 |           `s.popleft()` |       |   ●   | Remove e devolve primeiro item
 |           `s.remove(e)` |   ●   |       | Remove o primeiro elemento de valor igual a `e`