marcação de xrefs em footnotes

Author: ramalho

print/xrefs/xvol_xrefs.py

@@ -164,7 +164,7 @@ def replace_xrefs_to_vols():
         else:
             raise ValueError(f'unexpected xref: {xref!r}')
         link = BASE_URL + '#' + xref
-        print(f'<<{xref}>>', f'{text} [vol.{volume}, fpy.li{SHORT_URLS[link]}]')
+        print(f'<<{xref}>>', f'{text} &#91;vol.{volume}, fpy.li{SHORT_URLS[link]}&#93;')
 
 
 if __name__ == '__main__':

vol1/cap02.adoc

@@ -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 Capítulo 16 [vol.2, fpy.li/4r].]
+|       `+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
@@ -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 Capítulo 16 [vol.2, fpy.li/4r].]
+|       `+s.__rmul__(n)+` |   ●   |   ●   | ++n * s++—concatenação repetida invertida
 |          `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 Capítulo 16 [vol.2, fpy.li/4r].]
+|       `+s.__rmul__(n)+` |   ●   |       | `++n * s`++—concatenação repetida invertida
 |               `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`

vol1/cap03.adoc

@@ -214,9 +214,9 @@ Padrões para mapeamentos se parecem com literais `dict`,
 mas podem casar com instâncias de qualquer subclasse real ou virtual de `collections.abc.Mapping`.footnote:[Uma
 subclasse virtual é
 qualquer classe registrada com uma chamada ao método `.register()` de uma ABC,
-como explicado na Seção 13.5.6 [vol.2, fpy.li/25]
-Um tipo implementado através da API Python/C também serve, se tiver bit de marcação específico setado no header.
-Veja https://fpy.li/2z[`Py_TPFLAGS_MAPPING`] (EN).]
+como explicado na Seção 13.5.6 [vol.2, fpy.li/25].
+Um tipo implementado através da API Python/C também serve, se tiver um bit de marcação específico setado no header.
+Veja `Py_TPFLAGS_MAPPING` [fpy.li/2z] (EN).]
 
 No <<ch_sequences>> nos concentramos apenas nos padrões de sequência,
 mas tipos diferentes de padrões podem ser combinados e aninhados.
@@ -389,7 +389,7 @@ TypeError: unhashable type: 'list'
 
 O código de hash de um objeto pode ser diferente dependendo da versão de Python, da arquitetura da máquina,
 e pelo((("salt"))) _sal_ acrescentado ao cálculo do hash por razões de segurança.footnote:[Veja a
-https://fpy.li/pep456[PEP 456—Secure and interchangeable hash algorithm (Algoritmo de hash seguro e intercambiável_)] (EN)
+_PEP 456—Secure and interchangeable hash algorithm (Algoritmo de hash seguro e intercambiável)_ [fpy.li/pep456&#93; (EN)
 para saber mais sobre as implicações de segurança e as soluções adotadas.]
 O código de hash de um objeto corretamente implementado tem a garantia de ser constante apenas dentro de um processo Python.
 
@@ -437,7 +437,7 @@ A <<mapping_methods_tbl>> mostra os métodos implementados por `dict` e pelas va
 |       `d.pop(k, [default])` |  ●   |      ●      |      ●      | Remove e devolve valor em `k`, ou `default` ou `None`, se `k` não existir
 |               `d.popitem()` |  ●   |      ●      |      ●      | Remove e devolve, na forma `(chave, valor)`, o último item inseridofootnote:[`OrderedDict.popitem(last=False)` remove o primeiro item inserido (FIFO). O argumento nomeado `last` não é suportado por `dict` ou `defaultdict`, pelo menos até Python 3.10b3.]
 |          `+d.__reversed__()+` |  ●   |      ●      |      ●      | Suporte a `reverse(d)`—devolve um iterador de chaves, da última para a primeira a serem inseridas
-|          `+d.__ror__(other)+` |  ●   |      ●      |      ●      | Suporte a `other \| dd`—operador de união invertido (Python ≥ 3.9)footnote:[Operadores invertidos são tratados no Capítulo 16 [vol.2, fpy.li/4r].]
+|          `+d.__ror__(other)+` |  ●   |      ●      |      ●      | Suporte a `other \| dd`—operador de união invertido (Python ≥ 3.9)footnote:[Operadores invertidos são tratados no Capítulo 16 [vol.2, fpy.li/4r&#93;.]
 |`d.setdefault(k, [default])` |  ●   |      ●      |      ●      | Se `k in d`, devolve `d[k]`; senão, atribui `d[k] = default` e devolve isso
 |       `+d.__setitem__(k, v)+` |  ●   |      ●      |      ●      | `d[k] = v`—coloca `v` em `k`
 |   `d.update(m, [**kwargs])` |  ●   |      ●      |      ●      | Atualiza `d` com itens de um mapeamento ou iterável de pares `(chave, valor)`

vol1/cap05.adoc

@@ -170,7 +170,7 @@ include::../code/05-data-classes/typing_namedtuple/coordinates.py[tags=COORDINAT
 Apesar de `NamedTuple` aparecer na declaração `class` como uma superclasse, ela não é.
 `typing.NamedTuple` usa a funcionalidade avançada de uma
 metaclassefootnote:[As metaclasses são um dos assuntos tratados no
-Capítulo 24 [vol.3, fpy.li/53].] para customizar a criação da classe do usuário.
+Capítulo 24 [vol.3, fpy.li/53].] para customizar a criação da classe do usuário.
 Confira isso:
 
 [source, python]
@@ -205,7 +205,7 @@ Observe que o corpo das classes no <<coord_tuple_ex>> e no <<coord_dataclass_ex>
 são idênticos—a diferença está na própria declaração `class`.
 O decorador `@dataclass` não depende de herança ou de uma metaclasse,
 então não deve interferir no uso desses mecanismos pelo
-usuário.footnote:[Decoradores de classe são discutidos no Capítulo 24 [vol.3, fpy.li/53],
+usuário.footnote:[Decoradores de classe são discutidos no Capítulo 24 [vol.3, fpy.li/53&#93;],
 na seção "Metaprogramação de classes", junto com as metaclasses.
 Ambos são formas de customizar o comportamento de uma classe além do que seria possível com herança.]
 A classe `Coordinate` no <<coord_dataclass_ex>> é uma subclasse de

vol1/cap07.adoc

@@ -339,7 +339,11 @@ Métodos:: Funções definidas no corpo de uma classe.
 
 Classes:: Quando((("classes", "as callable objects"))) invocada, uma classe executa seu método
 `+__new__+` para criar uma instância, e a seguir `+__init__+`, para inicializá-la. Então a instância é devolvida ao usuário.
-Como não existe um operador `new` no Python, invocar uma classe é como invocar uma função.footnote:[Invocar uma classe normalmente cria uma instância daquela mesma classe, mas outros comportamentos são possíveis, sobrescrevendo o `+__new__+`. Veremos um exemplo disso na Seção 22.2.3 [vol.3, fpy.li/5b].]
+Como não existe um operador `new` no Python,
+invocar uma classe é como invocar uma função.footnote:[Invocar
+uma classe normalmente cria uma instância daquela mesma classe,
+mas outros comportamentos são possíveis, sobrescrevendo o `+__new__+`.
+Veremos um exemplo disso na Seção 22.2.3 [vol.3, fpy.li/5b].]
 
 Instâncias de classe:: Se uma classe define um método `+__call__+`, suas instâncias podem então ser invocadas como funções—esse é o assunto da próxima seção.
 

vol1/cap08.adoc

@@ -1880,7 +1880,11 @@ include::../code/08-def-type-hints/comparable/top_test.py[tags=TOP_TEST]
 ----
 ====
 <1> A constante `typing.TYPE_CHECKING` é sempre `False` durante a execução do programa, mas os checadores de tipos fingem que ela é `True` quando estão fazendo a verificação.
-<2> Declaração de tipo explícita para a variável `series`, para tornar mais fácil a leitura da saída do Mypy.footnote:[Sem essa dica de tipo, o Mypy inferiria o tipo de `series` como `Generator[Tuple[builtins.int, builtins.str*&#x5d;, None, None&#x5d;`, que é prolixo mas _consistente-com_ `Iterator[tuple[int, str&#x5d;&#x5d;`, como veremos na Seção 17.12 [vol.3, fpy.li/5k].]
+<2> Declaração de tipo explícita para a variável `series`, para tornar mais fácil a leitura da saída do
+Mypy.footnote:[Sem essa dica de tipo, o Mypy inferiria o tipo de `series` como
+`Generator[Tuple[builtins.int, builtins.str*&#x5d;, None, None&#x5d;`,
+que é prolixo mas _consistente-com_ `Iterator[tuple[int, str&#x5d;&#x5d;`,
+como veremos na Seção 17.12 [vol.3, fpy.li/5k&#93;.]
 <3> Esse `if` evita que as três linhas seguintes sejam executadas durante o teste.
 <4> `reveal_type()` não pode ser chamada durante a execução, porque não é uma função regular, mas sim um mecanismo de depuração do Mypy - por isso não há `import` para ela.
 Mypy vai produzir uma mensagem de depuração para cada chamada à pseudo-função `reveal_type()`, mostrando o tipo inferido do argumento.