"Updated version number to 0.2.24, removed RutValidador class, and refactored Rut class to validate format and digit verifier internally."

Author: cortega26

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rutificador"
-version = "0.2.23"
+version = "0.2.24"
 description = "Esta librería proporciona una implementación en Python para validar y formatear el Rol Único Tributario (RUT) utilizado en Chile."
 authors = ["Carlos Ortega González <[email protected]>"]
 license = "MIT"

rutificador/__init__.py

@@ -8,15 +8,14 @@
     Rut: Representa un RUT chileno, con métodos para validación y formateo.
     RutDigitoVerificador: Calcula y representa el dígito verificador de un RUT chileno.
     RutInvalidoError: Excepción personalizada para errores de RUT inválido.
-    RutValidador: Valida un RUT chileno.
 """
 
 from typing import List
 
-__version__ = "0.2.23"
+__version__ = "0.2.24"
 __author__ = "Carlos Ortega González"
 __license__ = "MIT"
 
-from .main import Rut, RutDigitoVerificador, RutInvalidoError, RutValidador
+from .main import Rut, RutDigitoVerificador, RutInvalidoError
 
-__all__: List[str] = ["Rut", "RutDigitoVerificador", "RutInvalidoError", "RutValidador"]
+__all__: List[str] = ["Rut", "RutDigitoVerificador", "RutInvalidoError"]

rutificador/main.py

@@ -1,8 +1,7 @@
 # pylint: disable=missing-module-docstring
 
 import re
-from typing import List, Tuple, Dict, Union
-from collections import deque
+from typing import List, Dict, Tuple, Union
 
 FACTORES_DIGITO_VERIFICADOR: List[int] = [2, 3, 4, 5, 6, 7]
 MODULO_DIGITO_VERIFICADOR: int = 11
@@ -18,9 +17,9 @@ class RutBase:
 
     def __init__(self, base: str):
         self.rut_original: str = base
-        self.base: str = self._validar_y_normalizar_base(base)
+        self.base: str = self.validar_y_normalizar_base(base)
 
-    def _validar_y_normalizar_base(self, base: str) -> str:
+    def validar_y_normalizar_base(self, base: str) -> str:
         """
         Valida y normaliza el número base.
 
@@ -53,20 +52,19 @@ class RutDigitoVerificador(RutBase):
 
     def __init__(self, base: str):
         super().__init__(base)
-        self.digito_verificador: str = self._calcular_digito_verificador()
+        self.digito_verificador: str = self.calcular_digito_verificador()
 
-    def _calcular_digito_verificador(self) -> str:
+    def calcular_digito_verificador(self) -> str:
         """
         Calcula el dígito verificador del RUT.
 
         Returns:
             str: El dígito verificador del RUT.
         """
-        factores = deque(FACTORES_DIGITO_VERIFICADOR)
         suma_parcial: int = sum(
-            int(digito) * factores[0] for digito in reversed(str(self.base))
+            int(digito) * FACTORES_DIGITO_VERIFICADOR[i % 6]
+            for i, digito in enumerate(reversed(str(self.base)))
         )
-        factores.rotate(-1)
         digito_verificador: int = (
             MODULO_DIGITO_VERIFICADOR - suma_parcial % MODULO_DIGITO_VERIFICADOR
         ) % MODULO_DIGITO_VERIFICADOR
@@ -76,24 +74,6 @@ def __str__(self) -> str:
         return self.digito_verificador
 
 
-class RutValidador:
-    """Valida un RUT chileno."""
-
-    @staticmethod
-    def validar_formato(rut: str) -> Tuple[bool, str]:
-        """Valida el formato del RUT."""
-        match = re.fullmatch(RUT_REGEX, rut)
-        if not match:
-            return False, f"El formato del RUT '{rut}' es inválido."
-        return True, match.group(1)
-
-    @staticmethod
-    def validar_digito_verificador(base: str, digito: str) -> bool:
-        """Valida el dígito verificador del RUT."""
-        digito_calculado = RutDigitoVerificador(base).digito_verificador
-        return digito.lower() == digito_calculado
-
-
 class Rut:
     """
     Representa un RUT chileno.
@@ -108,26 +88,37 @@ class Rut:
         formatear_lista_ruts: Formatea una lista de RUTs según las opciones especificadas.
     """
 
+    PATRON_RUT = re.compile(RUT_REGEX)
+
     def __init__(self, rut: str):
         self.rut_string: str = str(rut).strip()
-        self._validar_rut()
+        self._validar_formato_rut()
+        self._validar_digito_verificador()
         self.base = RutBase(self.base_string)
         self.digito_verificador = RutDigitoVerificador(self.base_string)
 
-    def _validar_rut(self) -> None:
-        """Valida el formato y el dígito verificador del RUT."""
-        es_valido, resultado = RutValidador.validar_formato(self.rut_string)
-        if not es_valido:
-            raise RutInvalidoError(resultado)
-        
-        self.base_string = resultado
-        match = re.fullmatch(RUT_REGEX, self.rut_string)
+    def _validar_formato_rut(self) -> None:
+        match = Rut.PATRON_RUT.fullmatch(self.rut_string)
+        if not match:
+            raise RutInvalidoError(
+                f"El formato del RUT '{self.rut_string}' es inválido."
+            )
+        self.base_string: str = match.group(1)
+
+    def _validar_digito_verificador(self) -> None:
+        match = Rut.PATRON_RUT.fullmatch(self.rut_string)
         digito_verificador_input = match.group(3).lower() if match.group(3) else None
-        
-        if digito_verificador_input and not RutValidador.validar_digito_verificador(self.base_string, digito_verificador_input):
+        digito_verificador_calculado = RutDigitoVerificador(
+            self.base_string
+        ).digito_verificador
+
+        if (
+            digito_verificador_input
+            and digito_verificador_input != digito_verificador_calculado
+        ):
             raise RutInvalidoError(
                 f"El dígito verificador '{digito_verificador_input}' no coincide con "
-                f"el dígito verificador calculado '{self.digito_verificador}'."
+                f"el dígito verificador calculado '{digito_verificador_calculado}'."
             )
 
     def __str__(self) -> str:
@@ -152,7 +143,10 @@ def formatear(self, separador_miles: bool = False, mayusculas: bool = False) ->
                 + rut.split("-")[1]
             )
 
-        return rut.upper() if mayusculas else rut
+        if mayusculas:
+            rut = rut.upper()
+
+        return rut
 
     @staticmethod
     def _agregar_separador_miles(numero: str) -> str:
@@ -172,22 +166,28 @@ def _validar_lista_ruts(ruts: List[str]) -> Dict[str, List[Union[str, Tuple[str,
 
     @staticmethod
     def _formatear_csv(ruts_formateados: List[str]) -> str:
-        return f"rut\n{chr(10).join(ruts_formateados)}"
+        cadena_ruts: str = "\n".join(ruts_formateados)
+        return f"rut\n{cadena_ruts}"
 
     @staticmethod
     def _formatear_xml(ruts_formateados: List[str]) -> str:
-        return "\n".join(["<root>"] + [f"    <rut>{rut}</rut>" for rut in ruts_formateados] + ["</root>"])
+        xml_lines: List[str] = ["<root>"]
+        for rut in ruts_formateados:
+            xml_lines.append(f"    <rut>{rut}</rut>")
+        xml_lines.append("</root>")
+        return "\n".join(xml_lines)
 
     @staticmethod
     def _formatear_json(ruts_formateados: List[str]) -> str:
-        return str([{"rut": rut} for rut in ruts_formateados])
+        ruts_json: List[Dict[str, str]] = [{"rut": rut} for rut in ruts_formateados]
+        return str(ruts_json)
 
     @staticmethod
     def formatear_lista_ruts(
         ruts: List[str],
         separador_miles: bool = False,
         mayusculas: bool = False,
-        formato: Union[str, None] = None,
+        formato=None,
     ) -> str:
         """
         Formatea una lista de RUTs según las opciones especificadas.
@@ -207,23 +207,25 @@ def formatear_lista_ruts(
             "xml": Rut._formatear_xml,
             "json": Rut._formatear_json,
         }
-        ruts_validos_invalidos: Dict[str, List[Union[str, Tuple[str, str]]]] = Rut._validar_lista_ruts(ruts)
+        ruts_validos_invalidos: Dict[str, List[str]] = Rut._validar_lista_ruts(ruts)
         ruts_validos: List[str] = ruts_validos_invalidos["validos"]
         ruts_invalidos: List[Tuple[str, str]] = ruts_validos_invalidos["invalidos"]
 
-        resultado: List[str] = []
+        resultado: str = ""
         if ruts_validos:
             ruts_validos_formateados: List[str] = [
                 Rut(rut).formatear(separador_miles, mayusculas) for rut in ruts_validos
             ]
-            resultado.append("RUTs válidos:")
-            if formato in formato_salida:
-                resultado.append(formato_salida[formato](ruts_validos_formateados))
+            resultado += "RUTs válidos:\n"
+            if formato in ("csv", "xml", "json"):
+                resultado += formato_salida[formato](ruts_validos_formateados)
             else:
-                resultado.extend(ruts_validos_formateados)
+                resultado += "\n".join(ruts_validos_formateados)
+            resultado += "\n\n"
 
         if ruts_invalidos:
-            resultado.append("\nRUTs inválidos:")
-            resultado.extend(f"{rut} - {error}" for rut, error in ruts_invalidos)
+            resultado += "RUTs inválidos:\n"
+            for rut, error in ruts_invalidos:
+                resultado += f"{rut} - {error}\n"
 
-        return "\n".join(resultado)
+        return resultado