Building Speed LLM

.gitattributes

@@ -33,3 +33,115 @@ 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
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environment
+venv/
+.env/
+.venv/
+env/
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+coverage.xml
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environments
+.env
+.venv
+env/
+
+# IDE specific files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Build artifacts
+dist/
+*.egg-info/
+*.egg
+*.manifest
+*.spec
+
+# Ignore only PyInstaller/setuptools build output inside build/, not our scripts
+build/lib/
+build/bdist*/
+build/temp*/
+
+# CLI binaries are tracked so Render can serve them for download
+!app/cli/dist/
+!app/cli/dist/agents-linux
+!app/cli/dist/agents-windows.exe
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# pyenv
+.python-version
+
+# mypy
+.mypy_cache/
+dmypy.json
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# macOS
+.DS_Store
+
+# Windows
+Thumbs.db
+
+# Database files
+*.db
+*.sqlite
+
+# Log files
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyInstaller
+*.spec
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Poetry
+poetry.lock
+
+# PDM
+__pypackages__/
+.pdm.toml
+
+# pytype
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+# Generated at build time
+app/cli/_build_config.py

pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.backends.legacy:build"
+
+[project]
+name = "llm-sped-fiscal"
+version = "0.1.0"
+description = "Sistema LLM para gestão de obrigações fiscais brasileiras (SPED)"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+dependencies = [
+    "torch>=2.3.0",
+    "numpy>=1.26.0",
+    "pydantic>=2.7.0",
+    "httpx>=0.27.0",
+    "aiofiles>=23.2.1",
+    "python-dateutil>=2.9.0",
+    "cryptography>=42.0.0",
+    "lxml>=5.2.0",
+    "python-dotenv>=1.0.0",
+    "requests>=2.31.0",
+    "zeep>=4.2.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.2.0",
+    "pytest-asyncio>=0.23.0",
+    "ruff>=0.4.0",
+    "mypy>=1.10.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.mypy]
+python_version = "3.12"
+strict = true

requirements.txt

@@ -0,0 +1,18 @@
+torch>=2.3.0
+numpy>=1.26.0
+pydantic>=2.7.0
+httpx>=0.27.0
+aiofiles>=23.2.1
+rich>=13.7.0
+typer>=0.12.0
+python-dateutil>=2.9.0
+cryptography>=42.0.0
+lxml>=5.2.0
+python-dotenv>=1.0.0
+sentencepiece>=0.2.0
+requests>=2.31.0
+zeep>=4.2.1
+# testes
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
+pytest-cov>=5.0.0

src/__init__.py

@@ -0,0 +1,10 @@
+"""
+LLM Fiscal Brasileiro — Sistema de Obrigações SPED com PyTorch.
+
+Ponto de entrada:
+    from src import PipelineFiscal
+    pipeline = PipelineFiscal()
+"""
+from src.models.fiscal_llm import PipelineFiscal, TransformerFiscal, TokenizadorFiscal
+
+__all__ = ["PipelineFiscal", "TransformerFiscal", "TokenizadorFiscal"]

src/calculators/__init__.py

@@ -0,0 +1,29 @@
+"""Calculadoras de tributos brasileiros."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal, ROUND_HALF_UP
+
+
+def arred(valor: Decimal, casas: int = 2) -> Decimal:
+    quantizador = Decimal(10) ** -casas
+    return valor.quantize(quantizador, rounding=ROUND_HALF_UP)
+
+
+@dataclass
+class ResultadoCalculo:
+    base_calculo: Decimal
+    aliquota: Decimal
+    valor_tributo: Decimal
+    deducoes: Decimal = Decimal("0")
+    creditos: Decimal = Decimal("0")
+    valor_a_recolher: Decimal = Decimal("0")
+    detalhes: dict = None
+
+    def __post_init__(self):
+        if self.detalhes is None:
+            self.detalhes = {}
+        if self.valor_a_recolher == Decimal("0"):
+            self.valor_a_recolher = max(
+                Decimal("0"), self.valor_tributo - self.creditos - self.deducoes
+            )

src/calculators/icms.py

@@ -0,0 +1,137 @@
+"""Calculadora de ICMS com suporte a ST, DIFAL e FCP."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Optional
+
+from src.calculators import ResultadoCalculo, arred
+from src.fiscal.constants import ALIQ_ICMS_INTERNA, aliq_icms_interestadual
+
+
+@dataclass
+class ParametrosICMS:
+    valor_mercadoria: Decimal
+    aliquota: Decimal
+    cst: str = "000"
+    uf_origem: str = "SP"
+    uf_destino: str = "SP"
+    reducao_base: Decimal = Decimal("0")
+    frete: Decimal = Decimal("0")
+    seguro: Decimal = Decimal("0")
+    outras_despesas: Decimal = Decimal("0")
+    desconto: Decimal = Decimal("0")
+    # Substituição Tributária
+    aliq_st: Optional[Decimal] = None
+    mva: Optional[Decimal] = None
+    base_st_retido: Decimal = Decimal("0")
+    # FCP (Fundo de Combate à Pobreza)
+    aliq_fcp: Decimal = Decimal("0")
+    aliq_fcp_st: Decimal = Decimal("0")
+    # DIFAL (Diferencial de Alíquota - EMENDA 87)
+    calcular_difal: bool = False
+    consumidor_final: bool = False
+
+
+@dataclass
+class ResultadoICMS:
+    base_calculo: Decimal = Decimal("0")
+    aliquota: Decimal = Decimal("0")
+    valor_icms: Decimal = Decimal("0")
+    # ST
+    base_st: Decimal = Decimal("0")
+    aliq_st: Decimal = Decimal("0")
+    valor_st: Decimal = Decimal("0")
+    # FCP
+    base_fcp: Decimal = Decimal("0")
+    valor_fcp: Decimal = Decimal("0")
+    valor_fcp_st: Decimal = Decimal("0")
+    # DIFAL
+    valor_difal_origem: Decimal = Decimal("0")
+    valor_difal_destino: Decimal = Decimal("0")
+    # Total
+    valor_total_icms: Decimal = Decimal("0")
+
+
+def calcular_icms(p: ParametrosICMS) -> ResultadoICMS:
+    r = ResultadoICMS()
+
+    if p.cst in {"040", "041", "050", "051", "060"}:
+        return r
+
+    base_bruta = (
+        p.valor_mercadoria + p.frete + p.seguro + p.outras_despesas - p.desconto
+    )
+
+    if p.cst in {"020", "070"}:
+        r.base_calculo = arred(base_bruta * (1 - p.reducao_base / 100))
+    else:
+        r.base_calculo = arred(base_bruta)
+
+    r.aliquota = p.aliquota
+    r.valor_icms = arred(r.base_calculo * p.aliquota / 100)
+
+    # FCP
+    if p.aliq_fcp > 0:
+        r.base_fcp = r.base_calculo
+        r.valor_fcp = arred(r.base_fcp * p.aliq_fcp / 100)
+
+    # Substituição Tributária
+    if p.cst in {"010", "030", "070"} and p.aliq_st is not None and p.mva is not None:
+        aliq_interna_dest = ALIQ_ICMS_INTERNA.get(p.uf_destino, Decimal("18"))
+        r.base_st = arred(r.base_calculo * (1 + p.mva / 100))
+        r.aliq_st = aliq_interna_dest
+        icms_proprio_dest = arred(r.base_st * aliq_interna_dest / 100)
+        r.valor_st = max(Decimal("0"), arred(icms_proprio_dest - r.valor_icms))
+        if p.aliq_fcp_st > 0:
+            r.valor_fcp_st = arred(r.base_st * p.aliq_fcp_st / 100)
+
+    # DIFAL (EC 87/2015) para operações interestaduais para consumidor final
+    if p.calcular_difal and p.consumidor_final and p.uf_origem != p.uf_destino:
+        aliq_interestadual = aliq_icms_interestadual(p.uf_origem, p.uf_destino)
+        aliq_interna_dest = ALIQ_ICMS_INTERNA.get(p.uf_destino, Decimal("18"))
+        difal = arred(r.base_calculo * (aliq_interna_dest - aliq_interestadual) / 100)
+        # Partilha DIFAL: 2019+ => 100% destino
+        r.valor_difal_destino = arred(difal * Decimal("0.60"))
+        r.valor_difal_origem = arred(difal * Decimal("0.40"))
+
+    r.valor_total_icms = arred(
+        r.valor_icms + r.valor_st + r.valor_fcp + r.valor_fcp_st
+        + r.valor_difal_destino + r.valor_difal_origem
+    )
+    return r
+
+
+def calcular_icms_credito_entrada(
+    valor_nf: Decimal,
+    aliquota: Decimal,
+    percentual_aproveitamento: Decimal = Decimal("100"),
+) -> Decimal:
+    credito_bruto = arred(valor_nf * aliquota / 100)
+    return arred(credito_bruto * percentual_aproveitamento / 100)
+
+
+def calcular_icms_apuracao(
+    debitos: list[Decimal],
+    creditos: list[Decimal],
+    saldo_anterior: Decimal = Decimal("0"),
+) -> ResultadoCalculo:
+    total_debitos = arred(sum(debitos))
+    total_creditos = arred(sum(creditos) + saldo_anterior)
+    saldo = total_creditos - total_debitos
+    valor_a_recolher = max(Decimal("0"), arred(total_debitos - total_creditos))
+    saldo_credor = max(Decimal("0"), arred(total_creditos - total_debitos))
+    return ResultadoCalculo(
+        base_calculo=total_debitos,
+        aliquota=Decimal("0"),
+        valor_tributo=total_debitos,
+        deducoes=Decimal("0"),
+        creditos=total_creditos,
+        valor_a_recolher=valor_a_recolher,
+        detalhes={
+            "total_debitos": total_debitos,
+            "total_creditos": total_creditos,
+            "saldo_devedor": valor_a_recolher,
+            "saldo_credor": saldo_credor,
+        },
+    )

src/calculators/ipi.py

@@ -0,0 +1,144 @@
+"""Calculadora de IPI (Imposto sobre Produtos Industrializados)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Optional
+
+from src.calculators import ResultadoCalculo, arred
+
+
+@dataclass
+class ParametrosIPI:
+    valor_produtos: Decimal
+    aliquota: Decimal
+    cst: str = "50"
+    frete: Decimal = Decimal("0")
+    seguro: Decimal = Decimal("0")
+    outras_despesas: Decimal = Decimal("0")
+    desconto: Decimal = Decimal("0")
+    # Para operações por unidade (pauta)
+    quantidade: Decimal = Decimal("0")
+    valor_pauta_unidade: Optional[Decimal] = None
+
+
+def calcular_ipi(p: ParametrosIPI) -> ResultadoCalculo:
+    # CSTs isentos/não tributados
+    if p.cst in {"51", "52", "53", "54", "55", "02", "03", "04", "05"}:
+        return ResultadoCalculo(
+            base_calculo=Decimal("0"),
+            aliquota=p.aliquota,
+            valor_tributo=Decimal("0"),
+            valor_a_recolher=Decimal("0"),
+        )
+
+    if p.cst == "03" and p.valor_pauta_unidade and p.quantidade:
+        # Tributação por pauta
+        base = arred(p.quantidade * p.valor_pauta_unidade)
+    else:
+        base = arred(
+            p.valor_produtos + p.frete + p.seguro + p.outras_despesas - p.desconto
+        )
+
+    valor = arred(base * p.aliquota / 100)
+
+    return ResultadoCalculo(
+        base_calculo=base,
+        aliquota=p.aliquota,
+        valor_tributo=valor,
+        valor_a_recolher=valor,
+        detalhes={"cst": p.cst},
+    )
+
+
+def calcular_ipi_apuracao(
+    debitos: list[Decimal],
+    creditos: list[Decimal],
+    saldo_anterior: Decimal = Decimal("0"),
+) -> ResultadoCalculo:
+    total_debitos = arred(sum(debitos))
+    total_creditos = arred(sum(creditos) + saldo_anterior)
+    valor_a_recolher = max(Decimal("0"), arred(total_debitos - total_creditos))
+    saldo_credor = max(Decimal("0"), arred(total_creditos - total_debitos))
+    return ResultadoCalculo(
+        base_calculo=total_debitos,
+        aliquota=Decimal("0"),
+        valor_tributo=total_debitos,
+        creditos=total_creditos,
+        valor_a_recolher=valor_a_recolher,
+        detalhes={
+            "total_debitos": total_debitos,
+            "total_creditos": total_creditos,
+            "saldo_credor": saldo_credor,
+        },
+    )
+
+
+# Alíquotas IPI simplificadas por capítulo NCM (TIPI)
+TIPI_ALIQUOTAS: dict[str, Decimal] = {
+    "01": Decimal("0"),    # Animais vivos
+    "02": Decimal("0"),    # Carnes e miudezas
+    "03": Decimal("0"),    # Peixes e crustáceos
+    "04": Decimal("0"),    # Leite, laticínios, ovos
+    "05": Decimal("0"),    # Outros produtos de origem animal
+    "06": Decimal("0"),    # Plantas vivas e produtos de floricultura
+    "07": Decimal("0"),    # Produtos hortícolas
+    "08": Decimal("0"),    # Frutas
+    "09": Decimal("0"),    # Café, chá, mate
+    "10": Decimal("0"),    # Cereais
+    "11": Decimal("0"),    # Produtos da indústria de moagem
+    "12": Decimal("0"),    # Sementes e frutos oleaginosos
+    "16": Decimal("0"),    # Preparações de carne, peixe
+    "17": Decimal("5"),    # Açúcares e produtos de confeitaria
+    "18": Decimal("5"),    # Cacau e suas preparações
+    "19": Decimal("5"),    # Preparações à base de cereais
+    "20": Decimal("5"),    # Preparações de produtos hortícolas e frutas
+    "21": Decimal("5"),    # Preparações alimentícias diversas
+    "22": Decimal("15"),   # Bebidas, líquidos alcoólicos e vinagres
+    "24": Decimal("300"),  # Tabaco e seus sucedâneos manufaturados
+    "25": Decimal("5"),    # Sal; enxofre; terras e pedras
+    "27": Decimal("5"),    # Combustíveis minerais, óleos minerais
+    "28": Decimal("5"),    # Produtos químicos inorgânicos
+    "29": Decimal("5"),    # Produtos químicos orgânicos
+    "30": Decimal("0"),    # Produtos farmacêuticos
+    "31": Decimal("0"),    # Adubos ou fertilizantes
+    "33": Decimal("7"),    # Óleos essenciais e resinoides; cosméticos
+    "34": Decimal("5"),    # Sabões, agentes orgânicos de superfície
+    "38": Decimal("5"),    # Produtos diversos das indústrias químicas
+    "39": Decimal("15"),   # Plásticos e suas obras
+    "40": Decimal("15"),   # Borracha e suas obras
+    "41": Decimal("5"),    # Peles, exceto peles com pelo
+    "42": Decimal("15"),   # Obras de couro; artigos de seleiro
+    "44": Decimal("5"),    # Madeira, carvão vegetal e obras de madeira
+    "48": Decimal("10"),   # Papel e cartão
+    "49": Decimal("5"),    # Livros, jornais, gravuras
+    "50": Decimal("10"),   # Seda
+    "51": Decimal("10"),   # Lã, pelos finos ou grosseiros
+    "52": Decimal("10"),   # Algodão
+    "61": Decimal("20"),   # Vestuário e seus acessórios (malha)
+    "62": Decimal("20"),   # Vestuário e seus acessórios (exceto malha)
+    "64": Decimal("20"),   # Calçados, polainas e artefatos semelhantes
+    "69": Decimal("15"),   # Produtos cerâmicos
+    "70": Decimal("15"),   # Vidro e suas obras
+    "72": Decimal("5"),    # Ferro fundido, ferro e aço
+    "73": Decimal("10"),   # Obras de ferro fundido, ferro ou aço
+    "74": Decimal("10"),   # Cobre e suas obras
+    "76": Decimal("10"),   # Alumínio e suas obras
+    "82": Decimal("10"),   # Ferramentas, artefatos de cutelaria
+    "84": Decimal("10"),   # Máquinas e aparelhos mecânicos
+    "85": Decimal("15"),   # Máquinas e aparelhos elétricos
+    "86": Decimal("5"),    # Veículos e material para vias férreas
+    "87": Decimal("25"),   # Veículos automóveis, tratores
+    "88": Decimal("0"),    # Aeronaves e aparelhos espaciais
+    "90": Decimal("15"),   # Instrumentos e aparelhos de óptica
+    "91": Decimal("20"),   # Instrumentos de relojoaria
+    "92": Decimal("25"),   # Instrumentos musicais
+    "94": Decimal("15"),   # Móveis; mobiliário médico-cirúrgico
+    "95": Decimal("25"),   # Brinquedos, jogos, artigos para divertimento
+    "96": Decimal("10"),   # Obras diversas
+}
+
+
+def obter_aliquota_ipi_ncm(ncm: str) -> Decimal:
+    capitulo = ncm[:2]
+    return TIPI_ALIQUOTAS.get(capitulo, Decimal("5"))

src/calculators/irpj_csll.py

@@ -0,0 +1,209 @@
+"""Calculadora de IRPJ e CSLL (Lucro Real e Lucro Presumido)."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Optional
+
+from src.calculators import ResultadoCalculo, arred
+from src.fiscal.constants import (
+    ALIQ_CSLL_FINANCEIRAS,
+    ALIQ_CSLL_PADRAO,
+    ALIQ_IRPJ_ADICIONAL,
+    ALIQ_IRPJ_BASE,
+    LIMITE_ADICIONAL_IRPJ_TRIMESTRAL,
+    PERCENTUAL_PRESUMIDO_CSLL,
+    PERCENTUAL_PRESUMIDO_IRPJ,
+)
+from src.fiscal.entities import RegimeTributario
+
+
+@dataclass
+class ResultadoIRPJ:
+    lucro_real_ajustado: Decimal = Decimal("0")
+    base_calculo: Decimal = Decimal("0")
+    aliquota_base: Decimal = Decimal("15")
+    valor_base: Decimal = Decimal("0")
+    base_adicional: Decimal = Decimal("0")
+    valor_adicional: Decimal = Decimal("0")
+    valor_irpj_total: Decimal = Decimal("0")
+    # Incentivos e deduções
+    incentivos_fiscais: Decimal = Decimal("0")
+    irpj_a_recolher: Decimal = Decimal("0")
+    compensacoes: Decimal = Decimal("0")
+    detalhes: dict = field(default_factory=dict)
+
+
+@dataclass
+class ResultadoCSLL:
+    base_calculo: Decimal = Decimal("0")
+    aliquota: Decimal = Decimal("0")
+    valor_csll: Decimal = Decimal("0")
+    csll_a_recolher: Decimal = Decimal("0")
+    compensacoes: Decimal = Decimal("0")
+    detalhes: dict = field(default_factory=dict)
+
+
+def calcular_irpj_lucro_real(
+    lucro_antes_ir: Decimal,
+    adicoes: Decimal = Decimal("0"),
+    exclusoes: Decimal = Decimal("0"),
+    compensacoes_prejuizo: Decimal = Decimal("0"),
+    incentivos_fiscais: Decimal = Decimal("0"),
+    irpj_estimativas: Decimal = Decimal("0"),
+    periodo: str = "trimestral",
+) -> ResultadoIRPJ:
+    r = ResultadoIRPJ()
+
+    lucro_ajustado = arred(lucro_antes_ir + adicoes - exclusoes)
+    r.lucro_real_ajustado = lucro_ajustado
+
+    # Compensação de prejuízo (limite 30% do lucro ajustado)
+    limite_compensacao = arred(lucro_ajustado * Decimal("0.30"))
+    comp_efetiva = min(compensacoes_prejuizo, limite_compensacao)
+    r.base_calculo = max(Decimal("0"), arred(lucro_ajustado - comp_efetiva))
+
+    r.aliquota_base = ALIQ_IRPJ_BASE
+    r.valor_base = arred(r.base_calculo * ALIQ_IRPJ_BASE / 100)
+
+    limite_adicional = (
+        LIMITE_ADICIONAL_IRPJ_TRIMESTRAL
+        if periodo == "trimestral"
+        else arred(LIMITE_ADICIONAL_IRPJ_TRIMESTRAL * Decimal("4"))
+    )
+    r.base_adicional = max(Decimal("0"), arred(r.base_calculo - limite_adicional))
+    r.valor_adicional = arred(r.base_adicional * ALIQ_IRPJ_ADICIONAL / 100)
+
+    r.valor_irpj_total = arred(r.valor_base + r.valor_adicional)
+    r.incentivos_fiscais = arred(incentivos_fiscais)
+
+    r.irpj_a_recolher = max(
+        Decimal("0"),
+        arred(r.valor_irpj_total - r.incentivos_fiscais - irpj_estimativas),
+    )
+
+    r.detalhes = {
+        "adicoes": adicoes,
+        "exclusoes": exclusoes,
+        "compensacao_prejuizo_utilizada": comp_efetiva,
+        "compensacoes_disponiveis": compensacoes_prejuizo,
+        "limite_compensacao_30pct": limite_compensacao,
+        "estimativas_pagas": irpj_estimativas,
+    }
+    return r
+
+
+def calcular_irpj_lucro_presumido(
+    receita_bruta: Decimal,
+    outras_receitas: Decimal = Decimal("0"),
+    atividade: str = "venda_mercadorias",
+    incentivos_fiscais: Decimal = Decimal("0"),
+    irpj_anteriores: Decimal = Decimal("0"),
+) -> ResultadoIRPJ:
+    r = ResultadoIRPJ()
+
+    percentual = PERCENTUAL_PRESUMIDO_IRPJ.get(atividade, Decimal("8.0"))
+    lucro_presumido = arred(receita_bruta * percentual / 100)
+    r.lucro_real_ajustado = arred(lucro_presumido + outras_receitas)
+    r.base_calculo = r.lucro_real_ajustado
+
+    r.aliquota_base = ALIQ_IRPJ_BASE
+    r.valor_base = arred(r.base_calculo * ALIQ_IRPJ_BASE / 100)
+
+    r.base_adicional = max(Decimal("0"), arred(r.base_calculo - LIMITE_ADICIONAL_IRPJ_TRIMESTRAL))
+    r.valor_adicional = arred(r.base_adicional * ALIQ_IRPJ_ADICIONAL / 100)
+
+    r.valor_irpj_total = arred(r.valor_base + r.valor_adicional)
+    r.incentivos_fiscais = incentivos_fiscais
+    r.irpj_a_recolher = max(
+        Decimal("0"),
+        arred(r.valor_irpj_total - incentivos_fiscais - irpj_anteriores),
+    )
+
+    r.detalhes = {
+        "receita_bruta": receita_bruta,
+        "percentual_presuncao": percentual,
+        "lucro_presumido": lucro_presumido,
+        "outras_receitas": outras_receitas,
+        "atividade": atividade,
+    }
+    return r
+
+
+def calcular_csll_lucro_real(
+    lucro_antes_csll: Decimal,
+    adicoes: Decimal = Decimal("0"),
+    exclusoes: Decimal = Decimal("0"),
+    compensacoes_base_negativa: Decimal = Decimal("0"),
+    tipo_empresa: str = "padrao",
+    csll_estimativas: Decimal = Decimal("0"),
+) -> ResultadoCSLL:
+    r = ResultadoCSLL()
+
+    base_ajustada = arred(lucro_antes_csll + adicoes - exclusoes)
+    limite_comp = arred(base_ajustada * Decimal("0.30"))
+    comp_efetiva = min(compensacoes_base_negativa, limite_comp)
+    r.base_calculo = max(Decimal("0"), arred(base_ajustada - comp_efetiva))
+
+    aliq = ALIQ_CSLL_FINANCEIRAS if tipo_empresa == "financeira" else ALIQ_CSLL_PADRAO
+    r.aliquota = aliq
+    r.valor_csll = arred(r.base_calculo * aliq / 100)
+    r.csll_a_recolher = max(Decimal("0"), arred(r.valor_csll - csll_estimativas))
+
+    r.detalhes = {
+        "adicoes": adicoes,
+        "exclusoes": exclusoes,
+        "compensacao_utilizada": comp_efetiva,
+        "estimativas_pagas": csll_estimativas,
+    }
+    return r
+
+
+def calcular_csll_lucro_presumido(
+    receita_bruta: Decimal,
+    outras_receitas: Decimal = Decimal("0"),
+    atividade: str = "comercio_industria",
+    tipo_empresa: str = "padrao",
+    csll_anteriores: Decimal = Decimal("0"),
+) -> ResultadoCSLL:
+    r = ResultadoCSLL()
+
+    percentual = PERCENTUAL_PRESUMIDO_CSLL.get(atividade, Decimal("12.0"))
+    base_presumida = arred(receita_bruta * percentual / 100 + outras_receitas)
+    r.base_calculo = base_presumida
+
+    aliq = ALIQ_CSLL_FINANCEIRAS if tipo_empresa == "financeira" else ALIQ_CSLL_PADRAO
+    r.aliquota = aliq
+    r.valor_csll = arred(r.base_calculo * aliq / 100)
+    r.csll_a_recolher = max(Decimal("0"), arred(r.valor_csll - csll_anteriores))
+
+    r.detalhes = {
+        "receita_bruta": receita_bruta,
+        "percentual_presuncao": percentual,
+        "base_presumida_bruta": base_presumida,
+        "outras_receitas": outras_receitas,
+        "atividade": atividade,
+    }
+    return r
+
+
+def calcular_irpj_estimativa_mensal(
+    receita_bruta_mes: Decimal,
+    atividade: str = "venda_mercadorias",
+    outras_receitas: Decimal = Decimal("0"),
+) -> dict[str, Decimal]:
+    """Cálculo de IRPJ por estimativa mensal (Lucro Real)."""
+    percentual = PERCENTUAL_PRESUMIDO_IRPJ.get(atividade, Decimal("8.0"))
+    base = arred(receita_bruta_mes * percentual / 100 + outras_receitas)
+
+    # Adicional: excedente ao limite mensal de R$20.000
+    limite_mensal = Decimal("20000")
+    irpj_base = arred(base * ALIQ_IRPJ_BASE / 100)
+    adicional = arred(max(Decimal("0"), base - limite_mensal) * ALIQ_IRPJ_ADICIONAL / 100)
+
+    return {
+        "base_estimada": base,
+        "irpj_aliquota_base": irpj_base,
+        "irpj_adicional": adicional,
+        "total_estimativa": arred(irpj_base + adicional),
+    }

src/calculators/iss.py

@@ -0,0 +1,157 @@
+"""Calculadora de ISS (Imposto sobre Serviços)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Optional
+
+from src.calculators import ResultadoCalculo, arred
+from src.fiscal.constants import ALIQ_ISS_MAXIMA, ALIQ_ISS_MINIMA, ALIQ_ISS_SERVICOS
+
+
+@dataclass
+class ParametrosISS:
+    valor_servico: Decimal
+    codigo_servico: str
+    aliquota_municipal: Optional[Decimal] = None
+    retencao_fonte: bool = False
+    municipio_prestacao: str = ""
+    municipio_tomador: str = ""
+    responsavel_retencao: str = "prestador"
+
+    def aliquota_efetiva(self) -> Decimal:
+        if self.aliquota_municipal is not None:
+            aliq = self.aliquota_municipal
+            aliq = max(aliq, ALIQ_ISS_MINIMA)
+            aliq = min(aliq, ALIQ_ISS_MAXIMA)
+            return aliq
+        return ALIQ_ISS_SERVICOS.get(
+            self.codigo_servico[:2], ALIQ_ISS_MAXIMA
+        )
+
+
+def calcular_iss(p: ParametrosISS) -> ResultadoCalculo:
+    aliq = p.aliquota_efetiva()
+    valor = arred(p.valor_servico * aliq / 100)
+
+    return ResultadoCalculo(
+        base_calculo=p.valor_servico,
+        aliquota=aliq,
+        valor_tributo=valor,
+        valor_a_recolher=valor,
+        detalhes={
+            "codigo_servico": p.codigo_servico,
+            "retencao_fonte": p.retencao_fonte,
+            "municipio_prestacao": p.municipio_prestacao,
+            "responsavel": "tomador" if p.retencao_fonte else "prestador",
+        },
+    )
+
+
+def calcular_iss_retido_tomador(
+    valor_servico: Decimal,
+    codigo_servico: str,
+    aliquota_municipal: Optional[Decimal] = None,
+) -> Decimal:
+    p = ParametrosISS(
+        valor_servico=valor_servico,
+        codigo_servico=codigo_servico,
+        aliquota_municipal=aliquota_municipal,
+        retencao_fonte=True,
+    )
+    resultado = calcular_iss(p)
+    return resultado.valor_tributo
+
+
+# Serviços sujeitos a retenção obrigatória pelo tomador (LC 116/2003, Art. 6º)
+SERVICOS_RETENCAO_OBRIGATORIA = {
+    "01",  # Serviços de informática e congêneres
+    "02",  # Pesquisa e desenvolvimento
+    "03",  # Serviços prestados mediante locação de bens
+    "04",  # Saúde, assistência médica
+    "07",  # Engenharia, arquitetura, agronomia, agrimensura
+    "08",  # Pesquisa, vigilância, rastreamento, monitoramento
+    "10",  # Serviços de intermediação e congêneres
+    "11",  # Guarda, estacionamento, armazenamento
+    "13",  # Fonografia, fotografia, cinematografia, reprografia
+    "15",  # Serviços bancários ou financeiros
+    "16",  # Serviços de transporte de natureza municipal
+    "17",  # Serviços de apoio técnico, administrativo, jurídico
+    "20",  # Serviços portuários, aeroportuários
+    "21",  # Serviços de registros públicos, cartorários
+}
+
+
+def requer_retencao_iss(codigo_servico: str) -> bool:
+    return codigo_servico[:2] in SERVICOS_RETENCAO_OBRIGATORIA
+
+
+def calcular_iss_simples_nacional(
+    receita_bruta_acumulada_12m: Decimal,
+    receita_servicos_mes: Decimal,
+    anexo: str = "III",
+) -> dict[str, Decimal]:
+    """Cálculo do ISS dentro do Simples Nacional por anexo."""
+    # Tabelas simplificadas Simples Nacional (Lei Complementar 123/2006)
+    tabelas = {
+        "III": [  # Serviços em geral (Anexo III)
+            (Decimal("180000"), Decimal("6.0"), Decimal("0")),
+            (Decimal("360000"), Decimal("11.2"), Decimal("9360")),
+            (Decimal("720000"), Decimal("13.5"), Decimal("17640")),
+            (Decimal("1800000"), Decimal("16.0"), Decimal("35640")),
+            (Decimal("3600000"), Decimal("21.0"), Decimal("125640")),
+            (Decimal("4800000"), Decimal("33.0"), Decimal("648000")),
+        ],
+        "IV": [  # Serviços especializados (Anexo IV) - sem CPP
+            (Decimal("180000"), Decimal("4.5"), Decimal("0")),
+            (Decimal("360000"), Decimal("9.0"), Decimal("8100")),
+            (Decimal("720000"), Decimal("10.2"), Decimal("12420")),
+            (Decimal("1800000"), Decimal("14.0"), Decimal("39780")),
+            (Decimal("3600000"), Decimal("22.0"), Decimal("183780")),
+            (Decimal("4800000"), Decimal("33.0"), Decimal("828000")),
+        ],
+        "V": [  # Serviços com fator R (Anexo V)
+            (Decimal("180000"), Decimal("15.5"), Decimal("0")),
+            (Decimal("360000"), Decimal("18.0"), Decimal("4500")),
+            (Decimal("720000"), Decimal("19.5"), Decimal("9900")),
+            (Decimal("1800000"), Decimal("20.5"), Decimal("17100")),
+            (Decimal("3600000"), Decimal("23.0"), Decimal("62100")),
+            (Decimal("4800000"), Decimal("30.5"), Decimal("540000")),
+        ],
+    }
+
+    tabela = tabelas.get(anexo, tabelas["III"])
+    aliq_nominal = Decimal("6.0")
+    deducao = Decimal("0")
+
+    for limite, aliq, ded in tabela:
+        if receita_bruta_acumulada_12m <= limite:
+            aliq_nominal = aliq
+            deducao = ded
+            break
+
+    aliq_efetiva = (
+        arred((receita_bruta_acumulada_12m * aliq_nominal / 100 - deducao) / receita_bruta_acumulada_12m * 100)
+        if receita_bruta_acumulada_12m > 0
+        else Decimal("0")
+    )
+
+    # ISS representa ~7-10% do DAS no Anexo III/IV
+    percentual_iss_das = {
+        "III": Decimal("33.50"),
+        "IV": Decimal("0"),  # ISS pago separado no Anexo IV
+        "V": Decimal("33.50"),
+    }
+
+    valor_das = arred(receita_servicos_mes * aliq_efetiva / 100)
+    valor_iss = arred(valor_das * percentual_iss_das.get(anexo, Decimal("33.5")) / 100)
+
+    return {
+        "receita_bruta_12m": receita_bruta_acumulada_12m,
+        "aliq_nominal": aliq_nominal,
+        "deducao": deducao,
+        "aliq_efetiva": aliq_efetiva,
+        "valor_das_total": valor_das,
+        "valor_iss_estimado": valor_iss,
+        "anexo": anexo,
+    }

src/calculators/pis_cofins.py

@@ -0,0 +1,180 @@
+"""Calculadora de PIS e COFINS (cumulativo e não-cumulativo)."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Optional
+
+from src.calculators import ResultadoCalculo, arred
+from src.fiscal.constants import (
+    ALIQ_COFINS_LUCRO_PRESUMIDO,
+    ALIQ_COFINS_LUCRO_REAL,
+    ALIQ_PIS_LUCRO_PRESUMIDO,
+    ALIQ_PIS_LUCRO_REAL,
+)
+from src.fiscal.entities import RegimeTributario
+
+
+@dataclass
+class ReceitaBruta:
+    descricao: str
+    valor: Decimal
+    cst_pis: str = "01"
+    cst_cofins: str = "01"
+    aliq_pis_especifica: Optional[Decimal] = None
+    aliq_cofins_especifica: Optional[Decimal] = None
+
+
+@dataclass
+class CreditoPisCofins:
+    descricao: str
+    base_calculo: Decimal
+    aliquota_pis: Decimal
+    aliquota_cofins: Decimal
+    cst_pis: str = "50"
+    cst_cofins: str = "50"
+
+    @property
+    def valor_pis(self) -> Decimal:
+        return arred(self.base_calculo * self.aliquota_pis / 100)
+
+    @property
+    def valor_cofins(self) -> Decimal:
+        return arred(self.base_calculo * self.aliquota_cofins / 100)
+
+
+@dataclass
+class ResultadoPisCofins:
+    # PIS
+    base_pis: Decimal = Decimal("0")
+    aliq_pis: Decimal = Decimal("0")
+    valor_pis_debito: Decimal = Decimal("0")
+    creditos_pis: Decimal = Decimal("0")
+    pis_a_recolher: Decimal = Decimal("0")
+    # COFINS
+    base_cofins: Decimal = Decimal("0")
+    aliq_cofins: Decimal = Decimal("0")
+    valor_cofins_debito: Decimal = Decimal("0")
+    creditos_cofins: Decimal = Decimal("0")
+    cofins_a_recolher: Decimal = Decimal("0")
+    # Regime
+    regime: str = ""
+    detalhes: dict = field(default_factory=dict)
+
+
+def calcular_pis_cofins(
+    receitas: list[ReceitaBruta],
+    regime: RegimeTributario,
+    creditos: list[CreditoPisCofins] | None = None,
+    saldo_anterior_pis: Decimal = Decimal("0"),
+    saldo_anterior_cofins: Decimal = Decimal("0"),
+) -> ResultadoPisCofins:
+    creditos = creditos or []
+    r = ResultadoPisCofins()
+
+    is_nao_cumulativo = regime == RegimeTributario.LUCRO_REAL
+    aliq_pis = ALIQ_PIS_LUCRO_REAL if is_nao_cumulativo else ALIQ_PIS_LUCRO_PRESUMIDO
+    aliq_cofins = ALIQ_COFINS_LUCRO_REAL if is_nao_cumulativo else ALIQ_COFINS_LUCRO_PRESUMIDO
+
+    r.regime = "Não-Cumulativo" if is_nao_cumulativo else "Cumulativo"
+    r.aliq_pis = aliq_pis
+    r.aliq_cofins = aliq_cofins
+
+    # Calcular débitos por receita
+    pis_debito_total = Decimal("0")
+    cofins_debito_total = Decimal("0")
+    base_tributavel_pis = Decimal("0")
+    base_tributavel_cofins = Decimal("0")
+
+    detalhes_receitas = []
+    for rec in receitas:
+        # CSTs que geram débito: 01, 02, 03, 04, 05
+        if rec.cst_pis in {"01", "02", "03", "04", "05"}:
+            ap = rec.aliq_pis_especifica if rec.aliq_pis_especifica is not None else aliq_pis
+            vp = arred(rec.valor * ap / 100)
+            pis_debito_total += vp
+            base_tributavel_pis += rec.valor
+        else:
+            vp = Decimal("0")
+
+        if rec.cst_cofins in {"01", "02", "03", "04", "05"}:
+            ac = rec.aliq_cofins_especifica if rec.aliq_cofins_especifica is not None else aliq_cofins
+            vc = arred(rec.valor * ac / 100)
+            cofins_debito_total += vc
+            base_tributavel_cofins += rec.valor
+        else:
+            vc = Decimal("0")
+
+        detalhes_receitas.append({
+            "descricao": rec.descricao,
+            "valor": rec.valor,
+            "cst_pis": rec.cst_pis,
+            "cst_cofins": rec.cst_cofins,
+            "valor_pis": vp,
+            "valor_cofins": vc,
+        })
+
+    r.base_pis = arred(base_tributavel_pis)
+    r.base_cofins = arred(base_tributavel_cofins)
+    r.valor_pis_debito = arred(pis_debito_total)
+    r.valor_cofins_debito = arred(cofins_debito_total)
+
+    # Créditos (apenas regime não-cumulativo)
+    creditos_pis = Decimal("0")
+    creditos_cofins = Decimal("0")
+    if is_nao_cumulativo:
+        for cred in creditos:
+            creditos_pis += cred.valor_pis
+            creditos_cofins += cred.valor_cofins
+
+    creditos_pis = arred(creditos_pis + saldo_anterior_pis)
+    creditos_cofins = arred(creditos_cofins + saldo_anterior_cofins)
+
+    r.creditos_pis = creditos_pis
+    r.creditos_cofins = creditos_cofins
+    r.pis_a_recolher = max(Decimal("0"), arred(r.valor_pis_debito - creditos_pis))
+    r.cofins_a_recolher = max(Decimal("0"), arred(r.valor_cofins_debito - creditos_cofins))
+
+    r.detalhes = {
+        "receitas": detalhes_receitas,
+        "saldo_credor_pis": max(Decimal("0"), arred(creditos_pis - r.valor_pis_debito)),
+        "saldo_credor_cofins": max(Decimal("0"), arred(creditos_cofins - r.valor_cofins_debito)),
+    }
+
+    return r
+
+
+def calcular_pis_cofins_retencao(
+    valor_servico: Decimal,
+    aliq_pis: Decimal = Decimal("0.65"),
+    aliq_cofins: Decimal = Decimal("3.00"),
+    aliq_csll: Decimal = Decimal("1.00"),
+    aliq_ir: Decimal = Decimal("1.50"),
+) -> dict[str, Decimal]:
+    """Retenção de PIS/COFINS/CSLL/IR na fonte para serviços (IN SRF 459/2004)."""
+    MIN_RETENCAO = Decimal("10.00")
+
+    valor_pis = arred(valor_servico * aliq_pis / 100)
+    valor_cofins = arred(valor_servico * aliq_cofins / 100)
+    valor_csll = arred(valor_servico * aliq_csll / 100)
+    valor_ir = arred(valor_servico * aliq_ir / 100)
+    total = arred(valor_pis + valor_cofins + valor_csll + valor_ir)
+
+    if total < MIN_RETENCAO:
+        return {
+            "valor_pis": Decimal("0"),
+            "valor_cofins": Decimal("0"),
+            "valor_csll": Decimal("0"),
+            "valor_ir": Decimal("0"),
+            "total_retido": Decimal("0"),
+            "observacao": f"Retenção dispensada: total R$ {total} < R$ {MIN_RETENCAO}",
+        }
+
+    return {
+        "valor_pis": valor_pis,
+        "valor_cofins": valor_cofins,
+        "valor_csll": valor_csll,
+        "valor_ir": valor_ir,
+        "total_retido": total,
+        "observacao": "",
+    }

src/calculators/simples_nacional.py

@@ -0,0 +1,292 @@
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from decimal import Decimal
+from typing import Optional
+
+from src.calculators import ResultadoCalculo, arred
+
+
+# ---------------------------------------------------------------------------
+# Tabelas do Simples Nacional (LC 123/2006 com alterações da LC 155/2016)
+# Vigência: a partir de 01/01/2018
+# Faixas: (limite_acumulado_12m, aliq_nominal, deducao)
+# ---------------------------------------------------------------------------
+
+TABELA_SIMPLES: dict[str, list[tuple[Decimal, Decimal, Decimal]]] = {
+    "I": [  # Comércio
+        (Decimal("180000.00"), Decimal("4.00"), Decimal("0.00")),
+        (Decimal("360000.00"), Decimal("7.30"), Decimal("5940.00")),
+        (Decimal("720000.00"), Decimal("9.50"), Decimal("13860.00")),
+        (Decimal("1800000.00"), Decimal("10.70"), Decimal("22500.00")),
+        (Decimal("3600000.00"), Decimal("14.30"), Decimal("87300.00")),
+        (Decimal("4800000.00"), Decimal("19.00"), Decimal("378000.00")),
+    ],
+    "II": [  # Indústria
+        (Decimal("180000.00"), Decimal("4.50"), Decimal("0.00")),
+        (Decimal("360000.00"), Decimal("7.80"), Decimal("5940.00")),
+        (Decimal("720000.00"), Decimal("10.00"), Decimal("13860.00")),
+        (Decimal("1800000.00"), Decimal("11.20"), Decimal("22500.00")),
+        (Decimal("3600000.00"), Decimal("14.70"), Decimal("85500.00")),
+        (Decimal("4800000.00"), Decimal("30.00"), Decimal("720000.00")),
+    ],
+    "III": [  # Serviços (com CPP)
+        (Decimal("180000.00"), Decimal("6.00"), Decimal("0.00")),
+        (Decimal("360000.00"), Decimal("11.20"), Decimal("9360.00")),
+        (Decimal("720000.00"), Decimal("13.50"), Decimal("17640.00")),
+        (Decimal("1800000.00"), Decimal("16.00"), Decimal("35640.00")),
+        (Decimal("3600000.00"), Decimal("21.00"), Decimal("125640.00")),
+        (Decimal("4800000.00"), Decimal("33.00"), Decimal("648000.00")),
+    ],
+    "IV": [  # Serviços (sem CPP — INSS pago separado)
+        (Decimal("180000.00"), Decimal("4.50"), Decimal("0.00")),
+        (Decimal("360000.00"), Decimal("9.00"), Decimal("8100.00")),
+        (Decimal("720000.00"), Decimal("10.20"), Decimal("12420.00")),
+        (Decimal("1800000.00"), Decimal("14.00"), Decimal("39780.00")),
+        (Decimal("3600000.00"), Decimal("22.00"), Decimal("183780.00")),
+        (Decimal("4800000.00"), Decimal("33.00"), Decimal("828000.00")),
+    ],
+    "V": [  # Serviços com fator R (profissões regulamentadas)
+        (Decimal("180000.00"), Decimal("15.50"), Decimal("0.00")),
+        (Decimal("360000.00"), Decimal("18.00"), Decimal("4500.00")),
+        (Decimal("720000.00"), Decimal("19.50"), Decimal("9900.00")),
+        (Decimal("1800000.00"), Decimal("20.50"), Decimal("17100.00")),
+        (Decimal("3600000.00"), Decimal("23.00"), Decimal("62100.00")),
+        (Decimal("4800000.00"), Decimal("30.50"), Decimal("540000.00")),
+    ],
+}
+
+
+PARTILHA_DAS: dict[str, list[dict[str, Decimal]]] = {
+    "I": [
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.74"), "PIS": Decimal("2.76"), "CPP": Decimal("41.50"), "ICMS": Decimal("34.00")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.74"), "PIS": Decimal("2.76"), "CPP": Decimal("41.50"), "ICMS": Decimal("34.00")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.74"), "PIS": Decimal("2.76"), "CPP": Decimal("42.00"), "ICMS": Decimal("33.50")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.74"), "PIS": Decimal("2.76"), "CPP": Decimal("42.00"), "ICMS": Decimal("33.50")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.74"), "PIS": Decimal("2.76"), "CPP": Decimal("42.00"), "ICMS": Decimal("33.50")},
+        {"IRPJ": Decimal("13.5"), "CSLL": Decimal("10.0"), "COFINS": Decimal("28.27"), "PIS": Decimal("6.13"), "CPP": Decimal("42.10"), "ICMS": Decimal("0.00")},
+    ],
+    "II": [
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("11.51"), "PIS": Decimal("2.49"), "CPP": Decimal("37.50"), "IPI": Decimal("7.50"), "ICMS": Decimal("32.00")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("11.51"), "PIS": Decimal("2.49"), "CPP": Decimal("37.50"), "IPI": Decimal("7.50"), "ICMS": Decimal("32.00")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("11.51"), "PIS": Decimal("2.49"), "CPP": Decimal("37.50"), "IPI": Decimal("7.50"), "ICMS": Decimal("32.00")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("11.51"), "PIS": Decimal("2.49"), "CPP": Decimal("37.50"), "IPI": Decimal("7.50"), "ICMS": Decimal("32.00")},
+        {"IRPJ": Decimal("5.5"), "CSLL": Decimal("3.5"), "COFINS": Decimal("11.51"), "PIS": Decimal("2.49"), "CPP": Decimal("37.50"), "IPI": Decimal("7.50"), "ICMS": Decimal("32.00")},
+        {"IRPJ": Decimal("8.0"), "CSLL": Decimal("7.5"), "COFINS": Decimal("20.96"), "PIS": Decimal("4.54"), "CPP": Decimal("23.50"), "IPI": Decimal("35.50"), "ICMS": Decimal("0.00")},
+    ],
+    "III": [
+        {"IRPJ": Decimal("4.0"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.82"), "PIS": Decimal("2.78"), "CPP": Decimal("43.40"), "ISS": Decimal("33.50")},
+        {"IRPJ": Decimal("4.0"), "CSLL": Decimal("3.5"), "COFINS": Decimal("14.05"), "PIS": Decimal("3.05"), "CPP": Decimal("43.40"), "ISS": Decimal("32.00")},
+        {"IRPJ": Decimal("4.0"), "CSLL": Decimal("3.5"), "COFINS": Decimal("13.64"), "PIS": Decimal("2.96"), "CPP": Decimal("43.40"), "ISS": Decimal("32.50")},
+        {"IRPJ": Decimal("4.0"), "CSLL": Decimal("3.5"), "COFINS": Decimal("13.64"), "PIS": Decimal("2.96"), "CPP": Decimal("43.40"), "ISS": Decimal("32.50")},
+        {"IRPJ": Decimal("4.0"), "CSLL": Decimal("3.5"), "COFINS": Decimal("12.82"), "PIS": Decimal("2.78"), "CPP": Decimal("43.40"), "ISS": Decimal("33.50")},
+        {"IRPJ": Decimal("35.0"), "CSLL": Decimal("15.0"), "COFINS": Decimal("16.03"), "PIS": Decimal("3.47"), "CPP": Decimal("30.50"), "ISS": Decimal("0.00")},
+    ],
+    "IV": [
+        {"IRPJ": Decimal("18.8"), "CSLL": Decimal("15.2"), "COFINS": Decimal("17.67"), "PIS": Decimal("3.83"), "ISS": Decimal("44.50")},
+        {"IRPJ": Decimal("19.8"), "CSLL": Decimal("15.2"), "COFINS": Decimal("20.55"), "PIS": Decimal("4.45"), "ISS": Decimal("40.00")},
+        {"IRPJ": Decimal("20.8"), "CSLL": Decimal("15.2"), "COFINS": Decimal("19.73"), "PIS": Decimal("4.27"), "ISS": Decimal("40.00")},
+        {"IRPJ": Decimal("17.8"), "CSLL": Decimal("19.2"), "COFINS": Decimal("18.90"), "PIS": Decimal("4.10"), "ISS": Decimal("40.00")},
+        {"IRPJ": Decimal("18.8"), "CSLL": Decimal("19.2"), "COFINS": Decimal("18.08"), "PIS": Decimal("3.92"), "ISS": Decimal("40.00")},
+        {"IRPJ": Decimal("53.5"), "CSLL": Decimal("21.5"), "COFINS": Decimal("20.55"), "PIS": Decimal("4.45"), "ISS": Decimal("0.00")},
+    ],
+}
+
+LIMITE_SIMPLES = Decimal("4800000.00")
+LIMITE_MEI = Decimal("81000.00")
+
+
+@dataclass
+class ResultadoSimples:
+    receita_bruta_mes: Decimal
+    receita_bruta_acumulada_12m: Decimal
+    anexo: str
+    faixa: int
+    aliq_nominal: Decimal
+    deducao: Decimal
+    aliq_efetiva: Decimal
+    valor_das: Decimal
+    partilha: dict[str, Decimal] = field(default_factory=dict)
+    periodo: str = ""
+    dentro_limite: bool = True
+
+
+def _calcular_aliq_efetiva(
+    rec_12m: Decimal,
+    aliq_nominal: Decimal,
+    deducao: Decimal,
+) -> Decimal:
+    if rec_12m <= 0:
+        return Decimal("0")
+    return arred(((rec_12m * aliq_nominal / 100) - deducao) / rec_12m * 100, 6)
+
+
+def _obter_faixa(rec_12m: Decimal, tabela: list) -> tuple[int, Decimal, Decimal]:
+    """Retorna (índice_faixa, aliq_nominal, deducao)."""
+    for i, (limite, aliq, ded) in enumerate(tabela):
+        if rec_12m <= limite:
+            return i, aliq, ded
+    
+    return len(tabela) - 1, tabela[-1][1], tabela[-1][2]
+
+
+def calcular_das(
+    receita_bruta_mes: Decimal,
+    receita_bruta_acumulada_12m: Decimal,
+    anexo: str = "I",
+    periodo: str = "",
+) -> ResultadoSimples:
+    """
+    Calcula o DAS (Documento de Arrecadação do Simples Nacional) mensal.
+
+    Args:
+        receita_bruta_mes: Receita bruta do mês de referência
+        receita_bruta_acumulada_12m: Soma dos últimos 12 meses (ou desde o início)
+        anexo: "I", "II", "III", "IV" ou "V"
+        periodo: "YYYY-MM"
+    """
+    dentro_limite = receita_bruta_acumulada_12m <= LIMITE_SIMPLES
+    tabela = TABELA_SIMPLES.get(anexo, TABELA_SIMPLES["I"])
+
+    faixa_idx, aliq_nominal, deducao = _obter_faixa(receita_bruta_acumulada_12m, tabela)
+    aliq_efetiva = _calcular_aliq_efetiva(receita_bruta_acumulada_12m, aliq_nominal, deducao)
+    valor_das = arred(receita_bruta_mes * aliq_efetiva / 100)
+
+    
+    partilha_tabela = PARTILHA_DAS.get(anexo, [])
+    partilha: dict[str, Decimal] = {}
+    if partilha_tabela and faixa_idx < len(partilha_tabela):
+        perc_faixa = partilha_tabela[faixa_idx]
+        for tributo, perc in perc_faixa.items():
+            partilha[tributo] = arred(valor_das * perc / 100)
+
+    return ResultadoSimples(
+        receita_bruta_mes=receita_bruta_mes,
+        receita_bruta_acumulada_12m=receita_bruta_acumulada_12m,
+        anexo=anexo,
+        faixa=faixa_idx + 1,
+        aliq_nominal=aliq_nominal,
+        deducao=deducao,
+        aliq_efetiva=aliq_efetiva,
+        valor_das=valor_das,
+        partilha=partilha,
+        periodo=periodo,
+        dentro_limite=dentro_limite,
+    )
+
+
+def calcular_fator_r(
+    folha_12m: Decimal,
+    rec_12m: Decimal,
+) -> Decimal:
+    """
+    Fator R: relação folha de pagamento / receita bruta nos últimos 12 meses.
+    Se Fator R >= 28%, o contribuinte pode optar pelo Anexo III ao invés do V.
+    """
+    if rec_12m <= 0:
+        return Decimal("0")
+    return arred(folha_12m / rec_12m * 100, 4)
+
+
+def determinar_anexo_servicos(
+    fator_r: Decimal,
+    lista_servico: str,
+) -> str:
+    """
+    Determina o anexo aplicável para empresas de serviços.
+    Serviços do Anexo V com Fator R >= 28% podem usar o Anexo III.
+    """
+    
+    anexo_iv = {
+        "construcao_civil", "servicos_vigilancia", "limpeza",
+        "transporte_cargas", "cuidados_pessoais",
+    }
+    
+    anexo_iii = {
+        "agencia_viagens", "academias", "agronegocio",
+        "arquitetura_engenharia_simples",
+    }
+    
+    fator_r_atividades = {
+        "medicina", "odontologia", "psicologia", "fisioterapia",
+        "advocacia", "contabilidade", "consultoria", "ti_software",
+        "engenharia", "arquitetura",
+    }
+
+    if lista_servico in anexo_iv:
+        return "IV"
+    if lista_servico in anexo_iii:
+        return "III"
+    if lista_servico in fator_r_atividades:
+        return "III" if fator_r >= Decimal("28") else "V"
+    return "III"
+
+
+@dataclass
+class ResultadoPGDAS:
+    """Resultado do PGDAS-D mensal."""
+    cnpj: str
+    periodo: str
+    receita_bruta_total: Decimal
+    das_total: Decimal
+    das_por_estabelecimento: list[ResultadoSimples] = field(default_factory=list)
+    data_vencimento: Optional[date] = None
+
+    @property
+    def resumo_partilha(self) -> dict[str, Decimal]:
+        totais: dict[str, Decimal] = {}
+        for r in self.das_por_estabelecimento:
+            for tributo, valor in r.partilha.items():
+                totais[tributo] = totais.get(tributo, Decimal("0")) + valor
+        return totais
+
+
+def calcular_pgdas(
+    cnpj: str,
+    periodo: str,
+    receitas_por_atividade: list[dict],
+    receita_acumulada_12m: Decimal,
+) -> ResultadoPGDAS:
+    """
+    Calcula o PGDAS-D completo para um período.
+
+    Args:
+        cnpj: CNPJ da empresa
+        periodo: "YYYY-MM"
+        receitas_por_atividade: [{"valor": ..., "anexo": "I/II/III/IV/V"}]
+        receita_acumulada_12m: Receita dos últimos 12 meses
+    """
+    das_total = Decimal("0")
+    resultados = []
+
+    for ativ in receitas_por_atividade:
+        valor = Decimal(str(ativ.get("valor", 0)))
+        anexo = ativ.get("anexo", "I")
+        resultado = calcular_das(valor, receita_acumulada_12m, anexo, periodo)
+        das_total += resultado.valor_das
+        resultados.append(resultado)
+
+    
+    ano, mes = map(int, periodo.split("-"))
+    mes_vcto = mes + 1 if mes < 12 else 1
+    ano_vcto = ano if mes < 12 else ano + 1
+    vcto = date(ano_vcto, mes_vcto, 20)
+
+    return ResultadoPGDAS(
+        cnpj=cnpj,
+        periodo=periodo,
+        receita_bruta_total=sum(Decimal(str(a["valor"])) for a in receitas_por_atividade),
+        das_total=arred(das_total),
+        das_por_estabelecimento=resultados,
+        data_vencimento=vcto,
+    )
+
+
+
+MEI_VALORES_FIXOS = {
+    "comercio_industria": Decimal("70.60"),   # R$ 70,60/mês (2024)
+    "servicos": Decimal("79.60"),
+    "comercio_servicos": Decimal("80.60"),
+}

src/fiscal/constants.py

@@ -0,0 +1,338 @@
+
+from decimal import Decimal
+
+
+ALIQ_ICMS_INTERNA: dict[str, Decimal] = {
+    "AC": Decimal("17"), "AL": Decimal("17"), "AP": Decimal("18"),
+    "AM": Decimal("20"), "BA": Decimal("19"), "CE": Decimal("20"),
+    "DF": Decimal("20"), "ES": Decimal("17"), "GO": Decimal("17"),
+    "MA": Decimal("22"), "MT": Decimal("17"), "MS": Decimal("17"),
+    "MG": Decimal("18"), "PA": Decimal("19"), "PB": Decimal("18"),
+    "PR": Decimal("19"), "PE": Decimal("20.5"), "PI": Decimal("21"),
+    "RJ": Decimal("20"), "RN": Decimal("18"), "RS": Decimal("17"),
+    "RO": Decimal("19.5"), "RR": Decimal("20"), "SC": Decimal("17"),
+    "SP": Decimal("18"), "SE": Decimal("19"), "TO": Decimal("20"),
+}
+
+
+ALIQ_ICMS_INTERESTADUAL: dict[str, Decimal] = {
+    "SUL_SUDESTE_para_OUTROS": Decimal("7"),
+    "OUTROS_para_SUL_SUDESTE": Decimal("12"),
+    "SUL_SUDESTE_para_SUL_SUDESTE": Decimal("12"),
+    "EXTERIOR": Decimal("4"),
+}
+
+UF_SUL_SUDESTE = {"SP", "RJ", "MG", "ES", "PR", "SC", "RS"}
+
+
+def aliq_icms_interestadual(uf_origem: str, uf_destino: str) -> Decimal:
+    if uf_origem in UF_SUL_SUDESTE and uf_destino not in UF_SUL_SUDESTE:
+        return ALIQ_ICMS_INTERESTADUAL["SUL_SUDESTE_para_OUTROS"]
+    return ALIQ_ICMS_INTERESTADUAL["OUTROS_para_SUL_SUDESTE"]
+
+
+ALIQ_PIS_LUCRO_REAL = Decimal("1.65")
+ALIQ_COFINS_LUCRO_REAL = Decimal("7.60")
+ALIQ_PIS_LUCRO_PRESUMIDO = Decimal("0.65")
+ALIQ_COFINS_LUCRO_PRESUMIDO = Decimal("3.00")
+
+ALIQ_IRPJ_BASE = Decimal("15")
+ALIQ_IRPJ_ADICIONAL = Decimal("10")
+LIMITE_ADICIONAL_IRPJ_MENSAL = Decimal("20000")
+LIMITE_ADICIONAL_IRPJ_TRIMESTRAL = Decimal("60000")
+LIMITE_ADICIONAL_IRPJ_ANUAL = Decimal("240000")
+
+
+PERCENTUAL_PRESUMIDO_IRPJ: dict[str, Decimal] = {
+    "revenda_combustiveis": Decimal("1.6"),
+    "venda_mercadorias": Decimal("8.0"),
+    "transporte_cargas": Decimal("8.0"),
+    "atividades_rurais": Decimal("8.0"),
+    "outros_negocios": Decimal("8.0"),
+    "transporte_passageiros": Decimal("16.0"),
+    "servicos_em_geral": Decimal("32.0"),
+    "intermediacao_negocios": Decimal("32.0"),
+    "administracao_locacao": Decimal("32.0"),
+    "profissoes_regulamentadas": Decimal("32.0"),
+}
+
+PERCENTUAL_PRESUMIDO_CSLL: dict[str, Decimal] = {
+    "comercio_industria": Decimal("12.0"),
+    "servicos_em_geral": Decimal("32.0"),
+}
+
+ALIQ_CSLL_PADRAO = Decimal("9")
+ALIQ_CSLL_FINANCEIRAS = Decimal("15")
+
+
+ALIQ_ISS_MINIMA = Decimal("2.0")
+ALIQ_ISS_MAXIMA = Decimal("5.0")
+
+
+ALIQ_ISS_SERVICOS: dict[str, Decimal] = {
+    "01": Decimal("5.0"),  # Serviços de informática
+    "02": Decimal("5.0"),  # Pesquisa e desenvolvimento
+    "03": Decimal("5.0"),  # Serviços prestados mediante locação
+    "04": Decimal("5.0"),  # Saúde, assistência médica
+    "05": Decimal("5.0"),  # Medicina e assistência veterinária
+    "06": Decimal("5.0"),  # Cuidados pessoais, estética, atividades físicas
+    "07": Decimal("5.0"),  # Serviços relativos a engenharia
+    "08": Decimal("5.0"),  # Pesquisa, vigilância, rastreamento
+    "09": Decimal("5.0"),  # Serviços relativos a hospedagem, turismo, viagens
+    "10": Decimal("5.0"),  # Serviços de intermediação
+    "11": Decimal("5.0"),  # Serviços de guarda, estacionamento
+    "12": Decimal("5.0"),  # Serviços de diversões, lazer, entretenimento
+    "13": Decimal("5.0"),  # Serviços relativos à fonografia, fotografia, cinematografia
+    "14": Decimal("5.0"),  # Serviços relativos a bens de terceiros
+    "15": Decimal("5.0"),  # Serviços relacionados ao setor bancário ou financeiro
+    "16": Decimal("5.0"),  # Serviços de transporte de natureza municipal
+    "17": Decimal("2.0"),  # Serviços de apoio técnico, administrativo, jurídico
+    "18": Decimal("5.0"),  # Serviços de regulação de sinistros
+    "19": Decimal("5.0"),  # Serviços de distribuição e venda de bilhetes e demais produtos
+    "20": Decimal("5.0"),  # Serviços portuários, aeroportuários
+    "21": Decimal("5.0"),  # Serviços de registros públicos
+    "22": Decimal("5.0"),  # Serviços de exploração de rodovias
+    "23": Decimal("5.0"),  # Serviços de programação e comunicação visual
+    "24": Decimal("5.0"),  # Serviços de chaveiros, confecção de carimbos
+    "25": Decimal("2.0"),  # Serviços funerários
+    "26": Decimal("5.0"),  # Serviços de coleta, remessa ou entrega de correspondências
+    "27": Decimal("5.0"),  # Serviços de assistência social
+    "28": Decimal("5.0"),  # Serviços de avaliação de bens e serviços
+    "29": Decimal("5.0"),  # Serviços de biblioteconomia
+    "30": Decimal("5.0"),  # Serviços de biologia, biotecnologia e química
+    "31": Decimal("5.0"),  # Serviços técnicos em edificações
+    "32": Decimal("5.0"),  # Serviços de desenho técnico
+    "33": Decimal("5.0"),  # Serviços de desembaraço aduaneiro
+    "34": Decimal("5.0"),  # Serviços de investigações particulares
+    "35": Decimal("5.0"),  # Serviços de reportagem, assessoria de imprensa
+    "36": Decimal("5.0"),  # Serviços de meteorologia
+    "37": Decimal("5.0"),  # Serviços de artistas, atletas, modelos e manequins
+    "38": Decimal("5.0"),  # Serviços de museologia
+    "39": Decimal("5.0"),  # Serviços de ourivesaria e lapidação
+    "40": Decimal("5.0"),  # Obras de arte sob encomenda
+}
+
+
+CST_ICMS: dict[str, str] = {
+    "000": "Tributada integralmente",
+    "010": "Tributada e com cobrança do ICMS por substituição tributária",
+    "020": "Com redução de base de cálculo",
+    "030": "Isenta ou não tributada e com cobrança do ICMS por substituição tributária",
+    "040": "Isenta",
+    "041": "Não tributada",
+    "050": "Suspensão",
+    "051": "Diferimento",
+    "060": "ICMS cobrado anteriormente por substituição tributária",
+    "070": "Com redução de base de cálculo e cobrança do ICMS por substituição tributária",
+    "090": "Outras",
+    # Simples Nacional
+    "101": "Tributada pelo Simples Nacional com permissão de crédito",
+    "102": "Tributada pelo Simples Nacional sem permissão de crédito",
+    "103": "Isenção do ICMS no Simples Nacional para faixa de receita bruta",
+    "201": "Tributada pelo Simples Nacional com permissão de crédito e com cobrança do ICMS por ST",
+    "202": "Tributada pelo Simples Nacional sem permissão de crédito e com cobrança do ICMS por ST",
+    "203": "Isenção do ICMS no Simples Nacional para faixa de receita bruta e com cobrança do ICMS por ST",
+    "300": "Imune",
+    "400": "Não tributada pelo Simples Nacional",
+    "500": "ICMS cobrado anteriormente por ST ou por antecipação",
+    "900": "Outros",
+}
+
+
+CST_IPI_ENTRADA: dict[str, str] = {
+    "00": "Entrada com recuperação de crédito",
+    "01": "Entrada tributada com alíquota zero",
+    "02": "Entrada isenta",
+    "03": "Entrada não-tributada",
+    "04": "Entrada imune",
+    "05": "Entrada com suspensão",
+    "49": "Outras entradas",
+}
+
+CST_IPI_SAIDA: dict[str, str] = {
+    "50": "Saída tributada",
+    "51": "Saída tributável com alíquota zero",
+    "52": "Saída isenta",
+    "53": "Saída não-tributada",
+    "54": "Saída imune",
+    "55": "Saída com suspensão",
+    "99": "Outras saídas",
+}
+
+
+CST_PIS_COFINS_SAIDA: dict[str, str] = {
+    "01": "Operação tributável (base de cálculo = valor da operação alíquota normal)",
+    "02": "Operação tributável (base de cálculo = valor da operação alíquota diferenciada)",
+    "03": "Operação tributável (base de cálculo = quantidade vendida x alíquota por unidade de produto)",
+    "04": "Operação tributável (tributação monofásica - revenda a alíquota zero)",
+    "05": "Operação tributável (ST)",
+    "06": "Operação tributável (alíquota zero)",
+    "07": "Operação isenta da contribuição",
+    "08": "Operação sem incidência da contribuição",
+    "09": "Operação com suspensão da contribuição",
+    "49": "Outras operações de saída",
+}
+
+CST_PIS_COFINS_ENTRADA: dict[str, str] = {
+    "50": "Operação com direito a crédito - vinculada exclusivamente a receita tributada no mercado interno",
+    "51": "Operação com direito a crédito - vinculada exclusivamente a receita não tributada no mercado interno",
+    "52": "Operação com direito a crédito - vinculada exclusivamente a receita de exportação",
+    "53": "Operação com direito a crédito - vinculada a receitas tributadas e não-tributadas no mercado interno",
+    "54": "Operação com direito a crédito - vinculada a receitas tributadas no mercado interno e de exportação",
+    "55": "Operação com direito a crédito - vinculada a receitas não-tributadas no mercado interno e de exportação",
+    "56": "Operação com direito a crédito - vinculada a receitas tributadas e não-tributadas no mercado interno e de exportação",
+    "60": "Crédito presumido - operação de aquisição vinculada exclusivamente a receita tributada no mercado interno",
+    "61": "Crédito presumido - operação de aquisição vinculada exclusivamente a receita não-tributada no mercado interno",
+    "62": "Crédito presumido - operação de aquisição vinculada exclusivamente a receita de exportação",
+    "63": "Crédito presumido - operação de aquisição vinculada a receitas tributadas e não-tributadas no mercado interno",
+    "64": "Crédito presumido - operação de aquisição vinculada a receitas tributadas no mercado interno e de exportação",
+    "65": "Crédito presumido - operação de aquisição vinculada a receitas não-tributadas no mercado interno e de exportação",
+    "66": "Crédito presumido - operação de aquisição vinculada a receitas tributadas e não-tributadas no mercado interno e de exportação",
+    "67": "Crédito presumido - outras operações",
+    "70": "Operação de aquisição sem direito a crédito",
+    "71": "Operação de aquisição com isenção",
+    "72": "Operação de aquisição com suspensão",
+    "73": "Operação de aquisição a alíquota zero",
+    "74": "Operação de aquisição (ST)",
+    "75": "Operação de aquisição sem incidência da contribuição",
+    "98": "Outras operações de entrada",
+    "99": "Outras operações",
+}
+
+
+CFOP: dict[str, str] = {
+    
+    "1101": "Compra para industrialização ou produção rural",
+    "1102": "Compra para comercialização",
+    "1111": "Compra para industrialização de mercadoria recebida anteriormente em consignação industrial",
+    "1113": "Compra para comercialização, de mercadoria recebida anteriormente em consignação mercantil",
+    "1116": "Compra para industrialização originada de encomenda para recebimento futuro",
+    "1117": "Compra para comercialização originada de encomenda para recebimento futuro",
+    "1122": "Compra para comercialização de energia elétrica",
+    "1124": "Industrialização efetuada por outra empresa",
+    "1126": "Compra para utilização na prestação de serviço sujeita ao ISSQN",
+    "1151": "Transferência para industrialização ou produção rural",
+    "1152": "Transferência para comercialização",
+    "1201": "Devolução de venda de produção do estabelecimento",
+    "1202": "Devolução de venda de mercadoria adquirida ou recebida de terceiros",
+    "1251": "Compra de energia elétrica para distribuição ou comercialização",
+    "1301": "Aquisição de serviço de comunicação para execução de serviço da mesma natureza",
+    "1302": "Aquisição de serviço de comunicação por estabelecimento industrial",
+    "1303": "Aquisição de serviço de comunicação por estabelecimento comercial",
+    "1352": "Aquisição de serviço de transporte por estabelecimento comercial",
+    "1353": "Aquisição de serviço de transporte por estabelecimento de prestador de serviço de comunicação",
+    "1401": "Compra para industrialização em operação com mercadoria sujeita ao regime de ST",
+    "1403": "Compra para comercialização em operação com mercadoria sujeita ao regime de ST",
+    "1407": "Compra de mercadoria para uso ou consumo em operação com mercadoria sujeita ao regime de ST",
+    "1501": "Entrada de mercadoria recebida com fim específico de exportação",
+    "1503": "Entrada de mercadoria recebida com fim específico de exportação, de estabelecimento do mesmo titular",
+    "1556": "Compra de material para uso ou consumo",
+    "1601": "Recebimento, por transferência, de saldo credor de ICMS",
+    "1651": "Compra de combustível ou lubrificante para industrialização subsequente",
+    "1652": "Compra de combustível ou lubrificante para comercialização",
+    "1653": "Compra de combustível ou lubrificante por consumidor ou usuário final",
+    "1658": "Transferência de combustível ou lubrificante recebido para industrialização subsequente",
+    "1659": "Transferência de combustível ou lubrificante recebido para comercialização",
+    "1660": "Saída de combustível ou lubrificante, de produção do estabelecimento",
+    "1661": "Saída de combustível ou lubrificante adquirido ou recebido de terceiros",
+    
+    "5101": "Venda de produção do estabelecimento",
+    "5102": "Venda de mercadoria adquirida ou recebida de terceiros",
+    "5103": "Venda de produção do estabelecimento, efetuada fora do estabelecimento",
+    "5104": "Venda de mercadoria adquirida ou recebida de terceiros, efetuada fora do estabelecimento",
+    "5105": "Venda de produção do estabelecimento que não deva por ele transitar",
+    "5106": "Venda de mercadoria adquirida ou recebida de terceiros, que não deva por ele transitar",
+    "5109": "Venda de produção do estabelecimento, destinada à Zona Franca de Manaus ou Áreas de Livre Comércio",
+    "5110": "Venda de mercadoria, adquirida ou recebida de terceiros, destinada à Zona Franca de Manaus ou Áreas de Livre Comércio",
+    "5111": "Venda de produção do estabelecimento remetida anteriormente em consignação industrial",
+    "5113": "Venda de mercadoria adquirida ou recebida de terceiros, remetida anteriormente em consignação mercantil",
+    "5116": "Venda de produção do estabelecimento originada de encomenda para entrega futura",
+    "5117": "Venda de mercadoria adquirida ou recebida de terceiros, originada de encomenda para entrega futura",
+    "5122": "Venda de energia elétrica no mercado interno",
+    "5124": "Industrialização efetuada para outra empresa",
+    "5125": "Industrialização efetuada para outra empresa quando a mercadoria recebida para utilização no processo de industrialização não transitar pelo estabelecimento adquirente da mercadoria",
+    "5151": "Transferência de produção do estabelecimento",
+    "5152": "Transferência de mercadoria adquirida ou recebida de terceiros",
+    "5201": "Devolução de compra para industrialização ou produção rural",
+    "5202": "Devolução de compra para comercialização",
+    "5401": "Venda de produção do estabelecimento em operação com produto sujeito ao regime de ST, como contribuinte substituto",
+    "5403": "Venda de mercadoria adquirida ou recebida de terceiros em operação com mercadoria sujeita ao regime de ST, como contribuinte substituto",
+    "5405": "Venda de mercadoria adquirida ou recebida de terceiros em operação com mercadoria sujeita ao regime de ST, como contribuinte substituído",
+    "5501": "Remessa de produção do estabelecimento, com fim específico de exportação",
+    "5503": "Remessa de mercadoria adquirida ou recebida de terceiros, com fim específico de exportação",
+    "5556": "Transferência de material para uso ou consumo",
+    "5601": "Transferência de saldo credor do ICMS para outro estabelecimento da mesma empresa, destinado à compensação de saldo devedor de ICMS",
+    "5602": "Transferência de saldo devedor de ICMS para outro estabelecimento da mesma empresa",
+    "5605": "Transferência de saldo credor de IPI para outro estabelecimento da mesma empresa, destinado à compensação de saldo devedor de IPI",
+    "5651": "Venda de combustível ou lubrificante de produção do estabelecimento destinados ao processo de industrialização",
+    "5652": "Venda de combustível ou lubrificante de produção do estabelecimento destinados à comercialização",
+    "5653": "Venda de combustível ou lubrificante de produção do estabelecimento destinados a consumidor ou usuário final",
+    # Saídas interestaduais
+    "6101": "Venda de produção do estabelecimento",
+    "6102": "Venda de mercadoria adquirida ou recebida de terceiros",
+    "6107": "Venda de produção do estabelecimento, destinada a não contribuinte",
+    "6108": "Venda de mercadoria adquirida ou recebida de terceiros, destinada a não contribuinte",
+    "6151": "Transferência de produção do estabelecimento",
+    "6152": "Transferência de mercadoria adquirida ou recebida de terceiros",
+    "6201": "Devolução de compra para industrialização ou produção rural",
+    "6202": "Devolução de compra para comercialização",
+}
+
+
+COD_PAISES: dict[str, str] = {
+    "1058": "BRASIL",
+    "0249": "ESTADOS UNIDOS DA AMERICA",
+    "0230": "ESPANHA",
+    "0232": "FRANCA",
+    "0276": "ALEMANHA",
+    "0040": "ARGENTINA",
+    "0119": "CHILE",
+    "0175": "COLOMBIA",
+    "0715": "REINO UNIDO",
+    "0538": "JAPAO",
+    "0628": "MEXICO",
+    "0765": "RUSSIA",
+    "0770": "SUECIA",
+    "0105": "CANADA",
+    "5760": "CHINA",
+    "0399": "ITALIA",
+    "0423": "HOLANDA",
+    "0773": "SUICA",
+    "0315": "INDIA",
+}
+
+
+CALENDARIO_OBRIGACOES: dict[str, list[str]] = {
+    "DCTF": ["Mensal - até o 15º dia útil do 2º mês subsequente"],
+    "EFD_ICMS_IPI": ["Mensal - até o 15º dia útil do mês subsequente"],
+    "EFD_CONTRIBUICOES": ["Mensal - até o 10º dia útil do 2º mês subsequente"],
+    "ECD": ["Anual - até o último dia útil de junho do ano seguinte"],
+    "ECF": ["Anual - até o último dia útil de julho do ano seguinte"],
+    "ESOCIAL": ["Mensal - folha até o dia 7 do mês seguinte"],
+    "EFD_REINF": ["Mensal - até o dia 15 do mês seguinte"],
+    "DEFIS": ["Anual - Simples Nacional - até 31 de março"],
+    "PGDAS": ["Mensal - Simples Nacional - até o dia 20"],
+    "DARF_PIS": ["Mensal - até o 25º dia do mês subsequente"],
+    "DARF_COFINS": ["Mensal - até o 25º dia do mês subsequente"],
+    "DARF_IRPJ_LP": ["Mensal - DARF estimativa até o último dia útil do mês subsequente"],
+    "DARF_CSLL_LP": ["Mensal - DARF estimativa até o último dia útil do mês subsequente"],
+    "DARF_IRPJ_LT": ["Trimestral - até o último dia útil do mês subsequente ao trimestre"],
+    "DARF_CSLL_LT": ["Trimestral - até o último dia útil do mês subsequente ao trimestre"],
+}
+
+
+COD_RECEITA_DARF: dict[str, str] = {
+    "6912": "IRPJ - Lucro Real - Estimativa Mensal",
+    "2362": "IRPJ - Lucro Real - Apuração Trimestral",
+    "2089": "IRPJ - Lucro Presumido - Apuração Trimestral",
+    "2372": "CSLL - Lucro Real - Estimativa Mensal",
+    "6773": "CSLL - Lucro Presumido - Apuração Trimestral",
+    "2484": "CSLL - Lucro Real - Apuração Trimestral",
+    "8109": "PIS/PASEP - Faturamento - Não-cumulativo",
+    "7987": "PIS/PASEP - Faturamento - Cumulativo",
+    "2172": "COFINS - Faturamento - Não-cumulativa",
+    "5856": "COFINS - Faturamento - Cumulativa",
+    "5253": "IPI - Geral",
+    "1038": "IRRF - Rendimentos do Trabalho",
+    "0561": "IRRF - Serviços Prestados por PJ",
+}

src/fiscal/entities.py

@@ -0,0 +1,286 @@
+
+from __future__ import annotations
+
+import re
+from datetime import date
+from decimal import Decimal
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class RegimeTributario(str, Enum):
+    LUCRO_REAL = "1"
+    LUCRO_PRESUMIDO = "2"
+    SIMPLES_NACIONAL = "3"
+    ARBITRADO = "4"
+    IMUNE = "5"
+    OPTANTE_SIMPLES = "6"
+    LUCRO_REAL_TRIMESTRAL = "7"
+
+
+class TipoEmpresa(str, Enum):
+    INDUSTRIA = "industria"
+    COMERCIO = "comercio"
+    SERVICOS = "servicos"
+    MISTO = "misto"
+
+
+class PerfilSPED(str, Enum):
+    A = "A"  # Escrituração completa
+    B = "B"  # Escrituração com dados simplificados
+    C = "C"  # Escrituração com dados simplificados (ME/EPP Simples)
+
+
+class UF(str, Enum):
+    AC = "AC"; AL = "AL"; AP = "AP"; AM = "AM"
+    BA = "BA"; CE = "CE"; DF = "DF"; ES = "ES"
+    GO = "GO"; MA = "MA"; MT = "MT"; MS = "MS"
+    MG = "MG"; PA = "PA"; PB = "PB"; PR = "PR"
+    PE = "PE"; PI = "PI"; RJ = "RJ"; RN = "RN"
+    RS = "RS"; RO = "RO"; RR = "RR"; SC = "SC"
+    SP = "SP"; SE = "SE"; TO = "TO"
+
+
+def _limpar_cnpj(cnpj: str) -> str:
+    return re.sub(r"\D", "", cnpj)
+
+
+def _validar_cnpj(cnpj: str) -> bool:
+    d = _limpar_cnpj(cnpj)
+    if len(d) != 14 or d == d[0] * 14:
+        return False
+    for i, j in [(12, 13), (13, 14)]:
+        s = sum(int(d[k]) * ((i - k - 1) % 8 + 2) for k in range(i))
+        c = 0 if (r := s % 11) < 2 else 11 - r
+        if c != int(d[j - 1]):
+            return False
+    return True
+
+
+def _validar_cpf(cpf: str) -> bool:
+    d = re.sub(r"\D", "", cpf)
+    if len(d) != 11 or d == d[0] * 11:
+        return False
+    for i in range(9, 11):
+        s = sum(int(d[k]) * (i + 1 - k) for k in range(i))
+        if (0 if (r := (s * 10 % 11)) >= 10 else r) != int(d[i]):
+            return False
+    return True
+
+
+class Endereco(BaseModel):
+    logradouro: str
+    numero: str
+    complemento: str = ""
+    bairro: str
+    municipio: str
+    uf: UF
+    cep: str
+    cod_municipio: str = ""
+
+    @field_validator("cep")
+    @classmethod
+    def normalizar_cep(cls, v: str) -> str:
+        return re.sub(r"\D", "", v).zfill(8)
+
+
+class Contato(BaseModel):
+    nome: str = ""
+    telefone: str = ""
+    fax: str = ""
+    email: str = ""
+
+
+class Empresa(BaseModel):
+    cnpj: str
+    razao_social: str
+    nome_fantasia: str = ""
+    ie: str = ""
+    im: str = ""
+    suframa: str = ""
+    regime_tributario: RegimeTributario
+    tipo_empresa: TipoEmpresa
+    endereco: Endereco
+    contato: Contato = Field(default_factory=Contato)
+    perfil_sped: PerfilSPED = PerfilSPED.A
+    atividade_industrial: bool = False
+    data_inicio_atividade: Optional[date] = None
+
+    @field_validator("cnpj")
+    @classmethod
+    def validar_cnpj(cls, v: str) -> str:
+        d = _limpar_cnpj(v)
+        if not _validar_cnpj(d):
+            raise ValueError(f"CNPJ inválido: {v}")
+        return d
+
+    @property
+    def cnpj_formatado(self) -> str:
+        d = self.cnpj
+        return f"{d[:2]}.{d[2:5]}.{d[5:8]}/{d[8:12]}-{d[12:]}"
+
+
+class Contador(BaseModel):
+    nome: str
+    cpf: str
+    crc: str
+    cnpj_escritorio: str = ""
+    endereco: Optional[Endereco] = None
+    contato: Contato = Field(default_factory=Contato)
+
+    @field_validator("cpf")
+    @classmethod
+    def validar_cpf(cls, v: str) -> str:
+        d = re.sub(r"\D", "", v)
+        if not _validar_cpf(d):
+            raise ValueError(f"CPF inválido: {v}")
+        return d
+
+
+class Produto(BaseModel):
+    codigo: str
+    descricao: str
+    ncm: str
+    ex_ipi: str = ""
+    unidade: str
+    tipo_item: str = "00"
+    cod_gen: str = ""
+    aliq_icms: Decimal = Decimal("0")
+    aliq_ipi: Decimal = Decimal("0")
+    cst_icms: str = "000"
+    cst_ipi: str = "50"
+    cst_pis: str = "01"
+    cst_cofins: str = "01"
+    cest: str = ""
+    cod_barras: str = ""
+    peso_bruto: Decimal = Decimal("0")
+    peso_liquido: Decimal = Decimal("0")
+
+
+class ItemNotaFiscal(BaseModel):
+    numero_item: int
+    produto: Produto
+    cfop: str
+    quantidade: Decimal
+    valor_unitario: Decimal
+    desconto: Decimal = Decimal("0")
+    outras_despesas: Decimal = Decimal("0")
+    frete: Decimal = Decimal("0")
+    seguro: Decimal = Decimal("0")
+
+    @property
+    def valor_produtos(self) -> Decimal:
+        return (self.quantidade * self.valor_unitario) - self.desconto
+
+    @property
+    def base_icms(self) -> Decimal:
+        return self.valor_produtos + self.frete + self.seguro + self.outras_despesas
+
+    @property
+    def valor_icms(self) -> Decimal:
+        return (self.base_icms * self.produto.aliq_icms / 100).quantize(Decimal("0.01"))
+
+    @property
+    def base_ipi(self) -> Decimal:
+        return self.valor_produtos
+
+    @property
+    def valor_ipi(self) -> Decimal:
+        return (self.base_ipi * self.produto.aliq_ipi / 100).quantize(Decimal("0.01"))
+
+    @property
+    def valor_total(self) -> Decimal:
+        return self.valor_produtos + self.valor_ipi + self.frete + self.seguro + self.outras_despesas
+
+
+class NotaFiscal(BaseModel):
+    numero: str
+    serie: str
+    modelo: str = "55"
+    data_emissao: date
+    data_saida_entrada: date
+    hora_saida_entrada: str = "00:00:00"
+    emitente: Empresa
+    destinatario: Empresa
+    natureza_operacao: str
+    tipo_operacao: str = "1"
+    ind_pagamento: str = "0"
+    chave_acesso: str = ""
+    protocolo: str = ""
+    itens: list[ItemNotaFiscal] = Field(default_factory=list)
+    info_complementar: str = ""
+
+    @property
+    def valor_produtos(self) -> Decimal:
+        return sum(i.valor_produtos for i in self.itens)
+
+    @property
+    def valor_frete(self) -> Decimal:
+        return sum(i.frete for i in self.itens)
+
+    @property
+    def valor_seguro(self) -> Decimal:
+        return sum(i.seguro for i in self.itens)
+
+    @property
+    def valor_desconto(self) -> Decimal:
+        return sum(i.desconto for i in self.itens)
+
+    @property
+    def valor_outras_despesas(self) -> Decimal:
+        return sum(i.outras_despesas for i in self.itens)
+
+    @property
+    def valor_icms(self) -> Decimal:
+        return sum(i.valor_icms for i in self.itens)
+
+    @property
+    def valor_ipi(self) -> Decimal:
+        return sum(i.valor_ipi for i in self.itens)
+
+    @property
+    def valor_total(self) -> Decimal:
+        return sum(i.valor_total for i in self.itens)
+
+
+class LancamentoContabil(BaseModel):
+    data: date
+    numero_lancamento: str
+    historico: str
+    debito_conta: str
+    credito_conta: str
+    valor: Decimal
+    complemento: str = ""
+
+
+class MovimentacaoEstoque(BaseModel):
+    data: date
+    produto: Produto
+    tipo_movimento: str
+    quantidade: Decimal
+    valor_unitario: Decimal
+    documento: str = ""
+
+    @property
+    def valor_total(self) -> Decimal:
+        return self.quantidade * self.valor_unitario
+
+
+class PeriodoApuracao(BaseModel):
+    data_inicio: date
+    data_fim: date
+    empresa: Empresa
+    notas_saida: list[NotaFiscal] = Field(default_factory=list)
+    notas_entrada: list[NotaFiscal] = Field(default_factory=list)
+    lancamentos: list[LancamentoContabil] = Field(default_factory=list)
+    movimentacoes: list[MovimentacaoEstoque] = Field(default_factory=list)
+
+    @property
+    def total_vendas(self) -> Decimal:
+        return sum(nf.valor_total for nf in self.notas_saida)
+
+    @property
+    def total_compras(self) -> Decimal:
+        return sum(nf.valor_total for nf in self.notas_entrada)

src/generators/cte.py

@@ -0,0 +1,334 @@
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from decimal import Decimal
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from src.fiscal.entities import Empresa
+
+NS_CTE = "http://www.portalfiscal.inf.br/cte"
+VERSAO_CTE = "4.00"
+
+
+def _sub(pai: ET.Element, tag: str, texto: str = "") -> ET.Element:
+    el = ET.SubElement(pai, tag)
+    if texto:
+        el.text = str(texto)
+    return el
+
+
+def _fmt_dec(v: Decimal, casas: int = 2) -> str:
+    return f"{v:.{casas}f}"
+
+
+def _limpar(s: str) -> str:
+    return re.sub(r"[^\w\s\-.,/@]", "", str(s))[:60]
+
+
+# ---------------------------------------------------------------------------
+# Dataclasses auxiliares
+# ---------------------------------------------------------------------------
+
+@dataclass
+class CargaCTe:
+    descricao: str
+    produto: str          # código produto predominante
+    valor_carga: Decimal
+    peso_kg: Decimal = field(default_factory=lambda: Decimal("0"))
+    volume_m3: Decimal = field(default_factory=lambda: Decimal("0"))
+
+
+@dataclass
+class DocumentoReferenciado:
+    chave_nfe: str        # chave NF-e 44 dígitos
+
+
+@dataclass
+class DadosTransporte:
+    rntrc: str            # Registro Nacional de Transportadores Rodoviários de Cargas
+    placa_veiculo: str
+    uf_veiculo: str
+    data_prevista_entrega: date
+
+
+@dataclass
+class ParteCTe:           # remetente, destinatário, etc.
+    cnpj: str
+    razao_social: str
+    endereco: str
+    municipio: str
+    uf: str
+    cep: str
+    cod_municipio: str
+
+
+# ---------------------------------------------------------------------------
+# Gerador principal
+# ---------------------------------------------------------------------------
+
+class GeradorCTe:
+    """
+    Gera o XML de CT-e conforme o leiaute 4.00 da SEFAZ.
+
+    O XML gerado deve ser assinado digitalmente com certificado ICP-Brasil
+    antes da transmissão.
+    """
+
+    VERSAO = "4.00"
+    MOD = "57"
+
+    _CUF_MAP = {
+        "AC": "12", "AL": "27", "AP": "16", "AM": "13", "BA": "29",
+        "CE": "23", "DF": "53", "ES": "32", "GO": "52", "MA": "21",
+        "MT": "51", "MS": "50", "MG": "31", "PA": "15", "PB": "25",
+        "PR": "41", "PE": "26", "PI": "22", "RJ": "33", "RN": "24",
+        "RS": "43", "RO": "11", "RR": "14", "SC": "42", "SP": "35",
+        "SE": "28", "TO": "17",
+    }
+
+    def __init__(
+        self,
+        emitente: Empresa,
+        remetente: ParteCTe,
+        destinatario: ParteCTe,
+        carga: CargaCTe,
+        documentos: list[DocumentoReferenciado],
+        transporte: DadosTransporte,
+        numero: str = "1",
+        serie: str = "001",
+        cfop: str = "6352",
+        natureza_operacao: str = "PRESTAÇÃO DE SERVIÇO DE TRANSPORTE",
+        aliq_icms: Decimal = Decimal("12"),
+        ambiente: str = "2",
+    ):
+        self.emitente = emitente
+        self.remetente = remetente
+        self.destinatario = destinatario
+        self.carga = carga
+        self.documentos = documentos
+        self.transporte = transporte
+        self.numero = numero
+        self.serie = serie
+        self.cfop = cfop
+        self.natureza_operacao = natureza_operacao
+        self.aliq_icms = aliq_icms
+        self.ambiente = ambiente  # 1=Produção, 2=Homologação
+        self._data_emissao: date = date.today()
+
+    # ------------------------------------------------------------------
+    # Utilitários internos
+    # ------------------------------------------------------------------
+
+    def _cuf(self, uf: str) -> str:
+        return self._CUF_MAP.get(uf.upper(), "35")
+
+    def _gerar_chave(self) -> str:
+        """
+        Gera a chave de acesso de 44 dígitos do CT-e.
+        Estrutura: cUF(2) + AAMM(4) + CNPJ(14) + mod(2=57) + serie(3) +
+                   nCT(9) + tpEmis(1) + cCT(8) + cDV(1)
+        """
+        uf = self._cuf(self.emitente.endereco.uf.value)
+        aamm = self._data_emissao.strftime("%y%m")
+        cnpj = self.emitente.cnpj.zfill(14)
+        mod = self.MOD.zfill(2)
+        serie = self.serie.zfill(3)
+        numero = self.numero.zfill(9)
+        tp_emis = "1"
+        c_ct = hashlib.md5(f"{cnpj}{numero}".encode()).hexdigest()[:8].upper()
+        c_ct_digits = "".join(str(int(c, 16) % 10) for c in c_ct)[:8]
+
+        chave_sem_dv = f"{uf}{aamm}{cnpj}{mod}{serie}{numero}{tp_emis}{c_ct_digits}"
+
+        
+        pesos = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4,
+                 5, 6, 7, 8, 9, 2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4]
+        soma = sum(int(chave_sem_dv[i]) * pesos[i] for i in range(43))
+        resto = soma % 11
+        dv = 0 if resto in (0, 1) else 11 - resto
+
+        return chave_sem_dv + str(dv)
+
+    def _fmt_dhemi(self) -> str:
+        return (
+            datetime.combine(self._data_emissao, datetime.min.time())
+            .strftime("%Y-%m-%dT%H:%M:%S") + "-03:00"
+        )
+
+    # ------------------------------------------------------------------
+    # Blocos XML
+    # ------------------------------------------------------------------
+
+    def _ide(self, inf_cte: ET.Element, chave: str) -> None:
+        emit_uf = self.emitente.endereco.uf.value
+        cuf = self._cuf(emit_uf)
+        ide = _sub(inf_cte, "ide")
+        _sub(ide, "cUF", cuf)
+        _sub(ide, "cCT", chave[35:43])
+        _sub(ide, "CFOP", self.cfop)
+        _sub(ide, "natOp", _limpar(self.natureza_operacao))
+        _sub(ide, "mod", self.MOD)
+        _sub(ide, "serie", self.serie.zfill(3))
+        _sub(ide, "nCT", self.numero.zfill(9))
+        _sub(ide, "dhEmi", self._fmt_dhemi())
+        _sub(ide, "tpImp", "1")     # 1=DACTE normal retrato
+        _sub(ide, "tpEmis", "1")    # 1=Emissão normal
+        _sub(ide, "cDV", chave[-1])
+        _sub(ide, "tpAmb", self.ambiente)
+        _sub(ide, "tpCT", "0")      # 0=CT-e normal
+        _sub(ide, "tpServ", "0")    # 0=Normal
+        cod_mun_emit = self.emitente.endereco.cod_municipio or "3550308"
+        _sub(ide, "cMunEnv", cod_mun_emit)
+        _sub(ide, "xMunEnv", _limpar(self.emitente.endereco.municipio))
+        _sub(ide, "UFEnv", emit_uf)
+        _sub(ide, "modal", "01")    # 01=Rodoviário
+        _sub(ide, "dhSaidaOrig", self._fmt_dhemi())
+        _sub(ide, "tpMultimodal", "0")
+        _sub(ide, "UFIni", self.remetente.uf)
+        _sub(ide, "UFFim", self.destinatario.uf)
+
+    def _compl(self, inf_cte: ET.Element) -> None:
+        compl = _sub(inf_cte, "compl")
+        _sub(compl, "xObs", _limpar(self.carga.descricao)[:160] if self.carga.descricao else "")
+
+    def _emit(self, inf_cte: ET.Element) -> None:
+        emp = self.emitente
+        end = emp.endereco
+        emit = _sub(inf_cte, "emit")
+        _sub(emit, "CNPJ", emp.cnpj)
+        if emp.ie:
+            _sub(emit, "IE", re.sub(r"\D", "", emp.ie))
+        _sub(emit, "xNome", _limpar(emp.razao_social)[:60])
+        if emp.nome_fantasia:
+            _sub(emit, "xFant", _limpar(emp.nome_fantasia)[:60])
+        ender_emit = _sub(emit, "enderEmit")
+        _sub(ender_emit, "xLgr", _limpar(end.logradouro))
+        _sub(ender_emit, "nro", end.numero)
+        if end.complemento:
+            _sub(ender_emit, "xCpl", _limpar(end.complemento))
+        _sub(ender_emit, "xBairro", _limpar(end.bairro))
+        _sub(ender_emit, "cMun", end.cod_municipio or "3550308")
+        _sub(ender_emit, "xMun", _limpar(end.municipio))
+        _sub(ender_emit, "CEP", re.sub(r"\D", "", end.cep))
+        _sub(ender_emit, "UF", end.uf.value)
+        _sub(ender_emit, "cPais", "1058")
+        _sub(ender_emit, "xPais", "Brasil")
+        if emp.contato.telefone:
+            _sub(emit, "fone", re.sub(r"\D", "", emp.contato.telefone))
+
+    def _parte(self, inf_cte: ET.Element, tag: str, ender_tag: str, parte: ParteCTe) -> None:
+        el = _sub(inf_cte, tag)
+        _sub(el, "CNPJ", re.sub(r"\D", "", parte.cnpj).zfill(14))
+        _sub(el, "xNome", _limpar(parte.razao_social)[:60])
+        ender = _sub(el, ender_tag)
+        _sub(ender, "xLgr", _limpar(parte.endereco))
+        _sub(ender, "nro", "S/N")
+        _sub(ender, "xBairro", "CENTRO")
+        _sub(ender, "cMun", parte.cod_municipio)
+        _sub(ender, "xMun", _limpar(parte.municipio))
+        _sub(ender, "CEP", re.sub(r"\D", "", parte.cep).zfill(8))
+        _sub(ender, "UF", parte.uf)
+        _sub(ender, "cPais", "1058")
+        _sub(ender, "xPais", "Brasil")
+
+    def _v_prest(self, inf_cte: ET.Element) -> None:
+        v_prest = _sub(inf_cte, "vPrest")
+        _sub(v_prest, "vTPrest", _fmt_dec(self.carga.valor_carga))
+        _sub(v_prest, "vRec", _fmt_dec(self.carga.valor_carga))
+
+    def _imp(self, inf_cte: ET.Element) -> None:
+        imp = _sub(inf_cte, "imp")
+        icms = _sub(imp, "ICMS")
+        icms00 = _sub(icms, "ICMS00")
+        _sub(icms00, "CST", "00")
+        v_bc = self.carga.valor_carga
+        v_icms = (v_bc * self.aliq_icms / Decimal("100")).quantize(Decimal("0.01"))
+        _sub(icms00, "vBC", _fmt_dec(v_bc))
+        _sub(icms00, "pICMS", _fmt_dec(self.aliq_icms, 4))
+        _sub(icms00, "vICMS", _fmt_dec(v_icms))
+
+    def _inf_cte_norm(self, inf_cte: ET.Element) -> None:
+        inf_cte_norm = _sub(inf_cte, "infCTeNorm")
+
+        
+        inf_carga = _sub(inf_cte_norm, "infCarga")
+        _sub(inf_carga, "vCarga", _fmt_dec(self.carga.valor_carga))
+        _sub(inf_carga, "proPred", _limpar(self.carga.produto)[:60])
+        inf_q = _sub(inf_carga, "infQ")
+        _sub(inf_q, "cUnid", "01")          # 01=KG
+        _sub(inf_q, "tpMed", "PESO BRUTO")
+        _sub(inf_q, "qCarga", _fmt_dec(self.carga.peso_kg, 4))
+
+        
+        if self.documentos:
+            inf_doc = _sub(inf_cte_norm, "infDoc")
+            for doc in self.documentos:
+                inf_nfe = _sub(inf_doc, "infNFe")
+                _sub(inf_nfe, "chave", doc.chave_nfe)
+                _sub(inf_nfe, "pin", "")
+
+        
+        inf_modal = _sub(inf_cte_norm, "infModal")
+        inf_modal.set("versaoModal", "3.00")
+        rodo = _sub(inf_modal, "rodo")
+        _sub(rodo, "RNTRC", self.transporte.rntrc)
+        veic = _sub(rodo, "veicTracao")
+        _sub(veic, "placa", self.transporte.placa_veiculo.upper())
+        _sub(veic, "UF", self.transporte.uf_veiculo.upper())
+        _sub(veic, "prop")  # tag vazia
+        occ = _sub(rodo, "occ")
+        _sub(occ, "serie", "001")
+        _sub(occ, "nOcc", "1")
+        _sub(occ, "dEmi", self._data_emissao.strftime("%Y-%m-%d"))
+        emi_occ = _sub(occ, "emiOcc")
+        _sub(emi_occ, "CNPJ", self.emitente.cnpj)
+        _sub(emi_occ, "xNome", _limpar(self.emitente.razao_social)[:60])
+        _sub(emi_occ, "cInt", "")
+        _sub(emi_occ, "IE", "")
+
+    # ------------------------------------------------------------------
+    # API pública
+    # ------------------------------------------------------------------
+
+    def gerar_xml(self) -> str:
+        """Retorna o XML do CT-e não assinado como string."""
+        chave = self._gerar_chave()
+
+        cte_proc = ET.Element("cteProc")
+        cte_proc.set("xmlns", NS_CTE)
+        cte_proc.set("versao", self.VERSAO)
+
+        cte = _sub(cte_proc, "CTe")
+        cte.set("xmlns", NS_CTE)
+
+        inf_cte = _sub(cte, "infCte")
+        inf_cte.set("versao", self.VERSAO)
+        inf_cte.set("Id", f"CTe{chave}")
+
+        self._ide(inf_cte, chave)
+        self._compl(inf_cte)
+        self._emit(inf_cte)
+        self._parte(inf_cte, "rem", "enderReme", self.remetente)
+        self._parte(inf_cte, "dest", "enderDest", self.destinatario)
+        self._v_prest(inf_cte)
+        self._imp(inf_cte)
+        self._inf_cte_norm(inf_cte)
+
+        
+        _sub(cte, "Signature")
+
+        ET.indent(cte_proc, space="  ")
+        return '<?xml version="1.0" encoding="UTF-8"?>\n' + ET.tostring(cte_proc, encoding="unicode")
+
+    def salvar(self, diretorio: str | Path = ".") -> Path:
+        """Salva o XML em diretório informado e retorna o caminho do arquivo."""
+        cnpj = self.emitente.cnpj
+        caminho = Path(diretorio) / f"CTe_{cnpj}_{self.numero.zfill(9)}.xml"
+        caminho.parent.mkdir(parents=True, exist_ok=True)
+        caminho.write_text(self.gerar_xml(), encoding="utf-8")
+        return caminho

src/generators/dctf.py

@@ -0,0 +1,271 @@
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from typing import Optional
+from xml.etree import ElementTree as ET
+
+from src.fiscal.constants import COD_RECEITA_DARF
+from src.fiscal.entities import Empresa
+
+
+def _sub(pai: ET.Element, tag: str, texto: str = "") -> ET.Element:
+    el = ET.SubElement(pai, tag)
+    if texto:
+        el.text = str(texto)
+    return el
+
+
+def _fmt_dec(v: Decimal) -> str:
+    return f"{v:.2f}"
+
+
+@dataclass
+class DebitoDCTF:
+    """Representa um débito tributário na DCTF."""
+    codigo_receita: str
+    periodo_apuracao: str       # YYYY-MM ou YYYY-TT (trimestre)
+    valor_debito: Decimal
+    valor_suspenso: Decimal = Decimal("0")
+    numero_processo: str = ""
+    tipo_suspensao: str = ""    # "D"=Decisão Judicial, "A"=Administrativo
+
+
+@dataclass
+class PagamentoDCTF:
+    """Pagamento (DARF) vinculado a um débito."""
+    numero_darf: str
+    data_pagamento: date
+    valor_principal: Decimal
+    valor_multa: Decimal = Decimal("0")
+    valor_juros: Decimal = Decimal("0")
+
+    @property
+    def valor_total(self) -> Decimal:
+        return self.valor_principal + self.valor_multa + self.valor_juros
+
+
+@dataclass
+class CompensacaoDCTF:
+    """Compensação de crédito vinculada a um débito."""
+    numero_per_comp: str        # Número do PER/COMP
+    data_transmissao: date
+    valor_compensado: Decimal
+    codigo_receita_credito: str
+
+
+@dataclass
+class ItemDCTF:
+    """Item de débito com seus pagamentos e compensações."""
+    debito: DebitoDCTF
+    pagamentos: list[PagamentoDCTF] = field(default_factory=list)
+    compensacoes: list[CompensacaoDCTF] = field(default_factory=list)
+
+    @property
+    def total_pago(self) -> Decimal:
+        return sum(p.valor_total for p in self.pagamentos)
+
+    @property
+    def total_compensado(self) -> Decimal:
+        return sum(c.valor_compensado for c in self.compensacoes)
+
+    @property
+    def saldo_a_pagar(self) -> Decimal:
+        return max(
+            Decimal("0"),
+            self.debito.valor_debito - self.debito.valor_suspenso
+            - self.total_pago - self.total_compensado,
+        )
+
+
+@dataclass
+class ConfigDCTF:
+    finalidade: str = "0"       # 0=Original, 1=Retificadora
+    situacao_especial: str = "" # Em branco=sem situação especial
+    declarante_pj_inativa: bool = False
+
+
+class GeradorDCTF:
+    """
+    Gera o arquivo XML da DCTF para importação no PGD DCTF Web.
+
+    Periodicidade: mensal.
+    Prazo: 15º dia útil do 2º mês subsequente ao período de apuração.
+    Obrigação: pessoas jurídicas com débitos de tributos federais.
+    """
+
+    VERSAO = "1.0"
+
+    def __init__(
+        self,
+        empresa: Empresa,
+        periodo: str,   # "YYYY-MM"
+        itens: Optional[list[ItemDCTF]] = None,
+        cfg: Optional[ConfigDCTF] = None,
+    ):
+        self.empresa = empresa
+        self.periodo = periodo
+        self.itens = itens or []
+        self.cfg = cfg or ConfigDCTF()
+
+    def _resumo_por_codigo(self) -> dict[str, dict]:
+        resumo: dict[str, dict] = {}
+        for item in self.itens:
+            cod = item.debito.codigo_receita
+            if cod not in resumo:
+                resumo[cod] = {
+                    "debito": Decimal("0"),
+                    "suspenso": Decimal("0"),
+                    "pago": Decimal("0"),
+                    "compensado": Decimal("0"),
+                    "saldo": Decimal("0"),
+                    "nome": COD_RECEITA_DARF.get(cod, cod),
+                }
+            resumo[cod]["debito"] += item.debito.valor_debito
+            resumo[cod]["suspenso"] += item.debito.valor_suspenso
+            resumo[cod]["pago"] += item.total_pago
+            resumo[cod]["compensado"] += item.total_compensado
+            resumo[cod]["saldo"] += item.saldo_a_pagar
+        return resumo
+
+    def gerar_xml(self) -> str:
+        """Gera o XML da DCTF para importação no PGD DCTF Web."""
+        root = ET.Element("DCTF")
+        root.set("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
+        root.set("versao", self.VERSAO)
+        
+        ide = _sub(root, "ideDeclarante")
+        _sub(ide, "CNPJ", self.empresa.cnpj)
+        _sub(ide, "nome", self.empresa.razao_social[:100])
+        _sub(ide, "perApuracao", self.periodo)
+        _sub(ide, "dtInicio", f"{self.periodo}-01")
+        _sub(ide, "dtFim", f"{self.periodo}-{self._ultimo_dia()}")
+        _sub(ide, "situacaoEspecial", self.cfg.situacao_especial)
+        _sub(ide, "indDeclaranteInativo", "S" if self.cfg.declarante_pj_inativa else "N")
+        _sub(ide, "finalidade", self.cfg.finalidade)
+
+        
+        for item in self.itens:
+            deb_el = _sub(root, "debito")
+            _sub(deb_el, "codReceita", item.debito.codigo_receita)
+            _sub(deb_el, "perApuracao", item.debito.periodo_apuracao)
+            _sub(deb_el, "vlrDebito", _fmt_dec(item.debito.valor_debito))
+
+            if item.debito.valor_suspenso > 0:
+                susp = _sub(deb_el, "suspensao")
+                _sub(susp, "tipoSuspensao", item.debito.tipo_suspensao or "D")
+                _sub(susp, "nrProcesso", item.debito.numero_processo)
+                _sub(susp, "vlrSuspenso", _fmt_dec(item.debito.valor_suspenso))
+
+            for pag in item.pagamentos:
+                pag_el = _sub(deb_el, "pagamento")
+                _sub(pag_el, "nrDarf", pag.numero_darf)
+                _sub(pag_el, "dtPagamento", pag.data_pagamento.strftime("%Y-%m-%d"))
+                _sub(pag_el, "vlrPrincipal", _fmt_dec(pag.valor_principal))
+                _sub(pag_el, "vlrMulta", _fmt_dec(pag.valor_multa))
+                _sub(pag_el, "vlrJuros", _fmt_dec(pag.valor_juros))
+                _sub(pag_el, "vlrTotal", _fmt_dec(pag.valor_total))
+
+            for comp in item.compensacoes:
+                comp_el = _sub(deb_el, "compensacao")
+                _sub(comp_el, "nrPERCOMP", comp.numero_per_comp)
+                _sub(comp_el, "dtTransmissao", comp.data_transmissao.strftime("%Y-%m-%d"))
+                _sub(comp_el, "vlrCompensado", _fmt_dec(comp.valor_compensado))
+                _sub(comp_el, "codReceitaCredito", comp.codigo_receita_credito)
+
+            _sub(deb_el, "vlrSaldoPagar", _fmt_dec(item.saldo_a_pagar))
+
+        
+        resumo = self._resumo_por_codigo()
+        total_el = _sub(root, "totalDebitos")
+        _sub(total_el, "vlrTotalDebitos", _fmt_dec(sum(r["debito"] for r in resumo.values())))
+        _sub(total_el, "vlrTotalSuspenso", _fmt_dec(sum(r["suspenso"] for r in resumo.values())))
+        _sub(total_el, "vlrTotalPago", _fmt_dec(sum(r["pago"] for r in resumo.values())))
+        _sub(total_el, "vlrTotalCompensado", _fmt_dec(sum(r["compensado"] for r in resumo.values())))
+        _sub(total_el, "vlrTotalSaldo", _fmt_dec(sum(r["saldo"] for r in resumo.values())))
+
+        ET.indent(root, space="  ")
+        return '<?xml version="1.0" encoding="UTF-8"?>\n' + ET.tostring(root, encoding="unicode")
+
+    def _ultimo_dia(self) -> str:
+        ano, mes = map(int, self.periodo.split("-"))
+        if mes == 12:
+            return "31"
+        ultimo = (date(ano, mes + 1, 1) - date(ano, mes, 1)).days
+        return str(ultimo).zfill(2)
+
+    def salvar(self, diretorio: str | Path = ".") -> Path:
+        caminho = Path(diretorio) / f"DCTF_{self.empresa.cnpj}_{self.periodo}.xml"
+        caminho.parent.mkdir(parents=True, exist_ok=True)
+        caminho.write_text(self.gerar_xml(), encoding="utf-8")
+        return caminho
+
+    def relatorio_resumo(self) -> str:
+        resumo = self._resumo_por_codigo()
+        linhas = [
+            f"DCTF — {self.empresa.razao_social} — Período: {self.periodo}",
+            "=" * 70,
+        ]
+        total_geral = Decimal("0")
+        for cod, dados in resumo.items():
+            linhas.append(
+                f"{cod} — {dados['nome']}"
+            )
+            linhas.append(f"  Débito:      R$ {dados['debito']:>12,.2f}")
+            if dados["suspenso"] > 0:
+                linhas.append(f"  Suspenso:    R$ {dados['suspenso']:>12,.2f}")
+            if dados["pago"] > 0:
+                linhas.append(f"  Pago (DARF): R$ {dados['pago']:>12,.2f}")
+            if dados["compensado"] > 0:
+                linhas.append(f"  Compensado:  R$ {dados['compensado']:>12,.2f}")
+            linhas.append(f"  Saldo:       R$ {dados['saldo']:>12,.2f}")
+            total_geral += dados["saldo"]
+
+        linhas += [
+            "=" * 70,
+            f"TOTAL A PAGAR: R$ {total_geral:>12,.2f}",
+        ]
+        return "\n".join(linhas)
+
+
+def montar_dctf_do_periodo(
+    empresa: Empresa,
+    periodo: str,
+    valor_irpj: Decimal = Decimal("0"),
+    valor_csll: Decimal = Decimal("0"),
+    valor_pis: Decimal = Decimal("0"),
+    valor_cofins: Decimal = Decimal("0"),
+    valor_cpp: Decimal = Decimal("0"),
+    valor_irrf: Decimal = Decimal("0"),
+    darfs_pagos: Optional[list[PagamentoDCTF]] = None,
+) -> GeradorDCTF:
+    """
+    Função auxiliar: monta a DCTF automaticamente a partir dos valores apurados.
+    """
+    darfs_pagos = darfs_pagos or []
+    itens: list[ItemDCTF] = []
+
+    pares = [
+        ("6912", valor_irpj),
+        ("2484", valor_csll),
+        ("8109", valor_pis),
+        ("2172", valor_cofins),
+        ("2100", valor_cpp),
+        ("1038", valor_irrf),
+    ]
+
+    for cod, valor in pares:
+        if valor > 0:
+            itens.append(ItemDCTF(
+                debito=DebitoDCTF(
+                    codigo_receita=cod,
+                    periodo_apuracao=periodo,
+                    valor_debito=valor,
+                ),
+                pagamentos=[p for p in darfs_pagos],
+            ))
+
+    return GeradorDCTF(empresa=empresa, periodo=periodo, itens=itens)

src/generators/defis.py

@@ -0,0 +1,200 @@
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from src.fiscal.entities import Empresa
+
+
+def _sub(pai: ET.Element, tag: str, texto: str = "") -> ET.Element:
+    el = ET.SubElement(pai, tag)
+    if texto:
+        el.text = str(texto)
+    return el
+
+
+def _fmt_dec(v: Decimal) -> str:
+    return f"{v:.2f}"
+
+
+@dataclass
+class ReceitaMensalDEFIS:
+    mes: int                          # 1-12
+    receita_bruta_total: Decimal
+    receita_bruta_exportacao: Decimal = field(default_factory=lambda: Decimal("0"))
+    receita_bruta_isenta: Decimal = field(default_factory=lambda: Decimal("0"))
+
+
+@dataclass
+class SocioDEFIS:
+    cpf_cnpj: str
+    nome: str
+    percentual_capital: Decimal       # ex: Decimal("50.00") = 50%
+    tipo: str = "PF"                  # "PF" ou "PJ"
+    pais_domicilio: str = "105"       # 105=Brasil (código BACEN)
+
+
+@dataclass
+class EmpregadoDEFIS:
+    competencia: str                  # "YYYY-MM"
+    quantidade: int
+
+
+class GeradorDEFIS:
+    """
+    Gera o arquivo DEFIS para declaração anual do Simples Nacional.
+
+    Prazo: 31 de março do ano seguinte ao período de apuração.
+    """
+
+    VERSAO = "1.0"
+
+    def __init__(
+        self,
+        empresa: Empresa,
+        ano_calendario: int,
+        receitas_mensais: list[ReceitaMensalDEFIS],
+        socios: list[SocioDEFIS],
+        empregados: list[EmpregadoDEFIS] | None = None,
+        retificadora: bool = False,
+        numero_recibo_retificada: str = "",
+    ):
+        self.empresa = empresa
+        self.ano_calendario = ano_calendario
+        self.receitas_mensais = receitas_mensais
+        self.socios = socios
+        self.empregados = empregados or []
+        self.retificadora = retificadora
+        self.numero_recibo_retificada = numero_recibo_retificada
+
+    # ------------------------------------------------------------------
+    # Totais auxiliares
+    # ------------------------------------------------------------------
+
+    @property
+    def _total_receita(self) -> Decimal:
+        return sum(r.receita_bruta_total for r in self.receitas_mensais)
+
+    @property
+    def _total_exportacao(self) -> Decimal:
+        return sum(r.receita_bruta_exportacao for r in self.receitas_mensais)
+
+    @property
+    def _total_isenta(self) -> Decimal:
+        return sum(r.receita_bruta_isenta for r in self.receitas_mensais)
+
+    # ------------------------------------------------------------------
+    # Geração do XML
+    # ------------------------------------------------------------------
+
+    def gerar_xml(self) -> str:
+        """Gera o XML DEFIS para transmissão."""
+        root = ET.Element("DEFIS")
+        root.set("versao", self.VERSAO)
+
+        # Identificação do declarante
+        ide = _sub(root, "ideDeclarante")
+        _sub(ide, "CNPJ", self.empresa.cnpj)
+        _sub(ide, "anoCalendario", str(self.ano_calendario))
+        _sub(ide, "indRetificadora", "S" if self.retificadora else "N")
+        nrec = _sub(ide, "nrecRetificadora")
+        if self.retificadora and self.numero_recibo_retificada:
+            nrec.text = self.numero_recibo_retificada
+        _sub(ide, "dtInicio", f"{self.ano_calendario}-01-01")
+        _sub(ide, "dtFim", f"{self.ano_calendario}-12-31")
+
+        
+        inf = _sub(root, "infEmpresa")
+        _sub(inf, "xNome", self.empresa.razao_social[:150])
+        _sub(inf, "xFantasia", self.empresa.nome_fantasia[:60] if self.empresa.nome_fantasia else "")
+        _sub(inf, "fone", self.empresa.contato.telefone)
+        _sub(inf, "email", self.empresa.contato.email)
+
+        
+        rec_bruta = _sub(root, "receitaBruta")
+        for rm in sorted(self.receitas_mensais, key=lambda r: r.mes):
+            mes_el = _sub(rec_bruta, "mes")
+            _sub(mes_el, "nMes", str(rm.mes))
+            _sub(mes_el, "vlrRecBruta", _fmt_dec(rm.receita_bruta_total))
+            _sub(mes_el, "vlrRecBrutaExportacao", _fmt_dec(rm.receita_bruta_exportacao))
+            _sub(mes_el, "vlrRecBrutaIsenta", _fmt_dec(rm.receita_bruta_isenta))
+
+        
+        total = _sub(root, "totalAnual")
+        _sub(total, "vlrRecBrutaTotal", _fmt_dec(self._total_receita))
+        _sub(total, "vlrRecBrutaExportTotal", _fmt_dec(self._total_exportacao))
+        _sub(total, "vlrRecBrutaIsentaTotal", _fmt_dec(self._total_isenta))
+
+        
+        qs = _sub(root, "quadroSocietario")
+        for socio in self.socios:
+            s_el = _sub(qs, "socio")
+            _sub(s_el, "CPF_CNPJ", socio.cpf_cnpj)
+            _sub(s_el, "xNome", socio.nome)
+            _sub(s_el, "pctCapital", _fmt_dec(socio.percentual_capital))
+            _sub(s_el, "tpSocio", socio.tipo)
+            _sub(s_el, "paisDomicilio", socio.pais_domicilio)
+
+        
+        emp_el = _sub(root, "empregados")
+        for emp in self.empregados:
+            comp_el = _sub(emp_el, "competencia")
+            _sub(comp_el, "perApur", emp.competencia)
+            _sub(comp_el, "qtdEmpregados", str(emp.quantidade))
+
+        ET.indent(root, space="  ")
+        return '<?xml version="1.0" encoding="UTF-8"?>\n' + ET.tostring(root, encoding="unicode")
+
+    # ------------------------------------------------------------------
+    # Persistência
+    # ------------------------------------------------------------------
+
+    def salvar(self, diretorio: str | Path = ".") -> Path:
+        """Salva como DEFIS_CNPJ_ANO.xml"""
+        caminho = Path(diretorio) / f"DEFIS_{self.empresa.cnpj}_{self.ano_calendario}.xml"
+        caminho.parent.mkdir(parents=True, exist_ok=True)
+        caminho.write_text(self.gerar_xml(), encoding="utf-8")
+        return caminho
+
+    # ------------------------------------------------------------------
+    # Relatório
+    # ------------------------------------------------------------------
+
+    def relatorio_resumo(self) -> str:
+        """Resumo anual: receita total, maior mês, menores meses."""
+        linhas = [
+            f"DEFIS — {self.empresa.razao_social} — Ano: {self.ano_calendario}",
+            "=" * 70,
+        ]
+
+        if not self.receitas_mensais:
+            linhas.append("Sem receitas informadas.")
+            return "\n".join(linhas)
+
+        nomes_mes = [
+            "", "Jan", "Fev", "Mar", "Abr", "Mai", "Jun",
+            "Jul", "Ago", "Set", "Out", "Nov", "Dez",
+        ]
+
+        for rm in sorted(self.receitas_mensais, key=lambda r: r.mes):
+            nome = nomes_mes[rm.mes] if 1 <= rm.mes <= 12 else str(rm.mes)
+            linhas.append(f"  {nome}: R$ {rm.receita_bruta_total:>12,.2f}")
+
+        maior = max(self.receitas_mensais, key=lambda r: r.receita_bruta_total)
+        menor = min(self.receitas_mensais, key=lambda r: r.receita_bruta_total)
+
+        linhas += [
+            "=" * 70,
+            f"Receita Total Anual:    R$ {self._total_receita:>12,.2f}",
+            f"Receita Exportação:     R$ {self._total_exportacao:>12,.2f}",
+            f"Receita Isenta:         R$ {self._total_isenta:>12,.2f}",
+            f"Maior mês:              {nomes_mes[maior.mes]} — R$ {maior.receita_bruta_total:,.2f}",
+            f"Menor mês:              {nomes_mes[menor.mes]} — R$ {menor.receita_bruta_total:,.2f}",
+            f"Prazo de entrega:       31/03/{self.ano_calendario + 1}",
+            f"Retificadora:           {'Sim' if self.retificadora else 'Não'}",
+        ]
+        return "\n".join(linhas)

src/generators/destda.py

@@ -0,0 +1,186 @@
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from src.fiscal.entities import Empresa
+
+
+COD_UF = {
+    "AC": "12", "AL": "27", "AM": "13", "AP": "16", "BA": "29",
+    "CE": "23", "DF": "53", "ES": "32", "GO": "52", "MA": "21",
+    "MG": "31", "MS": "50", "MT": "51", "PA": "15", "PB": "25",
+    "PE": "26", "PI": "22", "PR": "41", "RJ": "33", "RN": "24",
+    "RO": "11", "RR": "14", "RS": "43", "SC": "42", "SE": "28",
+    "SP": "35", "TO": "17",
+}
+
+
+def _sub(pai: ET.Element, tag: str, texto: str = "") -> ET.Element:
+    el = ET.SubElement(pai, tag)
+    if texto:
+        el.text = str(texto)
+    return el
+
+
+def _fmt(v: Decimal) -> str:
+    return f"{v:.2f}"
+
+
+@dataclass
+class OperacaoSTDeSTDA:
+    """Operação de ICMS-ST, DIFAL ou antecipação do Simples Nacional."""
+    uf_origem: str
+    uf_destino: str
+    tipo: str               # "ST" | "DIFAL" | "ANTEC"
+    base_calculo: Decimal
+    aliquota: Decimal       # percentual, ex: Decimal("18")
+    valor_imposto: Decimal
+    valor_pago: Decimal = Decimal("0")
+
+    def __post_init__(self):
+        if self.valor_pago == Decimal("0"):
+            self.valor_pago = self.valor_imposto
+
+
+class GeradorDeSTDA:
+    
+
+    VERSAO = "1.1"
+
+    def __init__(
+        self,
+        empresa: Empresa,
+        periodo: str,                       # "YYYY-MM"
+        operacoes: list[OperacaoSTDeSTDA],
+        uf_declarante: str = "SP",
+        retificadora: bool = False,
+    ):
+        self.empresa = empresa
+        self.periodo = periodo
+        self.operacoes = operacoes
+        self.uf_declarante = uf_declarante.upper()
+        self.retificadora = retificadora
+
+    
+    def data_vencimento(self) -> date:
+        ano, mes = map(int, self.periodo.split("-"))
+        if mes == 12:
+            return date(ano + 1, 1, 20)
+        return date(ano, mes + 1, 20)
+
+    @property
+    def _ops_st(self) -> list[OperacaoSTDeSTDA]:
+        return [o for o in self.operacoes if o.tipo == "ST"]
+
+    @property
+    def _ops_difal(self) -> list[OperacaoSTDeSTDA]:
+        return [o for o in self.operacoes if o.tipo == "DIFAL"]
+
+    @property
+    def _ops_antec(self) -> list[OperacaoSTDeSTDA]:
+        return [o for o in self.operacoes if o.tipo == "ANTEC"]
+
+    def _total(self, ops: list[OperacaoSTDeSTDA], campo: str) -> Decimal:
+        return sum(getattr(o, campo) for o in ops)
+
+    
+    def gerar_xml(self) -> str:
+        ano, mes = self.periodo.split("-")
+        ultimo_dia = self._ultimo_dia(int(ano), int(mes))
+
+        root = ET.Element("DeSTDA")
+        root.set("versao", self.VERSAO)
+        root.set("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
+
+        
+        inf = _sub(root, "infDeSTDA")
+        _sub(inf, "CNPJ", self.empresa.cnpj)
+        _sub(inf, "cUF", COD_UF.get(self.uf_declarante, "35"))
+        _sub(inf, "dtInicio", f"{ano}-{mes}-01")
+        _sub(inf, "dtFim", f"{ano}-{mes}-{ultimo_dia}")
+        _sub(inf, "indRetificadora", "S" if self.retificadora else "N")
+        _sub(inf, "dtEnvio", date.today().strftime("%Y-%m-%d"))
+
+        
+        self._bloco_st(root)
+        self._bloco_difal(root)
+        self._bloco_antec(root)
+
+        
+        tot = _sub(root, "totais")
+        vst    = self._total(self._ops_st,    "valor_imposto")
+        vdifal = self._total(self._ops_difal, "valor_imposto")
+        vantec = self._total(self._ops_antec, "valor_imposto")
+        vpago  = self._total(self.operacoes,  "valor_pago")
+        _sub(tot, "vST_Total",    _fmt(vst))
+        _sub(tot, "vDIFAL_Total", _fmt(vdifal))
+        _sub(tot, "vANTEC_Total", _fmt(vantec))
+        _sub(tot, "vTotal",       _fmt(vst + vdifal + vantec))
+        _sub(tot, "vPago_Total",  _fmt(vpago))
+
+        ET.indent(root, space="  ")
+        return '<?xml version="1.0" encoding="UTF-8"?>\n' + ET.tostring(root, encoding="unicode")
+
+    def _bloco_st(self, root: ET.Element) -> None:
+        for op in self._ops_st:
+            el = _sub(root, "ST")
+            _sub(el, "UF_ST",         op.uf_destino)
+            _sub(el, "vBC_ST",        _fmt(op.base_calculo))
+            _sub(el, "pICMS_ST",      _fmt(op.aliquota))
+            _sub(el, "vICMS_ST",      _fmt(op.valor_imposto))
+            _sub(el, "vICMS_ST_Pago", _fmt(op.valor_pago))
+
+    def _bloco_difal(self, root: ET.Element) -> None:
+        for op in self._ops_difal:
+            el = _sub(root, "DIFAL")
+            _sub(el, "UF_DIFAL",         op.uf_destino)
+            _sub(el, "vBC_DIFAL",        _fmt(op.base_calculo))
+            _sub(el, "pICMS_DIFAL",      _fmt(op.aliquota))
+            _sub(el, "vICMS_DIFAL",      _fmt(op.valor_imposto))
+            _sub(el, "vICMS_DIFAL_Pago", _fmt(op.valor_pago))
+
+    def _bloco_antec(self, root: ET.Element) -> None:
+        for op in self._ops_antec:
+            el = _sub(root, "ANTEC")
+            _sub(el, "UF_ANTEC",         op.uf_origem)
+            _sub(el, "vBC_ANTEC",        _fmt(op.base_calculo))
+            _sub(el, "pICMS_ANTEC",      _fmt(op.aliquota))
+            _sub(el, "vICMS_ANTEC",      _fmt(op.valor_imposto))
+            _sub(el, "vICMS_ANTEC_Pago", _fmt(op.valor_pago))
+
+    def salvar(self, diretorio: str | Path = ".") -> Path:
+        caminho = Path(diretorio) / f"DeSTDA_{self.empresa.cnpj}_{self.periodo}.xml"
+        caminho.parent.mkdir(parents=True, exist_ok=True)
+        caminho.write_text(self.gerar_xml(), encoding="utf-8")
+        return caminho
+
+    def relatorio_resumo(self) -> str:
+        vst    = self._total(self._ops_st,    "valor_imposto")
+        vdifal = self._total(self._ops_difal, "valor_imposto")
+        vantec = self._total(self._ops_antec, "valor_imposto")
+        total  = vst + vdifal + vantec
+        venc   = self.data_vencimento()
+        linhas = [
+            f"DeSTDA — {self.empresa.razao_social} — Período: {self.periodo}",
+            "=" * 60,
+            f"ICMS-ST:       R$ {vst:>12,.2f}  ({len(self._ops_st)} operação/ões)",
+            f"DIFAL:         R$ {vdifal:>12,.2f}  ({len(self._ops_difal)} operação/ões)",
+            f"Antecipação:   R$ {vantec:>12,.2f}  ({len(self._ops_antec)} operação/ões)",
+            "=" * 60,
+            f"TOTAL A PAGAR: R$ {total:>12,.2f}",
+            f"Vencimento:    {venc.strftime('%d/%m/%Y')}",
+        ]
+        return "\n".join(linhas)
+
+    @staticmethod
+    def _ultimo_dia(ano: int, mes: int) -> str:
+        if mes == 12:
+            return "31"
+        from datetime import date as d
+        dias = (d(ano, mes + 1, 1) - d(ano, mes, 1)).days
+        return str(dias).zfill(2)

src/generators/dirf.py

@@ -0,0 +1,186 @@
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Dataclasses
+# ---------------------------------------------------------------------------
+
+@dataclass
+class BeneficiarioDIRF:
+    """Beneficiário de rendimentos sujeitos à retenção na fonte."""
+    cpf_cnpj: str
+    nome: str
+    tipo: str                              # "PF" ou "PJ"
+    cod_receita: str                       # ex: "0561" (trabalho assalariado), "1708" (serviços PJ)
+    rendimentos_por_mes: dict[int, Decimal] = field(default_factory=dict)   # {mes(1-12): valor}
+    ir_retido_por_mes: dict[int, Decimal] = field(default_factory=dict)     # {mes(1-12): valor}
+    
+    data_admissao: Optional[date] = None   # para assalariados
+    data_demissao: Optional[date] = None
+    natureza: str = "A"                    # "A"=assalariado, "B"=autônomo, "C"=outros
+
+
+@dataclass
+class ResponsavelDIRF:
+    cpf: str
+    nome: str
+    cargo: str
+    ddd: str
+    telefone: str
+
+
+# ---------------------------------------------------------------------------
+# Gerador
+# ---------------------------------------------------------------------------
+
+class GeradorDIRF:
+    """
+    Gera o arquivo DIRF no formato texto para importação no PGD DIRF.
+
+    Periodicidade: anual.
+    Prazo: último dia útil de fevereiro do ano seguinte.
+    Obrigação: toda PJ que pagou rendimentos sujeitos ao IRRF.
+    """
+
+    def __init__(
+        self,
+        empresa,                           # Empresa (src.fiscal.entities.Empresa)
+        ano_calendario: int,
+        beneficiarios: list[BeneficiarioDIRF],
+        responsavel: ResponsavelDIRF,
+        retificadora: bool = False,
+        numero_recibo_retificada: str = "",
+    ):
+        self.empresa = empresa
+        self.ano_calendario = ano_calendario
+        self.beneficiarios = beneficiarios
+        self.responsavel = responsavel
+        self.retificadora = retificadora
+        self.numero_recibo_retificada = numero_recibo_retificada
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _apenas_digitos(s: str) -> str:
+        return re.sub(r"\D", "", s)
+
+    def _linha_cabecalho(self) -> str:
+        """Linha DIRF — cabeçalho da declaração."""
+        ano_exercicio = self.ano_calendario + 1
+        ret = "S" if self.retificadora else "N"
+        partes = ["DIRF", str(ano_exercicio), ret]
+        if self.retificadora and self.numero_recibo_retificada:
+            partes.append(self.numero_recibo_retificada)
+        return " ".join(partes)
+
+    def _linha_respo(self) -> str:
+        """Linha RESPO — identificação do responsável pela declaração."""
+        r = self.responsavel
+        cpf = self._apenas_digitos(r.cpf).zfill(11)
+        ddd = self._apenas_digitos(r.ddd)
+        tel = self._apenas_digitos(r.telefone)
+        return f"RESPO {cpf} {r.nome} {r.cargo} {ddd}{tel}"
+
+    def _linha_decpj(self) -> str:
+        """Linha DECPJ — identificação da empresa declarante."""
+        emp = self.empresa
+        cnpj = self._apenas_digitos(emp.cnpj).zfill(14)
+        return f"DECPJ {cnpj} {emp.razao_social} 2062 N"
+
+    def _blocos_beneficiarios(self) -> list[str]:
+        """Gera os blocos de beneficiários agrupados por código de receita."""
+        linhas: list[str] = []
+
+        
+        por_receita: dict[str, list[BeneficiarioDIRF]] = {}
+        for ben in self.beneficiarios:
+            por_receita.setdefault(ben.cod_receita, []).append(ben)
+
+        for cod_receita, grupo in por_receita.items():
+            linhas.append(f"IDREC {cod_receita}")
+            for ben in grupo:
+                doc = self._apenas_digitos(ben.cpf_cnpj)
+                if ben.tipo == "PF":
+                    doc = doc.zfill(11)
+                    linhas.append(f"BPFDEC {doc} {ben.nome} {cod_receita}")
+                else:
+                    doc = doc.zfill(14)
+                    linhas.append(f"BPJDEC {doc} {ben.nome} {cod_receita}")
+
+                
+                meses = sorted(
+                    set(ben.rendimentos_por_mes.keys()) | set(ben.ir_retido_por_mes.keys())
+                )
+                for mes in meses:
+                    rend = ben.rendimentos_por_mes.get(mes, Decimal("0"))
+                    ir = ben.ir_retido_por_mes.get(mes, Decimal("0"))
+                    linhas.append(
+                        f"{self.ano_calendario} {mes:02d} {rend:.2f} {ir:.2f}"
+                    )
+
+        return linhas
+
+    # ------------------------------------------------------------------
+    # Interface pública
+    # ------------------------------------------------------------------
+
+    def gerar_txt(self) -> str:
+        """Gera o arquivo texto no layout PGD DIRF."""
+        linhas: list[str] = []
+        linhas.append(self._linha_cabecalho())
+        linhas.append(self._linha_respo())
+        linhas.append(self._linha_decpj())
+        linhas.extend(self._blocos_beneficiarios())
+        linhas.append("FIMDIRF")
+        return "\n".join(linhas) + "\n"
+
+    def salvar(self, diretorio: str | Path = ".") -> Path:
+        """Salva o arquivo como DIRF_CNPJ_ANO.txt."""
+        cnpj = self._apenas_digitos(self.empresa.cnpj).zfill(14)
+        caminho = Path(diretorio) / f"DIRF_{cnpj}_{self.ano_calendario}.txt"
+        caminho.parent.mkdir(parents=True, exist_ok=True)
+        caminho.write_text(self.gerar_txt(), encoding="utf-8")
+        return caminho
+
+    def relatorio_resumo(self) -> str:
+        """Retorna totais de rendimentos e IR retido agrupados por código de receita."""
+        totais: dict[str, dict[str, Decimal]] = {}
+        for ben in self.beneficiarios:
+            cod = ben.cod_receita
+            if cod not in totais:
+                totais[cod] = {"rendimentos": Decimal("0"), "ir_retido": Decimal("0"), "beneficiarios": 0}
+            totais[cod]["rendimentos"] += sum(ben.rendimentos_por_mes.values())
+            totais[cod]["ir_retido"] += sum(ben.ir_retido_por_mes.values())
+            totais[cod]["beneficiarios"] += 1  # type: ignore[operator]
+
+        emp = self.empresa
+        linhas = [
+            f"DIRF {self.ano_calendario} — {emp.razao_social} — CNPJ: {emp.cnpj}",
+            "=" * 70,
+        ]
+        total_rend = Decimal("0")
+        total_ir = Decimal("0")
+        for cod, dados in sorted(totais.items()):
+            linhas.append(f"Cód. Receita: {cod}")
+            linhas.append(f"  Beneficiários:  {dados['beneficiarios']:>6}")
+            linhas.append(f"  Rendimentos:  R$ {dados['rendimentos']:>12,.2f}")
+            linhas.append(f"  IR Retido:    R$ {dados['ir_retido']:>12,.2f}")
+            total_rend += dados["rendimentos"]
+            total_ir += dados["ir_retido"]
+
+        linhas += [
+            "=" * 70,
+            f"TOTAL RENDIMENTOS: R$ {total_rend:>12,.2f}",
+            f"TOTAL IR RETIDO:   R$ {total_ir:>12,.2f}",
+        ]
+        return "\n".join(linhas)

src/generators/ecd.py

@@ -0,0 +1,294 @@
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from typing import Optional
+
+from src.fiscal.entities import Empresa, LancamentoContabil, PeriodoApuracao
+from src.generators.sped_writer import ArquivoSPED, criar_registro
+
+VERSAO_LEIAUTE = "010"
+
+
+@dataclass
+class PlanoContas:
+    codigo: str
+    descricao: str
+    nivel: int
+    tipo: str  # A=Analítica, S=Sintética
+    natureza: str  # D=Devedora, C=Credora
+
+
+@dataclass
+class ConfigECD:
+    versao: str = VERSAO_LEIAUTE
+    finalidade: str = "G"  # G=Livro Diário, R=Razão Auxiliar
+    hash_anterior: str = ""
+    tipo_escrituracao: str = "G"  # G=Geral
+    indicador_sit_especial: str = ""
+
+
+class GeradorECD:
+    
+
+    def __init__(
+        self,
+        periodo: PeriodoApuracao,
+        plano_contas: Optional[list[PlanoContas]] = None,
+        cfg: Optional[ConfigECD] = None,
+        contador: Optional[object] = None,
+    ):
+        self.periodo = periodo
+        self.plano_contas = plano_contas or self._plano_contas_padrao()
+        self.cfg = cfg or ConfigECD()
+        self.contador = contador
+        self._arquivo = ArquivoSPED(
+            f"ECD_{periodo.empresa.cnpj}_{periodo.data_inicio.year}.txt"
+        )
+
+    def _plano_contas_padrao(self) -> list[PlanoContas]:
+        return [
+            PlanoContas("1", "ATIVO", 1, "S", "D"),
+            PlanoContas("1.1", "ATIVO CIRCULANTE", 2, "S", "D"),
+            PlanoContas("1.1.1", "CAIXA E EQUIVALENTES", 3, "S", "D"),
+            PlanoContas("1.1.1.01", "CAIXA", 4, "A", "D"),
+            PlanoContas("1.1.1.02", "BANCOS CONTA MOVIMENTO", 4, "A", "D"),
+            PlanoContas("1.1.2", "CONTAS A RECEBER", 3, "S", "D"),
+            PlanoContas("1.1.2.01", "CLIENTES", 4, "A", "D"),
+            PlanoContas("1.1.3", "ESTOQUES", 3, "S", "D"),
+            PlanoContas("1.1.3.01", "MERCADORIAS", 4, "A", "D"),
+            PlanoContas("1.2", "ATIVO NÃO CIRCULANTE", 2, "S", "D"),
+            PlanoContas("1.2.1", "IMOBILIZADO", 3, "S", "D"),
+            PlanoContas("1.2.1.01", "MÓVEIS E UTENSÍLIOS", 4, "A", "D"),
+            PlanoContas("1.2.1.02", "EQUIPAMENTOS", 4, "A", "D"),
+            PlanoContas("2", "PASSIVO", 1, "S", "C"),
+            PlanoContas("2.1", "PASSIVO CIRCULANTE", 2, "S", "C"),
+            PlanoContas("2.1.1", "FORNECEDORES", 3, "S", "C"),
+            PlanoContas("2.1.1.01", "FORNECEDORES NACIONAIS", 4, "A", "C"),
+            PlanoContas("2.1.2", "OBRIGAÇÕES FISCAIS", 3, "S", "C"),
+            PlanoContas("2.1.2.01", "ICMS A RECOLHER", 4, "A", "C"),
+            PlanoContas("2.1.2.02", "PIS A RECOLHER", 4, "A", "C"),
+            PlanoContas("2.1.2.03", "COFINS A RECOLHER", 4, "A", "C"),
+            PlanoContas("2.1.2.04", "IRPJ A RECOLHER", 4, "A", "C"),
+            PlanoContas("2.1.2.05", "CSLL A RECOLHER", 4, "A", "C"),
+            PlanoContas("2.1.3", "OBRIGAÇÕES TRABALHISTAS", 3, "S", "C"),
+            PlanoContas("2.1.3.01", "SALÁRIOS A PAGAR", 4, "A", "C"),
+            PlanoContas("2.2", "PASSIVO NÃO CIRCULANTE", 2, "S", "C"),
+            PlanoContas("3", "PATRIMÔNIO LÍQUIDO", 1, "S", "C"),
+            PlanoContas("3.1", "CAPITAL SOCIAL", 2, "S", "C"),
+            PlanoContas("3.1.01", "CAPITAL SUBSCRITO E INTEGRALIZADO", 3, "A", "C"),
+            PlanoContas("3.2", "RESERVAS E LUCROS", 2, "S", "C"),
+            PlanoContas("3.2.01", "LUCROS ACUMULADOS", 3, "A", "C"),
+            PlanoContas("4", "RECEITAS", 1, "S", "C"),
+            PlanoContas("4.1", "RECEITA OPERACIONAL BRUTA", 2, "S", "C"),
+            PlanoContas("4.1.01", "VENDAS DE MERCADORIAS", 3, "A", "C"),
+            PlanoContas("4.1.02", "PRESTAÇÃO DE SERVIÇOS", 3, "A", "C"),
+            PlanoContas("4.2", "DEDUÇÕES DA RECEITA", 2, "S", "D"),
+            PlanoContas("4.2.01", "DEVOLUÇÕES DE VENDAS", 3, "A", "D"),
+            PlanoContas("4.2.02", "IMPOSTOS SOBRE VENDAS", 3, "A", "D"),
+            PlanoContas("5", "CUSTOS", 1, "S", "D"),
+            PlanoContas("5.1", "CUSTO DE MERCADORIAS VENDIDAS", 2, "S", "D"),
+            PlanoContas("5.1.01", "CMV - MERCADORIAS", 3, "A", "D"),
+            PlanoContas("6", "DESPESAS OPERACIONAIS", 1, "S", "D"),
+            PlanoContas("6.1", "DESPESAS ADMINISTRATIVAS", 2, "S", "D"),
+            PlanoContas("6.1.01", "SALÁRIOS E ORDENADOS", 3, "A", "D"),
+            PlanoContas("6.1.02", "ENCARGOS SOCIAIS", 3, "A", "D"),
+            PlanoContas("6.1.03", "ALUGUÉIS", 3, "A", "D"),
+            PlanoContas("6.1.04", "SERVIÇOS DE TERCEIROS", 3, "A", "D"),
+            PlanoContas("6.2", "DESPESAS COMERCIAIS", 2, "S", "D"),
+            PlanoContas("6.2.01", "FRETES E CARRETOS", 3, "A", "D"),
+            PlanoContas("6.2.02", "COMISSÕES", 3, "A", "D"),
+            PlanoContas("6.3", "DESPESAS FINANCEIRAS", 2, "S", "D"),
+            PlanoContas("6.3.01", "JUROS E ENCARGOS", 3, "A", "D"),
+        ]
+
+    def _bloco_0(self) -> None:
+        emp = self.periodo.empresa
+        end = emp.endereco
+
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "0000",
+            self.cfg.versao,
+            self.cfg.tipo_escrituracao,
+            "G",  # ind_sit_ini_pj (G=Geral)
+            emp.cnpj,
+            emp.regime_tributario.value,
+            emp.razao_social,
+            end.uf.value,
+            emp.ie,
+            end.cod_municipio,
+            self.cfg.indicador_sit_especial,
+            "",  # nr_rec_anterior
+            self.periodo.data_inicio,
+            self.periodo.data_fim,
+            "N",  # ind_grandes_contribuintes
+            self.cfg.finalidade,
+            "1",  # ind_pub_soc_emp
+            "",   # ind_ecd_complem
+            "",   # hash_ecd_substituto
+        ))
+
+        self._arquivo.adicionar_linha_raw(criar_registro("0001", "0"))
+
+        # 0007 - Identificação dos Signatários da ECD
+        if self.contador:
+            c = self.contador
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "0007",
+                c.cpf,
+                "2",  # qualif_assig (2=Contabilista)
+            ))
+
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "0990", self._arquivo.total_linhas() + 1
+        ))
+
+    def _bloco_i(self) -> None:
+        
+        self._arquivo.adicionar_linha_raw(criar_registro("I001", "0"))
+
+        
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "I010",
+            "G",   # ind_lc (G=Livro Diário)
+            "",    # nr_livro
+            "",    # nr_pag_ini
+            "",    # qt_lin
+            "",    # nr_pag_fin
+            "",    # nome_livro
+            self.periodo.data_inicio,
+            self.periodo.data_fim,
+            "",    # hash_lc
+            "",    # nr_pag_ini_cert
+            "",    # nr_pag_fin_cert
+            "1",   # dt_cert
+            "1",   # nm_cart
+            "1",   # nr_off_cart
+            "1",   # tp_assinante
+            "1",   # tratamento_diff
+        ))
+
+        
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "I020",
+            "EMPRESA",
+            self.periodo.empresa.cnpj,
+            "1",   # cod_ccp
+            "1",   # cpf
+        ))
+
+        
+        for conta in self.plano_contas:
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "I050",
+                conta.codigo,
+                conta.codigo,   # cod_cta_ref
+                conta.nivel,
+                conta.tipo,
+                conta.natureza,
+                conta.descricao,
+                "",             # cod_cta_cnt_sup
+                "",             # cod_cta_cnt_cpl
+                "",             # tipo_cta_ref
+            ))
+
+        
+        for conta in [c for c in self.plano_contas if c.tipo == "A"]:
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "I100",
+                conta.codigo,
+                "0",   # ind_dc_ini
+                Decimal("0"),   # vl_saldo_ini
+                Decimal("0"),   # vl_deb
+                Decimal("0"),   # vl_cred
+                "0",   # ind_dc_fin
+                Decimal("0"),   # vl_saldo_fin
+            ))
+
+        
+        for i, lanc in enumerate(self.periodo.lancamentos, 1):
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "I200",
+                str(i).zfill(6),   # num_lanc
+                lanc.data,
+                "01",              # cod_hist_padrao
+                lanc.historico,
+                Decimal("0"),      # vl_lanc (total do lançamento)
+            ))
+
+            
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "I250",
+                lanc.debito_conta,
+                "D",
+                lanc.valor,
+                "01",   # cod_hist_padrao
+                lanc.historico,
+                "",     # num_doc
+                "",     # cod_part
+            ))
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "I250",
+                lanc.credito_conta,
+                "C",
+                lanc.valor,
+                "01",
+                lanc.historico,
+                "",
+                "",
+            ))
+
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "I990", self._arquivo.total_linhas()
+        ))
+
+    def _bloco_j(self) -> None:
+        
+        self._arquivo.adicionar_linha_raw(criar_registro("J001", "0"))
+
+        
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "J005",
+            self.periodo.data_fim,
+            "0",   # cod_qualif_cp (0=não referenciado)
+            "0",   # cod_pl_ref
+            "0",   # cod_ver_pl_ref
+        ))
+
+        
+        for conta in self.plano_contas[:10]:  # Primeiras contas como exemplo
+            self._arquivo.adicionar_linha_raw(criar_registro(
+                "J100",
+                conta.codigo,
+                conta.codigo,
+                conta.descricao,
+                conta.nivel,
+                conta.tipo,
+                conta.natureza,
+                Decimal("0"),   # vl_saldo_ini
+                "0",            # ind_vl_cta
+                Decimal("0"),   # vl_saldo_fin
+                "0",
+                "",             # cod_cta_ref_conv
+            ))
+
+        self._arquivo.adicionar_linha_raw(criar_registro(
+            "J990", self._arquivo.total_linhas()
+        ))
+
+    def _bloco_9(self) -> None:
+        self._arquivo.adicionar_linha_raw(criar_registro("9001", "0"))
+        qt = self._arquivo.total_linhas() + 3
+        self._arquivo.adicionar_linha_raw(criar_registro("9900", "0000", "1"))
+        self._arquivo.adicionar_linha_raw(criar_registro("9990", qt))
+        self._arquivo.adicionar_linha_raw(criar_registro("9999", qt + 1))
+
+    def gerar(self, diretorio: str | Path = ".") -> Path:
+        self._bloco_0()
+        self._bloco_i()
+        self._bloco_j()
+        self._bloco_9()
+        return self._arquivo.salvar(diretorio)