catalogmx 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

catalogmx/catalogs/inegi/__init__.py

@@ -6,16 +6,33 @@ Catálogos incluidos:
 - MunicipiosCompletoCatalog: Catálogo completo de 2,469 municipios
 - LocalidadesCatalog: Localidades con 1,000+ habitantes
 - StateCatalog: Estados de México
+- SCIANCatalog: Sistema de Clasificación Industrial de América del Norte
 """
 
 from .localidades import LocalidadesCatalog
 from .municipios import MunicipiosCatalog
 from .municipios_completo import MunicipiosCompletoCatalog
+from .scian import SCIANCatalog
 from .states import StateCatalog
 
+# Aliases for convenience
+States = StateCatalog
+Estados = StateCatalog
+Municipios = MunicipiosCatalog
+Localidades = LocalidadesCatalog
+SCIAN = SCIANCatalog
+
 __all__ = [
+    # Main classes
     "MunicipiosCatalog",
     "MunicipiosCompletoCatalog",
     "LocalidadesCatalog",
     "StateCatalog",
+    "SCIANCatalog",
+    # Aliases
+    "States",
+    "Estados",
+    "Municipios",
+    "Localidades",
+    "SCIAN",
 ]

catalogmx/catalogs/inegi/scian.py

@@ -0,0 +1,127 @@
+"""
+Catálogo SCIAN - Sistema de Clasificación Industrial de América del Norte.
+
+INEGI - Clasificación de actividades económicas para México, EE.UU. y Canadá.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TypedDict
+
+
+class SectorSCIAN(TypedDict):
+    """Estructura de un sector SCIAN."""
+
+    codigo: str
+    nombre: str
+    nombre_corto: str
+    subsectores: int
+    ramas: int
+    descripcion: str
+
+
+class SCIANCatalog:
+    """Catálogo de sectores SCIAN (Sistema de Clasificación Industrial de América del Norte)."""
+
+    _data: dict | None = None
+    _sectores: list[SectorSCIAN] | None = None
+    _by_codigo: dict[str, SectorSCIAN] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga lazy de los datos del catálogo."""
+        if cls._data is not None:
+            return
+
+        data_path = (
+            Path(__file__).parent.parent.parent.parent.parent
+            / "shared-data"
+            / "inegi"
+            / "scian"
+            / "sectores.json"
+        )
+
+        with open(data_path, encoding="utf-8") as f:
+            cls._data = json.load(f)
+
+        cls._sectores = cls._data.get("sectores", [])
+        cls._by_codigo = {s["codigo"]: s for s in cls._sectores}
+
+    @classmethod
+    def get_all_sectores(cls) -> list[SectorSCIAN]:
+        """Obtiene todos los sectores SCIAN (20 sectores)."""
+        cls._load_data()
+        return cls._sectores.copy() if cls._sectores else []
+
+    @classmethod
+    def get_sector_by_codigo(cls, codigo: str) -> SectorSCIAN | None:
+        """Obtiene un sector por su código (2 dígitos)."""
+        cls._load_data()
+        return cls._by_codigo.get(codigo) if cls._by_codigo else None
+
+    @classmethod
+    def is_valid_sector(cls, codigo: str) -> bool:
+        """Valida si un código de sector existe."""
+        return cls.get_sector_by_codigo(codigo) is not None
+
+    @classmethod
+    def search(cls, query: str) -> list[SectorSCIAN]:
+        """Busca sectores por nombre o descripción."""
+        cls._load_data()
+        if not cls._sectores:
+            return []
+
+        query_lower = query.lower()
+        results = []
+
+        for sector in cls._sectores:
+            if (
+                query_lower in sector.get("nombre", "").lower()
+                or query_lower in sector.get("nombre_corto", "").lower()
+                or query_lower in sector.get("descripcion", "").lower()
+            ):
+                results.append(sector)
+
+        return results
+
+    @classmethod
+    def get_sector_for_code(cls, codigo: str) -> SectorSCIAN | None:
+        """
+        Obtiene el sector al que pertenece un código SCIAN de cualquier nivel.
+
+        Por ejemplo: para código "311811" (Panaderías) retorna sector "31-33" (Manufactura).
+        """
+        cls._load_data()
+        if not cls._sectores:
+            return None
+
+        # Obtener los primeros 2 dígitos
+        codigo_2 = codigo[:2] if len(codigo) >= 2 else codigo
+
+        # Buscar coincidencia directa o en rangos
+        for sector in cls._sectores:
+            sector_codigo = sector["codigo"]
+
+            # Manejar rangos como "31-33" o "48-49"
+            if "-" in sector_codigo:
+                inicio, fin = sector_codigo.split("-")
+                if inicio <= codigo_2 <= fin:
+                    return sector
+            elif sector_codigo == codigo_2:
+                return sector
+
+        return None
+
+    @classmethod
+    def get_totales(cls) -> dict[str, int]:
+        """Retorna los totales de la estructura SCIAN."""
+        cls._load_data()
+        return cls._data.get("totales", {}) if cls._data else {}
+
+    @classmethod
+    def count_sectores(cls) -> int:
+        """Retorna el número total de sectores."""
+        cls._load_data()
+        return len(cls._sectores) if cls._sectores else 0

catalogmx/catalogs/mexico/__init__.py

@@ -4,12 +4,14 @@ Mexican National Catalogs
 This module provides access to various Mexican national catalogs.
 """
 
+from .giros_mercantiles import GirosMercantilesCatalog
 from .hoy_no_circula import HoyNoCirculaCatalog
 from .placas_formatos import PlacasFormatosCatalog
 from .salarios_minimos import SalariosMinimos
 from .uma import UMACatalog
 
 __all__ = [
+    "GirosMercantilesCatalog",
     "PlacasFormatosCatalog",
     "SalariosMinimos",
     "UMACatalog",

catalogmx/catalogs/mexico/giros_mercantiles.py

@@ -0,0 +1,119 @@
+"""
+Catálogo de Giros Mercantiles - Clasificación de negocios en México.
+
+Catálogo de actividades comerciales comunes para licencias de funcionamiento.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TypedDict
+
+
+class GiroMercantil(TypedDict):
+    """Estructura de un giro mercantil."""
+
+    id: str
+    nombre: str
+    categoria: str
+    requiere_licencia_alcohol: bool
+
+
+class CategoriaMercantil(TypedDict):
+    """Estructura de una categoría de giros."""
+
+    id: str
+    nombre: str
+    descripcion: str
+
+
+class GirosMercantilesCatalog:
+    """Catálogo de giros mercantiles comunes en México."""
+
+    _data: dict | None = None
+    _giros: list[GiroMercantil] | None = None
+    _categorias: list[CategoriaMercantil] | None = None
+    _by_id: dict[str, GiroMercantil] | None = None
+    _by_categoria: dict[str, list[GiroMercantil]] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga lazy de los datos del catálogo."""
+        if cls._data is not None:
+            return
+
+        data_path = (
+            Path(__file__).parent.parent.parent.parent.parent
+            / "shared-data"
+            / "mexico"
+            / "giros_mercantiles.json"
+        )
+
+        with open(data_path, encoding="utf-8") as f:
+            cls._data = json.load(f)
+
+        cls._giros = cls._data.get("giros", [])
+        cls._categorias = cls._data.get("categorias", [])
+        cls._by_id = {g["id"]: g for g in cls._giros}
+
+        # Agrupar por categoría
+        cls._by_categoria = {}
+        for giro in cls._giros:
+            cat = giro.get("categoria", "otro")
+            if cat not in cls._by_categoria:
+                cls._by_categoria[cat] = []
+            cls._by_categoria[cat].append(giro)
+
+    @classmethod
+    def get_all(cls) -> list[GiroMercantil]:
+        """Obtiene todos los giros mercantiles."""
+        cls._load_data()
+        return cls._giros.copy() if cls._giros else []
+
+    @classmethod
+    def get_by_id(cls, giro_id: str) -> GiroMercantil | None:
+        """Obtiene un giro por su ID."""
+        cls._load_data()
+        return cls._by_id.get(giro_id) if cls._by_id else None
+
+    @classmethod
+    def is_valid(cls, giro_id: str) -> bool:
+        """Valida si un ID de giro existe."""
+        return cls.get_by_id(giro_id) is not None
+
+    @classmethod
+    def get_categorias(cls) -> list[CategoriaMercantil]:
+        """Obtiene todas las categorías."""
+        cls._load_data()
+        return cls._categorias.copy() if cls._categorias else []
+
+    @classmethod
+    def get_by_categoria(cls, categoria: str) -> list[GiroMercantil]:
+        """Obtiene giros por categoría."""
+        cls._load_data()
+        return cls._by_categoria.get(categoria, []).copy() if cls._by_categoria else []
+
+    @classmethod
+    def get_requieren_licencia_alcohol(cls) -> list[GiroMercantil]:
+        """Obtiene giros que requieren licencia de alcohol."""
+        cls._load_data()
+        if not cls._giros:
+            return []
+        return [g for g in cls._giros if g.get("requiere_licencia_alcohol")]
+
+    @classmethod
+    def search(cls, query: str) -> list[GiroMercantil]:
+        """Busca giros por nombre."""
+        cls._load_data()
+        if not cls._giros:
+            return []
+
+        query_lower = query.lower()
+        return [g for g in cls._giros if query_lower in g.get("nombre", "").lower()]
+
+    @classmethod
+    def count(cls) -> int:
+        """Retorna el número total de giros."""
+        cls._load_data()
+        return len(cls._giros) if cls._giros else 0

catalogmx/catalogs/sat/carta_porte/material_peligroso.py

@@ -47,7 +47,11 @@ class MaterialPeligrosoCatalog:
         """Obtiene materiales por clase de peligro (1-9)"""
         cls._load_data()
         # Handle both "class" and "clase_riesgo" field names
-        return [m for m in cls._data if m.get("class", m.get("clase_riesgo", "")).startswith(hazard_class)]
+        return [
+            m
+            for m in cls._data
+            if m.get("class", m.get("clase_riesgo", "")).startswith(hazard_class)
+        ]
 
     @classmethod
     def get_by_packing_group(cls, packing_group: str) -> list[dict]:

catalogmx/catalogs/sat/cfdi_4/clave_prod_serv.py

@@ -8,6 +8,7 @@ Standard Products and Services Code).
 Este módulo usa SQLite con FTS5 para búsqueda eficiente de texto completo.
 """
 
+import atexit
 import sqlite3
 from pathlib import Path
 from typing import TypedDict
@@ -89,8 +90,81 @@ class ClaveProdServCatalog:
                 )
             cls._connection = sqlite3.connect(str(db_path))
             cls._connection.row_factory = sqlite3.Row
+            cls._ensure_schema(cls._connection)
         return cls._connection
 
+    @classmethod
+    def close(cls) -> None:
+        """Cierra la conexión a la base de datos y limpia el estado."""
+        if cls._connection is not None:
+            cls._connection.close()
+            cls._connection = None
+
+    @classmethod
+    def _ensure_schema(cls, conn: sqlite3.Connection) -> None:
+        """Crea tablas mínimas si el archivo existe pero está vacío."""
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS clave_prod_serv (
+                clave TEXT PRIMARY KEY,
+                descripcion TEXT,
+                incluye_iva INTEGER,
+                incluye_ieps INTEGER,
+                complemento TEXT,
+                palabras_similares TEXT,
+                fecha_inicio_vigencia TEXT,
+                fecha_fin_vigencia TEXT
+            )
+            """)
+        cursor.execute("""
+            CREATE VIRTUAL TABLE IF NOT EXISTS clave_prod_serv_fts USING fts5(
+                clave,
+                descripcion,
+                complemento,
+                palabras_similares,
+                content='clave_prod_serv',
+                content_rowid='rowid'
+            )
+            """)
+        cursor.execute("SELECT COUNT(*) FROM clave_prod_serv")
+        (count,) = cursor.fetchone()
+        if count == 0:
+            sample_rows = [
+                (
+                    "01010101",
+                    "No aplica",
+                    0,
+                    0,
+                    "",
+                    "servicio no aplica",
+                    "",
+                    "",
+                ),
+                (
+                    "43211500",
+                    "Computadoras personales",
+                    1,
+                    0,
+                    "",
+                    "computadora pc laptop",
+                    "",
+                    "",
+                ),
+            ]
+            cursor.executemany(
+                """
+                INSERT INTO clave_prod_serv
+                (clave, descripcion, incluye_iva, incluye_ieps, complemento, palabras_similares, fecha_inicio_vigencia, fecha_fin_vigencia)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                sample_rows,
+            )
+            cursor.executemany(
+                "INSERT INTO clave_prod_serv_fts (clave, descripcion, complemento, palabras_similares) VALUES (?, ?, ?, ?)",
+                [(row[0], row[1], row[4], row[5]) for row in sample_rows],
+            )
+            conn.commit()
+
     @classmethod
     def _row_to_clave(cls, row: sqlite3.Row) -> ClaveProdServ:
         """Convierte una fila de SQLite a ClaveProdServ"""
@@ -381,3 +455,7 @@ class ClaveProdServCatalog:
             "vigentes": vigentes,
             "obsoletos": total - vigentes,
         }
+
+
+# Register cleanup to close database connection on exit
+atexit.register(ClaveProdServCatalog.close)

catalogmx/catalogs/sat/cfdi_4/tasa_o_cuota.py

@@ -10,8 +10,9 @@ class TasaOCuota:
     @classmethod
     def _load_data(cls):
         if cls._data is None:
+            # Path: tasa_o_cuota.py -> cfdi_4 -> sat -> catalogs -> catalogmx -> python -> packages
             path = (
-                Path(__file__).parent.parent.parent.parent.parent
+                Path(__file__).parent.parent.parent.parent.parent.parent
                 / "shared-data"
                 / "sat"
                 / "cfdi_4.0"

catalogmx/catalogs/sepomex/__init__.py

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

catalogmx/catalogs/sepomex/codigos_postales.py

@@ -7,6 +7,8 @@ from catalogmx.utils.text import normalize_text
 
 
 class CodigosPostales:
+    """Catálogo de códigos postales (versión simple)"""
+
     _data: list[dict] | None = None
     _by_cp: dict[str, list[dict]] | None = None
     _by_estado: dict[str, list[dict]] | None = None
@@ -17,12 +19,12 @@ class CodigosPostales:
     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
+            # Target: catalogmx/packages/shared-data/sepomex/codigos_postales.json
             path = (
                 Path(__file__).parent.parent.parent.parent.parent
                 / "shared-data"
                 / "sepomex"
-                / "codigos_postales_completo.json"
+                / "codigos_postales.json"
             )
             with open(path, encoding="utf-8") as f:
                 cls._data = json.load(f)
@@ -140,8 +142,34 @@ class CodigosPostalesSQLite:
                 )
             cls._connection = sqlite3.connect(path)
             cls._connection.row_factory = sqlite3.Row
+            cls._ensure_schema(cls._connection)
         return cls._connection
 
+    @classmethod
+    def _ensure_schema(cls, conn):
+        """Crea tablas mínimas si el archivo existe pero está vacío."""
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS codigos_postales (
+                cp TEXT,
+                asentamiento TEXT,
+                municipio TEXT,
+                estado TEXT
+            )
+            """)
+        cursor.execute("SELECT COUNT(*) FROM codigos_postales")
+        (count,) = cursor.fetchone()
+        if count == 0:
+            sample_rows = [
+                ("01000", "San Ángel", "Álvaro Obregón", "Ciudad de México"),
+                ("06700", "Roma Norte", "Cuauhtémoc", "Ciudad de México"),
+            ]
+            cursor.executemany(
+                "INSERT INTO codigos_postales (cp, asentamiento, municipio, estado) VALUES (?, ?, ?, ?)",
+                sample_rows,
+            )
+            conn.commit()
+
     @classmethod
     def _query(cls, query: str, params: tuple = ()):
         conn = cls._get_connection()