catalogmx 0.3.0__py3-none-any.whl

catalogmx/catalogs/sat/nomina/tipo_regimen.py

@@ -0,0 +1,47 @@
+"""Catálogo c_TipoRegimen"""
+
+import json
+from pathlib import Path
+
+
+class TipoRegimenCatalog:
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "nomina_1.2"
+                / "tipo_regimen.json"
+            )
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+                # Handle both list and dict formats
+                cls._data = data if isinstance(data, list) else data.get("regimenes", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_regimen(cls, code: str) -> dict | None:
+        """Obtiene tipo de régimen por código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Verifica si un código de régimen es válido"""
+        return cls.get_regimen(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los tipos de régimen"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def is_asimilado(cls, code: str) -> bool:
+        """Verifica si es régimen asimilado a salarios"""
+        return code in ["05", "06", "07", "08", "09", "10", "11", "12", "13"]

catalogmx/catalogs/sepomex/__init__.py

@@ -0,0 +1,5 @@
+"""Catálogos SEPOMEX"""
+
+from .codigos_postales import CodigosPostales
+
+__all__ = ["CodigosPostales"]

catalogmx/catalogs/sepomex/codigos_postales.py

@@ -0,0 +1,184 @@
+"""Catálogo de Códigos Postales SEPOMEX"""
+
+import json
+from pathlib import Path
+
+from catalogmx.utils.text import normalize_text
+
+
+class CodigosPostales:
+    _data: list[dict] | None = None
+    _by_cp: dict[str, list[dict]] | None = None
+    _by_estado: dict[str, list[dict]] | None = None
+    _by_estado_normalized: dict[str, list[dict]] | None = None
+    _by_municipio_normalized: dict[str, list[dict]] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        if cls._data is None:
+            # Path: catalogmx/packages/python/catalogmx/catalogs/sepomex/codigos_postales.py
+            # Target: catalogmx/packages/shared-data/sepomex/codigos_postales_completo.json
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sepomex"
+                / "codigos_postales_completo.json"
+            )
+            with open(path, encoding="utf-8") as f:
+                cls._data = json.load(f)
+
+            # Index by CP (can have multiple settlements)
+            cls._by_cp = {}
+            for item in cls._data:
+                cp = item["cp"]
+                if cp not in cls._by_cp:
+                    cls._by_cp[cp] = []
+                cls._by_cp[cp].append(item)
+
+            # Index by estado
+            cls._by_estado = {}
+            for item in cls._data:
+                estado = item["estado"]
+                if estado not in cls._by_estado:
+                    cls._by_estado[estado] = []
+                cls._by_estado[estado].append(item)
+
+            # Index by estado normalized (accent-insensitive)
+            cls._by_estado_normalized = {}
+            for item in cls._data:
+                estado_norm = normalize_text(item["estado"])
+                if estado_norm not in cls._by_estado_normalized:
+                    cls._by_estado_normalized[estado_norm] = []
+                cls._by_estado_normalized[estado_norm].append(item)
+
+            # Index by municipio normalized (accent-insensitive)
+            cls._by_municipio_normalized = {}
+            for item in cls._data:
+                municipio_norm = normalize_text(item["municipio"])
+                if municipio_norm not in cls._by_municipio_normalized:
+                    cls._by_municipio_normalized[municipio_norm] = []
+                cls._by_municipio_normalized[municipio_norm].append(item)
+
+    @classmethod
+    def get_by_cp(cls, cp: str) -> list[dict]:
+        """Obtiene todos los asentamientos de un código postal"""
+        cls._load_data()
+        return cls._by_cp.get(cp, [])
+
+    @classmethod
+    def is_valid(cls, cp: str) -> bool:
+        """Verifica si un código postal existe"""
+        cls._load_data()
+        return cp in cls._by_cp
+
+    @classmethod
+    def get_by_estado(cls, estado: str) -> list[dict]:
+        """Obtiene todos los códigos postales de un estado (insensible a acentos)"""
+        cls._load_data()
+        estado_normalized = normalize_text(estado)
+        return cls._by_estado_normalized.get(estado_normalized, [])
+
+    @classmethod
+    def get_by_municipio(cls, municipio: str) -> list[dict]:
+        """Obtiene todos los códigos postales de un municipio (insensible a acentos)"""
+        cls._load_data()
+        municipio_normalized = normalize_text(municipio)
+        return cls._by_municipio_normalized.get(municipio_normalized, [])
+
+    @classmethod
+    def search_by_colonia(cls, colonia: str) -> list[dict]:
+        """Busca códigos postales por nombre de colonia (insensible a acentos)"""
+        cls._load_data()
+        colonia_normalized = normalize_text(colonia)
+        return [
+            item for item in cls._data if colonia_normalized in normalize_text(item["asentamiento"])
+        ]
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los códigos postales"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_municipio(cls, cp: str) -> str | None:
+        """Obtiene el municipio de un código postal"""
+        settlements = cls.get_by_cp(cp)
+        return settlements[0]["municipio"] if settlements else None
+
+    @classmethod
+    def get_estado(cls, cp: str) -> str | None:
+        """Obtiene el estado de un código postal"""
+        settlements = cls.get_by_cp(cp)
+        return settlements[0]["estado"] if settlements else None
+
+
+class CodigosPostalesSQLite:
+    _db_path = None
+    _connection = None
+
+    @classmethod
+    def _get_db_path(cls):
+        if cls._db_path is None:
+            cls._db_path = (
+                Path(__file__).parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sqlite"
+                / "sepomex.db"
+            )
+        return cls._db_path
+
+    @classmethod
+    def _get_connection(cls):
+        import sqlite3
+
+        if cls._connection is None:
+            path = cls._get_db_path()
+            if not path.exists():
+                raise FileNotFoundError(
+                    f"Database not found at {path}. Please run the migration script."
+                )
+            cls._connection = sqlite3.connect(path)
+            cls._connection.row_factory = sqlite3.Row
+        return cls._connection
+
+    @classmethod
+    def _query(cls, query: str, params: tuple = ()):
+        conn = cls._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(query, params)
+        rows = cursor.fetchall()
+        return [dict(row) for row in rows]
+
+    @classmethod
+    def get_by_cp(cls, cp: str) -> list[dict]:
+        """Obtiene todos los asentamientos de un código postal desde SQLite"""
+        return cls._query("SELECT * FROM codigos_postales WHERE cp = ?", (cp,))
+
+    @classmethod
+    def is_valid(cls, cp: str) -> bool:
+        """Verifica si un código postal existe en SQLite"""
+        result = cls._query("SELECT 1 FROM codigos_postales WHERE cp = ? LIMIT 1", (cp,))
+        return len(result) > 0
+
+    @classmethod
+    def get_by_estado(cls, estado: str) -> list[dict]:
+        """Obtiene todos los códigos postales de un estado desde SQLite"""
+        return cls._query("SELECT * FROM codigos_postales WHERE estado = ?", (estado,))
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los códigos postales desde SQLite"""
+        return cls._query("SELECT * FROM codigos_postales")
+
+    @classmethod
+    def get_municipio(cls, cp: str) -> str | None:
+        """Obtiene el municipio de un código postal desde SQLite"""
+        settlements = cls.get_by_cp(cp)
+        return settlements[0]["municipio"] if settlements else None
+
+    @classmethod
+    def get_estado(cls, cp: str) -> str | None:
+        """Obtiene el estado de un código postal desde SQLite"""
+        settlements = cls.get_by_cp(cp)
+        return settlements[0]["estado"] if settlements else None

catalogmx/cli.py

@@ -0,0 +1,185 @@
+"""
+Module that contains the command line app.
+
+Why does this file exist, and why not put this in __main__?
+
+  You might be tempted to import things from __main__ later, but that will cause
+  problems: the code will get executed twice:
+
+  - When you run `python -mrfcmx` python will execute
+    ``__main__.py`` as a script. That means there won't be any
+    ``rfcmx.__main__`` in ``sys.modules``.
+  - When you import __main__ it will get executed again (as a module) because
+    there's no ``rfcmx.__main__`` in ``sys.modules``.
+
+  Also see (1) from http://click.pocoo.org/5/setuptools/#setuptools-integration
+"""
+
+import datetime
+
+import click
+
+from catalogmx.validators.curp import CURPGenerator, CURPValidator
+from catalogmx.validators.rfc import RFCGenerator, RFCValidator
+
+
+@click.group()
+@click.version_option(version="0.2.0")
+def main():
+    """
+    Mexican RFC and CURP calculator and validator.
+
+    This tool helps you generate and validate:
+    - RFC (Registro Federal de Contribuyentes) for individuals and companies
+    - CURP (Clave Única de Registro de Población) for individuals
+    """
+    pass
+
+
+@main.group()
+def rfc():
+    """RFC (Registro Federal de Contribuyentes) commands"""
+    pass
+
+
+@main.group()
+def curp():
+    """CURP (Clave Única de Registro de Población) commands"""
+    pass
+
+
+@rfc.command("validate")
+@click.argument("rfc_code")
+def rfc_validate(rfc_code):
+    """Validate an RFC code"""
+    validator = RFCValidator(rfc_code)
+
+    if validator.validate():
+        click.echo(click.style(f"✓ RFC {rfc_code} is valid", fg="green"))
+        tipo = validator.detect_fisica_moral()
+        click.echo(f"  Type: {tipo}")
+
+        # Show validation details
+        validations = validator.validators()
+        click.echo("\n  Validation details:")
+        for name, result in validations.items():
+            status = "✓" if result else "✗"
+            color = "green" if result else "red"
+            click.echo(f"    {click.style(status, fg=color)} {name}")
+    else:
+        click.echo(click.style(f"✗ RFC {rfc_code} is invalid", fg="red"))
+
+
+@rfc.command("generate-fisica")
+@click.option("--nombre", "-n", required=True, help="First name(s)")
+@click.option("--paterno", "-p", required=True, help="First surname (apellido paterno)")
+@click.option("--materno", "-m", default="", help="Second surname (apellido materno)")
+@click.option("--fecha", "-f", required=True, help="Birth date (YYYY-MM-DD)")
+def rfc_generate_fisica(nombre, paterno, materno, fecha):
+    """Generate RFC for Persona Física (individual)"""
+    try:
+        # Parse date
+        fecha_obj = datetime.datetime.strptime(fecha, "%Y-%m-%d").date()
+
+        # Generate RFC
+        rfc_code = RFCGenerator.generate_fisica(
+            nombre=nombre, paterno=paterno, materno=materno, fecha=fecha_obj
+        )
+
+        click.echo(click.style(f"\nGenerated RFC: {rfc_code}", fg="green", bold=True))
+        click.echo(f"\nName: {nombre} {paterno} {materno}")
+        click.echo(f"Birth date: {fecha}")
+
+    except ValueError as e:
+        click.echo(click.style(f"Error: {str(e)}", fg="red"))
+    except Exception as e:
+        click.echo(click.style(f"Unexpected error: {str(e)}", fg="red"))
+
+
+@rfc.command("generate-moral")
+@click.option("--razon-social", "-r", required=True, help="Company name (razón social)")
+@click.option("--fecha", "-f", required=True, help="Incorporation date (YYYY-MM-DD)")
+def rfc_generate_moral(razon_social, fecha):
+    """Generate RFC for Persona Moral (company/legal entity)"""
+    try:
+        # Parse date
+        fecha_obj = datetime.datetime.strptime(fecha, "%Y-%m-%d").date()
+
+        # Generate RFC
+        rfc_code = RFCGenerator.generate_moral(razon_social=razon_social, fecha=fecha_obj)
+
+        click.echo(click.style(f"\nGenerated RFC: {rfc_code}", fg="green", bold=True))
+        click.echo(f"\nCompany: {razon_social}")
+        click.echo(f"Incorporation date: {fecha}")
+
+    except ValueError as e:
+        click.echo(click.style(f"Error: {str(e)}", fg="red"))
+    except Exception as e:
+        click.echo(click.style(f"Unexpected error: {str(e)}", fg="red"))
+
+
+@curp.command("validate")
+@click.argument("curp_code")
+def curp_validate(curp_code):
+    """Validate a CURP code"""
+    validator = CURPValidator(curp_code)
+
+    if validator.is_valid():
+        click.echo(click.style(f"✓ CURP {curp_code} is valid", fg="green"))
+    else:
+        click.echo(click.style(f"✗ CURP {curp_code} is invalid", fg="red"))
+
+
+@curp.command("generate")
+@click.option("--nombre", "-n", required=True, help="First name(s)")
+@click.option("--paterno", "-p", required=True, help="First surname (apellido paterno)")
+@click.option("--materno", "-m", default="", help="Second surname (apellido materno)")
+@click.option("--fecha", "-f", required=True, help="Birth date (YYYY-MM-DD)")
+@click.option(
+    "--sexo",
+    "-s",
+    required=True,
+    type=click.Choice(["H", "M"], case_sensitive=False),
+    help="Gender: H (Hombre/Male) or M (Mujer/Female)",
+)
+@click.option("--estado", "-e", required=True, help="Birth state (e.g., Jalisco, CDMX, etc.)")
+def curp_generate(nombre, paterno, materno, fecha, sexo, estado):
+    """Generate CURP for an individual"""
+    try:
+        # Parse date
+        fecha_obj = datetime.datetime.strptime(fecha, "%Y-%m-%d").date()
+
+        # Generate CURP
+        generator = CURPGenerator(
+            nombre=nombre,
+            paterno=paterno,
+            materno=materno,
+            fecha_nacimiento=fecha_obj,
+            sexo=sexo.upper(),
+            estado=estado,
+        )
+
+        curp_code = generator.curp
+
+        click.echo(click.style(f"\nGenerated CURP: {curp_code}", fg="green", bold=True))
+        click.echo(f"\nName: {nombre} {paterno} {materno}")
+        click.echo(f"Birth date: {fecha}")
+        click.echo(f"Gender: {sexo.upper()}")
+        click.echo(f"Birth state: {estado}")
+
+        # Show a note about homoclave
+        click.echo(
+            click.style(
+                '\nNote: The homoclave (last 2 characters) is a placeholder ("00").', fg="yellow"
+            )
+        )
+        click.echo(click.style("The official homoclave is assigned by RENAPO.", fg="yellow"))
+
+    except ValueError as e:
+        click.echo(click.style(f"Error: {str(e)}", fg="red"))
+    except Exception as e:
+        click.echo(click.style(f"Unexpected error: {str(e)}", fg="red"))
+
+
+if __name__ == "__main__":
+    main()