Upload 44 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/files/ABC/modelo.dai filter=lfs diff=lfs merge=lfs -text

CLAUDE.md

@@ -0,0 +1,302 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Sistema de Geração de Laudos de Avaliação Imobiliária - A web application for generating real estate appraisal reports (laudos) for property tax review processes in Porto Alegre, Brazil. The system uses statistical regression models and generates formatted DOCX documents.
+
+## Running the Application
+
+```bash
+# Activate virtual environment
+source .venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+```
+
+The Gradio web interface starts at `http://0.0.0.0:7860`.
+
+## Architecture Overview
+
+```
+├── app.py                    # Entry point - launches Gradio server
+├── config/
+│   ├── settings.py           # Paths and server config
+│   └── constants.py          # UI dropdown options, field limits
+├── ui/
+│   └── app_builder.py        # Gradio interface (8 tabs), callbacks, document generation
+├── document/
+│   ├── generator.py          # LaudoGenerator class - main orchestrator
+│   ├── numbering.py          # Section numbering (NumeradorSecoes)
+│   ├── formatters/           # DOCX formatting utilities
+│   └── anexos/               # Annex generators
+├── core/entities/            # Data classes (Laudo, Solicitacao, Imovel)
+├── models/                   # Model loading and registry
+├── extractors/               # PDF data extraction
+├── templates/
+│   ├── header.docx           # Document header template
+│   └── textos/               # Text templates (CONSIDERACOES_INICIAIS.docx, etc.)
+├── utils/
+│   ├── docx_loader.py        # DOCX reading and merging utilities
+│   ├── formatters.py         # Value formatting utilities
+│   └── estatisticas_utils.py # Statistics formatting utilities
+└── output/                   # Generated reports
+```
+
+---
+
+## Detailed File Reference
+
+### config/settings.py
+**Purpose:** System paths and server configuration.
+
+| Constant | Description |
+|----------|-------------|
+| `BASE_DIR` | Project root directory |
+| `MODELS_DIR` | Path to `models/files/` |
+| `TEMPLATES_DIR` | Path to `templates/` |
+| `TEXTOS_DIR` | Path to `templates/textos/` (text templates) |
+| `OUTPUT_DIR` | Path to `output/laudos_gerados/` |
+| `SERVER_HOST` | Gradio server host (`0.0.0.0`) |
+| `SERVER_PORT` | Gradio server port (`7860`) |
+
+### config/constants.py
+**Purpose:** UI dropdown lists and field limits.
+
+| Constant | Description |
+|----------|-------------|
+| `MAX_MOTIVOS_DESVALORIZANTES` | Max devaluation reasons (15) |
+| `MAX_VALORES_MERCADO` | Max market value entries (15) |
+| `MAX_DOCUMENTACAO_PADRAO` | Max standard docs (10) |
+| `MAX_DOCUMENTACAO_ESPECIFICA` | Max specific docs (10) |
+| `UNIDADES_DEMANDANTES` | Dropdown list for requesting units |
+| `TECNICOS_RESPONSAVEIS` | Dropdown list for responsible technicians |
+| `METODOS_AVALIACAO` | Dropdown list for evaluation methods |
+
+---
+
+### document/formatters/table.py
+**Purpose:** Table creation and cell formatting for DOCX.
+
+| Function | Description |
+|----------|-------------|
+| `set_cell_shading(cell, color)` | Sets cell background color (hex) |
+| `set_cell_text_rotation(cell, direcao='btLr')` | Rotates text 90° vertical (`btLr`) or 270° (`tbRl`) |
+| `formatar_celula_tabela(cell, texto, negrito, cor, shading_color, rotacao)` | Formats cell with text, bold, color, shading, rotation |
+| `add_simple_table(doc, dados_tabela, header_row, largura_colunas, rotacao_cabecalho)` | Creates simple table. `rotacao_cabecalho=True` rotates headers vertically and auto-adjusts height |
+| `configurar_linha_tabela_altura(row, altura_cm)` | Sets minimum row height in cm |
+| `criar_celula_cabecalho_tabela(cell, texto)` | Formats section header cell (bold, underline, gray) |
+| `criar_celula_dados_tabela(cell, texto, is_label)` | Formats data cell |
+
+### document/formatters/paragraph.py
+**Purpose:** Paragraph and text formatting.
+
+| Function | Description |
+|----------|-------------|
+| `aplicar_cor_run(run, cor)` | Applies RGB color to a run |
+| `criar_paragrafo_formatado(doc, texto, negrito, sublinhado, italico, tamanho, cor, alinhamento, ...)` | Creates fully formatted paragraph |
+| `add_body_text(doc, text, cor, indent)` | Adds body text with standard formatting |
+| `add_placeholder_text(doc, text, indent)` | Adds red placeholder text |
+| `add_bullet_text(doc, text, indent_level)` | Adds bulleted text |
+
+### document/formatters/heading.py
+**Purpose:** Section titles and headings.
+
+| Function | Description |
+|----------|-------------|
+| `add_heading_custom(doc, text, level)` | Adds custom heading (level 1 or 2) |
+| `add_section_title(doc, number, text)` | Main section title (e.g., "1. SOLICITACAO") |
+| `add_subsection_title(doc, number, text)` | Subsection title (e.g., "1.1 Consideracoes") |
+| `add_subsubsection_title(doc, number, text)` | Sub-subsection (e.g., "3.2.1") |
+| `add_subsubsubsection_title(doc, number, text)` | Sub-sub-subsection (e.g., "3.2.1.1") |
+
+### document/formatters/image.py
+**Purpose:** Image insertion.
+
+| Function | Description |
+|----------|-------------|
+| `inserir_imagem_de_documento(doc, imagem_data, largura_inches)` | Inserts image from another document |
+| `add_image_placeholder(doc)` | Adds "[IMAGEM]" placeholder |
+
+---
+
+### document/generator.py
+**Purpose:** Main document generation orchestrator.
+
+**Class: `LaudoGenerator`**
+
+| Method | Description |
+|--------|-------------|
+| `gerar(dados, motivos_formatados)` | Main entry point - generates complete laudo. Merges photo registry if provided |
+| `_configurar_margens(doc)` | Sets document margins |
+| `_substituir_processo_header(doc, numero_processo)` | Replaces "XXX" in header with process number |
+| `_gerar_cabecalho(doc, dados)` | Generates initial data table |
+| `_gerar_corpo(doc, dados, motivos_formatados)` | Generates main body sections. Loads "Considerações Iniciais" from template |
+| `_gerar_tabela_valores_mercado(doc, valores_lista)` | Creates market values table |
+| `_gerar_assinatura(doc, dados)` | Generates signature section |
+| `_criar_titulo_anexo(doc, titulo)` | Creates annex title (size 10, centered, bold, underlined) |
+| `_gerar_anexos(doc, dados)` | Generates all annexes (I-VI) |
+| `_gerar_nome_arquivo(dados)` | Creates output filename |
+
+### document/numbering.py
+**Purpose:** Automatic hierarchical section numbering.
+
+**Class: `NumeradorSecoes`**
+
+| Method | Description |
+|--------|-------------|
+| `secao()` | Increments and returns section number ("1", "2", ...) |
+| `subsecao()` | Returns subsection number ("1.1", "1.2", ...) |
+| `subsubsecao()` | Returns sub-subsection ("1.1.1", ...) |
+| `subsubsubsecao()` | Returns sub-sub-subsection ("1.1.1.1", ...) |
+| `numero_atual(nivel)` | Returns current number without incrementing |
+| `definir_secao(numero)` | Manually sets section number |
+
+---
+
+### document/anexos/
+
+| File | Main Function | Description |
+|------|---------------|-------------|
+| `banco_dados.py` | `gerar_anexo_banco_dados(doc, modelo)` | Generates sample data table from `modelo.xy_preview`. Uses `rotacao_cabecalho=True` |
+| `estatisticas.py` | `gerar_anexo_estatisticas(doc, modelo)` | Generates descriptive statistics and test results. Descriptive table uses `rotacao_cabecalho=True` |
+| `planilha_calculo.py` | `gerar_anexo_planilha(doc, modelo)` | Generates coefficients table and observed vs calculated. Both tables use `rotacao_cabecalho=True` |
+| `graficos.py` | `gerar_anexo_graficos(doc, modelo)` | Generates diagnostic plots (obs vs calc, residuals, QQ, histogram) |
+| `metodologia.py` | `gerar_anexo_metodologia(doc, modelo)` | Generates methodology section from model data |
+| `calculo_valor.py` | `gerar_anexo_calculo(doc, modelo, valores_imovel)` | Generates value calculation section |
+
+**graficos.py helper functions:**
+- `_gerar_graficos_diagnostico(modelo)` - Creates all diagnostic plots
+- `_criar_grafico_obs_calc(y_obs, y_calc)` - Observed vs Calculated scatter
+- `_criar_grafico_residuos(y_calc, residuos)` - Residuals vs Fitted
+- `_criar_qqplot(residuos)` - Q-Q plot for normality
+- `_criar_histograma_residuos(residuos)` - Histogram with normal curve
+
+---
+
+### models/
+
+| File | Description |
+|------|-------------|
+| `model_data.py` | `ModelData` dataclass with properties: `r2`, `r2_ajustado`, `equacao`, `variaveis`, `n_amostras`, `n_variaveis` |
+| `model_loader.py` | `load_model(path)` - Loads `.dai` files via joblib |
+| `registry.py` | `ModelRegistry` class, `list_available_models()`, `get_model(name)` |
+
+**ModelData attributes:**
+- `nome`, `path` - Model identification
+- `xy_preview` - DataFrame with sample data
+- `estatisticas` - Descriptive statistics DataFrame
+- `tabelas_coef` - Coefficients DataFrame
+- `tabelas_obs_calc` - Observed vs Calculated DataFrame
+- `modelos_resumos` - Dict with R2, tests, equation
+- `modelos_sm` - Statsmodels result object (for graphs)
+
+---
+
+### ui/app_builder.py
+**Purpose:** Gradio interface construction and callbacks.
+
+| Function | Description |
+|----------|-------------|
+| `toggle_custom_field(dropdown_value)` | Shows/hides custom field when "Outros" selected |
+| `adicionar_campo(count, max_count)` | Adds dynamic field |
+| `remover_campo(count, max_count)` | Removes dynamic field |
+| `processar_upload_pdf(pdf_file)` | Extracts data from uploaded PDF |
+| `gerar_campos_valores_mercado(ano_ini, ano_fim)` | Generates market value fields for year range |
+| `gerar_documento_callback(...)` | Main callback that calls `LaudoGenerator.gerar()` |
+
+---
+
+### utils/
+
+| File | Function | Description |
+|------|----------|-------------|
+| `docx_loader.py` | `ler_texto_docx(caminho)` | Reads text content from a DOCX template file |
+| `docx_loader.py` | `mesclar_documento_fotos(doc, caminho_fotos)` | Merges photo registry DOCX into main document using `docxcompose` |
+| `estatisticas_utils.py` | `reorganizar_modelos_resumos(resumo)` | Reorganizes model stats dict for display |
+| `estatisticas_utils.py` | `formatar_numero(valor, casas)` | Formats number with decimal places |
+| `formatters.py` | `formatar_valor_monetario(valor)` | Formats currency value |
+| `formatters.py` | `formatar_motivos_desvalorizantes(...)` | Formats devaluation reasons for document |
+
+---
+
+### extractors/pdf_extractor.py
+**Purpose:** Extracts property data from SIAT PDFs.
+
+| Function | Description |
+|----------|-------------|
+| `extrair_dados_pdf(pdf_file)` | Main extraction function, returns dict with property data |
+
+---
+
+## Key Patterns
+
+### Model Loading
+```python
+from models import get_model, list_available_models
+models = list_available_models()  # Returns folder names
+model = get_model("MOD_V_TCOND_Z4_008C")  # Returns ModelData
+```
+
+### Document Generation Flow
+1. `ui/app_builder.py` -> `gerar_documento_callback()`
+2. Formats data and calls `LaudoGenerator.gerar(dados, motivos)`
+3. Generator creates sections and annexes
+4. If photo registry uploaded, merges it after ANEXO VI using `docxcompose`
+5. Output saved to `output/laudos_gerados/`
+
+### UI Tabs Structure
+| Tab | Name | Purpose |
+|-----|------|---------|
+| 1 | Solicitação | General request data, proposer info |
+| 2 | Documentação | Standard and specific documentation lists |
+| 3 | Motivos Desvalorizantes | Devaluation reasons with checkboxes |
+| 4 | Imóvel Objeto | Property data with PDF extraction |
+| 5 | Avaliação | Evaluator info and methodology |
+| 6 | Valores de Mercado | Market values per year |
+| 7 | Registro Fotográfico | Photo registry DOCX upload + link to generator |
+| 8 | Gerar Documento | Generate button and download |
+
+### Table with Vertical Headers
+```python
+from document.formatters import add_simple_table
+# rotacao_cabecalho=True rotates headers 90 degrees and auto-adjusts row height
+add_simple_table(doc, dados, header_row=True, rotacao_cabecalho=True)
+```
+
+### Dynamic Fields Pattern
+Maximum counts defined in `config/constants.py`. UI callbacks in `ui/app_builder.py` use `adicionar_campo()` and `remover_campo()`.
+
+### Text Templates
+Pre-written text content is loaded from DOCX files in `templates/textos/`:
+```python
+from config.settings import TEXTOS_DIR
+from utils.docx_loader import ler_texto_docx
+
+texto = ler_texto_docx(TEXTOS_DIR / "CONSIDERACOES_INICIAIS.docx")
+```
+
+Available templates:
+- `CONSIDERACOES_INICIAIS.docx` - Initial considerations section text
+- `DIAGNOSTICO_MERCADO.docx` - Market diagnosis text
+
+### Photo Registry Merge
+Photo registry documents can be uploaded and merged into the laudo:
+```python
+from utils.docx_loader import mesclar_documento_fotos
+
+# After generating annexes, merge photo doc if provided
+if registro_foto_path:
+    doc = mesclar_documento_fotos(doc, Path(registro_foto_path))
+```
+
+External photo registry generator: https://huggingface.co/spaces/gui-sparim/gerador_fotos
+
+## Language
+
+All UI text, comments, and documentation are in Brazilian Portuguese. Code identifiers mix Portuguese (domain terms) and English (technical terms).

app.py

@@ -0,0 +1,50 @@
+"""
+Sistema de Geração de Laudos de Avaliação Imobiliária.
+
+Ponto de entrada da aplicação.
+"""
+import sys
+from pathlib import Path
+
+# Adicionar diretório raiz ao path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from ui.app_builder import build_interface
+from config.settings import SERVER_HOST, SERVER_PORT
+
+
+def main(fill_dummy: bool = True):
+    """
+    Função principal.
+
+    Args:
+        fill_dummy: Se True, preenche campos com valores de teste (default: True).
+    """
+    print("=" * 50)
+    print("Sistema de Geração de Laudos")
+    print("=" * 50)
+
+    # Verificar modelos disponíveis
+    from models import list_available_models
+    modelos = list_available_models()
+    print(f"\nModelos disponíveis: {modelos}")
+
+    if fill_dummy:
+        print("\n[MODO TESTE] Campos preenchidos com valores dummy")
+
+    # Construir e lançar interface
+    app = build_interface(fill_dummy=fill_dummy)
+
+    print(f"\nIniciando servidor em http://{SERVER_HOST}:{SERVER_PORT}")
+    print("Pressione Ctrl+C para encerrar.\n")
+
+    app.launch(
+        server_name=SERVER_HOST,
+        server_port=SERVER_PORT,
+        share=False
+    )
+
+
+if __name__ == "__main__":
+    # Altere para fill_dummy=False para produção
+    main(fill_dummy=True)

config/constants.py

@@ -0,0 +1,61 @@
+"""
+Constantes e listas para o sistema de geração de laudos.
+"""
+
+# --- Limites de campos dinâmicos ---
+MAX_MOTIVOS_DESVALORIZANTES = 15
+MAX_VALORES_MERCADO = 15
+MAX_DOCUMENTACAO_PADRAO = 10
+MAX_DOCUMENTACAO_ESPECIFICA = 10
+
+# --- Listas para Interface Gráfica ---
+
+UNIDADES_DEMANDANTES = [
+    "Equipe da Planta Genérica de Valores – EPGV (DAI/RM/SMF)",
+    "Outros"
+]
+
+TIPOS_REQUERIMENTO = [
+    "Revisão de Valor Venal - Imóvel Acima do Valor de Mercado",
+    "Outros"
+]
+
+UNIDADES_RESPONSAVEIS = [
+    "Equipe de Avaliações – EAV (DAI/RM/SMF)",
+    "Equipe de Suporte, Judiciais e Locações– ESJL",
+    "Outros"
+]
+
+TECNICOS_RESPONSAVEIS = [
+    "Eng. Adriana Kirsch Bissigo – CREA/RS 69.342",
+    "Eng. Clara Francisca Marques – CREA RS 202.777",
+    "Eng. David Schuch Bertoglio – CREA/RS: 114.44",
+    "Eng. Débora Fonseca Alves – CREA RS190257",
+    "Eng. Edgar Alejandro Vargas - CREA RS 222061",
+    "Eng. Gilmara Müller – CREA 100.093",
+    "Eng. Jones Ritta Rodrigues – CREA/RS 141453-D",
+    "Arq. Fernanda Pontel – CAU/RS A50731-8",
+    "Arq. Gustavo N. B. Bastos – CAU 51953-7",
+    "Arq. Jéssica Lange – CAU A64935-0",
+    "Arq. Roberta Brenner Ayub – CAU A29665-1",
+    "Outros"
+]
+
+METODOS_AVALIACAO = [
+    "Método Comparativo Dados de Mercado - ABNT NBR 14.653-2",
+    "Método Comparativo Dados de Mercado - ABNT NBR 14.653-2 e Método de Quantificação de Custo",
+    "Método Involutivo conforme NBR 14.653",
+    "Outros"
+]
+
+# --- Textos padrão ---
+
+TEXTO_OBSERVACOES_COMPLEMENTARES = """- Pressupõe-se que todas as informações fornecidas por terceiros merecem credibilidade;
+
+- Considerou-se que os documentos e/ou títulos de propriedade do avaliando espelham a realidade;
+
+- Este Laudo de Avaliação consta de {{num_paginas}} folhas, numeradas de 1 a {{num_paginas}} e esta datada;
+
+- Este Laudo de Avaliação utilizou o modelo de avaliação {{modelo_avaliacao}};
+
+- Este Laudo de Avaliação tem como referência {{datas_referencia}}."""

config/settings.py

@@ -0,0 +1,23 @@
+"""
+Configurações do sistema de geração de laudos.
+"""
+from pathlib import Path
+
+# Diretório base do projeto
+BASE_DIR = Path(__file__).parent.parent
+
+# Diretórios principais
+MODELS_DIR = BASE_DIR / "models" / "files"
+TEMPLATES_DIR = BASE_DIR / "templates"
+OUTPUT_DIR = BASE_DIR / "output" / "laudos_gerados"
+
+# Templates
+HEADER_TEMPLATE = TEMPLATES_DIR / "header.docx"
+TEXTOS_DIR = TEMPLATES_DIR / "textos"
+
+# Configurações do servidor Gradio
+SERVER_HOST = "0.0.0.0"
+SERVER_PORT = 7860
+
+# Garantir que diretórios de saída existam
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

core/entities/__init__.py

@@ -0,0 +1,14 @@
+"""
+Entidades do domínio.
+"""
+from .solicitacao import Solicitacao
+from .imovel import Imovel, MotivoDesvalorizante, ValorMercado
+from .laudo import Laudo
+
+__all__ = [
+    'Solicitacao',
+    'Imovel',
+    'MotivoDesvalorizante',
+    'ValorMercado',
+    'Laudo',
+]

core/entities/imovel.py

@@ -0,0 +1,67 @@
+"""
+Entidade Imóvel - dados do imóvel avaliado.
+"""
+from dataclasses import dataclass, field
+from typing import List, Optional
+from decimal import Decimal
+
+
+@dataclass
+class MotivoDesvalorizante:
+    """Representa um motivo desvalorizante do imóvel."""
+
+    descricao: str
+    alegado: bool = True
+    confirmado: bool = False
+
+
+@dataclass
+class ValorMercado:
+    """Representa um valor de mercado para um ano específico."""
+
+    ano: int
+    valor: Decimal
+    extenso: str = ""
+
+
+@dataclass
+class Imovel:
+    """Representa o imóvel objeto da avaliação."""
+
+    # Identificação
+    inscricao: str
+    endereco: str
+    bairro: str
+
+    # Localização cadastral
+    setor: str = ""
+    quarteirao: str = ""
+    lote: str = ""
+
+    # Características
+    finalidade: str = ""
+    area_territorial: str = ""
+    construcoes: str = ""
+
+    # Valores venais (do cadastro)
+    valores_venais: str = ""
+
+    # Motivos desvalorizantes
+    motivos_desvalorizantes: List[MotivoDesvalorizante] = field(default_factory=list)
+
+    # Valores de mercado por ano
+    valores_mercado: List[ValorMercado] = field(default_factory=list)
+
+    # Documentação
+    documentacao_padrao: List[str] = field(default_factory=list)
+    documentacao_especifica: List[str] = field(default_factory=list)
+
+    @property
+    def motivos_alegados(self) -> List[MotivoDesvalorizante]:
+        """Retorna motivos alegados pelo contribuinte."""
+        return [m for m in self.motivos_desvalorizantes if m.alegado]
+
+    @property
+    def motivos_confirmados(self) -> List[MotivoDesvalorizante]:
+        """Retorna motivos confirmados pela avaliação."""
+        return [m for m in self.motivos_desvalorizantes if m.confirmado]

core/entities/laudo.py

@@ -0,0 +1,72 @@
+"""
+Entidade Laudo - representa um laudo de avaliação completo.
+"""
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Optional
+
+from .solicitacao import Solicitacao
+from .imovel import Imovel
+
+
+@dataclass
+class Laudo:
+    """Representa um laudo de avaliação imobiliária completo."""
+
+    # Dados da solicitação
+    solicitacao: Solicitacao
+
+    # Dados do imóvel
+    imovel: Imovel
+
+    # Modelo e método de avaliação
+    modelo_avaliacao: str
+    metodo_avaliacao: str
+
+    # Responsáveis
+    tecnico_responsavel: str
+    unidade_responsavel: str
+
+    # Datas de referência
+    datas_referencia: str = ""
+
+    # Campos customizados
+    metodo_avaliacao_custom: Optional[str] = None
+    tecnico_responsavel_custom: Optional[str] = None
+    unidade_responsavel_custom: Optional[str] = None
+
+    @property
+    def numero(self) -> str:
+        """Retorna número do laudo (da solicitação)."""
+        return self.solicitacao.numero
+
+    @property
+    def processo(self) -> str:
+        """Retorna número do processo."""
+        return self.solicitacao.processo
+
+    @property
+    def data(self) -> date:
+        """Retorna data do laudo."""
+        return self.solicitacao.data
+
+    @property
+    def metodo_avaliacao_final(self) -> str:
+        """Retorna método de avaliação customizado se 'Outros' selecionado."""
+        if self.metodo_avaliacao == "Outros" and self.metodo_avaliacao_custom:
+            return self.metodo_avaliacao_custom
+        return self.metodo_avaliacao
+
+    @property
+    def tecnico_responsavel_final(self) -> str:
+        """Retorna técnico responsável customizado se 'Outros' selecionado."""
+        if self.tecnico_responsavel == "Outros" and self.tecnico_responsavel_custom:
+            return self.tecnico_responsavel_custom
+        return self.tecnico_responsavel
+
+    @property
+    def unidade_responsavel_final(self) -> str:
+        """Retorna unidade responsável customizada se 'Outros' selecionado."""
+        if self.unidade_responsavel == "Outros" and self.unidade_responsavel_custom:
+            return self.unidade_responsavel_custom
+        return self.unidade_responsavel

core/entities/solicitacao.py

@@ -0,0 +1,35 @@
+"""
+Entidade Solicitação - dados da solicitação do laudo.
+"""
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Optional
+
+
+@dataclass
+class Solicitacao:
+    """Representa uma solicitação de laudo de avaliação."""
+
+    numero: str
+    processo: str
+    unidade_demandante: str
+    tipo_requerimento: str
+    data: date = field(default_factory=date.today)
+
+    # Campos opcionais customizados
+    unidade_demandante_custom: Optional[str] = None
+    tipo_requerimento_custom: Optional[str] = None
+
+    @property
+    def unidade_demandante_final(self) -> str:
+        """Retorna unidade demandante customizada se 'Outros' selecionado."""
+        if self.unidade_demandante == "Outros" and self.unidade_demandante_custom:
+            return self.unidade_demandante_custom
+        return self.unidade_demandante
+
+    @property
+    def tipo_requerimento_final(self) -> str:
+        """Retorna tipo de requerimento customizado se 'Outros' selecionado."""
+        if self.tipo_requerimento == "Outros" and self.tipo_requerimento_custom:
+            return self.tipo_requerimento_custom
+        return self.tipo_requerimento

document/__init__.py

@@ -0,0 +1,41 @@
+"""
+Módulo de geração de documentos DOCX.
+"""
+from .numbering import NumeradorSecoes
+from .generator import LaudoGenerator
+from .formatters import (
+    # Parágrafos
+    criar_paragrafo_formatado,
+    add_body_text,
+    add_placeholder_text,
+    add_bullet_text,
+    # Títulos
+    add_section_title,
+    add_subsection_title,
+    add_subsubsection_title,
+    add_subsubsubsection_title,
+    # Tabelas
+    add_simple_table,
+    formatar_celula_tabela,
+    configurar_linha_tabela_altura,
+    criar_celula_cabecalho_tabela,
+    criar_celula_dados_tabela,
+)
+
+__all__ = [
+    'NumeradorSecoes',
+    'LaudoGenerator',
+    'criar_paragrafo_formatado',
+    'add_body_text',
+    'add_placeholder_text',
+    'add_bullet_text',
+    'add_section_title',
+    'add_subsection_title',
+    'add_subsubsection_title',
+    'add_subsubsubsection_title',
+    'add_simple_table',
+    'formatar_celula_tabela',
+    'configurar_linha_tabela_altura',
+    'criar_celula_cabecalho_tabela',
+    'criar_celula_dados_tabela',
+]

document/anexos/__init__.py

@@ -0,0 +1,18 @@
+"""
+Geradores de anexos a partir dos dados do modelo (.dai).
+"""
+from .metodologia import gerar_anexo_metodologia
+from .banco_dados import gerar_anexo_banco_dados
+from .planilha_calculo import gerar_anexo_planilha
+from .graficos import gerar_anexo_graficos
+from .calculo_valor import gerar_anexo_calculo
+from .estatisticas import gerar_anexo_estatisticas
+
+__all__ = [
+    'gerar_anexo_metodologia',
+    'gerar_anexo_banco_dados',
+    'gerar_anexo_planilha',
+    'gerar_anexo_graficos',
+    'gerar_anexo_calculo',
+    'gerar_anexo_estatisticas',
+]

document/anexos/banco_dados.py

@@ -0,0 +1,88 @@
+"""
+Gerador do Anexo de Banco de Dados.
+Gera a tabela com os dados das amostras (Xy_preview).
+"""
+from typing import Optional
+import pandas as pd
+from docx import Document
+from docx.shared import Pt, Inches
+
+from models.model_data import ModelData
+from document.formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+    add_simple_table,
+)
+
+# Hífen que não permite quebra de linha (non-breaking hyphen)
+HIFEN_NAO_QUEBRAVEL = '\u2011'
+
+
+def _formatar_numero(val: float, casas_decimais: int = 2) -> str:
+    """
+    Formata número substituindo hífen por hífen não-quebrável.
+    Evita que o Word quebre a linha entre o sinal negativo e o número.
+    """
+    texto = f"{val:.{casas_decimais}f}"
+    return texto.replace('-', HIFEN_NAO_QUEBRAVEL)
+
+
+def gerar_anexo_banco_dados(doc: Document, modelo: Optional[ModelData]) -> None:
+    """
+    Gera o conteúdo do Anexo de Banco de Dados.
+    
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir banco de dados manualmente]")
+        return
+    
+    if modelo.xy_preview.empty:
+        add_placeholder_text(doc, "[Banco de dados não disponível no modelo]")
+        return
+    
+    df = modelo.xy_preview
+
+    # Detectar colunas que contêm apenas valores inteiros
+    colunas_inteiras = set()
+    for col in df.columns:
+        valores = df[col].dropna()
+        if len(valores) > 0 and all(
+            isinstance(v, (int, float)) and float(v) == int(v)
+            for v in valores
+        ):
+            colunas_inteiras.add(col)
+
+    # Informações gerais
+    add_body_text(doc, f"Total de amostras: {len(df)}")
+    add_body_text(doc, f"Variáveis: {', '.join(df.columns.tolist())}")
+
+    doc.add_paragraph()
+
+    # Preparar dados para tabela (exibir todos os dados com ID)
+    headers = ["ID"] + df.columns.tolist()
+    dados = [headers]
+
+    for idx, (_, row) in enumerate(df.iterrows(), start=1):
+        linha = [str(idx)]  # ID da amostra (1-based)
+        for col, val in zip(df.columns, row.values):
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                linha.append("")
+            elif col in colunas_inteiras:
+                # Inteiros também podem ser negativos
+                texto = str(int(val))
+                linha.append(texto.replace('-', HIFEN_NAO_QUEBRAVEL))
+            elif isinstance(val, (int, float)):
+                linha.append(_formatar_numero(val, casas_decimais=2))
+            else:
+                linha.append(str(val))
+        dados.append(linha)
+    
+    # Calcular larguras proporcionais (ID mais estreito)
+    n_cols = len(headers)
+    larguras = [0.5] + [1] * (n_cols - 1)  # ID mais estreito, demais iguais
+    
+    add_simple_table(doc, dados, header_row=True, largura_colunas=larguras, rotacao_cabecalho=True)

document/anexos/calculo_valor.py

@@ -0,0 +1,92 @@
+"""
+Gerador do Anexo de Cálculo do Valor.
+Apresenta a equação e resultado do cálculo.
+"""
+from typing import Optional, Dict, Any
+from docx import Document
+
+from models.model_data import ModelData
+from document.formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+    criar_paragrafo_formatado,
+)
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+
+def gerar_anexo_calculo(
+    doc: Document, 
+    modelo: Optional[ModelData],
+    valores_imovel: Optional[Dict[str, Any]] = None
+) -> None:
+    """
+    Gera o conteúdo do Anexo de Cálculo do Valor.
+    
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+        valores_imovel: Valores das variáveis do imóvel avaliado (opcional)
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir cálculo manualmente]")
+        return
+    
+    # Equação do modelo
+    if modelo.equacao:
+        add_subsection_title(doc, "", "Equação do Modelo")
+        criar_paragrafo_formatado(
+            doc, 
+            modelo.equacao, 
+            tamanho=11,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER,
+            espaco_depois=12
+        )
+    
+    # Variáveis utilizadas
+    if modelo.variaveis:
+        add_subsection_title(doc, "", "Variáveis do Modelo")
+        for var in modelo.variaveis:
+            add_body_text(doc, f"• {var}")
+    
+    doc.add_paragraph()
+    
+    # Coeficientes
+    if not modelo.tabelas_coef.empty:
+        add_subsection_title(doc, "", "Coeficientes")
+        df = modelo.tabelas_coef
+        
+        # Mostrar coeficientes principais
+        if 'coef' in df.columns or 'Coeficiente' in df.columns:
+            col_coef = 'coef' if 'coef' in df.columns else 'Coeficiente'
+            for idx, row in df.iterrows():
+                coef = row[col_coef]
+                if isinstance(coef, float):
+                    add_body_text(doc, f"• {idx}: {coef:.6f}")
+                else:
+                    add_body_text(doc, f"• {idx}: {coef}")
+    
+    doc.add_paragraph()
+    
+    # Seção para cálculo específico do imóvel (placeholder para preenchimento)
+    add_subsection_title(doc, "", "Cálculo do Valor do Imóvel")
+    
+    if valores_imovel:
+        _calcular_valor(doc, modelo, valores_imovel)
+    else:
+        add_placeholder_text(doc, "[Inserir valores das variáveis para o imóvel avaliado]")
+        add_placeholder_text(doc, "[Inserir cálculo e resultado final]")
+
+
+def _calcular_valor(doc: Document, modelo: ModelData, valores: Dict[str, Any]) -> None:
+    """Calcula e apresenta o valor do imóvel."""
+    add_body_text(doc, "Valores utilizados:")
+    
+    for var, val in valores.items():
+        if isinstance(val, float):
+            add_body_text(doc, f"• {var} = {val:.2f}")
+        else:
+            add_body_text(doc, f"• {var} = {val}")
+    
+    doc.add_paragraph()
+    add_placeholder_text(doc, "[Resultado do cálculo]")

document/anexos/estatisticas.py

@@ -0,0 +1,230 @@
+"""
+Gerador do Anexo de Estatísticas.
+Apresenta o resumo estatístico do modelo seguindo a estrutura do interface_estatisticas.
+"""
+from typing import Optional, Dict, Any
+from docx import Document
+from docx.shared import Pt
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from models.model_data import ModelData
+from document.formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+    add_simple_table,
+    criar_paragrafo_formatado,
+)
+from utils.estatisticas_utils import reorganizar_modelos_resumos, formatar_numero
+
+
+def gerar_anexo_estatisticas(doc: Document, modelo: Optional[ModelData]) -> None:
+    """
+    Gera o conteúdo do Anexo de Estatísticas.
+
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir estatísticas manualmente]")
+        return
+
+    # Estatísticas descritivas das variáveis
+    if not modelo.estatisticas.empty:
+        add_subsection_title(doc, "", "Estatísticas Descritivas das Variáveis")
+        _adicionar_estatisticas_descritivas(doc, modelo.estatisticas)
+        doc.add_paragraph()
+
+    # Resumo do modelo (usando estrutura reorganizada)
+    if modelo.modelos_resumos:
+        resumo = reorganizar_modelos_resumos(modelo.modelos_resumos)
+
+        # Estatísticas Gerais
+        _adicionar_estatisticas_gerais(doc, resumo.get("estatisticas_gerais", {}))
+
+        # Testes Estatísticos
+        _adicionar_teste_f(doc, resumo.get("teste_f", {}))
+        _adicionar_teste_ks(doc, resumo.get("teste_ks", {}))
+        _adicionar_perc_resid(doc, resumo.get("perc_resid", {}))
+        _adicionar_teste_dw(doc, resumo.get("teste_dw", {}))
+        _adicionar_teste_bp(doc, resumo.get("teste_bp", {}))
+
+        # Equação do Modelo
+        _adicionar_equacao(doc, resumo.get("equacao"))
+
+    if modelo.estatisticas.empty and not modelo.modelos_resumos:
+        add_placeholder_text(doc, "[Estatísticas não disponíveis no modelo]")
+
+
+def _adicionar_estatisticas_descritivas(doc: Document, df) -> None:
+    """Adiciona tabela de estatísticas descritivas."""
+    headers = [str(col) for col in df.columns.tolist()]
+
+    if df.index.name or len(df.index) > 0:
+        headers = ["Variável"] + headers
+        dados = [headers]
+
+        for idx, row in df.iterrows():
+            linha = [str(idx)]
+            for val in row.values:
+                linha.append(formatar_numero(val))
+            dados.append(linha)
+    else:
+        dados = [headers]
+        for _, row in df.iterrows():
+            linha = [formatar_numero(val) for val in row.values]
+            dados.append(linha)
+
+    add_simple_table(doc, dados, header_row=True, rotacao_cabecalho=True)
+
+
+def _adicionar_estatisticas_gerais(doc: Document, estat_gerais: Dict[str, Any]) -> None:
+    """Adiciona tabela de estatísticas gerais do modelo."""
+    if not estat_gerais:
+        return
+
+    add_subsection_title(doc, "", "Estatísticas Gerais do Modelo")
+
+    dados = [["Indicador", "Valor"]]
+
+    for chave, info in estat_gerais.items():
+        nome = info.get("nome", chave)
+        valor = info.get("valor")
+        if valor is not None:
+            dados.append([nome, formatar_numero(valor)])
+
+    if len(dados) > 1:
+        add_simple_table(doc, dados, header_row=True)
+
+    doc.add_paragraph()
+
+
+def _adicionar_teste_f(doc: Document, teste: Dict[str, Any]) -> None:
+    """Adiciona resultado do Teste F."""
+    if not teste.get("estatistica"):
+        return
+
+    add_subsection_title(doc, "", teste.get("nome", "Teste F"))
+
+    dados = [["Indicador", "Valor"]]
+    dados.append(["Estatística F", formatar_numero(teste["estatistica"])])
+
+    if teste.get("pvalor") is not None:
+        dados.append(["P-valor", formatar_numero(teste["pvalor"])])
+
+    add_simple_table(doc, dados, header_row=True)
+
+    if teste.get("interpretacao"):
+        _adicionar_interpretacao(doc, teste["interpretacao"])
+
+    doc.add_paragraph()
+
+
+def _adicionar_teste_ks(doc: Document, teste: Dict[str, Any]) -> None:
+    """Adiciona resultado do Teste de Kolmogorov-Smirnov."""
+    if not teste.get("estatistica"):
+        return
+
+    add_subsection_title(doc, "", teste.get("nome", "Teste de Normalidade (Kolmogorov-Smirnov)"))
+
+    dados = [["Indicador", "Valor"]]
+    dados.append(["Estatística KS", formatar_numero(teste["estatistica"])])
+
+    if teste.get("pvalor") is not None:
+        dados.append(["P-valor", formatar_numero(teste["pvalor"])])
+
+    add_simple_table(doc, dados, header_row=True)
+
+    if teste.get("interpretacao"):
+        _adicionar_interpretacao(doc, teste["interpretacao"])
+
+    doc.add_paragraph()
+
+
+def _adicionar_perc_resid(doc: Document, perc: Dict[str, Any]) -> None:
+    """Adiciona resultado do teste de comparação com curva normal."""
+    if not perc.get("valor"):
+        return
+
+    add_subsection_title(doc, "", perc.get("nome", "Teste de Normalidade (Comparação com a Curva Normal)"))
+
+    add_body_text(doc, f"Percentuais atingidos: {perc['valor']}")
+
+    interpretacoes = perc.get("interpretacao", [])
+    if interpretacoes:
+        add_body_text(doc, "Critérios ideais:")
+        for item in interpretacoes:
+            add_body_text(doc, f"  • {item}")
+
+    doc.add_paragraph()
+
+
+def _adicionar_teste_dw(doc: Document, teste: Dict[str, Any]) -> None:
+    """Adiciona resultado do Teste de Durbin-Watson."""
+    if not teste.get("estatistica"):
+        return
+
+    add_subsection_title(doc, "", teste.get("nome", "Teste de Autocorrelação (Durbin-Watson)"))
+
+    dados = [["Indicador", "Valor"]]
+    dados.append(["Estatística DW", formatar_numero(teste["estatistica"])])
+
+    add_simple_table(doc, dados, header_row=True)
+
+    if teste.get("interpretacao"):
+        _adicionar_interpretacao(doc, teste["interpretacao"])
+
+    doc.add_paragraph()
+
+
+def _adicionar_teste_bp(doc: Document, teste: Dict[str, Any]) -> None:
+    """Adiciona resultado do Teste de Breusch-Pagan."""
+    if not teste.get("estatistica"):
+        return
+
+    add_subsection_title(doc, "", teste.get("nome", "Teste de Homocedasticidade (Breusch-Pagan)"))
+
+    dados = [["Indicador", "Valor"]]
+    dados.append(["Estatística LM", formatar_numero(teste["estatistica"])])
+
+    if teste.get("pvalor") is not None:
+        dados.append(["P-valor", formatar_numero(teste["pvalor"])])
+
+    add_simple_table(doc, dados, header_row=True)
+
+    if teste.get("interpretacao"):
+        _adicionar_interpretacao(doc, teste["interpretacao"])
+
+    doc.add_paragraph()
+
+
+def _adicionar_equacao(doc: Document, equacao: Optional[str]) -> None:
+    """Adiciona equação do modelo centralizada."""
+    if not equacao:
+        return
+
+    add_subsection_title(doc, "", "Equação do Modelo")
+
+    criar_paragrafo_formatado(
+        doc,
+        equacao,
+        tamanho=11,
+        alinhamento=WD_ALIGN_PARAGRAPH.CENTER,
+        espaco_antes=6,
+        espaco_depois=6,
+    )
+
+    doc.add_paragraph()
+
+
+def _adicionar_interpretacao(doc: Document, texto: str) -> None:
+    """Adiciona texto de interpretação em itálico."""
+    criar_paragrafo_formatado(
+        doc,
+        f"Interpretação: {texto}",
+        italico=True,
+        tamanho=10,
+        espaco_antes=3,
+        espaco_depois=3,
+    )

document/anexos/graficos.py

@@ -0,0 +1,315 @@
+"""
+Gerador do Anexo de Gráficos.
+Insere gráficos de diagnóstico do modelo no documento.
+"""
+import base64
+import io
+from typing import Optional, List, Tuple
+from docx import Document
+from docx.shared import Inches
+
+import matplotlib
+matplotlib.use('Agg')  # Backend não-interativo para geração de imagens
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import stats
+
+from models.model_data import ModelData
+from document.formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+)
+
+
+def gerar_anexo_graficos(doc: Document, modelo: Optional[ModelData]) -> None:
+    """
+    Gera o conteúdo do Anexo de Gráficos.
+
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir gráficos manualmente]")
+        return
+
+    graficos_inseridos = 0
+
+    # Tentar gerar gráficos a partir dos dados do modelo
+    if modelo.modelos_sm is not None or not modelo.tabelas_obs_calc.empty:
+        graficos = _gerar_graficos_diagnostico(modelo)
+
+        for titulo, img_buffer in graficos:
+            # Título já está dentro do gráfico, não precisa adicionar em texto
+            # Tamanho reduzido para caber 2 gráficos por página
+            doc.add_picture(img_buffer, width=Inches(5.0))
+            graficos_inseridos += 1
+
+    # Fallback: tentar inserir graf_model existente
+    if graficos_inseridos == 0 and modelo.graf_model:
+        add_subsection_title(doc, "", "Gráficos do Modelo")
+        if _inserir_grafico(doc, modelo.graf_model):
+            graficos_inseridos += 1
+
+    if graficos_inseridos == 0:
+        add_placeholder_text(doc, "[Gráficos não disponíveis no modelo]")
+
+
+def _gerar_graficos_diagnostico(modelo: ModelData) -> List[Tuple[str, io.BytesIO]]:
+    """
+    Gera gráficos de diagnóstico do modelo de regressão.
+
+    Args:
+        modelo: Dados do modelo
+
+    Returns:
+        Lista de tuplas (título, buffer de imagem)
+    """
+    graficos = []
+
+    # Obter dados para os gráficos
+    obs_calc = modelo.tabelas_obs_calc
+    modelos_sm = modelo.modelos_sm
+
+    # Identificar colunas de valores observados e calculados
+    y_obs = None
+    y_calc = None
+    residuos = None
+
+    if not obs_calc.empty:
+        # Tentar identificar colunas
+        cols_lower = {c.lower(): c for c in obs_calc.columns}
+
+        for nome_obs in ['observado', 'obs', 'y_obs', 'y', 'valor_observado']:
+            if nome_obs in cols_lower:
+                y_obs = obs_calc[cols_lower[nome_obs]].values
+                break
+
+        for nome_calc in ['calculado', 'calc', 'y_calc', 'y_hat', 'previsto', 'predicted', 'valor_calculado']:
+            if nome_calc in cols_lower:
+                y_calc = obs_calc[cols_lower[nome_calc]].values
+                break
+
+        for nome_res in ['residuo', 'residuos', 'resid', 'residual']:
+            if nome_res in cols_lower:
+                residuos = obs_calc[cols_lower[nome_res]].values
+                break
+
+    # Se temos statsmodels result, extrair dados dele
+    if modelos_sm is not None:
+        try:
+            if y_obs is None and hasattr(modelos_sm, 'model') and hasattr(modelos_sm.model, 'endog'):
+                y_obs = modelos_sm.model.endog
+            if y_calc is None and hasattr(modelos_sm, 'fittedvalues'):
+                y_calc = modelos_sm.fittedvalues
+            if residuos is None and hasattr(modelos_sm, 'resid'):
+                residuos = modelos_sm.resid
+        except Exception:
+            pass
+
+    # Calcular resíduos se temos obs e calc
+    if residuos is None and y_obs is not None and y_calc is not None:
+        residuos = np.array(y_obs) - np.array(y_calc)
+
+    # Gráfico 1: Valores Observados vs Calculados
+    if y_obs is not None and y_calc is not None:
+        graf = _criar_grafico_obs_calc(y_obs, y_calc)
+        if graf:
+            graficos.append(("Valores Observados vs Calculados", graf))
+
+    # Gráfico 2: Resíduos vs Valores Ajustados
+    if residuos is not None and y_calc is not None:
+        graf = _criar_grafico_residuos(y_calc, residuos)
+        if graf:
+            graficos.append(("Resíduos vs Valores Ajustados", graf))
+
+    # Gráfico 3: QQ-Plot dos Resíduos
+    if residuos is not None:
+        graf = _criar_qqplot(residuos)
+        if graf:
+            graficos.append(("Gráfico Q-Q dos Resíduos", graf))
+
+    # Gráfico 4: Histograma dos Resíduos
+    if residuos is not None:
+        graf = _criar_histograma_residuos(residuos)
+        if graf:
+            graficos.append(("Distribuição dos Resíduos", graf))
+
+    return graficos
+
+
+def _criar_grafico_obs_calc(y_obs: np.ndarray, y_calc: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria gráfico de valores observados vs calculados."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        ax.scatter(y_calc, y_obs, alpha=0.6, edgecolors='black', linewidths=0.5, color='#FF8C00')
+
+        # Linha de identidade (45 graus)
+        min_val = min(min(y_obs), min(y_calc))
+        max_val = max(max(y_obs), max(y_calc))
+        ax.plot([min_val, max_val], [min_val, max_val], 'r--', linewidth=1.5, label='Linha de identidade')
+
+        ax.set_xlabel('Valores Calculados', fontsize=11)
+        ax.set_ylabel('Valores Observados', fontsize=11)
+        ax.set_title('Valores Observados vs Calculados', fontsize=12, fontweight='bold')
+        ax.legend(loc='upper left')
+        ax.grid(True, alpha=0.3)
+
+        # Ajustar limites
+        margin = (max_val - min_val) * 0.05
+        ax.set_xlim(min_val - margin, max_val + margin)
+        ax.set_ylim(min_val - margin, max_val + margin)
+
+        plt.tight_layout()
+
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')
+        buf.seek(0)
+        plt.close(fig)
+
+        return buf
+    except Exception as e:
+        print(f"Erro ao criar gráfico obs vs calc: {e}")
+        return None
+
+
+def _criar_grafico_residuos(y_calc: np.ndarray, residuos: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria gráfico de resíduos vs valores ajustados."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        ax.scatter(y_calc, residuos, alpha=0.6, edgecolors='black', linewidths=0.5, color='#FF8C00')
+        ax.axhline(y=0, color='red', linestyle='--', linewidth=1.5)
+
+        ax.set_xlabel('Valores Ajustados', fontsize=11)
+        ax.set_ylabel('Resíduos', fontsize=11)
+        ax.set_title('Resíduos vs Valores Ajustados', fontsize=12, fontweight='bold')
+        ax.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')
+        buf.seek(0)
+        plt.close(fig)
+
+        return buf
+    except Exception as e:
+        print(f"Erro ao criar gráfico de resíduos: {e}")
+        return None
+
+
+def _criar_qqplot(residuos: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria QQ-Plot dos resíduos."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        # Padronizar resíduos
+        residuos_std = (residuos - np.mean(residuos)) / np.std(residuos)
+
+        stats.probplot(residuos_std, dist="norm", plot=ax)
+
+        ax.set_xlabel('Quantis Teóricos', fontsize=11)
+        ax.set_ylabel('Quantis Amostrais', fontsize=11)
+        ax.set_title('Gráfico Q-Q (Normalidade dos Resíduos)', fontsize=12, fontweight='bold')
+        ax.grid(True, alpha=0.3)
+
+        # Mudar cor dos pontos para laranja
+        ax.get_lines()[0].set_markerfacecolor('#FF8C00')
+        ax.get_lines()[0].set_markeredgecolor('black')
+        ax.get_lines()[0].set_markeredgewidth(0.5)
+
+        plt.tight_layout()
+
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')
+        buf.seek(0)
+        plt.close(fig)
+
+        return buf
+    except Exception as e:
+        print(f"Erro ao criar QQ-plot: {e}")
+        return None
+
+
+def _criar_histograma_residuos(residuos: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria histograma dos resíduos com curva normal."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        # Histograma
+        n, bins, patches = ax.hist(residuos, bins='auto', density=True, alpha=0.7,
+                                    color='#FF8C00', edgecolor='black', linewidth=0.5)
+
+        # Curva normal ajustada
+        mu, sigma = np.mean(residuos), np.std(residuos)
+        x = np.linspace(min(residuos), max(residuos), 100)
+        y = stats.norm.pdf(x, mu, sigma)
+        ax.plot(x, y, 'r-', linewidth=2, label='Curva Normal')
+
+        ax.set_xlabel('Resíduos', fontsize=11)
+        ax.set_ylabel('Densidade', fontsize=11)
+        ax.set_title('Distribuição dos Resíduos', fontsize=12, fontweight='bold')
+        ax.legend(loc='upper right')
+        ax.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')
+        buf.seek(0)
+        plt.close(fig)
+
+        return buf
+    except Exception as e:
+        print(f"Erro ao criar histograma: {e}")
+        return None
+
+
+def _inserir_grafico(doc: Document, graf_data: str) -> bool:
+    """
+    Tenta inserir um gráfico no documento.
+
+    Args:
+        doc: Documento DOCX
+        graf_data: Dados do gráfico (base64, caminho, HTML, ou string)
+
+    Returns:
+        True se conseguiu inserir, False caso contrário
+    """
+    try:
+        # Verificar se é HTML (Plotly)
+        if graf_data.strip().startswith('<html') or graf_data.strip().startswith('<div'):
+            add_body_text(doc, "[Gráfico em formato HTML/Plotly - gráficos de diagnóstico gerados automaticamente]")
+            return False
+
+        # Tentar como base64
+        if graf_data.startswith('data:image'):
+            header, encoded = graf_data.split(',', 1)
+            image_data = base64.b64decode(encoded)
+            image_stream = io.BytesIO(image_data)
+            doc.add_picture(image_stream, width=Inches(5.0))
+            return True
+
+        # Tentar como base64 puro
+        try:
+            image_data = base64.b64decode(graf_data)
+            image_stream = io.BytesIO(image_data)
+            doc.add_picture(image_stream, width=Inches(5.0))
+            return True
+        except Exception:
+            pass
+
+        # Tentar como caminho de arquivo
+        from pathlib import Path
+        if len(graf_data) < 500 and Path(graf_data).exists():
+            doc.add_picture(graf_data, width=Inches(5.0))
+            return True
+
+        return False
+
+    except Exception as e:
+        print(f"Erro ao inserir gráfico: {e}")
+        return False

document/anexos/metodologia.py

@@ -0,0 +1,103 @@
+"""
+Gerador do Anexo de Metodologia.
+Gera a seção de metodologia a partir dos dados do modelo (.dai).
+"""
+from typing import Optional
+from docx import Document
+from docx.shared import Pt
+
+from models.model_data import ModelData
+from document.formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+    add_simple_table,
+)
+
+
+def gerar_anexo_metodologia(doc: Document, modelo: Optional[ModelData], num_secao: str = "") -> None:
+    """
+    Gera o conteúdo do Anexo de Metodologia.
+    
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+        num_secao: Número da seção para títulos
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir metodologia manualmente]")
+        return
+    
+    # Informações do modelo
+    add_subsection_title(doc, "", "Modelo Utilizado")
+    add_body_text(doc, f"Modelo: {modelo.nome}")
+    
+    if modelo.n_amostras:
+        add_body_text(doc, f"Número de amostras: {modelo.n_amostras}")
+    
+    if modelo.n_variaveis:
+        add_body_text(doc, f"Número de variáveis: {modelo.n_variaveis}")
+    
+    # Variáveis do modelo
+    if modelo.variaveis:
+        add_subsection_title(doc, "", "Variáveis do Modelo")
+        for var in modelo.variaveis:
+            add_body_text(doc, f"• {var}")
+    
+    # Equação
+    if modelo.equacao:
+        add_subsection_title(doc, "", "Equação do Modelo")
+        add_body_text(doc, modelo.equacao)
+    
+    # Coeficientes
+    if not modelo.tabelas_coef.empty:
+        add_subsection_title(doc, "", "Coeficientes")
+        _adicionar_tabela_coeficientes(doc, modelo)
+    
+    # Estatísticas do modelo
+    if modelo.modelos_resumos:
+        add_subsection_title(doc, "", "Indicadores Estatísticos")
+        _adicionar_resumo_modelo(doc, modelo)
+
+
+def _adicionar_tabela_coeficientes(doc: Document, modelo: ModelData) -> None:
+    """Adiciona tabela de coeficientes."""
+    df = modelo.tabelas_coef
+    
+    # Preparar dados para tabela
+    headers = ["Variável"] + [str(col) for col in df.columns.tolist()]
+    dados = [headers]
+    
+    for idx, row in df.iterrows():
+        linha = [str(idx)] + [f"{v:.4f}" if isinstance(v, float) else str(v) for v in row.values]
+        dados.append(linha)
+    
+    add_simple_table(doc, dados, header_row=True)
+
+
+def _adicionar_resumo_modelo(doc: Document, modelo: ModelData) -> None:
+    """Adiciona resumo estatístico do modelo."""
+    resumo = modelo.modelos_resumos
+    
+    indicadores = []
+    
+    if 'r2' in resumo:
+        indicadores.append(f"R² = {resumo['r2']:.4f}")
+    
+    if 'r2_ajustado' in resumo:
+        indicadores.append(f"R² ajustado = {resumo['r2_ajustado']:.4f}")
+    
+    if 'fc' in resumo:
+        indicadores.append(f"Fc = {resumo['fc']:.2f}")
+    
+    if 'sig' in resumo:
+        indicadores.append(f"Significância = {resumo['sig']:.4f}")
+    
+    if 'n' in resumo:
+        indicadores.append(f"n = {resumo['n']}")
+    
+    if 'k' in resumo:
+        indicadores.append(f"k = {resumo['k']}")
+    
+    for ind in indicadores:
+        add_body_text(doc, f"• {ind}")

document/anexos/planilha_calculo.py

@@ -0,0 +1,196 @@
+"""
+Gerador do Anexo de Planilha de Cálculo e Resultados Estatísticos.
+Gera tabelas de coeficientes, valores observados vs calculados e resumo estatístico.
+"""
+from typing import Optional, Dict, Any
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from models.model_data import ModelData
+from document.formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+    add_simple_table,
+    criar_paragrafo_formatado,
+)
+from utils.estatisticas_utils import reorganizar_modelos_resumos, formatar_numero
+
+
+def gerar_anexo_planilha(doc: Document, modelo: Optional[ModelData]) -> None:
+    """
+    Gera o conteúdo do Anexo de Planilha de Cálculo e Resultados Estatísticos.
+
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir planilha manualmente]")
+        return
+
+    conteudo_gerado = False
+
+    # 1. RESUMO ESTATÍSTICO (como na aba Resumo do interface_estatisticas)
+    if modelo.modelos_resumos:
+        _adicionar_resumo_estatistico(doc, modelo.modelos_resumos)
+        conteudo_gerado = True
+
+    # 2. Tabela de Coeficientes
+    if not modelo.tabelas_coef.empty:
+        add_subsection_title(doc, "", "Coeficientes do Modelo")
+        _adicionar_tabela_coeficientes(doc, modelo.tabelas_coef)
+        doc.add_paragraph()
+        conteudo_gerado = True
+
+    # 3. Tabela de Valores Observados vs Calculados
+    if not modelo.tabelas_obs_calc.empty:
+        add_subsection_title(doc, "", "Valores Observados vs Calculados")
+        _adicionar_tabela_obs_calc(doc, modelo.tabelas_obs_calc)
+        conteudo_gerado = True
+
+    if not conteudo_gerado:
+        add_placeholder_text(doc, "[Dados de planilha não disponíveis no modelo]")
+
+
+def _adicionar_resumo_estatistico(doc: Document, modelos_resumos: Dict[str, Any]) -> None:
+    """
+    Adiciona o resumo estatístico no formato da aba Resumo do interface_estatisticas.
+    """
+    resumo = reorganizar_modelos_resumos(modelos_resumos)
+
+    # Estatísticas Gerais
+    estat_gerais = resumo.get("estatisticas_gerais", {})
+    if estat_gerais:
+        add_subsection_title(doc, "", "Estatísticas Gerais")
+        dados = [["Indicador", "Valor"]]
+        for chave, info in estat_gerais.items():
+            nome = info.get("nome", chave)
+            valor = info.get("valor")
+            if valor is not None:
+                dados.append([nome, formatar_numero(valor)])
+        if len(dados) > 1:
+            add_simple_table(doc, dados, header_row=True)
+        doc.add_paragraph()
+
+    # Teste F
+    teste_f = resumo.get("teste_f", {})
+    if teste_f.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_f.get("nome", "Teste F"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística F", formatar_numero(teste_f["estatistica"])])
+        if teste_f.get("pvalor") is not None:
+            dados.append(["P-valor", formatar_numero(teste_f["pvalor"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_f.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_f["interpretacao"])
+        doc.add_paragraph()
+
+    # Teste de Normalidade (Kolmogorov-Smirnov)
+    teste_ks = resumo.get("teste_ks", {})
+    if teste_ks.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_ks.get("nome", "Teste de Normalidade (Kolmogorov-Smirnov)"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística KS", formatar_numero(teste_ks["estatistica"])])
+        if teste_ks.get("pvalor") is not None:
+            dados.append(["P-valor", formatar_numero(teste_ks["pvalor"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_ks.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_ks["interpretacao"])
+        doc.add_paragraph()
+
+    # Teste de Normalidade (Comparação com Curva Normal)
+    perc_resid = resumo.get("perc_resid", {})
+    if perc_resid.get("valor"):
+        add_subsection_title(doc, "", perc_resid.get("nome", "Teste de Normalidade (Comparação com a Curva Normal)"))
+        add_body_text(doc, f"Percentuais atingidos: {perc_resid['valor']}")
+        interpretacoes = perc_resid.get("interpretacao", [])
+        if interpretacoes:
+            add_body_text(doc, "Critérios ideais:")
+            for item in interpretacoes:
+                add_body_text(doc, f"  • {item}")
+        doc.add_paragraph()
+
+    # Teste de Autocorrelação (Durbin-Watson)
+    teste_dw = resumo.get("teste_dw", {})
+    if teste_dw.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_dw.get("nome", "Teste de Autocorrelação (Durbin-Watson)"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística DW", formatar_numero(teste_dw["estatistica"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_dw.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_dw["interpretacao"])
+        doc.add_paragraph()
+
+    # Teste de Homocedasticidade (Breusch-Pagan)
+    teste_bp = resumo.get("teste_bp", {})
+    if teste_bp.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_bp.get("nome", "Teste de Homocedasticidade (Breusch-Pagan)"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística LM", formatar_numero(teste_bp["estatistica"])])
+        if teste_bp.get("pvalor") is not None:
+            dados.append(["P-valor", formatar_numero(teste_bp["pvalor"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_bp.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_bp["interpretacao"])
+        doc.add_paragraph()
+
+    # Equação do Modelo
+    equacao = resumo.get("equacao")
+    if equacao:
+        add_subsection_title(doc, "", "Equação do Modelo")
+        criar_paragrafo_formatado(
+            doc,
+            equacao,
+            tamanho=11,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER,
+            espaco_antes=6,
+            espaco_depois=6,
+        )
+        doc.add_paragraph()
+
+
+def _adicionar_interpretacao(doc: Document, texto: str) -> None:
+    """Adiciona texto de interpretação em itálico."""
+    criar_paragrafo_formatado(
+        doc,
+        f"Interpretação: {texto}",
+        italico=True,
+        tamanho=10,
+        espaco_antes=3,
+        espaco_depois=3,
+    )
+
+
+def _adicionar_tabela_coeficientes(doc: Document, df) -> None:
+    """Adiciona tabela de coeficientes."""
+    headers = ["Variável"] + [str(col) for col in df.columns.tolist()]
+    dados = [headers]
+
+    for idx, row in df.iterrows():
+        linha = [str(idx)]
+        for val in row.values:
+            if isinstance(val, float):
+                linha.append(f"{val:.6f}")
+            else:
+                linha.append(str(val) if val is not None else "")
+        dados.append(linha)
+
+    add_simple_table(doc, dados, header_row=True, rotacao_cabecalho=True)
+
+
+def _adicionar_tabela_obs_calc(doc: Document, df) -> None:
+    """Adiciona tabela de valores observados vs calculados (todos os dados com ID)."""
+    headers = ["ID"] + [str(col) for col in df.columns.tolist()]
+    dados = [headers]
+
+    for idx, (_, row) in enumerate(df.iterrows(), start=1):
+        linha = [str(idx)]  # ID da amostra (1-based)
+        for val in row.values:
+            if isinstance(val, float):
+                linha.append(f"{val:.2f}")
+            else:
+                linha.append(str(val) if val is not None else "")
+        dados.append(linha)
+
+    add_simple_table(doc, dados, header_row=True, rotacao_cabecalho=True)

document/formatters/__init__.py

@@ -0,0 +1,61 @@
+"""
+Formatadores de documentos DOCX.
+"""
+from .paragraph import (
+    aplicar_cor_run,
+    criar_paragrafo_formatado,
+    add_body_text,
+    add_placeholder_text,
+    add_bullet_text,
+)
+from .heading import (
+    add_heading_custom,
+    add_section_title,
+    add_subsection_title,
+    add_subsubsection_title,
+    add_subsubsubsection_title,
+)
+from .table import (
+    set_cell_shading,
+    formatar_celula_tabela,
+    add_simple_table,
+    configurar_linha_tabela_altura,
+    criar_celula_cabecalho_tabela,
+    criar_celula_dados_tabela,
+)
+from .image import (
+    inserir_imagem_de_documento,
+    add_image_placeholder,
+)
+from .section import (
+    iniciar_secao_paisagem,
+    iniciar_secao_retrato,
+)
+
+__all__ = [
+    # Parágrafos
+    'aplicar_cor_run',
+    'criar_paragrafo_formatado',
+    'add_body_text',
+    'add_placeholder_text',
+    'add_bullet_text',
+    # Títulos
+    'add_heading_custom',
+    'add_section_title',
+    'add_subsection_title',
+    'add_subsubsection_title',
+    'add_subsubsubsection_title',
+    # Tabelas
+    'set_cell_shading',
+    'formatar_celula_tabela',
+    'add_simple_table',
+    'configurar_linha_tabela_altura',
+    'criar_celula_cabecalho_tabela',
+    'criar_celula_dados_tabela',
+    # Imagens
+    'inserir_imagem_de_documento',
+    'add_image_placeholder',
+    # Seções
+    'iniciar_secao_paisagem',
+    'iniciar_secao_retrato',
+]

document/formatters/heading.py

@@ -0,0 +1,57 @@
+"""
+Formatadores de títulos e seções.
+"""
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from .paragraph import criar_paragrafo_formatado
+
+
+def add_heading_custom(doc: Document, text: str, level: int = 1):
+    """Adiciona título customizado."""
+    configs = {
+        1: {'tamanho': 14, 'antes': 18, 'depois': 12},
+        2: {'tamanho': 12, 'antes': 12, 'depois': 6},
+    }
+    cfg = configs.get(level, {'tamanho': 11, 'antes': 6, 'depois': 6})
+
+    return criar_paragrafo_formatado(
+        doc, text, negrito=True, sublinhado=True, tamanho=cfg['tamanho'],
+        espaco_antes=cfg['antes'], espaco_depois=cfg['depois'],
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_section_title(doc: Document, number: str, text: str):
+    """Adiciona título de seção principal (ex: 1. SOLICITAÇÃO)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number}. {text}", negrito=True, tamanho=12,
+        espaco_antes=18, espaco_depois=12, alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_subsection_title(doc: Document, number: str, text: str):
+    """Adiciona título de subseção (ex: 1.1 Considerações)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number} {text}", negrito=True, tamanho=11,
+        espaco_antes=12, espaco_depois=6, recuo_esq=0.3,
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_subsubsection_title(doc: Document, number: str, text: str):
+    """Adiciona título de sub-subseção (ex: 3.2.1)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number} {text}", negrito=True, tamanho=11,
+        espaco_antes=10, espaco_depois=4, recuo_esq=0.5,
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_subsubsubsection_title(doc: Document, number: str, text: str):
+    """Adiciona título de sub-sub-subseção (ex: 3.2.1.1)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number} {text}", negrito=True, tamanho=10,
+        espaco_antes=8, espaco_depois=4, recuo_esq=0.7,
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )

document/formatters/image.py

@@ -0,0 +1,63 @@
+"""
+Formatadores de imagens.
+"""
+from io import BytesIO
+from docx import Document
+from docx.shared import Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from typing import Dict, Any, Optional
+
+
+def inserir_imagem_de_documento(
+    doc: Document,
+    imagem_data: Optional[Dict[str, Any]],
+    largura_inches: float = 5.5
+) -> bool:
+    """
+    Insere uma imagem extraída de outro documento.
+
+    Args:
+        doc: Documento destino
+        imagem_data: Dict com 'paragraph_element' e 'doc' (documento origem)
+        largura_inches: Largura da imagem
+
+    Returns:
+        True se inseriu com sucesso, False caso contrário
+    """
+    if not imagem_data:
+        return False
+
+    try:
+        para_elem = imagem_data['paragraph_element']
+        doc_origem = imagem_data['doc']
+
+        ns_a = '{http://schemas.openxmlformats.org/drawingml/2006/main}'
+        ns_r = '{http://schemas.openxmlformats.org/officeDocument/2006/relationships}'
+
+        for blip in para_elem.iter(f'{ns_a}blip'):
+            embed_id = blip.get(f'{ns_r}embed')
+            if embed_id:
+                try:
+                    image_part = doc_origem.part.related_parts[embed_id]
+                    image_stream = BytesIO(image_part.blob)
+
+                    p = doc.add_paragraph()
+                    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                    run = p.add_run()
+                    run.add_picture(image_stream, width=Inches(largura_inches))
+                    return True
+                except Exception as e:
+                    print(f"Erro ao copiar imagem: {e}")
+                    return False
+    except Exception as e:
+        print(f"Erro ao processar imagem: {e}")
+        return False
+
+    return False
+
+
+def add_image_placeholder(doc: Document) -> None:
+    """Adiciona placeholder de imagem."""
+    p = doc.add_paragraph()
+    p.add_run("[IMAGEM]").italic = True
+    p.alignment = WD_ALIGN_PARAGRAPH.CENTER

document/formatters/paragraph.py

@@ -0,0 +1,102 @@
+"""
+Formatadores de parágrafos.
+"""
+from docx import Document
+from docx.shared import Pt, Inches, Cm, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from typing import Optional, Tuple, Union
+
+
+def aplicar_cor_run(run, cor: Optional[Union[Tuple[int, int, int], RGBColor]]) -> None:
+    """
+    Aplica cor RGB a um run.
+
+    Args:
+        run: Run do python-docx
+        cor: tuple (r,g,b) ou RGBColor
+    """
+    if cor:
+        if isinstance(cor, tuple):
+            run.font.color.rgb = RGBColor(cor[0], cor[1], cor[2])
+        else:
+            run.font.color.rgb = cor
+
+
+def criar_paragrafo_formatado(
+    doc: Document,
+    texto: str,
+    negrito: bool = False,
+    sublinhado: bool = False,
+    italico: bool = False,
+    tamanho: int = 11,
+    cor: Optional[Union[Tuple[int, int, int], RGBColor]] = None,
+    alinhamento=WD_ALIGN_PARAGRAPH.JUSTIFY,
+    espaco_antes: int = 0,
+    espaco_depois: int = 6,
+    recuo_esq: float = 0,
+    recuo_primeira_linha: float = 0,
+    fonte: str = 'Arial'
+):
+    """
+    Cria um parágrafo com formatação completa.
+
+    Args:
+        doc: Documento python-docx
+        texto: Texto do parágrafo
+        negrito, sublinhado, italico: Formatação do texto
+        tamanho: Tamanho da fonte em pontos
+        cor: RGBColor ou tuple (r,g,b)
+        alinhamento: WD_ALIGN_PARAGRAPH constant
+        espaco_antes, espaco_depois: Espaçamento em pontos
+        recuo_esq: Recuo esquerdo em inches
+        recuo_primeira_linha: Recuo da primeira linha em cm
+        fonte: Nome da fonte
+
+    Returns:
+        Parágrafo criado
+    """
+    p = doc.add_paragraph()
+    run = p.add_run(texto)
+
+    run.bold = negrito
+    run.underline = sublinhado
+    run.italic = italico
+    run.font.size = Pt(tamanho)
+    run.font.name = fonte
+    aplicar_cor_run(run, cor)
+
+    p.alignment = alinhamento
+    p.paragraph_format.space_before = Pt(espaco_antes)
+    p.paragraph_format.space_after = Pt(espaco_depois)
+    if recuo_esq:
+        p.paragraph_format.left_indent = Inches(recuo_esq)
+    if recuo_primeira_linha:
+        p.paragraph_format.first_line_indent = Cm(recuo_primeira_linha)
+
+    return p
+
+
+def add_body_text(doc: Document, text: str, cor=None, indent: bool = True):
+    """Adiciona texto do corpo com formatação padrão."""
+    return criar_paragrafo_formatado(
+        doc, text, tamanho=11, cor=cor,
+        espaco_depois=6, recuo_esq=0.3 if indent else 0,
+        recuo_primeira_linha=1.25 if indent else 0
+    )
+
+
+def add_placeholder_text(doc: Document, text: str = "[Preencher informações]", indent: bool = True):
+    """Adiciona texto placeholder em vermelho."""
+    return criar_paragrafo_formatado(
+        doc, text, tamanho=11, cor=RGBColor(255, 0, 0),
+        espaco_depois=6, recuo_esq=0.3 if indent else 0,
+        recuo_primeira_linha=1.25 if indent else 0
+    )
+
+
+def add_bullet_text(doc: Document, text: str, indent_level: int = 1):
+    """Adiciona texto com bullet/recuo."""
+    return criar_paragrafo_formatado(
+        doc, f"• {text}", tamanho=11,
+        espaco_depois=3, recuo_esq=0.3 + (indent_level * 0.2)
+    )

document/formatters/section.py

@@ -0,0 +1,59 @@
+"""
+Formatadores de seções e orientação de página.
+"""
+from docx import Document
+from docx.shared import Cm
+from docx.enum.section import WD_ORIENT
+
+
+def iniciar_secao_paisagem(doc: Document) -> None:
+    """
+    Adiciona uma nova seção com orientação paisagem.
+
+    Args:
+        doc: Documento DOCX
+    """
+    # Adicionar quebra de seção
+    new_section = doc.add_section()
+
+    # Configurar orientação paisagem
+    new_section.orientation = WD_ORIENT.LANDSCAPE
+
+    # Trocar largura e altura para paisagem
+    new_width = new_section.page_height
+    new_height = new_section.page_width
+    new_section.page_width = new_width
+    new_section.page_height = new_height
+
+    # Ajustar margens para paisagem
+    new_section.top_margin = Cm(2)
+    new_section.bottom_margin = Cm(2)
+    new_section.left_margin = Cm(2)
+    new_section.right_margin = Cm(2)
+
+
+def iniciar_secao_retrato(doc: Document) -> None:
+    """
+    Adiciona uma nova seção com orientação retrato.
+
+    Args:
+        doc: Documento DOCX
+    """
+    # Adicionar quebra de seção
+    new_section = doc.add_section()
+
+    # Configurar orientação retrato
+    new_section.orientation = WD_ORIENT.PORTRAIT
+
+    # Trocar largura e altura para retrato (se estava em paisagem)
+    if new_section.page_width > new_section.page_height:
+        new_width = new_section.page_height
+        new_height = new_section.page_width
+        new_section.page_width = new_width
+        new_section.page_height = new_height
+
+    # Margens padrão para retrato
+    new_section.top_margin = Cm(2.5)
+    new_section.bottom_margin = Cm(2.5)
+    new_section.left_margin = Cm(3)
+    new_section.right_margin = Cm(2)

document/formatters/table.py

@@ -0,0 +1,238 @@
+"""
+Formatadores de tabelas.
+"""
+from docx import Document
+from docx.shared import Pt, Inches, Cm
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.table import WD_TABLE_ALIGNMENT, WD_CELL_VERTICAL_ALIGNMENT
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
+from typing import List, Optional, Union, Dict, Any
+
+from .paragraph import aplicar_cor_run
+
+WD_ALIGN_VERTICAL = WD_CELL_VERTICAL_ALIGNMENT
+
+
+def set_cell_shading(cell, color: str) -> None:
+    """
+    Define a cor de fundo de uma célula.
+
+    Args:
+        cell: Célula da tabela
+        color: Cor em hex (ex: "E6E6E6")
+    """
+    shading = OxmlElement('w:shd')
+    shading.set(qn('w:fill'), color)
+    cell._tc.get_or_add_tcPr().append(shading)
+
+
+def set_cell_text_rotation(cell, direcao: str = 'btLr') -> None:
+    """
+    Define a direção/rotação do texto em uma célula.
+
+    Args:
+        cell: Célula da tabela
+        direcao: Direção do texto:
+            - 'btLr': bottom-to-top, left-to-right (90° - vertical)
+            - 'tbRl': top-to-bottom, right-to-left (270°)
+    """
+    tcPr = cell._tc.get_or_add_tcPr()
+    textDirection = OxmlElement('w:textDirection')
+    textDirection.set(qn('w:val'), direcao)
+    tcPr.append(textDirection)
+
+
+def formatar_celula_tabela(cell, texto: str, negrito: bool = False, cor=None,
+                           shading_color: Optional[str] = None, rotacao: bool = False):
+    """
+    Formata uma célula de tabela com configurações padrão.
+
+    Args:
+        cell: Célula da tabela
+        texto: Texto a inserir
+        negrito: Se o texto deve ser negrito
+        cor: Cor do texto (tuple ou RGBColor)
+        shading_color: Cor de fundo da célula (hex string)
+        rotacao: Se True, rotaciona o texto 90° (vertical)
+
+    Returns:
+        Run criado
+    """
+    p = cell.paragraphs[0]
+
+    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    p.paragraph_format.left_indent = Cm(0)
+    p.paragraph_format.right_indent = Cm(0)
+    p.paragraph_format.first_line_indent = Cm(0)
+    p.paragraph_format.space_before = Pt(0)
+    p.paragraph_format.space_after = Pt(0)
+
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+    run = p.add_run(texto)
+    run.font.size = Pt(9)
+    run.font.name = 'Arial'
+    run.bold = negrito
+
+    if cor:
+        aplicar_cor_run(run, cor)
+
+    if shading_color:
+        set_cell_shading(cell, shading_color)
+
+    if rotacao:
+        set_cell_text_rotation(cell)
+
+    return run
+
+
+def add_simple_table(
+    doc: Document,
+    dados_tabela: List[List[Union[str, Dict[str, Any]]]],
+    header_row: bool = True,
+    largura_colunas: Optional[List[int]] = None,
+    rotacao_cabecalho: bool = False
+):
+    """
+    Adiciona uma tabela simples ao documento.
+
+    Args:
+        doc: Documento
+        dados_tabela: Lista de listas. Cada célula pode ser string ou dict {'texto', 'cor'}
+        header_row: Se True, primeira linha é cabeçalho (negrito com fundo cinza)
+        largura_colunas: Lista de inteiros representando proporção da largura de cada coluna.
+        rotacao_cabecalho: Se True, rotaciona o texto dos cabeçalhos 90° (vertical)
+
+    Returns:
+        Tabela criada ou None se dados vazios
+    """
+    if not dados_tabela or not dados_tabela[0]:
+        return None
+
+    num_colunas = len(dados_tabela[0])
+
+    if largura_colunas is None:
+        largura_colunas = [1] * num_colunas
+    elif len(largura_colunas) != num_colunas:
+        raise ValueError("largura_colunas deve ter o mesmo número de colunas de dados_tabela")
+
+    total = sum(largura_colunas)
+    proporcoes = [x / total for x in largura_colunas]
+
+    table = doc.add_table(rows=len(dados_tabela), cols=num_colunas)
+    table.style = 'Table Grid'
+    table.alignment = WD_TABLE_ALIGNMENT.CENTER
+
+    largura_total = Inches(6.5)
+    larguras_em_colunas = [largura_total * p for p in proporcoes]
+
+    for i, row_data in enumerate(dados_tabela):
+        row = table.rows[i]
+        for j, cell_data in enumerate(row_data):
+            if j >= len(row.cells):
+                continue
+
+            cell = row.cells[j]
+
+            if isinstance(cell_data, dict):
+                texto = cell_data.get('texto', '')
+                cor = cell_data.get('cor')
+            else:
+                texto = str(cell_data) if cell_data else ""
+                cor = None
+
+            is_header = header_row and i == 0
+
+            formatar_celula_tabela(
+                cell, texto,
+                negrito=is_header,
+                cor=cor,
+                shading_color="E6E6E6" if is_header else None,
+                rotacao=is_header and rotacao_cabecalho
+            )
+
+            cell.width = larguras_em_colunas[j]
+
+    # Ajustar altura do cabeçalho para texto rotacionado
+    if header_row and rotacao_cabecalho and dados_tabela:
+        # Calcular o maior texto do cabeçalho
+        header_texts = []
+        for cell_data in dados_tabela[0]:
+            if isinstance(cell_data, dict):
+                header_texts.append(cell_data.get('texto', ''))
+            else:
+                header_texts.append(str(cell_data) if cell_data else "")
+
+        if header_texts:
+            max_len = max(len(t) for t in header_texts)
+            # Aproximadamente 0.18cm por caractere em Arial 9pt + margem
+            altura_cm = max(1.0, max_len * 0.18 + 0.3)
+            configurar_linha_tabela_altura(table.rows[0], altura_cm)
+
+    doc.add_paragraph()
+    return table
+
+
+def configurar_linha_tabela_altura(row, altura_cm: float = 0.6) -> None:
+    """
+    Configura altura mínima de uma linha de tabela.
+
+    Args:
+        row: Linha da tabela
+        altura_cm: Altura em centímetros
+    """
+    tr = row._tr
+    trPr = tr.get_or_add_trPr()
+    trHeight = OxmlElement('w:trHeight')
+    trHeight.set(qn('w:val'), str(int(Cm(altura_cm).twips)))
+    trHeight.set(qn('w:hRule'), 'atLeast')
+    trPr.append(trHeight)
+
+
+def criar_celula_cabecalho_tabela(cell, texto: str, recuo_primeira_linha_cm: float = 1.0) -> None:
+    """
+    Formata uma célula de cabeçalho de seção na tabela principal.
+
+    Args:
+        cell: Célula da tabela
+        texto: Texto do cabeçalho
+        recuo_primeira_linha_cm: Recuo da primeira linha
+    """
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+    p = cell.paragraphs[0]
+    p.paragraph_format.left_indent = Cm(0)
+    p.paragraph_format.first_line_indent = Cm(recuo_primeira_linha_cm)
+    p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+
+    run = p.add_run(texto)
+    run.bold = True
+    run.underline = True
+    run.font.size = Pt(11)
+    run.font.name = 'Arial'
+
+    set_cell_shading(cell, "E6E6E6")
+
+
+def criar_celula_dados_tabela(cell, texto: str, is_label: bool = False) -> None:
+    """
+    Formata uma célula de dados na tabela principal.
+
+    Args:
+        cell: Célula da tabela
+        texto: Texto da célula
+        is_label: Se True, formata como rótulo (negrito)
+    """
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+    p = cell.paragraphs[0]
+    p.paragraph_format.left_indent = Cm(0)
+    p.paragraph_format.first_line_indent = Cm(0)
+    p.paragraph_format.space_before = Pt(0)
+    p.paragraph_format.space_after = Pt(0)
+
+    run = p.add_run(texto)
+    run.bold = is_label
+    run.font.size = Pt(9)
+    run.font.name = 'Arial'

document/generator.py

@@ -0,0 +1,407 @@
+"""
+Gerador principal de laudos de avaliação.
+"""
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from docx import Document
+from docx.shared import Pt, Inches, Cm
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.table import WD_TABLE_ALIGNMENT
+
+from .numbering import NumeradorSecoes
+from .formatters import (
+    criar_paragrafo_formatado,
+    add_body_text,
+    add_placeholder_text,
+    add_section_title,
+    add_subsection_title,
+    add_subsubsection_title,
+    add_simple_table,
+    configurar_linha_tabela_altura,
+    criar_celula_cabecalho_tabela,
+    criar_celula_dados_tabela,
+    iniciar_secao_paisagem,
+    iniciar_secao_retrato,
+)
+
+from config.settings import TEMPLATES_DIR, TEXTOS_DIR, OUTPUT_DIR
+from models import get_model
+from utils.docx_loader import ler_texto_docx, mesclar_documento_fotos
+from .anexos import (
+    gerar_anexo_metodologia,
+    gerar_anexo_banco_dados,
+    gerar_anexo_planilha,
+    gerar_anexo_graficos,
+    gerar_anexo_calculo,
+)
+
+
+class LaudoGenerator:
+    """Gerador de laudos de avaliação imobiliária."""
+
+    def __init__(self):
+        self.header_path = TEMPLATES_DIR / "header.docx"
+        self.output_dir = OUTPUT_DIR
+
+    def gerar(self, dados: Dict, motivos_formatados: Dict) -> Optional[Path]:
+        """
+        Gera um laudo completo.
+
+        Args:
+            dados: Dicionário com todos os dados do laudo
+            motivos_formatados: Dicionário com motivos desvalorizantes formatados
+
+        Returns:
+            Path do arquivo gerado ou None se falhar
+        """
+        try:
+            # Criar documento
+            doc = None
+            if self.header_path.exists():
+                try:
+                    doc = Document(str(self.header_path))
+                    self._substituir_processo_header(doc, dados.get('numero_processo', ''))
+                except Exception:
+                    # Header inválido ou corrompido, criar documento vazio
+                    doc = None
+
+            if doc is None:
+                doc = Document()
+                self._configurar_margens(doc)
+
+            # Atualizar dados com motivos formatados
+            dados['motivos_alegados'] = motivos_formatados.get('alegados_texto', '')
+            dados['motivos_existentes'] = motivos_formatados.get('confirmados_texto', '')
+
+            # Gerar seções
+            self._gerar_cabecalho(doc, dados)
+            self._gerar_corpo(doc, dados, motivos_formatados)
+            self._gerar_assinatura(doc, dados)
+            self._gerar_anexos(doc, dados)
+
+            # Mesclar documento de registro fotográfico se fornecido
+            registro_foto_path = dados.get('registro_fotografico_path')
+            if registro_foto_path:
+                doc = mesclar_documento_fotos(doc, Path(registro_foto_path))
+
+            # Salvar
+            output_path = self._gerar_nome_arquivo(dados)
+            doc.save(str(output_path))
+
+            return output_path
+
+        except Exception as e:
+            print(f"Erro ao gerar laudo: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    def _configurar_margens(self, doc: Document) -> None:
+        """Configura margens do documento."""
+        for section in doc.sections:
+            section.top_margin = Cm(2.5)
+            section.bottom_margin = Cm(2.5)
+            section.left_margin = Cm(3)
+            section.right_margin = Cm(2)
+
+    def _substituir_processo_header(self, doc: Document, numero_processo: str) -> None:
+        """Substitui número do processo no header."""
+        if not numero_processo:
+            return
+
+        for section in doc.sections:
+            if section.header:
+                for paragraph in section.header.paragraphs:
+                    if "XXX" in paragraph.text:
+                        new_text = paragraph.text.replace("XXX", numero_processo)
+                        for run in paragraph.runs:
+                            run.clear()
+                        run = paragraph.add_run(new_text)
+                        run.bold = True
+                        run.font.name = 'Arial'
+                        run.font.size = Pt(10)
+
+    def _gerar_cabecalho(self, doc: Document, dados: Dict) -> None:
+        """Gera o cabeçalho/tabela inicial do laudo."""
+        # Título
+        criar_paragrafo_formatado(
+            doc, "LAUDO DE AVALIAÇÃO", negrito=True, sublinhado=True, tamanho=14,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER
+        )
+
+        # Número do laudo
+        criar_paragrafo_formatado(
+            doc, dados.get('numero_laudo', 'LA_XXX_XXXX'), tamanho=12,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER, espaco_depois=12
+        )
+
+        # Tabela de dados
+        table = doc.add_table(rows=0, cols=2)
+        table.style = 'Table Grid'
+        table.alignment = WD_TABLE_ALIGNMENT.CENTER
+
+        def add_section_header(text):
+            row = table.add_row()
+            row.height = Cm(1.2)
+            cell = row.cells[0]
+            cell.merge(row.cells[1])
+            criar_celula_cabecalho_tabela(cell, text)
+
+        def add_row(label, value):
+            row = table.add_row()
+            configurar_linha_tabela_altura(row, 0.6)
+            criar_celula_dados_tabela(row.cells[0], label, is_label=True)
+            criar_celula_dados_tabela(row.cells[1], str(value) if value else "")
+
+        # Definição das seções
+        secoes = [
+            ("SOLICITAÇÃO", [
+                ("Unidade demandante:", 'unidade_demandante'),
+                ("Requerimento:", 'dados_requerimento'),
+                ("Requerente/Representante legal:", 'representante_legal'),
+                ("Motivos desvalorizantes alegados:", 'motivos_alegados'),
+                ("Valor venal proposto contribuinte:", 'valor_proposto'),
+                ("Documentação Padrão:", 'documentacao_padrao'),
+                ("Documentação Específica:", 'documentacao_especifica'),
+            ]),
+            ("IMÓVEL OBJETO", [
+                ("Endereço:", 'endereco_imovel'),
+                ("Bairro (Setor/Quarteirão):", 'bairro_imovel'),
+                ("Lote Fiscal:", 'lote_imovel'),
+                ("Inscrição:", 'inscricao_imovel'),
+                ("Finalidade Imóvel:", 'finalidade_imovel'),
+                ("Área Territorial Total / Privativa:", 'area_territorial'),
+                ("Área construída:", 'construcoes_imovel'),
+                ("Valores Venais Guias IPTU:", 'valores_venais'),
+            ]),
+            ("ANÁLISE VALOR DE MERCADO", [
+                ("Unidade responsável:", 'unidade_responsavel'),
+                ("Técnico responsável:", 'tecnico_responsavel'),
+                ("Método de Avaliação:", 'metodo_avaliacao'),
+                ("Modelo de Avaliação utilizado:", 'modelo_avaliacao'),
+            ]),
+            ("CONCLUSÃO TÉCNICA", [
+                ("Valores de Mercado:", 'valores_mercado'),
+                ("Referências:", 'datas_referencia'),
+                ("Motivos desvalorizantes existentes:", 'motivos_existentes'),
+            ]),
+        ]
+
+        for header, rows in secoes:
+            add_section_header(header)
+            for label, key in rows:
+                add_row(label, dados.get(key, ''))
+
+        for row in table.rows:
+            row.cells[0].width = Inches(2.5)
+            row.cells[1].width = Inches(4.0)
+
+    def _gerar_corpo(self, doc: Document, dados: Dict, motivos_formatados: Dict) -> None:
+        """Gera o corpo principal do laudo."""
+        num = NumeradorSecoes()
+
+        # 1. SOLICITAÇÃO
+        add_section_title(doc, num.secao(), "SOLICITAÇÃO")
+        add_subsection_title(doc, num.subsecao(), "CONSIDERAÇÕES INICIAIS")
+
+        # Carregar texto de considerações iniciais do template
+        texto_consideracoes = ler_texto_docx(TEXTOS_DIR / "CONSIDERACOES_INICIAIS.docx")
+        if texto_consideracoes:
+            for paragrafo in texto_consideracoes.split("\n\n"):
+                if paragrafo.strip():
+                    add_body_text(doc, paragrafo.strip())
+        else:
+            add_placeholder_text(doc, "[Inserir considerações iniciais]")
+
+        add_subsection_title(doc, num.subsecao(), "DOCUMENTAÇÃO APRESENTADA")
+        add_placeholder_text(doc)
+
+        # 2. IMÓVEL OBJETO
+        add_section_title(doc, num.secao(), "IMÓVEL OBJETO")
+        add_subsection_title(doc, num.subsecao(), "DESCRIÇÃO DO IMÓVEL")
+        add_placeholder_text(doc)
+
+        add_subsection_title(doc, num.subsecao(), "CARACTERÍSTICAS PARTICULARMENTE DESVALORIZANTES")
+
+        secoes_motivos = motivos_formatados.get('secoes', [])
+        if not secoes_motivos:
+            add_placeholder_text(doc)
+        else:
+            for secao in secoes_motivos:
+                add_subsubsection_title(doc, num.subsubsecao(), secao['titulo'])
+                p = doc.add_paragraph()
+                p.add_run(f"Status: {secao['status']}").italic = True
+                p.paragraph_format.left_indent = Inches(0.5)
+                add_placeholder_text(doc)
+
+        # 3. ANÁLISE DE MERCADO
+        add_section_title(doc, num.secao(), "ANÁLISE VALOR DE MERCADO")
+        add_subsection_title(doc, num.subsecao(), "DIAGNÓSTICO DE MERCADO")
+        add_placeholder_text(doc, "[Inserir diagnóstico de mercado]")
+
+        add_subsection_title(doc, num.subsecao(), "METODOLOGIA DE AVALIAÇÃO")
+        # Tentar gerar metodologia a partir do modelo
+        modelo_nome = dados.get('modelo_avaliacao', '')
+        modelo = get_model(modelo_nome) if modelo_nome else None
+        if modelo:
+            gerar_anexo_metodologia(doc, modelo)
+        else:
+            add_placeholder_text(doc, "[Inserir metodologia - selecione um modelo]")
+
+        # 4. ESPECIFICAÇÃO
+        add_section_title(doc, num.secao(), "ESPECIFICAÇÃO DA AVALIAÇÃO")
+        add_body_text(doc, f"Método: {dados.get('metodo_avaliacao', '')}")
+        add_placeholder_text(doc)
+
+        # 5. CONCLUSÃO
+        add_section_title(doc, num.secao(), "CONCLUSÃO TÉCNICA")
+        add_body_text(doc, "Em face do acima exposto, esta EAV concluiu que:")
+
+        add_subsection_title(doc, num.subsecao(), "SOBRE AS CARACTERÍSTICAS PARTICULARMENTE DESVALORIZANTES")
+        if not secoes_motivos:
+            add_body_text(doc, "- não foram identificados motivos desvalorizantes;")
+        else:
+            for i, secao in enumerate(secoes_motivos, 1):
+                if secao['confirmado']:
+                    texto = f"- {secao['titulo'].lower()}, conforme item 2.2.{i};"
+                else:
+                    texto = f"- quanto ao motivo \"{secao['titulo'].lower()}\", não foi confirmado;"
+                add_body_text(doc, texto)
+
+        add_subsection_title(doc, num.subsecao(), "SOBRE O VALOR DE MERCADO")
+        valores_mercado_lista = dados.get('valores_mercado_lista', [])
+        if valores_mercado_lista:
+            self._gerar_tabela_valores_mercado(doc, valores_mercado_lista)
+        else:
+            add_placeholder_text(doc)
+
+        add_subsection_title(doc, num.subsecao(), "OBSERVAÇÕES COMPLEMENTARES")
+        add_placeholder_text(doc, "[Inserir observações]")
+
+        # 6. ANEXOS (lista)
+        add_section_title(doc, num.secao(), "ANEXOS")
+        for anexo in ["I. BANCO DE DADOS", "II. PLANILHA DE CÁLCULO", "III. GRÁFICOS",
+                      "IV. CÁLCULO DO VALOR", "V. DADOS DO IMÓVEL", "VI. REGISTRO FOTOGRÁFICO"]:
+            add_body_text(doc, anexo)
+
+    def _gerar_tabela_valores_mercado(self, doc: Document, valores_lista: List[Dict]) -> None:
+        """Gera tabela de valores de mercado."""
+        dados_tabela = [
+            ["Exercício IPTU", "Ano Base", "VTOTAL Imóvel"]
+        ]
+
+        for item in valores_lista:
+            ano = item.get('ano', '')
+            valor = item.get('valor', '')
+            valor_extenso = item.get('valor_extenso', '')
+
+            if ano and valor:
+                exercicio = str(ano)
+                ano_base = str(int(ano) - 1) if ano else ''
+
+                if valor_extenso:
+                    vtotal = f"R$ {valor} ({valor_extenso})"
+                else:
+                    vtotal = f"R$ {valor}"
+
+                dados_tabela.append([exercicio, ano_base, vtotal])
+
+        if len(dados_tabela) > 1:
+            add_simple_table(doc, dados_tabela, header_row=True, largura_colunas=[1, 1, 8])
+
+    def _gerar_assinatura(self, doc: Document, dados: Dict) -> None:
+        """Gera a seção de assinatura."""
+        doc.add_paragraph()
+
+        data_laudo = dados.get('data_laudo', datetime.now().strftime('%d de %B de %Y'))
+        criar_paragrafo_formatado(
+            doc, f"Porto Alegre, {data_laudo}.",
+            tamanho=11, alinhamento=WD_ALIGN_PARAGRAPH.RIGHT
+        )
+
+        doc.add_paragraph()
+        doc.add_paragraph()
+
+        p = doc.add_paragraph()
+        p.paragraph_format.first_line_indent = Inches(0)
+        p.paragraph_format.left_indent = Inches(0)
+        p.add_run("_" * 40)
+        p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        if dados.get('tecnico_responsavel'):
+            criar_paragrafo_formatado(
+                doc, dados.get('tecnico_responsavel'), tamanho=11,
+                alinhamento=WD_ALIGN_PARAGRAPH.CENTER
+            )
+
+        p = doc.add_paragraph()
+        p.paragraph_format.first_line_indent = Inches(0)
+        p.paragraph_format.left_indent = Inches(0)
+        run = p.add_run("Equipe de Avaliações\nDAI-RM-SMF")
+        run.bold = True
+        run.font.size = Pt(11)
+        run.font.name = 'Arial'
+        p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+    def _criar_titulo_anexo(self, doc: Document, titulo: str) -> None:
+        """Cria título de anexo com formatação padrão (tamanho 10, centralizado)."""
+        criar_paragrafo_formatado(
+            doc, titulo, negrito=True, sublinhado=True, tamanho=10,
+            espaco_antes=18, espaco_depois=12, alinhamento=WD_ALIGN_PARAGRAPH.CENTER
+        )
+
+    def _gerar_anexos(self, doc: Document, dados: Dict) -> None:
+        """Gera as páginas de anexos a partir dos dados do modelo."""
+        # Tentar carregar o modelo selecionado
+        modelo_nome = dados.get('modelo_avaliacao', '')
+        modelo = get_model(modelo_nome) if modelo_nome else None
+
+        # ANEXO I - BANCO DE DADOS (orientação paisagem)
+        iniciar_secao_paisagem(doc)
+        self._criar_titulo_anexo(doc, "ANEXO I – BANCO DE DADOS")
+        gerar_anexo_banco_dados(doc, modelo)
+
+        # ANEXO II - PLANILHA DE CÁLCULO (volta para retrato)
+        iniciar_secao_retrato(doc)
+        self._criar_titulo_anexo(doc, "ANEXO II – PLANILHA DE CÁLCULO E RESULTADOS ESTATÍSTICOS")
+        gerar_anexo_planilha(doc, modelo)
+
+        # ANEXO III - GRÁFICOS
+        doc.add_page_break()
+        self._criar_titulo_anexo(doc, "ANEXO III – GRÁFICOS")
+        gerar_anexo_graficos(doc, modelo)
+
+        # ANEXO IV - CÁLCULO DO VALOR
+        doc.add_page_break()
+        self._criar_titulo_anexo(doc, "ANEXO IV – CÁLCULO DO VALOR")
+        gerar_anexo_calculo(doc, modelo)
+
+        # ANEXO V - DADOS E LOCALIZAÇÃO (placeholder manual)
+        doc.add_page_break()
+        self._criar_titulo_anexo(doc, "ANEXO V – DADOS E LOCALIZAÇÃO DO IMÓVEL")
+        add_placeholder_text(doc, "[Inserir dados e localização do imóvel]")
+
+        # ANEXO VI - REGISTRO FOTOGRÁFICO
+        # Se houver documento de fotos, não gerar título nem placeholder
+        # (o documento já contém o título do anexo)
+        registro_foto_path = dados.get('registro_fotografico_path')
+        if not registro_foto_path:
+            doc.add_page_break()
+            self._criar_titulo_anexo(doc, "ANEXO VI – REGISTRO FOTOGRÁFICO")
+            add_placeholder_text(doc, "[Inserir registro fotográfico]")
+
+    def _gerar_nome_arquivo(self, dados: Dict) -> Path:
+        """Gera nome do arquivo de saída."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        inscricao = dados.get('inscricao_imovel', 'sem_inscricao')
+        numero = dados.get('numero_laudo', 'sem_numero')
+
+        inscricao_safe = re.sub(r'[^\w\-]', '_', inscricao)
+        numero_safe = re.sub(r'[^\w\-]', '_', numero)
+
+        filename = f"Laudo_{numero_safe}_{inscricao_safe}_{timestamp}.docx"
+        return self.output_dir / filename

document/numbering.py

@@ -0,0 +1,68 @@
+"""
+Numeração automática hierárquica de seções.
+"""
+
+
+class NumeradorSecoes:
+    """
+    Gerencia numeração automática hierárquica de seções.
+
+    Uso:
+        num = NumeradorSecoes()
+        num.secao()           # "1"
+        num.subsecao()        # "1.1"
+        num.subsecao()        # "1.2"
+        num.secao()           # "2"
+        num.subsubsecao()     # "2.0.1" (se não chamou subsecao antes)
+    """
+
+    def __init__(self, secao_inicial: int = 0):
+        """
+        Args:
+            secao_inicial: Número inicial para seções (0 = começa em 1)
+        """
+        self.contadores = [secao_inicial, 0, 0, 0]
+
+    def _reset_niveis_abaixo(self, nivel: int) -> None:
+        """Reseta contadores de níveis abaixo do especificado."""
+        for i in range(nivel + 1, len(self.contadores)):
+            self.contadores[i] = 0
+
+    def secao(self) -> str:
+        """Incrementa e retorna número da seção (ex: '1')."""
+        self.contadores[0] += 1
+        self._reset_niveis_abaixo(0)
+        return str(self.contadores[0])
+
+    def subsecao(self) -> str:
+        """Incrementa e retorna número da subseção (ex: '1.1')."""
+        self.contadores[1] += 1
+        self._reset_niveis_abaixo(1)
+        return f"{self.contadores[0]}.{self.contadores[1]}"
+
+    def subsubsecao(self) -> str:
+        """Incrementa e retorna número da sub-subseção (ex: '1.1.1')."""
+        self.contadores[2] += 1
+        self._reset_niveis_abaixo(2)
+        return f"{self.contadores[0]}.{self.contadores[1]}.{self.contadores[2]}"
+
+    def subsubsubsecao(self) -> str:
+        """Incrementa e retorna número da sub-sub-subseção (ex: '1.1.1.1')."""
+        self.contadores[3] += 1
+        return f"{self.contadores[0]}.{self.contadores[1]}.{self.contadores[2]}.{self.contadores[3]}"
+
+    def numero_atual(self, nivel: int = 0) -> str:
+        """Retorna o número atual de um nível sem incrementar."""
+        if nivel == 0:
+            return str(self.contadores[0])
+        elif nivel == 1:
+            return f"{self.contadores[0]}.{self.contadores[1]}"
+        elif nivel == 2:
+            return f"{self.contadores[0]}.{self.contadores[1]}.{self.contadores[2]}"
+        else:
+            return f"{self.contadores[0]}.{self.contadores[1]}.{self.contadores[2]}.{self.contadores[3]}"
+
+    def definir_secao(self, numero: int) -> None:
+        """Define manualmente o número da seção atual."""
+        self.contadores[0] = numero
+        self._reset_niveis_abaixo(0)

extractors/pdf_extractor.py

@@ -0,0 +1,148 @@
+"""
+Extrator de dados do PDF do SIAT.
+"""
+import re
+from typing import Optional, Dict
+from pypdf import PdfReader
+
+
+def extrair_dados_pdf(pdf_file) -> Optional[Dict]:
+    """Extrai dados do PDF do SIAT."""
+    if pdf_file is None:
+        return None
+
+    try:
+        reader = PdfReader(pdf_file)
+        text = ""
+        for page in reader.pages:
+            page_text = page.extract_text()
+            if page_text:
+                text += page_text
+
+        dados = {
+            "inscricao_imovel": None,
+            "endereco_imovel": None,
+            "bairro_imovel": None,
+            "setor_imovel": None,
+            "quarteirao_imovel": None,
+            "lote_imovel": None,
+            "finalidade_imovel": None,
+            "area_territorial": None,
+            "construcoes_imovel": "Sem construções cadastradas",
+            "valores_venais": None
+        }
+
+        # INSCRIÇÃO
+        m = re.search(r'(\d{0,10})Inscriç', text)
+        if m:
+            dados["inscricao_imovel"] = m.group(1)
+
+        # BAIRRO
+        pattern_bairro = re.compile(r"Quadra \/ Lote(.*?)Bairro", re.DOTALL)
+        bairros = [b.strip() for b in pattern_bairro.findall(text)]
+        if bairros:
+            dados["bairro_imovel"] = list(set(bairros))[-1]
+
+        # ENDEREÇO
+        pattern_endereco = re.compile(
+            r"([^\n]*? - Porto Alegre/RS - \d{5}-\d{3})",
+            re.IGNORECASE
+        )
+        matches_end = pattern_endereco.findall(text)
+        if matches_end:
+            endereco_completo = matches_end[-1]
+            if dados["bairro_imovel"]:
+                dados["endereco_imovel"] = endereco_completo.split(f" - {dados['bairro_imovel']}")[0].strip()
+            else:
+                dados["endereco_imovel"] = re.split(r"\s-\s(?:PORTO ALEGRE|Porto Alegre)/RS", endereco_completo)[0].strip()
+
+        # SETOR
+        pattern_setor = re.compile(r"Ratei(.*?)Setor", re.DOTALL)
+        try:
+            setores = [re.findall(r"(?<!\d)\d{5}(?![,\d])", m)[-1] for m in pattern_setor.findall(text)]
+            if setores:
+                dados["setor_imovel"] = list(set(setores))[-1]
+        except (IndexError, Exception):
+            pass
+
+        # QUARTEIRÃO
+        pattern_quadra = re.compile(r"Setor(.*?)Quadra", re.DOTALL)
+        try:
+            quadras = [re.findall(r"(?<!\d)\d{4}(?![,\d])", m)[-1] for m in pattern_quadra.findall(text)]
+            if quadras:
+                dados["quarteirao_imovel"] = list(set(quadras))[-1]
+        except (IndexError, Exception):
+            pass
+
+        # LOTE
+        pattern_lote = re.compile(r"Lote Fiscal(.*?)Quarteir", re.DOTALL)
+        try:
+            lotes = [re.findall(r"(\d{1}\.\d{8}\.\d{4})", m)[-1] for m in pattern_lote.findall(text)]
+            if lotes:
+                dados["lote_imovel"] = list(set(lotes))[-1]
+        except (IndexError, Exception):
+            pass
+
+        # FINALIDADE
+        pattern_finalidade = re.compile(r"Uso(.*?)Finalidad", re.DOTALL)
+        fins = [f.strip() for f in pattern_finalidade.findall(text)]
+        if fins:
+            dados["finalidade_imovel"] = list(set(fins))[-1]
+
+        # VALOR VENAL
+        pattern_valor = re.compile(r'Tributação(.*?)Planta', re.DOTALL)
+        matches_valor = pattern_valor.findall(text)
+        valores_ano = []
+        for m in matches_valor:
+            try:
+                ano = re.search(r'(\d{4})', m).group(1)
+                valores = re.findall(r'(\d{1,3}(?:\.\d{3})*,\d{2})', m)
+                valor_venal = valores[2]
+                valores_ano.append(f"{ano}: R$ {valor_venal}")
+            except:
+                continue
+        if valores_ano:
+            dados["valores_venais"] = " | ".join(valores_ano)
+
+        # ÁREA TERRITORIAL
+        match_area_real = re.search(r"Área real total\s+(\d{1,5},\d{2})\s*m²", text, re.IGNORECASE)
+        area_real = match_area_real.group(1) if match_area_real else "0,00"
+
+        matches_corr = re.findall(r'territorial corrigida(.*?)Última', text, re.DOTALL | re.IGNORECASE)
+        corrigidas = []
+        for m in matches_corr:
+            valores = re.findall(r"(\d{1,5},\d{2})", m)
+            if valores:
+                corrigidas.extend(valores)
+        corrigidas_unicas = list(set(corrigidas))
+        area_corrigida = corrigidas_unicas[-1] if corrigidas_unicas else "0,00"
+
+        dados["area_territorial"] = f"{area_real} m² / {area_corrigida} m²"
+
+        # ÁREA CONSTRUÍDA
+        pattern_area_construida = re.compile(
+            r"Área Construída(.*?)Documento de Origem",
+            re.DOTALL | re.IGNORECASE
+        )
+        match_area = pattern_area_construida.search(text)
+        construcoes = []
+        if match_area:
+            bloco = match_area.group(1)
+            pattern_const = re.compile(
+                r"^\s*\d+\s+(?P<area>\d{1,4},\d{2})\s+(?P<ano>\d{4})\s+\d{4}\s+(?P<tipo>.*?)\s+\d{1,2}-\d{1,2}%",
+                re.MULTILINE
+            )
+            for m in pattern_const.finditer(bloco):
+                area = m.group("area")
+                ano = m.group("ano")
+                tipo = m.group("tipo").strip()
+                construcoes.append(f"{area} m² / {ano} / {tipo}")
+
+        if construcoes:
+            dados["construcoes_imovel"] = "\n".join(construcoes)
+
+        return dados
+
+    except Exception as e:
+        print(f"Erro ao extrair dados do PDF: {e}")
+        return None

models/__init__.py

@@ -0,0 +1,33 @@
+"""
+Sistema de Modelos de Avaliação.
+
+Uso:
+    from models import list_available_models, get_model
+
+    # Listar modelos disponíveis
+    modelos = list_available_models()
+    print(modelos)  # ['ABC', 'MOD_V_TCOND_Z4_008C', ...]
+
+    # Carregar um modelo
+    modelo = get_model('ABC')
+    print(modelo.r2)
+    print(modelo.variaveis)
+"""
+from .model_data import ModelData
+from .registry import (
+    ModelRegistry,
+    get_registry,
+    list_available_models,
+    get_model,
+)
+from .model_loader import load_model, load_model_by_name
+
+__all__ = [
+    'ModelData',
+    'ModelRegistry',
+    'get_registry',
+    'list_available_models',
+    'get_model',
+    'load_model',
+    'load_model_by_name',
+]

models/files/ABC/modelo.dai

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b72078033c7ea67662dde85f737c3cd4033b749bfb50b57ff3b090971a966b1c
+size 691301

models/model_data.py

@@ -0,0 +1,77 @@
+"""
+Dataclass tipada para os dados do modelo de avaliação.
+Os dados são carregados de arquivos .dai (joblib).
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+
+import pandas as pd
+
+
+@dataclass
+class ModelData:
+    """Representa os dados estatísticos de um modelo de avaliação."""
+
+    nome: str
+    path: Path
+
+    # Dados do banco de dados
+    xy_preview: pd.DataFrame = field(default_factory=pd.DataFrame)
+    top_x_esc: pd.DataFrame = field(default_factory=pd.DataFrame)
+    top_y_esc: pd.Series = field(default_factory=pd.Series)
+
+    # Estatísticas descritivas
+    estatisticas: pd.DataFrame = field(default_factory=pd.DataFrame)
+
+    # Modelo de regressão
+    tabelas_coef: pd.DataFrame = field(default_factory=pd.DataFrame)
+    tabelas_obs_calc: pd.DataFrame = field(default_factory=pd.DataFrame)
+    modelos_resumos: Dict[str, Any] = field(default_factory=dict)
+    modelos_sm: Any = None  # RegressionResultsWrapper
+
+    # Transformações e gráficos
+    formatted_top_transformation_info: List[Any] = field(default_factory=list)
+    graf_model: str = ""
+
+    @property
+    def r2(self) -> Optional[float]:
+        """Retorna o coeficiente de determinação R²."""
+        return self.modelos_resumos.get('r2')
+
+    @property
+    def r2_ajustado(self) -> Optional[float]:
+        """Retorna o R² ajustado."""
+        return self.modelos_resumos.get('r2_ajustado')
+
+    @property
+    def equacao(self) -> Optional[str]:
+        """Retorna a equação do modelo."""
+        return self.modelos_resumos.get('equacao')
+
+    @property
+    def variaveis(self) -> List[str]:
+        """Retorna lista de variáveis do modelo."""
+        if self.tabelas_coef.empty:
+            return []
+        return [v for v in self.tabelas_coef.index.tolist() if v != 'const']
+
+    @property
+    def n_amostras(self) -> int:
+        """Retorna número de amostras no banco de dados."""
+        return self.modelos_resumos.get('n', 0)
+
+    @property
+    def n_variaveis(self) -> int:
+        """Retorna número de variáveis do modelo."""
+        return self.modelos_resumos.get('k', 0)
+
+    def tem_template(self) -> bool:
+        """Verifica se existe template de metodologia."""
+        template_path = self.path / "metodologia.docx"
+        return template_path.exists()
+
+    def get_template_path(self) -> Optional[Path]:
+        """Retorna caminho do template de metodologia."""
+        template_path = self.path / "metodologia.docx"
+        return template_path if template_path.exists() else None

models/model_loader.py

@@ -0,0 +1,63 @@
+"""
+Carregador de modelos de avaliação.
+Carrega arquivos .dai via joblib.
+"""
+from pathlib import Path
+from typing import Optional
+import joblib
+
+from .model_data import ModelData
+
+
+def load_model(model_path: Path) -> Optional[ModelData]:
+    """
+    Carrega um modelo de avaliação a partir de uma pasta.
+
+    Args:
+        model_path: Caminho para a pasta do modelo (contendo modelo.dai)
+
+    Returns:
+        ModelData com os dados carregados, ou None se falhar
+    """
+    dai_path = model_path / "modelo.dai"
+
+    if not dai_path.exists():
+        return None
+
+    try:
+        data = joblib.load(dai_path)
+    except Exception as e:
+        print(f"Erro ao carregar {dai_path}: {e}")
+        return None
+
+    model = ModelData(
+        nome=model_path.name,
+        path=model_path,
+        xy_preview=data.get('Xy_preview_out_coords'),
+        top_x_esc=data.get('top_X_esc'),
+        top_y_esc=data.get('top_y_esc'),
+        estatisticas=data.get('estatisticas'),
+        tabelas_coef=data.get('tabelas_coef'),
+        tabelas_obs_calc=data.get('tabelas_obs_calc'),
+        modelos_resumos=data.get('modelos_resumos', {}),
+        modelos_sm=data.get('modelos_sm'),
+        formatted_top_transformation_info=data.get('formatted_top_transformation_info', []),
+        graf_model=data.get('graf_model', ''),
+    )
+
+    return model
+
+
+def load_model_by_name(name: str, models_dir: Path) -> Optional[ModelData]:
+    """
+    Carrega um modelo pelo nome.
+
+    Args:
+        name: Nome do modelo (nome da pasta)
+        models_dir: Diretório raiz dos modelos
+
+    Returns:
+        ModelData com os dados carregados, ou None se não encontrar
+    """
+    model_path = models_dir / name
+    return load_model(model_path)

models/registry.py

@@ -0,0 +1,116 @@
+"""
+Registro de modelos de avaliação.
+Descobre automaticamente modelos disponíveis na pasta models/files/.
+"""
+from pathlib import Path
+from typing import List, Optional, Dict
+
+from .model_data import ModelData
+from .model_loader import load_model
+
+
+class ModelRegistry:
+    """Registro centralizado de modelos de avaliação."""
+
+    def __init__(self, models_dir: Path):
+        """
+        Inicializa o registro.
+
+        Args:
+            models_dir: Diretório contendo as pastas dos modelos
+        """
+        self.models_dir = models_dir
+        self._cache: Dict[str, ModelData] = {}
+
+    def discover_models(self) -> List[str]:
+        """
+        Descobre todos os modelos disponíveis.
+
+        Returns:
+            Lista de nomes de modelos (nomes das pastas que contêm modelo.dai)
+        """
+        models = []
+
+        if not self.models_dir.exists():
+            return models
+
+        for path in sorted(self.models_dir.iterdir()):
+            if path.is_dir() and not path.name.startswith('_'):
+                dai_path = path / "modelo.dai"
+                if dai_path.exists():
+                    models.append(path.name)
+
+        return models
+
+    def get_model(self, name: str) -> Optional[ModelData]:
+        """
+        Obtém um modelo pelo nome.
+
+        Args:
+            name: Nome do modelo
+
+        Returns:
+            ModelData ou None se não encontrar
+        """
+        if name in self._cache:
+            return self._cache[name]
+
+        model_path = self.models_dir / name
+        model = load_model(model_path)
+
+        if model:
+            self._cache[name] = model
+
+        return model
+
+    def list_models(self) -> List[str]:
+        """
+        Lista todos os modelos disponíveis.
+        Alias para discover_models() para compatibilidade.
+        """
+        return self.discover_models()
+
+    def clear_cache(self) -> None:
+        """Limpa o cache de modelos carregados."""
+        self._cache.clear()
+
+
+# Instância global do registro
+_registry: Optional[ModelRegistry] = None
+
+
+def get_registry(models_dir: Optional[Path] = None) -> ModelRegistry:
+    """
+    Obtém a instância global do registro.
+
+    Args:
+        models_dir: Diretório dos modelos (usa padrão se não fornecido)
+
+    Returns:
+        Instância do ModelRegistry
+    """
+    global _registry
+
+    if _registry is None:
+        if models_dir is None:
+            # Caminho padrão relativo ao projeto
+            models_dir = Path(__file__).parent / "files"
+        _registry = ModelRegistry(models_dir)
+
+    return _registry
+
+
+def list_available_models() -> List[str]:
+    """
+    Lista todos os modelos disponíveis.
+    Função de conveniência para uso direto.
+    """
+    return get_registry().list_models()
+
+
+def get_model(name: str) -> Optional[ModelData]:
+    """
+    Obtém um modelo pelo nome.
+    Função de conveniência para uso direto.
+    """
+    return get_registry().get_model(name)

requirements.txt

@@ -0,0 +1,10 @@
+gradio
+python-docx
+Pillow
+docxcompose
+pypdf
+joblib
+pandas
+statsmodels
+matplotlib
+scipy

ui/app_builder.py

@@ -0,0 +1,613 @@
+"""
+Construtor da interface Gradio com campos dinâmicos.
+"""
+import gradio as gr
+from datetime import datetime
+from typing import List, Dict, Any
+
+from config.constants import (
+    UNIDADES_DEMANDANTES,
+    TIPOS_REQUERIMENTO,
+    UNIDADES_RESPONSAVEIS,
+    TECNICOS_RESPONSAVEIS,
+    METODOS_AVALIACAO,
+    MAX_MOTIVOS_DESVALORIZANTES,
+    MAX_VALORES_MERCADO,
+    MAX_DOCUMENTACAO_PADRAO,
+    MAX_DOCUMENTACAO_ESPECIFICA,
+)
+from models import list_available_models
+from document import LaudoGenerator
+from utils.formatters import (
+    formatar_valor_monetario,
+    aplicar_mascara_monetaria,
+    formatar_lista_para_documento,
+    formatar_motivos_desvalorizantes,
+    formatar_valores_mercado_para_documento,
+)
+from extractors.pdf_extractor import extrair_dados_pdf
+
+
+# ============================================================================
+# CALLBACKS
+# ============================================================================
+
+def toggle_custom_field(dropdown_value):
+    """Callback para mostrar/esconder campo customizado."""
+    return gr.update(visible=(dropdown_value == "Outros"))
+
+
+def adicionar_campo(count, max_count):
+    """Adiciona um campo dinâmico."""
+    new = min(count + 1, max_count)
+    return [new] + [gr.update(visible=(i < new)) for i in range(max_count)]
+
+
+def remover_campo(count, max_count):
+    """Remove um campo dinâmico."""
+    new = max(count - 1, 1)
+    return [new] + [gr.update(visible=(i < new)) for i in range(max_count)]
+
+
+def processar_upload_pdf(pdf_file):
+    """Processa upload de PDF e extrai dados."""
+    dados = extrair_dados_pdf(pdf_file)
+    if dados:
+        setor = dados.get('setor_imovel', '')
+        quarteirao = dados.get('quarteirao_imovel', '')
+        setor_quarteirao = f"{setor} / {quarteirao}" if setor and quarteirao else setor or quarteirao
+
+        return [
+            dados.get('inscricao_imovel', ''),
+            dados.get('endereco_imovel', ''),
+            dados.get('bairro_imovel', ''),
+            setor_quarteirao,
+            dados.get('lote_imovel', ''),
+            dados.get('finalidade_imovel', ''),
+            dados.get('area_territorial', ''),
+            dados.get('construcoes_imovel', ''),
+            dados.get('valores_venais', ''),
+        ]
+    return [''] * 9
+
+
+def gerar_campos_valores_mercado(ano_ini, ano_fim):
+    """Gera campos de valores de mercado para intervalo de anos."""
+    try:
+        ano_ini, ano_fim = int(ano_ini), int(ano_fim)
+    except:
+        return [gr.update(visible=False), gr.update(value=""), gr.update(value="")] * MAX_VALORES_MERCADO + [gr.update(value="")]
+
+    if ano_fim < ano_ini:
+        ano_ini, ano_fim = ano_fim, ano_ini
+    anos = list(range(ano_ini, ano_fim + 1))
+
+    updates = []
+    for i in range(MAX_VALORES_MERCADO):
+        if i < min(len(anos), MAX_VALORES_MERCADO):
+            updates.extend([gr.update(visible=True), gr.update(value=str(anos[i])), gr.update(value="")])
+        else:
+            updates.extend([gr.update(visible=False), gr.update(value=""), gr.update(value="")])
+
+    referencias_texto = ", ".join([f"Dezembro/{ano-1}" for ano in anos])
+    updates.append(gr.update(value=referencias_texto))
+
+    return updates
+
+
+def limpar_campos_valores_mercado():
+    """Limpa todos os campos de valores de mercado."""
+    return [gr.update(visible=False), gr.update(value=""), gr.update(value="")] * MAX_VALORES_MERCADO + [gr.update(value="")]
+
+
+def criar_lista_valores_mercado(anos: List[str], valores: List[str]) -> List[dict]:
+    """Cria lista estruturada de valores de mercado."""
+    lista = []
+    for ano, valor in zip(anos, valores):
+        ano_str = str(ano).strip() if ano else ''
+        valor_str = str(valor).strip() if valor else ''
+
+        if ano_str and valor_str:
+            try:
+                valor_formatado, valor_extenso = formatar_valor_monetario(valor_str)
+                lista.append({
+                    'ano': ano_str,
+                    'valor': valor_formatado,
+                    'valor_extenso': valor_extenso or ''
+                })
+            except Exception:
+                lista.append({
+                    'ano': ano_str,
+                    'valor': valor_str,
+                    'valor_extenso': ''
+                })
+    return lista
+
+
+def _get_data_atual_formatada():
+    """Retorna a data atual formatada em português."""
+    meses = {
+        "January": "janeiro", "February": "fevereiro", "March": "março",
+        "April": "abril", "May": "maio", "June": "junho",
+        "July": "julho", "August": "agosto", "September": "setembro",
+        "October": "outubro", "November": "novembro", "December": "dezembro"
+    }
+    data = datetime.now().strftime("%d de %B de %Y")
+    for en, pt in meses.items():
+        data = data.replace(en, pt)
+    return data
+
+
+# ============================================================================
+# GERAÇÃO DO DOCUMENTO
+# ============================================================================
+
+def gerar_documento_callback(*args):
+    """Callback principal para gerar o documento."""
+    idx = 0
+
+    # Dados gerais
+    numero_laudo = args[idx]; idx += 1
+    numero_processo = args[idx]; idx += 1
+    data_laudo = args[idx]; idx += 1
+
+    unidade_demandante = args[idx]; idx += 1
+    unidade_demandante_custom = args[idx]; idx += 1
+    dados_requerimento = args[idx]; idx += 1
+    dados_requerimento_custom = args[idx]; idx += 1
+    representante_legal = args[idx]; idx += 1
+    valor_proposto = args[idx]; idx += 1
+    ano_proposto = args[idx]; idx += 1
+
+    # Documentação Padrão (dinâmico)
+    documentacao_padrao = []
+    for _ in range(MAX_DOCUMENTACAO_PADRAO):
+        doc = args[idx]; idx += 1
+        if doc and doc.strip():
+            documentacao_padrao.append(doc.strip())
+
+    # Documentação Específica (dinâmico)
+    documentacao_especifica = []
+    for _ in range(MAX_DOCUMENTACAO_ESPECIFICA):
+        doc = args[idx]; idx += 1
+        if doc and doc.strip():
+            documentacao_especifica.append(doc.strip())
+
+    # Motivos desvalorizantes (dinâmico)
+    motivos = []
+    for _ in range(MAX_MOTIVOS_DESVALORIZANTES):
+        desc = args[idx]; idx += 1
+        aleg = args[idx]; idx += 1
+        conf = args[idx]; idx += 1
+        if desc and desc.strip():
+            motivos.append({
+                'descricao': desc.strip(),
+                'alegado': aleg,
+                'confirmado': conf
+            })
+
+    # Imóvel
+    inscricao_imovel = args[idx]; idx += 1
+    endereco_imovel = args[idx]; idx += 1
+    bairro_imovel = args[idx]; idx += 1
+    setor_quarteirao = args[idx]; idx += 1
+    lote_imovel = args[idx]; idx += 1
+    finalidade_imovel = args[idx]; idx += 1
+    area_territorial = args[idx]; idx += 1
+    construcoes_imovel = args[idx]; idx += 1
+    valores_venais = args[idx]; idx += 1
+
+    # Avaliação
+    unidade_responsavel = args[idx]; idx += 1
+    unidade_responsavel_custom = args[idx]; idx += 1
+    tecnico_responsavel = args[idx]; idx += 1
+    tecnico_responsavel_custom = args[idx]; idx += 1
+    metodo_avaliacao = args[idx]; idx += 1
+    metodo_avaliacao_custom = args[idx]; idx += 1
+    modelo_avaliacao = args[idx]; idx += 1
+
+    # Valores de mercado (dinâmico)
+    valores_anos = []
+    valores_valores = []
+    for _ in range(MAX_VALORES_MERCADO):
+        ano = args[idx]; idx += 1
+        valor = args[idx]; idx += 1
+        if ano and valor:
+            valores_anos.append(str(ano).strip())
+            valores_valores.append(str(valor).strip())
+
+    datas_referencia = args[idx]; idx += 1
+
+    # Registro fotográfico (upload)
+    registro_fotografico_path = args[idx]; idx += 1
+
+    # Preparar dados
+    def get_valor(dropdown, custom):
+        return custom if dropdown == "Outros" and custom else dropdown
+
+    valor_formatado, valor_extenso = formatar_valor_monetario(valor_proposto)
+    valor_proposto_completo = f"{valor_formatado} ({valor_extenso})" if valor_extenso else valor_formatado
+
+    setor_parts = setor_quarteirao.split(" / ") if " / " in setor_quarteirao else [setor_quarteirao, ""]
+    setor, quarteirao = (setor_parts[0], setor_parts[1]) if len(setor_parts) > 1 else (setor_parts[0], "")
+    bairro_completo = f"{bairro_imovel} ({setor} / {quarteirao})" if setor or quarteirao else bairro_imovel
+
+    valores_mercado_lista = criar_lista_valores_mercado(valores_anos, valores_valores)
+    motivos_formatados = formatar_motivos_desvalorizantes(motivos)
+
+    dados = {
+        'numero_laudo': numero_laudo,
+        'numero_processo': numero_processo,
+        'data_laudo': data_laudo,
+        'unidade_demandante': get_valor(unidade_demandante, unidade_demandante_custom),
+        'dados_requerimento': get_valor(dados_requerimento, dados_requerimento_custom),
+        'representante_legal': representante_legal,
+        'valor_proposto': f"{valor_proposto_completo} (referente ao IPTU {ano_proposto})" if valor_proposto_completo else "",
+        'documentacao_padrao': formatar_lista_para_documento(documentacao_padrao),
+        'documentacao_especifica': formatar_lista_para_documento(documentacao_especifica),
+        'endereco_imovel': endereco_imovel,
+        'bairro_imovel': bairro_completo,
+        'lote_imovel': lote_imovel,
+        'inscricao_imovel': inscricao_imovel,
+        'finalidade_imovel': finalidade_imovel,
+        'area_territorial': area_territorial,
+        'construcoes_imovel': construcoes_imovel,
+        'valores_venais': valores_venais,
+        'unidade_responsavel': get_valor(unidade_responsavel, unidade_responsavel_custom),
+        'tecnico_responsavel': get_valor(tecnico_responsavel, tecnico_responsavel_custom),
+        'metodo_avaliacao': get_valor(metodo_avaliacao, metodo_avaliacao_custom),
+        'modelo_avaliacao': modelo_avaliacao,
+        'valores_mercado': formatar_valores_mercado_para_documento(valores_anos, valores_valores),
+        'valores_mercado_lista': valores_mercado_lista,
+        'datas_referencia': datas_referencia,
+        'registro_fotografico_path': registro_fotografico_path,
+    }
+
+    # Gerar documento
+    generator = LaudoGenerator()
+    output_path = generator.gerar(dados, motivos_formatados)
+
+    if output_path:
+        return f"✅ Documento gerado: {output_path.name}\nLocal: {output_path}", str(output_path)
+    else:
+        return "❌ Erro ao gerar documento", None
+
+
+# ============================================================================
+# VALORES DUMMY PARA TESTES
+# ============================================================================
+
+def get_dummy_values() -> Dict[str, Any]:
+    """
+    Retorna valores dummy para preencher os campos da interface.
+    Facilita testes durante o desenvolvimento.
+    Para remover esta funcionalidade, delete esta função e as referências a ela.
+    """
+    return {
+        # Dados gerais
+        "numero_laudo": "LA_001_2025",
+        "numero_processo": "123.456789.25.0",
+        "representante_legal": "João da Silva",
+        "valor_proposto": "500.000,00",
+        "ano_proposto": "2025",
+
+        # Documentação padrão
+        "docs_padrao": [
+            "Requerimento assinado",
+            "Cópia do RG e CPF",
+            "Comprovante de residência",
+        ],
+
+        # Documentação específica
+        "docs_especifica": [
+            "Laudo técnico de engenharia",
+            "Fotos do imóvel",
+        ],
+
+        # Motivos desvalorizantes
+        "motivos": [
+            {"descricao": "Imóvel em área de risco", "alegado": True, "confirmado": False},
+            {"descricao": "Falta de infraestrutura", "alegado": True, "confirmado": True},
+        ],
+
+        # Dados do imóvel
+        "inscricao": "001.002345.0001-0",
+        "endereco": "Rua das Flores, 123",
+        "bairro": "Centro",
+        "setor_quarteirao": "001 / 002",
+        "lote": "0001",
+        "finalidade": "Residencial",
+        "area_territorial": "360,00 m²",
+        "construcoes": "Casa térrea com 120,00 m² de área construída",
+        "valores_venais": "VT: R$ 200.000,00 | VC: R$ 150.000,00 | VTOTAL: R$ 350.000,00",
+
+        # Valores de mercado
+        "anos_mercado": ["2023", "2024", "2025"],
+        "valores_mercado": ["450.000,00", "480.000,00", "500.000,00"],
+        "ref_datas": "Dezembro/2022, Dezembro/2023, Dezembro/2024",
+    }
+
+
+# ============================================================================
+# INTERFACE
+# ============================================================================
+
+def build_interface(fill_dummy: bool = False) -> gr.Blocks:
+    """
+    Constrói a interface Gradio com campos dinâmicos e abas.
+
+    Args:
+        fill_dummy: Se True, preenche campos com valores de teste.
+    """
+    # Obter valores dummy se solicitado
+    dummy = get_dummy_values() if fill_dummy else {}
+
+    # Obter lista de modelos disponíveis
+    modelos_disponiveis = list_available_models()
+    if not modelos_disponiveis:
+        modelos_disponiveis = ["Nenhum modelo encontrado"]
+
+    with gr.Blocks(title="Sistema de Geração de Laudos") as app:
+        gr.Markdown("# Sistema de Geração de Laudos de Avaliação")
+
+        with gr.Tabs():
+            # ================================================================
+            # ABA 1: SOLICITAÇÃO
+            # ================================================================
+            with gr.TabItem("1. Solicitação"):
+                gr.Markdown("### Dados Gerais")
+                with gr.Row():
+                    numero_laudo = gr.Textbox(label="Número do Laudo", placeholder="LA_XXX_2025", value=dummy.get("numero_laudo", ""))
+                    numero_processo = gr.Textbox(label="Processo Administrativo", placeholder="000.000000.00.0", value=dummy.get("numero_processo", ""))
+                    data_laudo = gr.Textbox(label="Data do Laudo", value=_get_data_atual_formatada())
+
+                with gr.Row():
+                    u_demand = gr.Dropdown(UNIDADES_DEMANDANTES, label="Unidade Demandante", value=UNIDADES_DEMANDANTES[0])
+                    u_demand_custom = gr.Textbox(label="Especifique", visible=False)
+                u_demand.change(toggle_custom_field, u_demand, u_demand_custom)
+
+                with gr.Row():
+                    req_tipo = gr.Dropdown(TIPOS_REQUERIMENTO, label="Requerimento", value=TIPOS_REQUERIMENTO[0])
+                    req_custom = gr.Textbox(label="Especifique", visible=False)
+                req_tipo.change(toggle_custom_field, req_tipo, req_custom)
+
+                rep_legal = gr.Textbox(label="Requerente/Representante Legal", value=dummy.get("representante_legal", ""))
+
+                gr.Markdown("### Valor Proposto pelo Contribuinte")
+                with gr.Row():
+                    v_proposto = gr.Textbox(label="Valor Proposto (R$)", placeholder="Digite e saia do campo", value=dummy.get("valor_proposto", ""))
+                    a_proposto = gr.Textbox(label="Ano Ref.", value=dummy.get("ano_proposto", "2025"))
+                v_proposto.blur(aplicar_mascara_monetaria, v_proposto, v_proposto)
+
+            # ================================================================
+            # ABA 2: DOCUMENTAÇÃO
+            # ================================================================
+            with gr.TabItem("2. Documentação"):
+                gr.Markdown("### Documentação Padrão")
+                docs_padrao_inputs = []
+                docs_padrao_rows = []
+                docs_padrao_dummy = dummy.get("docs_padrao", [])
+                n_docs_padrao = len(docs_padrao_dummy) if docs_padrao_dummy else 1
+                for i in range(MAX_DOCUMENTACAO_PADRAO):
+                    with gr.Row(visible=(i < n_docs_padrao)) as row:
+                        val = docs_padrao_dummy[i] if i < len(docs_padrao_dummy) else ""
+                        docs_padrao_inputs.append(gr.Textbox(label=f"Documento {i+1}", show_label=(i == 0), value=val))
+                        docs_padrao_rows.append(row)
+                docs_padrao_count = gr.State(n_docs_padrao)
+                with gr.Row():
+                    btn_add_doc_padrao = gr.Button("➕ Adicionar", size="sm")
+                    btn_rem_doc_padrao = gr.Button("➖ Remover", size="sm")
+                btn_add_doc_padrao.click(
+                    lambda c: adicionar_campo(c, MAX_DOCUMENTACAO_PADRAO),
+                    docs_padrao_count,
+                    [docs_padrao_count] + docs_padrao_rows
+                )
+                btn_rem_doc_padrao.click(
+                    lambda c: remover_campo(c, MAX_DOCUMENTACAO_PADRAO),
+                    docs_padrao_count,
+                    [docs_padrao_count] + docs_padrao_rows
+                )
+
+                gr.Markdown("---")
+                gr.Markdown("### Documentação Específica")
+                docs_esp_inputs = []
+                docs_esp_rows = []
+                docs_esp_dummy = dummy.get("docs_especifica", [])
+                n_docs_esp = len(docs_esp_dummy) if docs_esp_dummy else 1
+                for i in range(MAX_DOCUMENTACAO_ESPECIFICA):
+                    with gr.Row(visible=(i < n_docs_esp)) as row:
+                        val = docs_esp_dummy[i] if i < len(docs_esp_dummy) else ""
+                        docs_esp_inputs.append(gr.Textbox(label=f"Doc Específico {i+1}", show_label=(i == 0), value=val))
+                        docs_esp_rows.append(row)
+                docs_esp_count = gr.State(n_docs_esp)
+                with gr.Row():
+                    btn_add_doc_esp = gr.Button("➕ Adicionar", size="sm")
+                    btn_rem_doc_esp = gr.Button("➖ Remover", size="sm")
+                btn_add_doc_esp.click(
+                    lambda c: adicionar_campo(c, MAX_DOCUMENTACAO_ESPECIFICA),
+                    docs_esp_count,
+                    [docs_esp_count] + docs_esp_rows
+                )
+                btn_rem_doc_esp.click(
+                    lambda c: remover_campo(c, MAX_DOCUMENTACAO_ESPECIFICA),
+                    docs_esp_count,
+                    [docs_esp_count] + docs_esp_rows
+                )
+
+            # ================================================================
+            # ABA 3: MOTIVOS DESVALORIZANTES
+            # ================================================================
+            with gr.TabItem("3. Motivos Desvalorizantes"):
+                gr.Markdown("### Motivos Desvalorizantes Alegados")
+                motivos_rows = []
+                motivos_desc = []
+                motivos_aleg = []
+                motivos_conf = []
+                motivos_dummy = dummy.get("motivos", [])
+                n_motivos = len(motivos_dummy) if motivos_dummy else 1
+                for i in range(MAX_MOTIVOS_DESVALORIZANTES):
+                    mot = motivos_dummy[i] if i < len(motivos_dummy) else {}
+                    with gr.Row(visible=(i < n_motivos)) as row:
+                        d = gr.Textbox(show_label=False, scale=3, placeholder=f"Motivo Desvalorizante {i+1}", value=mot.get("descricao", ""))
+                        a = gr.Checkbox(label="Alegado", value=mot.get("alegado", True))
+                        c = gr.Checkbox(label="Confirmado", value=mot.get("confirmado", False))
+                        motivos_desc.append(d)
+                        motivos_aleg.append(a)
+                        motivos_conf.append(c)
+                        motivos_rows.append(row)
+                motivos_count = gr.State(n_motivos)
+                with gr.Row():
+                    btn_add_motivo = gr.Button("➕ Adicionar Motivo", size="sm")
+                    btn_rem_motivo = gr.Button("➖ Remover Motivo", size="sm")
+                btn_add_motivo.click(
+                    lambda c: adicionar_campo(c, MAX_MOTIVOS_DESVALORIZANTES),
+                    motivos_count,
+                    [motivos_count] + motivos_rows
+                )
+                btn_rem_motivo.click(
+                    lambda c: remover_campo(c, MAX_MOTIVOS_DESVALORIZANTES),
+                    motivos_count,
+                    [motivos_count] + motivos_rows
+                )
+
+            # ================================================================
+            # ABA 4: IMÓVEL OBJETO
+            # ================================================================
+            with gr.TabItem("4. Imóvel Objeto"):
+                gr.Markdown("### Dados do Imóvel")
+                with gr.Row():
+                    pdf_up = gr.File(label="PDF SIAT", type="filepath")
+                    btn_pdf = gr.Button("🔍 Processar PDF", size="sm")
+
+                inscricao = gr.Textbox(label="Inscrição", placeholder="Aguardando processamento do PDF ou preenchimento manual", value=dummy.get("inscricao", ""))
+                with gr.Row():
+                    endereco = gr.Textbox(label="Endereço", value=dummy.get("endereco", ""))
+                    bairro = gr.Textbox(label="Bairro", value=dummy.get("bairro", ""))
+                with gr.Row():
+                    setor_q = gr.Textbox(label="Setor / Quarteirão", value=dummy.get("setor_quarteirao", ""))
+                    lote = gr.Textbox(label="Lote Fiscal", value=dummy.get("lote", ""))
+                with gr.Row():
+                    finalidade = gr.Textbox(label="Finalidade", value=dummy.get("finalidade", ""))
+                    area_ter = gr.Textbox(label="Área Territorial", value=dummy.get("area_territorial", ""))
+                construcoes = gr.Textbox(label="Construções", lines=2, value=dummy.get("construcoes", ""))
+                val_venais = gr.Textbox(label="Valores Venais", lines=2, value=dummy.get("valores_venais", ""))
+
+                imovel_outputs = [inscricao, endereco, bairro, setor_q, lote, finalidade, area_ter, construcoes, val_venais]
+                btn_pdf.click(processar_upload_pdf, pdf_up, imovel_outputs)
+
+            # ================================================================
+            # ABA 5: AVALIAÇÃO
+            # ================================================================
+            with gr.TabItem("5. Avaliação"):
+                gr.Markdown("### Dados do Avaliador")
+                with gr.Row():
+                    u_resp = gr.Dropdown(UNIDADES_RESPONSAVEIS, label="Unidade Responsável", value=UNIDADES_RESPONSAVEIS[0])
+                    u_resp_custom = gr.Textbox(label="Especifique", visible=False)
+                u_resp.change(toggle_custom_field, u_resp, u_resp_custom)
+
+                with gr.Row():
+                    tec_resp = gr.Dropdown(TECNICOS_RESPONSAVEIS, label="Técnico Responsável", value=TECNICOS_RESPONSAVEIS[0])
+                    tec_resp_custom = gr.Textbox(label="Especifique", visible=False)
+                tec_resp.change(toggle_custom_field, tec_resp, tec_resp_custom)
+
+                gr.Markdown("### Metodologia")
+                with gr.Row():
+                    metodo = gr.Dropdown(METODOS_AVALIACAO, label="Método de Avaliação", value=METODOS_AVALIACAO[0])
+                    metodo_custom = gr.Textbox(label="Especifique", visible=False)
+                metodo.change(toggle_custom_field, metodo, metodo_custom)
+
+                modelo = gr.Dropdown(modelos_disponiveis, label="Modelo de Avaliação (.dai)", value=modelos_disponiveis[0] if modelos_disponiveis else None)
+
+            # ================================================================
+            # ABA 6: VALORES DE MERCADO
+            # ================================================================
+            with gr.TabItem("6. Valores de Mercado"):
+                gr.Markdown("### Definir Intervalo de Anos")
+                with gr.Row():
+                    ano_ini = gr.Number(value=2020, label="Ano Inicial")
+                    ano_fim = gr.Number(value=2025, label="Ano Final")
+                    btn_gerar_anos = gr.Button("📅 Gerar Campos", size="sm")
+                    btn_limpar_anos = gr.Button("🗑️ Limpar", size="sm")
+
+                gr.Markdown("### Valores por Ano")
+                vm_rows = []
+                vm_anos = []
+                vm_vals = []
+                vm_outputs_flat = []
+                anos_dummy = dummy.get("anos_mercado", [])
+                valores_dummy = dummy.get("valores_mercado", [])
+                n_vm = len(anos_dummy) if anos_dummy else 0
+
+                for i in range(MAX_VALORES_MERCADO):
+                    ano_val = anos_dummy[i] if i < len(anos_dummy) else ""
+                    valor_val = valores_dummy[i] if i < len(valores_dummy) else ""
+                    with gr.Row(visible=(i < n_vm)) as row:
+                        a = gr.Textbox(label="Ano", interactive=False, scale=1, value=ano_val)
+                        v = gr.Textbox(label="Valor (R$)", scale=2, placeholder="R$ 0,00", value=valor_val)
+                        v.blur(aplicar_mascara_monetaria, v, v)
+                        vm_anos.append(a)
+                        vm_vals.append(v)
+                        vm_rows.append(row)
+                        vm_outputs_flat.extend([row, a, v])
+
+                ref_datas = gr.Textbox(label="Datas de Referência (datas-base)", value=dummy.get("ref_datas", ""))
+
+                btn_gerar_anos.click(gerar_campos_valores_mercado, [ano_ini, ano_fim], vm_outputs_flat + [ref_datas])
+                btn_limpar_anos.click(limpar_campos_valores_mercado, [], vm_outputs_flat + [ref_datas])
+
+            # ================================================================
+            # ABA 7: REGISTRO FOTOGRÁFICO
+            # ================================================================
+            with gr.TabItem("7. Registro Fotográfico"):
+                gr.Markdown("### Upload do Registro Fotográfico")
+                gr.Markdown(
+                    "Faça upload do documento DOCX com o registro fotográfico do imóvel. "
+                    "O documento será anexado ao final do laudo gerado."
+                )
+
+                registro_foto_upload = gr.File(
+                    label="Documento de Registro Fotográfico (.docx)",
+                    type="filepath",
+                    file_types=[".docx"]
+                )
+
+                gr.Markdown("---")
+                gr.Markdown(
+                    "**Dica:** Você pode gerar o registro fotográfico utilizando a ferramenta: "
+                    "[Gerador de Fotos](https://huggingface.co/spaces/gui-sparim/gerador_fotos)"
+                )
+
+            # ================================================================
+            # ABA 8: GERAR DOCUMENTO
+            # ================================================================
+            with gr.TabItem("8. Gerar Documento"):
+                gr.Markdown("### Gerar Laudo de Avaliação")
+                gr.Markdown("Verifique se todos os dados foram preenchidos nas abas anteriores.")
+
+                btn_gerar = gr.Button("📄 Gerar Documento", variant="primary", size="lg")
+
+                gr.Markdown("---")
+                res_md = gr.Markdown()
+                res_file = gr.File(label="Download do Documento")
+
+        # Coleta de todos os inputs
+        all_inputs = [
+            numero_laudo, numero_processo, data_laudo,
+            u_demand, u_demand_custom,
+            req_tipo, req_custom,
+            rep_legal, v_proposto, a_proposto
+        ]
+        all_inputs.extend(docs_padrao_inputs)
+        all_inputs.extend(docs_esp_inputs)
+        for d, a, c in zip(motivos_desc, motivos_aleg, motivos_conf):
+            all_inputs.extend([d, a, c])
+        all_inputs.extend(imovel_outputs)
+        all_inputs.extend([u_resp, u_resp_custom, tec_resp, tec_resp_custom, metodo, metodo_custom, modelo])
+        for a, v in zip(vm_anos, vm_vals):
+            all_inputs.extend([a, v])
+        all_inputs.append(ref_datas)
+        all_inputs.append(registro_foto_upload)
+
+        btn_gerar.click(gerar_documento_callback, all_inputs, [res_md, res_file])
+
+    return app

utils/__init__.py

@@ -0,0 +1,12 @@
+"""
+Utilitários do sistema.
+"""
+from .docx_loader import ler_texto_docx, mesclar_documento_fotos
+from .formatters import formatar_valor_monetario, formatar_motivos_desvalorizantes
+
+__all__ = [
+    'ler_texto_docx',
+    'mesclar_documento_fotos',
+    'formatar_valor_monetario',
+    'formatar_motivos_desvalorizantes',
+]

utils/docx_loader.py

@@ -0,0 +1,64 @@
+"""
+Utilitários para leitura e manipulação de arquivos DOCX.
+"""
+from docx import Document
+from pathlib import Path
+from typing import Optional, Union
+
+
+def ler_texto_docx(caminho_arquivo: Union[str, Path]) -> str:
+    """
+    Lê conteúdo de texto de um arquivo DOCX.
+
+    Args:
+        caminho_arquivo: Caminho para o arquivo DOCX
+
+    Returns:
+        Texto do documento com parágrafos separados por quebras duplas de linha
+    """
+    caminho = Path(caminho_arquivo)
+    if not caminho.exists():
+        return ""
+
+    try:
+        doc = Document(str(caminho))
+        return "\n\n".join(p.text for p in doc.paragraphs if p.text.strip())
+    except Exception as e:
+        print(f"Erro ao ler arquivo DOCX {caminho}: {e}")
+        return ""
+
+
+def mesclar_documento_fotos(
+    doc_principal: Document,
+    caminho_fotos: Optional[Union[str, Path]]
+) -> Document:
+    """
+    Mescla documento de registro fotográfico ao documento principal.
+
+    Args:
+        doc_principal: Objeto Document principal do laudo
+        caminho_fotos: Caminho para o arquivo DOCX de registro fotográfico
+
+    Returns:
+        Documento mesclado (ou original se não houver documento de fotos)
+    """
+    if not caminho_fotos:
+        return doc_principal
+
+    caminho = Path(caminho_fotos)
+    if not caminho.exists():
+        return doc_principal
+
+    try:
+        from docxcompose.composer import Composer
+
+        doc_fotos = Document(str(caminho))
+        composer = Composer(doc_principal)
+        composer.append(doc_fotos)
+        return composer.doc
+    except ImportError:
+        print("docxcompose não instalado. Execute: pip install docxcompose")
+        return doc_principal
+    except Exception as e:
+        print(f"Erro ao mesclar documento de fotos: {e}")
+        return doc_principal

utils/estatisticas_utils.py

@@ -0,0 +1,114 @@
+"""
+Utilitários para processamento de estatísticas do modelo.
+Funções compartilhadas entre interface_estatisticas e geração de documentos.
+"""
+from typing import Dict, Any, Optional
+import numpy as np
+
+
+def reorganizar_modelos_resumos(resumo_original: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Reorganiza a estrutura do dicionário modelos_resumos para uma
+    estrutura mais organizada com estatísticas gerais e testes separados.
+
+    Parâmetros
+    ----------
+    resumo_original : dict
+        Dicionário original com as chaves do modelo.
+
+    Retorna
+    -------
+    dict
+        Dicionário reorganizado com a nova estrutura.
+    """
+    if not resumo_original:
+        return {}
+
+    return {
+        "estatisticas_gerais": {
+            "n": {
+                "nome": "Número de observações",
+                "valor": resumo_original.get("n")
+            },
+            "k": {
+                "nome": "Número de variáveis independentes",
+                "valor": resumo_original.get("k")
+            },
+            "desvio_padrao_residuos": {
+                "nome": "Desvio padrão dos resíduos",
+                "valor": resumo_original.get("desvio_padrao_residuos")
+            },
+            "mse": {
+                "nome": "MSE",
+                "valor": resumo_original.get("mse")
+            },
+            "r2": {
+                "nome": "R²",
+                "valor": resumo_original.get("r2")
+            },
+            "r2_ajustado": {
+                "nome": "R² ajustado",
+                "valor": resumo_original.get("r2_ajustado")
+            },
+            "r_pearson": {
+                "nome": "Correlação Pearson",
+                "valor": resumo_original.get("r_pearson")
+            }
+        },
+        "teste_f": {
+            "nome": "Teste F",
+            "estatistica": resumo_original.get("Fc"),
+            "pvalor": resumo_original.get("p_valor_F"),
+            "interpretacao": resumo_original.get("Interpretacao_F")
+        },
+        "teste_ks": {
+            "nome": "Teste de Normalidade (Kolmogorov-Smirnov)",
+            "estatistica": resumo_original.get("ks_stat"),
+            "pvalor": resumo_original.get("ks_p"),
+            "interpretacao": resumo_original.get("Interpretacao_KS")
+        },
+        "perc_resid": {
+            "nome": "Teste de Normalidade (Comparação com a Curva Normal)",
+            "valor": resumo_original.get("perc_resid"),
+            "interpretacao": [
+                "Ideal 68% → aceitável entre 64% e 75%",
+                "Ideal 90% → aceitável entre 88% e 95%",
+                "Ideal 95% → aceitável entre 95% e 100%"
+            ]
+        },
+        "teste_dw": {
+            "nome": "Teste de Autocorrelação (Durbin-Watson)",
+            "estatistica": resumo_original.get("dw"),
+            "interpretacao": resumo_original.get("Interpretacao_DW")
+        },
+        "teste_bp": {
+            "nome": "Teste de Homocedasticidade (Breusch-Pagan)",
+            "estatistica": resumo_original.get("bp_lm"),
+            "pvalor": resumo_original.get("bp_p"),
+            "interpretacao": resumo_original.get("Interpretacao_BP")
+        },
+        "equacao": resumo_original.get("equacao")
+    }
+
+
+def formatar_numero(valor: Any, casas_decimais: int = 4) -> str:
+    """
+    Formata número com casas decimais específicas.
+
+    Parâmetros
+    ----------
+    valor : Any
+        Valor a ser formatado.
+    casas_decimais : int
+        Número de casas decimais (default: 4).
+
+    Retorna
+    -------
+    str
+        Valor formatado como string.
+    """
+    if valor is None:
+        return "N/A"
+    if isinstance(valor, (int, float, np.floating)):
+        return f"{valor:.{casas_decimais}f}"
+    return str(valor)

utils/formatters.py

@@ -0,0 +1,240 @@
+"""
+Formatadores de texto e valores monetários.
+"""
+import re
+from typing import Tuple, List, Dict
+
+
+def numero_para_extenso(valor: float) -> str:
+    """Converte um valor numérico para sua representação por extenso em português."""
+    if valor == 0:
+        return "zero reais"
+
+    unidades = ['', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove']
+    especiais = ['dez', 'onze', 'doze', 'treze', 'quatorze', 'quinze', 'dezesseis', 'dezessete', 'dezoito', 'dezenove']
+    dezenas = ['', '', 'vinte', 'trinta', 'quarenta', 'cinquenta', 'sessenta', 'setenta', 'oitenta', 'noventa']
+    centenas = ['', 'cento', 'duzentos', 'trezentos', 'quatrocentos', 'quinhentos', 'seiscentos', 'setecentos', 'oitocentos', 'novecentos']
+
+    def converter_grupo(n):
+        if n == 0:
+            return ''
+        if n == 100:
+            return 'cem'
+
+        resultado = ''
+
+        if n >= 100:
+            resultado += centenas[n // 100]
+            n %= 100
+            if n > 0:
+                resultado += ' e '
+
+        if n >= 20:
+            resultado += dezenas[n // 10]
+            n %= 10
+            if n > 0:
+                resultado += ' e ' + unidades[n]
+        elif n >= 10:
+            resultado += especiais[n - 10]
+        elif n > 0:
+            resultado += unidades[n]
+
+        return resultado
+
+    parte_inteira = int(valor)
+    centavos = round((valor - parte_inteira) * 100)
+
+    resultado = ''
+
+    if parte_inteira >= 1000000:
+        milhoes = parte_inteira // 1000000
+        if milhoes == 1:
+            resultado += 'um milhão'
+        else:
+            resultado += converter_grupo(milhoes) + ' milhões'
+        parte_inteira %= 1000000
+        if parte_inteira > 0:
+            resultado += ' e '
+
+    if parte_inteira >= 1000:
+        milhares = parte_inteira // 1000
+        if milhares == 1:
+            resultado += 'mil'
+        else:
+            resultado += converter_grupo(milhares) + ' mil'
+        parte_inteira %= 1000
+        if parte_inteira > 0:
+            resultado += ' e '
+
+    if parte_inteira > 0:
+        resultado += converter_grupo(parte_inteira)
+
+    if resultado:
+        if int(valor) == 1:
+            resultado += ' real'
+        else:
+            resultado += ' reais'
+
+    if centavos > 0:
+        if resultado:
+            resultado += ' e '
+        resultado += converter_grupo(centavos)
+        if centavos == 1:
+            resultado += ' centavo'
+        else:
+            resultado += ' centavos'
+
+    return resultado
+
+
+def parse_valor_monetario(valor_str: str) -> float:
+    """Converte string de valor monetário para float."""
+    if not valor_str:
+        return 0.0
+    valor_limpo = re.sub(r'[^\d,.]', '', valor_str)
+    valor_limpo = valor_limpo.replace('.', '').replace(',', '.')
+    try:
+        return float(valor_limpo)
+    except ValueError:
+        return 0.0
+
+
+def formatar_valor_monetario(valor_str: str) -> Tuple[str, str]:
+    """Formata valor monetário e retorna tupla (valor_formatado, extenso)."""
+    valor_float = parse_valor_monetario(valor_str)
+
+    if valor_float == 0:
+        return valor_str, ""
+
+    valor_formatado = f"R$ {valor_float:,.2f}".replace(',', 'X').replace('.', ',').replace('X', '.')
+    extenso = numero_para_extenso(valor_float)
+
+    return valor_formatado, extenso
+
+
+def aplicar_mascara_monetaria(valor: str) -> str:
+    """Aplica máscara monetária brasileira a um valor."""
+    if not valor:
+        return ""
+
+    valor = valor.strip()
+
+    if re.match(r'^R\$\s*[\d\.]+,\d{2}$', valor):
+        return valor
+
+    if re.search(r'[a-zA-ZáéíóúãõâêîôûàèìòùçÁÉÍÓÚÃÕÂÊÎÔÛÀÈÌÒÙÇ]', valor):
+        return valor
+
+    valor_limpo = re.sub(r'R\$\s*', '', valor)
+
+    if ',' in valor_limpo and '.' in valor_limpo:
+        valor_limpo = valor_limpo.replace('.', '').replace(',', '.')
+    elif ',' in valor_limpo:
+        valor_limpo = valor_limpo.replace(',', '.')
+
+    try:
+        valor_float = float(valor_limpo)
+    except ValueError:
+        return valor
+
+    return f"R$ {valor_float:,.2f}".replace(',', 'X').replace('.', ',').replace('X', '.')
+
+
+def formatar_lista_para_documento(items: List[str]) -> str:
+    """Formata lista de itens para inclusão no documento."""
+    items_limpos = [i.strip() for i in items if i and i.strip()]
+    if not items_limpos:
+        return ""
+    return "\n".join([f"- {i};" for i in items_limpos])
+
+
+def formatar_valores_mercado_para_documento(anos: List[str], valores: List[str]) -> str:
+    """Formata lista de valores de mercado por ano para inclusão no documento."""
+    linhas = []
+    for ano, valor in zip(anos, valores):
+        if ano and valor:
+            try:
+                ano_str = str(int(float(ano))) if ano else ""
+            except (ValueError, TypeError):
+                ano_str = str(ano) if ano else ""
+
+            valor_float = parse_valor_monetario(valor)
+            if valor_float > 0:
+                extenso = numero_para_extenso(valor_float)
+                linhas.append(f"{ano_str} - {valor} ({extenso})")
+            else:
+                linhas.append(f"{ano_str} - {valor}")
+
+    if not linhas:
+        return ""
+    return "\n".join(linhas)
+
+
+def formatar_motivos_desvalorizantes(motivos: List[Dict]) -> Dict:
+    """Formata a lista unificada de motivos desvalorizantes."""
+    if not motivos:
+        return {
+            'alegados': [],
+            'confirmados': [],
+            'todos': [],
+            'alegados_texto': '',
+            'confirmados_texto': '',
+            'secoes': []
+        }
+
+    alegados = []
+    confirmados = []
+    todos = []
+    secoes = []
+
+    for i, motivo in enumerate(motivos, 1):
+        descricao = motivo.get('descricao', '').strip()
+        foi_alegado = motivo.get('alegado', False)
+        foi_confirmado = motivo.get('confirmado', False)
+
+        if not descricao:
+            continue
+
+        item = {
+            'numero': i,
+            'descricao': descricao,
+            'alegado': foi_alegado,
+            'confirmado': foi_confirmado
+        }
+
+        todos.append(item)
+
+        if foi_alegado:
+            alegados.append(descricao)
+
+        if foi_confirmado:
+            confirmados.append(descricao)
+
+        status = []
+        if foi_alegado:
+            status.append("alegado pelo contribuinte")
+        else:
+            status.append("não alegado pelo contribuinte")
+        if foi_confirmado:
+            status.append("e confirmado na análise")
+        else:
+            status.append("e não confirmado na análise")
+
+        secoes.append({
+            'numero': i,
+            'titulo': descricao,
+            'status': ", ".join(status) if status else "identificado na vistoria",
+            'confirmado': foi_confirmado
+        })
+
+    alegados_texto = formatar_lista_para_documento(alegados)
+    confirmados_texto = formatar_lista_para_documento(confirmados)
+
+    return {
+        'alegados': alegados,
+        'confirmados': confirmados,
+        'todos': todos,
+        'alegados_texto': alegados_texto,
+        'confirmados_texto': confirmados_texto,
+        'secoes': secoes
+    }