simples-nacional-br

# simples-nacional-br

[![testes](https://github.com/peterwkdev-creator/simples-nacional-br/actions/workflows/testes.yml/badge.svg)](https://github.com/peterwkdev-creator/simples-nacional-br/actions/workflows/testes.yml)

Alíquota efetiva, valor do mês e Fator R do **Simples Nacional**, conferidos
faixa a faixa contra as tabelas oficiais da Lei Complementar 123/2006
(redação da LC 155/2016) e, de 2027 em diante, da LC 214/2025. Python puro,
só a biblioteca padrão, `Decimal` do começo ao fim.

![A página calcula o exemplo do Anexo III e depois o mesmo mês pelo Fator R](docs/vitrine.gif)

**[Experimente no navegador](https://peterwkdev-creator.github.io/simples-nacional-br/)**:
a página roda esta mesma biblioteca, testada, no seu navegador (Pyodide):
alíquota efetiva, valor do mês, a parte de cada tributo e, com o Fator R,
a folha que leva ao Anexo III e quanto muda o DAS. Nenhum número sai do
seu computador. Na primeira visita o navegador baixa
cerca de 6 MB (o Python do Pyodide; a biblioteca são 61 KB); depois, cada
conta leva de 0 a 2 ms (medido na página publicada em 10/10/2026).

> **É estimativa, não consultoria tributária.** Não substitui o PGDAS-D nem o
> contador. Todos os exemplos usam números inventados.

## Instalar

```bash
pip install "git+https://github.com/peterwkdev-creator/simples-nacional-br@v1.4.3"
```

Sem dependência; Python 3.9 ou mais novo. Para só experimentar, nem precisa
instalar: do checkout limpo, os dois comandos abaixo rodam como estão.

```bash
python -m unittest
```

```bash
python -m simples_nacional --ano 2026 --anexo I --rbt12 4500000 --receita-mes 375000
```

Testado a cada push com Python 3.9 a 3.14 (Linux) e 3.13 (Windows).
Sem `--ano`, a linha de comando usa o ano corrente e diz qual tabela usou.

## Uso

```python
from simples_nacional import aliquota_efetiva, anexo_por_fator_r, avisos, valor_devido

aliquota_efetiva("I", 4_500_000, ano=2026)       # Decimal('0.106')
valor_devido("I", 4_500_000, "375000", ano=2026) # Decimal('39750.00')
anexo_por_fator_r(280_000, 1_000_000)            # 'III'
avisos(4_500_000, ano=2026)                      # ['RBT12 acima do sublimite ...']
```

`ano` é o ano-calendário do **mês de apuração**, não o de hoje: o DAS de
dezembro de 2026, calculado em janeiro de 2027, usa a tabela de 2026.
Valores em `Decimal`, `int` ou `str`; `float` é recusado, porque erra
centavo. RBT12 acima de R$ 4,8 milhões levanta `LimiteExcedido` (um
`ValueError`). Sublimite, início de atividade e a leitura de números no
formato brasileiro estão em [Mais exemplos](#mais-exemplos).

## Por quê

A alíquota efetiva não é a alíquota impressa no anexo. LC 123, art. 18,
§ 1º-A:

```
alíquota efetiva = (RBT12 × alíquota nominal − parcela a deduzir) / RBT12
```

RBT12 é a receita bruta dos 12 meses anteriores ao período de apuração (a
partir de 2027, dos 12 meses antecedentes ao mês anterior: para apurar março,
de fevereiro do ano anterior a janeiro; LC 123, art. 18, § 1º, na redação da
LC 214/2025). Um
comércio com RBT12 de R$ 4.500.000,00 está na 6ª faixa do Anexo I (nominal
19%, parcela a deduzir R$ 378.000,00):

```
(4.500.000 × 19% − 378.000) / 4.500.000 = 477.000 / 4.500.000 = 10,60%
```

Aplicar a nominal de 19% dá R$ 855.000,00 no ano, onde a lei dá
R$ 477.000,00. É o erro relatado em
[mcp-fiscal-brasil#146](https://github.com/DeHor-Labs/mcp-fiscal-brasil/issues/146).

## O que cobre

- Anexos I a V, seis faixas cada (teto, alíquota nominal, parcela a
  deduzir), com a alíquota efetiva e o valor do mês.
- Fator R: folha de 12 meses ÷ RBT12; 28% ou mais vai para o Anexo III,
  senão para o V. E o planejamento: a folha que leva a 28%, quanto falta e
  o valor do mês nos dois anexos.
- Teto de R$ 4,8 milhões: erro explicado, nunca número.
- Sublimite de R$ 3,6 milhões: aviso de que o valor é só a parte federal;
  a pedido, o ICMS ou ISS (e o IBS, desde 2027) pela 5ª faixa; até 2026, o
  mês em que a receita do ano passa do sublimite.
- Início de atividade, mês a mês, e o limite proporcional no ano de início.
- Tabela do ano de apuração: em 2027 e 2028 a 6ª faixa tem nominal 0,1
  ponto menor; a partir de 2029 volta a de hoje.
- Repartição do valor do mês por tributo (IRPJ, CSLL, Cofins, PIS, CPP,
  ICMS, ISS e, de 2027 em diante, CBS e IBS), com a tabela de cada período
  de 2018 a 2033.
- CNAE → anexo: a subclasse que impede o Simples, a ambígua (Res. CGSN
  140, Anexos VI e VII) e, para as outras, o anexo pela LC 123, art. 18,
  com o Fator R quando ele decide; a indústria vai ao Anexo I de 2027 em
  diante.
- Servidor MCP, para o Claude e outros assistentes chamarem as mesmas
  contas: valor do mês, repartição, Fator R e CNAE.

Fora do escopo, entre outros: sublimites estaduais, exportação e MEI. A
lista completa e a fonte legal de cada regra estão em [Fontes e limites](#fontes-e-limites).

## Como é testado

- Um caso por faixa de cada anexo (30), com a conta à mão escrita no teste e
  refeita a partir dos números da própria linha.
- O teto de cada faixa fica na faixa de baixo (o anexo diz "até"); um
  centavo acima sobe de faixa.
- Fator R em 27,99%, 28% e 28,01%.
- A 6ª faixa de 2027 e 2028 nos cinco anexos, com a conta à mão; as faixas 1
  a 5 iguais às de hoje; 2018, 2026, 2029 e depois com a tabela de hoje.
- Início de atividade: 1º, 2º, 4º e 12º mês até 2026; 1º, 2º, 3º, 5º e 13º
  a partir de 2027, com o mês anterior ao de apuração fora da média.
- ICMS, ISS e IBS pela 5ª faixa em 2027, 2028, 2029, 2030, 2031, 2032, 2033
  e depois, com a conta à mão; o mês que passa do sublimite com o RBT12 na
  1ª, 4ª, 5ª e 6ª faixa, com e sem o teto de 5% do ISS, com e sem
  impedimento, e nas fronteiras de 20% do sublimite e do limite.
- Teste de mutação: trocar qualquer um dos 90 valores da tabela, uma das
  cinco nominais de 2027, um dos 85 percentuais de repartição, uma fronteira
  de ano ou uma regra do início de atividade, um de cada vez, derruba pelo
  menos um teste.
- Os exemplos em Python deste README rodam como estão, num teste.

Arredondamento: a lei não fixa regra. A alíquota efetiva guarda todos os
dígitos; o valor do mês é arredondado em centavos com `ROUND_HALF_UP`. As
contas usam um contexto `Decimal` próprio (28 dígitos): um
`getcontext().prec` mudado no programa de quem usa a biblioteca não muda o
resultado. Na linha de comando, a efetiva da linha "Valor do mês" sai com
as casas (4 ou mais) que fecham a conta no centavo, e o Fator R é cortado,
não arredondado, na 4ª casa: 27,99999% aparece 27,9999%, ao lado do Anexo V.

## Mais exemplos

```python
from simples_nacional import (aliquota_efetiva, valor_devido, valor_devido_acima_do_sublimite,
                              valor_devido_inicio_atividade)

aliquota_efetiva("I", 4_500_000, ano=2027)      # Decimal('0.105'): 6ª faixa de 2027

# acima do sublimite com a receita do ano dentro dele, até 2026:
# 6ª faixa só federal (10,6%) + ICMS pela 5ª faixa (12,36% × 33,5% = 4,1406%)
aliquota_efetiva("I", 4_500_000, ano=2026, icms_iss_no_das=True)       # Decimal('0.14740600')
valor_devido("I", 4_500_000, "375000", ano=2026, icms_iss_no_das=True) # Decimal('55277.25')

# de 2027 em diante, também o IBS: 10,5% + 12,36% × (33,50% + 0,17%)
aliquota_efetiva("I", 4_500_000, ano=2027, icms_iss_no_das=True)       # Decimal('0.14661612')

# até 2026, o mês em que a receita do ano (3.400.000 antes dele) passa do sublimite:
# 200.000 dentro, pela efetiva com ISS, e 300.000 acima, federais + ISS em 3.600.000
valor_devido_acima_do_sublimite("III", 4_000_000, 500_000, 3_400_000, ano=2026)  # Decimal('113563.08')

# início de atividade: receita de cada mês, do 1º até o de apuração
valor_devido_inicio_atividade("I", [30_000, 50_000], ano=2026)  # Decimal('2825.00')
valor_devido_inicio_atividade("I", [400_000], ano=2027)         # Decimal('16000.00'), 1ª faixa
```

Na linha de comando, o ICMS ou o ISS pela 5ª faixa vem com
`--icms-iss-no-das`, e a saída mostra as duas parcelas da efetiva:

```bash
python -m simples_nacional --ano 2026 --anexo I --rbt12 4500000 --receita-mes 375000 --icms-iss-no-das
```

Até 2026, `--receita-ano` (a receita do ano antes do mês de apuração) calcula
o mês em que ela passa do sublimite e mostra cada parcela:

```bash
python -m simples_nacional --ano 2026 --anexo III --rbt12 4000000 --receita-mes 500000 --receita-ano 3400000
```

Na linha de comando, o início de atividade vai em `--receitas`, separadas
por ponto e vírgula, no lugar de `--rbt12` e `--receita-mes`:

```bash
python -m simples_nacional --ano 2026 --anexo I --receitas "30.000;50.000"
```

Com `--mes-inicio` (o mês do calendário em que a atividade começou, de 1 a
12), a saída confere a receita do ano de início contra o limite e o
sublimite proporcionais; sem ele, avisa quando a receita passa de
R$ 300.000,00 por mês e pede o mês. Na API, o mesmo vem de
`avisos_inicio_atividade(receitas, mes_inicio, ano=...)`:

```python
from simples_nacional import avisos_inicio_atividade

# aberta em novembro: 2 meses até dezembro, limite 800.000 e sublimite 600.000
avisos_inicio_atividade([300_000, 400_000], 11, ano=2026)
# ['Receita acumulada no ano de início de atividade (2026) de R$ 700.000,00,
#   acima do sublimite proporcional de R$ 600.000,00 ...']
```

Na linha de comando e em `ler_numero`, números aceitos: `4500000`,
`4500000.00`, `1000,50`, `1.000,50` e
`360.000` (ponto seguido de três dígitos é milhar), com ou sem `R$` na
frente e espaço nas pontas, como o Excel copia a célula (`R$ 1.000,50`). O
que é ambíguo, como `1,000.50` ou `100 000`, dá erro em vez de virar outro
número. `--version` mostra a versão instalada.

A mesma leitura e a saída no formato brasileiro são públicas, para quem
integra a biblioteca num sistema:

```python
from decimal import Decimal
from simples_nacional import ler_numero, para_decimal, porcentagem, reais

ler_numero("360.000")                 # Decimal('360000'); ambíguo: ValueError
para_decimal("1000.50", "receita")    # Decimal('1000.50'); float: TypeError
para_decimal("360.000", "receita")    # Decimal('360.000'