Simplifica o quadro de CUB e move explicações para notas de rodapé

Uma linha por construção com CUB final por exercício; projetos simples mostram 100%. Composições e definições técnicas da MESA ficam em notas nativas junto da primeira ocorrência. Preserva alterações de pesos entre exercícios e ordena notas conforme a leitura. Validação: 110 testes e renderização conferida.

document/evolutivo.py

@@ -14,7 +14,7 @@ from .avaliacoes_importadas import currency
 from .mesa_content import content_for
 from .evo_adjustments import REDUCERS, applied_reducers
 from .fundamentacao import number, global_foundation
-from .footnotes import add_footnote
+from .footnotes import add_footnote, add_first_footnote, order_footnotes
 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,
@@ -244,7 +244,6 @@ def gerar_corpo_evolutivo(doc, imported, num, caracteristicas_refs=None):
     if not groups: add_body_text(doc,'Não há sequências construtivas detalhadas preservadas; o total importado permanece identificado na composição.')
     construction_characteristics(doc,groups)
     heading(doc,num,'CUB histórico, referência temporal e adequações',4)
-    definitions_for(doc,rows,['cubGroup','cubType','cubValue','cubPercent'])
     construction_cub_notes(doc,groups)
     heading(doc,num,'BDI e justificativa',4)
     definitions_for(doc,rows,['bdi'])
@@ -373,28 +372,67 @@ def construction_characteristics(doc, groups):
 
 
 def construction_cub_notes(doc, groups):
-    notes,compositions = OrderedDict(),OrderedDict()
+    entries_all = [entry for entries in groups.values() for entry in entries]
+    if not entries_all:
+        return
+    rows = list({row['id']:row for row,c,i in entries_all}.values())
+    labels = [ref(row,show_base=False) for row in rows]
+    records = [['Construção','Projeto CUB'] + labels]
+    composition_notes, siglas = [], OrderedDict()
     for entries in groups.values():
+        by_id = {row['id']:c for row,c,i in entries}
+        variants = OrderedDict()
         for row,c,i in entries:
-            catalog = content_for(source(row))['referencias'].get('siglasCub',[])
-            short = str(c.get('cubTipo') or '').split(' (',1)[0]
-            found = next((item for item in catalog if item.get('sigla')==short),{})
-            if found: notes.setdefault(f"{short}: {found['descricao']}.",[]).append((row,c,i))
-            if not c.get('cubCompostoAtivo'): continue
-            composition = c.get('cubComposicaoCalculada') or c.get('cubComposicao') or [
-                {'cubTipo':c.get('cubTipo'),'peso':c.get('cubPesoPrincipalCalculado'),'valorCub':c.get('valorCubPrincipal')},
-                {'cubTipo':c.get('cubTipoSecundario'),'peso':c.get('cubPesoSecundarioCalculado'),'valorCub':c.get('valorCubSecundario')}]
-            details = [{key:item.get(key) for key in ('cubTipo','peso','valorCub')} for item in composition]
-            # Historical values/weights distinguish compositions, incidental IDs do not.
-            compositions.setdefault(json.dumps(details,sort_keys=True,ensure_ascii=False),[]).append((row,c,i))
-    construction_notes(doc,notes,groups)
-    if compositions:
-        add_body_text(doc,'O CUB composto corresponde à média ponderada dos projetos: CUB = Σ(CUBᵢ × pesoᵢ) / Σ(pesoᵢ). Os valores compostos salvos constam no quadro de cálculo.')
-        records = [['Construção / referência','Projeto padrão','Peso','CUB histórico (R$/m²)']]
-        for identity,entries in compositions.items():
-            for item in json.loads(identity):
-                records.append([entry_scope(entries,groups,show_base=False),str(item.get('cubTipo') or 'Não informado'),fmt(item.get('peso'),4),currency(item.get('valorCub'))])
-        table(doc,records,[2.5,1.8,.8,1.4],font_size=7)
+            if c.get('cubCompostoAtivo'):
+                composition = c.get('cubComposicaoCalculada') or c.get('cubComposicao') or [
+                    {'cubTipo':c.get('cubTipo'),'peso':c.get('cubPesoPrincipalCalculado')},
+                    {'cubTipo':c.get('cubTipoSecundario'),'peso':c.get('cubPesoSecundarioCalculado')}]
+                parts = [f"{item.get('cubTipo') or 'Projeto não informado'}: {pct(item['peso']) if number(item.get('peso')) is not None else 'peso não informado'}"
+                         for item in composition if isinstance(item,dict)]
+                description = '; '.join(parts) or 'Composição não preservada no arquivo.'
+                project = 'CUB composto'
+            else:
+                project = str(c.get('cubTipo') or 'Não informado').split(' (',1)[0] + ' (100%)'
+                description = project
+                short = str(c.get('cubTipo') or '').split(' (',1)[0]
+                catalog = content_for(source(row))['referencias'].get('siglasCub',[])
+                found = next((item for item in catalog if item.get('sigla')==short),{})
+                if found:
+                    siglas.setdefault(short,found['descricao'])
+            variants.setdefault((project,description),[]).append((row,c,i))
+        project_labels = list(dict.fromkeys(key[0] for key in variants))
+        label = project_labels[0] if len(project_labels)==1 else 'Varia por exercício'
+        records.append([construction_name(entries[0][1],entries[0][2]),label] + [currency(by_id[row['id']].get('valorCub')) if row['id'] in by_id else '—' for row in rows])
+        if any(key[0]=='CUB composto' for key in variants) or len(variants)>1:
+            details = []
+            for (project,description),subset in variants.items():
+                scope = '; '.join(ref(row,show_base=False) for row,c,i in subset) if len(variants)>1 else 'Todos os exercícios apresentados'
+                details.append(f'{scope}: {description}.')
+            composition_notes.append((len(records)-1,' '.join(details),any(key[0]=='CUB composto' for key in variants)))
+    obj = table(doc,records,[2.5,1.5]+[1.15]*len(rows),auto_fit=False)
+    for key,pattern in [('cubGroup',r'\bCUB\b'),('cubType',r'Projeto CUB'),
+                        ('cubValue',r'CUB histórico'),('cubPercent',r'%\s+(?:do\s+)?CUB')]:
+        variants = OrderedDict()
+        for row,c,i in entries_all:
+            text = content_for(source(row)).get('notas',{}).get(key)
+            if text:
+                variants.setdefault(text,[]).append(ref(row,show_base=False))
+        if variants:
+            text = ' '.join(text + (f" Aplicável a {'; '.join(dict.fromkeys(scope))}." if len(variants)>1 else '') for text,scope in variants.items())
+            if add_first_footnote(doc,pattern,text) is None:
+                add_footnote(doc,obj.cell(0,1).paragraphs[0],text)
+    used_notes = []
+    explained_composite = False
+    for index,text,has_composite in composition_notes:
+        if has_composite and not explained_composite:
+            text = 'O CUB composto corresponde à média ponderada dos projetos: CUB = Σ(CUBᵢ × pesoᵢ) / Σ(pesoᵢ). ' + text
+            explained_composite = True
+        add_footnote(doc,obj.cell(index,1).paragraphs[0],text)
+        used_notes.append(text)
+    for short,description in siglas.items():
+        add_first_footnote(doc,r'\b'+re.escape(short)+r'\b',f'{short}: {description}.')
+    order_footnotes(doc)
+    fit_table_to_page(doc,obj,notes=used_notes)
 
 
 def construction_bdi_notes(doc, groups):

document/footnotes.py

@@ -6,6 +6,69 @@ from docx.opc.constants import CONTENT_TYPE as CT, RELATIONSHIP_TYPE as RT
 from docx.opc.packuri import PackURI
 from docx.opc.part import Part, XmlPart
 from docx.shared import Pt
+from docx.text.paragraph import Paragraph
+from copy import deepcopy
+import re
+
+
+def add_first_footnote(doc, pattern, text):
+    """Attach a note immediately after the first body/table occurrence of a term."""
+    for element in doc.element.body.iter(qn('w:p')):
+        paragraph = Paragraph(element, doc._body)
+        match = re.search(pattern, paragraph.text)
+        if not match:
+            continue
+        offset = 0
+        for run in paragraph.runs:
+            end = offset + len(run.text)
+            if offset < match.end() <= end:
+                cut = match.end() - offset
+                tail = run.text[cut:]
+                run.text = run.text[:cut]
+                identifier = add_footnote(doc, paragraph, text)
+                marker = paragraph.runs[-1]._r
+                run._r.addnext(marker)
+                if tail:
+                    remainder = OxmlElement('w:r')
+                    if run._r.rPr is not None:
+                        remainder.append(deepcopy(run._r.rPr))
+                    content = OxmlElement('w:t')
+                    content.text = tail
+                    content.set(qn('xml:space'), 'preserve')
+                    remainder.append(content)
+                    marker.addnext(remainder)
+                return identifier
+            offset = end
+        return add_footnote(doc, paragraph, text)
+    return None
+
+
+def order_footnotes(doc):
+    """Keep IDs and stored note order aligned with their first body occurrence.
+
+    Notes can be attached retroactively to earlier terms. Align both orders so
+    Word and LibreOffice associate every visible number with the right text.
+    """
+    try:
+        part = doc.part.part_related_by(RT.FOOTNOTES)
+    except KeyError:
+        return
+    root = parse_xml(part.blob)
+    notes = {n.get(qn('w:id')): n for n in root if int(n.get(qn('w:id'))) > 0}
+    refs = list(doc.element.body.iter(qn('w:footnoteReference')))
+    ordered_ids = list(dict.fromkeys(r.get(qn('w:id')) for r in refs))
+    ordered_ids += [key for key in notes if key not in ordered_ids]
+    mapping = {key: str(i+1) for i,key in enumerate(ordered_ids)}
+    for reference in refs:
+        reference.set(qn('w:id'),mapping[reference.get(qn('w:id'))])
+    for old_id in ordered_ids:
+        note = notes[old_id]
+        note.set(qn('w:id'),mapping[old_id])
+        root.append(note)
+    if isinstance(part,XmlPart):
+        part._element = root
+    else:
+        part._blob = etree.tostring(root,xml_declaration=True,encoding='UTF-8',standalone=True)
 
 
 def add_footnote(doc, paragraph, text):

tests/test_cub_notes.py

@@ -0,0 +1,73 @@
+import copy
+import io
+import unittest
+import zipfile
+
+from docx import Document
+from docx.oxml import parse_xml
+from docx.oxml.ns import qn
+
+from document.evolutivo import construction_cub_notes, construction_groups
+from document.footnotes import add_first_footnote
+from test_evolutivo_documento import fixture, resolved
+
+
+class CubNotesTests(unittest.TestCase):
+    def notes(self, doc):
+        stream=io.BytesIO();doc.save(stream)
+        with zipfile.ZipFile(stream) as archive:
+            root=parse_xml(archive.read('word/footnotes.xml'))
+        return [''.join(t.text or '' for t in n.iter(qn('w:t'))).strip() for n in root if int(n.get(qn('w:id'))) > 0]
+
+    def test_one_row_per_construction_saved_values_and_composition_in_footnotes(self):
+        data=fixture((2021,2022,2023,2024,2025))
+        for year in data['anos']:
+            simple=copy.deepcopy(year['construcao']['construcoes'][0])
+            simple.update(id='simples',seq=2,nome='Galpão simples',cubTipo='GI (Galpao Industrial)',cubCompostoAtivo=False,valorCub=1000)
+            year['construcao']['construcoes'].append(simple)
+        imported=resolved(data)
+        doc=Document()
+        intro=doc.add_paragraph('O custo unitário básico (CUB) é empregado no cálculo.')
+        percent=doc.add_paragraph('CUNIT = CUB × (% CUB / 100)')
+        doc.add_paragraph('CUB histórico, referência temporal e adequações')
+        construction_cub_notes(doc,construction_groups(imported['avaliacoes']))
+        self.assertEqual(len(doc.tables),1)
+        table=doc.tables[0]
+        self.assertEqual(len(table.rows),3)
+        self.assertEqual(len(table.columns),7)
+        self.assertEqual(table.cell(1,1).text,'CUB composto')
+        self.assertEqual(table.cell(2,1).text,'GI (100%)')
+        self.assertEqual([c.text for c in table.rows[1].cells][2:],['R$ 1.400,00']*5)
+        self.assertEqual([c.text for c in table.rows[2].cells][2:],['R$ 1.000,00']*5)
+        notes=self.notes(doc)
+        self.assertEqual(len(notes),6)
+        self.assertIn('% do CUB',notes[1])
+        self.assertIn('valor do CUB por metro quadrado',notes[2])
+        self.assertIn('tipo ou composição de CUB',notes[3])
+        composite=next(n for n in notes if 'média ponderada' in n)
+        self.assertIn('GI: 60,00%; R1-N: 40,00%',composite)
+        self.assertIn('Todos os exercícios',composite)
+        self.assertTrue(any('GI: Galpao industrial' in n for n in notes))
+        self.assertIsNotNone(intro._p.find('.//'+qn('w:footnoteReference')))
+        self.assertIsNotNone(percent._p.find('.//'+qn('w:footnoteReference')))
+        self.assertFalse(any('grupo dos dados' in p.text or 'média ponderada' in p.text for p in doc.paragraphs))
+        self.assertEqual(intro.text,'O custo unitário básico (CUB) é empregado no cálculo.')
+
+    def test_first_occurrence_marker_preserves_text_and_formatting(self):
+        doc=Document()
+        first=doc.add_paragraph()
+        first.add_run('Projeto ')
+        first.add_run('CUB composto e CUB simples.').italic=True
+        later=doc.add_paragraph('Outro CUB composto.')
+        add_first_footnote(doc,r'CUB composto','Explicação técnica.')
+        self.assertEqual(first.text,'Projeto CUB composto e CUB simples.')
+        self.assertEqual(first.runs[1].text,'CUB composto')
+        self.assertTrue(first.runs[1].italic)
+        self.assertIsNotNone(first.runs[2]._r.find(qn('w:footnoteReference')))
+        self.assertTrue(first.runs[3].italic)
+        self.assertIsNone(later._p.find('.//'+qn('w:footnoteReference')))
+        self.assertEqual(self.notes(doc),['Explicação técnica.'])
+
+
+if __name__=='__main__':
+    unittest.main()

tests/test_evo_adjustments.py

@@ -121,8 +121,10 @@ class AppliedAdjustmentsTests(unittest.TestCase):
             c=copy.deepcopy(y['construcao']['construcoes'][0]);c.update(id='segundo',seq=2,nome='Galpão B')
             y['construcao']['construcoes'].append(c)
         doc=body(resolved(data))
-        weighted=[t for t in doc.tables if t.rows[0].cells[1].text=='Projeto padrão']
+        weighted=[t for t in doc.tables if t.rows[0].cells[1].text=='Projeto CUB']
         self.assertEqual(len(weighted),1);self.assertEqual(len(weighted[0].rows),3)
+        self.assertEqual(weighted[0].cell(1,1).text,'CUB composto')
+        self.assertEqual([c.text for c in weighted[0].rows[0].cells][2:],['IPTU 2022','IPTU 2023'])
         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:
@@ -136,6 +138,10 @@ class AppliedAdjustmentsTests(unittest.TestCase):
         t=next(t for t in doc.tables if t.rows[0].cells[1].text=='Tipo / ano')
         self.assertEqual(len(t.rows),3)
         self.assertIn('IPTU 2023',t.rows[2].cells[0].text)
-        t=next(t for t in doc.tables if t.rows[0].cells[1].text=='Projeto padrão')
-        self.assertEqual(len(t.rows),5)
-        self.assertIn('IPTU 2022',t.rows[1].cells[0].text);self.assertIn('IPTU 2023',t.rows[3].cells[0].text)
+        t=next(t for t in doc.tables if t.rows[0].cells[1].text=='Projeto CUB')
+        self.assertEqual(len(t.rows),2)
+        from docx.opc.constants import RELATIONSHIP_TYPE as RT
+        from docx.oxml import parse_xml
+        text=' '.join(parse_xml(doc.part.part_related_by(RT.FOOTNOTES).blob).itertext())
+        for expected in ['IPTU 2022','IPTU 2023','60,00%','50,00%']:
+            self.assertIn(expected,text)

tests/test_evolutivo_documento.py

@@ -127,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), 4)
-            self.assertEqual(len(notes), 4)
+            self.assertGreaterEqual(len(refs), 4)
+            self.assertEqual(len(refs), len(notes))
             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'])