Mantém todos os exercícios nas tabelas com ajuste automático da fonte

Remove blocos fixos de quatro/cinco anos e encurta rótulos de construção. Mede os dados preenchidos, margens e notas para selecionar fonte uniforme a partir de 8 pt, em passos de 0,5 pt. Aplica aos comparativos, fundamentação e conclusões. Validado com 106 testes e renderização da cobaia de cinco exercícios e três construções.

README.md

@@ -143,6 +143,8 @@ O arquivo é lido novamente no backend ao gerar o documento; os valores da prév
 
 O laudo evolutivo apresenta no corpo as seções **3.3 Terreno**, **3.4 Construções** e **3.5 Composição do imóvel**, com parâmetros por exercício, variáveis e equação, áreas de modelo e aplicação, CUB histórico simples ou composto, adequação, BDI, Ross-Heidecke, residual, Kd, redutores e Fc. A seção 4 discrimina fundamentação dos componentes e global, com a precisão restrita ao terreno. A conclusão mostra o valor adotado e seu extenso; a composição conserva o resultado calculado.
 
+Os quadros comparativos mantêm todos os exercícios na mesma tabela, sem dividir o quinto ano em outro quadro. Depois do preenchimento dos valores e marcadores de notas, a fonte parte de 8 pt e diminui em passos de 0,5 pt conforme a estimativa de largura e altura disponíveis. Os valores monetários e os anos são medidos para caberem sem quebra; cabeçalhos e valores usam o mesmo tamanho. A regra também se aplica aos quadros anuais de fundamentação e conclusão. As notas de rodapé permanecem em 7 pt.
+
 Em **5. Avaliação**, a revisão recupera as justificativas públicas salvas e permite complementar VU, área, BDI por sequência, Fc, ajustes não aplicados e critério de adoção. É possível reutilizar deliberadamente as justificativas nos demais exercícios. Critérios de fundamentação não preenchidos continuam pendentes; observações internas não são publicadas. Conferências com os dados salvos apontam divergências sem corrigir os resultados.
 
 Os anexos estatísticos EVO usam o modelo do catálogo (dataset da MESA no Hugging Face ou pasta local no desenvolvimento) somente quando coeficientes, covariância, transformações e amostra correspondem ao contexto preservado. Caso contrário, o documento registra a falta de correspondência e utiliza o contexto importado na narrativa. Resultados não são reestimados. As avaliações AME e o preenchimento manual mantêm seus fluxos próprios.

document/avaliacoes_importadas.py

@@ -1,6 +1,6 @@
 """Document sections based on the adopted results saved in AME/EVO."""
 from .formatters import add_body_text, add_simple_table, add_subsection_title
-from .formatters.table import set_table_font_size
+from .formatters.table_fit import fit_table_to_page
 from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
 
 
@@ -26,7 +26,7 @@ def conclusion_table(doc, imported):
         from .evolutivo import table
         table(doc,rows,[1.3,3.4,1.6],keep_together=len(rows)<=9,font_size=7)
     else:
-        set_table_font_size(add_simple_table(doc, rows, header_row=True, largura_colunas=[1.4, 3.6, 2.5]),7)
+        fit_table_to_page(doc, add_simple_table(doc, rows, header_row=True, largura_colunas=[1.4, 3.6, 2.5]))
     from utils.formatters import numero_para_extenso
     for item in imported['avaliacoes']:
         extenso = numero_para_extenso(Decimal(item['valor_total']))

document/evolutivo.py

@@ -2,6 +2,7 @@
 from collections import OrderedDict
 from decimal import Decimal, ROUND_HALF_UP
 import json
+import re
 
 from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.oxml import OxmlElement
@@ -15,6 +16,7 @@ from .evo_adjustments import REDUCERS, applied_reducers
 from .fundamentacao import number, global_foundation
 from .footnotes import add_footnote
 from .formatters.table import set_table_font_size
+from .formatters.table_fit import fit_table_to_page
 from .anexos.metodologia import (_gerar_variaveis, _adicionar_pesquisa,
                                 _adicionar_fundamentos_comparativos, _adicionar_tabela_equacao)
 from models.imported_context import context_key, snapshot_model, matching_local
@@ -57,8 +59,9 @@ def complement(row, key, fallback='Não informado no arquivo; complemento técni
     return (row.get('complementos') or {}).get(key) or fallback
 
 
-def table(doc, rows, widths=None, compact=False, keep_together=False, font_size=None):
+def table(doc, rows, widths=None, compact=False, keep_together=False, font_size=None, auto_fit=True):
     section = doc.sections[-1]
+    annual = any(re.search(r'\bIPTU\s+\d{4}\b', str(value)) for row in rows for value in row)
     if doc.paragraphs:
         previous = doc.paragraphs[-1]
         if previous.text.startswith(('Construção ', 'Composição das áreas', 'IPTU ', 'Memória integral', 'Memória das etapas')):
@@ -71,7 +74,7 @@ def table(doc, rows, widths=None, compact=False, keep_together=False, font_size=
             props = cell._tc.get_or_add_tcPr()
             for no_wrap in list(props.findall(qn('w:noWrap'))): props.remove(no_wrap)
             margins = OxmlElement('w:tcMar')
-            padding = 25 if compact else 65
+            padding = 25 if compact or annual else 65
             for side, size in [('top',padding),('bottom',padding),('left',80),('right',80)]:
                 node = OxmlElement('w:'+side); node.set(qn('w:w'), str(size)); node.set(qn('w:type'),'dxa'); margins.append(node)
             props.append(margins)
@@ -83,7 +86,9 @@ def table(doc, rows, widths=None, compact=False, keep_together=False, font_size=
     for side in ['top','left','bottom','right','insideH','insideV']:
         node = OxmlElement('w:'+side); node.set(qn('w:val'),'single'); node.set(qn('w:sz'),'4'); node.set(qn('w:color'),'D9D9D9'); borders.append(node)
     obj._tbl.tblPr.append(borders)
-    if font_size is not None:
+    if annual and auto_fit:
+        fit_table_to_page(doc, obj)
+    elif font_size is not None:
         set_table_font_size(obj, font_size)
     return obj
 
@@ -105,20 +110,21 @@ def equation(doc, text):
         para.paragraph_format.keep_together = True
 
 
-def compared(doc, rows, metrics, notes=None, batch_size=4, show_base=False):
-    """Keep references distinct, with a wider batch for short result labels."""
-    for offset in range(0,len(rows),batch_size):
-        batch = rows[offset:offset+batch_size]
-        labels = [ref(row, show_base=show_base) for row in batch]
-        duplicates = len(set(labels)) != len(labels)
-        if duplicates: labels = [f"{label}\n{row['titulo_origem']} [{row['id']}]" for label,row in zip(labels,batch)]
-        # Short comparative tables stay with their captions; longer ones may
-        # continue with the repeated header.
-        obj = table(doc, [['Parâmetro / resultado']+labels] + [[label]+[getter(row) for row in batch] for label,getter in metrics], [2.4]+[1.45]*len(batch), keep_together=len(metrics)<=12)
-        for index, (label, _) in enumerate(metrics, 1):
-            if notes and label in notes:
-                add_footnote(doc, obj.rows[index].cells[0].paragraphs[0], notes[label])
-        set_table_font_size(obj, 7)
+def compared(doc, rows, metrics, notes=None, show_base=False):
+    """Keep all exercises in one table and fit after values and notes exist."""
+    if not rows:
+        return
+    labels = [ref(row, show_base=show_base) for row in rows]
+    if len(set(labels)) != len(labels):
+        labels = [f"{label}\n{row['titulo_origem']} [{row['id']}]" for label,row in zip(labels,rows)]
+    obj = table(doc, [['Parâmetro / valor']+labels] + [[label]+[getter(row) for row in rows] for label,getter in metrics],
+                [2.4]+[1.45]*len(rows), auto_fit=False)
+    used_notes = []
+    for index, (label, _) in enumerate(metrics, 1):
+        if notes and label in notes:
+            add_footnote(doc, obj.rows[index].cells[0].paragraphs[0], notes[label])
+            used_notes.append(notes[label])
+    fit_table_to_page(doc, obj, notes=used_notes)
 
 
 def model_analysis(doc, model, tipo_y):
@@ -204,7 +210,7 @@ def gerar_corpo_evolutivo(doc, imported, num, caracteristicas_refs=None):
         'Estimado Unitário': 'Estimativa do valor do terreno por metro quadrado (R$/m²), antes dos ajustes. Quando o modelo estima o valor total, corresponde à conversão desse valor pela área utilizada no modelo.',
         'CA −15%': 'CA: campo de arbítrio. CA −15% e CA +15% são os limites inferior e superior, correspondentes a 85% e 115% da estimativa central. N��o representam descontos automaticamente aplicados. Os limites são expressos na unidade da variável dependente do modelo: R$/m² no modelo unitário e R$ no modelo total.',
         'IC 80% Inf.': 'IC 80%: intervalo de confiança de 80% da estimativa do modelo. Inf. e Sup. indicam seus limites inferior e superior. Expressam a incerteza estatística e não se confundem com o campo de arbítrio. Os limites são expressos em R$/m² no modelo unitário e R$ no modelo total.',
-    }, batch_size=5)
+    })
     add_body_text(doc,'A referência anual das avaliações é distinta do ano-base omitido na codificação das variáveis dicotômicas do modelo.')
     heading(doc,num,'Ajustes aplicados e valor territorial adotado',4)
     # Load after shared formatters are available to the narrative helper.
@@ -259,16 +265,16 @@ def gerar_corpo_evolutivo(doc, imported, num, caracteristicas_refs=None):
         # annual inputs together; characteristics above are grouped by changes.
         compared(doc,[row for row,c,i in entries],[
             ('Data do CUB',lambda row:cub_date(row)),
-            ('Projeto / composição CUB',lambda row:'CUB composto' if by_id[row['id']].get('cubCompostoAtivo') else str(by_id[row['id']].get('cubTipo') or 'Não informado')),
-            ('CUB histórico (R$/m²)',lambda row:currency(by_id[row['id']].get('valorCub'))),
-            ('Adequação do CUB (%)',lambda row:pct(by_id[row['id']].get('percentualCubCalculado',by_id[row['id']].get('percentualCub')))),
+            ('Projeto CUB',lambda row:'Composto' if by_id[row['id']].get('cubCompostoAtivo') else str(by_id[row['id']].get('cubTipo') or 'Não informado').split(' (',1)[0]),
+            ('CUB (R$/m²)',lambda row:currency(by_id[row['id']].get('valorCub'))),
+            ('Adequação CUB (%)',lambda row:pct(by_id[row['id']].get('percentualCubCalculado',by_id[row['id']].get('percentualCub')))),
             ('CUNIT (R$/m²)',lambda row:currency(by_id[row['id']].get('custoUnitario'))),
             ('BDI (%)',lambda row:pct(by_id[row['id']].get('bdi'))),
-            ('Multiplicador 1 + BDI/100',lambda row:fmt(1+number(by_id[row['id']]['bdi'])/100,4) if number(by_id[row['id']].get('bdi')) is not None else 'Não informado'),
+            ('Fator BDI',lambda row:fmt(1+number(by_id[row['id']]['bdi'])/100,4) if number(by_id[row['id']].get('bdi')) is not None else 'Não informado'),
             ('Vida útil consumida (%)',lambda row:pct(by_id[row['id']].get('percentualVidaUtil'))),
             ('Depreciação K',lambda row:fmt(by_id[row['id']].get('depreciacao'),4)),
-            ('Fator remanescente Kd',lambda row:fmt(by_id[row['id']].get('kd'),3)),
-            ('Valor da construção - VC (R$)',lambda row:currency(by_id[row['id']].get('vcalcConstSeq'))),
+            ('Kd',lambda row:fmt(by_id[row['id']].get('kd'),3)),
+            ('Valor da construção (R$)',lambda row:currency(by_id[row['id']].get('vcalcConstSeq'))),
         ])
     refs['composicao'] = heading(doc,num,'AVALIAÇÃO DO IMÓVEL OBJETO',2)
     add_body_text(doc,'Na ausência de outros ajustes, a composição corresponde a VI = (VT + VC) × Fc, em que VT é o valor territorial e VC é o custo de reedição das construções. Havendo ajustes, a sequência efetivamente salva, apresentada abaixo, prevalece sobre essa expressão simplificada.').paragraph_format.keep_with_next = True

document/formatters/table_fit.py

@@ -0,0 +1,120 @@
+"""Fit annual tables after their values and footnote markers have been filled."""
+from functools import lru_cache
+from math import ceil
+from pathlib import Path
+import re
+
+from PIL import ImageFont
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+
+from .table import set_table_font_size
+
+
+@lru_cache(maxsize=2)
+def _font(bold=False):
+    # The same bundled metrics are available locally and in Spaces. DejaVu Sans
+    # is slightly wider than Arial, leaving a margin for Word font substitution.
+    from matplotlib import get_data_path
+    name = 'DejaVuSans-Bold.ttf' if bold else 'DejaVuSans.ttf'
+    return ImageFont.truetype(str(Path(get_data_path()) / 'fonts' / 'ttf' / name), 1000)
+
+
+@lru_cache(maxsize=8192)
+def _width(text, bold=False):
+    return _font(bold).getlength(text) / 1000
+
+
+def _lines(text, width, size, bold=False):
+    """Estimate wrapping using glyph widths, preserving explicit line breaks."""
+    count = 0
+    for line in text.split('\n'):
+        used = 0
+        count += 1
+        for word in re.findall(r'\S+', line):
+            length = _width(word, bold) * size
+            gap = _width(' ', bold) * size if used else 0
+            if used and used + gap + length > width:
+                count += 1
+                used = 0
+                gap = 0
+            if length > width:
+                extra = max(0, ceil(length / width) - 1)
+                count += extra
+                used = length - extra * width
+            else:
+                used += gap + length
+    return count
+
+
+def _margin(cell, side, default):
+    margins = cell._tc.get_or_add_tcPr().find(qn('w:tcMar'))
+    node = margins.find(qn('w:' + side)) if margins is not None else None
+    return int(node.get(qn('w:w'), default)) / 20 if node is not None else default / 20
+
+
+def fit_table_to_page(doc, table, notes=()):
+    """Select the largest half-point size <= 8 that fits the populated table.
+
+    Currency, numbers and year labels must fit on one line. Other text can wrap.
+    Height includes cell padding, the caption allowance and 7 pt footnotes. This
+    is a conservative estimate: Word remains responsible for final pagination.
+    The years always remain columns of the same table, even for longer tables.
+    """
+    section = doc.sections[-1]
+    page_width = (section.page_width - section.left_margin - section.right_margin) / 12700
+    page_height = (section.page_height - section.top_margin - section.bottom_margin) / 12700
+    note_height = sum(_lines(str(note), page_width, 7) * 8 + 4 for note in notes)
+    available_height = max(1, page_height - 30 - note_height)
+    rows = []
+    for row in table.rows:
+        row_props = row._tr.get_or_add_trPr()
+        if row_props.find(qn('w:cantSplit')) is None:
+            row_props.append(OxmlElement('w:cantSplit'))
+        cells = []
+        for cell in row.cells:
+            props = cell._tc.get_or_add_tcPr()
+            for node in list(props.findall(qn('w:noWrap'))):
+                props.remove(node)
+            width = max(1, cell.width / 12700 - _margin(cell, 'left', 80) - _margin(cell, 'right', 80) - 2)
+            paragraphs = []
+            for paragraph in cell.paragraphs:
+                marker_count = len(paragraph._p.findall('.//' + qn('w:footnoteReference')))
+                text = paragraph.text + '1' * marker_count
+                bold = any(run.bold for run in paragraph.runs)
+                paragraphs.append((text, bold, paragraph))
+            cells.append((width, _margin(cell, 'top', 65) + _margin(cell, 'bottom', 65), paragraphs))
+        rows.append(cells)
+
+    def fits(size):
+        height = 0
+        for cells in rows:
+            row_height = 0
+            for width, padding, paragraphs in cells:
+                cell_height = padding
+                for text, bold, paragraph in paragraphs:
+                    # Do not split an amount, a date, a coefficient or IPTU year
+                    # into fragments to make the width calculation succeed.
+                    single_line = bool(re.fullmatch(r'(?:R\$\s*)?[−+\-]?\d[\d.,%/\s]*|IPTU\s+\d{4}', text.strip()))
+                    if single_line and _width(text, bold) * size > width:
+                        return False
+                    cell_height += _lines(text, width, size, bold) * size * 1.15
+                    cell_height += (paragraph.paragraph_format.space_before or 0) / 12700
+                    cell_height += (paragraph.paragraph_format.space_after or 0) / 12700
+                row_height = max(row_height, cell_height)
+            height += row_height
+        return height <= available_height
+
+    # w:sz stores integer half-points: smaller steps would be rounded away.
+    size = 8
+    while size > 0.5 and not fits(size):
+        size -= 0.5
+    set_table_font_size(table, size)
+    keep_together = fits(size)
+    for row_index, row in enumerate(table.rows):
+        for cell in row.cells:
+            for paragraph in cell.paragraphs:
+                paragraph.paragraph_format.line_spacing = 1.05
+                paragraph.paragraph_format.keep_with_next = keep_together and row_index < len(table.rows) - 1
+                paragraph.paragraph_format.keep_together = True
+    return size

document/generator.py

@@ -31,6 +31,7 @@ from .formatters import (
     iniciar_secao_paisagem,
     iniciar_secao_retrato,
 )
+from .formatters.table_fit import fit_table_to_page
 
 from config.settings import TEMPLATES_DIR, TEXTOS_DIR, OUTPUT_DIR
 from models import get_model, list_available_models
@@ -354,12 +355,13 @@ class LaudoGenerator:
                     valores_extenso.append(f"{exercicio}: {valor_extenso}.")
 
         if len(dados_tabela) > 1:
-            add_simple_table(
+            tabela = add_simple_table(
                 doc,
                 dados_tabela,
                 header_row=True,
                 largura_colunas=[1.6, 1.3, 4.6],
             )
+            fit_table_to_page(doc, tabela)
 
         if valores_extenso:
             p = criar_paragrafo_formatado(

tests/test_annual_tables.py

@@ -0,0 +1,91 @@
+import io
+import unittest
+
+from docx import Document
+from docx.oxml.ns import qn
+from docx.shared import Cm
+
+from document.avaliacoes_importadas import conclusion_table
+from document.evolutivo import compared
+from document.formatters.table_fit import _width
+from document.generator import LaudoGenerator
+
+
+class AnnualTablesTests(unittest.TestCase):
+    def rows(self, count=5):
+        return [{'ano': str(2022 + i), 'ano_base': str(2021 + i)} for i in range(count)]
+
+    def test_five_exercises_remain_in_one_table_after_reopening(self):
+        doc = Document()
+        compared(doc, self.rows(), [('Fator BDI', lambda row: '1,2500')])
+        stream = io.BytesIO()
+        doc.save(stream)
+        stream.seek(0)
+        reopened = Document(stream)
+        self.assertEqual(len(reopened.tables), 1)
+        table = reopened.tables[0]
+        self.assertEqual([c.text for c in table.rows[0].cells][1:], [f'IPTU {year}' for year in range(2022, 2027)])
+        self.assertEqual({run.font.size.pt for row in table.rows for cell in row.cells for paragraph in cell.paragraphs for run in paragraph.runs}, {8})
+        self.assertTrue(all(p.paragraph_format.keep_with_next for cell in table.rows[0].cells for p in cell.paragraphs))
+        self.assertTrue(all(not p.paragraph_format.keep_with_next for cell in table.rows[-1].cells for p in cell.paragraphs))
+
+    def test_long_amounts_reduce_uniform_font_in_half_point_steps(self):
+        doc = Document()
+        amount = 'R$ 987.654.321.000,99'
+        compared(doc, self.rows(), [('Valor da construção (R$)', lambda row: amount)])
+        table = doc.tables[0]
+        sizes = {run.font.size.pt for row in table.rows for cell in row.cells for p in cell.paragraphs for run in p.runs}
+        self.assertEqual(len(sizes), 1)
+        size = sizes.pop()
+        self.assertLess(size, 8)
+        self.assertEqual(size * 2, int(size * 2))
+        cell = table.rows[1].cells[-1]
+        available = cell.width / 12700 - 10
+        self.assertLessEqual(_width(amount) * size, available)
+        self.assertGreater(_width(amount) * (size + 0.5), available)
+        self.assertEqual(cell.text, amount)
+        self.assertEqual(len(table.columns), 6)
+        self.assertTrue(all(row._tr.trPr.find(qn('w:cantSplit')) is not None for row in table.rows))
+
+    def test_six_exercises_and_duplicate_references_are_not_dropped(self):
+        rows = self.rows(6)
+        rows[1]['ano'] = rows[0]['ano']
+        for index, row in enumerate(rows):
+            row.update(titulo_origem=f'Avaliação {index + 1}', id=f'origem-{index}')
+        doc = Document()
+        compared(doc, rows, [('Valor', lambda row: 'R$ 1.234,56')])
+        self.assertEqual(len(doc.tables), 1)
+        labels = [c.text for c in doc.tables[0].rows[0].cells][1:]
+        self.assertEqual(len(labels), 6)
+        self.assertEqual(len(set(labels)), 6)
+        self.assertIn('Avaliação 1 [origem-0]', labels[0])
+        self.assertIn('Avaliação 2 [origem-1]', labels[1])
+
+    def test_height_is_also_considered_and_does_not_remove_years(self):
+        doc = Document()
+        doc.sections[0].page_height = Cm(15)
+        compared(doc, self.rows(), [(f'Parâmetro {i}', lambda row: '1,2500') for i in range(25)])
+        self.assertEqual(len(doc.tables), 1)
+        self.assertEqual(len(doc.tables[0].rows), 26)
+        self.assertEqual(len(doc.tables[0].columns), 6)
+        self.assertLess(doc.tables[0].cell(0, 0).paragraphs[0].runs[0].font.size.pt, 8)
+
+    def test_vertical_conclusions_also_start_at_eight_points(self):
+        for method in ('modelo', 'evolutivo', 'manual'):
+            with self.subTest(method=method):
+                doc = Document()
+                if method == 'manual':
+                    LaudoGenerator()._gerar_tabela_valores_mercado(doc, [
+                        {'ano': row['ano'], 'valor': '100.000,00'} for row in self.rows()])
+                else:
+                    conclusion_table(doc, {'tipo': method, 'avaliacoes': [
+                        {**row, 'id': f'row-{i}', 'objeto': 'Imóvel', 'titulo': f'Exercício {row["ano"]}', 'valor_total': '100000'}
+                        for i, row in enumerate(self.rows())]})
+                self.assertEqual(len(doc.tables), 1)
+                self.assertEqual(len(doc.tables[0].rows), 6)
+                sizes = {run.font.size.pt for row in doc.tables[0].rows for cell in row.cells for p in cell.paragraphs for run in p.runs}
+                self.assertEqual(sizes, {8})
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_evo_adjustments.py

@@ -87,10 +87,10 @@ class AppliedAdjustmentsTests(unittest.TestCase):
         doc=body(resolved(data))
         weighted=[t for t in doc.tables if t.rows[0].cells[1].text=='Projeto padrão']
         self.assertEqual(len(weighted),1);self.assertEqual(len(weighted[0].rows),3)
-        calculations=[t for t in doc.tables if any(r.cells[0].text=='Valor da construção - VC (R$)' for r in t.rows)]
+        calculations=[t for t in doc.tables if any(r.cells[0].text=='Valor da construção (R$)' for r in t.rows)]
         self.assertEqual(len(calculations),2)
         for t in calculations:
-            for label in ['CUB histórico (R$/m²)','BDI (%)','Depreciação K','Fator remanescente Kd']:
+            for label in ['Projeto CUB','CUB (R$/m²)','BDI (%)','Fator BDI','Depreciação K','Kd']:
                 self.assertTrue(any(r.cells[0].text==label for r in t.rows))
 
     def test_changes_in_characteristics_and_compositions_keep_applicability(self):

tests/test_evolutivo_documento.py

@@ -113,7 +113,8 @@ class EvolutivoDocumentTests(unittest.TestCase):
         doc = Document(); num = NumeradorSecoes(3); num.subsecao(); num.subsecao()
         gerar_corpo_evolutivo(doc, imported, num)
         tables = [t for t in doc.tables if any(r.cells[0].text == 'IC 80% Inf.' for r in t.rows)]
-        self.assertEqual(len(tables), 2)
+        self.assertEqual(len(tables), 1)
+        self.assertEqual(len(tables[0].columns), 7)
         labels = [r.cells[0].text for r in tables[0].rows]
         for label in ['Estimado Unitário', 'CA −15%', 'CA +15%', 'IC 80% Inf.', 'IC 80% Sup.']:
             self.assertIn(label, labels)
@@ -126,8 +127,8 @@ class EvolutivoDocumentTests(unittest.TestCase):
             body = etree.fromstring(archive.read('word/document.xml'))
             refs = body.findall('.//'+qn('w:footnoteReference'))
             notes = {n.get(qn('w:id')): ''.join(n.itertext()) for n in root if int(n.get(qn('w:id'))) > 0}
-            self.assertEqual(len(refs), 7)
-            self.assertEqual(len(notes), 7)
+            self.assertEqual(len(refs), 4)
+            self.assertEqual(len(notes), 4)
             self.assertEqual({r.get(qn('w:id')) for r in refs}, set(notes))
             self.assertIn('CA: campo de arbítrio', notes['2'])
             self.assertIn('intervalo de confiança de 80%', notes['3'])