Organiza justificativa e composição do BDI por construção

Mantém a explicação geral do BDI no capítulo principal e cria subseção por construção com justificativa e tabela encerrada pelo total adotado em destaque. Compara por exercício quando houver mudanças e preserva divergências entre soma e percentual global. Validado com 123 testes e revisão visual do exemplo com três construções.

document/evolutivo.py

@@ -126,6 +126,7 @@ def compared(doc, rows, metrics, notes=None, show_base=False):
             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)
+    return obj
 
 
 def model_analysis(doc, model, tipo_y):
@@ -454,27 +455,71 @@ def construction_cub_notes(doc, groups):
 
 
 def construction_bdi_notes(doc, groups, num=None):
-    notes,compositions = OrderedDict(),OrderedDict()
     for entries in groups.values():
+        name = construction_name(entries[0][1],entries[0][2])
+        if num is not None:
+            heading(doc,num,name,5)
+        else:
+            add_subsubsubsubsection_title(doc,'',name)
+        reasons,references = OrderedDict(),OrderedDict()
+        components,by_id,variants = OrderedDict(),{},set()
         for row,c,i in entries:
             key = str(c.get('id') or c.get('seq') or i+1)
-            note = (row.get('complementos') or {}).get('bdi',{}).get(key) or 'não preservada no arquivo; complemento técnico pendente.'
-            notes.setdefault('Justificativa do BDI: '+note,[]).append((row,c,i))
+            note = (row.get('complementos') or {}).get('bdi',{}).get(key)
+            if note and note.strip(): reasons.setdefault(note.strip(),[]).append(row)
             reference = next((item for item in content_for(source(row))['referencias'].get('bdiTiposConstrucao',[]) if item.get('tipo')==c.get('tipoConstrucao')),None)
             if reference:
-                notes.setdefault(f"Referência técnica para {reference['tipo']}: BDI {reference['bdi']}. O percentual adotado consta no quadro de cálculo.",[]).append((row,c,i))
-            composition = c.get('bdiComposicaoAdotada')
-            if isinstance(composition,list) and composition:
-                details = [{key:item.get(key) for key in ('descricao','percentual')} for item in composition]
-                compositions.setdefault(json.dumps(details,sort_keys=True,ensure_ascii=False),[]).append((row,c,i))
-    construction_notes(doc,notes,groups)
-    if compositions:
-        records = [['Construção / referência','Componente de BDI adotado','Percentual']]
-        for identity,entries in compositions.items():
-            records.extend([[entry_scope(entries,groups,show_base=False),str(item.get('descricao') or ''),pct(item.get('percentual'))] for item in json.loads(identity)])
-        if num is not None:
-            heading(doc,num,'Composição do BDI',5)
-        table(doc,records,[2.3,3.2,1],font_size=7)
+                text = f"Referência técnica para {reference['tipo']}: BDI {reference['bdi']}. O percentual adotado é o registrado nesta tabela."
+                references.setdefault(text,[]).append(row)
+            values,counts = OrderedDict(),{}
+            composition = c.get('bdiComposicaoAdotada') or []
+            for item in composition if isinstance(composition,list) else []:
+                if not isinstance(item,dict): continue
+                label = str(item.get('descricao') or 'Componente não informado')
+                counts[label] = counts.get(label,0)+1
+                identity = (label,counts[label])
+                components.setdefault(identity,label)
+                values[identity] = number(item.get('percentual'))
+            total = sum(values.values(),Decimal(0)) if values and all(v is not None for v in values.values()) else None
+            adopted = number(c.get('bdi'))
+            by_id[row['id']] = {'components':values,'sum':total,'adopted':adopted}
+            variants.add((tuple(values.items()),adopted))
+        for text,applicable in reasons.items():
+            scope = ' ('+'; '.join(ref(row,show_base=False) for row in applicable)+')' if len(applicable)!=len(entries) else ''
+            add_body_text(doc,f'Justificativa do BDI{scope}: {text}').paragraph_format.keep_with_next = True
+        metrics = [(label,lambda row,k=key: pct(by_id[row['id']]['components'][k]) if k in by_id[row['id']]['components'] else '—') for key,label in components.items()]
+        differs = any(value['sum'] is not None and (value['adopted'] is None or
+                      value['sum'].quantize(Decimal('.01')) != value['adopted'].quantize(Decimal('.01'))) for value in by_id.values())
+        if differs:
+            metrics.append(('Soma dos componentes',lambda row:pct(by_id[row['id']]['sum'])))
+        metrics.append(('Total do BDI',lambda row:pct(by_id[row['id']]['adopted'])))
+        used_notes = []
+        for text,applicable in references.items():
+            scope = '; '.join(ref(row,show_base=False) for row in applicable)+': ' if len(applicable)!=len(entries) else ''
+            used_notes.append(scope+text)
+        for row,c,i in entries:
+            value = by_id[row['id']]
+            text = ''
+            if not value['components']:
+                text = 'O arquivo registra o percentual global do BDI sem discriminar sua composição.'
+            elif value['sum'] is None:
+                text = 'A composição registrada contém percentuais não informados; o total do BDI é o percentual global adotado no arquivo.'
+            elif value['adopted'] is None or value['sum'].quantize(Decimal('.01')) != value['adopted'].quantize(Decimal('.01')):
+                text = 'A soma dos componentes difere do percentual global registrado. O total do BDI preserva o percentual adotado no arquivo.'
+            if text:
+                scope = ref(row,show_base=False)+': ' if len(variants)>1 else ''
+                if scope+text not in used_notes: used_notes.append(scope+text)
+        if len(variants)>1:
+            obj = compared(doc,[row for row,c,i in entries],metrics)
+        else:
+            row = entries[0][0]
+            obj = table(doc,[['Componente de BDI adotado','Percentual']]+[[label,getter(row)] for label,getter in metrics],[4.5,1.5],auto_fit=False)
+        for cell in obj.rows[-1].cells:
+            for paragraph in cell.paragraphs:
+                for run in paragraph.runs: run.bold = True
+        if used_notes:
+            add_footnote(doc,obj.rows[-1].cells[0].paragraphs[0],' '.join(used_notes))
+        fit_table_to_page(doc,obj,notes=used_notes)
 
 
 def conservation_code(value):

tests/test_bdi_sections.py

@@ -0,0 +1,103 @@
+import copy
+import unittest
+
+from docx import Document
+from docx.opc.constants import RELATIONSHIP_TYPE as RT
+from docx.oxml import parse_xml
+from docx.oxml.ns import qn
+
+from document.evolutivo import construction_bdi_notes, construction_groups
+from test_evo_adjustments import body
+from test_evolutivo_documento import fixture, resolved
+
+
+LABELS = ['Administração central', 'Despesas financeiras', 'Seguros e garantias', 'Riscos', 'Tributos', 'Remuneração']
+
+
+def composition(values):
+    return [{'descricao': label, 'percentual': value} for label, value in zip(LABELS, values)]
+
+
+def notes(doc):
+    root = parse_xml(doc.part.part_related_by(RT.FOOTNOTES).blob)
+    return ' '.join(''.join(n.itertext(qn('w:t'))) for n in root if int(n.get(qn('w:id'))) > 0)
+
+
+class BdiSectionsTests(unittest.TestCase):
+    def data(self):
+        data = fixture((2021, 2022))
+        for year in data['anos']:
+            c = year['construcao']['construcoes'][0]
+            c.update(bdiComposicaoAdotada=composition([4, 1, 1, 2, 7, 10]), bdiJustificativa='Composição aditiva sobre o custo direto.')
+        return data
+
+    def render(self, data):
+        imported = resolved(data)
+        before = copy.deepcopy(imported)
+        doc = Document()
+        construction_bdi_notes(doc, construction_groups(imported['avaliacoes']))
+        self.assertEqual(imported, before)
+        return doc
+
+    def test_general_chapter_only_introduction_and_each_construction_has_total(self):
+        data = self.data()
+        for year in data['anos']:
+            second = copy.deepcopy(year['construcao']['construcoes'][0])
+            second.update(id='second', seq=2, nome='Galpão B', bdi=20,
+                          bdiComposicaoAdotada=composition([3, 1, 1, 2, 6, 7]))
+            year['construcao']['construcoes'].append(second)
+        doc = body(resolved(data))
+        paragraphs = [p.text for p in doc.paragraphs]
+        start = paragraphs.index('3.4.1.3 BDI e justificativa')
+        end = paragraphs.index('3.4.1.3.1 Construção 1 — Galpão A')
+        self.assertEqual(len(paragraphs[start + 1:end]), 2)
+        self.assertTrue(paragraphs[start + 1].startswith('BDI (%):'))
+        self.assertTrue(paragraphs[start + 2].startswith('O BDI informado em percentual'))
+        self.assertIn('3.4.1.3.2 Construção 2 — Galpão B', paragraphs)
+        tables = [t for t in doc.tables if t.cell(0, 0).text == 'Componente de BDI adotado']
+        self.assertEqual(len(tables), 2)
+        for table, total in zip(tables, ['25,00%', '20,00%']):
+            self.assertEqual([c.text for c in table.rows[-1].cells], ['Total do BDI', total])
+            self.assertEqual(len(table.rows), 8)
+            self.assertEqual(len(table.columns), 2)
+            self.assertTrue(all(run.bold for c in table.rows[-1].cells for p in c.paragraphs for run in p.runs))
+        self.assertFalse(any('Aplicável a Construção' in p for p in paragraphs[start:paragraphs.index('3.4.1.4 Depreciação e conservação')]))
+
+    def test_year_changes_compare_components_and_totals_without_duplicate_subchapters(self):
+        data = self.data()
+        c = data['anos'][1]['construcao']['construcoes'][0]
+        c.update(bdi=20, bdiComposicaoAdotada=composition([3, 1, 1, 2, 6, 7]), bdiJustificativa='Justificativa do segundo exercício.')
+        doc = self.render(data)
+        self.assertEqual(len(doc.tables), 1)
+        table = doc.tables[0]
+        self.assertEqual([c.text for c in table.rows[0].cells], ['Parâmetro / valor', 'IPTU 2022', 'IPTU 2023'])
+        self.assertEqual([c.text for c in table.rows[1].cells], ['Administração central', '4,00%', '3,00%'])
+        self.assertEqual([c.text for c in table.rows[-1].cells], ['Total do BDI', '25,00%', '20,00%'])
+        text = '\n'.join(p.text for p in doc.paragraphs)
+        self.assertIn('Justificativa do BDI (IPTU 2022): Composição aditiva', text)
+        self.assertIn('Justificativa do BDI (IPTU 2023): Justificativa do segundo exercício.', text)
+
+    def test_divergent_sum_does_not_replace_saved_bdi(self):
+        data = self.data()
+        for year in data['anos']:
+            year['construcao']['construcoes'][0]['bdiComposicaoAdotada'][0]['percentual'] = 5
+        doc = self.render(data)
+        self.assertEqual([c.text for c in doc.tables[0].rows[-2].cells], ['Soma dos componentes', '26,00%'])
+        self.assertEqual([c.text for c in doc.tables[0].rows[-1].cells], ['Total do BDI', '25,00%'])
+        self.assertIn('difere do percentual global registrado', notes(doc))
+
+    def test_missing_composition_and_private_reason_are_not_invented_or_exposed(self):
+        data = self.data()
+        for year in data['anos']:
+            c = year['construcao']['construcoes'][0]
+            c.pop('bdiComposicaoAdotada')
+            c.update(bdi=0, bdiJustificativa='JUSTIFICATIVA INTERNA', bdiJustificativaInterna=True)
+        doc = self.render(data)
+        self.assertEqual(len(doc.tables[0].rows), 2)
+        self.assertEqual([c.text for c in doc.tables[0].rows[-1].cells], ['Total do BDI', '0,00%'])
+        self.assertNotIn('JUSTIFICATIVA INTERNA', '\n'.join(p.text for p in doc.paragraphs) + notes(doc))
+        self.assertIn('sem discriminar sua composição', notes(doc))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_evo_hierarchy.py

@@ -42,7 +42,9 @@ class EvolutivoHierarchyTests(unittest.TestCase):
             self.assertTrue(p.paragraph_format.keep_with_next)
             self.assertEqual(p._p.getnext().tag, qn('w:tbl'))
         paragraphs = [p.text for p in doc.paragraphs]
-        for text in ['3.4.1.1.1 Composição das áreas', '3.4.1.3.1 Composição do BDI',
+        bdi_headings = [p.text for p in doc.paragraphs if p.text.startswith('3.4.1.3.')]
+        self.assertEqual(bdi_headings, [f'3.4.1.3.{index} Construção {index} — {name}' for index, name in enumerate(names, 1)])
+        for text in ['3.4.1.1.1 Composição das áreas',
                      '3.4.1.5 Cálculo por construção e exercício', '3.5 AVALIAÇÃO DO IMÓVEL OBJETO',
                      '4. ESPECIFICAÇÃO DA AVALIAÇÃO', '5. CONCLUSÃO TÉCNICA']:
             self.assertIn(text, paragraphs)