├── .editorconfig ├── .gitattributes ├── .gitignore ├── .travis.yml ├── LICENSE ├── README.md ├── requeriments.txt ├── setup.cfg ├── setup.py ├── sped ├── __init__.py ├── arquivos.py ├── blocos.py ├── campos.py ├── ecd │ ├── __init__.py │ ├── arquivos.py │ ├── blocos.py │ ├── registros.py │ ├── tabelas.py │ └── tabelas │ │ ├── SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF$1$198 │ │ ├── SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_BACEN$1$199 │ │ ├── SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_SUSEP$1$200 │ │ ├── SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_TSE$1$225 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_A$13$386 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_A$6$386 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_B$4$387 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_B$6$387 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_C$4$388 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_A$4$395 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_B$1$396 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_B$2$396 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_C$1$397 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_C$2$397 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$12$389 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$3$389 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P150$3$398 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_A$2$390 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_B$3$391 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_B$4$391 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_C$2$392 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_D$3$393 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_D$7$393 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_E$2$394 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_A$1$399 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_B$1$400 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_C$1$401 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_D$2$402 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_D$3$402 │ │ ├── SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_E$1$403 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_ENTIDADES$2$201 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INDICADOR_INICIO_PERIODO$2$194 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INDICADOR_INICIO_PERIODO$2$202 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INSTITUICOES$1$203 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_MUNICIPIOS$3$204 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_NATUREZA$1$197 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_NATUREZA$1$205 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_PAISES$1$198 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_PAISES$1$206 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_QUALIFICACAO$3$207 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_RELACIONAMENTOS$1$200 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_RELACIONAMENTOS$1$208 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_SITUACAO$2$209 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_TIPO_PLANO_REF$1$406 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_TIPO_PLANO_REF$1$574 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF$1$210 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF_NIRE$1$203 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF_NIRE$1$211 │ │ ├── SPEDCONTABIL_GLOBAL$SPEDECF_NATUREZA_SUBCONTA$2$404 │ │ └── metadados ├── ecf │ ├── __init__.py │ ├── arquivos.py │ ├── blocos.py │ └── registros.py ├── efd │ ├── __init__.py │ ├── icms_ipi │ │ ├── __init__.py │ │ ├── arquivos.py │ │ ├── blocos.py │ │ └── registros.py │ └── pis_cofins │ │ ├── __init__.py │ │ ├── arquivos.py │ │ ├── blocos.py │ │ └── registros.py ├── erros.py ├── escrituracao.py ├── fci │ ├── __init__.py │ ├── arquivos.py │ ├── blocos.py │ └── registros.py ├── lcdpr │ ├── __init__.py │ ├── arquivos.py │ ├── blocos.py │ └── registros.py ├── leiaute.py ├── leiautes │ ├── ecd_2016.json │ ├── ecd_2017.json │ ├── ecf_2016.json │ └── ecf_2017.json └── registros.py └── test ├── __init__.py ├── fci_test.py └── pis_cofins.py /.editorconfig: -------------------------------------------------------------------------------- 1 | # http://editorconfig.org 2 | 3 | root = true 4 | 5 | [*] 6 | charset = utf-8 7 | end_of_line = lf 8 | insert_final_newline = true 9 | trim_trailing_whitespace = true 10 | 11 | [*.{py,rst,ini}] 12 | indent_style = space 13 | indent_size = 4 14 | 15 | [*.{yml,html,css,js}] 16 | indent_style = space 17 | indent_size = 2 18 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Basics 2 | *.py[cod] 3 | *.pyc 4 | __pycache__ 5 | 6 | # Logs 7 | *.log 8 | pip-log.txt 9 | 10 | # Unit test / coverage reports 11 | .coverage 12 | .tox 13 | nosetests.xml 14 | 15 | # Translations 16 | *.mo 17 | *.pot 18 | 19 | # Pycharm 20 | .idea 21 | 22 | # Vim 23 | 24 | *~ 25 | *.swp 26 | *.swo 27 | 28 | # npm 29 | node_modules/ 30 | 31 | # Compass 32 | .sass-cache 33 | 34 | # Vagrant 35 | .vagrant 36 | 37 | # Generated files 38 | assets/ 39 | 40 | # Setup Generated files 41 | dist/ 42 | build/ 43 | .eggs/ 44 | *.egg-info 45 | 46 | 47 | .env/ 48 | /.pytest_cache/ 49 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: python 2 | python: 3 | - '3.5' 4 | - '3.6' 5 | install: 6 | - pip install six 7 | - pip install pytest 8 | - pip install coveralls 9 | script: 10 | - coverage run --source=sped setup.py test 11 | deploy: 12 | provider: pypi 13 | user: danimaribeiro 14 | password: 15 | secure: PDqIGKOTaUWpM4R8HDqV9cumPUlbLBH/IpFpkGfy79E4UsR6cY4eb0WfoNwBXIlH0lBqVIJizgHcqD3yo0GeHFmOrnjOIZdSZyo3QG7W+nlzIohrwvgQ+pG//nBOgRJn/K5FVV9f2HM+QgKpNXgVU14ZIu+iR8mv/uanuMFoIZu9zmTUJk7mBYGRJteBsr7i+2AaTODQp4G1kXdnWQhj5R+cCVgd2uMFEtErXrqUs+KJ5hxT+OvDQQgEeZao7CVm8fS7Y+OJXBAciXnvtN/dmXlIWXJTtplnnzjGnuwj3c5hnpaX5N3PzJQwXy0ParrwyMoKRFr4ESgZWrlxHnxaPNe0TQjqQs2MFprFVoYgDKfaOzdcwI+bdKaiDztcvOmHPi17L8LdryTT97zSuTMFcKXkhxbr/W/kyL4VClIVrp3AVHyu4K9ih9rjgM+AZjIK28B2GKLCvaZpQy/lFmi21TyNZ92lodWKXJX76i7HhdkExasBiWk3CprC3cuL4wDPJnp9Rb9oO0R0qBV11UC4MsPvtR+6RSJZt/eus3iyNWcq4nbMlFe//yvk265n8nJlxP4qcCthi5+zthbGWoH7+TOMHVE0Svla7EKY0TpPtlixh9Jj0Reqk8sJqbo8RuvrI37nsJG1F5QAmme2TYtn4CryekbCpQLCvq8eZBGCk/4= 16 | on: 17 | branch: 11.0 18 | distributions: bdist_wheel 19 | after_success: 20 | - coveralls 21 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 SPED-BR (https://github.com/sped-br) e seus contribuidores 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # SPED para python 2 | 3 | Biblioteca para geração dos arquivos do Sistema Público de Escrituração Digital (SPED) para Python. 4 | 5 | > This software is coded and documented in portuguese only as it is intended to be used to generate the necessary files for the brazilian government regarding to digital bookkeeping. 6 | 7 | ``` 8 | !!! Aviso importante !!! 9 | 10 | O SPED necessita de atualizações constantes para continuar se adequando a legislação vigente e eu como desenvolvedor inicial desta biblioteca não consigo mais mante-la e portanto estou arquivando este repositório. 11 | 12 | Nos anos que mantive este projeto público, o uso foi mínimo ou inexistente. 13 | 14 | Comumente recebo emails, por ser o mantenedor dela, sempre de alguém procurando uma solução simples e barata para a geração dos arquivos do SPED, porém estes são muito mais complexos que os necessários a NF-e, a título de comparação. 15 | 16 | Caso você possua recursos e disponibilidade para manter este projeto ou você faça uso dele e deseja assumir a administração da organização no GitHub e PyPI, você é bem vindo para tal desde que demostre real interesse nisso com contribuições (Pull Requests) a este repositório. 17 | 18 | Ao termino de 1 ano deste comunicado, este repositório e os pacotes PyPI serão removidos de forma definitiva. 19 | 20 | A licença de uso (MIT) permite que qualquer um use o código fonte aqui disponibilizado como bem queira, sem a necessidade de minha autorização para tal. 21 | ``` 22 | 23 | ## Requisitos 24 | 25 | - python 26 | - six 27 | 28 | ## Como instalar 29 | 30 | $ pip install python-sped 31 | 32 | ## Objetivos do Projeto 33 | 34 | A ideia inicial do projeto e unificar em uma única biblioteca módulos para facilitar a geração dos arquivos do SPED, diminuido o retrabalho necessário para isso e tentando ao máximo garantir que o arquivo gerado seja considerado válido pelo validador do SPED. 35 | 36 | Não é objetivo deste projeto, remover a necessidade do programador em conhecer o SPED, bem como sua legislação e saber informar adequadamente todas as informações corretamente. 37 | 38 | ## Compatibilidade do Projeto 39 | 40 | O projeto inicialmente suportará apenas Python 3.4+, o suporte para Python 2.7 está em desenvolvimento. Pull requests que melhorem a compatibilidade são bem vindos. 41 | 42 | Outras linguagens de programação poderão ter versões especificas conforme minha disponibilidade de tempo. 43 | 44 | ## Contribuições para o Projeto 45 | 46 | Contribuições são bem vindas ao projeto, exemplos de como você pode contribuir: 47 | 48 | - usando o projeto e [apontando bugs](https://github.com/sped-br/python-sped/issues) 49 | - [sugestões de melhoria](https://github.com/sped-br/python-sped/issues) 50 | - enviando [pull requests](https://github.com/sped-br/python-sped/pulls) 51 | - auxiliando na [documentação](https://github.com/sped-br/python-sped/wiki) 52 | 53 | ## Status do Projeto 54 | 55 | O projeto está em fase inicial de desenvolvimento e **não deve** ser usado em produção. 56 | 57 | | Módulo | Status | 58 | | -------------- | :-------: | 59 | | ECD | Funcional | 60 | | ECF | Funcional | 61 | | EFD-PIS/COFINS | Funcional | 62 | | EFD-ICMS/IPI | Funcional | 63 | | FCI | Funcional | 64 | 65 | ### ECD 66 | 67 | Este módulo está funcional, com todos seus registros codificados, porém muitos campos ainda não possuem uma validação 68 | adequada, consultado tabelas externas por exemplo, ou validando corretamente todos os tamanhos de campos. 69 | 70 | Ele pode ser usado para gerar um arquivo digital, com validações de abertura e fechamento de bloco automaticamente. 71 | 72 | ### ECF 73 | 74 | Este módulo está funcional, com todos seus registros codificados, porém muitos campos ainda não possuem uma validação 75 | adequada, consultado tabelas externas por exemplo, ou validando corretamente todos os tamanhos de campos. 76 | 77 | Ele pode ser usado para gerar um arquivo digital, com validações de abertura e fechamento de bloco automaticamente. 78 | 79 | ### EFD-ICMS/IPI 80 | 81 | Este módulo está funcional, com todos seus registros codificados, porém muitos campos ainda não possuem uma validação 82 | adequada, consultado tabelas externas por exemplo, ou validando corretamente todos os tamanhos de campos. 83 | 84 | Ele pode ser usado para gerar um arquivo digital, com validações de abertura e fechamento de bloco automaticamente. 85 | 86 | ### EFD-PIS/COFINS 87 | 88 | Este módulo está funcional, com todos seus registros codificados, porém muitos campos ainda não possuem uma validação 89 | adequada, consultado tabelas externas por exemplo, ou validando corretamente todos os tamanhos de campos. 90 | 91 | Ele pode ser usado para gerar um arquivo digital, com validações de abertura e fechamento de bloco automaticamente. 92 | 93 | ### FCI 94 | 95 | Este módulo está funcional, com todos seus registros codificados, porém muitos campos ainda não possuem uma validação 96 | adequada, validando corretamente todos os tamanhos de campos. 97 | 98 | Ele pode ser usado para gerar um arquivo digital, com validações de abertura e fechamento de bloco automaticamente. 99 | -------------------------------------------------------------------------------- /requeriments.txt: -------------------------------------------------------------------------------- 1 | coveralls==0.5 2 | six==1.9.0 3 | pytest==2.6.4 4 | -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | [metadata] 2 | description-file = README.md 3 | 4 | [tool:pytest] 5 | addopts = sped --doctest-modules 6 | 7 | [bdist_wheel] 8 | universal = 1 9 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from setuptools import setup, find_packages 4 | from setuptools.command.test import test as test_command 5 | from sped import __version__ 6 | 7 | 8 | class PyTest(test_command): 9 | user_options = [('pytest-args=', 'a', "Arguments to pass to py.test")] 10 | 11 | def initialize_options(self): 12 | test_command.initialize_options(self) 13 | self.pytest_args = [] 14 | 15 | def finalize_options(self): 16 | test_command.finalize_options(self) 17 | self.test_args = [] 18 | self.test_suite = True 19 | 20 | def run_tests(self): 21 | # doctest 22 | import sys 23 | import pytest 24 | 25 | errno = pytest.main(self.pytest_args) 26 | sys.exit(errno) 27 | 28 | 29 | setup( 30 | name='python-sped', 31 | packages=find_packages(exclude=['contrib', 'docs', 'test*']), 32 | include_package_data=True, 33 | package_data={ 34 | 'sped': ['leiautes/*'], 35 | }, 36 | version=__version__, 37 | description='Biblioteca para geração dos arquivos do Sistema Público de Escrituração Digital (SPED) para Python.', 38 | long_description='Biblioteca para geração dos arquivos do Sistema Público de Escrituração Digital (SPED) para ' 39 | 'Python.', 40 | author='Sergio Garcia', 41 | author_email='sergio@ginx.com.br', 42 | url='https://github.com/Trust-Code/python-sped', 43 | download_url='https://github.com/Trust-Code/python-sped/releases', 44 | license='MIT', 45 | classifiers=[ 46 | 'Development Status :: 3 - Alpha', 47 | 'Intended Audience :: Developers', 48 | 'License :: OSI Approved :: MIT License', 49 | 'Programming Language :: Python :: 3', 50 | 'Programming Language :: Python :: 3.6', 51 | ], 52 | keywords='sped fiscal contábil contabilidade receita federal', 53 | install_requires=['six'], 54 | tests_require=['pytest'], 55 | extras_require={ 56 | 'dev': ['pylint>=1.9.1'], 57 | 'leiaute': [ 58 | 'jupyter>=1.0.0', 59 | 'pyquery>=1.4.0', 60 | ] 61 | }, 62 | cmdclass={'test': PyTest}, 63 | ) 64 | -------------------------------------------------------------------------------- /sped/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from .escrituracao import ECD 4 | from .escrituracao import ECF 5 | from .escrituracao import EFD_ICMS_IPI 6 | from .escrituracao import EFD_PIS_COFINS 7 | from .escrituracao import Escrituracao 8 | 9 | 10 | __version__ = '1.0.2' 11 | -------------------------------------------------------------------------------- /sped/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | 4 | from collections import OrderedDict 5 | from io import StringIO 6 | 7 | from .registros import RegistroIndefinido 8 | 9 | 10 | class ArquivoDigital(object): 11 | registros = None 12 | blocos = None 13 | 14 | registro_abertura = RegistroIndefinido 15 | registro_encerramento = RegistroIndefinido 16 | 17 | def __init__(self): 18 | self._registro_abertura = self.registro_abertura() 19 | self._registro_encerramento = self.registro_encerramento() 20 | self._blocos = OrderedDict() 21 | 22 | def readfile(self, filename): 23 | with open(filename) as spedfile: 24 | for line in [line.rstrip('\r\n') for line in spedfile]: 25 | self.read_registro(line.decode('utf8')) 26 | 27 | def read_registro(self, line): 28 | reg_id = line.split('|')[1] 29 | 30 | try: 31 | registro_class = getattr(self.__class__.registros, 32 | 'Registro' + reg_id) 33 | except AttributeError: 34 | raise RuntimeError(u"Arquivo inválido para EFD - PIS/COFINS") 35 | 36 | registro = registro_class(line) 37 | 38 | if registro.__class__ == self.__class__.registro_abertura: 39 | self._registro_abertura = registro 40 | elif registro.__class__ == self.__class__.registro_encerramento: 41 | self._registro_encerramento = registro 42 | else: 43 | bloco_id = reg_id[0] 44 | bloco = self._blocos[bloco_id] 45 | bloco.add(registro) 46 | 47 | def write_to(self, buff): 48 | buff.write(self._registro_abertura.as_line() + u'\r\n') 49 | reg_count = 2 50 | for key in self._blocos.keys(): 51 | bloco = self._blocos[key] 52 | reg_count += len(bloco.registros) 53 | for registro in bloco.registros: 54 | buff.write(registro.as_line() + u'\r\n') 55 | 56 | self._registro_encerramento[2] = reg_count 57 | 58 | buff.write(self._registro_encerramento.as_line() + u'\r\n') 59 | 60 | def getstring(self): 61 | buff = StringIO() 62 | self.write_to(buff) 63 | return buff.getvalue() 64 | -------------------------------------------------------------------------------- /sped/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from .registros import Registro 4 | 5 | 6 | class Bloco(object): 7 | def __init__(self, nome=''): 8 | self._nome = nome 9 | self._registros = [] 10 | 11 | def __repr__(self): 12 | return '<%s.%s(%s)>' % (self.__class__.__module__, 13 | self.__class__.__name__, self._nome) 14 | 15 | @property 16 | def abertura(self): 17 | # Define o indicador de movimento ou dados 18 | return self.registro_abertura 19 | 20 | @property 21 | def encerramento(self): 22 | # Define a quantidade de registros 23 | return self.registro_encerramento 24 | 25 | @property 26 | def registros(self): 27 | return [self.abertura] + self._registros + [self.encerramento] 28 | 29 | def add(self, registro): 30 | # Não adiciona o registro de abertura e fechamento 31 | if not registro.__class__ == self.registro_abertura.__class__ and \ 32 | not registro.__class__ == self.registro_encerramento.__class__: 33 | self._registros.append(registro) 34 | -------------------------------------------------------------------------------- /sped/campos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | 4 | import re 5 | 6 | from datetime import date 7 | from datetime import datetime 8 | from decimal import Decimal 9 | 10 | from .erros import CampoFixoError 11 | from .erros import CampoObrigatorioError 12 | from .erros import FormatoInvalidoError 13 | 14 | 15 | class Campo(object): 16 | """ 17 | Classe base para definição de um campo de um registro do SPED. 18 | 19 | >>> campo = Campo(1, 'TESTE', True) 20 | >>> campo 21 | 22 | >>> campo.indice 23 | 1 24 | >>> campo.nome 25 | 'TESTE' 26 | >>> campo.obrigatorio 27 | True 28 | """ 29 | def __init__(self, indice, nome, obrigatorio=False): 30 | self._indice = indice 31 | self._nome = nome 32 | self._obrigatorio = obrigatorio 33 | 34 | def __repr__(self): 35 | return '<%s.%s(%s, %s)>' % (self.__class__.__module__, 36 | self.__class__.__name__, 37 | self._indice, self._nome) 38 | 39 | @property 40 | def indice(self): 41 | return self._indice 42 | 43 | @property 44 | def nome(self): 45 | return self._nome 46 | 47 | @property 48 | def obrigatorio(self): 49 | return self._obrigatorio 50 | 51 | def get(self, registro): 52 | return registro.valores[self._indice] or None 53 | 54 | def set(self, registro, valor): 55 | if self._obrigatorio and not valor: 56 | raise CampoObrigatorioError(registro, self.nome) 57 | if not valor: 58 | registro.valores[self._indice] = '' 59 | return 60 | if valor and not self.__class__.validar(valor): 61 | raise FormatoInvalidoError(registro, self.nome) 62 | if not isinstance(valor, str): 63 | raise FormatoInvalidoError(registro, self.nome) 64 | registro.valores[self._indice] = valor or '' 65 | 66 | @staticmethod 67 | def validar(valor): 68 | return True 69 | 70 | 71 | class CampoFixo(Campo): 72 | """ 73 | Classe base para definição de um campo de um registro do SPED. 74 | 75 | >>> campo = CampoFixo(1, 'REG', '0000') 76 | >>> campo 77 | 78 | >>> campo.indice 79 | 1 80 | >>> campo.nome 81 | 'REG' 82 | >>> campo.obrigatorio 83 | True 84 | >>> campo.valor 85 | '0000' 86 | """ 87 | def __init__(self, indice, nome, valor): 88 | super().__init__(indice, nome, True) 89 | self._valor = valor 90 | 91 | @property 92 | def valor(self): 93 | return self._valor 94 | 95 | def get(self, registro): 96 | return self._valor 97 | 98 | def set(self, registro, valor): 99 | if valor != self._valor: 100 | raise CampoFixoError(registro, self.nome) 101 | 102 | 103 | class CampoAlfanumerico(Campo): 104 | def __init__(self, indice, nome, obrigatorio=False, tamanho=None): 105 | super().__init__(indice, nome, obrigatorio) 106 | self._tamanho = tamanho 107 | 108 | @property 109 | def tamanho(self): 110 | return self._tamanho 111 | 112 | def set(self, registro, valor): 113 | valor = valor or '' 114 | if self._tamanho is not None: 115 | valor = valor[:self._tamanho] 116 | super().set(registro, valor) 117 | 118 | 119 | class CampoBool(Campo): 120 | def __init__(self, indice, nome, obrigatorio=False, valorVerdadeiro='S', valorFalso='N'): 121 | super().__init__(indice, nome, obrigatorio) 122 | self.valorVerdadeiro = valorVerdadeiro 123 | self.valorFalso = valorFalso 124 | 125 | def get(self, registro): 126 | valor = super().get(registro) 127 | if not valor: 128 | return None 129 | return valor == self.valorVerdadeiro 130 | 131 | def set(self, registro, valor): 132 | if isinstance(valor, bool): 133 | super().set(registro, self.valorVerdadeiro if valor else self.valorFalso) 134 | elif valor is None: 135 | super().set(registro, None) 136 | else: 137 | raise FormatoInvalidoError(registro, self.nome) 138 | 139 | 140 | class CampoNumerico(Campo): 141 | def __init__(self, indice, nome, obrigatorio=False, 142 | precisao=None, minimo=0, maximo=1000): 143 | super().__init__(indice, nome, obrigatorio) 144 | self._precisao = precisao if precisao is not None else 0 145 | self._minimo = minimo 146 | self._maximo = maximo 147 | 148 | @property 149 | def precisao(self): 150 | return self._precisao 151 | 152 | @property 153 | def minimo(self): 154 | return self._minimo 155 | 156 | @property 157 | def maximo(self): 158 | return self._maximo 159 | 160 | def get(self, registro): 161 | valor = super().get(registro) 162 | if not valor: 163 | return None 164 | return Decimal(valor.replace(',', '.')) 165 | 166 | def set(self, registro, valor): 167 | if isinstance(valor, str): 168 | valor = Decimal(valor.replace(',', '.')) 169 | 170 | if isinstance(valor, Decimal) or isinstance(valor, float): 171 | super().set(registro, (('%.' + str(self._precisao) + 'f') % valor).replace('.', ',')) 172 | elif isinstance(valor, int): 173 | super().set(registro, str(valor)) 174 | elif not valor: 175 | super().set(registro, '0') 176 | else: 177 | raise FormatoInvalidoError(registro, self.nome) 178 | 179 | 180 | class CampoData(Campo): 181 | def __init__(self, indice, nome, obrigatorio=False): 182 | super().__init__(indice, nome, obrigatorio) 183 | 184 | def get(self, registro): 185 | valor = super().get(registro) 186 | if not valor: 187 | return None 188 | return datetime.strptime(valor, '%d%m%Y').date() 189 | 190 | def set(self, registro, valor): 191 | if isinstance(valor, date): 192 | super().set(registro, valor.strftime('%d%m%Y')) 193 | elif not valor: 194 | super().set(registro, None) 195 | else: 196 | raise FormatoInvalidoError(registro, self.nome) 197 | 198 | 199 | class CampoRegex(Campo): 200 | def __init__(self, indice, nome, obrigatorio=False, regex=None): 201 | super().__init__(indice, nome, obrigatorio) 202 | self._regex = re.compile('^' + regex + '$') 203 | 204 | def set(self, registro, valor): 205 | if not isinstance(valor, str): 206 | valor = str(valor) 207 | if not valor or self._regex.match(valor): 208 | super().set(registro, valor) 209 | else: 210 | raise FormatoInvalidoError(registro, str(self)) 211 | 212 | # def __repr__(self): 213 | # return '' f'{self.__class__.__name__}({self.indice}, {self.nome}, {self._obrigatorio}, {self._regex})' 214 | 215 | 216 | class CampoCNPJ(Campo): 217 | @staticmethod 218 | def validar(valor): 219 | if len(valor) != 14: 220 | return False 221 | 222 | multiplicadores = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] 223 | 224 | cnpj = [int(c) for c in valor] 225 | 226 | soma1 = sum([cnpj[i] * multiplicadores[i+1] for i in range(12)]) 227 | soma2 = sum([cnpj[i] * multiplicadores[i] for i in range(13)]) 228 | digito1 = 11 - (soma1 % 11) 229 | digito2 = 11 - (soma2 % 11) 230 | 231 | if digito1 >= 10: 232 | digito1 = 0 233 | 234 | if digito2 >= 10: 235 | digito2 = 0 236 | 237 | if cnpj[12] != digito1 or cnpj[13] != digito2: 238 | return False 239 | 240 | return True 241 | 242 | 243 | class CampoCPF(Campo): 244 | @staticmethod 245 | def validar(valor): 246 | if len(valor) != 11: 247 | return False 248 | 249 | multiplicadores = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2] 250 | 251 | cpf = [int(c) for c in valor] 252 | 253 | soma1 = sum([cpf[i] * multiplicadores[i+1] for i in range(9)]) 254 | soma2 = sum([cpf[i] * multiplicadores[i] for i in range(10)]) 255 | digito1 = 11 - (soma1 % 11) 256 | digito2 = 11 - (soma2 % 11) 257 | 258 | if digito1 >= 10: 259 | digito1 = 0 260 | 261 | if digito2 >= 10: 262 | digito2 = 0 263 | 264 | if cpf[9] != digito1 or cpf[10] != digito2: 265 | return False 266 | 267 | return True 268 | 269 | 270 | class CampoCPFouCNPJ(Campo): 271 | @staticmethod 272 | def validar(valor): 273 | if len(valor) == 14: 274 | return CampoCNPJ.validar(valor) 275 | if len(valor) == 11: 276 | return CampoCPF.validar(valor) 277 | return False 278 | -------------------------------------------------------------------------------- /sped/ecd/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/ecd/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from .. import arquivos 4 | from . import blocos 5 | from . import registros 6 | from .blocos import Bloco0 7 | from .blocos import BlocoI 8 | from .blocos import BlocoJ 9 | from .blocos import Bloco9 10 | from .registros import Registro0000 11 | from .registros import Registro9900 12 | from .registros import Registro9999 13 | from .registros import RegistroI030 14 | from .registros import RegistroJ900 15 | 16 | 17 | class ArquivoDigital(arquivos.ArquivoDigital): 18 | registro_abertura = Registro0000 19 | registro_encerramento = Registro9999 20 | registros = registros 21 | blocos = blocos 22 | 23 | def __init__(self): 24 | super(ArquivoDigital, self).__init__() 25 | self._blocos['0'] = Bloco0('0') 26 | self._blocos['I'] = BlocoI('I') 27 | self._blocos['J'] = BlocoJ('J') 28 | self._blocos['9'] = Bloco9('9') 29 | 30 | def prepare(self): 31 | bloco_9 = self._blocos['9'] = Bloco9('9') 32 | 33 | for bloco in self._blocos.values(): 34 | regs = {} 35 | for reg in bloco.registros: 36 | if reg.REG not in regs: 37 | regs[reg.REG] = 0 38 | regs[reg.REG] += 1 39 | if bloco == self._blocos['0']: 40 | bloco.registro_encerramento.QTD_LIN_0 = sum( 41 | [x for x in regs.values()]) + 1 42 | regs['0000'] = 1 43 | if bloco == self._blocos['I']: 44 | bloco.registro_encerramento.QTD_LIN_I = sum( 45 | [x for x in regs.values()]) 46 | if bloco == self._blocos['J']: 47 | bloco.registro_encerramento.QTD_LIN_J = sum( 48 | [x for x in regs.values()]) 49 | if bloco == bloco_9: 50 | regs['9999'] = 1 51 | regs['9900'] += len(regs.keys()) 52 | for reg in regs.keys(): 53 | registro = Registro9900() 54 | registro.REG_BLC = reg 55 | registro.QTD_REG_BLC = regs[reg] 56 | bloco_9.add(registro) 57 | 58 | if bloco == self._blocos['9']: 59 | bloco.registro_encerramento.QTD_LIN_9 = sum( 60 | [x for x in regs.values()]) 61 | 62 | reg_count = 2 63 | for bloco in self._blocos.values(): 64 | reg_count += len(bloco.registros) 65 | 66 | encerramentoI = [x for x in self._blocos['I'].registros 67 | if isinstance(x, RegistroI030)] 68 | encerramentoI[0].QTD_LIN = reg_count 69 | 70 | encerramentoJ = [x for x in self._blocos['J'].registros 71 | if isinstance(x, RegistroJ900)] 72 | encerramentoJ[0].QTD_LIN = reg_count 73 | 74 | # self._blocos['J'].registros[1].QTD_LIN = reg_count 75 | self._registro_encerramento.QTD_LIN = reg_count 76 | -------------------------------------------------------------------------------- /sped/ecd/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..blocos import Bloco 4 | from .registros import Registro0001 5 | from .registros import Registro0990 6 | from .registros import RegistroI001 7 | from .registros import RegistroI990 8 | from .registros import RegistroJ001 9 | from .registros import RegistroJ990 10 | from .registros import Registro9001 11 | from .registros import Registro9990 12 | 13 | 14 | class Bloco0(Bloco): 15 | """ 16 | Abertura, Identificação e Referências 17 | """ 18 | registro_abertura = Registro0001() 19 | registro_encerramento = Registro0990() 20 | 21 | @property 22 | def fechamento(self): 23 | registro = Bloco.fechamento.fget(self) 24 | registro[2] += 1 25 | return registro 26 | 27 | 28 | class BlocoI(Bloco): 29 | """ 30 | Lançamentos Contábeis 31 | """ 32 | registro_abertura = RegistroI001() 33 | registro_encerramento = RegistroI990() 34 | 35 | 36 | class BlocoJ(Bloco): 37 | """ 38 | Demonstrações Contábeis 39 | """ 40 | registro_abertura = RegistroJ001() 41 | registro_encerramento = RegistroJ990() 42 | 43 | 44 | class Bloco9(Bloco): 45 | """ 46 | Controle e Encerramento do Arquivo Digital 47 | """ 48 | registro_abertura = Registro9001() 49 | registro_encerramento = Registro9990() 50 | 51 | @property 52 | def fechamento(self): 53 | registro = super(Bloco9, self).fechamento 54 | registro[2] += 1 55 | return registro 56 | -------------------------------------------------------------------------------- /sped/ecd/registros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..registros import Registro 4 | from ..campos import Campo 5 | from ..campos import CampoData 6 | from ..campos import CampoFixo 7 | from ..campos import CampoNumerico 8 | from ..campos import CampoAlfanumerico 9 | 10 | 11 | class Registro0000(Registro): 12 | """ 13 | ABERTURA DO ARQUIVO DIGITAL E IDENTIFICAÇÃO DO EMPRESÁRIO OU DA SOCIEDADE 14 | EMPRESÁRIA 15 | """ 16 | campos = [ 17 | CampoFixo(1, 'REG', '0000'), 18 | CampoFixo(2, 'LECD', 'LECD'), 19 | CampoData(3, 'DT_INI'), 20 | CampoData(4, 'DT_FIN'), 21 | Campo(5, 'NOME'), 22 | Campo(6, 'CNPJ'), 23 | Campo(7, 'UF'), 24 | Campo(8, 'IE'), 25 | CampoNumerico(9, 'COD_MUN'), 26 | Campo(10, 'IM'), 27 | Campo(11, 'IND_SIT_ESP'), 28 | Campo(12, 'IND_SIT_INI_PER'), 29 | Campo(13, 'IND_NIRE'), 30 | Campo(14, 'IND_FIN_ESC'), 31 | Campo(15, 'COD_HASH_SUB'), 32 | Campo(16, 'IND_GRANDE_PORTE'), 33 | Campo(17, 'TIP_ECD'), 34 | Campo(18, 'COD_SCP'), 35 | Campo(19, 'IDENT_MF'), 36 | Campo(20, 'IND_ESC_CONS') 37 | ] 38 | 39 | 40 | class Registro0001(Registro): 41 | """ 42 | ABERTURA DO BLOCO 0 43 | """ 44 | campos = [ 45 | CampoFixo(1, 'REG', '0001'), 46 | Campo(2, 'IND_DAD'), 47 | ] 48 | 49 | 50 | class Registro0007(Registro): 51 | """ 52 | OUTRAS INSCRIÇÕES CADASTRAIS DO EMPRESÁRIO OU SOCIEDADE EMPRESÁRIA 53 | """ 54 | campos = [ 55 | CampoFixo(1, 'REG', '0007'), 56 | Campo(2, 'COD_ENT_REF'), 57 | Campo(3, 'COD_INSCR'), 58 | ] 59 | 60 | 61 | class Registro0020(Registro): 62 | """ 63 | ESCRITURAÇÃO CONTÁBIL DESCENTRALIZADA 64 | """ 65 | campos = [ 66 | CampoFixo(1, 'REG', '0020'), 67 | Campo(2, 'IND_DEC'), 68 | Campo(3, 'CNPJ'), 69 | Campo(4, 'UF'), 70 | Campo(5, 'IE'), 71 | Campo(6, 'COD_MUN'), 72 | Campo(7, 'IM'), 73 | Campo(8, 'NIRE'), 74 | ] 75 | 76 | 77 | class Registro0150(Registro): 78 | """ 79 | TABELA DE CADASTRO DO PARTICIPANTE 80 | """ 81 | campos = [ 82 | CampoFixo(1, 'REG', '0150'), 83 | Campo(2, 'COD_PART'), 84 | Campo(3, 'NOME'), 85 | Campo(4, 'COD_PAIS'), 86 | Campo(5, 'CNPJ'), 87 | Campo(6, 'CPF'), 88 | Campo(7, 'NIT'), 89 | Campo(8, 'UF'), 90 | Campo(9, 'IE'), 91 | Campo(10, 'IE_ST'), 92 | Campo(11, 'COD_MUN'), 93 | Campo(12, 'IM'), 94 | Campo(13, 'SUFRAMA'), 95 | ] 96 | 97 | 98 | class Registro0180(Registro): 99 | """ 100 | IDENTIFICAÇÃO DO RELACIONAMENTO COM O PARTICIPANTE 101 | """ 102 | campos = [ 103 | CampoFixo(1, 'REG', '0180'), 104 | Campo(2, 'COD_REL'), 105 | CampoData(3, 'DT_INI_REL'), 106 | CampoData(4, 'DT_FIN_REL'), 107 | ] 108 | 109 | 110 | class Registro0990(Registro): 111 | """ 112 | ENCERRAMENTO DO BLOCO 0 113 | """ 114 | campos = [ 115 | CampoFixo(1, 'REG', '0990'), 116 | CampoNumerico(2, 'QTD_LIN_0'), 117 | ] 118 | 119 | 120 | class RegistroI001(Registro): 121 | """ 122 | ABERTURA DO BLOCO I 123 | """ 124 | campos = [ 125 | CampoFixo(1, 'REG', 'I001'), 126 | Campo(2, 'IND_DAD'), 127 | ] 128 | 129 | 130 | class RegistroI010(Registro): 131 | """ 132 | IDENTIFICAÇÃO DA ESCRITURAÇÃO CONTÁBIL 133 | """ 134 | campos = [ 135 | CampoFixo(1, 'REG', 'I010'), 136 | Campo(2, 'IND_ESC'), 137 | Campo(3, 'COD_VER_LC'), 138 | ] 139 | 140 | 141 | class RegistroI012(Registro): 142 | """ 143 | LIVROS AUXILIARES AO DIÁRIO 144 | """ 145 | campos = [ 146 | CampoFixo(1, 'REG', 'I012'), 147 | Campo(2, 'NUM_ORD'), 148 | Campo(3, 'NAT_LIVR'), 149 | Campo(4, 'TIPO'), 150 | Campo(5, 'COD_HASH_AUX'), 151 | ] 152 | 153 | 154 | class RegistroI015(Registro): 155 | """ 156 | IDENTIFICAÇÃO DAS CONTAS DA ESCRITURAÇÃO RESUMIDA A QUE SE REFERE A 157 | ESCRITURAÇÃO AUXILIAR 158 | """ 159 | campos = [ 160 | CampoFixo(1, 'REG', 'I015'), 161 | Campo(2, 'COD_CTA_RES'), 162 | ] 163 | 164 | 165 | class RegistroI020(Registro): 166 | """ 167 | CAMPOS ADICIONAIS 168 | """ 169 | campos = [ 170 | CampoFixo(1, 'REG', 'I020'), 171 | Campo(2, 'REG_COD'), 172 | Campo(3, 'NUM_AD'), 173 | Campo(4, 'CAMPO'), 174 | Campo(5, 'DESCRICAO'), 175 | Campo(6, 'TIPO'), 176 | ] 177 | 178 | 179 | class RegistroI030(Registro): 180 | """ 181 | TERMO DE ABERTURA DO LIVRO 182 | """ 183 | campos = [ 184 | CampoFixo(1, 'REG', 'I030'), 185 | Campo(2, 'DNRC_ABERT'), 186 | CampoNumerico(3, 'NUM_ORD'), 187 | Campo(4, 'NAT_LIVR'), 188 | CampoNumerico(5, 'QTD_LIN'), 189 | Campo(6, 'NOME'), 190 | Campo(7, 'NIRE'), 191 | Campo(8, 'CNPJ'), 192 | CampoData(9, 'DT_ARQ'), 193 | CampoData(10, 'DT_ARQ_CONV'), 194 | Campo(11, 'DESC_MUN'), 195 | CampoData(12, 'DT_EX_SOCIAL'), 196 | ] 197 | 198 | 199 | class RegistroI050(Registro): 200 | """ 201 | PLANO DE CONTAS 202 | """ 203 | campos = [ 204 | CampoFixo(1, 'REG', 'I050'), 205 | CampoData(2, 'DT_ALT'), 206 | Campo(3, 'COD_NAT'), 207 | Campo(4, 'IND_CTA'), 208 | CampoNumerico(5, 'NIVEL'), 209 | Campo(6, 'COD_CTA'), 210 | Campo(7, 'COD_CTA_SUP'), 211 | Campo(8, 'CTA'), 212 | ] 213 | 214 | 215 | class RegistroI051(Registro): 216 | """ 217 | PLANO DE CONTAS REFERENCIAL 218 | """ 219 | campos = [ 220 | CampoFixo(1, 'REG', 'I051'), 221 | Campo(2, 'COD_ENT_REF'), 222 | Campo(3, 'COD_CCUS'), 223 | Campo(4, 'COD_CTA_REF'), 224 | ] 225 | 226 | 227 | class RegistroI052(Registro): 228 | """ 229 | INDICAÇÃO DOS CÓDIGOS DE AGLUTINAÇÃO 230 | """ 231 | campos = [ 232 | CampoFixo(1, 'REG', 'I052'), 233 | Campo(2, 'COD_CCUS'), 234 | Campo(3, 'COD_AGL'), 235 | ] 236 | 237 | 238 | class RegistroI075(Registro): 239 | """ 240 | TABELA DE HISTÓRICO PADRONIZADO 241 | """ 242 | campos = [ 243 | CampoFixo(1, 'REG', 'I075'), 244 | Campo(2, 'COD_HIST'), 245 | Campo(3, 'DESCR_HIST'), 246 | ] 247 | 248 | 249 | class RegistroI100(Registro): 250 | """ 251 | CENTRO DE CUSTOS 252 | """ 253 | campos = [ 254 | CampoFixo(1, 'REG', 'I100'), 255 | CampoData(2, 'DT_ALT'), 256 | Campo(3, 'COD_CCUS'), 257 | Campo(4, 'CCUS'), 258 | ] 259 | 260 | 261 | class RegistroI150(Registro): 262 | """ 263 | SALDOS PERIÓDICOS – IDENTIFICAÇÃO DO PERÍODO 264 | """ 265 | campos = [ 266 | CampoFixo(1, 'REG', 'I150'), 267 | CampoData(2, 'DT_INI'), 268 | CampoData(3, 'DT_FIN'), 269 | ] 270 | 271 | 272 | class RegistroI155(Registro): 273 | """ 274 | DETALHE DOS SALDOS PERIÓDICOS 275 | """ 276 | campos = [ 277 | CampoFixo(1, 'REG', 'I155'), 278 | Campo(2, 'COD_CTA'), 279 | Campo(3, 'COD_CCUS'), 280 | CampoNumerico(4, 'VL_SLD_INI', precisao=2), 281 | Campo(5, 'IND_DC_INI'), 282 | CampoNumerico(6, 'VL_DEB', precisao=2), 283 | CampoNumerico(7, 'VL_CRED', precisao=2), 284 | CampoNumerico(8, 'VL_SLD_FIN', precisao=2), 285 | Campo(9, 'IND_DC_FIN'), 286 | ] 287 | 288 | 289 | class RegistroI200(Registro): 290 | """ 291 | LANÇAMENTO CONTÁBIL 292 | """ 293 | campos = [ 294 | CampoFixo(1, 'REG', 'I200'), 295 | Campo(2, 'NUM_LCTO'), 296 | CampoData(3, 'DT_LCTO'), 297 | CampoNumerico(4, 'VL_LCTO', precisao=2), 298 | Campo(5, 'IND_LCTO'), 299 | ] 300 | 301 | 302 | class RegistroI250(Registro): 303 | """ 304 | PARTIDAS DO LANÇAMENTO 305 | """ 306 | campos = [ 307 | CampoFixo(1, 'REG', 'I250'), 308 | Campo(2, 'COD_CTA'), 309 | Campo(3, 'COD_CCUS'), 310 | CampoNumerico(4, 'VL_DC', precisao=2), 311 | Campo(5, 'IND_DC'), 312 | Campo(6, 'NUM_ARQ'), 313 | Campo(7, 'COD_HIST_PAD'), 314 | Campo(8, 'HIST'), 315 | Campo(9, 'COD_PART'), 316 | ] 317 | 318 | 319 | class RegistroI300(Registro): 320 | """ 321 | BALANCETES DIÁRIOS – IDENTIFICAÇÃO DA DATA 322 | """ 323 | campos = [ 324 | CampoFixo(1, 'REG', 'I300'), 325 | CampoData(2, 'DT_BCTE'), 326 | ] 327 | 328 | 329 | class RegistroI310(Registro): 330 | """ 331 | DETALHES DO BALANCETE DIÁRIO 332 | """ 333 | campos = [ 334 | CampoFixo(1, 'REG', 'I310'), 335 | Campo(2, 'COD_CTA'), 336 | Campo(3, 'COD_CCUS'), 337 | CampoNumerico(4, 'VAL_DEBD', precisao=2), 338 | CampoNumerico(5, 'VAL_CREDD', precisao=2), 339 | ] 340 | 341 | 342 | class RegistroI350(Registro): 343 | """ 344 | SALDOS DAS CONTAS DE RESULTADO ANTES DO ENCERRAMENTO - IDENTIFICAÇÃO DA 345 | DATA 346 | """ 347 | campos = [ 348 | CampoFixo(1, 'REG', 'I350'), 349 | CampoData(2, 'DT_RES'), 350 | ] 351 | 352 | 353 | class RegistroI355(Registro): 354 | """ 355 | DETALHES DOS SALDOS DAS CONTAS DE RESULTADO ANTES DO ENCERRAMENTO 356 | """ 357 | campos = [ 358 | CampoFixo(1, 'REG', 'I355'), 359 | Campo(2, 'COD_CTA'), 360 | Campo(3, 'COD_CCUS'), 361 | CampoNumerico(4, 'VL_CTA', precisao=2), 362 | Campo(5, 'IND_DC'), 363 | ] 364 | 365 | 366 | class RegistroI500(Registro): 367 | """ 368 | PARÂMETROS DE IMPRESSÃO E VISUALIZAÇÃO DO LIVRO RAZÃO AUXILIAR COM LEIAUTE 369 | PARAMETRIZÁVEL 370 | """ 371 | campos = [ 372 | CampoFixo(1, 'REG', 'I500'), 373 | Campo(2, 'TAM_FONTE'), 374 | ] 375 | 376 | 377 | class RegistroI510(Registro): 378 | """ 379 | DEFINIÇÃO DE CAMPOS DO LIVRO RAZÃO AUXILIAR COM LEIAUTE PARAMETRIZÁVEL 380 | """ 381 | campos = [ 382 | CampoFixo(1, 'REG', 'I510'), 383 | Campo(2, 'NM_CAMPO'), 384 | Campo(3, 'DESC_CAMPO'), 385 | Campo(4, 'TIPO_CAMPO'), 386 | Campo(5, 'TAM_CAMPO'), 387 | Campo(6, 'DEC_CAMPO'), 388 | Campo(7, 'COL_CAMPO'), 389 | ] 390 | 391 | 392 | class RegistroI550(Registro): 393 | """ 394 | DETALHES DO LIVRO RAZÃO AUXILIAR COM LEIAUTE PARAMETRIZÁVEL 395 | """ 396 | campos = [ 397 | CampoFixo(1, 'REG', 'I550'), 398 | Campo(2, 'RZ_CONT'), 399 | ] 400 | 401 | 402 | class RegistroI555(Registro): 403 | """ 404 | TOTAIS NO LIVRO RAZÃO AUXILIAR COM LEIAUTE PARAMETRIZÁVEL 405 | """ 406 | campos = [ 407 | CampoFixo(1, 'REG', 'I555'), 408 | Campo(2, 'RZ_CONT_TOT'), 409 | ] 410 | 411 | 412 | class RegistroI990(Registro): 413 | """ 414 | ENCERRAMENTO DO BLOCO I 415 | """ 416 | campos = [ 417 | CampoFixo(1, 'REG', 'I990'), 418 | CampoNumerico(2, 'QTD_LIN_I'), 419 | ] 420 | 421 | 422 | class RegistroJ001(Registro): 423 | """ 424 | ABERTURA DO BLOCO J 425 | """ 426 | campos = [ 427 | CampoFixo(1, 'REG', 'J001'), 428 | Campo(2, 'IND_DAD'), 429 | ] 430 | 431 | 432 | class RegistroJ005(Registro): 433 | """ 434 | DEMONSTRAÇÕES CONTÁBEIS 435 | """ 436 | campos = [ 437 | CampoFixo(1, 'REG', 'J005'), 438 | CampoData(2, 'DT_INI'), 439 | CampoData(3, 'DT_FIN'), 440 | CampoNumerico(4, 'ID_DEM'), 441 | Campo(5, 'CAB_DEM'), 442 | ] 443 | 444 | 445 | class RegistroJ100(Registro): 446 | """ 447 | BALANÇO PATRIMONIAL 448 | """ 449 | campos = [ 450 | CampoFixo(1, 'REG', 'J100'), 451 | Campo(2, 'COD_AGL'), 452 | CampoNumerico(3, 'NIVEL_AGL'), 453 | Campo(4, 'IND_GRP_BAL'), 454 | Campo(5, 'DESCR_COD_AGL'), 455 | CampoNumerico(6, 'VL_CTA', precisao=2), 456 | Campo(7, 'IND_DC_BAL'), 457 | CampoNumerico(8, 'VL_CTA_INI', precisao=2), 458 | Campo(9, 'IND_DC_BAL_INI'), 459 | Campo(10, 'NOTA_EXP_REF'), 460 | ] 461 | 462 | 463 | class RegistroJ150(Registro): 464 | """ 465 | DEMONSTRAÇÃO DO RESULTADO DO EXERCÍCIO 466 | """ 467 | campos = [ 468 | CampoFixo(1, 'REG', 'J150'), 469 | Campo(2, 'COD_AGL'), 470 | CampoNumerico(3, 'NIVEL_AGL'), 471 | Campo(4, 'DESCR_COD_AGL'), 472 | CampoNumerico(5, 'VL_CTA', precisao=2), 473 | Campo(6, 'IND_VL'), 474 | CampoNumerico(7, 'VL_CTA_ULT_DRE', precisao=2), 475 | Campo(8, 'IND_VL_ULT_DRE'), 476 | Campo(9, 'NOTA_EXP_REF'), 477 | ] 478 | 479 | 480 | class RegistroJ800(Registro): 481 | """ 482 | OUTRAS INFORMAÇÕES 483 | """ 484 | campos = [ 485 | CampoFixo(1, 'REG', 'J800'), 486 | Campo(2, 'ARQ_RTF'), 487 | Campo(3, 'IND_FIM_RTF'), 488 | ] 489 | 490 | 491 | class RegistroJ900(Registro): 492 | """ 493 | TERMO DE ENCERRAMENTO 494 | """ 495 | campos = [ 496 | CampoFixo(1, 'REG', 'J900'), 497 | Campo(2, 'DNRC_ENCER'), 498 | CampoNumerico(3, 'NUM_ORD'), 499 | Campo(4, 'NAT_LIVRO'), 500 | Campo(5, 'NOME'), 501 | CampoNumerico(6, 'QTD_LIN'), 502 | CampoData(7, 'DT_INI_ESCR'), 503 | CampoData(8, 'DT_FIN_ESCR'), 504 | ] 505 | 506 | 507 | class RegistroJ930(Registro): 508 | """ 509 | IDENTIFICAÇÃO DOS SIGNATÁRIOS DA ESCRITURAÇÃO 510 | """ 511 | campos = [ 512 | CampoFixo(1, 'REG', 'J930'), 513 | CampoAlfanumerico(2, 'IDENT_NOM'), 514 | CampoAlfanumerico(3, 'IDENT_CPF_CNPJ', tamanho=14), 515 | CampoAlfanumerico(4, 'IDENT_QUALIF'), 516 | CampoAlfanumerico(5, 'COD_ASSIN', tamanho=3), 517 | CampoAlfanumerico(6, 'IND_CRC'), 518 | CampoAlfanumerico(7, 'EMAIL'), 519 | CampoAlfanumerico(8, 'FONE'), 520 | CampoAlfanumerico(9, 'UF_CRC'), 521 | CampoAlfanumerico(10, 'NUM_SEQ_CRC'), 522 | CampoData(11, 'DT_CRC'), 523 | CampoAlfanumerico(12, 'IND_RESP_LEGAL') 524 | ] 525 | 526 | 527 | class RegistroJ990(Registro): 528 | """ 529 | ENCERRAMENTO DO BLOCO J 530 | """ 531 | campos = [ 532 | CampoFixo(1, 'REG', 'J990'), 533 | CampoNumerico(2, 'QTD_LIN_J'), 534 | ] 535 | 536 | 537 | class Registro9001(Registro): 538 | """ 539 | ABERTURA DO BLOCO 9 540 | """ 541 | campos = [ 542 | CampoFixo(1, 'REG', '9001'), 543 | Campo(2, 'IND_DAD'), 544 | ] 545 | 546 | 547 | class Registro9900(Registro): 548 | """ 549 | REGISTROS DO ARQUIVO 550 | """ 551 | campos = [ 552 | CampoFixo(1, 'REG', '9900'), 553 | Campo(2, 'REG_BLC'), 554 | CampoNumerico(3, 'QTD_REG_BLC'), 555 | ] 556 | 557 | 558 | class Registro9990(Registro): 559 | """ 560 | ENCERRAMENTO DO BLOCO 9 561 | """ 562 | campos = [ 563 | CampoFixo(1, 'REG', '9990'), 564 | CampoNumerico(2, 'QTD_LIN_9'), 565 | ] 566 | 567 | 568 | class Registro9999(Registro): 569 | """ 570 | ENCERRAMENTO DO ARQUIVO DIGITAL 571 | """ 572 | campos = [ 573 | CampoFixo(1, 'REG', '9999'), 574 | CampoNumerico(2, 'QTD_LIN'), 575 | ] 576 | -------------------------------------------------------------------------------- /sped/ecd/tabelas.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | import os 4 | import re 5 | 6 | import sys 7 | 8 | __all__ = ['PLANO_REFERENCIAL_PJ_RESUMIDO'] 9 | 10 | PLANO_REFERENCIAL_PJ_RESUMIDO = [] 11 | 12 | path_tabelas = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'tabelas') 13 | # tabela = 'SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$12$389' 14 | tabela = 'SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P150$3$398' 15 | path_tabela = os.path.join(path_tabelas, tabela) 16 | 17 | def carregar_tabela(caminho_tabela, encoding='cp1252'): 18 | if sys.version_info[0] == 2: 19 | # Carregamento da tabelas desabilitado no Python 2.7 20 | return 21 | with open(caminho_tabela, 'r', encoding=encoding) as file: 22 | header = re.match('versão=(?P\\d+) (?P.+)$', file.readline()) 23 | if not header: 24 | raise Error() 25 | version = header.groupdict()['version'] 26 | columns = header.groupdict()['columns'].split(', ') 27 | 28 | return [dict(zip(columns, line.split('|'))) for line in file.readlines()] 29 | 30 | if sys.version_info[0] > 2: 31 | # Carregamento da tabelas desabilitado no Python 2.7 32 | if not PLANO_REFERENCIAL_PJ_RESUMIDO: 33 | pj1 = carregar_tabela(os.path.join(path_tabelas, 'SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$12$389')) 34 | pj2 = carregar_tabela(os.path.join(path_tabelas, 'SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P150$3$398')) 35 | PLANO_REFERENCIAL_PJ_RESUMIDO = pj1 + pj2 36 | -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF$1$198: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF$1$198 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_BACEN$1$199: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_BACEN$1$199 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_SUSEP$1$200: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_SUSEP$1$200 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_TSE$1$225: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_CONTAS_REFERENCIAIS$SPEDCONTABIL_CONTASREF_TSE$1$225 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_A$13$386: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_A$13$386 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_A$6$386: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_A$6$386 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_B$4$387: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_B$4$387 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_B$6$387: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_B$6$387 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_C$4$388: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L100_C$4$388 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_A$4$395: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_A$4$395 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_B$1$396: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_B$1$396 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_B$2$396: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_B$2$396 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_C$1$397: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_C$1$397 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_C$2$397: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_L300_C$2$397 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$12$389: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$12$389 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$3$389: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P100$3$389 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P150$3$398: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_P150$3$398 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_A$2$390: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_A$2$390 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_B$3$391: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_B$3$391 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_B$4$391: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_B$4$391 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_C$2$392: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_C$2$392 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_D$3$393: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_D$3$393 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_D$7$393: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_D$7$393 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_E$2$394: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U100_E$2$394 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_A$1$399: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_A$1$399 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_B$1$400: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_B$1$400 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_C$1$401: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_C$1$401 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_D$2$402: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_D$2$402 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_D$3$402: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_D$3$402 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_E$1$403: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_DINAMICO_2014$SPEDECF_DINAMICA_U150_E$1$403 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_ENTIDADES$2$201: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_ENTIDADES$2$201 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INDICADOR_INICIO_PERIODO$2$194: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INDICADOR_INICIO_PERIODO$2$194 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INDICADOR_INICIO_PERIODO$2$202: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INDICADOR_INICIO_PERIODO$2$202 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INSTITUICOES$1$203: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_INSTITUICOES$1$203 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_MUNICIPIOS$3$204: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_MUNICIPIOS$3$204 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_NATUREZA$1$197: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_NATUREZA$1$197 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_NATUREZA$1$205: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_NATUREZA$1$205 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_PAISES$1$198: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_PAISES$1$198 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_PAISES$1$206: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_PAISES$1$206 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_QUALIFICACAO$3$207: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_QUALIFICACAO$3$207 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_RELACIONAMENTOS$1$200: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_RELACIONAMENTOS$1$200 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_RELACIONAMENTOS$1$208: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_RELACIONAMENTOS$1$208 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_SITUACAO$2$209: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_SITUACAO$2$209 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_TIPO_PLANO_REF$1$406: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_TIPO_PLANO_REF$1$406 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_TIPO_PLANO_REF$1$574: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_TIPO_PLANO_REF$1$574 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF$1$210: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF$1$210 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF_NIRE$1$203: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF_NIRE$1$203 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF_NIRE$1$211: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDCONTABIL_UF_NIRE$1$211 -------------------------------------------------------------------------------- /sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDECF_NATUREZA_SUBCONTA$2$404: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/SPEDCONTABIL_GLOBAL$SPEDECF_NATUREZA_SUBCONTA$2$404 -------------------------------------------------------------------------------- /sped/ecd/tabelas/metadados: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sped-br/python-sped/665db2176a561b882e8d64a7972db3fdb826be7f/sped/ecd/tabelas/metadados -------------------------------------------------------------------------------- /sped/ecf/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/ecf/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from .. import arquivos 4 | from . import blocos 5 | from . import registros 6 | from .blocos import Bloco0 7 | from .blocos import BlocoC 8 | from .blocos import BlocoE 9 | from .blocos import BlocoJ 10 | from .blocos import BlocoK 11 | from .blocos import BlocoL 12 | from .blocos import BlocoM 13 | from .blocos import BlocoN 14 | from .blocos import BlocoP 15 | from .blocos import BlocoT 16 | from .blocos import BlocoU 17 | from .blocos import BlocoX 18 | from .blocos import BlocoY 19 | from .blocos import Bloco9 20 | from .registros import Registro0000 21 | from .registros import Registro9900 22 | from .registros import Registro9999 23 | 24 | 25 | class ArquivoDigital(arquivos.ArquivoDigital): 26 | registro_abertura = Registro0000 27 | registro_encerramento = Registro9999 28 | registros = registros 29 | blocos = blocos 30 | 31 | def __init__(self): 32 | super(ArquivoDigital, self).__init__() 33 | self._blocos['0'] = Bloco0() 34 | self._blocos['C'] = BlocoC() 35 | self._blocos['E'] = BlocoE() 36 | self._blocos['J'] = BlocoJ() 37 | self._blocos['K'] = BlocoK() 38 | self._blocos['L'] = BlocoL() 39 | self._blocos['M'] = BlocoM() 40 | self._blocos['N'] = BlocoN() 41 | self._blocos['P'] = BlocoP() 42 | self._blocos['T'] = BlocoT() 43 | self._blocos['U'] = BlocoU() 44 | self._blocos['X'] = BlocoX() 45 | self._blocos['Y'] = BlocoY() 46 | self._blocos['9'] = Bloco9() 47 | 48 | def prepare(self): 49 | bloco_9 = self._blocos['9'] = Bloco9() 50 | 51 | for bloco in self._blocos.values(): 52 | regs = {} 53 | for reg in bloco.registros: 54 | if reg.REG not in regs: 55 | regs[reg.REG] = 0 56 | regs[reg.REG] += 1 57 | if bloco == self._blocos['0']: 58 | regs['0000'] = 1 59 | if bloco == bloco_9: 60 | regs['9999'] = 1 61 | regs['9900'] += len(regs.keys()) 62 | for reg in regs.keys(): 63 | registro = Registro9900() 64 | registro.REG_BLC = reg 65 | registro.QTD_REG_BLC = regs[reg] 66 | bloco_9.add(registro) 67 | 68 | reg_count = 2 69 | for bloco in self._blocos.values(): 70 | reg_count += len(bloco.registros) 71 | -------------------------------------------------------------------------------- /sped/ecf/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..blocos import Bloco 4 | from .registros import Registro0001 5 | from .registros import Registro0990 6 | from .registros import RegistroC001 7 | from .registros import RegistroC990 8 | from .registros import RegistroE001 9 | from .registros import RegistroE990 10 | from .registros import RegistroJ001 11 | from .registros import RegistroJ990 12 | from .registros import RegistroK001 13 | from .registros import RegistroK990 14 | from .registros import RegistroL001 15 | from .registros import RegistroL990 16 | from .registros import RegistroM001 17 | from .registros import RegistroM990 18 | from .registros import RegistroN001 19 | from .registros import RegistroN990 20 | from .registros import RegistroP001 21 | from .registros import RegistroP990 22 | from .registros import RegistroQ001 23 | from .registros import RegistroQ990 24 | from .registros import RegistroT001 25 | from .registros import RegistroT990 26 | from .registros import RegistroU001 27 | from .registros import RegistroU990 28 | from .registros import RegistroX001 29 | from .registros import RegistroX990 30 | from .registros import RegistroY001 31 | from .registros import RegistroY990 32 | from .registros import Registro9001 33 | from .registros import Registro9099 34 | 35 | 36 | class Bloco0(Bloco): 37 | """ 38 | Abertura e Identificação 39 | """ 40 | registro_abertura = Registro0001 41 | registro_encerramento = Registro0990 42 | 43 | @property 44 | def fechamento(self): 45 | registro = Bloco.fechamento.fget(self) 46 | registro[2] += 1 47 | return registro 48 | 49 | 50 | class BlocoC(Bloco): 51 | """ 52 | Informações Recuperadas das ECD (bloco recuperado pelo sistema – não é importado) 53 | """ 54 | registro_abertura = RegistroC001 55 | registro_encerramento = RegistroC990 56 | 57 | 58 | class BlocoE(Bloco): 59 | """ 60 | Informações Recuperadas da ECF Anterior e Cálculo Fiscal dos Dados Recuperados da ECD (Bloco recuperado pelo sistema – não é importado) 61 | """ 62 | registro_abertura = RegistroE001 63 | registro_encerramento = RegistroE990 64 | 65 | 66 | class BlocoJ(Bloco): 67 | """ 68 | Plano de Contas e Mapeamento 69 | """ 70 | registro_abertura = RegistroJ001 71 | registro_encerramento = RegistroJ990 72 | 73 | 74 | class BlocoK(Bloco): 75 | """ 76 | Saldos das Contas Contábeis e Referenciais 77 | """ 78 | registro_abertura = RegistroK001 79 | registro_encerramento = RegistroK990 80 | 81 | 82 | class BlocoL(Bloco): 83 | """ 84 | Lucro Líquido 85 | """ 86 | registro_abertura = RegistroL001 87 | registro_encerramento = RegistroL990 88 | 89 | 90 | class BlocoM(Bloco): 91 | """ 92 | e-LALUR e e-LACS 93 | """ 94 | registro_abertura = RegistroM001 95 | registro_encerramento = RegistroM990 96 | 97 | 98 | class BlocoN(Bloco): 99 | """ 100 | Imposto de Renda e Contribuição Social (Lucro Real) 101 | """ 102 | registro_abertura = RegistroN001 103 | registro_encerramento = RegistroN990 104 | 105 | 106 | class BlocoP(Bloco): 107 | """ 108 | Lucro Presumido 109 | """ 110 | registro_abertura = RegistroP001 111 | registro_encerramento = RegistroP990 112 | 113 | 114 | class BlocoQ(Bloco): 115 | """ 116 | Livro Caixa 117 | """ 118 | registro_abertura = RegistroQ001 119 | registro_encerramento = RegistroQ990 120 | 121 | 122 | class BlocoT(Bloco): 123 | """ 124 | Lucro Arbitrado 125 | """ 126 | registro_abertura = RegistroT001 127 | registro_encerramento = RegistroT990 128 | 129 | 130 | class BlocoU(Bloco): 131 | """ 132 | Imunes ou Isentas 133 | """ 134 | registro_abertura = RegistroU001 135 | registro_encerramento = RegistroU990 136 | 137 | 138 | class BlocoX(Bloco): 139 | """ 140 | Informações Econômicas 141 | """ 142 | registro_abertura = RegistroX001 143 | registro_encerramento = RegistroX990 144 | 145 | 146 | class BlocoY(Bloco): 147 | """ 148 | Informações Gerais 149 | """ 150 | registro_abertura = RegistroY001 151 | registro_encerramento = RegistroY990 152 | 153 | 154 | class Bloco9(Bloco): 155 | """ 156 | Encerramento do Arquivo Digital 157 | """ 158 | registro_abertura = Registro9001 159 | registro_encerramento = Registro9099 160 | 161 | @property 162 | def fechamento(self): 163 | registro = super(Bloco9, self).fechamento 164 | registro[2] += 1 165 | return registro 166 | -------------------------------------------------------------------------------- /sped/ecf/registros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..campos import * 4 | from ..registros import Registro 5 | 6 | 7 | class Registro0000(Registro): 8 | """ 9 | Abertura do Arquivo Digital e Identificação da Pessoa Jurídica 10 | 11 | >>> r = Registro0000() 12 | >>> r.REG 13 | '0000' 14 | >>> r.NOME_ESC 15 | 'LECF' 16 | >>> line='|0000|LECF|1.00|11111111000191|EMPRESA TESTE|0|0|||01012014|31122014|N||0||' 17 | >>> r = Registro0000(line) 18 | >>> r.as_line() 19 | '|0000|LECF|1.00|11111111000191|EMPRESA TESTE|0|0|||01012014|31122014|N||0||' 20 | >>> r.REG 21 | '0000' 22 | >>> r.NOME_ESC 23 | 'LECF' 24 | >>> r.COD_VER 25 | '1.00' 26 | >>> r.CNPJ 27 | '11111111000191' 28 | >>> r.NOME 29 | 'EMPRESA TESTE' 30 | >>> r.DT_INI 31 | datetime.date(2014, 1, 1) 32 | >>> r.NOME = 'EMPRESA DEMO' 33 | >>> r.NOME 34 | 'EMPRESA DEMO' 35 | """ 36 | campos = [ 37 | CampoFixo(1, 'REG', '0000'), 38 | CampoFixo(2, 'NOME_ESC', 'LECF'), 39 | CampoAlfanumerico(3, 'COD_VER', obrigatorio=True, tamanho=4), 40 | CampoCNPJ(4, 'CNPJ', obrigatorio=True), 41 | CampoAlfanumerico(5, 'NOME', obrigatorio=True), 42 | CampoRegex(6, 'IND_SIT_INI_PER', obrigatorio=True, regex='[0-4]'), 43 | CampoRegex(7, 'SIT_ESPECIAL', obrigatorio=True, regex='[0-9]'), 44 | CampoNumerico(8, 'PAT_REMAN_CIS', precisao=2, minimo=Decimal(0), maximo=Decimal(100)), 45 | CampoData(9, 'DT_SIT_ESP'), 46 | CampoData(10, 'DT_INI', obrigatorio=True), 47 | CampoData(11, 'DT_FIN', obrigatorio=True), 48 | CampoRegex(12, 'RETIFICADORA', obrigatorio=True, regex='[SN]'), 49 | CampoAlfanumerico(13, 'NUM_REC', tamanho=41), 50 | CampoRegex(14, 'TIP_ECF', obrigatorio=True, regex='[0-2]'), 51 | CampoAlfanumerico(15, 'COD_SCP', tamanho=14) 52 | ] 53 | 54 | 55 | class Registro0001(Registro): 56 | """ 57 | Abertura do Bloco 0 58 | """ 59 | campos = [ 60 | CampoFixo(1, 'REG', '0001'), 61 | Campo(2, 'IND_DAD'), 62 | ] 63 | 64 | 65 | class Registro0010(Registro): 66 | """ 67 | Parâmetros de Tributação 68 | """ 69 | campos = [ 70 | CampoFixo(1, 'REG', '0010'), 71 | Campo(2, 'HASH_ECF_ANTERIOR'), 72 | Campo(3, 'OPT_REFIS'), 73 | Campo(4, 'OPT_PAES'), 74 | CampoNumerico(5, 'FORMA_TRIB'), 75 | Campo(6, 'FORMA_APUR'), 76 | Campo(7, 'COD_QUALIF_PJ'), 77 | Campo(8, 'FORMA_TRIB_PER'), 78 | Campo(9, 'MES_BAL_RED'), 79 | Campo(10, 'TIP_ESC_PRE'), 80 | Campo(11, 'TIP_ENT'), 81 | Campo(12, 'FORMA_APUR_I'), 82 | Campo(13, 'APUR_CSLL'), 83 | Campo(14, 'OPT_EXT_RTT'), 84 | Campo(15, 'DIF_FCONT'), 85 | ] 86 | 87 | 88 | class Registro0020(Registro): 89 | """ 90 | Parâmetros Complementares 91 | """ 92 | campos = [ 93 | CampoFixo(1, 'REG', '0020'), 94 | Campo(2, 'IND_ALIQ_CSLL'), 95 | Campo(3, 'IND_QTE_SCP'), 96 | Campo(4, 'IND_ADM_FUN_CLU'), 97 | Campo(5, 'IND_PART_CONS'), 98 | Campo(6, 'IND_OP_EXT'), 99 | Campo(7, 'IND_OP_VINC'), 100 | Campo(8, 'IND_PJ_ENQUAD'), 101 | Campo(9, 'IND_PART_EXT'), 102 | Campo(10, 'IND_ATIV_RURAL'), 103 | Campo(11, 'IND_LUC_EXP'), 104 | Campo(12, 'IND_RED_ISEN'), 105 | Campo(13, 'IND_FIN'), 106 | Campo(14, 'IND_DOA_ELEIT'), 107 | Campo(15, 'IND_PART_COLIG'), 108 | Campo(16, 'IND_VEND_EXP'), 109 | Campo(17, 'IND_REC_EXT'), 110 | Campo(18, 'IND_ATIV_EXT'), 111 | Campo(19, 'IND_COM_EXP'), 112 | Campo(20, 'IND_PGTO_EXT'), 113 | Campo(21, 'IND_E_COM_TI'), 114 | Campo(22, 'IND_ROY_REC'), 115 | Campo(23, 'IND_ROY_PAG'), 116 | Campo(24, 'IND_REND_SERV'), 117 | Campo(25, 'IND_PGTO_REM'), 118 | Campo(26, 'IND_INOV_TEC'), 119 | Campo(27, 'IND_CAP_INF'), 120 | Campo(28, 'IND_PJ_HAB'), 121 | Campo(29, 'IND_POLO_AM'), 122 | Campo(30, 'IND_ZON_EXP'), 123 | Campo(31, 'IND_AREA_COM'), 124 | ] 125 | 126 | 127 | class Registro0030(Registro): 128 | """ 129 | Dados Cadastrais 130 | """ 131 | campos = [ 132 | CampoFixo(1, 'REG', '0030'), 133 | Campo(2, 'COD_NAT'), 134 | Campo(3, 'CNAE_FISCAL'), 135 | Campo(4, 'ENDERECO'), 136 | Campo(5, 'NUM'), 137 | Campo(6, 'COMPL'), 138 | Campo(7, 'BAIRRO'), 139 | Campo(8, 'UF'), 140 | Campo(9, 'COD_MUN'), 141 | Campo(10, 'CEP'), 142 | Campo(11, 'NUM_TEL'), 143 | Campo(12, 'EMAIL'), 144 | ] 145 | 146 | 147 | class Registro0035(Registro): 148 | """ 149 | Identificação das SCP 150 | """ 151 | campos = [ 152 | CampoFixo(1, 'REG', '0035'), 153 | Campo(2, 'COD_SCP'), 154 | Campo(3, 'NOME_SCP'), 155 | ] 156 | 157 | 158 | class Registro0930(Registro): 159 | """ 160 | Identificação dos Signatários da ECF 161 | """ 162 | campos = [ 163 | CampoFixo(1, 'REG', '0930'), 164 | Campo(2, 'IDENT_NOM'), 165 | Campo(3, 'IDENT_CPF_CNPJ'), 166 | Campo(4, 'IDENT_QUALIF'), 167 | Campo(5, 'IND_CRC'), 168 | Campo(6, 'EMAIL'), 169 | Campo(7, 'FONE'), 170 | ] 171 | 172 | 173 | class Registro0990(Registro): 174 | """ 175 | Encerramento do Bloco 0 176 | """ 177 | campos = [ 178 | CampoFixo(1, 'REG', '0990'), 179 | CampoNumerico(2, 'QTD_LIN'), 180 | ] 181 | 182 | 183 | class RegistroC001(Registro): 184 | """ 185 | Abertura do Bloco C – Informações Recuperadas da ECD 186 | """ 187 | campos = [ 188 | CampoFixo(1, 'REG', 'C001'), 189 | Campo(2, 'IND_DAD'), 190 | ] 191 | 192 | 193 | class RegistroC040(Registro): 194 | """ 195 | Identificador da ECD 196 | """ 197 | campos = [ 198 | CampoFixo(1, 'REG', 'C040'), 199 | Campo(2, 'HASH_ECD'), 200 | CampoData(3, 'DT_INI'), 201 | CampoData(4, 'DT_FIN'), 202 | Campo(5, 'IND_SIT_ESP'), 203 | CampoCNPJ(6, 'CNPJ'), 204 | CampoNumerico(7, 'NUM_ORD'), 205 | Campo(8, 'NIRE'), 206 | Campo(9, 'NAT_LIVR'), 207 | Campo(10, 'COD_VER_LC'), 208 | Campo(11, 'IND_ESC'), 209 | ] 210 | 211 | 212 | class RegistroC050(Registro): 213 | """ 214 | Plano de Contas da ECD 215 | """ 216 | campos = [ 217 | CampoFixo(1, 'REG', 'C050'), 218 | CampoData(2, 'DT_ALT'), 219 | Campo(3, 'COD_NAT'), 220 | Campo(4, 'IND_CTA'), 221 | CampoNumerico(5, 'NIVEL'), 222 | Campo(6, 'COD_CTA'), 223 | Campo(7, 'COD_CTA_SUP'), 224 | Campo(8, 'CTA'), 225 | ] 226 | 227 | 228 | class RegistroC051(Registro): 229 | """ 230 | Plano de Contas Referencial 231 | """ 232 | campos = [ 233 | CampoFixo(1, 'REG', 'C051'), 234 | Campo(2, 'COD_ENT_REF'), 235 | Campo(3, 'COD_CCUS'), 236 | Campo(4, 'COD_CTA_REF'), 237 | ] 238 | 239 | 240 | class RegistroC053(Registro): 241 | """ 242 | Subcontas Correlatas 243 | """ 244 | campos = [ 245 | CampoFixo(1, 'REG', 'C053'), 246 | Campo(2, 'COD_IDT'), 247 | Campo(3, 'COD_CNT_CORR'), 248 | Campo(4, 'NAT_SUB_CNT'), 249 | ] 250 | 251 | 252 | class RegistroC100(Registro): 253 | """ 254 | Centro de Custos 255 | """ 256 | campos = [ 257 | CampoFixo(1, 'REG', 'C100'), 258 | CampoData(2, 'DT_ALT'), 259 | Campo(3, 'COD_CCUS'), 260 | Campo(4, 'CCUS'), 261 | ] 262 | 263 | 264 | class RegistroC150(Registro): 265 | """ 266 | Identificação do Período dos Saldos Periódicos das Contas Patrimoniais 267 | """ 268 | campos = [ 269 | CampoFixo(1, 'REG', 'C150'), 270 | CampoData(2, 'DT_INI'), 271 | CampoData(3, 'DT_FIN'), 272 | ] 273 | 274 | 275 | class RegistroC155(Registro): 276 | """ 277 | Detalhes dos Saldos Contábeis das Contas Patrimoniais 278 | """ 279 | campos = [ 280 | CampoFixo(1, 'REG', 'C155'), 281 | Campo(2, 'COD_CTA'), 282 | Campo(3, 'COD_CCUS'), 283 | CampoNumerico(4, 'VL_SLD_INI', precisao=2), 284 | Campo(5, 'IND_VL_SLD_INI'), 285 | CampoNumerico(6, 'VL_DEB', precisao=2), 286 | CampoNumerico(7, 'VL_CRED', precisao=2), 287 | CampoNumerico(8, 'VL_SLD_FIN', precisao=2), 288 | Campo(9, 'IND_VL_SLD_FIN'), 289 | Campo(10, 'LINHA_ECD'), 290 | ] 291 | 292 | 293 | class RegistroC157(Registro): 294 | """ 295 | Transferência de Saldos do Plano de Contas Anterior 296 | """ 297 | campos = [ 298 | CampoFixo(1, 'REG', 'C157'), 299 | Campo(2, 'COD_CTA'), 300 | Campo(3, 'COD_CCUS'), 301 | CampoNumerico(4, 'VL_SLD_FIN', precisao=2), 302 | Campo(5, 'IND_VL_SLD_FIN'), 303 | Campo(6, 'LINHA_ECD'), 304 | ] 305 | 306 | 307 | class RegistroC350(Registro): 308 | """ 309 | Identificação da Data dos Saldos das Contas de Resultado Antes do Encerramento 310 | """ 311 | campos = [ 312 | CampoFixo(1, 'REG', 'C350'), 313 | CampoData(2, 'DT_RES'), 314 | ] 315 | 316 | 317 | class RegistroC355(Registro): 318 | """ 319 | Detalhes dos Saldos das Contas de Resultado Antes do Encerramento 320 | """ 321 | campos = [ 322 | CampoFixo(1, 'REG', 'C355'), 323 | Campo(2, 'COD_CTA'), 324 | Campo(3, 'COD_CCUS'), 325 | CampoNumerico(4, 'VL_CTA', precisao=2), 326 | Campo(5, 'IND_VL_CTA'), 327 | Campo(6, 'LINHA_ECD'), 328 | ] 329 | 330 | 331 | class RegistroC990(Registro): 332 | """ 333 | Encerramento do Bloco C 334 | """ 335 | campos = [ 336 | CampoFixo(1, 'REG', 'C990'), 337 | CampoNumerico(2, 'QTD_LIN'), 338 | ] 339 | 340 | 341 | class RegistroE001(Registro): 342 | """ 343 | Abertura do Bloco E – Informações Recuperadas da ECF Anterior e Cálculo Fiscal dos Dados Recuperados da ECD 344 | """ 345 | campos = [ 346 | CampoFixo(1, 'REG', 'E001'), 347 | Campo(2, 'IND_DAD'), 348 | ] 349 | 350 | 351 | class RegistroE010(Registro): 352 | """ 353 | Saldos Finais Recuperados da ECF Anterior 354 | """ 355 | campos = [ 356 | CampoFixo(1, 'REG', 'E010'), 357 | Campo(2, 'COD_NAT'), 358 | Campo(3, 'COD_CTA_REF'), 359 | Campo(4, 'DESC_CTA_REF'), 360 | CampoNumerico(5, 'VAL_CTA_REF', precisao=2), 361 | Campo(6, 'IND_VAL_CTA_REF'), 362 | ] 363 | 364 | 365 | class RegistroE015(Registro): 366 | """ 367 | Contas Contábeis Mapeadas 368 | """ 369 | campos = [ 370 | CampoFixo(1, 'REG', 'E015'), 371 | Campo(2, 'COD_CTA'), 372 | Campo(3, 'COD_CCUS'), 373 | Campo(4, 'DESC_CTA'), 374 | CampoNumerico(5, 'VAL_CTA', precisao=2), 375 | Campo(6, 'IND_VAL_CTA'), 376 | ] 377 | 378 | 379 | class RegistroE020(Registro): 380 | """ 381 | Saldos Finais das Contas da Parte B do e-Lalur da ECF Imediatamente Anterior 382 | """ 383 | campos = [ 384 | CampoFixo(1, 'REG', 'E020'), 385 | Campo(2, 'COD_CTA_B'), 386 | Campo(3, 'DESC_CTA_LAL'), 387 | CampoData(4, 'DT_AP_LAL'), 388 | Campo(5, 'COD_LAN_ORIG'), 389 | Campo(6, 'DESC_LAN_ORIG'), 390 | CampoData(7, 'DT_LIM_LAL'), 391 | Campo(8, 'TRIBUTO'), 392 | CampoNumerico(9, 'VL_SALDO_FIN', precisao=2), 393 | Campo(10, 'IND_VL_SALDO_FIN'), 394 | ] 395 | 396 | 397 | class RegistroE030(Registro): 398 | """ 399 | Identificação do Período 400 | """ 401 | campos = [ 402 | CampoFixo(1, 'REG', 'E030'), 403 | CampoData(2, 'DT_INI'), 404 | CampoData(3, 'DT_FIN'), 405 | Campo(4, 'PER_APUR'), 406 | ] 407 | 408 | 409 | class RegistroE155(Registro): 410 | """ 411 | Detalhes dos Saldos Contábeis Calculados com Base nas ECD 412 | """ 413 | campos = [ 414 | CampoFixo(1, 'REG', 'E155'), 415 | Campo(2, 'COD_CTA'), 416 | Campo(3, 'COD_CCUS'), 417 | CampoNumerico(4, 'VL_SLD_INI', precisao=2), 418 | Campo(5, 'IND_VL_SLD_INI'), 419 | CampoNumerico(6, 'VL_DEB', precisao=2), 420 | CampoNumerico(7, 'VL_CRED', precisao=2), 421 | CampoNumerico(8, 'VL_SLD_FIN', precisao=2), 422 | Campo(9, 'IND_VL_SLD_FIN'), 423 | ] 424 | 425 | 426 | class RegistroE355(Registro): 427 | """ 428 | Detalhes dos Saldos das Contas de Resultado Antes do Encerramento 429 | """ 430 | campos = [ 431 | CampoFixo(1, 'REG', 'E355'), 432 | Campo(2, 'COD_CTA'), 433 | Campo(3, 'COD_CCUS'), 434 | CampoNumerico(4, 'VL_SLD_FIN', precisao=2), 435 | Campo(5, 'IND_VL_SLD_FIN'), 436 | ] 437 | 438 | 439 | class RegistroE990(Registro): 440 | """ 441 | Encerramento do Bloco E 442 | """ 443 | campos = [ 444 | CampoFixo(1, 'REG', 'E990'), 445 | CampoNumerico(2, 'QTD_LIN'), 446 | ] 447 | 448 | 449 | class RegistroJ001(Registro): 450 | """ 451 | Abertura do Bloco J – Plano de Contas e Mapeamento 452 | """ 453 | campos = [ 454 | CampoFixo(1, 'REG', 'J001'), 455 | Campo(2, 'IND_DAD'), 456 | ] 457 | 458 | 459 | class RegistroJ050(Registro): 460 | """ 461 | Plano de Contas do Contribuinte 462 | """ 463 | campos = [ 464 | CampoFixo(1, 'REG', 'J050'), 465 | CampoData(2, 'DT_ALT'), 466 | Campo(3, 'COD_NAT'), 467 | Campo(4, 'IND_CTA'), 468 | CampoNumerico(5, 'NIVEL'), 469 | Campo(6, 'COD_CTA'), 470 | Campo(7, 'COD_CTA_SUP'), 471 | Campo(8, 'CTA'), 472 | ] 473 | 474 | 475 | class RegistroJ051(Registro): 476 | """ 477 | Plano de Contas Referencial 478 | """ 479 | campos = [ 480 | CampoFixo(1, 'REG', 'J051'), 481 | Campo(2, 'COD_CCUS'), 482 | Campo(3, 'COD_CTA_REF'), 483 | ] 484 | 485 | 486 | class RegistroJ053(Registro): 487 | """ 488 | Subcontas Correlatas 489 | """ 490 | campos = [ 491 | CampoFixo(1, 'REG', 'J053'), 492 | Campo(2, 'COD_IDT'), 493 | Campo(3, 'COD_CNT_CORR'), 494 | Campo(4, 'NAT_SUB_CNT'), 495 | ] 496 | 497 | 498 | class RegistroJ100(Registro): 499 | """ 500 | Centro de Custos 501 | """ 502 | campos = [ 503 | CampoFixo(1, 'REG', 'J100'), 504 | CampoData(2, 'DT_ALT'), 505 | Campo(3, 'COD_CCUS'), 506 | Campo(4, 'CCUS'), 507 | ] 508 | 509 | 510 | class RegistroJ990(Registro): 511 | """ 512 | Encerramento do Bloco J 513 | """ 514 | campos = [ 515 | CampoFixo(1, 'REG', 'J990'), 516 | CampoNumerico(2, 'QTD_LIN'), 517 | ] 518 | 519 | 520 | class RegistroK001(Registro): 521 | """ 522 | Abertura do Bloco K – Saldos das Contas Contábeis e Referenciais 523 | """ 524 | campos = [ 525 | CampoFixo(1, 'REG', 'K001'), 526 | Campo(2, 'IND_DAD'), 527 | ] 528 | 529 | 530 | class RegistroK030(Registro): 531 | """ 532 | Identificação dos Períodos e Formas de Apuração do IRPJ e da CSLL no Ano-Calendário 533 | """ 534 | campos = [ 535 | CampoFixo(1, 'REG', 'K030'), 536 | CampoData(2, 'DT_INI'), 537 | CampoData(3, 'DT_FIN'), 538 | Campo(4, 'PER_APUR'), 539 | ] 540 | 541 | 542 | class RegistroK155(Registro): 543 | """ 544 | Detalhes dos Saldos Contábeis (Depois do Encerramento do Resultado do Período) 545 | """ 546 | campos = [ 547 | CampoFixo(1, 'REG', 'K155'), 548 | Campo(2, 'COD_CTA'), 549 | Campo(3, 'COD_CCUS'), 550 | CampoNumerico(4, 'VL_SLD_INI', precisao=2), 551 | Campo(5, 'IND_VL_SLD_INI'), 552 | CampoNumerico(6, 'VL_DEB', precisao=2), 553 | CampoNumerico(7, 'VL_CRED', precisao=2), 554 | CampoNumerico(8, 'VL_SLD_FIN', precisao=2), 555 | Campo(9, 'IND_VL_SLD_FIN'), 556 | ] 557 | 558 | 559 | class RegistroK156(Registro): 560 | """ 561 | Mapeamento Referencial do Saldo Final 562 | """ 563 | campos = [ 564 | CampoFixo(1, 'REG', 'K156'), 565 | Campo(2, 'COD_CTA_REF'), 566 | CampoNumerico(3, 'VL_SLD_FIN', precisao=2), 567 | Campo(4, 'IND_VL_SLD_FIN'), 568 | ] 569 | 570 | 571 | class RegistroK355(Registro): 572 | """ 573 | Saldos Finais das Contas Contábeis de Resultado Antes do Encerramento 574 | """ 575 | campos = [ 576 | CampoFixo(1, 'REG', 'K355'), 577 | Campo(2, 'COD_CTA'), 578 | Campo(3, 'COD_CCUS'), 579 | CampoNumerico(4, 'VL_SLD_FIN', precisao=2), 580 | Campo(5, 'IND_VL_SLD_FIN'), 581 | ] 582 | 583 | 584 | class RegistroK356(Registro): 585 | """ 586 | Mapeamento Referencial dos Saldos Finais das Contas de Resultado Antes do Encerramento 587 | """ 588 | campos = [ 589 | CampoFixo(1, 'REG', 'K356'), 590 | Campo(2, 'COD_CTA_REF'), 591 | CampoNumerico(3, 'VL_SLD_FIN', precisao=2), 592 | Campo(4, 'IND_VL_SLD_FIN'), 593 | ] 594 | 595 | 596 | class RegistroK990(Registro): 597 | """ 598 | Encerramento do Bloco K 599 | """ 600 | campos = [ 601 | CampoFixo(1, 'REG', 'K990'), 602 | CampoNumerico(2, 'QTD_LIN'), 603 | ] 604 | 605 | 606 | class RegistroL001(Registro): 607 | """ 608 | Abertura do Bloco L – Lucro Real 609 | """ 610 | campos = [ 611 | CampoFixo(1, 'REG', 'L001'), 612 | Campo(2, 'IND_DAD'), 613 | ] 614 | 615 | 616 | class RegistroL030(Registro): 617 | """ 618 | Identificação dos Períodos e Formas de Apuração do IRPJ e da CSLL no Ano-Calendário 619 | """ 620 | campos = [ 621 | CampoFixo(1, 'REG', 'L030'), 622 | CampoData(2, 'DT_INI'), 623 | CampoData(3, 'DT_FIN'), 624 | Campo(4, 'PER_APUR'), 625 | ] 626 | 627 | 628 | class RegistroL100(Registro): 629 | """ 630 | Balanço Patrimonial 631 | """ 632 | campos = [ 633 | CampoFixo(1, 'REG', 'L100'), 634 | Campo(2, 'CODIGO'), 635 | CampoAlfanumerico(3, 'DESCRICAO'), 636 | Campo(4, 'TIPO'), 637 | CampoNumerico(5, 'NIVEL'), 638 | Campo(6, 'COD_NAT'), 639 | Campo(7, 'COD_CTA_SUP'), 640 | CampoNumerico(8, 'VAL_CTA_REF_INI', precisao=2), 641 | Campo(9, 'IND_VAL_CTA_REF_INI'), 642 | CampoNumerico(10, 'VAL_CTA_REF_FIN', precisao=2), 643 | Campo(11, 'IND_VAL_CTA_REF_FIN'), 644 | ] 645 | 646 | 647 | class RegistroL200(Registro): 648 | """ 649 | Método de Avaliação do Estoque Final 650 | """ 651 | campos = [ 652 | CampoFixo(1, 'REG', 'L200'), 653 | Campo(2, 'IND_AVAL_ESTOQ'), 654 | ] 655 | 656 | 657 | class RegistroL210(Registro): 658 | """ 659 | Informativo da Composição de Custos 660 | """ 661 | campos = [ 662 | CampoFixo(1, 'REG', 'L210'), 663 | Campo(2, 'CODIGO'), 664 | CampoAlfanumerico(3, 'DESCRICAO'), 665 | CampoNumerico(4, 'VALOR', precisao=2), 666 | ] 667 | 668 | 669 | class RegistroL300(Registro): 670 | """ 671 | Demonstração do Resultado do Exercício 672 | """ 673 | campos = [ 674 | CampoFixo(1, 'REG', 'L300'), 675 | Campo(2, 'CODIGO'), 676 | CampoAlfanumerico(3, 'DESCRICAO'), 677 | Campo(4, 'TIPO'), 678 | CampoNumerico(5, 'NIVEL'), 679 | Campo(6, 'COD_NAT'), 680 | Campo(7, 'COD_CTA_SUP'), 681 | CampoNumerico(8, 'VALOR', precisao=2), 682 | Campo(9, 'IND_VALOR'), 683 | ] 684 | 685 | 686 | class RegistroL990(Registro): 687 | """ 688 | Encerramento do Bloco L 689 | """ 690 | campos = [ 691 | CampoFixo(1, 'REG', 'L990'), 692 | CampoNumerico(2, 'QTD_LIN'), 693 | ] 694 | 695 | 696 | class RegistroM001(Registro): 697 | """ 698 | Abertura do Bloco M – Livro Eletrônico de 699 | Apuração do Lucro Real (e-Lalur) e Licro Eletrônico 700 | de Apuração da Base de Cálculo da CSLL (e-Lacs) 701 | """ 702 | campos = [ 703 | CampoFixo(1, 'REG', 'M001'), 704 | Campo(2, 'IND_DAD'), 705 | ] 706 | 707 | 708 | class RegistroM010(Registro): 709 | """ 710 | Identificação da Conta na Parte B e-Lalur e do e-Lacs 711 | """ 712 | campos = [ 713 | CampoFixo(1, 'REG', 'M010'), 714 | Campo(2, 'COD_CTA_B'), 715 | Campo(3, 'DESC_CTA_LAL'), 716 | CampoData(4, 'DT_AP_LAL'), 717 | Campo(5, 'COD_LAN_ORIG'), 718 | Campo(6, 'DESC_LAN_ORIG'), 719 | CampoData(7, 'DT_LIM_LAL'), 720 | Campo(8, 'TRIBUTO'), 721 | CampoNumerico(9, 'VL_SALDO_INI', precisao=2), 722 | Campo(10, 'IND_VL_SALDO_INI'), 723 | CampoCNPJ(11, 'CNPJ_SIT_ESP'), 724 | ] 725 | 726 | 727 | class RegistroM030(Registro): 728 | """ 729 | Identificação do Período e Forma de Apuração do 730 | IRPJ e da CSLL das Empresas Tributadas pelo 731 | Lucro Real 732 | """ 733 | campos = [ 734 | CampoFixo(1, 'REG', 'M030'), 735 | CampoData(2, 'DT_INI'), 736 | CampoData(3, 'DT_FIN'), 737 | Campo(4, 'PER_APUR'), 738 | ] 739 | 740 | 741 | class RegistroM300(Registro): 742 | """ 743 | Lançamentos da Parte A do e-Lalur 744 | """ 745 | campos = [ 746 | CampoFixo(1, 'REG', 'M300'), 747 | Campo(2, 'CODIGO'), 748 | CampoAlfanumerico(3, 'DESCRICAO'), 749 | Campo(4, 'TIPO_LANCAMENTO'), 750 | Campo(5, 'IND_RELACAO'), 751 | CampoNumerico(6, 'VALOR', precisao=2), 752 | Campo(7, 'HIST_LAN_LAL'), 753 | ] 754 | 755 | 756 | class RegistroM305(Registro): 757 | """ 758 | Conta da Parte B do e-Lalur 759 | """ 760 | campos = [ 761 | CampoFixo(1, 'REG', 'M305'), 762 | Campo(2, 'COD_CTA_B'), 763 | CampoNumerico(3, 'VL_CTA', precisao=2), 764 | Campo(4, 'IND_VL_CTA'), 765 | ] 766 | 767 | 768 | class RegistroM310(Registro): 769 | """ 770 | Contas Contábeis Relacionadas ao Lançamento da 771 | Parte A do e-Lalur. 772 | """ 773 | campos = [ 774 | CampoFixo(1, 'REG', 'M310'), 775 | Campo(2, 'COD_CTA'), 776 | Campo(3, 'COD_CCUS'), 777 | CampoNumerico(4, 'VL_CTA', precisao=2), 778 | Campo(5, 'IND_VL_CTA') 779 | ] 780 | 781 | 782 | class RegistroM312(Registro): 783 | """ 784 | Números dos Lançamentos Relacionados à Conta Contábil 785 | """ 786 | campos = [ 787 | CampoFixo(1, 'REG', 'M312'), 788 | Campo(2, 'NUM_LCTO'), 789 | ] 790 | 791 | 792 | class RegistroM315(Registro): 793 | """ 794 | Identificação de Processos Judiciais e 795 | Administrativos Referentes ao Lançamento 796 | """ 797 | campos = [ 798 | CampoFixo(1, 'REG', 'M315'), 799 | Campo(2, 'IND_PROC'), 800 | Campo(3, 'NUM_PROC'), 801 | ] 802 | 803 | 804 | class RegistroM350(Registro): 805 | """ 806 | Lançamentos da Parte A do e-Lacs 807 | """ 808 | campos = [ 809 | CampoFixo(1, 'REG', 'M350'), 810 | Campo(2, 'CODIGO'), 811 | CampoAlfanumerico(3, 'DESCRICAO'), 812 | Campo(4, 'TIPO_LANCAMENTO'), 813 | Campo(5, 'IND_RELACAO'), 814 | CampoNumerico(6, 'VALOR', precisao=2), 815 | Campo(7, 'HIST_LAN_LAL'), 816 | ] 817 | 818 | 819 | class RegistroM355(Registro): 820 | """ 821 | Conta da Parte B do e-Lacs 822 | """ 823 | campos = [ 824 | CampoFixo(1, 'REG', 'M355'), 825 | Campo(2, 'COD_CTA_B'), 826 | CampoNumerico(3, 'VL_CTA', precisao=2), 827 | Campo(4, 'IND_VL_CTA'), 828 | ] 829 | 830 | 831 | class RegistroM360(Registro): 832 | """ 833 | Contas Contábeis Relacionadas ao Lançamento da 834 | Parte A do e-Lacs. 835 | """ 836 | campos = [ 837 | CampoFixo(1, 'REG', 'M360'), 838 | Campo(2, 'COD_CTA'), 839 | Campo(3, 'COD_CCUS'), 840 | CampoNumerico(4, 'VL_CTA', precisao=2), 841 | Campo(5, 'IND_VL_CTA'), 842 | ] 843 | 844 | 845 | class RegistroM362(Registro): 846 | """ 847 | Números dos Lançamentos Relacionados à Conta 848 | Contábil 849 | """ 850 | campos = [ 851 | CampoFixo(1, 'REG', 'M362'), 852 | Campo(2, 'NUM_LCTO'), 853 | ] 854 | 855 | 856 | class RegistroM365(Registro): 857 | """ 858 | Identificação de Processos Judiciais e 859 | Administrativos Referentes ao Lançamento 860 | """ 861 | campos = [ 862 | CampoFixo(1, 'REG', 'M365'), 863 | Campo(2, 'IND_PROC'), 864 | Campo(3, 'NUM_PROC'), 865 | ] 866 | 867 | 868 | class RegistroM410(Registro): 869 | """ 870 | Lançamentos na Conta da Parte B do e-Lalur e do e- 871 | Lacs Sem Reflexo na Parte A 872 | """ 873 | campos = [ 874 | CampoFixo(1, 'REG', 'M410'), 875 | Campo(2, 'COD_CTA_B'), 876 | Campo(3, 'COD_TRIBUTO'), 877 | CampoNumerico(4, 'VAL_LAN_LALB_PB', precisao=2), 878 | Campo(5, 'IND_VAL_LAN_LALB_PB'), 879 | Campo(6, 'COD_CTA_B_CTP'), 880 | Campo(7, 'HIST_LAN_LALB'), 881 | Campo(8, 'IND_LAN_ANT'), 882 | ] 883 | 884 | 885 | class RegistroM415(Registro): 886 | """ 887 | Identificação de Processos Judiciais e 888 | Administrativos Referentes ao Lançamento 889 | """ 890 | campos = [ 891 | CampoFixo(1, 'REG', 'M415'), 892 | Campo(2, 'IND_PROC'), 893 | Campo(3, 'NUM_PROC'), 894 | ] 895 | 896 | 897 | class RegistroM500(Registro): 898 | """ 899 | Controle de Saldos das Contas da Parte B do e-Lalur 900 | e do e-Lacs 901 | """ 902 | campos = [ 903 | CampoFixo(1, 'REG', 'M500'), 904 | Campo(2, 'COD_CTA_B'), 905 | Campo(3, 'COD_TRIBUTO'), 906 | Campo(4, 'SD_INI_LAL'), 907 | Campo(5, 'IND_SD_INI_LAL'), 908 | CampoNumerico(6, 'VL_LCTO_PARTE_A', precisao=2), 909 | Campo(7, 'IND_VL_LCTO_PARTE_A'), 910 | CampoNumerico(8, 'VL_LCTO_PARTEB', precisao=2), 911 | Campo(9, 'IND_ VL_LCTO_PARTEB'), 912 | Campo(10, 'SD_FIM_LAL'), 913 | Campo(11, 'IND_SD_FIM_LAL'), 914 | ] 915 | 916 | 917 | class RegistroM990(Registro): 918 | """ 919 | Encerramento do Bloco M 920 | """ 921 | campos = [ 922 | CampoFixo(1, 'REG', 'M990'), 923 | CampoNumerico(2, 'QTD_LIN'), 924 | ] 925 | 926 | 927 | class RegistroN001(Registro): 928 | """ 929 | Abertura do bloco N – Cálculo do IRPJ e da CSLL 930 | """ 931 | campos = [ 932 | CampoFixo(1, 'REG', 'N001'), 933 | Campo(2, 'IND_DAD'), 934 | ] 935 | 936 | 937 | class RegistroN030(Registro): 938 | """ 939 | Identificação do Período e Forma de Apuração do 940 | IRPJ e da CSLL das Empresas Tributadas pelo 941 | Lucro Real 942 | """ 943 | campos = [ 944 | CampoFixo(1, 'REG', 'N030'), 945 | CampoData(2, 'DT_INI'), 946 | CampoData(3, 'DT_FIN'), 947 | Campo(4, 'PER_APUR'), 948 | ] 949 | 950 | 951 | class RegistroN500(Registro): 952 | """ 953 | Base de Cálculo do IRPJ Sobre o Lucro Real Após 954 | as Compensações de Prejuízo 955 | """ 956 | campos = [ 957 | CampoFixo(1, 'REG', 'N500'), 958 | Campo(2, 'CODIGO'), 959 | CampoAlfanumerico(3, 'DESCRICAO'), 960 | CampoNumerico(4, 'VALOR', precisao=2), 961 | ] 962 | 963 | 964 | class RegistroN600(Registro): 965 | """ 966 | Demonstração do Lucro da Exploração 967 | """ 968 | campos = [ 969 | CampoFixo(1, 'REG', 'N600'), 970 | Campo(2, 'CODIGO'), 971 | CampoAlfanumerico(3, 'DESCRICAO'), 972 | CampoNumerico(4, 'VALOR', precisao=2), 973 | ] 974 | 975 | 976 | class RegistroN610(Registro): 977 | """ 978 | Cálculo da Isenção e Redução do Imposto sobre 979 | Lucro Real 980 | """ 981 | campos = [ 982 | CampoFixo(1, 'REG', 'N610'), 983 | Campo(2, 'CODIGO'), 984 | CampoAlfanumerico(3, 'DESCRICAO'), 985 | CampoNumerico(4, 'VALOR', precisao=2), 986 | ] 987 | 988 | 989 | class RegistroN615(Registro): 990 | """ 991 | Informações da Base de Cálculo de Incentivos Fiscais 992 | """ 993 | campos = [ 994 | CampoFixo(1, 'REG', 'N615'), 995 | Campo(2, 'BASE_CALC'), 996 | Campo(3, 'PER_INCEN_FINOR'), 997 | CampoNumerico(4, 'VL_LIQ_INCEN_FINOR', precisao=2), 998 | Campo(5, 'PER_INCEN_FINAM'), 999 | CampoNumerico(6, 'VL_LIQ_INCEN_FINAM', precisao=2), 1000 | CampoNumerico(7, 'VL_TOTAL', precisao=2), 1001 | ] 1002 | 1003 | 1004 | class RegistroN620(Registro): 1005 | """ 1006 | Cálculo do IRPJ Mensal por Estimativa 1007 | """ 1008 | campos = [ 1009 | CampoFixo(1, 'REG', 'N620'), 1010 | Campo(2, 'CODIGO'), 1011 | CampoAlfanumerico(3, 'DESCRICAO'), 1012 | CampoNumerico(4, 'VALOR', precisao=2), 1013 | ] 1014 | 1015 | 1016 | class RegistroN630(Registro): 1017 | """ 1018 | Cálculo do IRPJ Com Base no Lucro Real 1019 | """ 1020 | campos = [ 1021 | CampoFixo(1, 'REG', 'N630'), 1022 | Campo(2, 'CODIGO'), 1023 | CampoAlfanumerico(3, 'DESCRICAO'), 1024 | CampoNumerico(4, 'VALOR', precisao=2), 1025 | ] 1026 | 1027 | 1028 | class RegistroN650(Registro): 1029 | """ 1030 | Base de Cálculo da CSLL Após Compensações das 1031 | Bases de Cálculo Negativa 1032 | """ 1033 | campos = [ 1034 | CampoFixo(1, 'REG', 'N650'), 1035 | Campo(2, 'CODIGO'), 1036 | CampoAlfanumerico(3, 'DESCRICAO'), 1037 | CampoNumerico(4, 'VALOR', precisao=2), 1038 | ] 1039 | 1040 | 1041 | class RegistroN660(Registro): 1042 | """ 1043 | Cálculo da CSLL Mensal por Estimativa 1044 | """ 1045 | campos = [ 1046 | CampoFixo(1, 'REG', 'N660'), 1047 | Campo(2, 'CODIGO'), 1048 | CampoAlfanumerico(3, 'DESCRICAO'), 1049 | CampoNumerico(4, 'VALOR', precisao=2), 1050 | ] 1051 | 1052 | 1053 | class RegistroN670(Registro): 1054 | """ 1055 | Cálculo da CSLL Com Base no Lucro Real 1056 | """ 1057 | campos = [ 1058 | CampoFixo(1, 'REG', 'N670'), 1059 | Campo(2, 'CODIGO'), 1060 | CampoAlfanumerico(3, 'DESCRICAO'), 1061 | CampoNumerico(4, 'VALOR', precisao=2), 1062 | ] 1063 | 1064 | 1065 | class RegistroN990(Registro): 1066 | """ 1067 | Encerramento do Bloco N 1068 | """ 1069 | campos = [ 1070 | CampoFixo(1, 'REG', 'N990'), 1071 | CampoNumerico(2, 'QTD_LIN'), 1072 | ] 1073 | 1074 | 1075 | class RegistroP001(Registro): 1076 | """ 1077 | Abertura do Bloco P – Lucro Presumido 1078 | """ 1079 | campos = [ 1080 | CampoFixo(1, 'REG', 'P001'), 1081 | Campo(2, 'IND_DAD'), 1082 | ] 1083 | 1084 | 1085 | class RegistroP030(Registro): 1086 | """ 1087 | Identificação dos Período e Forma de Apuração do 1088 | IRPJ e da CSLL das Empresas Tributadas pelo 1089 | Lucro Presumido 1090 | """ 1091 | campos = [ 1092 | CampoFixo(1, 'REG', 'P030'), 1093 | CampoData(2, 'DT_INI'), 1094 | CampoData(3, 'DT_FIN'), 1095 | Campo(4, 'PER_APUR'), 1096 | ] 1097 | 1098 | 1099 | class RegistroP100(Registro): 1100 | """ 1101 | Balanço Patrimonial 1102 | """ 1103 | campos = [ 1104 | CampoFixo(1, 'REG', 'P100'), 1105 | Campo(2, 'CODIGO'), 1106 | CampoAlfanumerico(3, 'DESCRICAO'), 1107 | Campo(4, 'TIPO'), 1108 | CampoNumerico(5, 'NIVEL'), 1109 | Campo(6, 'COD_NAT'), 1110 | Campo(7, 'COD_CTA_SUP'), 1111 | CampoNumerico(8, 'VAL_CTA_REF_INI', precisao=2), 1112 | Campo(9, 'IND_VAL_CTA_REF_INI'), 1113 | CampoNumerico(10, 'VAL_CTA_REF_FIN', precisao=2), 1114 | Campo(11, 'IND_VAL_CTA_REF_FIN'), 1115 | ] 1116 | 1117 | 1118 | class RegistroP130(Registro): 1119 | """ 1120 | Demonstração das Receitas Incentivadas do Lucro 1121 | Presumido 1122 | """ 1123 | campos = [ 1124 | CampoFixo(1, 'REG', 'P130'), 1125 | Campo(2, 'CODIGO'), 1126 | CampoAlfanumerico(3, 'DESCRICAO'), 1127 | CampoNumerico(4, 'VALOR', precisao=2), 1128 | ] 1129 | 1130 | 1131 | class RegistroP150(Registro): 1132 | """ 1133 | Demonstração do Resultado 1134 | """ 1135 | campos = [ 1136 | CampoFixo(1, 'REG', 'P150'), 1137 | Campo(2, 'CODIGO'), 1138 | CampoAlfanumerico(3, 'DESCRICAO'), 1139 | Campo(4, 'TIPO'), 1140 | CampoNumerico(5, 'NIVEL'), 1141 | Campo(6, 'COD_NAT'), 1142 | Campo(7, 'COD_CTA_SUP'), 1143 | CampoNumerico(8, 'VALOR', precisao=2), 1144 | Campo(9, 'IND_VALOR'), 1145 | ] 1146 | 1147 | 1148 | class RegistroP200(Registro): 1149 | """ 1150 | Apuração da Base de Cálculo do Lucro Presumido 1151 | """ 1152 | campos = [ 1153 | CampoFixo(1, 'REG', 'P200'), 1154 | Campo(2, 'CODIGO'), 1155 | CampoAlfanumerico(3, 'DESCRICAO'), 1156 | CampoNumerico(4, 'VALOR', precisao=2), 1157 | ] 1158 | 1159 | 1160 | class RegistroP230(Registro): 1161 | """ 1162 | Cálculo da Isenção e Redução do Lucro Presumido 1163 | """ 1164 | campos = [ 1165 | CampoFixo(1, 'REG', 'P230'), 1166 | Campo(2, 'CODIGO'), 1167 | CampoAlfanumerico(3, 'DESCRICAO'), 1168 | CampoNumerico(4, 'VALOR', precisao=2), 1169 | ] 1170 | 1171 | 1172 | class RegistroP300(Registro): 1173 | """ 1174 | Cálculo do IRPJ com Base no Lucro Presumido 1175 | """ 1176 | campos = [ 1177 | CampoFixo(1, 'REG', 'P300'), 1178 | Campo(2, 'CODIGO'), 1179 | CampoAlfanumerico(3, 'DESCRICAO'), 1180 | CampoNumerico(4, 'VALOR', precisao=2), 1181 | ] 1182 | 1183 | 1184 | class RegistroP400(Registro): 1185 | """ 1186 | Apuração da Base de Cálculo da CSLL com Base no 1187 | Lucro Presumido 1188 | """ 1189 | campos = [ 1190 | CampoFixo(1, 'REG', 'P400'), 1191 | Campo(2, 'CODIGO'), 1192 | CampoAlfanumerico(3, 'DESCRICAO'), 1193 | CampoNumerico(4, 'VALOR', precisao=2), 1194 | ] 1195 | 1196 | 1197 | class RegistroP500(Registro): 1198 | """ 1199 | Cálculo da CSLL com Base no Lucro Líquido 1200 | """ 1201 | campos = [ 1202 | CampoFixo(1, 'REG', 'P500'), 1203 | Campo(2, 'CODIGO'), 1204 | CampoAlfanumerico(3, 'DESCRICAO'), 1205 | CampoNumerico(4, 'VALOR', precisao=2), 1206 | ] 1207 | 1208 | 1209 | class RegistroP990(Registro): 1210 | """ 1211 | Encerramento do Bloco P 1212 | """ 1213 | campos = [ 1214 | CampoFixo(1, 'REG', 'P990'), 1215 | CampoNumerico(2, 'QTD_LIN'), 1216 | ] 1217 | 1218 | 1219 | class RegistroQ001(Registro): 1220 | """ 1221 | Abertura do Bloco Q 1222 | """ 1223 | campos = [ 1224 | CampoFixo(1, 'REG', 'Q001'), 1225 | CampoNumerico(2, 'IND_DAD'), 1226 | ] 1227 | 1228 | 1229 | class RegistroQ100(Registro): 1230 | """ 1231 | Demonstrativo do Livro Caixa 1232 | """ 1233 | campos = [ 1234 | CampoFixo(1, 'REG', 'Q100'), 1235 | CampoData(2, 'DATA'), 1236 | CampoNumerico(3, 'NUM_DOC'), 1237 | CampoAlfanumerico(4, 'HIST'), 1238 | CampoNumerico(5, 'VL_ENTRADA', precisao=2), 1239 | CampoNumerico(6, 'VL_SAIDA', precisao=2), 1240 | CampoNumerico(7, 'SLD_FIN', precisao=2), 1241 | ] 1242 | 1243 | 1244 | class RegistroQ990(Registro): 1245 | """ 1246 | Encerramento do Bloco Q 1247 | """ 1248 | campos = [ 1249 | CampoFixo(1, 'REG', 'Q990'), 1250 | CampoNumerico(2, 'QTD_LIN'), 1251 | ] 1252 | 1253 | 1254 | class RegistroT001(Registro): 1255 | """ 1256 | Abertura do Bloco T – Lucro Arbitrado 1257 | """ 1258 | campos = [ 1259 | CampoFixo(1, 'REG', 'T001'), 1260 | Campo(2, 'IND_DAD'), 1261 | ] 1262 | 1263 | 1264 | class RegistroT030(Registro): 1265 | """ 1266 | Identificação dos Período e Forma de Apuração do 1267 | IRPJ e CSLL das Empresas Tributadas pelo Lucro 1268 | Arbitrado 1269 | """ 1270 | campos = [ 1271 | CampoFixo(1, 'REG', 'T030'), 1272 | CampoData(2, 'DT_INI'), 1273 | CampoData(3, 'DT_FIN'), 1274 | Campo(4, 'PER_APUR'), 1275 | ] 1276 | 1277 | 1278 | class RegistroT120(Registro): 1279 | """ 1280 | Apuração da Base de Cálculo do IRPJ com Base no 1281 | Lucro Arbitrado 1282 | """ 1283 | campos = [ 1284 | CampoFixo(1, 'REG', 'T120'), 1285 | Campo(2, 'CODIGO'), 1286 | CampoAlfanumerico(3, 'DESCRICAO'), 1287 | CampoNumerico(4, 'VALOR', precisao=2), 1288 | ] 1289 | 1290 | 1291 | class RegistroT150(Registro): 1292 | """ 1293 | Cálculo do Imposto de Renda com Base no Lucro 1294 | Arbitrado 1295 | """ 1296 | campos = [ 1297 | CampoFixo(1, 'REG', 'T150'), 1298 | Campo(2, 'CODIGO'), 1299 | CampoAlfanumerico(3, 'DESCRICAO'), 1300 | CampoNumerico(4, 'VALOR', precisao=2), 1301 | ] 1302 | 1303 | 1304 | class RegistroT170(Registro): 1305 | """ 1306 | Apuração da Base de Cálculo da CSLL com Base no 1307 | Lucro Arbitrado 1308 | """ 1309 | campos = [ 1310 | CampoFixo(1, 'REG', 'T170'), 1311 | Campo(2, 'CODIGO'), 1312 | CampoAlfanumerico(3, 'DESCRICAO'), 1313 | CampoNumerico(4, 'VALOR', precisao=2), 1314 | ] 1315 | 1316 | 1317 | class RegistroT181(Registro): 1318 | """ 1319 | Cálculo da CSLL com Base no Lucro Arbitrado 1320 | """ 1321 | campos = [ 1322 | CampoFixo(1, 'REG', 'T181'), 1323 | Campo(2, 'CODIGO'), 1324 | CampoAlfanumerico(3, 'DESCRICAO'), 1325 | CampoNumerico(4, 'VALOR', precisao=2), 1326 | ] 1327 | 1328 | 1329 | class RegistroT990(Registro): 1330 | """ 1331 | Encerramento do Bloco T 1332 | """ 1333 | campos = [ 1334 | CampoFixo(1, 'REG', 'T990'), 1335 | CampoNumerico(2, 'QTD_LIN'), 1336 | ] 1337 | 1338 | 1339 | class RegistroU001(Registro): 1340 | """ 1341 | Abertura do Bloco U – Imunes e Isentas 1342 | """ 1343 | campos = [ 1344 | CampoFixo(1, 'REG', 'U001'), 1345 | Campo(2, 'IND_DAD'), 1346 | ] 1347 | 1348 | 1349 | class RegistroU030(Registro): 1350 | """ 1351 | Identificação dos Períodos e Formas de Apuração do 1352 | IPRJ e da CSLL das Empressa Imunes e Isentas 1353 | """ 1354 | campos = [ 1355 | CampoFixo(1, 'REG', 'U030'), 1356 | CampoData(2, 'DT_INI'), 1357 | CampoData(3, 'DT_FIN'), 1358 | Campo(4, 'PER_APUR'), 1359 | ] 1360 | 1361 | 1362 | class RegistroU100(Registro): 1363 | """ 1364 | Balanço Patrimonial 1365 | """ 1366 | campos = [ 1367 | CampoFixo(1, 'REG', 'U100'), 1368 | Campo(2, 'CODIGO'), 1369 | CampoAlfanumerico(3, 'DESCRICAO'), 1370 | Campo(4, 'TIPO'), 1371 | CampoNumerico(5, 'NIVEL'), 1372 | Campo(6, 'COD_NAT'), 1373 | Campo(7, 'COD_CTA_SUP'), 1374 | CampoNumerico(8, 'VAL_CTA_REF_INI', precisao=2), 1375 | Campo(9, 'IND_VAL_CTA_REF_INI'), 1376 | CampoNumerico(10, 'VAL_CTA_REF_FIN', precisao=2), 1377 | Campo(11, 'IND_VAL_CTA_REF_FIN'), 1378 | ] 1379 | 1380 | 1381 | class RegistroU150(Registro): 1382 | """ 1383 | Demonstração do Resultado 1384 | """ 1385 | campos = [ 1386 | CampoFixo(1, 'REG', 'U150'), 1387 | Campo(2, 'CODIGO'), 1388 | CampoAlfanumerico(3, 'DESCRICAO'), 1389 | Campo(4, 'TIPO'), 1390 | CampoNumerico(5, 'NIVEL'), 1391 | Campo(6, 'COD_NAT'), 1392 | Campo(7, 'COD_CTA_SUP'), 1393 | CampoNumerico(8, 'VALOR', precisao=2), 1394 | Campo(9, 'IND_VALOR'), 1395 | ] 1396 | 1397 | 1398 | class RegistroU180(Registro): 1399 | """ 1400 | Cálculo do IRPJ das Empresas Imunes ou Isentas 1401 | """ 1402 | campos = [ 1403 | CampoFixo(1, 'REG', 'U180'), 1404 | Campo(2, 'CODIGO'), 1405 | CampoAlfanumerico(3, 'DESCRICAO'), 1406 | CampoNumerico(4, 'VALOR', precisao=2), 1407 | ] 1408 | 1409 | 1410 | class RegistroU182(Registro): 1411 | """ 1412 | Cálculo da CSLL das Empresas Imunes ou Isentas 1413 | """ 1414 | campos = [ 1415 | CampoFixo(1, 'REG', 'U182'), 1416 | Campo(2, 'CODIGO'), 1417 | CampoAlfanumerico(3, 'DESCRICAO'), 1418 | CampoNumerico(4, 'VALOR', precisao=2), 1419 | ] 1420 | 1421 | 1422 | class RegistroU990(Registro): 1423 | """ 1424 | Encerramento do Bloco U 1425 | """ 1426 | campos = [ 1427 | CampoFixo(1, 'REG', 'U990'), 1428 | CampoNumerico(2, 'QTD_LIN'), 1429 | ] 1430 | 1431 | 1432 | class RegistroX001(Registro): 1433 | """ 1434 | Abertura do Bloco X – Informações Econômicas 1435 | """ 1436 | campos = [ 1437 | CampoFixo(1, 'REG', 'X001'), 1438 | Campo(2, 'IND_DAD'), 1439 | ] 1440 | 1441 | 1442 | class RegistroX280(Registro): 1443 | """ 1444 | Atividades Incentivadas - PJ em Geral 1445 | """ 1446 | campos = [ 1447 | CampoFixo(1, 'REG', 'X280'), 1448 | Campo(2, 'IND_ATIV'), 1449 | Campo(3, 'IND_PROJ'), 1450 | Campo(4, 'ATO_CONC'), 1451 | Campo(5, 'VIG_INI'), 1452 | Campo(6, 'VIG_FIM'), 1453 | ] 1454 | 1455 | 1456 | class RegistroX291(Registro): 1457 | """ 1458 | Operações com o Exterior - Pessoa 1459 | Vinculada/Interposta/País com Tributação 1460 | Favorecida. 1461 | """ 1462 | campos = [ 1463 | CampoFixo(1, 'REG', 'X291'), 1464 | Campo(2, 'CODIGO'), 1465 | CampoAlfanumerico(3, 'DESCRICAO'), 1466 | CampoNumerico(4, 'VALOR', precisao=2), 1467 | ] 1468 | 1469 | 1470 | class RegistroX292(Registro): 1471 | """ 1472 | Operações com o Exterior - Pessoa Não Vinculada/ 1473 | Não Interposta/País sem Tributação Favorecida 1474 | """ 1475 | campos = [ 1476 | CampoFixo(1, 'REG', 'X292'), 1477 | Campo(2, 'CODIGO'), 1478 | CampoAlfanumerico(3, 'DESCRICAO'), 1479 | CampoNumerico(4, 'VALOR', precisao=2), 1480 | ] 1481 | 1482 | 1483 | class RegistroX300(Registro): 1484 | """ 1485 | Operações com o Exterior - Exportações (Entradas 1486 | de Divisas) 1487 | """ 1488 | campos = [ 1489 | CampoFixo(1, 'REG', 'X300'), 1490 | Campo(2, 'NUM_ORDEM'), 1491 | Campo(3, 'TIP_EXP'), 1492 | Campo(4, 'DESC_EXP'), 1493 | CampoNumerico(5, 'TOT_OPER', precisao=2), 1494 | Campo(6, 'COD_NCM'), 1495 | CampoNumerico(7, 'QTDE'), 1496 | Campo(8, 'UNI_MED'), 1497 | Campo(9, 'IND_OPER'), 1498 | Campo(10, 'TIP_MET'), 1499 | CampoNumerico(11, 'VL_PAR', precisao=2), 1500 | CampoNumerico(12, 'VL_PRAT', precisao=2), 1501 | CampoNumerico(13, 'VL_AJ', precisao=2), 1502 | CampoNumerico(14, 'VL_JUR', precisao=2), 1503 | CampoNumerico(15, 'VL_JUR_MIN', precisao=2), 1504 | CampoNumerico(16, 'VL_JUR_MAX', precisao=2), 1505 | Campo(17, 'COD_CNC'), 1506 | Campo(18, 'TIP_MOEDA'), 1507 | ] 1508 | 1509 | 1510 | class RegistroX310(Registro): 1511 | """ 1512 | Operações com o Exterior - Contratantes das 1513 | Exportações 1514 | """ 1515 | campos = [ 1516 | CampoFixo(1, 'REG', 'X310'), 1517 | Campo(2, 'NOME'), 1518 | CampoNumerico(3, 'PAIS'), 1519 | CampoNumerico(4, 'VL_OPER', precisao=2), 1520 | Campo(5, 'COND_PES'), 1521 | ] 1522 | 1523 | 1524 | class RegistroX320(Registro): 1525 | """ 1526 | Operações com o Exterior - Importações (Saídas de Divisas) 1527 | """ 1528 | campos = [ 1529 | CampoFixo(1, 'REG', 'X320'), 1530 | Campo(2, 'NUM_ORD'), 1531 | Campo(3, 'TIP_IMP'), 1532 | Campo(4, 'DESC_IMP'), 1533 | CampoNumerico(5, 'TOT_OPER', precisao=2), 1534 | Campo(6, 'COD_NCM'), 1535 | CampoNumerico(7, 'QTDE'), 1536 | Campo(8, 'UNI_MED'), 1537 | Campo(9, 'TIP_MET'), 1538 | CampoNumerico(10, 'VL_PAR', precisao=2), 1539 | CampoNumerico(11, 'VL_PRAT', precisao=2), 1540 | CampoNumerico(12, 'VL_AJ', precisao=2), 1541 | CampoNumerico(13, 'VL_JUR', precisao=2), 1542 | CampoNumerico(14, 'VL_JUR_MIN', precisao=2), 1543 | CampoNumerico(15, 'VL_JUR_MAX', precisao=2), 1544 | Campo(16, 'COD_CNC'), 1545 | Campo(17, 'TIP_MOEDA'), 1546 | ] 1547 | 1548 | 1549 | class RegistroX330(Registro): 1550 | """ 1551 | Operações com o Exterior - Contratantes das 1552 | Importações 1553 | """ 1554 | campos = [ 1555 | CampoFixo(1, 'REG', 'X330'), 1556 | Campo(2, 'NOME'), 1557 | CampoNumerico(3, 'PAIS'), 1558 | CampoNumerico(4, 'VL_OPER', precisao=2), 1559 | Campo(5, 'COND_PES'), 1560 | ] 1561 | 1562 | 1563 | class RegistroX340(Registro): 1564 | """ 1565 | Identificação da Participação no Exterior 1566 | """ 1567 | campos = [ 1568 | CampoFixo(1, 'REG', 'X340'), 1569 | Campo(2, 'RAZ_SOCIAL'), 1570 | Campo(3, 'NIF'), 1571 | Campo(4, 'IND_CONTROLE'), 1572 | CampoNumerico(5, 'PAIS'), 1573 | Campo(6, 'IND_REPETRO'), 1574 | Campo(7, 'IND_CONSOL'), 1575 | Campo(8, 'MOT_NAO_CONSOL'), 1576 | ] 1577 | 1578 | 1579 | class RegistroX350(Registro): 1580 | """ 1581 | Participações no Exterior - Resultado do Período de 1582 | Apuração 1583 | """ 1584 | campos = [ 1585 | CampoFixo(1, 'REG', 'X350'), 1586 | CampoNumerico(2, 'REC_LIQ'), 1587 | CampoNumerico(3, 'CUSTOS'), 1588 | CampoNumerico(4, 'LUC_BRUTO'), 1589 | CampoNumerico(5, 'REC_AUFERIDAS'), 1590 | CampoNumerico(6, 'REC_OUTRAS_OPER'), 1591 | CampoNumerico(7, 'DESP_BRASIL'), 1592 | CampoNumerico(8, 'DESP_OPER'), 1593 | CampoNumerico(9, 'LUC_OPER'), 1594 | CampoNumerico(10, 'REC_PARTIC'), 1595 | CampoNumerico(11, 'REC_OUTRAS'), 1596 | CampoNumerico(12, 'DESP_OUTRAS'), 1597 | CampoNumerico(13, 'LUC_LIQ_ANT_IR'), 1598 | CampoNumerico(14, 'IMP_DEV'), 1599 | CampoNumerico(15, 'LUC_LIQ'), 1600 | CampoNumerico(16, 'LUC_ARB_ANT_IMP'), 1601 | CampoNumerico(17, 'IMP_DEV_ARB'), 1602 | CampoNumerico(18, 'LUC_ARB_PER_APUR'), 1603 | ] 1604 | 1605 | 1606 | class RegistroX351(Registro): 1607 | """ 1608 | Demonstrativo de Resultados e de Imposto a Pagar 1609 | no Exterior 1610 | """ 1611 | campos = [ 1612 | CampoFixo(1, 'REG', 'X351'), 1613 | CampoNumerico(2, 'RES_INV_PER'), 1614 | CampoNumerico(3, 'RES_INV_PER_REAL'), 1615 | CampoNumerico(4, 'RES_REPRETO_PER'), 1616 | CampoNumerico(5, 'RES_REPRETO_PER_REAL'), 1617 | CampoNumerico(6, 'RES_NEG_ACUM'), 1618 | CampoNumerico(7, 'RES_POS_TRIB'), 1619 | CampoNumerico(8, 'RES_POS_TRIB_REAL'), 1620 | CampoNumerico(9, 'IMP_PAG'), 1621 | CampoNumerico(10, 'IMP_PAG_REAL'), 1622 | CampoNumerico(11, 'IMP_PAG_REND'), 1623 | CampoNumerico(12, 'IMP_PAG_REND_REAL'), 1624 | ] 1625 | 1626 | 1627 | class RegistroX352(Registro): 1628 | """ 1629 | Demonstrativo de Resultados no Exterior de 1630 | Coligadas em Regime de Caixa 1631 | """ 1632 | campos = [ 1633 | CampoFixo(1, 'REG', 'X352'), 1634 | CampoNumerico(2, 'RES_PER'), 1635 | CampoNumerico(3, 'RES_PER_REAL'), 1636 | CampoNumerico(4, 'LUC_DISP'), 1637 | CampoNumerico(5, 'LUC_DISP_REAL'), 1638 | ] 1639 | 1640 | 1641 | class RegistroX353(Registro): 1642 | """ 1643 | Demonstrativo de Consolidação 1644 | """ 1645 | campos = [ 1646 | CampoFixo(1, 'REG', 'X353'), 1647 | CampoNumerico(2, 'RES_NEG_UTIL'), 1648 | CampoNumerico(3, 'RES_NEG_UTIL_REAL'), 1649 | CampoNumerico(4, 'SALDO_RES_NEG_NAO_UTIL'), 1650 | CampoNumerico(5, 'SALDO_RES_NEG_NAO_UTIL_REAL'), 1651 | ] 1652 | 1653 | 1654 | class RegistroX354(Registro): 1655 | """ 1656 | Demonstrativo de Prejuízos Acumulados 1657 | """ 1658 | campos = [ 1659 | CampoFixo(1, 'REG', 'X354'), 1660 | CampoNumerico(2, 'RES_NEG'), 1661 | CampoNumerico(3, 'RES_NEG_REAL'), 1662 | CampoNumerico(4, 'SALDO_RES_NEG'), 1663 | ] 1664 | 1665 | 1666 | class RegistroX355(Registro): 1667 | """ 1668 | Demonstrativo de Rendas Ativas e passivas 1669 | """ 1670 | campos = [ 1671 | CampoFixo(1, 'REG', 'X355'), 1672 | CampoNumerico(2, 'REND_PASS_PROP'), 1673 | CampoNumerico(3, 'REND_PASS_PROP_REAL'), 1674 | CampoNumerico(4, 'REND_TOTAL'), 1675 | CampoNumerico(5, 'REND_TOTAL_REAL'), 1676 | CampoNumerico(6, 'REND_ATIV_PROP'), 1677 | CampoNumerico(7, 'REND_ATIV_PROP_REAL'), 1678 | CampoNumerico(8, 'PERCENTUAL'), 1679 | ] 1680 | 1681 | 1682 | class RegistroX356(Registro): 1683 | """ 1684 | Demonstrativo de Estrutura Societária 1685 | """ 1686 | campos = [ 1687 | CampoFixo(1, 'REG', 'X356'), 1688 | CampoNumerico(2, 'PERC_PART'), 1689 | CampoNumerico(3, 'ATIVO_TOTAL'), 1690 | CampoNumerico(4, 'PAT_LIQUIDO'), 1691 | ] 1692 | 1693 | 1694 | class RegistroX356(Registro): 1695 | """ 1696 | Demonstrativo de Imposto Pago no Exterior 1697 | """ 1698 | # TODO: Registro não definido no arquivo ECF 1699 | campos = [ 1700 | CampoFixo(1, 'REG', 'X366'), 1701 | ] 1702 | 1703 | 1704 | class RegistroX390(Registro): 1705 | """ 1706 | Origem e Aplicação de Recursos - Imunes ou Isentas 1707 | """ 1708 | campos = [ 1709 | CampoFixo(1, 'REG', 'X390'), 1710 | Campo(2, 'CODIGO'), 1711 | CampoAlfanumerico(3, 'DESCRICAO'), 1712 | CampoNumerico(4, 'VALOR', precisao=2), 1713 | ] 1714 | 1715 | 1716 | class RegistroX400(Registro): 1717 | """ 1718 | Comércio Eletrônico e Tecnologia da Informação 1719 | """ 1720 | campos = [ 1721 | CampoFixo(1, 'REG', 'X400'), 1722 | Campo(2, 'CODIGO'), 1723 | CampoAlfanumerico(3, 'DESCRICAO'), 1724 | CampoNumerico(4, 'VALOR', precisao=2), 1725 | ] 1726 | 1727 | 1728 | class RegistroX410(Registro): 1729 | """ 1730 | Comércio Eletrônico 1731 | """ 1732 | campos = [ 1733 | CampoFixo(1, 'REG', 'X410'), 1734 | CampoNumerico(2, 'PAIS'), 1735 | Campo(3, 'IND_HOME_DISP'), 1736 | Campo(4, 'IND_SERV_DISP'), 1737 | ] 1738 | 1739 | 1740 | class RegistroX420(Registro): 1741 | """ 1742 | Royalties Recebidos ou Pagos a Beneficiários do 1743 | Brasil e do Exterior 1744 | """ 1745 | campos = [ 1746 | CampoFixo(1, 'REG', 'X420'), 1747 | Campo(2, 'TIP_ROY'), 1748 | CampoNumerico(3, 'PAIS'), 1749 | CampoNumerico(4, 'VL_EXPL_DIR_SW', precisao=2), 1750 | CampoNumerico(5, 'VL_EXPL_DIR_AUT', precisao=2), 1751 | CampoNumerico(6, 'VL_EXPL_MARCA', precisao=2), 1752 | CampoNumerico(7, 'VL_EXPL_PAT', precisao=2), 1753 | CampoNumerico(8, 'VL_EXPL_KNOW', precisao=2), 1754 | CampoNumerico(9, 'VL_EXPL_FRANQ', precisao=2), 1755 | CampoNumerico(10, 'VL_EXPL_INT', precisao=2), 1756 | ] 1757 | 1758 | 1759 | class RegistroX430(Registro): 1760 | """ 1761 | Rendimentos Relativos a Serviços, Juros e 1762 | Dividendos Recebidos do Brasil e do Exterior 1763 | """ 1764 | campos = [ 1765 | CampoFixo(1, 'REG', 'X430'), 1766 | CampoNumerico(2, 'PAIS'), 1767 | CampoNumerico(3, 'VL_SERV_ASSIST', precisao=2), 1768 | CampoNumerico(4, 'VL_SERV_SEM_ASSIST', precisao=2), 1769 | CampoNumerico(5, 'VL_SERV_SEM_ASSIST_EXT', precisao=2), 1770 | CampoNumerico(6, 'VL_JURO', precisao=2), 1771 | CampoNumerico(7, 'VL_DEMAIS_JUROS', precisao=2), 1772 | CampoNumerico(8, 'VL_DIVID', precisao=2), 1773 | ] 1774 | 1775 | 1776 | class RegistroX450(Registro): 1777 | """ 1778 | Pagamentos/Remessas Relativos a Serviços, Juros e 1779 | Dividendos Recebidos do Brasil e do Exterior 1780 | """ 1781 | campos = [ 1782 | CampoFixo(1, 'REG', 'X450'), 1783 | CampoNumerico(2, 'PAIS'), 1784 | CampoNumerico(3, 'VL_SERV_ASSIST', precisao=2), 1785 | CampoNumerico(4, 'VL_SERV_SEM_ASSIST', precisao=2), 1786 | CampoNumerico(5, 'VL_SERV_SEM_ASSIST_EXT', precisao=2), 1787 | CampoNumerico(6, 'VL_JURO_PF', precisao=2), 1788 | CampoNumerico(7, 'VL_JURO_PJ', precisao=2), 1789 | CampoNumerico(8, 'VL_DEMAIS_JUROS', precisao=2), 1790 | CampoNumerico(9, 'VL_DIVID_PF', precisao=2), 1791 | CampoNumerico(10, 'VL_DIVID_PJ', precisao=2), 1792 | ] 1793 | 1794 | 1795 | class RegistroX460(Registro): 1796 | """ 1797 | Inovação Tecnológica e Desenvolvimento 1798 | Tecnológico 1799 | """ 1800 | campos = [ 1801 | CampoFixo(1, 'REG', 'X460'), 1802 | Campo(2, 'CODIGO'), 1803 | CampoAlfanumerico(3, 'DESCRICAO'), 1804 | CampoNumerico(4, 'VALOR', precisao=2), 1805 | ] 1806 | 1807 | 1808 | class RegistroX470(Registro): 1809 | """ 1810 | Capacitação de Informática e Inclusão Digital 1811 | """ 1812 | campos = [ 1813 | CampoFixo(1, 'REG', 'X470'), 1814 | Campo(2, 'CODIGO'), 1815 | CampoAlfanumerico(3, 'DESCRICAO'), 1816 | CampoNumerico(4, 'VALOR', precisao=2), 1817 | ] 1818 | 1819 | 1820 | class RegistroX480(Registro): 1821 | """ 1822 | Repes, Recap, Padis, PATVD, Reidi, Repenec, 1823 | Reicomp, Retaero, Recine, Resíduos Sólidos, 1824 | Recopa, Copa do Mundo, Retid, REPNBL-Redes, 1825 | Reif e Olimpíadas 1826 | """ 1827 | campos = [ 1828 | CampoFixo(1, 'REG', 'X480'), 1829 | Campo(2, 'CODIGO'), 1830 | CampoAlfanumerico(3, 'DESCRICAO'), 1831 | CampoNumerico(4, 'VALOR', precisao=2), 1832 | ] 1833 | 1834 | 1835 | class RegistroX490(Registro): 1836 | """ 1837 | Pólo Industrial de Manaus e Amazônia Ocidental 1838 | """ 1839 | campos = [ 1840 | CampoFixo(1, 'REG', 'X490'), 1841 | Campo(2, 'CODIGO'), 1842 | CampoAlfanumerico(3, 'DESCRICAO'), 1843 | CampoNumerico(4, 'VALOR', precisao=2), 1844 | ] 1845 | 1846 | 1847 | class RegistroX500(Registro): 1848 | """ 1849 | Zonas de Processamento de Exportação (ZPE) 1850 | """ 1851 | campos = [ 1852 | CampoFixo(1, 'REG', 'X500'), 1853 | Campo(2, 'CODIGO'), 1854 | CampoAlfanumerico(3, 'DESCRICAO'), 1855 | CampoNumerico(4, 'VALOR', precisao=2), 1856 | ] 1857 | 1858 | 1859 | class RegistroX510(Registro): 1860 | """ 1861 | Áreas de Livre Comércio (ALC) 1862 | """ 1863 | campos = [ 1864 | CampoFixo(1, 'REG', 'X510'), 1865 | Campo(2, 'CODIGO'), 1866 | CampoAlfanumerico(3, 'DESCRICAO'), 1867 | CampoNumerico(4, 'VALOR', precisao=2), 1868 | ] 1869 | 1870 | 1871 | class RegistroX990(Registro): 1872 | """ 1873 | Encerramento do Bloco X 1874 | """ 1875 | campos = [ 1876 | CampoFixo(1, 'REG', 'X990'), 1877 | CampoNumerico(2, 'QTD_LIN'), 1878 | ] 1879 | 1880 | 1881 | class RegistroY001(Registro): 1882 | """ 1883 | Abertura do Bloco Y – Informações Gerais 1884 | """ 1885 | campos = [ 1886 | CampoFixo(1, 'REG', 'Y001'), 1887 | Campo(2, 'IND_DAD'), 1888 | ] 1889 | 1890 | 1891 | class RegistroY520(Registro): 1892 | """ 1893 | Pagamentos/Recebimentos do Exterior ou de Não 1894 | Residentes 1895 | """ 1896 | campos = [ 1897 | CampoFixo(1, 'REG', 'Y520'), 1898 | Campo(2, 'TIP_EXT'), 1899 | CampoNumerico(3, 'PAIS'), 1900 | Campo(4, 'FORMA'), 1901 | Campo(5, 'NAT_OPER'), 1902 | CampoNumerico(6, 'VL_PERIODO', precisao=2), 1903 | ] 1904 | 1905 | 1906 | class RegistroY540(Registro): 1907 | """ 1908 | Discriminação da Receita de Vendas dos 1909 | Estabelecimentos por Atividade Econômica 1910 | """ 1911 | campos = [ 1912 | CampoFixo(1, 'REG', 'Y540'), 1913 | CampoCNPJ(2, 'CNPJ_ESTAB'), 1914 | CampoNumerico(3, 'VL_REC_ESTAB', precisao=2), 1915 | Campo(4, 'CNAE'), 1916 | ] 1917 | 1918 | 1919 | class RegistroY550(Registro): 1920 | """ 1921 | Vendas a Comercial Exportadora com Fim 1922 | Específico de Exportação 1923 | """ 1924 | campos = [ 1925 | CampoFixo(1, 'REG', 'Y550'), 1926 | CampoCNPJ(2, 'CNPJ_EXP'), 1927 | Campo(3, 'COD_NCM'), 1928 | CampoNumerico(4, 'VL_VENDA', precisao=2), 1929 | ] 1930 | 1931 | 1932 | class RegistroY560(Registro): 1933 | """ 1934 | Detalhamento das Exportações da Comercial 1935 | Exportadora 1936 | """ 1937 | campos = [ 1938 | CampoFixo(1, 'REG', 'Y560'), 1939 | CampoCNPJ(2, 'CNPJ'), 1940 | Campo(3, 'COD_NCM'), 1941 | CampoNumerico(4, 'VL_COMPRA', precisao=2), 1942 | CampoNumerico(5, 'VL_EXP', precisao=2), 1943 | ] 1944 | 1945 | 1946 | class RegistroY570(Registro): 1947 | """ 1948 | Demonstrativo do Imposto de Renda e CSLL 1949 | Retidos na Fonte 1950 | """ 1951 | campos = [ 1952 | CampoFixo(1, 'REG', 'Y570'), 1953 | CampoCNPJ(2, 'CNPJ_FON'), 1954 | Campo(3, 'NOM_EMP'), 1955 | Campo(4, 'IND_ORG_PUB'), 1956 | Campo(5, 'COD_REC'), 1957 | CampoNumerico(6, 'VL_REND', precisao=2), 1958 | CampoNumerico(7, 'IR_RET', precisao=2), 1959 | CampoNumerico(8, 'CSLL_RET', precisao=2), 1960 | ] 1961 | 1962 | 1963 | class RegistroY580(Registro): 1964 | """ 1965 | Doações a Campanhas Eleitorais 1966 | """ 1967 | campos = [ 1968 | CampoFixo(1, 'REG', 'Y580'), 1969 | CampoCNPJ(2, 'CNPJ'), 1970 | Campo(3, 'TIP_BENEF'), 1971 | Campo(4, 'FORM_DOA'), 1972 | CampoNumerico(5, 'VL_DOA', precisao=2), 1973 | ] 1974 | 1975 | 1976 | class RegistroY590(Registro): 1977 | """ 1978 | Ativos no Exterior 1979 | """ 1980 | campos = [ 1981 | CampoFixo(1, 'REG', 'Y590'), 1982 | Campo(2, 'TIP_ATIVO'), 1983 | CampoNumerico(3, 'PAIS'), 1984 | Campo(4, 'DISCRIMINACAO'), 1985 | CampoNumerico(5, 'VL_ANT', precisao=2), 1986 | CampoNumerico(6, 'VL_ATUAL', precisao=2), 1987 | ] 1988 | 1989 | 1990 | class RegistroY600(Registro): 1991 | """ 1992 | Identificação de Sócios ou Titular 1993 | """ 1994 | campos = [ 1995 | CampoFixo(1, 'REG', 'Y600'), 1996 | CampoData(2, 'DT_ALT_SOC'), 1997 | CampoData(3, 'DT_FIM_SOC'), 1998 | CampoNumerico(4, 'PAIS'), 1999 | Campo(5, 'IND_QUALIF_SOCIO'), 2000 | Campo(6, 'CPF_CNPJ'), 2001 | Campo(7, 'NOM_EMP'), 2002 | Campo(8, 'QUALIF'), 2003 | CampoNumerico(9, 'PERC_CAP_TOT'), 2004 | CampoNumerico(10, 'PERC_CAP_VOT'), 2005 | Campo(11, 'CPF_REP_LEG'), 2006 | Campo(12, 'QUALIF_REP_LEG'), 2007 | CampoNumerico(13, 'VL_REM_TRAB', precisao=2), 2008 | CampoNumerico(14, 'VL_LUC_DIV', precisao=2), 2009 | CampoNumerico(15, 'VL_JUR_CAP', precisao=2), 2010 | CampoNumerico(16, 'VL_DEM_REND', precisao=2), 2011 | CampoNumerico(17, 'VL_IR_RET', precisao=2), 2012 | ] 2013 | 2014 | 2015 | # class RegistroY611(Registro): 2016 | # """ 2017 | # Rendimentos de Dirigentes, Conselheiros, Sócios ou 2018 | # Titular 2019 | # """ 2020 | # campos = [ 2021 | # CampoFixo(1, 'REG', 'Y611'), 2022 | # CampoNumerico(2, 'PAIS'), 2023 | # Campo(3, 'IND_PF_PJ'), 2024 | # Campo(4, 'CPF_CNPJ'), 2025 | # Campo(5, 'NOM_EMP'), 2026 | # Campo(6, 'QUALIF'), 2027 | # CampoNumerico(7, 'VL_REM_TRAB', precisao=2), 2028 | # CampoNumerico(8, 'VL_LUC_DIV', precisao=2), 2029 | # CampoNumerico(9, 'VL_JUR_CAP', precisao=2), 2030 | # CampoNumerico(10, 'VL_DEM_REND', precisao=2), 2031 | # CampoNumerico(11, 'VL_IR_RET', precisao=2), 2032 | # ] 2033 | 2034 | 2035 | class RegistroY612(Registro): 2036 | """ 2037 | Rendimentos de Dirigentes e Conselheiros - Imunes 2038 | ou Isentas 2039 | """ 2040 | campos = [ 2041 | CampoFixo(1, 'REG', 'Y612'), 2042 | Campo(2, 'CPF'), 2043 | Campo(3, 'NOME'), 2044 | Campo(4, 'QUALIF'), 2045 | CampoNumerico(5, 'VL_REM_TRAB', precisao=2), 2046 | CampoNumerico(6, 'VL_DEM_REND', precisao=2), 2047 | CampoNumerico(7, 'VL_IR_RET', precisao=2), 2048 | ] 2049 | 2050 | 2051 | class RegistroY620(Registro): 2052 | """ 2053 | Participação Avaliada pelo Método de Equivalência 2054 | Patrimonial 2055 | """ 2056 | campos = [ 2057 | CampoFixo(1, 'REG', 'Y620'), 2058 | CampoNumerico(2, 'PAIS'), 2059 | CampoCNPJ(3, 'CNPJ'), 2060 | Campo(4, 'NOM_EMP'), 2061 | CampoNumerico(5, 'VALOR_REAIS'), 2062 | CampoNumerico(6, 'VALOR_ESTR'), 2063 | CampoNumerico(7, 'PERC_CAP_TOT'), 2064 | CampoNumerico(8, 'PERC_CAP_VOT'), 2065 | CampoNumerico(9, 'RES_EQ_PAT'), 2066 | Campo(10, 'DATA_AQUIS'), 2067 | Campo(11, 'IND_PROC_CART'), 2068 | Campo(12, 'NUM_PROC_CART'), 2069 | Campo(13, 'NOME_CART'), 2070 | Campo(14, 'IND_PROC_RFB'), 2071 | Campo(15, 'NUM_PROC_RFB'), 2072 | ] 2073 | 2074 | 2075 | class RegistroY630(Registro): 2076 | """ 2077 | Fundos/Clubes de Investimento 2078 | """ 2079 | campos = [ 2080 | CampoFixo(1, 'REG', 'Y630'), 2081 | CampoCNPJ(2, 'CNPJ'), 2082 | Campo(3, 'QTE_QUOT'), 2083 | Campo(4, 'QTE_QUOTA'), 2084 | Campo(5, 'PATR_FIN_PER'), 2085 | Campo(6, 'DAT_ABERT'), 2086 | Campo(7, 'DAT_ENCER'), 2087 | ] 2088 | 2089 | 2090 | class RegistroY640(Registro): 2091 | """ 2092 | Participações em Consórcios de Empresas 2093 | """ 2094 | campos = [ 2095 | CampoFixo(1, 'REG', 'Y640'), 2096 | CampoCNPJ(2, 'CNPJ'), 2097 | Campo(3, 'COND_DECL'), 2098 | CampoNumerico(4, 'VL_CONS', precisao=2), 2099 | CampoCNPJ(5, 'CNPJ_LID'), 2100 | CampoNumerico(6, 'VL_DECL', precisao=2), 2101 | ] 2102 | 2103 | 2104 | class RegistroY650(Registro): 2105 | """ 2106 | Participantes do Consórcio 2107 | """ 2108 | campos = [ 2109 | CampoFixo(1, 'REG', 'Y650'), 2110 | CampoCNPJ(2, 'CNPJ'), 2111 | CampoNumerico(3, 'VL_PART', precisao=2), 2112 | ] 2113 | 2114 | 2115 | class RegistroY660(Registro): 2116 | """ 2117 | Dados de Sucessoras 2118 | """ 2119 | campos = [ 2120 | CampoFixo(1, 'REG', 'Y660'), 2121 | CampoCNPJ(2, 'CNPJ'), 2122 | Campo(3, 'NOM_EMP'), 2123 | CampoNumerico(4, 'PERC_PAT_LIQ'), 2124 | ] 2125 | 2126 | 2127 | class RegistroY665(Registro): 2128 | """ 2129 | Demonstrativo das Diferenças na Adoção Inicial 2130 | """ 2131 | campos = [ 2132 | CampoFixo(1, 'REG', 'Y665'), 2133 | Campo(2, 'COD_CTA'), 2134 | Campo(3, 'COD_CCUS'), 2135 | Campo(4, 'DESC_CTA'), 2136 | CampoNumerico(5, 'VL_SALDO_SOC', precisao=2), 2137 | Campo(6, 'IND_VL_SALDO_SOC'), 2138 | CampoNumerico(7, 'VL_SALDO_FIS', precisao=2), 2139 | Campo(8, 'IND_VL_SALDO_FIS'), 2140 | Campo(9, 'DIF_SALDOS'), 2141 | Campo(10, 'IND_DIF_SALDOS'), 2142 | Campo(11, 'MET_CONTR'), 2143 | Campo(12, 'COD_SUBCONT'), 2144 | Campo(13, 'COD_CCUS_SUB'), 2145 | Campo(14, 'DESC_SUB'), 2146 | ] 2147 | 2148 | 2149 | class RegistroY671(Registro): 2150 | """ 2151 | Outras Informações 2152 | """ 2153 | campos = [ 2154 | CampoFixo(1, 'REG', 'Y671'), 2155 | CampoNumerico(2, 'VL_AQ_MAQ', precisao=2), 2156 | CampoNumerico(3, 'VL_DOA_CRIANCA', precisao=2), 2157 | CampoNumerico(4, 'VL_DOA_IDOSO', precisao=2), 2158 | CampoNumerico(5, 'VL_AQ_IMOBILIZADO', precisao=2), 2159 | CampoNumerico(6, 'VL_BX_IMOBILIZADO', precisao=2), 2160 | CampoNumerico(7, 'VL_INC_INI', precisao=2), 2161 | CampoNumerico(8, 'VL_INC_FIN', precisao=2), 2162 | CampoNumerico(9, 'VL_CSLL_DEPREC_INI', precisao=2), 2163 | CampoNumerico(10, 'VL_DIF_IC_VC', precisao=2), 2164 | CampoNumerico(11, 'VL_OC_SEM_IOF', precisao=2), 2165 | CampoNumerico(12, 'VL_FOLHA_ALIQ_RED', precisao=2), 2166 | CampoNumerico(13, 'VL_ALIQ_RED', precisao=2), 2167 | Campo(14, 'IND_ALTER_CAPITAL'), 2168 | Campo(15, 'IND_BCN_CSLL'), 2169 | ] 2170 | 2171 | 2172 | class RegistroY672(Registro): 2173 | """ 2174 | Outras Informações (Lucro Presumido ou Lucro 2175 | Arbitrado) 2176 | """ 2177 | campos = [ 2178 | CampoFixo(1, 'REG', 'Y672'), 2179 | CampoNumerico(2, 'VL_CAPITAL_ANT', precisao=2), 2180 | CampoNumerico(3, 'VL_CAPITAL', precisao=2), 2181 | CampoNumerico(4, 'VL_ESTOQUE_ANT', precisao=2), 2182 | CampoNumerico(5, 'VL_ESTOQUES', precisao=2), 2183 | CampoNumerico(6, 'VL_CAIXA_ANT', precisao=2), 2184 | CampoNumerico(7, 'VL_CAIXA', precisao=2), 2185 | CampoNumerico(8, 'VL_APLIC_FIN_ANT', precisao=2), 2186 | CampoNumerico(9, 'VL_APLIC_FIN', precisao=2), 2187 | CampoNumerico(10, 'VL_CTA_REC_ANT', precisao=2), 2188 | CampoNumerico(11, 'VL_CTA_REC', precisao=2), 2189 | CampoNumerico(12, 'VL_CTA_PAG_ANT', precisao=2), 2190 | CampoNumerico(13, 'VL_CTA_PAG', precisao=2), 2191 | CampoNumerico(14, 'VL_COMPRA_MERC', precisao=2), 2192 | CampoNumerico(15, 'VL_COMPRA_ATIVO', precisao=2), 2193 | CampoNumerico(16, 'VL_RECEITAS', precisao=2), 2194 | CampoNumerico(17, 'TOT_ATIVO', precisao=2), 2195 | CampoNumerico(18, 'VL_FOLHA', precisao=2), 2196 | CampoNumerico(19, 'VL_ALIQ_RED', precisao=2), 2197 | Campo(20, 'IND_REG_APUR'), 2198 | Campo(21, 'IND_AVAL_ESTOQ'), 2199 | ] 2200 | 2201 | 2202 | class RegistroY680(Registro): 2203 | """ 2204 | Mês das Informações de Optantes pelo Refis (Lucro 2205 | Real, Presumido e Arbitrado) 2206 | """ 2207 | campos = [ 2208 | CampoFixo(1, 'REG', 'Y680'), 2209 | Campo(2, 'MES'), 2210 | ] 2211 | 2212 | 2213 | class RegistroY681(Registro): 2214 | """ 2215 | Informações de Optantes pelo Refis (Lucro Real, 2216 | Presumido e Arbitrado) 2217 | """ 2218 | campos = [ 2219 | CampoFixo(1, 'REG', 'Y681'), 2220 | Campo(2, 'CODIGO'), 2221 | CampoAlfanumerico(3, 'DESCRICAO'), 2222 | CampoNumerico(4, 'VALOR', precisao=2), 2223 | ] 2224 | 2225 | 2226 | class RegistroY682(Registro): 2227 | """ 2228 | Informações de Optantes pelo Refis - Imunes ou 2229 | Isentas 2230 | """ 2231 | campos = [ 2232 | CampoFixo(1, 'REG', 'Y682'), 2233 | Campo(2, 'MES'), 2234 | Campo(3, 'ACRES_PATR'), 2235 | ] 2236 | 2237 | 2238 | class RegistroY690(Registro): 2239 | """ 2240 | Informações de Optantes pelo Paes 2241 | """ 2242 | campos = [ 2243 | CampoFixo(1, 'REG', 'Y690'), 2244 | Campo(2, 'MES'), 2245 | CampoNumerico(3, 'VL_REC_BRU', precisao=2), 2246 | ] 2247 | 2248 | 2249 | class RegistroY800(Registro): 2250 | """ 2251 | Outras Informações 2252 | """ 2253 | campos = [ 2254 | CampoFixo(1, 'REG', 'Y800'), 2255 | Campo(2, 'ARQ_RTF'), 2256 | Campo(3, 'IND_FIM_RTF'), 2257 | ] 2258 | 2259 | 2260 | class RegistroY990(Registro): 2261 | """ 2262 | Encerramento do Bloco Y 2263 | """ 2264 | campos = [ 2265 | CampoFixo(1, 'REG', 'Y990'), 2266 | CampoNumerico(2, 'QTD_LIN'), 2267 | ] 2268 | 2269 | 2270 | class Registro9001(Registro): 2271 | """ 2272 | Abertura do Bloco 9 2273 | """ 2274 | campos = [ 2275 | CampoFixo(1, 'REG', '9001'), 2276 | Campo(2, 'IND_DAD'), 2277 | ] 2278 | 2279 | 2280 | class Registro9100(Registro): 2281 | """ 2282 | Avisos da Escrituração 2283 | """ 2284 | campos = [ 2285 | CampoFixo(1, 'REG', '9100'), 2286 | # TODO: Campo 2 não está definido 2287 | Campo(2, ''), 2288 | Campo(3, 'MSG_REGRA'), 2289 | Campo(4, 'REGISTRO'), 2290 | Campo(5, 'CAMPO'), 2291 | Campo(6, 'CONTEÚDO'), 2292 | CampoNumerico(7, 'VALOR_ESPERADO'), 2293 | ] 2294 | 2295 | 2296 | class Registro9900(Registro): 2297 | """ 2298 | Registros do Arquivo 2299 | """ 2300 | campos = [ 2301 | CampoFixo(1, 'REG', '9900'), 2302 | Campo(2, 'REG_BLC'), 2303 | CampoNumerico(3, 'QTD_REG_BLC'), 2304 | Campo(4, 'VERSAO'), 2305 | Campo(5, 'ID_TAB_DIN'), 2306 | ] 2307 | 2308 | 2309 | class Registro9099(Registro): 2310 | """ 2311 | Encerramento do Bloco 9 2312 | """ 2313 | campos = [ 2314 | CampoFixo(1, 'REG', '9099'), 2315 | CampoNumerico(2, 'QTD_LIN'), 2316 | ] 2317 | 2318 | 2319 | class Registro9999(Registro): 2320 | """ 2321 | Encerramento do Arquivo Digital 2322 | """ 2323 | campos = [ 2324 | CampoFixo(1, 'REG', '9999'), 2325 | CampoNumerico(2, 'QTD_LIN'), 2326 | ] 2327 | -------------------------------------------------------------------------------- /sped/efd/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/efd/icms_ipi/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/efd/icms_ipi/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ... import arquivos 4 | from . import blocos 5 | from . import registros 6 | from .blocos import Bloco0 7 | from .blocos import BlocoB 8 | from .blocos import BlocoC 9 | from .blocos import BlocoD 10 | from .blocos import BlocoE 11 | from .blocos import BlocoG 12 | from .blocos import BlocoH 13 | from .blocos import BlocoK 14 | from .blocos import Bloco1 15 | from .blocos import Bloco9 16 | from .registros import Registro0000 17 | from .registros import Registro9900 18 | from .registros import Registro9999 19 | 20 | 21 | class ArquivoDigital(arquivos.ArquivoDigital): 22 | registro_abertura = Registro0000 23 | registro_encerramento = Registro9999 24 | registros = registros 25 | blocos = blocos 26 | 27 | def __init__(self): 28 | super(ArquivoDigital, self).__init__() 29 | self._blocos['0'] = Bloco0() 30 | self._blocos['B'] = BlocoB() 31 | self._blocos['C'] = BlocoC() 32 | self._blocos['D'] = BlocoD() 33 | self._blocos['E'] = BlocoE() 34 | self._blocos['G'] = BlocoG() 35 | self._blocos['H'] = BlocoH() 36 | self._blocos['K'] = BlocoK() 37 | self._blocos['1'] = Bloco1() 38 | self._blocos['9'] = Bloco9() 39 | 40 | def prepare(self): 41 | bloco_9 = self._blocos['9'] = Bloco9() 42 | for bloco in self._blocos.values(): 43 | regs = {} 44 | for reg in bloco.registros: 45 | if reg.REG not in regs: 46 | regs[reg.REG] = 0 47 | regs[reg.REG] += 1 48 | total = sum([x for x in regs.values()]) 49 | bloco.registro_abertura.IND_MOV = '1' if total <= 2 else '0' 50 | if bloco == self._blocos['0']: 51 | bloco.registro_encerramento.QTD_LIN_0 = total + 1 52 | regs['0000'] = 1 53 | if bloco == self._blocos['B']: 54 | bloco.registro_encerramento.QTD_LIN_B = total 55 | if bloco == self._blocos['C']: 56 | bloco.registro_encerramento.QTD_LIN_C = total 57 | if bloco == self._blocos['D']: 58 | bloco.registro_encerramento.QTD_LIN_D = total 59 | if bloco == self._blocos['E']: 60 | bloco.registro_encerramento.QTD_LIN_E = total 61 | if bloco == self._blocos['G']: 62 | bloco.registro_encerramento.QTD_LIN_G = total 63 | if bloco == self._blocos['H']: 64 | bloco.registro_encerramento.QTD_LIN_H = total 65 | if bloco == self._blocos['K']: 66 | bloco.registro_encerramento.QTD_LIN_K = total 67 | if bloco == self._blocos['1']: 68 | bloco.registro_encerramento.QTD_LIN_1 = total 69 | if bloco == self._blocos['9']: 70 | bloco.registro_encerramento.QTD_LIN_9 = total + 5 71 | if bloco == bloco_9: 72 | regs['9999'] = 1 73 | regs['9900'] += len(regs.keys()) 74 | for reg in regs.keys(): 75 | registro = Registro9900() 76 | registro.REG_BLC = reg 77 | registro.QTD_REG_BLC = str(regs[reg]) 78 | bloco_9.add(registro) 79 | -------------------------------------------------------------------------------- /sped/efd/icms_ipi/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ...blocos import Bloco 4 | from .registros import Registro0001 5 | from .registros import Registro0990 6 | from .registros import RegistroB001 7 | from .registros import RegistroB990 8 | from .registros import RegistroC001 9 | from .registros import RegistroC990 10 | from .registros import RegistroD001 11 | from .registros import RegistroD990 12 | from .registros import RegistroE001 13 | from .registros import RegistroE990 14 | from .registros import RegistroG001 15 | from .registros import RegistroG990 16 | from .registros import RegistroH001 17 | from .registros import RegistroH990 18 | from .registros import RegistroK001 19 | from .registros import RegistroK990 20 | from .registros import Registro1001 21 | from .registros import Registro1990 22 | from .registros import Registro9001 23 | from .registros import Registro9990 24 | 25 | 26 | class Bloco0(Bloco): 27 | """ 28 | Abertura, Identificação e Referências 29 | """ 30 | registro_abertura = Registro0001() 31 | registro_encerramento = Registro0990() 32 | 33 | @property 34 | def fechamento(self): 35 | registro = self.__class__.registro_encerramento() 36 | # Define a quantidade de registros 37 | registro[2] = len(self._registros) + 3 38 | return registro 39 | 40 | 41 | class BlocoB(Bloco): 42 | """ 43 | Apuração de ISS – Mercadorias (ICMS/IPI) 44 | """ 45 | registro_abertura = RegistroB001() 46 | registro_encerramento = RegistroB990() 47 | 48 | 49 | class BlocoC(Bloco): 50 | """ 51 | Documentos Fiscais I – Mercadorias (ICMS/IPI) 52 | """ 53 | registro_abertura = RegistroC001() 54 | registro_encerramento = RegistroC990() 55 | 56 | 57 | class BlocoD(Bloco): 58 | """ 59 | Documentos Fiscais II – Serviços (ICMS) 60 | """ 61 | registro_abertura = RegistroD001() 62 | registro_encerramento = RegistroD990() 63 | 64 | 65 | class BlocoE(Bloco): 66 | """ 67 | Apuração do ICMS e do IPI 68 | """ 69 | registro_abertura = RegistroE001() 70 | registro_encerramento = RegistroE990() 71 | 72 | 73 | class BlocoG(Bloco): 74 | """ 75 | Controle do Crédito de ICMS do Ativo Permanente – CIAP 76 | """ 77 | registro_abertura = RegistroG001() 78 | registro_encerramento = RegistroG990() 79 | 80 | 81 | class BlocoH(Bloco): 82 | """ 83 | Inventário Físico 84 | """ 85 | registro_abertura = RegistroH001() 86 | registro_encerramento = RegistroH990() 87 | 88 | 89 | class BlocoK(Bloco): 90 | """ 91 | Controle da Produção e do Estoque 92 | """ 93 | registro_abertura = RegistroK001() 94 | registro_encerramento = RegistroK990() 95 | 96 | 97 | class Bloco1(Bloco): 98 | """ 99 | Outras Informações 100 | """ 101 | registro_abertura = Registro1001() 102 | registro_encerramento = Registro1990() 103 | 104 | 105 | class Bloco9(Bloco): 106 | """ 107 | Controle e Encerramento do Arquivo Digital 108 | """ 109 | registro_abertura = Registro9001() 110 | registro_encerramento = Registro9990() 111 | 112 | @property 113 | def fechamento(self): 114 | registro = self.__class__.registro_encerramento() 115 | # Define a quantidade de registros 116 | registro[2] = len(self._registros) + 3 117 | return registro 118 | -------------------------------------------------------------------------------- /sped/efd/pis_cofins/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/efd/pis_cofins/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ... import arquivos 4 | from . import blocos 5 | from . import registros 6 | from .blocos import Bloco0 7 | from .blocos import Bloco1 8 | from .blocos import Bloco9 9 | from .blocos import BlocoA 10 | from .blocos import BlocoC 11 | from .blocos import BlocoD 12 | from .blocos import BlocoF 13 | from .blocos import BlocoI 14 | from .blocos import BlocoM 15 | from .blocos import BlocoP 16 | from .registros import Registro0000 17 | from .registros import Registro9999 18 | 19 | 20 | class ArquivoDigital(arquivos.ArquivoDigital): 21 | registro_abertura = Registro0000 22 | registro_encerramento = Registro9999 23 | registros = registros 24 | blocos = blocos 25 | 26 | def __init__(self): 27 | super(ArquivoDigital, self).__init__() 28 | self._blocos['0'] = Bloco0() 29 | self._blocos['A'] = BlocoA() 30 | self._blocos['C'] = BlocoC() 31 | self._blocos['D'] = BlocoD() 32 | self._blocos['F'] = BlocoF() 33 | self._blocos['I'] = BlocoI() 34 | self._blocos['M'] = BlocoM() 35 | self._blocos['P'] = BlocoP() 36 | self._blocos['1'] = Bloco1() 37 | self._blocos['9'] = Bloco9() 38 | -------------------------------------------------------------------------------- /sped/efd/pis_cofins/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ...blocos import Bloco 4 | from .registros import Registro0001 5 | from .registros import Registro0990 6 | from .registros import Registro1001 7 | from .registros import Registro1990 8 | from .registros import Registro9001 9 | from .registros import Registro9990 10 | from .registros import RegistroA001 11 | from .registros import RegistroA990 12 | from .registros import RegistroC001 13 | from .registros import RegistroC990 14 | from .registros import RegistroD001 15 | from .registros import RegistroD990 16 | from .registros import RegistroF001 17 | from .registros import RegistroF990 18 | from .registros import RegistroI001 19 | from .registros import RegistroI990 20 | from .registros import RegistroM001 21 | from .registros import RegistroM990 22 | from .registros import RegistroP001 23 | from .registros import RegistroP990 24 | 25 | 26 | class Bloco0(Bloco): 27 | """ 28 | Abertura, Identificação e Referências 29 | """ 30 | registro_abertura = Registro0001() 31 | registro_encerramento = Registro0990() 32 | 33 | 34 | class BlocoA(Bloco): 35 | """ 36 | Documentos Fiscais - Serviços (ISS) 37 | """ 38 | registro_abertura = RegistroA001() 39 | registro_encerramento = RegistroA990() 40 | 41 | 42 | class BlocoC(Bloco): 43 | """ 44 | Documentos Fiscais I – Mercadorias (ICMS/IPI) 45 | """ 46 | registro_abertura = RegistroC001() 47 | registro_encerramento = RegistroC990() 48 | 49 | 50 | class BlocoD(Bloco): 51 | """ 52 | Documentos Fiscais II – Serviços (ICMS) 53 | """ 54 | registro_abertura = RegistroD001() 55 | registro_encerramento = RegistroD990() 56 | 57 | 58 | class BlocoF(Bloco): 59 | """ 60 | Demais Documentos e Operações 61 | """ 62 | registro_abertura = RegistroF001() 63 | registro_encerramento = RegistroF990() 64 | 65 | 66 | class BlocoI(Bloco): 67 | """ 68 | Operações das Instituições Financeiras e Assemelhadas, Seguradoras, Entidades de Previdência Privada e Operadoras de Planos de Assistência à Saúde (*) 69 | """ 70 | registro_abertura = RegistroI001() 71 | registro_encerramento = RegistroI990() 72 | 73 | 74 | class BlocoM(Bloco): 75 | """ 76 | Apuração da Contribuição e Crédito de PIS/PASEP e da COFINS 77 | """ 78 | registro_abertura = RegistroM001() 79 | registro_encerramento = RegistroM990() 80 | 81 | 82 | class BlocoP(Bloco): 83 | """ 84 | Apuração da Contribuição Previdenciária sobre a Receita Bruta 85 | """ 86 | registro_abertura = RegistroP001() 87 | registro_encerramento = RegistroP990() 88 | 89 | 90 | class Bloco1(Bloco): 91 | """ 92 | Complemento da Escrituração – Controle de Saldos de Créditos e de Retenções, Operações Extemporâneas e Outras Informações 93 | """ 94 | registro_abertura = Registro1001() 95 | registro_encerramento = Registro1990() 96 | 97 | 98 | class Bloco9(Bloco): 99 | """ 100 | Controle e Encerramento do Arquivo Digital 101 | """ 102 | registro_abertura = Registro0001() 103 | registro_encerramento = Registro0990() 104 | -------------------------------------------------------------------------------- /sped/erros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | 4 | class RegistroError(Exception): 5 | def __init__(self, registro): 6 | self._registro = registro 7 | 8 | def __str__(self): 9 | return u'{0}'.format(self._registro) 10 | 11 | 12 | class CampoError(RegistroError): 13 | def __init__(self, registro, campo): 14 | super(CampoError, self).__init__(registro) 15 | self._campo = campo 16 | 17 | def __str__(self): 18 | return u'{0} -> {1}'.format(self._registro.__class__.__name__, self._campo) 19 | 20 | 21 | class CampoFixoError(CampoError): 22 | pass 23 | 24 | 25 | class CampoInexistenteError(CampoError): 26 | pass 27 | 28 | 29 | class CampoObrigatorioError(CampoError): 30 | pass 31 | 32 | 33 | class FormatoInvalidoError(CampoError): 34 | pass 35 | 36 | 37 | class UseValorError(CampoError): 38 | pass 39 | -------------------------------------------------------------------------------- /sped/escrituracao.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from pathlib import Path 4 | from .campos import Campo 5 | from .campos import CampoBool 6 | from .campos import CampoAlfanumerico 7 | from .campos import CampoCPF 8 | from .campos import CampoCPFouCNPJ 9 | from .campos import CampoCNPJ 10 | from .campos import CampoData 11 | from .campos import CampoFixo 12 | from .campos import CampoNumerico 13 | from .campos import CampoRegex 14 | from .blocos import Bloco 15 | from .registros import Registro 16 | 17 | import json 18 | import re 19 | import types 20 | 21 | 22 | ECD='ecd' 23 | ECF='ecf' 24 | EFD_ICMS_IPI='efd_icms_ipi' 25 | EFD_PIS_COFINS='efd_pis_cofins' 26 | 27 | class Escrituracao(object): 28 | """ 29 | >>> escrituracao = Escrituracao(ECD, 2016) 30 | >>> escrituracao 31 | 32 | >>> escrituracao = Escrituracao(ECD, 2017) 33 | >>> escrituracao 34 | 35 | >>> escrituracao.registro_abertura.__class__ == escrituracao.registros.Registro0000 36 | True 37 | >>> escrituracao.registro_encerramento.__class__ == escrituracao.registros.Registro9999 38 | True 39 | >>> escrituracao._blocos['0'].registro_abertura.__class__ == escrituracao.registros.Registro0001 40 | True 41 | >>> escrituracao._blocos['0'].registro_encerramento.__class__ == escrituracao.registros.Registro0990 42 | True 43 | >>> escrituracao.registros.Registro == escrituracao._registro_escrituracao 44 | True 45 | >>> registro = escrituracao.registros.Registro0000() 46 | >>> registro 47 | 48 | >>> isinstance(registro, escrituracao._registro_escrituracao) 49 | True 50 | >>> registro.escrituracao 51 | 52 | >>> registro.IDENT_MF = 'M' 53 | Traceback (most recent call last): 54 | ... 55 | sped.erros.FormatoInvalidoError: Registro0000 -> IDENT_MF 56 | >>> registro.IDENT_MF = True 57 | >>> registro.IDENT_MF = False 58 | >>> registro.CNPJ = '1' 59 | Traceback (most recent call last): 60 | ... 61 | sped.erros.FormatoInvalidoError: Registro0000 -> CNPJ 62 | >>> registro.CNPJ = '10711130000196' 63 | >>> r = escrituracao.registros.Registro0000('|0000|LECD|01012015|31122015|EMPRESA TESTE|11111111000199|AM||3434401|99999||0|1|0||0|0||N|N|') 64 | >>> r.CNPJ 65 | '11111111000199' 66 | >>> r.IDENT_MF 67 | False 68 | >>> r = escrituracao.registros.Registro0000('|0000|LECD|01012017|31122017|GINX LTDA - ME|10711130000196|PR||4106902|01015622961||0|1|0||0|0||N|N|') 69 | >>> r.COD_SCP 70 | >>> r.TIP_ECD 71 | '0' 72 | >>> escrituracao = Escrituracao(ECF, 2017) 73 | >>> escrituracao 74 | 75 | """ 76 | def __init__(self, tipo: str, ano_calendario: int): 77 | self._tipo = tipo 78 | self._ano_calendario = ano_calendario 79 | 80 | self._registros = types.ModuleType('registros') 81 | self._blocos = {} 82 | 83 | self._registro_escrituracao = type('Registro', (Registro,), { 'escrituracao': self }) 84 | self._add_registro(self._registro_escrituracao) 85 | 86 | sped_path = Path(__file__).parent 87 | 88 | leiaute_path = '%s/leiautes/%s_%s.json' % (sped_path, self._tipo, 89 | self._ano_calendario) 90 | leiaute_ecd = Path(leiaute_path) 91 | 92 | with leiaute_ecd.open(encoding='utf-8', newline='\n') as f: 93 | p = json.load(f) 94 | 95 | for bloco in p['blocos']: 96 | self._blocos[bloco['nome']] = Bloco(bloco['nome']) 97 | 98 | for registro in p['registros']: 99 | campos = [] 100 | 101 | for campo in registro['campos']: 102 | indice = campo['indice'] 103 | nome = campo['nome'] 104 | valores = campo['valores'] 105 | regras = campo['regras'] 106 | tipo = campo['tipo'] 107 | obrigatorio = campo['obrigatorio'] 108 | 109 | # Campos Fixo 110 | m = re.match(r'"([a-z0-9]+)"', valores, re.IGNORECASE) 111 | if m: 112 | campos.append(CampoFixo(indice, nome, m.group(1))) 113 | continue 114 | 115 | m = re.match(r'\[([a-z0-9]+)\]', valores, re.IGNORECASE) 116 | if m: 117 | campos.append(CampoFixo(indice, nome, m.group(1))) 118 | continue 119 | 120 | # Campos Regex 121 | m = re.match(r'\[([^\]]+)\]', valores) 122 | if m: 123 | valoresValidos = m.groups()[0].replace(' ', '').replace('"', '').replace('\n', '').replace(',', ';').split(';') 124 | if set(valoresValidos) == set(['S', 'N']): 125 | campos.append(CampoBool(indice, nome, obrigatorio=obrigatorio)) 126 | continue 127 | else: 128 | campos.append(CampoRegex(indice, nome, obrigatorio=obrigatorio, regex='|'.join(valoresValidos))) 129 | continue 130 | 131 | # Campos Data 132 | if nome.startswith('DT_') or nome.startswith('DATA_'): 133 | campos.append(CampoData(indice, nome, obrigatorio=obrigatorio)) 134 | continue 135 | 136 | # Campo CNPJ ou CPF 137 | if 'REGRA_VALIDA_CNPJ' in regras and 'REGRA_VALIDA_CPF' in regras or nome == 'IDENT_CPF_CNPJ' or nome == 'CPF_CNPJ': 138 | campos.append(CampoCPFouCNPJ(indice, nome, obrigatorio=obrigatorio)) 139 | continue 140 | 141 | # Campo CNPJ 142 | if 'REGRA_VALIDA_CNPJ' in regras or nome == 'CNPJ': 143 | campos.append(CampoCNPJ(indice, nome, obrigatorio=obrigatorio)) 144 | continue 145 | 146 | # Campo CPF 147 | if 'REGRA_VALIDA_CPF' in regras: 148 | campos.append(CampoCPF(indice, nome, obrigatorio=obrigatorio)) 149 | continue 150 | 151 | # CampoAlfaNumerico 152 | if tipo == 'C': 153 | campos.append(CampoAlfanumerico(indice, nome, obrigatorio=obrigatorio, tamanho=campo['tamanho'])) 154 | continue 155 | 156 | # Campos Decimal 157 | if tipo == 'N': 158 | campos.append(CampoNumerico(indice, nome, obrigatorio=obrigatorio, precisao=campo['decimal'])) 159 | continue 160 | 161 | # Campos Decimal 162 | if tipo == 'NS': 163 | campos.append(CampoNumerico(indice, nome, obrigatorio=obrigatorio, precisao=campo['decimal'])) 164 | continue 165 | 166 | # CampoNumerico 167 | if indice is not None: 168 | campos.append(Campo(indice, nome, obrigatorio=obrigatorio)) 169 | 170 | nome_registro = registro['nome'] 171 | r = type('Registro' + registro['codigo'], (self._registro_escrituracao,), { 'campos': campos }) 172 | if re.match(r'ABERTURA DO ARQUIVO DIGITAL', nome_registro): 173 | self.registro_abertura = r() 174 | if re.match(r'ENCERRAMENTO DO ARQUIVO DIGITAL', nome_registro): 175 | self.registro_encerramento = r() 176 | m = re.match(r'ABERTURA DO BLOCO (.)', nome_registro) 177 | if m: 178 | self._blocos[m.group(1)].registro_abertura = r() 179 | m = re.match(r'ENCERRAMENTO DO BLOCO (.)', nome_registro) 180 | if m: 181 | self._blocos[m.group(1)].registro_encerramento = r() 182 | self._add_registro(r) 183 | 184 | def _add_registro(self, registro: type): 185 | setattr(self._registros, registro.__name__, registro) 186 | 187 | @property 188 | def blocos(self) -> list: 189 | return self._blocos 190 | 191 | @property 192 | def registros(self) -> types.ModuleType: 193 | return self._registros 194 | 195 | def prepare(self): 196 | bloco_9 = self._blocos['9'] 197 | 198 | for bloco in self._blocos.values(): 199 | regs = {} 200 | 201 | for reg in bloco.registros: 202 | if reg.REG not in regs: 203 | regs[reg.REG] = 0 204 | regs[reg.REG] += 1 205 | 206 | if bloco == self._blocos['0']: 207 | regs['0000'] = 1 208 | 209 | if bloco == bloco_9: 210 | regs['9999'] = 1 211 | regs['9900'] += len(regs.keys()) 212 | 213 | for reg in regs.keys(): 214 | registro = self.registros.Registro9900() # pylint: disable=E1101 215 | try: 216 | registro.REG_BLC = reg 217 | except: 218 | for rrr in bloco.registros: 219 | print(rrr) 220 | print(locals()) 221 | raise 222 | registro.QTD_REG_BLC = regs[reg] 223 | bloco_9.add(registro) 224 | 225 | reg_count = 2 226 | for bloco in self._blocos.values(): 227 | reg_count += len(bloco.registros) 228 | 229 | self.registro_encerramento[2] = reg_count 230 | 231 | def write_to(self, buff): 232 | buff.write('%s\r\n' % self.registro_abertura) 233 | reg_count = 2 234 | for bloco in self._blocos.values(): 235 | reg_count += len(bloco.registros) 236 | for registro in bloco.registros: 237 | buff.write('%s\r\n' % registro) 238 | 239 | self.registro_encerramento[2] = reg_count 240 | 241 | buff.write('%s\r\n' % self.registro_encerramento) 242 | 243 | def add(self, registro: Registro): 244 | pass 245 | 246 | def __repr__(self): 247 | return '<%s.%s(%s, %s)>' % (self.__class__.__module__, 248 | self.__class__.__name__, 249 | self._tipo, self._ano_calendario) 250 | -------------------------------------------------------------------------------- /sped/fci/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/fci/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from .. import arquivos 4 | from . import registros 5 | from . import blocos 6 | from .blocos import Bloco0 7 | from .blocos import Bloco5 8 | from .blocos import Bloco9 9 | from .registros import Registro0000 10 | from .registros import Registro9999 11 | 12 | 13 | class ArquivoDigital(arquivos.ArquivoDigital): 14 | registro_abertura = Registro0000 15 | registro_encerramento = Registro9999 16 | registros = registros 17 | blocos = blocos 18 | 19 | def __init__(self): 20 | super(ArquivoDigital, self).__init__() 21 | self._blocos['0'] = Bloco0() 22 | self._blocos['5'] = Bloco5() 23 | self._blocos['9'] = Bloco9() 24 | 25 | utf = (u"0001|Texto em caracteres UTF-8: (dígrafo BR)'ção',(dígrafo " 26 | u"espanhol-enhe)'ñ',(trema)'Ü',(ordinais)'ªº',(ligamento s+z a" 27 | u"lemão)'ß'.") 28 | self.read_registro(utf) 29 | self.read_registro('|9900|0000|1') 30 | self.read_registro('|9900|0010|1') 31 | self.read_registro('|9900|5020|') 32 | 33 | def read_registro(self, line): 34 | 35 | # caso o usuario insira linha sem pip 36 | pipe = '|' if line[0] != '|' else '' 37 | line = pipe + line 38 | reg_id = line.split('|')[1] 39 | 40 | try: 41 | registro_class = \ 42 | getattr(self.__class__.registros, 'Registro' + reg_id) 43 | except AttributeError: 44 | raise RuntimeError(u"Arquivo inválido para FCI") 45 | 46 | registro = registro_class(line) 47 | if registro.__class__ == self.__class__.registro_abertura: 48 | self._registro_abertura = registro 49 | elif registro.__class__ == self.__class__.registro_encerramento: 50 | self._registro_encerramento = registro 51 | elif registro.__class__ == \ 52 | self.__class__.blocos.Bloco0.registro_abertura: 53 | self.blocos.Bloco0.abertura = registro 54 | else: 55 | bloco_id = reg_id[0] 56 | bloco = self._blocos[bloco_id] 57 | bloco.add(registro) 58 | 59 | # Contabiliza os registros 5020 60 | if reg_id == '5020': 61 | registros_9 = self._blocos['9'].registros[3] 62 | registros_9.valores[3] = \ 63 | str((len(self._blocos['5'].registros)) - 2) 64 | 65 | def write_to(self, buffer): 66 | 67 | linha_abertura = self._registro_abertura.as_line()[1:] 68 | buffer.write(linha_abertura + u'\r\n') 69 | reg_count = 2 70 | for key in self._blocos.keys(): 71 | bloco = self._blocos[key] 72 | reg_count += len(bloco.registros) 73 | for r in bloco.registros: 74 | a = r.as_line() 75 | a = a[1:] 76 | buffer.write(a + u'\r\n') 77 | 78 | self._registro_encerramento[2] = reg_count 79 | linha_fechamento = self._registro_encerramento.as_line()[1:] 80 | buffer.write(linha_fechamento + u'\r\n') 81 | 82 | def readfile(self, filename): 83 | 84 | with open(filename) as arq: 85 | for line in [line.rstrip('\r\n') for line in arq]: 86 | if (line[:4] != '9900' and line[:4] != '0001' and line[:4] != '0990'): 87 | self.read_registro(line.decode('utf-8-sig')) 88 | -------------------------------------------------------------------------------- /sped/fci/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..blocos import Bloco 4 | 5 | from .registros import Registro0001 6 | from .registros import Registro0990 7 | from .registros import Registro5001 8 | from .registros import Registro5990 9 | from .registros import Registro9001 10 | from .registros import Registro9990 11 | 12 | 13 | class Bloco0(Bloco): 14 | """ 15 | Cabeçalho da FCI: Identificação do contribuinte 16 | """ 17 | registro_abertura = Registro0001() 18 | registro_encerramento = Registro0990() 19 | 20 | @property 21 | def abertura(self): 22 | return self.registro_abertura 23 | 24 | @property 25 | def fechamento(self): 26 | # Define a quantidade de registros 27 | self.registro_encerramento[2] = len(self._registros) + 3 28 | return self.registro_encerramento 29 | 30 | def add(self, registro): 31 | self._registros.append(registro) 32 | 33 | 34 | class Bloco5(Bloco): 35 | registro_abertura = Registro5001() 36 | registro_encerramento = Registro5990() 37 | 38 | @property 39 | def abertura(self): 40 | return self.registro_abertura 41 | 42 | 43 | class Bloco9(Bloco): 44 | """ 45 | Controle e Encerramento do Arquivo Digital 46 | """ 47 | registro_abertura = Registro9001() 48 | registro_encerramento = Registro9990() 49 | 50 | @property 51 | def abertura(self): 52 | return self.registro_abertura 53 | -------------------------------------------------------------------------------- /sped/fci/registros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..campos import CampoFixo, CampoAlfanumerico, CampoNumerico 4 | from ..registros import Registro 5 | from ..erros import CampoError 6 | 7 | 8 | class Registro0000(Registro): 9 | campos = [ 10 | CampoFixo(1, 'REG', '0000'), 11 | CampoAlfanumerico(2, 'CNPJ_CONTRIBUINTE'), 12 | CampoAlfanumerico(3, 'NOME_CONTRIBUINTE'), 13 | CampoFixo(4, 'VERSAO_LEIAUTE', '1.0'), 14 | CampoAlfanumerico(5, 'HASH CODE', obrigatorio=False, tamanho=47), 15 | CampoAlfanumerico(6, 'DT_RECEPCAO_ARQUIVO', obrigatorio=False, 16 | tamanho=20), 17 | CampoAlfanumerico(7, 'COD_RECEPCAO_ARQUIVO', obrigatorio=False, 18 | tamanho=36), 19 | CampoAlfanumerico(8, 'DT_VALIDACAO_ARQUIVO', obrigatorio=False, 20 | tamanho=20), 21 | CampoAlfanumerico(9, 'IN_VALIDACAO_ARQUIVO', obrigatorio=False, 22 | tamanho=20) 23 | ] 24 | 25 | 26 | class Registro0001(Registro): 27 | campos = [ 28 | CampoFixo(1, 'REG', "0001"), 29 | CampoAlfanumerico(2, 'TEXTO_PADRAO_UTF8', obrigatorio=True) 30 | ] 31 | 32 | 33 | class Registro0010(Registro): 34 | campos = [ 35 | CampoFixo(1, 'REG', '0010'), 36 | CampoAlfanumerico(2, 'CNPJ_CONTRIBUINTE', obrigatorio=True), 37 | CampoAlfanumerico(3, 'NOME_RAZAO_SOCIAL', obrigatorio=True), 38 | CampoAlfanumerico(4, 'INSCRICAO_ESTADUAL', obrigatorio=True), 39 | CampoAlfanumerico(5, 'ENDERECO_ESTABELECIMENTO', obrigatorio=True), 40 | CampoNumerico(6, 'CEP', obrigatorio=True), 41 | CampoAlfanumerico(7, 'MUNICIPIO', obrigatorio=True), 42 | CampoAlfanumerico(8, 'UF', obrigatorio=True) 43 | ] 44 | 45 | 46 | class Registro0990(Registro): 47 | campos = [ 48 | CampoFixo(1, 'REG', '0990'), 49 | CampoNumerico(2, 'QUANTIDADE_LINHAS') 50 | ] 51 | 52 | def __init__(self, line=None): 53 | if not line: 54 | self._valores = [''] * (len(self.campos) + 1) 55 | for c in self.campos: 56 | if isinstance(c, CampoFixo): 57 | self._valores[c.indice] = c.valor 58 | else: 59 | self._valores = line.split('|') 60 | for c in self.campos: 61 | if isinstance(c, CampoFixo): 62 | if self._valores[c.indice] != c.valor: 63 | raise CampoError(self, c.nome) 64 | 65 | 66 | class Registro5001(Registro): 67 | campos = [ 68 | CampoFixo(1, 'REG', '5001'), 69 | ] 70 | 71 | def __init__(self, line=None): 72 | if not line: 73 | self._valores = [''] * (len(self.campos) + 1) 74 | for c in self.campos: 75 | if isinstance(c, CampoFixo): 76 | self._valores[c.indice] = c.valor 77 | else: 78 | self._valores = line.split('|') 79 | for c in self.campos: 80 | if isinstance(c, CampoFixo): 81 | if self._valores[c.indice] != c.valor: 82 | raise CampoError(self, c.nome) 83 | 84 | 85 | class Registro5020(Registro): 86 | campos = [ 87 | CampoFixo(1, 'REG', '5020'), 88 | CampoAlfanumerico(2, 'NOME_MERCADORIA', obrigatorio=True, tamanho=255), 89 | CampoNumerico(3, 'CODIGO_NCM', obrigatorio=True), 90 | CampoAlfanumerico(4, 'CODIGO_MERCADORIA', obrigatorio=True, 91 | tamanho=50), 92 | CampoNumerico(5, 'CODIGO_GTIN'), 93 | CampoAlfanumerico(6, 'UNIDADE_MERCADORIA', tamanho=6, 94 | obrigatorio=True), 95 | CampoNumerico(7, 'VALOR_SAIDA_MERCADORIA_INTERESTADUAL', precisao=2, 96 | obrigatorio=True), 97 | CampoNumerico(8, 'VALOR_PARCELA_IMPORTADA_EXTERIOR', precisao=2, 98 | obrigatorio=True), 99 | CampoNumerico(9, 'CONTEUDO_IMPORTACAO_CI', precisao=2, 100 | obrigatorio=True), 101 | CampoAlfanumerico(10, 'CODIGO_FCI', obrigatorio=False, tamanho=36), 102 | CampoAlfanumerico(11, 'IN_VALIDACAO_FICHA', obrigatorio=False, 103 | tamanho=20) 104 | ] 105 | 106 | 107 | class Registro5990(Registro): 108 | campos = [ 109 | CampoFixo(1, 'REG', '5990'), 110 | CampoNumerico(2, 'QUANTIDADE_LINHAS'), 111 | ] 112 | 113 | def __init__(self, line=None): 114 | if not line: 115 | self._valores = [''] * (len(self.campos) + 1) 116 | for c in self.campos: 117 | if isinstance(c, CampoFixo): 118 | self._valores[c.indice] = c.valor 119 | else: 120 | self._valores = line.split('|') 121 | for c in self.campos: 122 | if isinstance(c, CampoFixo): 123 | if self._valores[c.indice] != c.valor: 124 | raise CampoError(self, c.nome) 125 | 126 | 127 | class Registro9001(Registro): 128 | campos = [ 129 | CampoFixo(1, 'REG', '9001') 130 | ] 131 | 132 | def __init__(self, line=None): 133 | if not line: 134 | self._valores = [''] * (len(self.campos) + 1) 135 | for c in self.campos: 136 | if isinstance(c, CampoFixo): 137 | self._valores[c.indice] = c.valor 138 | else: 139 | self._valores = line.split('|') 140 | for c in self.campos: 141 | if isinstance(c, CampoFixo): 142 | if self._valores[c.indice] != c.valor: 143 | raise CampoError(self, c.nome) 144 | 145 | 146 | class Registro9900(Registro): 147 | campos = [ 148 | CampoFixo(1, 'REG', '9900'), 149 | CampoAlfanumerico(2, 'REG_SER_TOTALIZADO', tamanho=4), 150 | CampoNumerico(3, 'QUANTIDADE_LINHAS_REGISTRO_ANTERIOR') 151 | ] 152 | 153 | 154 | class Registro9990(Registro): 155 | campos = [ 156 | CampoFixo(1, 'REG', '9990'), 157 | CampoNumerico(2, 'QUANTIDADE_LINHAS') 158 | ] 159 | 160 | def __init__(self, line=None): 161 | if not line: 162 | self._valores = [''] * (len(self.campos) + 1) 163 | for c in self.campos: 164 | if isinstance(c, CampoFixo): 165 | self._valores[c.indice] = c.valor 166 | else: 167 | self._valores = line.split('|') 168 | for c in self.campos: 169 | if isinstance(c, CampoFixo): 170 | if self._valores[c.indice] != c.valor: 171 | raise CampoError(self, c.nome) 172 | 173 | 174 | class Registro9999(Registro): 175 | campos = [ 176 | CampoFixo(1, 'REG', '9999'), 177 | CampoNumerico(2, 'QUANTIDADE_LINHAS_ARQUIVO') 178 | ] 179 | 180 | def __init__(self, line=None): 181 | if not line: 182 | self._valores = [''] * (len(self.campos) + 1) 183 | for c in self.campos: 184 | if isinstance(c, CampoFixo): 185 | self._valores[c.indice] = c.valor 186 | else: 187 | self._valores = line.split('|') 188 | for c in self.campos: 189 | if isinstance(c, CampoFixo): 190 | if self._valores[c.indice] != c.valor: 191 | raise CampoError(self, c.nome) 192 | -------------------------------------------------------------------------------- /sped/lcdpr/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /sped/lcdpr/arquivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from sped import arquivos 4 | from sped.lcdpr import blocos 5 | from sped.lcdpr import registros 6 | from sped.lcdpr.blocos import Bloco0 7 | from sped.lcdpr.blocos import BlocoQ 8 | from sped.lcdpr.blocos import Bloco9 9 | from sped.lcdpr.registros import Registro0000 10 | from sped.lcdpr.registros import Registro9999 11 | 12 | 13 | class ArquivoDigital(arquivos.ArquivoDigital): 14 | registro_abertura = Registro0000 15 | registro_encerramento = Registro9999 16 | registros = registros 17 | blocos = blocos 18 | 19 | def __init__(self): 20 | super(ArquivoDigital, self).__init__() 21 | self._blocos['0'] = Bloco0() 22 | self._blocos['Q'] = BlocoQ() 23 | self._blocos['9'] = Bloco9() 24 | 25 | def prepare(self): 26 | reg_count = 0 27 | 28 | for bloco in self._blocos.values(): 29 | reg_count += len(bloco.registros) 30 | 31 | self.registro_encerramento._numero_linhas = reg_count 32 | 33 | if __name__ == "__main__": 34 | import doctest 35 | doctest.testmod() 36 | -------------------------------------------------------------------------------- /sped/lcdpr/blocos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..blocos import Bloco 4 | from .registros import RegistroQ100 5 | from .registros import RegistroQ200 6 | 7 | class Bloco0(Bloco): 8 | """ 9 | Abertura e Identificação 10 | """ 11 | registro_abertura = None 12 | registro_encerramento = None 13 | 14 | 15 | class BlocoQ(Bloco): 16 | """ 17 | Demonstrativo do Resultado da Atividade Rural 18 | """ 19 | registro_abertura = None 20 | registro_encerramento = None 21 | 22 | @property 23 | def registros(self): 24 | regs = [] 25 | 26 | if self.abertura is not None: 27 | regs.append(self.abertura) 28 | 29 | regs = regs + [r for r in self._registros if isinstance(r, RegistroQ100)] 30 | regs = regs + [r for r in self._registros if isinstance(r, RegistroQ200)] 31 | 32 | if self.encerramento is not None: 33 | regs.append(self.encerramento) 34 | 35 | return regs 36 | 37 | 38 | class Bloco9(Bloco): 39 | """ 40 | Identificação do Contador e Encerramento do Arquivo Digital 41 | """ 42 | registro_abertura = None 43 | registro_encerramento = None 44 | 45 | -------------------------------------------------------------------------------- /sped/lcdpr/registros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from ..campos import * 4 | from ..registros import Registro 5 | from ..registros import RegistroAbertura 6 | from ..registros import RegistroEncerramento 7 | 8 | 9 | class Registro0000(RegistroAbertura): 10 | """ 11 | ABERTURA DO ARQUIVO DIGITAL E IDENTIFICAÇÃO DA PESSOA FÍSICA 12 | """ 13 | campos = [ 14 | CampoFixo(1, 'REG', '0000'), 15 | CampoFixo(2, 'NOME_ESC', 'LCDPR'), 16 | CampoAlfanumerico(3, 'COD_VER', obrigatorio=True, tamanho=4), 17 | CampoCPF(4, 'CPF', obrigatorio=True), 18 | CampoAlfanumerico(5, 'NOME', obrigatorio=True), 19 | CampoRegex(6, 'IND_SIT_INI_PER', obrigatorio=True, regex='[0-2]'), 20 | CampoRegex(7, 'SIT_ESPECIAL', obrigatorio=True, regex='[0-3]'), 21 | CampoData(8, 'DT_SIT_ESP'), 22 | CampoData(9, 'DT_INI', obrigatorio=True), 23 | CampoData(10, 'DT_FIN', obrigatorio=True), 24 | ] 25 | 26 | 27 | class Registro0010(Registro): 28 | """ 29 | PARÂMETROS DE TRIBUTAÇÃO 30 | """ 31 | campos = [ 32 | CampoFixo(1, 'REG', '0010'), 33 | CampoRegex(2, 'FORMA_APUR', obrigatorio=True, regex='[1-2]'), 34 | ] 35 | 36 | class Registro0030(Registro): 37 | """ 38 | DADOS CADASTRAIS DO CONTRIBUINTE 39 | """ 40 | campos = [ 41 | CampoFixo(1, 'REG', '0030'), 42 | Campo(2, 'ENDERECO'), 43 | Campo(3, 'NUM'), 44 | Campo(4, 'COMPL'), 45 | Campo(5, 'BAIRRO'), 46 | Campo(6, 'UF'), 47 | Campo(7, 'COD_MUN'), 48 | Campo(8, 'CEP'), 49 | Campo(9, 'NUM_TEL'), 50 | Campo(10, 'EMAIL'), 51 | ] 52 | 53 | 54 | class Registro0040(Registro): 55 | """ 56 | CADASTRO DOS IMÓVEIS RURAIS 57 | """ 58 | campos = [ 59 | CampoFixo(1, 'REG', '0040'), 60 | Campo(2, 'COD_IMÓVEL'), 61 | Campo(3, 'PAIS'), 62 | Campo(4, 'MOEDA'), 63 | Campo(5, 'CAD_ITR'), 64 | Campo(6, 'CAEPF'), 65 | Campo(7, 'INSCR_ESTADUAL'), 66 | Campo(8, 'NOME_IMÓVEL'), 67 | Campo(9, 'ENDERECO'), 68 | Campo(10, 'NUM'), 69 | Campo(11, 'COMPL'), 70 | Campo(12, 'BAIRRO'), 71 | Campo(13, 'UF'), 72 | Campo(14, 'COD_MUN'), 73 | Campo(15, 'CEP'), 74 | Campo(16, 'TIPO_EXPLORAÇÃO'), 75 | Campo(17, 'PARTICIPAÇÃO'), 76 | ] 77 | 78 | 79 | class Registro0045(Registro): 80 | """ 81 | CADASTRO DE TERCEIROS 82 | """ 83 | campos = [ 84 | CampoFixo(1, 'REG', '0045'), 85 | Campo(2, 'COD_IMÓVEL'), 86 | Campo(3, 'TIPO_CONTRAPARTE'), 87 | Campo(4, 'ID_CONTRAPARTE'), 88 | Campo(5, 'NOME_CONTRAPARTE'), 89 | Campo(6, 'PERC_CONTRAPARTE'), 90 | ] 91 | 92 | 93 | class Registro0050(Registro): 94 | """ 95 | CADASTRO DAS CONTAS BANCÁRIAS DO PRODUTOR RURAL 96 | """ 97 | campos = [ 98 | CampoFixo(1, 'REG', '0050'), 99 | Campo(2, 'COD_CONTA'), 100 | Campo(3, 'PAIS_CTA'), 101 | Campo(4, 'BANCO'), 102 | Campo(5, 'NOME_BANCO'), 103 | Campo(6, 'AGENCIA'), 104 | Campo(7, 'NUM_CONTA'), 105 | ] 106 | 107 | 108 | class RegistroQ100(Registro): 109 | """ 110 | DEMONSTRATIVO DO RESULTADO DA ATIVIDADE RURAL 111 | """ 112 | campos = [ 113 | CampoFixo(1, 'REG', 'Q100'), 114 | CampoData(2, 'DATA'), 115 | Campo(3, 'COD_IMÓVEL'), 116 | Campo(4, 'COD_CONTA'), 117 | Campo(5, 'NUM_DOC'), 118 | Campo(6, 'TIPO_DOC'), 119 | Campo(7, 'HIST'), 120 | Campo(8, 'ID_PARTIC'), 121 | Campo(9, 'TIPO_LANC'), 122 | CampoNumerico2(10, 'VL_ENTRADA', precisao=19), 123 | CampoNumerico2(11, 'VL_SAIDA', precisao=19), 124 | CampoNumerico2(12, 'SLD_FIN', precisao=19), 125 | Campo(13, 'NAT_SLD_FIN'), 126 | ] 127 | 128 | 129 | class RegistroQ200(Registro): 130 | """ 131 | RESUMO MENSAL DO DEMONSTRATIVO DO RESULTADO DA ATIVIDADE RURAL 132 | """ 133 | campos = [ 134 | CampoFixo(1, 'REG', 'Q200'), 135 | Campo(2, 'MÊS'), 136 | CampoNumerico2(3, 'VL_ENTRADA'), 137 | CampoNumerico2(4, 'VL_SAIDA'), 138 | CampoNumerico2(5, 'SLD_FIN'), 139 | Campo(6, 'NAT_SLD_FIN'), 140 | ] 141 | 142 | 143 | class Registro9999(RegistroEncerramento): 144 | """ 145 | Encerramento do Arquivo Digital 146 | """ 147 | campos = [ 148 | CampoFixo(1, 'REG', '9999'), 149 | Campo(2, 'IDENT_NOM'), 150 | Campo(3, 'IDENT_CPF_CNPJ'), 151 | Campo(4, 'IND_CRC'), 152 | Campo(5, 'EMAIL'), 153 | Campo(6, 'FONE'), 154 | CampoNumerico(7, 'QTD_LIN'), 155 | ] 156 | -------------------------------------------------------------------------------- /sped/leiaute.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import json 3 | import re 4 | from datetime import date 5 | 6 | from json import JSONEncoder 7 | 8 | 9 | class LeiauteEncoder(JSONEncoder): 10 | def default(self, o): # pylint: disable=E0202 11 | if isinstance(o, date): 12 | return o.isoformat() 13 | return o.__dict__ 14 | 15 | 16 | def normalize_spaces(s): 17 | return re.sub(r'[\n\r\s]{2,}', ' ', s) 18 | 19 | 20 | def normalize_quotes(s): 21 | return s.replace('“','"').replace('”','"') 22 | 23 | 24 | def remove_space(s): 25 | return re.sub(r'\n|\r|\s', '', s) 26 | 27 | 28 | def extrair_parametros(s): 29 | return [remove_space(r[1:-1]) for r in re.findall(r'\[[^\]]+\]', s)] 30 | 31 | 32 | class Leiaute(object): 33 | def __init__(self, tipo, versao, data_inicio, blocos, registros): 34 | self.tipo = tipo 35 | self.versao = versao 36 | self.data_inicio = data_inicio 37 | self.blocos = blocos 38 | self.registros = registros 39 | 40 | 41 | class Bloco(object): 42 | def __init__(self, nome, descricao): 43 | self.nome = nome 44 | self.descricao = descricao 45 | 46 | def __repr__(self): 47 | return '' % (self.nome, self.descricao) 48 | 49 | 50 | class Registro(object): 51 | def __init__(self, codigo, nome, regras, nivel, ocorrencia, campos_chave): 52 | self.codigo = codigo 53 | self.nome = nome 54 | self.regras = regras 55 | self.nivel = nivel 56 | self.ocorrencia = ocorrencia 57 | self.campos_chave = campos_chave 58 | self.campos = [] 59 | 60 | def __repr__(self): 61 | return '' % (self.codigo, self.nome) 62 | 63 | 64 | class Campo(object): 65 | def __init__(self, indice, nome, descricao, tipo, tamanho, decimal, valores, obrigatorio, regras): 66 | try: 67 | self.indice = int(indice) 68 | except: 69 | self.indice = None 70 | self.nome = nome 71 | self.descricao = descricao 72 | self.tipo = tipo 73 | 74 | try: 75 | self.tamanho = int(tamanho) 76 | except: 77 | self.tamanho = None 78 | 79 | try: 80 | self.decimal = int(decimal) 81 | except: 82 | self.decimal = None 83 | 84 | self.valores = normalize_quotes(valores) 85 | self.obrigatorio = obrigatorio 86 | self.regras = regras 87 | 88 | def __repr__(self): 89 | return '' % (self.indice, self.nome) 90 | -------------------------------------------------------------------------------- /sped/registros.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from .campos import CampoData 4 | from .campos import CampoFixo 5 | from .campos import CampoRegex 6 | from .erros import CampoError 7 | from .erros import CampoInexistenteError 8 | from .erros import RegistroError 9 | 10 | 11 | class Registro(object): 12 | """ 13 | Classe abstrata para a manipulação dos registros. 14 | 15 | >>> class RegistroTest(Registro): 16 | ... campos = [CampoFixo(1, 'REG', 'TEST'), 17 | ... CampoData(2, 'DT_INI'), 18 | ... CampoData(3, 'DT_FIM'), 19 | ... CampoRegex(4, 'RETIFICADORA', obrigatorio=True, regex='[SN]'),] 20 | >>> line = '|ERRO|01012015||N|' 21 | >>> r = RegistroTest(line) # doctest: +IGNORE_EXCEPTION_DETAIL 22 | Traceback (most recent call last): 23 | ... 24 | CampoError: RegistroTest -> REG 25 | >>> line = '|TEST|01012015||N|' 26 | >>> r = RegistroTest(line) 27 | >>> r.REG 28 | 'TEST' 29 | >>> r.REG = '0000' # doctest: +IGNORE_EXCEPTION_DETAIL 30 | Traceback (most recent call last): 31 | ... 32 | CampoFixoError: RegistroTest -> REG 33 | >>> r.DT_INI 34 | datetime.date(2015, 1, 1) 35 | >>> r.DT_FIM 36 | >>> from datetime import date 37 | >>> r.DT_INI = date(2014, 2, 1) 38 | >>> r.DT_INI 39 | datetime.date(2014, 2, 1) 40 | >>> r.DT_INI = '01012014' # doctest: +IGNORE_EXCEPTION_DETAIL 41 | Traceback (most recent call last): 42 | ... 43 | FormatoInvalidoError: RegistroTest -> DT_INI 44 | >>> r.DT_INI = '' 45 | >>> r.DT_INI 46 | >>> r.DT_INI = None 47 | >>> r.DT_INI 48 | >>> r.CAMPO_INEXISTENTE = '' # doctest: +IGNORE_EXCEPTION_DETAIL 49 | Traceback (most recent call last): 50 | ... 51 | CampoInexistenteError: RegistroTest -> CAMPO_INEXISTENTE 52 | >>> r.CAMPO_INEXISTENTE # doctest: +IGNORE_EXCEPTION_DETAIL 53 | Traceback (most recent call last): 54 | ... 55 | CampoInexistenteError: RegistroTest -> CAMPO_INEXISTENTE 56 | >>> r.RETIFICADORA 57 | 'N' 58 | >>> r.RETIFICADORA = 'S' 59 | >>> r.RETIFICADORA 60 | 'S' 61 | >>> r.RETIFICADORA = '0' # doctest: +IGNORE_EXCEPTION_DETAIL 62 | Traceback (most recent call last): 63 | ... 64 | FormatoInvalidoError: RegistroTest -> RETIFICADORA 65 | """ 66 | campos = [] 67 | 68 | def __init__(self, line=None): 69 | if not line: 70 | self._valores = [''] * (len(self.campos) + 2) 71 | for c in self.campos: 72 | if isinstance(c, CampoFixo): 73 | self._valores[c.indice] = c.valor 74 | else: 75 | self._valores = line.split('|') 76 | for c in self.campos: 77 | if isinstance(c, CampoFixo): 78 | if self._valores[c.indice] != c.valor: 79 | raise CampoError(self, c.nome) 80 | 81 | @property 82 | def campos(self): 83 | return self.__class__.campos 84 | 85 | @property 86 | def valores(self): 87 | return self._valores 88 | 89 | def __getitem__(self, key): 90 | campo = ([c for c in self.campos if c.indice == key or c.nome == key] or [None])[0] 91 | if not campo: 92 | raise CampoInexistenteError(self, key) 93 | return campo.get(self) 94 | 95 | def __setitem__(self, key, value): 96 | campo = ([c for c in self.campos if c.indice == key or c.nome == key] or [None])[0] 97 | if not campo: 98 | raise CampoInexistenteError(self, key) 99 | campo.set(self, value) 100 | 101 | def __getattr__(self, name): 102 | campo = ([c for c in self.campos if c.nome == name] or [None])[0] 103 | if not campo: 104 | raise CampoInexistenteError(self, name) 105 | return campo.get(self) 106 | 107 | def __setattr__(self, name, value): 108 | if name.startswith('_'): 109 | super(Registro, self).__setattr__(name, value) 110 | return 111 | campo = ([c for c in self.campos if c.nome == name] or [None])[0] 112 | if not campo: 113 | raise CampoInexistenteError(self, name) 114 | campo.set(self, value) 115 | 116 | def as_line(self): 117 | return str(self) 118 | 119 | def __str__(self): 120 | return '|'.join(self._valores) 121 | 122 | def __repr__(self): 123 | return '<%s.%s>' % (self.__class__.__module__, self.__class__.__name__) 124 | 125 | 126 | class RegistroIndefinido(Registro): 127 | def __init__(self): 128 | super(RegistroIndefinido, self).__init__() 129 | raise RegistroError(self) 130 | -------------------------------------------------------------------------------- /test/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | -------------------------------------------------------------------------------- /test/fci_test.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | import unittest 4 | import os 5 | import sys 6 | 7 | # Necessário para que o arquivo de testes encontre 8 | test_root = os.path.dirname(os.path.abspath(__file__)) 9 | os.chdir(test_root) 10 | sys.path.insert(0, os.path.dirname(test_root)) 11 | sys.path.insert(0, test_root) 12 | 13 | from sped.fci import arquivos 14 | 15 | 16 | class TestArquivoDigital(unittest.TestCase): 17 | 18 | def test_read_registro(self): 19 | txt = u"""0000|11111111000191|EMPRESA TESTE|1.0 20 | 0001|Texto em caracteres UTF-8: (dígrafo BR)'ção',(dígrafo espanhol-enhe)'ñ',(trema)'Ü',(ordinais)'ªº',(ligamento s+z alemão)'ß'. 21 | 0010|46377222000129|Contribuinte de Teste S/A|686001664111|Rua XV de novembro, 1.234|01506000|São João|SP 22 | 0990|4 23 | 5001 24 | 5020|Motor de pistão por ignição, cilindrada igual a 2.000 cm³ - R123-A4-5|84073490|12j8ai.5d0-ao4p|07123456789012|unid|9123,45|4567,89|50,07 25 | 5020|Motor de pistão por ignição, cilindrada igual a 2.000 cm³ - R123-A4-5|84073490|12j8ai.5d0-ao4p|07123456789012|unid|9123,45|4567,89|50,07 26 | 5020|Motor de pistão por ignição, cilindrada igual a 2.000 cm³ - R123-A4-5|84073490|12j8ai.5d0-ao4p|07123456789012|unid|9123,45|4567,89|50,07 27 | 5990|5 28 | 9001 29 | 9900|0000|1 30 | 9900|0010|1 31 | 9900|5020|3 32 | 9990|5 33 | 9999|15 34 | """.replace('\n', '\r\n') 35 | 36 | # Permite validacao de string grandes 37 | self.maxDiff = None 38 | arq = arquivos.ArquivoDigital() 39 | 40 | arq.read_registro('0000|11111111000191|EMPRESA TESTE|1.0') 41 | 42 | arq.read_registro(u"|0001|Texto em caracteres UTF-8: (dígrafo BR)'ção'," 43 | u"(dígrafo espanhol-enhe)'ñ',(trema)'Ü',(ordinais" 44 | u")'ªº',(ligamento s+z alemão)'ß'.") 45 | 46 | arq.read_registro( u'|0010|46377222000129|Contribuinte de Teste ' 47 | u'S/A|686001664111|Rua XV de novembro, 1.234|' 48 | u'01506000|São João|SP') 49 | 50 | arq.read_registro(u'|5020|Motor de pistão por ignição, cilindrada ' 51 | u'igual a 2.000 cm³ - R123-A4-5|84073490|' 52 | u'12j8ai.5d0-ao4p|07123456789012|unid|9123,45|' 53 | u'4567,89|50,07') 54 | 55 | arq.read_registro(u'|5020|Motor de pistão por ignição, cilindrada ' 56 | u'igual a 2.000 cm³ - R123-A4-5|84073490|' 57 | u'12j8ai.5d0-ao4p|07123456789012|unid|9123,45|' 58 | u'4567,89|50,07') 59 | 60 | arq.read_registro(u'|5020|Motor de pistão por ignição, cilindrada ' 61 | u'igual a 2.000 cm³ - R123-A4-5|84073490|' 62 | u'12j8ai.5d0-ao4p|07123456789012|unid|9123,45|' 63 | u'4567,89|50,07') 64 | 65 | self.assertEqual(txt, arq.getstring()) 66 | 67 | if __name__ == '__main__': 68 | unittest.main() 69 | -------------------------------------------------------------------------------- /test/pis_cofins.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | import unittest 4 | import os 5 | import sys 6 | 7 | # Necessário para que o arquivo de testes encontre 8 | test_root = os.path.dirname(os.path.abspath(__file__)) 9 | os.chdir(test_root) 10 | sys.path.insert(0, os.path.dirname(test_root)) 11 | sys.path.insert(0, test_root) 12 | 13 | from sped.efd.icms_ipi.arquivos import ArquivoDigital 14 | from sped.efd.icms_ipi.registros import Registro0100 15 | 16 | class TestSpedPisCofins(unittest.TestCase): 17 | 18 | def test_read_registro(self): 19 | txt = u"""|0000|010|0|01102016|30102016|KMEE INFORMATICA LTDA|53.939.351/0001-29|333.333.333-33|SP|222.222.222.222|1234567|5999|0123|A|1| 20 | |0001|0| 21 | |0100|Daniel Sadamo|12334532212|532212|||Rua dos ferroviario|123|Agonia|||||| 22 | |0990|3| 23 | |C001|1| 24 | |C990|2| 25 | |D001|1| 26 | |D990|2| 27 | |E001|1| 28 | |E990|2| 29 | |G001|1| 30 | |G990|2| 31 | |H001|1| 32 | |H990|2| 33 | |K001|1| 34 | |K990|2| 35 | |1001|1| 36 | |1990|2| 37 | |9001|1| 38 | |9990|2| 39 | |9999|21| 40 | """.replace('\n', '\r\n') 41 | 42 | # Permite validacao de string grandes 43 | self.maxDiff = None 44 | arq = ArquivoDigital() 45 | 46 | arq._registro_abertura.COD_VER = '010' 47 | arq._registro_abertura.COD_FIN = '0' 48 | arq._registro_abertura.DT_INI = '01102016' 49 | arq._registro_abertura.DT_FIN = '30102016' 50 | arq._registro_abertura.NOME = 'KMEE INFORMATICA LTDA' 51 | arq._registro_abertura.CNPJ = '53.939.351/0001-29' 52 | arq._registro_abertura.CPF = '333.333.333-33' 53 | arq._registro_abertura.UF = 'SP' 54 | arq._registro_abertura.IE = '222.222.222.222' 55 | arq._registro_abertura.COD_MUN = '1234567' 56 | arq._registro_abertura.IM = '5999' 57 | arq._registro_abertura.SUFRAMA = '0123' 58 | arq._registro_abertura.IND_PERFIL = 'A' 59 | arq._registro_abertura.IND_ATIV = '1' 60 | 61 | contabilista = Registro0100() 62 | contabilista.NOME = 'Daniel Sadamo' 63 | contabilista.CPF = '12334532212' 64 | contabilista.CRC = '532212' 65 | contabilista.END = 'Rua dos ferroviario' 66 | contabilista.NUM = '123' 67 | contabilista.COMPL = 'Agonia' 68 | 69 | arq._blocos['0'].add(contabilista) 70 | self.assertEqual(txt, arq.getstring()) 71 | 72 | if __name__ == '__main__': 73 | unittest.main() 74 | --------------------------------------------------------------------------------