PyNFSeNacionalGT 0.1.0__py3-none-any.whl

pynfsenacional/__init__.py

@@ -0,0 +1,26 @@
+"""PyNFSeNacional — Emissão de NFS-e pela API SEFIN Nacional (DPS) + DANFSe local.
+
+API pública:
+    from pynfsenacional import Emissor
+    emissor = Emissor("config/cliente.json")
+    nota = emissor.emitir(valor=150.00, descricao="...", tomador={...})
+    nota.danfse("nota.pdf")
+
+Estado: alpha (pipeline completo). Ver docs/roadmap.md para o escopo e
+docs/conhecimento-fiscal.md para a regra fiscal (DPS, E-codes, numeração, DANFSe).
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .config import ClienteConfig
+from .emissor import Emissor, Nota
+
+try:
+    # Fonte única da versão: o metadado do pacote instalado (pyproject.toml).
+    __version__ = version("PyNFSeNacionalGT")
+except PackageNotFoundError:  # pragma: no cover - rodando do source, sem instalar
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["Emissor", "Nota", "ClienteConfig", "__version__"]

pynfsenacional/assinatura.py

@@ -0,0 +1,46 @@
+"""Assinatura digital XMLDSIG da DPS. Lib: `erpbrasil.assinatura` (signxml).
+
+★ Era o ponto que parecia o "nó" — resolvido por biblioteca madura (em produção no
+ecossistema Odoo Brasil). Assinatura *enveloped* sobre o nó `infDPS`, com `Reference`
+apontando para o `Id`. Validado contra a referência PHP: o `DigestValue` produzido aqui
+é **byte-a-byte idêntico** ao do gabarito (RSA-SHA1 + transforms enveloped/c14n) — ver
+tests/golden. A `<Signature>` entra como último filho do `<DPS>`, depois do `infDPS`.
+"""
+
+from __future__ import annotations
+
+from lxml import etree
+
+NS = "http://www.sped.fazenda.gov.br/nfse"
+
+
+def assinar_dps(xml_dps: str, *, cert_pfx_path: str, senha: str) -> str:
+    """Recebe o XML da DPS (não assinado) e devolve o XML assinado (XMLDSIG enveloped).
+
+    Delegado a `erpbrasil.assinatura`: assina apontando o `Reference` para o `Id` do
+    `infDPS`. RSA-SHA1 (algoritmo do padrão NFe/NFSe).
+    """
+    from erpbrasil.assinatura.assinatura import Assinatura
+    from erpbrasil.assinatura.certificado import Certificado
+
+    raiz = etree.fromstring(xml_dps.encode("utf-8"))
+    inf = raiz.find(f"{{{NS}}}infDPS")
+    if inf is None:
+        raise ValueError("DPS sem nó infDPS — nada para assinar")
+    reference = inf.get("Id")
+    if not reference:
+        raise ValueError("infDPS sem atributo Id — assinatura precisa do Reference")
+
+    cert = Certificado(cert_pfx_path, senha)
+    assinado = Assinatura(cert).assina_xml2(raiz, reference)
+
+    # Reserializa com o prolog `<?xml version='1.0' encoding='UTF-8'?>` — sem ele o SEFIN
+    # rejeita com E1229 ("Xml não está utilizando codificação UTF-8"). O prolog fica FORA
+    # do infDPS/Signature, então não altera o DigestValue nem a assinatura já calculados.
+    if isinstance(assinado, str):
+        elem = etree.fromstring(assinado.encode("utf-8"))
+    elif isinstance(assinado, bytes):
+        elem = etree.fromstring(assinado)
+    else:
+        elem = assinado
+    return str(etree.tostring(elem, encoding="UTF-8", xml_declaration=True).decode("utf-8"))

pynfsenacional/certificado.py

@@ -0,0 +1,149 @@
+"""Leitura do certificado A1 (.pfx / PKCS#12). Lib: `cryptography`.
+
+⚠️ Gotcha ICP-Brasil (docs/conhecimento-fiscal.md §9): certificados A1 ICP-Brasil
+usam cifras legadas (RC2/3DES) que o OpenSSL 3 desabilita por padrão. Se a leitura
+falhar, **NÃO assuma "senha errada"** — pode ser o bloqueio legado. Aqui:
+  1. tenta ler direto com `cryptography` (cobre a maioria);
+  2. se falhar, tenta um fallback best-effort via `openssl pkcs12 -legacy` (quando o
+     binário existe) — se ISSO funciona, era cifra legada (e recuperamos);
+  3. senão, levanta `CertificadoError` deixando as DUAS causas possíveis explícitas.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.serialization import pkcs12
+from cryptography.hazmat.primitives.serialization.pkcs12 import PKCS12KeyAndCertificates
+from cryptography.x509.oid import NameOID
+
+from .config import Certificado as CertConfig
+
+
+class CertificadoError(Exception):
+    """Falha ao abrir/usar o certificado A1."""
+
+
+class Certificado:
+    """Abre o .pfx e expõe chave privada + certificado para assinatura e mTLS."""
+
+    def __init__(self, cfg: CertConfig):
+        self.cfg = cfg
+        self._carregado: PKCS12KeyAndCertificates | None = None
+        self.legado: bool = False  # True se foi preciso o fallback de cifra legada
+
+    # ── leitura ─────────────────────────────────────────────────────────────
+    def carregar(self) -> Certificado:
+        """Lê o .pfx. Idempotente. Ver gotcha legado acima."""
+        if self._carregado is not None:
+            return self
+        caminho = Path(self.cfg.path)
+        if not caminho.exists():
+            raise CertificadoError(f"certificado não encontrado: {caminho}")
+        data = caminho.read_bytes()
+        senha = self.cfg.senha.encode()
+        try:
+            self._carregado = pkcs12.load_pkcs12(data, senha)
+        except ValueError as e:
+            recuperado = self._tentar_legado(data, senha)
+            if recuperado is None:
+                raise CertificadoError(
+                    "falha ao abrir o .pfx. Pode ser (a) senha incorreta OU (b) cifra "
+                    "legada ICP-Brasil (RC2/3DES) bloqueada pelo OpenSSL — NÃO é "
+                    "necessariamente senha errada (conhecimento-fiscal §9). "
+                    f"Detalhe: {e}"
+                ) from e
+            self._carregado = recuperado
+            self.legado = True
+        if self._carregado.cert is None or self._carregado.cert.certificate is None:
+            raise CertificadoError("o .pfx não contém um certificado")
+        return self
+
+    def _tentar_legado(self, data: bytes, senha: bytes) -> PKCS12KeyAndCertificates | None:
+        """Best-effort: usa o `openssl` do sistema com o provedor `-legacy` para
+        reembalar o .pfx num formato que a `cryptography` lê. Devolve None se não der."""
+        openssl = shutil.which("openssl")
+        if not openssl:
+            return None
+        with tempfile.TemporaryDirectory() as tmp:
+            pfx = Path(tmp) / "in.pfx"
+            pem = Path(tmp) / "out.pem"
+            pfx.write_bytes(data)
+            try:
+                # legacy → PEM (cert+chave), depois recarrega na cryptography
+                subprocess.run(
+                    [openssl, "pkcs12", "-legacy", "-in", str(pfx), "-out", str(pem),
+                     "-nodes", "-passin", f"pass:{senha.decode()}"],
+                    check=True, capture_output=True, timeout=30,
+                )
+                pem_bytes = pem.read_bytes()
+            except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+                return None
+            key = serialization.load_pem_private_key(pem_bytes, password=None)
+            if not isinstance(key, rsa.RSAPrivateKey):  # A1 ICP-Brasil é sempre RSA
+                return None
+            cert = x509.load_pem_x509_certificate(pem_bytes)
+            # reembala num PKCS12 moderno em memória p/ uniformizar o tipo de retorno
+            novo = pkcs12.serialize_key_and_certificates(
+                b"pynfse", key, cert, None, serialization.BestAvailableEncryption(senha),
+            )
+            return pkcs12.load_pkcs12(novo, senha)
+
+    # ── acesso ────────────────────────────────────────────────────────────────
+    def _exigir(self) -> PKCS12KeyAndCertificates:
+        if self._carregado is None:
+            self.carregar()
+        assert self._carregado is not None
+        return self._carregado
+
+    @property
+    def certificado_x509(self) -> x509.Certificate:
+        cert = self._exigir().cert
+        assert cert is not None
+        return cert.certificate
+
+    @property
+    def validade(self) -> datetime:
+        """Fim da validade (UTC) do certificado."""
+        return self.certificado_x509.not_valid_after_utc
+
+    @property
+    def titular(self) -> str:
+        """Common Name do titular (em A1 ICP-Brasil costuma ser 'NOME:CNPJ')."""
+        attrs = self.certificado_x509.subject.get_attributes_for_oid(NameOID.COMMON_NAME)
+        return str(attrs[0].value) if attrs else ""
+
+    @property
+    def cnpj(self) -> str | None:
+        """CNPJ/CPF do titular, extraído do CN ICP-Brasil ('NOME:DOC'), se houver."""
+        cn = self.titular
+        if ":" in cn:
+            doc = "".join(ch for ch in cn.rsplit(":", 1)[1] if ch.isdigit())
+            return doc or None
+        return None
+
+    def como_pem(self, destino_dir: str | Path) -> tuple[str, str]:
+        """Exporta (cert_pem_path, key_pem_path) para o mTLS via `requests`.
+        Arquivos temporários — nunca versionar (ficam em `destino_dir`)."""
+        p12 = self._exigir()
+        assert p12.cert is not None and p12.key is not None
+        destino = Path(destino_dir)
+        destino.mkdir(parents=True, exist_ok=True)
+        cert_path = destino / "cert.pem"
+        key_path = destino / "key.pem"
+        cert_path.write_bytes(p12.cert.certificate.public_bytes(serialization.Encoding.PEM))
+        key_path.write_bytes(
+            p12.key.private_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PrivateFormat.PKCS8,
+                encryption_algorithm=serialization.NoEncryption(),
+            )
+        )
+        return str(cert_path), str(key_path)

pynfsenacional/cli.py

@@ -0,0 +1,83 @@
+"""CLI turnkey: `nfse-nacional emitir config/cliente.json --valor 150,00 ...`.
+
+Pensada para o contador: aponta para o config (certificado + prestador) e emite.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+from .config import ConfigError
+from .emissor import Emissor
+
+
+def _to_float(s: str) -> float:
+    """Aceita '1.262,90', '1262.90', '100'. Padrão pt-BR."""
+    s = s.strip()
+    if "," in s:
+        s = s.replace(".", "").replace(",", ".")
+    return float(s)
+
+
+def _cmd_emitir(args: argparse.Namespace) -> int:
+    tomador = None
+    if args.tomador_doc or args.tomador_nome:
+        tomador = {"cpf_cnpj": args.tomador_doc, "nome": args.tomador_nome}
+    try:
+        emissor = Emissor(args.config, ambiente=args.ambiente)
+        nota = emissor.emitir(
+            valor=_to_float(args.valor),
+            descricao=args.descricao,
+            tomador=tomador,
+            numero=args.numero,
+            serie=args.serie,
+        )
+    except ConfigError as e:           # config/dados inválidos — antes de tocar o SEFIN
+        print(f"❌ config inválida:\n{e}", file=sys.stderr)
+        return 2
+
+    if nota.emitida:
+        marca = "(já emitida)" if nota.status == "ja_emitida" else ""
+        print(f"✅ emitida {marca}— nNFSe {nota.numero_nfse} · chave {nota.chave_acesso}")
+        if args.xml_out and nota.nfse_xml:
+            with open(args.xml_out, "w", encoding="utf-8") as fh:
+                fh.write(nota.nfse_xml)
+            print("   XML:", args.xml_out)
+        if args.pdf:
+            print("   DANFSe:", nota.danfse(args.pdf))
+        return 0
+    print(f"❌ não emitida: {nota.erro_msg}", file=sys.stderr)
+    return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="nfse-nacional",
+                                description="Emite NFS-e pela API SEFIN Nacional.")
+    p.add_argument("-v", "--verbose", action="store_true", help="mostra o log do processo")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    e = sub.add_parser("emitir", help="emite uma NFS-e")
+    e.add_argument("config", help="caminho do config/<cliente>.json")
+    e.add_argument("--valor", required=True, help="valor do serviço (ex.: 150,00)")
+    e.add_argument("--descricao", required=True)
+    e.add_argument("--tomador-doc", dest="tomador_doc")
+    e.add_argument("--tomador-nome", dest="tomador_nome")
+    e.add_argument("--numero", help="nDPS (default: contador do ambiente)")
+    e.add_argument("--serie", default="1")
+    e.add_argument("--ambiente", choices=["homologacao", "producao"],
+                   help="homologacao = TESTE (sem validade) · producao = nota real")
+    e.add_argument("--pdf", help="gera o DANFSe neste caminho")
+    e.add_argument("--xml-out", dest="xml_out", help="salva o XML da NFS-e neste caminho")
+    e.set_defaults(func=_cmd_emitir)
+
+    args = p.parse_args(argv)
+    if args.verbose:
+        logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+    codigo: int = args.func(args)
+    return codigo
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pynfsenacional/config.py

@@ -0,0 +1,229 @@
+"""Configuração do cliente/prestador — carrega o JSON descrito em
+docs/conhecimento-fiscal.md §3 em dataclasses tipadas.
+
+Duas responsabilidades:
+  • **Carregar/representar** o JSON em dataclasses (`from_dict`/`from_json`), com erro
+    de schema amigável (`ConfigError`) em vez de `TypeError` cru.
+  • **Validar fiscalmente** (`validar`) — os E-codes que dão para pegar ANTES de tocar o
+    SEFIN (cTribNac 6 díg, cTribMun presente, pTotTribSN se Simples, CNPJ/CPF mód-11…).
+A montagem do XML da DPS fica em dps.py.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from . import documentos
+
+_AMBIENTES = ("homologacao", "producao")
+
+
+class ConfigError(ValueError):
+    """Config malformada (bloco ausente, campo desconhecido, tipo errado)."""
+
+
+def _construir(tipo: type, dados: dict[str, Any], contexto: str,
+               ignorar: tuple[str, ...] = ()) -> Any:
+    """Constrói uma dataclass a partir de um dict, com erro de schema amigável.
+
+    Campos em `ignorar` são descartados (ex.: endereço/nome do prestador, que não
+    são enviados — E0128/E0121). Chave desconhecida ou faltando → `ConfigError` com
+    contexto, em vez do `TypeError` cru do `**splat`.
+    """
+    if not isinstance(dados, dict):
+        raise ConfigError(f"{contexto}: esperado objeto JSON, recebido {type(dados).__name__}")
+    dados = {k: v for k, v in dados.items() if k not in ignorar}
+    campos = {f.name for f in dataclasses.fields(tipo)}
+    desconhecidos = set(dados) - campos
+    if desconhecidos:
+        raise ConfigError(
+            f"{contexto}: campo(s) não reconhecido(s): {sorted(desconhecidos)}. "
+            f"Válidos: {sorted(campos)}"
+        )
+    try:
+        return tipo(**dados)
+    except TypeError as e:  # campo obrigatório ausente
+        raise ConfigError(f"{contexto}: {e}") from e
+
+
+@dataclass
+class Certificado:
+    """Certificado A1 ICP-Brasil do PRÓPRIO prestador (.pfx). NUNCA versionar."""
+    path: str
+    senha: str
+
+
+@dataclass
+class Regime:
+    """Regime tributário do prestador (ver §3)."""
+    opSimpNac: int          # 1=Não Optante · 2=MEI · 3=Optante ME/EPP (Simples)
+    regApTribSN: int = 1    # apuração do SN (se optante)
+    regEspTrib: int = 0     # regime especial (0=Nenhum)
+
+
+@dataclass
+class Prestador:
+    cnpj: str               # 14 dígitos
+    codigo_municipio: str   # IBGE 7 díg do emitente
+    regime: Regime
+    uf: str | None = None
+    inscricao_municipal: str | None = None
+    # Nome/endereço do prestador NÃO são enviados quando ele é o emitente (E0128/E0121).
+
+
+@dataclass
+class Servico:
+    codigo_municipio_prestacao: str   # IBGE do local da prestação
+    cTribNac: str                     # 6 dígitos (LC116)
+    cTribMun: str                     # desdobro municipal
+    descricao_padrao: str = "Serviço Prestado"
+    tributos: dict[str, Any] = field(default_factory=dict)  # ex.: {"pTotTribSN": "6.00"}
+
+
+@dataclass
+class ClienteConfig:
+    id: str
+    nome_cliente: str
+    certificado: Certificado
+    prestador: Prestador
+    servico: Servico
+    ambiente: str = "homologacao"
+    dados_nota: dict[str, Any] = field(default_factory=dict)
+
+    # ── carregamento ──────────────────────────────────────────────────────────
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> ClienteConfig:
+        if not isinstance(d, dict):
+            raise ConfigError(f"config: esperado objeto JSON, recebido {type(d).__name__}")
+        for chave in ("id", "nome_cliente", "certificado", "prestador", "servico"):
+            if chave not in d:
+                raise ConfigError(f"config: bloco/campo obrigatório ausente: '{chave}'")
+
+        cert = _construir(Certificado, d["certificado"], "certificado")
+        prest_raw = dict(d["prestador"])
+        if "regime" not in prest_raw:
+            raise ConfigError("prestador: bloco 'regime' obrigatório ausente")
+        regime = _construir(Regime, prest_raw.pop("regime"), "prestador.regime")
+        # endereço/telefone/email do prestador NÃO vão na DPS (E0128/E0121): descartados.
+        prestador = _construir(
+            Prestador, {**prest_raw, "regime": regime}, "prestador",
+            ignorar=("endereco", "telefone", "email"),
+        )
+        servico = _construir(Servico, d["servico"], "servico")
+        return cls(
+            id=str(d["id"]),
+            nome_cliente=d["nome_cliente"],
+            certificado=cert,
+            prestador=prestador,
+            servico=servico,
+            ambiente=d.get("ambiente", "homologacao"),
+            dados_nota=d.get("dados_nota", {}),
+        )
+
+    @classmethod
+    def from_json(cls, path: str | Path) -> ClienteConfig:
+        raw = Path(path).read_text(encoding="utf-8")
+        try:
+            dados = json.loads(raw)
+        except json.JSONDecodeError as e:
+            raise ConfigError(
+                f"{path}: JSON inválido ({e}). O config real é JSON puro — comentários "
+                f"// só existem no exemplo anotado .jsonc, não num config carregável."
+            ) from e
+        return cls.from_dict(dados)
+
+    # ── validação fiscal ──────────────────────────────────────────────────────
+    def validar(self) -> list[str]:
+        """Lista os problemas fiscais (vazia = ok). Pega, ANTES do SEFIN, os E-codes
+        que são determinísticos a partir da config. Ver docs/conhecimento-fiscal.md §4.
+        """
+        problemas: list[str] = []
+        p, s, r = self.prestador, self.servico, self.prestador.regime
+
+        # Prestador (emitente)
+        if not documentos.cnpj_valido(p.cnpj):
+            problemas.append(
+                f"CNPJ do prestador inválido (14 dígitos + dígito verificador): {p.cnpj!r}"
+            )
+        if not (p.codigo_municipio.isdigit() and len(p.codigo_municipio) == 7):
+            problemas.append(
+                f"código IBGE do município do prestador deve ter 7 dígitos: {p.codigo_municipio!r}"
+            )
+        if r.opSimpNac not in (1, 2, 3):
+            problemas.append(
+                f"regime.opSimpNac deve ser 1 (Não Optante), 2 (MEI) ou 3 (ME/EPP); "
+                f"recebido {r.opSimpNac!r}"
+            )
+
+        # Serviço / códigos de tributação
+        if not (s.cTribNac.isdigit() and len(s.cTribNac) == 6):
+            problemas.append(
+                f"E1235: cTribNac deve ter exatamente 6 dígitos (TSCodTribNac); "
+                f"recebido {s.cTribNac!r}"
+            )
+        if not (s.cTribMun and str(s.cTribMun).strip()):
+            problemas.append(
+                "E0312: cTribMun é obrigatório (o município administra a combinação "
+                "cTribNac+cTribMun; meio-par é rejeitado)"
+            )
+        if not (s.codigo_municipio_prestacao.isdigit()
+                and len(s.codigo_municipio_prestacao) == 7):
+            problemas.append(
+                f"código IBGE do local da prestação deve ter 7 dígitos: "
+                f"{s.codigo_municipio_prestacao!r}"
+            )
+
+        # Tributos: Simples (MEI/ME-EPP) exige pTotTribSN (E0712/E1235)
+        if r.opSimpNac in (2, 3):
+            ptot = s.tributos.get("pTotTribSN")
+            if ptot is None or str(ptot).strip() == "":
+                problemas.append(
+                    f"E0712/E1235: prestador é Simples (opSimpNac={r.opSimpNac}) → "
+                    f"'pTotTribSN' é obrigatório em servico.tributos"
+                )
+            else:
+                try:
+                    float(str(ptot).replace(",", "."))
+                except ValueError:
+                    problemas.append(f"servico.tributos.pTotTribSN não é numérico: {ptot!r}")
+
+        # Ambiente
+        if self.ambiente not in _AMBIENTES:
+            problemas.append(
+                f"ambiente inválido: {self.ambiente!r} (use 'homologacao' ou 'producao')"
+            )
+        return problemas
+
+
+def validar_tomador(tomador: dict[str, Any] | None) -> list[str]:
+    """Valida o bloco do tomador da emissão (E1235 §7). Tomador `None`/sem doc =
+    consumidor final (omite <toma>) → sem problemas. Com documento, EXIGE nome e
+    documento válido (mód-11)."""
+    if not tomador:
+        return []
+    doc = documentos.digitos(tomador.get("cpf_cnpj") or tomador.get("cpf") or tomador.get("cnpj"))
+    if not doc:
+        return []  # sem documento → tratado como não identificado (omite <toma>)
+
+    problemas: list[str] = []
+    nome = (tomador.get("nome") or tomador.get("xNome") or "").strip()
+    if not nome:
+        problemas.append(
+            "E1235: tomador identificado EXIGE nome (xNome) — a API não resolve pela "
+            "Receita (§7); informe o nome ou resolva por CNPJ (BrasilAPI)"
+        )
+    if len(doc) == 14:
+        if not documentos.cnpj_valido(doc):
+            problemas.append(f"CNPJ do tomador inválido: {doc!r}")
+    elif len(doc) == 11:
+        if not documentos.cpf_valido(doc):
+            problemas.append(f"CPF do tomador inválido: {doc!r}")
+    else:
+        problemas.append(
+            f"documento do tomador deve ser CPF (11) ou CNPJ (14 dígitos); recebido {doc!r}"
+        )
+    return problemas

pynfsenacional/danfse.py

@@ -0,0 +1,34 @@
+"""Geração local do DANFSe (PDF) a partir do XML da NFS-e. Lib: `BrazilFiscalReport`.
+
+Necessário porque a API de PDF do governo (ADN) é descontinuada em 01/07/2026
+(NT-008/2026) — ver docs/conhecimento-fiscal.md §1. Geramos o PDF localmente, a
+partir do XML devolvido pelo SEFIN.
+
+Os 2 gotchas do §6 (rótulo "SEM VALIDADE JURÍDICA" por `tpAmb` ≠ `ambGer`; UF do
+local da prestação resolvida pelo IBGE) **já vêm corrigidos upstream** na
+`BrazilFiscalReport` ≥ 1.0 — não precisamos repetir os patches da referência PHP.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def render(nfse_xml: str, destino: str | Path) -> str:
+    """Gera o PDF do DANFSe a partir do XML da NFS-e; devolve o caminho do PDF.
+
+    `nfse_xml`: o XML da NFS-e devolvido pelo SEFIN (não o da DPS).
+
+    Requer o extra opcional: `pip install PyNFSeNacionalGT[danfse]`.
+    """
+    try:
+        from brazilfiscalreport.danfse import Danfse
+    except ImportError as e:
+        raise ImportError(
+            "geração do DANFSe requer o extra opcional: pip install PyNFSeNacionalGT[danfse]"
+        ) from e
+
+    destino = Path(destino)
+    destino.parent.mkdir(parents=True, exist_ok=True)
+    Danfse(xml=nfse_xml).output(str(destino))
+    return str(destino)

pynfsenacional/documentos.py

@@ -0,0 +1,43 @@
+"""Validação de CPF/CNPJ (dígito verificador mód-11) — stdlib pura.
+
+Usado pela validação fiscal (`config.validar`, tomador da DPS). Isolado aqui para
+ser testável de forma independente (inclusive property-based) e reutilizável.
+"""
+
+from __future__ import annotations
+
+import re
+
+_NAO_DIGITO = re.compile(r"\D")
+
+
+def digitos(s: str | None) -> str:
+    """Remove tudo que não for dígito (espelha `gt_digitos` do PHP)."""
+    return _NAO_DIGITO.sub("", s or "")
+
+
+def _mod11_dv(base: str, pesos: list[int]) -> int:
+    """Dígito verificador mód-11 da Receita: resto<2 → 0, senão 11−resto."""
+    soma = sum(int(d) * p for d, p in zip(base, pesos, strict=True))
+    resto = soma % 11
+    return 0 if resto < 2 else 11 - resto
+
+
+def cpf_valido(valor: str | None) -> bool:
+    """True se `valor` (com ou sem máscara) é um CPF válido (11 díg + mód-11)."""
+    cpf = digitos(valor)
+    if len(cpf) != 11 or cpf == cpf[0] * 11:  # rejeita repetidos (00000000000…)
+        return False
+    dv1 = _mod11_dv(cpf[:9], list(range(10, 1, -1)))
+    dv2 = _mod11_dv(cpf[:10], list(range(11, 1, -1)))
+    return cpf[9] == str(dv1) and cpf[10] == str(dv2)
+
+
+def cnpj_valido(valor: str | None) -> bool:
+    """True se `valor` (com ou sem máscara) é um CNPJ válido (14 díg + mód-11)."""
+    cnpj = digitos(valor)
+    if len(cnpj) != 14 or cnpj == cnpj[0] * 14:
+        return False
+    dv1 = _mod11_dv(cnpj[:12], [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2])
+    dv2 = _mod11_dv(cnpj[:13], [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2])
+    return cnpj[12] == str(dv1) and cnpj[13] == str(dv2)