validate-docbr/validate_docbr/CNPJ.py at main · alvarofpp/validate-docbr · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
import string
from random import sample

from validate_docbr.DocumentBase import DocumentBase


class CNPJ(DocumentBase):
    """Classe referente ao Cadastro Nacional da Pessoa Jurídica (CNPJ).

    Aceita tanto o formato numérico tradicional quanto o novo formato
    alfanumérico. A validação reconhece ambos os formatos automaticamente.
    """

    def __init__(self) -> None:
        self.digits = list(range(10))
        self.digits_and_letters = list(string.ascii_uppercase) + list(string.digits)
        self.weights_first = list(range(5, 1, -1)) + list(range(9, 1, -1))
        self.weights_second = list(range(6, 1, -1)) + list(range(9, 1, -1))

    def validate(self, doc: str = '') -> bool:
        """Valida o CNPJ.

        Aceita tanto o formato numérico (``XX.XXX.XXX/XXXX-XX``) quanto o
        formato alfanumérico (``XX.XXX.XXX/XXXX-XX`` com letras).

        Args:
            doc: CNPJ a ser validado. Aceita com ou sem máscara.

        Returns:
            True se o CNPJ for válido, False caso contrário.
        """
        if not self._validate_input(doc, ['.', '/', '-'], allow_letters=True):
            return False

        doc = doc.strip().upper()
        doc = self._only_digits_and_letters(doc)

        if len(doc) != 14:
            return False

        if self._is_repeated_characters(doc):
            return False

        return self._generate_first_digit(doc) == doc[12] \
               and self._generate_second_digit(doc) == doc[13]

    def generate(self, mask: bool = False, digits_only: bool = True) -> str:
        """Gera um CNPJ válido.

        Args:
            mask: Se True, retorna o CNPJ formatado
                (ex: ``12.345.678/0001-00``).
            digits_only: Se True, gera apenas com dígitos numéricos.
                Se False, gera no formato alfanumérico.

        Returns:
            CNPJ gerado em formato string.
        """
        if digits_only:
            cnpj = [str(sample(self.digits, 1)[0]) for _ in range(12)]
        else:
            cnpj = [sample(self.digits_and_letters, 1)[0] for _ in range(12)]

        cnpj.append(self._generate_first_digit(cnpj))
        cnpj.append(self._generate_second_digit(cnpj))

        cnpj = "".join(cnpj)

        return self.mask(cnpj) if mask else cnpj

    def mask(self, doc: str = '') -> str:
        """Coloca a máscara de CNPJ no documento.

        Args:
            doc: CNPJ com ou sem máscara.

        Returns:
            CNPJ formatado no padrão ``XX.XXX.XXX/XXXX-XX``.
        """
        doc = self._only_digits_and_letters(doc.strip().upper())
        return f"{doc[:2]}.{doc[2:5]}.{doc[5:8]}/{doc[8:12]}-{doc[-2:]}"

    def _generate_first_digit(self, doc: str | list[str]) -> str:
        """Gera o primeiro dígito verificador do CNPJ.

        Utiliza aritmética baseada em valores ASCII para suportar
        caracteres alfanuméricos.

        Args:
            doc: String ou lista com os caracteres do CNPJ.

        Returns:
            Primeiro dígito verificador.
        """
        total = sum(
            (ord(str(doc[position])) - 48) * self.weights_first[position]
            for position in range(12)
        )

        remainder = total % 11
        return str(0 if remainder < 2 else 11 - remainder)

    def _generate_second_digit(self, doc: str | list[str]) -> str:
        """Gera o segundo dígito verificador do CNPJ.

        Utiliza aritmética baseada em valores ASCII para suportar
        caracteres alfanuméricos.

        Args:
            doc: String ou lista com os caracteres do CNPJ.

        Returns:
            Segundo dígito verificador.
        """
        total = sum(
            (ord(str(doc[position])) - 48) * self.weights_second[position]
            for position in range(13)
        )

        remainder = total % 11
        return str(0 if remainder < 2 else 11 - remainder)

    def _is_repeated_characters(self, doc: str) -> bool:
        """Verifica se o CNPJ contém apenas caracteres repetidos.

        Exemplo: ``00000000000000``.

        Args:
            doc: String com os caracteres do CNPJ.

        Returns:
            True se todos os caracteres forem iguais.
        """
        return len(set(doc)) == 1