CoolFace
Modelpublic

LesterCerioli/Speed

sourceHugging Facemitupdated 3mo agoView on Hugging Face
0likes
Model Card

LLM Fiscal Brasileiro — SPED Fiscal System

PyTorch-powered LLM for Brazilian fiscal obligations (SPED) Python 3.12 · PyTorch · Pydantic v2 · 117 tests

Table of Contents / Índice

English

Overview

The Brazilian Fiscal LLM is a Python 3.12 library that combines a custom PyTorch Transformer with a complete set of Brazilian tax compliance tools. It is designed to be consumed as a library by any application — there is no CLI or UI bundled in.

The system covers the full lifecycle of Brazilian fiscal obligations:

  • —Intent classification of natural-language fiscal queries (16 obligation classes)
  • —RAG (Retrieval-Augmented Generation) with 25 indexed fiscal knowledge documents
  • —Tax calculators for all major Brazilian taxes (ICMS, IPI, PIS/COFINS, IRPJ/CSLL, ISS, Simples Nacional)
  • —SPED file generators for all federal digital bookkeeping obligations
  • —Electronic document generators (NF-e, NFC-e, CT-e, MDF-e) with digital signatures
  • —SEFAZ SOAP transmitter for NF-e authorization

The single entry point is PipelineFiscal, which orchestrates all components.

Architecture

┌──────────────────────────────────────────────────────────────────┐
│                        PipelineFiscal                            │
│  (src/models/fiscal_llm.py)                                      │
│                                                                  │
│  ┌─────────────────────┐   ┌──────────────────────────────────┐  │
│  │  TransformerFiscal  │   │   BancoEmbeddingsFiscais (RAG)   │  │
│  │  PyTorch 4-layer    │   │   25 knowledge documents         │  │
│  │  encoder, d=256     │   │   cosine similarity search       │  │
│  │  8 heads, Pre-LN    │   └──────────────────────────────────┘  │
│  └─────────────────────┘                                         │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │              Intent Classification (16 classes)             │ │
│  └─────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  ┌──────────────────┐  ┌──────────────────┐  ┌───────────────┐  │
│  │  Tax Calculators │  │  SPED Generators │  │  DFe / XML    │  │
│  │  ICMS · IPI      │  │  EFD ICMS/IPI    │  │  NF-e · NFC-e │  │
│  │  PIS/COFINS      │  │  EFD Contribu.   │  │  CT-e · MDF-e │  │
│  │  IRPJ/CSLL · ISS │  │  ECD · ECF       │  │  EFD-Reinf    │  │
│  │  Simples Nac.    │  │  DCTF · GIA      │  │  e-Social     │  │
│  └──────────────────┘  │  DIRF · DEFIS    │  └───────────────┘  │
│                         │  DeSTDA          │                     │
│                         └──────────────────┘                     │
└──────────────────────────────────────────────────────────────────┘

Key design decisions:

  • —The LLM (TransformerFiscal) uses character-level tokenization — no external tokenizer dependency.
  • —RAG runs entirely in-memory using normalized cosine similarity on CLS embeddings.
  • —All monetary values use Python Decimal with ROUND_HALF_UP — no floating-point arithmetic.
  • —SPED files are pipe-delimited (|REGISTRO|CAMPO1|) UTF-8, matching the official Receita Federal spec.
  • —NF-e/CT-e/MDF-e use XML v4.00 with RSA-SHA1 XMLDSig digital signatures via the cryptography library.

Project Structure

llm-speed/
├── src/
│   ├── __init__.py                  # Exports PipelineFiscal
│   ├── fiscal/
│   │   ├── entities.py              # Pydantic v2 models (Empresa, NotaFiscal, …)
│   │   └── constants.py             # Tax rates, CST tables, CFOP codes, deadlines
│   ├── calculators/
│   │   ├── icms.py                  # ICMS (own + ST + DIFAL + FCP)
│   │   ├── ipi.py                   # IPI (TIPI rates by NCM chapter)
│   │   ├── pis_cofins.py            # PIS/COFINS (cumulative + non-cumulative + withholding)
│   │   ├── irpj_csll.py             # IRPJ/CSLL (Lucro Real + Lucro Presumido + monthly estimates)
│   │   ├── iss.py                   # ISS (LC 116/2003 + Simples Nacional annexes)
│   │   └── simples_nacional.py      # Simples Nacional (5 annexes, Fator R, PGDAS-D, MEI)
│   ├── generators/
│   │   ├── sped_writer.py           # Base SPED pipe-delimited writer
│   │   ├── efd_icms_ipi.py          # EFD ICMS/IPI (blocks 0,C,E,G,H,K,1,9)
│   │   ├── efd_contribuicoes.py     # EFD Contribuições PIS/COFINS (blocks 0,C,M,1,9)
│   │   ├── ecd.py                   # ECD — Escrituração Contábil Digital
│   │   ├── ecf.py                   # ECF — Escrituração Contábil Fiscal (LALUR/LACS)
│   │   ├── nfe_xml.py               # NF-e XML v4.00 (model 55) + digital signature
│   │   ├── nfce_xml.py              # NFC-e XML v4.00 (model 65, consumer/POS)
│   │   ├── cte.py                   # CT-e XML v4.00 (model 57, freight)
│   │   ├── mdfe.py                  # MDF-e XML v3.00 (manifest, model 58)
│   │   ├── efd_reinf.py             # EFD-Reinf XML events (R-1000…R-2099)
│   │   ├── esocial.py               # e-Social XML events (S-1000…S-1299, S-2200, S-2299)
│   │   ├── dctf.py                  # DCTF XML (federal tax debit declaration)
│   │   ├── dirf.py                  # DIRF text file (annual IRRF withholding declaration)
│   │   ├── defis.py                 # DEFIS XML (Simples Nacional annual declaration)
│   │   ├── destda.py                # DeSTDA XML (Simples Nacional monthly ICMS-ST/DIFAL)
│   │   └── gia.py                   # GIA/GIA-ST AIE file (São Paulo monthly ICMS)
│   ├── models/
│   │   ├── fiscal_llm.py            # TransformerFiscal + RAG + PipelineFiscal
│   │   └── trainer.py               # TrainerFiscal (173 examples, early stopping, class weights)
│   └── transmitters/
│       └── receita_federal.py       # NF-e SEFAZ SOAP transmitter + SPED local validator
├── tests/
│   ├── test_calculators.py          # 43 tests for all tax calculators
│   └── test_generators.py           # 74 tests for all generators
├── pyproject.toml
└── requirements.txt

Installation

Requirements: Python 3.12+, pip

bash
# Clone the repository
git clone <repo-url>
cd llm-speed

# Create and activate virtual environment
python -m venv venv
source venv/bin/activate        # Linux/macOS
# venv\Scripts\activate         # Windows

# Install dependencies
pip install -r requirements.txt

Core dependencies:

PackagePurpose
torch>=2.3.0TransformerFiscal model + training
pydantic>=2.7.0Validated fiscal data models
cryptography>=42.0.0NF-e/CT-e XML digital signatures (RSA-SHA1)
lxml>=5.2.0C14N canonicalization for XMLDSig
httpx>=0.27.0SEFAZ SOAP HTTP client
zeep>=4.2.1SOAP envelope helpers
python-dateutil>=2.9.0Brazilian fiscal calendar calculations

Quick Start

python
from src import PipelineFiscal

# Instantiate the LLM pipeline (uses random weights until trained)
pipeline = PipelineFiscal(diretorio_saida="./output")

# --- Natural language processing ---
resultado = pipeline.processar(
    "calculate ICMS for a sale",
    {"valor_mercadoria": 10000, "aliquota": 18, "uf_origem": "SP", "uf_destino": "RJ"}
)
print(resultado.resumo())
# [calcular_icms]
#   base_calculo: R$ 10,000.00
#   aliquota: R$ 18.00
#   valor_icms: R$ 1,800.00
#   valor_total_icms: R$ 1,800.00

# --- Direct tax calculation ---
r = pipeline.calcular_pis_cofins({
    "valor": 100000,
    "regime": "lucro_presumido",
})
print(r["pis_a_recolher"])   # 650.00
print(r["cofins_a_recolher"]) # 3000.00

# --- Generate SPED files for an entire period ---
from src.fiscal.entities import PeriodoApuracao, Empresa, ...
periodo = PeriodoApuracao(...)
arquivos = pipeline.gerar_obrigacoes(periodo)
# Returns: {"EFD_ICMS_IPI": ResultadoFiscal, "EFD_CONTRIBUICOES": ..., ...}

# --- SEFAZ status check ---
status = pipeline.verificar_sefaz(uf="SP")
print(status["mensagem"])

LLM Model

TransformerFiscal

A compact Transformer encoder trained for Brazilian fiscal intent classification.

ParameterValue
ArchitectureTransformer Encoder (Pre-LN)
Layers4
d_model256
Attention heads8
FFN dimension1,024
TokenizerCharacter-level (vocab ~200 chars)
Max sequence length1,024 tokens
Output classes16 fiscal obligation types

16 Intent Classes:

ClassDescription
EFD_ICMS_IPIGenerate EFD ICMS/IPI digital bookkeeping
EFD_CONTRIBUICOESGenerate EFD Contribuições (PIS/COFINS)
ECDGenerate Escrituração Contábil Digital
ECFGenerate Escrituração Contábil Fiscal
NFeEmit / cancel NF-e or NFC-e
NFSeEmit NFS-e (municipal service invoice)
CTeGenerate CT-e freight document
eSocialGenerate e-Social payroll events
EFD_REINFGenerate EFD-Reinf withholding events
DCTFGenerate DCTF federal tax declaration
PGDASCalculate Simples Nacional DAS / PGDAS-D
calculo_icmsCalculate ICMS for a transaction
calculo_ipiCalculate IPI for industrial products
calculo_pis_cofinsCalculate PIS and COFINS on revenue
calculo_irpj_csllCalculate IRPJ and CSLL (corporate taxes)
calculo_issCalculate ISS (municipal services tax)

RAG Knowledge Base

BancoEmbeddingsFiscais indexes 25 fiscal knowledge documents covering all major obligations, rates, deadlines, and legislation. Retrieval uses cosine similarity on CLS token embeddings.

python
# Direct access to RAG
pipeline.rag.buscar("prazo EFD ICMS IPI", top_k=3)
# Returns: [(text, similarity_score), ...]

Tax Calculators

All calculators are available directly via PipelineFiscal or imported from src.calculators.*. All monetary values use Decimal with ROUND_HALF_UP.

ICMS (src/calculators/icms.py)

python
resultado = pipeline.calcular_icms({
    "valor_mercadoria": 10000,
    "aliquota": 18,              # internal rate (%)
    "uf_origem": "SP",
    "uf_destino": "RJ",
    "frete": 500,
    "cst": "000",                # CST: 000=taxed, 020=reduced, 040=exempt, 060=ST
    "calcular_difal": False,
    "consumidor_final": False,
    # Optional ST parameters:
    # "calcular_st": True, "mva": 40, "aliq_interna_destino": 18
})

Supports: CST 000/010/020/030/040/041/050/051/060/070, ICMS-ST with MVA, FCP (Fundo de Combate à Pobreza), DIFAL (EC 87/2015).

IPI (src/calculators/ipi.py)

python
resultado = pipeline.calcular_ipi({
    "valor_produtos": 5000,
    "aliquota": 10,
    "cst": "50",   # 50=taxed, 52=exempt, 54=suspended
    "frete": 200,
})

Includes TIPI rates by NCM chapter (0% pharmaceuticals, 25% vehicles, 300% tobacco).

PIS/COFINS (src/calculators/pis_cofins.py)

python
resultado = pipeline.calcular_pis_cofins({
    "valor": 100000,
    "regime": "lucro_real",      # or "lucro_presumido"
    # Optional credits (non-cumulative regime only):
    "receitas": [
        {"descricao": "Vendas", "valor": 100000, "cst_pis": "01", "cst_cofins": "01"}
    ],
})
RegimePISCOFINS
Lucro Presumido (cumulative)0.65%3.00%
Lucro Real (non-cumulative)1.65%7.60%

Supports credits on purchases, energy, rent, depreciation (Lei 10.637/2002 and 10.833/2003).

IRPJ / CSLL (src/calculators/irpj_csll.py)

python
resultado = pipeline.calcular_irpj_csll({
    "valor": 500000,             # Lucro Real: net profit / Lucro Presumido: gross revenue
    "regime": "lucro_presumido", # or "lucro_real"
    "atividade": "venda_mercadorias",  # or "servicos_em_geral", "intermediacao"
})
RuleValue
IRPJ base rate15%
IRPJ surcharge+10% on profit > R$ 20,000/month
CSLL rate9% (general) / 15% (financial institutions)
Lucro Presumido — commerce/industry8% of revenue
Lucro Presumido — services32% of revenue
Tax loss carryforward limit30% of taxable profit

ISS (src/calculators/iss.py)

python
resultado = pipeline.calcular_iss({
    "valor_servico": 10000,
    "codigo_servico": "17",      # LC 116/2003 service code
    "aliquota": 3,               # municipal rate (2%–5%)
    "retencao_fonte": True,
})

Simples Nacional (src/calculators/simples_nacional.py)

python
# Single activity DAS calculation
resultado = pipeline.calcular_simples({
    "receita_mes": 50000,
    "rbt12": 600000,   # 12-month accumulated revenue
    "anexo": "I",      # I=commerce, II=industry, III-V=services
})

# Full PGDAS-D with multiple activities
resultado = pipeline.calcular_pgdas({
    "periodo": "2024-01",
    "rbt12": 600000,
    "atividades": [
        {"tipo": "comercio", "receita": 30000},
        {"tipo": "servicos_advocacia", "receita": 20000},
    ],
})

Covers all 5 annexes (6 revenue brackets each), Fator R calculation for Annex III vs V, and MEI fixed amounts.

SPED / DFe Generators

EFD ICMS/IPI (src/generators/efd_icms_ipi.py)

Layout version 017. Generates all mandatory blocks:

BlockContents
0Establishment identification, participants (0150), products (0200)
CNF-e records (C100, C110, C170, C190)
EICMS settlement (E110), IPI settlement (E520)
GCIAP — ICMS credits on permanent assets (G001, G110)
HPhysical inventory (H005, H010)
KProduction and stock control (K100, K200) — industrial companies
1Other information
9File control and closing
python
from src.generators.efd_icms_ipi import GeradorEFDICMSIPI
gerador = GeradorEFDICMSIPI(periodo)
caminho = gerador.gerar("./output")

EFD Contribuições (src/generators/efd_contribuicoes.py)

Layout version 006. PIS/COFINS digital bookkeeping.

Blocks: 0, C (documents), M (PIS/COFINS settlement — M100, M200, M600), 1, 9.

ECD (src/generators/ecd.py)

Layout version 010. Digital accounting bookkeeping.

Includes default chart of accounts (50+ accounts), journal entries (I200/I250), balance sheet (J150).

ECF (src/generators/ecf.py)

Layout version 009. Replaces the old DIPJ declaration.

BlockContents
0Tax parameters (0010), accountant (0930)
LLALUR/LACS adjustments (Lucro Real)
NIRPJ/CSLL calculation (N620, N630)
PLucro Presumido quarterly breakdown
YPartner information (Y600)

NF-e (src/generators/nfe_xml.py)

NF-e XML v4.00, model 55. Full document with all fiscal groups:

  • —ide — identification with 44-digit access key (Módulo 11)
  • —emit / dest — emitter and recipient
  • —det — items with ICMS (CST 000–090), IPI, PIS, COFINS per item
  • —total / transp / pag — totals, transport, payment
  • —AssinadorNFe — RSA-SHA1 XMLDSig using PKCS#12 certificate
python
from src.generators.nfe_xml import GeradorNFeXML, AssinadorNFe
gerador = GeradorNFeXML(emitente, destinatario, itens)
xml = gerador.gerar_xml()
xml_assinado = AssinadorNFe(cert_path, cert_password).assinar(xml)

NFC-e (src/generators/nfce_xml.py)

NFC-e XML v4.00, model 65. Consumer invoice for POS/retail. Optional CPF identification, QR Code URL.

CT-e (src/generators/cte.py)

CT-e XML v4.00, model 57. Freight transport fiscal document.

  • —Road modal (rodoviário) with RNTRC registration
  • —44-digit access key (Módulo 11, model 57)
  • —ICMS calculation on freight service
  • —Referenced NF-e documents

MDF-e (src/generators/mdfe.py)

MDF-e XML v3.00, model 58. Groups CT-e and NF-e documents in transport routes.

  • —Unload municipalities with referenced documents
  • —Driver registration
  • —Cargo insurance data
  • —44-digit access key (Módulo 11, model 58)

EFD-Reinf (src/generators/efd_reinf.py)

XML events for the EFD-Reinf (withholdings and social security information).

EventDescription
R-1000Employer registration
R-2010Services taken — INSS withholding
R-2020Services provided — INSS withholding
R-2060CPRB (payroll tax exemption)
R-2099Period closing

e-Social (src/generators/esocial.py)

XML events for Brazil's digital labor bookkeeping system.

EventDescription
S-1000Employer data table
S-1010Payroll items (rubricas) table — 16 standard CLT items
S-1200Monthly payroll (remuneração)
S-1299Monthly payroll closing
S-2200Employee admission
S-2299Employment termination (rescisão)

DCTF (src/generators/dctf.py)

XML for PGD DCTF Web. Monthly declaration of federal tax debits and credits.

python
from src.generators.dctf import montar_dctf_do_periodo
gerador = montar_dctf_do_periodo(
    empresa=empresa,
    periodo="2024-01",
    valor_irpj=Decimal("5000"),
    valor_csll=Decimal("1800"),
    valor_pis=Decimal("650"),
    valor_cofins=Decimal("3000"),
)
caminho = gerador.salvar("./output")
print(gerador.relatorio_resumo())

Annual Declarations

DIRF (src/generators/dirf.py)

Annual declaration of income tax withheld at source (IRRF). Text file format for PGD DIRF.

Deadline: Last business day of February.

python
from src.generators.dirf import GeradorDIRF, BeneficiarioDIRF, ResponsavelDIRF
gerador = GeradorDIRF(empresa, ano_calendario=2024, beneficiarios=[...], responsavel=...)
caminho = gerador.salvar("./output")

DEFIS (src/generators/defis.py)

Annual fiscal information declaration for Simples Nacional companies. XML format for the Simples Nacional portal.

Deadline: March 31 of the following year.

python
from src.generators.defis import GeradorDEFIS, ReceitaMensalDEFIS, SocioDEFIS
gerador = GeradorDEFIS(empresa, ano_calendario=2024, receitas_mensais=[...], socios=[...])
xml = gerador.gerar_xml()
print(gerador.relatorio_resumo())

DeSTDA (src/generators/destda.py)

Monthly declaration of ICMS-ST, DIFAL, and tax anticipation for Simples Nacional companies.

Deadline: 20th of the following month.

python
from src.generators.destda import GeradorDeSTDA, OperacaoSTDeSTDA
ops = [
    OperacaoSTDeSTDA("SP", "RJ", "ST",  base_calculo=Decimal("10000"),
                     aliquota=Decimal("18"), valor_imposto=Decimal("1800")),
    OperacaoSTDeSTDA("SP", "MG", "DIFAL", base_calculo=Decimal("5000"),
                     aliquota=Decimal("6"), valor_imposto=Decimal("300")),
]
gerador = GeradorDeSTDA(empresa, "2024-01", ops)
print(gerador.relatorio_resumo())

GIA / GIA-ST — São Paulo (src/generators/gia.py)

Monthly ICMS information and settlement guide for São Paulo state. AIE pipe-delimited file format for SEFAZ-SP / SCANC.

Deadline: 20th of the following month (may vary by revenue tier).

python
from src.generators.gia import GeradorGIA, ApuracaoGIA, ApuracaoGIAST
apuracao = ApuracaoGIA(
    debitos_operacoes_proprias=Decimal("50000"),
    creditos_entradas=Decimal("30000"),
)
gerador = GeradorGIA(empresa, "2024-01", apuracao, apuracoes_st=[
    ApuracaoGIAST("MG", Decimal("20000"), Decimal("12"), Decimal("2400")),
])
caminho = gerador.salvar("./output")   # → GIA_CNPJ_2024-01.aie

SEFAZ Transmitter

NF-e (src/transmitters/receita_federal.py)

python
from src.transmitters.receita_federal import TransmissorNFe

transmissor = TransmissorNFe(uf="SP", ambiente="2")  # ambiente 2=homologação

# Check service availability
status = transmissor.verificar_status_servico()

# Submit NF-e for authorization
resultado = transmissor.autorizar_nfe(xml_assinado)
print(resultado.protocolo)   # authorization protocol

# Cancel NF-e
resultado = transmissor.cancelar_nfe(chave, protocolo, justificativa)

SOAP endpoints: SP (SEFAZ-SP), SVRS (other states), SVAN (national contingency).

SPED Local Validator

python
from src.transmitters.receita_federal import TransmissorSPEDLocal, ValidadorArquivoSPED

# Validates required records and line counts
valido, erros = ValidadorArquivoSPED().validar(caminho_arquivo)

# Prepares file for PGE (Java program) transmission
resultado = TransmissorSPEDLocal("./output").preparar_efd_icms_ipi(caminho)
Note: EFD ICMS/IPI, EFD Contribuições, and ECD files must be transmitted through the Receita Federal's local PGE/Validador program — direct HTTP upload is not supported for SPED. Only NF-e uses direct SEFAZ SOAP webservices.

Training the Model

The TransformerFiscal ships with random weights. Use TrainerFiscal to train it on the built-in dataset (173 labeled examples) or your own data.

python
from src import PipelineFiscal

pipeline = PipelineFiscal()

# Train with built-in examples
history = pipeline.treinar(
    epochs=50,                          # early stopping kicks in before if val_loss plateaus
    caminho_saida="./checkpoints/fiscal_llm.pt",
)

# Load trained model
pipeline = PipelineFiscal(caminho_modelo="./checkpoints/fiscal_llm.pt")

# Evaluate per-class accuracy
from src.models.trainer import TrainerFiscal, EXEMPLOS_CLASSIFICACAO
from src.models.fiscal_llm import TokenizadorFiscal, TransformerFiscal, CLASSES_OBRIGACAO

tokenizador = TokenizadorFiscal()
trainer = TrainerFiscal(pipeline.modelo, tokenizador)
metricas = trainer.avaliar_por_classe(EXEMPLOS_CLASSIFICACAO)
print(f"Overall accuracy: {metricas['acuracia_geral']:.1%}")

Training configuration:

ParameterDefault
Epochs50
OptimizerAdamW
Learning rate3e-4 (OneCycleLR)
Batch size16
Gradient clipping1.0
Val split15%
Early stopping patience8 epochs
Class weightsEnabled (inverse frequency)

Running Tests

bash
pip install pytest pytest-asyncio
python -m pytest tests/ -v

117 tests covering all components:

ModuleTests
ICMS calculator9
IPI calculator6
PIS/COFINS calculator6
IRPJ/CSLL calculator7
ISS calculator5
Simples Nacional calculator9
SPED writer3
EFD ICMS/IPI (incl. Blocks G+K)10
EFD Contribuições3
ECD5
ECF3
NF-e6
NFC-e4
CT-e4
MDF-e4
EFD-Reinf3
e-Social3
DCTF5
DIRF4
DEFIS5
DeSTDA5
GIA5

Fiscal Calendar

ObligationFrequencyDeadline
DAS (Simples Nacional)MonthlyDay 20 of following month
DeSTDA (ICMS-ST Simples)MonthlyDay 20 of following month
GIA-SPMonthlyDay 20 of following month
EFD ICMS/IPIMonthly15th business day of following month
DCTFMonthly15th business day of 2nd following month
EFD ContribuiçõesMonthly10th business day of 2nd following month
EFD-ReinfMonthlyDay 15 of following month
e-Social (payroll)MonthlyDay 7 of following month
ECDAnnualLast business day of June
DEFIS (Simples Nacional)AnnualMarch 31
ECFAnnualLast business day of July
DIRFAnnualLast business day of February

Português Brasileiro

Visão Geral

O LLM Fiscal Brasileiro é uma biblioteca Python 3.12 que combina um Transformer PyTorch customizado com um conjunto completo de ferramentas de compliance tributário brasileiro. O sistema é projetado para ser consumido como biblioteca por qualquer aplicação — não há CLI ou interface gráfica embutida.

O sistema cobre o ciclo de vida completo das obrigações fiscais brasileiras:

  • —Classificação de intenção de consultas fiscais em linguagem natural (16 classes de obrigações)
  • —RAG (Geração Aumentada por Recuperação) com 25 documentos de conhecimento fiscal indexados
  • —Calculadoras tributárias para todos os principais tributos brasileiros (ICMS, IPI, PIS/COFINS, IRPJ/CSLL, ISS, Simples Nacional)
  • —Geradores de arquivos SPED para todas as obrigações de escrituração digital federal
  • —Geradores de documentos eletrônicos (NF-e, NFC-e, CT-e, MDF-e) com assinatura digital
  • —Transmissor SOAP SEFAZ para autorização de NF-e

O ponto de entrada único é o PipelineFiscal, que orquestra todos os componentes.

Arquitetura

┌──────────────────────────────────────────────────────────────────┐
│                        PipelineFiscal                            │
│  (src/models/fiscal_llm.py)                                      │
│                                                                  │
│  ┌─────────────────────┐   ┌──────────────────────────────────┐  │
│  │  TransformerFiscal  │   │   BancoEmbeddingsFiscais (RAG)   │  │
│  │  PyTorch encoder    │   │   25 documentos de conhecimento  │  │
│  │  4 camadas, d=256   │   │   busca por similaridade cosseno │  │
│  │  8 cabeças, Pre-LN  │   └──────────────────────────────────┘  │
│  └─────────────────────┘                                         │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │         Classificação de Intenção (16 classes)              │ │
│  └─────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  ┌──────────────────┐  ┌──────────────────┐  ┌───────────────┐  │
│  │   Calculadoras   │  │ Geradores SPED   │  │  DFe / XML    │  │
│  │  ICMS · IPI      │  │  EFD ICMS/IPI   │  │  NF-e · NFC-e │  │
│  │  PIS/COFINS      │  │  EFD Contribu.  │  │  CT-e · MDF-e │  │
│  │  IRPJ/CSLL · ISS │  │  ECD · ECF      │  │  EFD-Reinf    │  │
│  │  Simples Nac.    │  │  DCTF · GIA     │  │  e-Social     │  │
│  └──────────────────┘  │  DIRF · DEFIS   │  └───────────────┘  │
│                         │  DeSTDA         │                     │
│                         └──────────────────┘                     │
└──────────────────────────────────────────────────────────────────┘

Decisões de design:

  • —O LLM usa tokenização em nível de caractere — sem dependência de tokenizador externo.
  • —O RAG roda inteiramente em memória usando similaridade cosseno nos embeddings CLS.
  • —Todos os valores monetários usam Decimal Python com ROUND_HALF_UP — zero aritmética de ponto flutuante.
  • —Arquivos SPED são pipe-delimitados (|REGISTRO|CAMPO1|) em UTF-8, seguindo a especificação oficial da Receita Federal.
  • —NF-e/CT-e/MDF-e usam XML v4.00 com assinaturas digitais RSA-SHA1 XMLDSig via biblioteca cryptography.

Estrutura do Projeto

llm-speed/
├── src/
│   ├── __init__.py                  # Exporta PipelineFiscal
│   ├── fiscal/
│   │   ├── entities.py              # Modelos Pydantic v2 (Empresa, NotaFiscal, …)
│   │   └── constants.py             # Alíquotas, tabelas CST, CFOPs, prazos
│   ├── calculators/
│   │   ├── icms.py                  # ICMS (próprio + ST + DIFAL + FCP)
│   │   ├── ipi.py                   # IPI (alíquotas TIPI por capítulo NCM)
│   │   ├── pis_cofins.py            # PIS/COFINS (cumulativo + não cumulativo + retenção)
│   │   ├── irpj_csll.py             # IRPJ/CSLL (Lucro Real + Lucro Presumido + estimativa)
│   │   ├── iss.py                   # ISS (LC 116/2003 + anexos Simples Nacional)
│   │   └── simples_nacional.py      # Simples Nacional (5 anexos, Fator R, PGDAS-D, MEI)
│   ├── generators/
│   │   ├── sped_writer.py           # Escritor base SPED pipe-delimitado
│   │   ├── efd_icms_ipi.py          # EFD ICMS/IPI (blocos 0,C,E,G,H,K,1,9)
│   │   ├── efd_contribuicoes.py     # EFD Contribuições PIS/COFINS (blocos 0,C,M,1,9)
│   │   ├── ecd.py                   # ECD — Escrituração Contábil Digital
│   │   ├── ecf.py                   # ECF — Escrituração Contábil Fiscal (LALUR/LACS)
│   │   ├── nfe_xml.py               # NF-e XML v4.00 (modelo 55) + assinatura digital
│   │   ├── nfce_xml.py              # NFC-e XML v4.00 (modelo 65, consumidor/PDV)
│   │   ├── cte.py                   # CT-e XML v4.00 (modelo 57, transporte)
│   │   ├── mdfe.py                  # MDF-e XML v3.00 (manifesto, modelo 58)
│   │   ├── efd_reinf.py             # EFD-Reinf XML eventos (R-1000…R-2099)
│   │   ├── esocial.py               # e-Social XML eventos (S-1000…S-1299, S-2200, S-2299)
│   │   ├── dctf.py                  # DCTF XML (declaração de débitos tributários federais)
│   │   ├── dirf.py                  # DIRF arquivo texto (declaração anual IRRF)
│   │   ├── defis.py                 # DEFIS XML (declaração anual Simples Nacional)
│   │   ├── destda.py                # DeSTDA XML (ICMS-ST/DIFAL mensal Simples Nacional)
│   │   └── gia.py                   # GIA/GIA-ST arquivo AIE (ICMS mensal São Paulo)
│   ├── models/
│   │   ├── fiscal_llm.py            # TransformerFiscal + RAG + PipelineFiscal
│   │   └── trainer.py               # TrainerFiscal (173 exemplos, early stopping, pesos por classe)
│   └── transmitters/
│       └── receita_federal.py       # Transmissor NF-e SOAP SEFAZ + validador SPED local
├── tests/
│   ├── test_calculators.py          # 43 testes das calculadoras tributárias
│   └── test_generators.py           # 74 testes dos geradores
├── pyproject.toml
└── requirements.txt

Instalação

Requisitos: Python 3.12+, pip

bash
# Clonar o repositório
git clone <repo-url>
cd llm-speed

# Criar e ativar ambiente virtual
python -m venv venv
source venv/bin/activate        # Linux/macOS
# venv\Scripts\activate         # Windows

# Instalar dependências
pip install -r requirements.txt

Dependências principais:

PacoteFinalidade
torch>=2.3.0Modelo TransformerFiscal + treinamento
pydantic>=2.7.0Modelos de dados fiscais validados
cryptography>=42.0.0Assinatura digital NF-e/CT-e (RSA-SHA1)
lxml>=5.2.0Canonicalização C14N para XMLDSig
httpx>=0.27.0Cliente HTTP SOAP SEFAZ
zeep>=4.2.1Auxiliares para envelope SOAP
python-dateutil>=2.9.0Cálculos de calendário fiscal brasileiro

Início Rápido

python
from src import PipelineFiscal

# Instanciar o pipeline LLM (pesos aleatórios até ser treinado)
pipeline = PipelineFiscal(diretorio_saida="./output")

# --- Processamento em linguagem natural ---
resultado = pipeline.processar(
    "calcule o ICMS de uma venda",
    {"valor_mercadoria": 10000, "aliquota": 18, "uf_origem": "SP", "uf_destino": "RJ"}
)
print(resultado.resumo())
# [calcular_icms]
#   base_calculo: R$ 10.000,00
#   valor_icms:   R$ 1.800,00
#   valor_total_icms: R$ 1.800,00

# --- Cálculo direto de tributos ---
r = pipeline.calcular_pis_cofins({
    "valor": 100000,
    "regime": "lucro_presumido",
})
print(r["pis_a_recolher"])    # 650.00
print(r["cofins_a_recolher"]) # 3000.00

# --- Gerar obrigações SPED do período ---
from src.fiscal.entities import PeriodoApuracao, Empresa, ...
periodo = PeriodoApuracao(...)
arquivos = pipeline.gerar_obrigacoes(periodo)
# Retorna: {"EFD_ICMS_IPI": ResultadoFiscal, "EFD_CONTRIBUICOES": ..., ...}

# --- Verificar status SEFAZ ---
status = pipeline.verificar_sefaz(uf="SP")
print(status["mensagem"])

Modelo LLM

TransformerFiscal

Encoder Transformer compacto treinado para classificação de intenção fiscal brasileira.

ParâmetroValor
ArquiteturaTransformer Encoder (Pre-LN)
Camadas4
d_model256
Cabeças de atenção8
Dimensão FFN1.024
TokenizadorNível de caractere (vocab ~200 chars)
Comprimento máximo de sequência1.024 tokens
Classes de saída16 tipos de obrigação fiscal

16 Classes de Intenção:

ClasseDescrição
EFD_ICMS_IPIGerar EFD ICMS/IPI
EFD_CONTRIBUICOESGerar EFD Contribuições (PIS/COFINS)
ECDGerar Escrituração Contábil Digital
ECFGerar Escrituração Contábil Fiscal
NFeEmitir/cancelar NF-e ou NFC-e
NFSeEmitir NFS-e (nota de serviço municipal)
CTeGerar CT-e (conhecimento de transporte)
eSocialGerar eventos e-Social (folha/admissão)
EFD_REINFGerar eventos EFD-Reinf (retenções)
DCTFGerar DCTF (débitos tributários federais)
PGDASCalcular DAS Simples Nacional / PGDAS-D
calculo_icmsCalcular ICMS de uma operação
calculo_ipiCalcular IPI de produto industrializado
calculo_pis_cofinsCalcular PIS e COFINS sobre receitas
calculo_irpj_csllCalcular IRPJ e CSLL (tributos corporativos)
calculo_issCalcular ISS (imposto municipal sobre serviços)

Base de Conhecimento RAG

BancoEmbeddingsFiscais indexa 25 documentos de conhecimento fiscal cobrindo todas as principais obrigações, alíquotas, prazos e legislação. A recuperação usa similaridade cosseno nos embeddings do token CLS.

python
# Acesso direto ao RAG
pipeline.rag.buscar("prazo EFD ICMS IPI", top_k=3)
# Retorna: [(texto, score_similaridade), ...]

Calculadoras Tributárias

Todas as calculadoras estão disponíveis via PipelineFiscal ou importadas de src.calculators.*. Todos os valores monetários usam Decimal com ROUND_HALF_UP.

ICMS (src/calculators/icms.py)

python
resultado = pipeline.calcular_icms({
    "valor_mercadoria": 10000,
    "aliquota": 18,              # alíquota interna (%)
    "uf_origem": "SP",
    "uf_destino": "RJ",
    "frete": 500,
    "cst": "000",                # CST: 000=tributado, 020=redução, 040=isento, 060=ST
    "calcular_difal": False,
    "consumidor_final": False,
    # Parâmetros opcionais ST:
    # "calcular_st": True, "mva": 40, "aliq_interna_destino": 18
})

Suporta: CST 000/010/020/030/040/041/050/051/060/070, ICMS-ST com MVA, FCP (Fundo de Combate à Pobreza), DIFAL (EC 87/2015).

IPI (src/calculators/ipi.py)

python
resultado = pipeline.calcular_ipi({
    "valor_produtos": 5000,
    "aliquota": 10,
    "cst": "50",   # 50=tributado, 52=isento, 54=suspenso
    "frete": 200,
})

Inclui alíquotas TIPI por capítulo NCM (0% farmacêuticos, 25% veículos, 300% cigarro).

PIS/COFINS (src/calculators/pis_cofins.py)

python
resultado = pipeline.calcular_pis_cofins({
    "valor": 100000,
    "regime": "lucro_real",      # ou "lucro_presumido"
    "receitas": [
        {"descricao": "Vendas", "valor": 100000, "cst_pis": "01", "cst_cofins": "01"}
    ],
})
RegimePISCOFINS
Lucro Presumido (cumulativo)0,65%3,00%
Lucro Real (não cumulativo)1,65%7,60%

Suporta créditos sobre compras, energia, aluguéis, depreciação (Leis 10.637/2002 e 10.833/2003).

IRPJ / CSLL (src/calculators/irpj_csll.py)

python
resultado = pipeline.calcular_irpj_csll({
    "valor": 500000,             # Lucro Real: lucro líquido / Lucro Presumido: receita bruta
    "regime": "lucro_presumido", # ou "lucro_real"
    "atividade": "venda_mercadorias",  # ou "servicos_em_geral", "intermediacao"
})
RegraValor
IRPJ alíquota base15%
IRPJ adicional+10% sobre lucro > R$ 20.000/mês
CSLL alíquota9% (geral) / 15% (financeiras)
Lucro Presumido — comércio/indústria8% da receita
Lucro Presumido — serviços32% da receita
Limite compensação prejuízos30% do lucro tributável

ISS (src/calculators/iss.py)

python
resultado = pipeline.calcular_iss({
    "valor_servico": 10000,
    "codigo_servico": "17",      # código da LC 116/2003
    "aliquota": 3,               # alíquota municipal (2%–5%)
    "retencao_fonte": True,
})

Simples Nacional (src/calculators/simples_nacional.py)

python
# Cálculo do DAS para uma atividade
resultado = pipeline.calcular_simples({
    "receita_mes": 50000,
    "rbt12": 600000,   # receita acumulada 12 meses
    "anexo": "I",      # I=comércio, II=indústria, III-V=serviços
})

# PGDAS-D completo com múltiplas atividades
resultado = pipeline.calcular_pgdas({
    "periodo": "2024-01",
    "rbt12": 600000,
    "atividades": [
        {"tipo": "comercio", "receita": 30000},
        {"tipo": "servicos_advocacia", "receita": 20000},
    ],
})

Cobre todos os 5 anexos (6 faixas cada), cálculo do Fator R para Anexo III vs V, e valores fixos do MEI.

Geradores SPED / DFe

EFD ICMS/IPI (src/generators/efd_icms_ipi.py)

Layout versão 017. Gera todos os blocos obrigatórios:

BlocoConteúdo
0Identificação do estabelecimento, participantes (0150), produtos (0200)
CRegistros NF-e (C100, C110, C170, C190)
EApuração ICMS (E110), apuração IPI (E520)
GCIAP — crédito ICMS sobre ativo permanente (G001, G110)
HInventário físico (H005, H010)
KControle de produção e estoque (K100, K200) — indústrias
1Outras informações
9Controle e encerramento do arquivo
python
from src.generators.efd_icms_ipi import GeradorEFDICMSIPI
gerador = GeradorEFDICMSIPI(periodo)
caminho = gerador.gerar("./output")

EFD Contribuições (src/generators/efd_contribuicoes.py)

Layout versão 006. Escrituração digital de PIS/COFINS.

Blocos: 0, C (documentos), M (apuração PIS/COFINS — M100, M200, M600), 1, 9.

ECD (src/generators/ecd.py)

Layout versão 010. Escrituração contábil digital.

Inclui plano de contas padrão (50+ contas), lançamentos (I200/I250), balanço (J150).

ECF (src/generators/ecf.py)

Layout versão 009. Substitui a DIPJ.

BlocoConteúdo
0Parâmetros fiscais (0010), contador (0930)
LAjustes LALUR/LACS (Lucro Real)
NCálculo IRPJ/CSLL (N620, N630)
PLucro Presumido por trimestre
YQuadro societário (Y600)

NF-e (src/generators/nfe_xml.py)

NF-e XML v4.00, modelo 55. Documento completo com todos os grupos fiscais:

  • —ide — identificação com chave de acesso 44 dígitos (Módulo 11)
  • —emit / dest — emitente e destinatário
  • —det — itens com ICMS (CST 000–090), IPI, PIS, COFINS por item
  • —total / transp / pag — totais, transporte, pagamento
  • —AssinadorNFe — assinatura RSA-SHA1 XMLDSig com certificado PKCS#12
python
from src.generators.nfe_xml import GeradorNFeXML, AssinadorNFe
gerador = GeradorNFeXML(emitente, destinatario, itens)
xml = gerador.gerar_xml()
xml_assinado = AssinadorNFe(cert_path, cert_password).assinar(xml)

NFC-e (src/generators/nfce_xml.py)

NFC-e XML v4.00, modelo 65. Nota do consumidor para PDV/varejo. Identificação do CPF opcional, URL QR Code.

CT-e (src/generators/cte.py)

CT-e XML v4.00, modelo 57. Documento fiscal para transporte de carga.

  • —Modal rodoviário com registro RNTRC
  • —Chave de acesso 44 dígitos (Módulo 11, modelo 57)
  • —Cálculo do ICMS sobre o serviço de transporte
  • —Documentos NF-e referenciados

MDF-e (src/generators/mdfe.py)

MDF-e XML v3.00, modelo 58. Agrupa CT-e e NF-e em rotas de transporte.

  • —Municípios de descarga com documentos referenciados
  • —Cadastro de condutores
  • —Dados do seguro de carga
  • —Chave de acesso 44 dígitos (Módulo 11, modelo 58)

EFD-Reinf (src/generators/efd_reinf.py)

Eventos XML para o EFD-Reinf (retenções e informações previdenciárias).

EventoDescrição
R-1000Cadastro do empregador
R-2010Serviços tomados — retenção INSS
R-2020Serviços prestados — retenção INSS
R-2060CPRB (contribuição previdenciária sobre receita bruta)
R-2099Fechamento do período

e-Social (src/generators/esocial.py)

Eventos XML para o sistema de escrituração digital trabalhista brasileiro.

EventoDescrição
S-1000Dados do empregador
S-1010Tabela de rubricas — 16 itens CLT padrão
S-1200Remuneração mensal (folha de pagamento)
S-1299Fechamento da folha mensal
S-2200Admissão de empregado
S-2299Desligamento (rescisão contratual)

DCTF (src/generators/dctf.py)

XML para o PGD DCTF Web. Declaração mensal de débitos e créditos tributários federais.

python
from src.generators.dctf import montar_dctf_do_periodo
gerador = montar_dctf_do_periodo(
    empresa=empresa,
    periodo="2024-01",
    valor_irpj=Decimal("5000"),
    valor_csll=Decimal("1800"),
    valor_pis=Decimal("650"),
    valor_cofins=Decimal("3000"),
)
caminho = gerador.salvar("./output")
print(gerador.relatorio_resumo())

Declarações Anuais

DIRF (src/generators/dirf.py)

Declaração anual do imposto de renda retido na fonte. Arquivo texto para o PGD DIRF.

Prazo: Último dia útil de fevereiro.

python
from src.generators.dirf import GeradorDIRF, BeneficiarioDIRF, ResponsavelDIRF
gerador = GeradorDIRF(empresa, ano_calendario=2024, beneficiarios=[...], responsavel=...)
caminho = gerador.salvar("./output")

DEFIS (src/generators/defis.py)

Declaração de informações socioeconômicas e fiscais para empresas do Simples Nacional. XML para o portal do Simples Nacional.

Prazo: 31 de março do ano seguinte.

python
from src.generators.defis import GeradorDEFIS, ReceitaMensalDEFIS, SocioDEFIS
gerador = GeradorDEFIS(empresa, ano_calendario=2024, receitas_mensais=[...], socios=[...])
xml = gerador.gerar_xml()
print(gerador.relatorio_resumo())

DeSTDA (src/generators/destda.py)

Declaração mensal de substituição tributária, diferencial de alíquota e antecipação para empresas do Simples Nacional.

Prazo: Dia 20 do mês seguinte.

python
from src.generators.destda import GeradorDeSTDA, OperacaoSTDeSTDA
ops = [
    OperacaoSTDeSTDA("SP", "RJ", "ST",    base_calculo=Decimal("10000"),
                     aliquota=Decimal("18"), valor_imposto=Decimal("1800")),
    OperacaoSTDeSTDA("SP", "MG", "DIFAL", base_calculo=Decimal("5000"),
                     aliquota=Decimal("6"),  valor_imposto=Decimal("300")),
]
gerador = GeradorDeSTDA(empresa, "2024-01", ops)
print(gerador.relatorio_resumo())

GIA / GIA-ST — São Paulo (src/generators/gia.py)

Guia de informação e apuração do ICMS mensal para o estado de São Paulo. Arquivo AIE pipe-delimitado para SEFAZ-SP / SCANC.

Prazo: Dia 20 do mês seguinte (pode variar por faixa de faturamento).

python
from src.generators.gia import GeradorGIA, ApuracaoGIA, ApuracaoGIAST
apuracao = ApuracaoGIA(
    debitos_operacoes_proprias=Decimal("50000"),
    creditos_entradas=Decimal("30000"),
)
gerador = GeradorGIA(empresa, "2024-01", apuracao, apuracoes_st=[
    ApuracaoGIAST("MG", Decimal("20000"), Decimal("12"), Decimal("2400")),
])
caminho = gerador.salvar("./output")   # → GIA_CNPJ_2024-01.aie

Transmissor SEFAZ

NF-e (src/transmitters/receita_federal.py)

python
from src.transmitters.receita_federal import TransmissorNFe

transmissor = TransmissorNFe(uf="SP", ambiente="2")  # ambiente 2=homologação

# Verificar disponibilidade do serviço
status = transmissor.verificar_status_servico()

# Transmitir NF-e para autorização
resultado = transmissor.autorizar_nfe(xml_assinado)
print(resultado.protocolo)   # protocolo de autorização

# Cancelar NF-e
resultado = transmissor.cancelar_nfe(chave, protocolo, justificativa)

Endpoints SOAP: SP (SEFAZ-SP), SVRS (demais estados), SVAN (contingência nacional).

Validador SPED Local

python
from src.transmitters.receita_federal import TransmissorSPEDLocal, ValidadorArquivoSPED

# Valida presença de registros obrigatórios e contagem de linhas
valido, erros = ValidadorArquivoSPED().validar(caminho_arquivo)

# Prepara arquivo para transmissão via PGE (programa Java)
resultado = TransmissorSPEDLocal("./output").preparar_efd_icms_ipi(caminho)
Observação: Os arquivos EFD ICMS/IPI, EFD Contribuições e ECD devem ser transmitidos pelo programa PGE/Validador da Receita Federal — não há upload HTTP direto para o SPED. Apenas a NF-e usa webservices SOAP diretos da SEFAZ.

Treinamento do Modelo

O TransformerFiscal é iniciado com pesos aleatórios. Use o TrainerFiscal para treiná-lo com o dataset built-in (173 exemplos rotulados) ou seus próprios dados.

python
from src import PipelineFiscal

pipeline = PipelineFiscal()

# Treinar com os exemplos built-in
historico = pipeline.treinar(
    epochs=50,                          # early stopping pode parar antes se val_loss parar de melhorar
    caminho_saida="./checkpoints/fiscal_llm.pt",
)

# Carregar modelo treinado
pipeline = PipelineFiscal(caminho_modelo="./checkpoints/fiscal_llm.pt")

# Avaliar acurácia por classe
from src.models.trainer import TrainerFiscal, EXEMPLOS_CLASSIFICACAO
from src.models.fiscal_llm import TokenizadorFiscal

tokenizador = TokenizadorFiscal()
trainer = TrainerFiscal(pipeline.modelo, tokenizador)
metricas = trainer.avaliar_por_classe(EXEMPLOS_CLASSIFICACAO)
print(f"Acurácia geral: {metricas['acuracia_geral']:.1%}")
for classe, acc in metricas["acuracia_por_classe"].items():
    print(f"  {classe}: {acc:.1%}")

Configuração de treinamento:

ParâmetroPadrão
Épocas50
OtimizadorAdamW
Learning rate3e-4 (OneCycleLR)
Batch size16
Gradient clipping1,0
Divisão validação15%
Paciência early stopping8 épocas
Pesos por classeHabilitado (frequência inversa)

Execução dos Testes

bash
pip install pytest pytest-asyncio
python -m pytest tests/ -v

117 testes cobrindo todos os componentes:

MóduloTestes
Calculadora ICMS9
Calculadora IPI6
Calculadora PIS/COFINS6
Calculadora IRPJ/CSLL7
Calculadora ISS5
Simples Nacional9
Escritor SPED3
EFD ICMS/IPI (incl. Blocos G+K)10
EFD Contribuições3
ECD5
ECF3
NF-e6
NFC-e4
CT-e4
MDF-e4
EFD-Reinf3
e-Social3
DCTF5
DIRF4
DEFIS5
DeSTDA5
GIA5

Calendário Fiscal

ObrigaçãoPeriodicidadePrazo
DAS (Simples Nacional)MensalDia 20 do mês seguinte
DeSTDA (ICMS-ST Simples)MensalDia 20 do mês seguinte
GIA-SPMensalDia 20 do mês seguinte
EFD ICMS/IPIMensal15º dia útil do mês seguinte
DCTFMensal15º dia útil do 2º mês seguinte
EFD ContribuiçõesMensal10º dia útil do 2º mês seguinte
EFD-ReinfMensalDia 15 do mês seguinte
e-Social (folha)MensalDia 7 do mês seguinte
ECDAnualÚltimo dia útil de junho
DEFIS (Simples Nacional)Anual31 de março
ECFAnualÚltimo dia útil de julho
DIRFAnualÚltimo dia útil de fevereiro

Sistema desenvolvido em Python 3.12 com PyTorch para o ecossistema fiscal brasileiro (SPED). 117 testes · 20 obrigações cobertas · 6 tributos calculados