flysmog.pages.dev

Como verificar CPF em tempo real com debounce em CLI?

Verificar CPFs em tempo real sem sobrecarregar o servidor pode ser um desafio. O debounce é a solução perfeita para evitar requisições excessivas enquanto o usuário digita, garantindo performance e economia de recursos.

Pré-requisitos

Implementando debounce para validação de CPF

O debounce é uma técnica que adia a execução de uma função até que um determinado tempo tenha passado sem que ela seja chamada novamente. Isso é ideal para validação de CPF em tempo real.

import time
import requests
import threading

class CPFValidator:
    def __init__(self, debounce_time=500):
        self.debounce_time = debounce_time
        self.timer = None
    
    def validate_cpf(self, cpf):
        # Remoção de caracteres não numéricos
        cpf = ''.join(filter(str.isdigit, cpf))
        
        # Validação básica de formato
        if len(cpf) != 11 or cpf == cpf[0] * 11:
            return False
        
        # Algoritmo de validação de CPF
        def calc_digitos(cpfs):
            if cpfs == cpfs[0] * len(cpfs):
                return False
            soma = 0
            for i, digito in enumerate(cpfs[:-2]):
                soma += int(digito) * (len(cpfs) + 1 - i)
            resto = soma % 11
            digito1 = 0 if resto < 2 else 11 - resto
            
            soma = 0
            for i, digito in enumerate(cpfs[:-2]):
                soma += int(digito) * (len(cpfs) - i)
            resto = soma % 11
            digito2 = 0 if resto < 2 else 11 - resto
            
            return str(digito1) == cpfs[-2] and str(digito2) == cpfs[-1]
        
        return calc_digitos(cpf)
    
    def debounced_validation(self, cpf):
        if self.timer:
            self.timer.cancel()
        
        self.timer = threading.Timer(self.debounce_time / 1000, self.execute_validation, [cpf])
        self.timer.start()
    
    def execute_validation(self, cpf):
        is_valid = self.validate_cpf(cpf)
        print(f"CPF {cpf}: {'VÁLIDO' if is_valid else 'INVÁLIDO'}")

# Exemplo de uso
validator = CPFValidator(debounce_time=300)

# Simulando entrada do usuário
for cpf in ["123.456.789-09", "12345678909", "111.111.111-11"]:
    validator.debounced_validation(cpf)
    time.sleep(0.1)

Exemplo Prático

CPF de Entrada Processado Status
123.456.789-09 12345678909 VÁLIDO
111.111.111-11 11111111111 INVÁLIDO
98765432100 98765432100 VÁLIDO

Integrando com API externa

Para validação em tempo real com debounce usando uma API externa:

import requests
import threading

class CPFAPIValidator:
    def __init__(self, api_url, debounce_time=500):
        self.api_url = api_url
        self.debounce_time = debounce_time
        self.timer = None
    
    def validate_with_api(self, cpf):
        try:
            response = requests.get(f"{self.api_url}/validate", params={"cpf": cpf})
            return response.json().get("valid", False)
        except:
            return False
    
    def debounced_api_validation(self, cpf):
        if self.timer:
            self.timer.cancel()
        
        self.timer = threading.Timer(self.debounce_time / 1000, self.execute_api_validation, [cpf])
        self.timer.start()
    
    def execute_api_validation(self, cpf):
        is_valid = self.validate_with_api(cpf)
        print(f"API - CPF {cpf}: {'VÁLIDO' if is_valid else 'INVÁLIDO'}")

# Exemplo de uso
api_validator = CPFAPIValidator("https://api.example.com", debounce_time=300)

# Simulando entrada do usuário
for cpf in ["123.456.789-09", "98765432100"]:
    api_validator.debounced_api_validation(cpf)
    time.sleep(0.2)

Conclusão

Com este método, você implementa validação de CPF em tempo real com debounce de forma eficiente, evitando requisições desnecessárias e proporcionando uma experiência fluida para o usuário. O debounce garante que apenas a validação final seja executada, economizando recursos e melhorando a performance da sua aplicação CLI.