catalogmx 0.3.0__py3-none-any.whl

catalogmx/catalogs/sat/carta_porte/carreteras.py

@@ -0,0 +1,59 @@
+"""Catálogo c_Carreteras - Carreteras Federales"""
+
+import json
+from pathlib import Path
+
+from catalogmx.utils.text import normalize_text
+
+
+class CarreterasCatalog:
+    _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"
+                / "carta_porte_3"
+                / "carreteras.json"
+            )
+            with open(path, encoding="utf-8") as f:
+                cls._data = json.load(f)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_carretera(cls, code: str) -> dict | None:
+        """Obtiene carretera 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 carretera es válido"""
+        return cls.get_carretera(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todas las carreteras"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_by_type(cls, tipo: str) -> list[dict]:
+        """Obtiene carreteras por tipo (Cuota, Libre)"""
+        cls._load_data()
+        return [c for c in cls._data if c["type"] == tipo]
+
+    @classmethod
+    def search_by_name(cls, name: str) -> list[dict]:
+        """Busca carreteras por nombre (insensible a acentos)"""
+        cls._load_data()
+        name_normalized = normalize_text(name)
+        return [
+            c
+            for c in cls._data
+            if name_normalized in normalize_text(c.get("nombre", c.get("name", "")))
+        ]

catalogmx/catalogs/sat/carta_porte/config_autotransporte.py

@@ -0,0 +1,54 @@
+"""Catálogo c_ConfigAutotransporte - Configuraciones Vehiculares"""
+
+import json
+from pathlib import Path
+
+
+class ConfigAutotransporteCatalog:
+    _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"
+                / "carta_porte_3"
+                / "config_autotransporte.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("configuraciones", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_config(cls, code: str) -> dict | None:
+        """Obtiene configuración 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 configuración es válido"""
+        return cls.get_config(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todas las configuraciones"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_by_type(cls, tipo: str) -> list[dict]:
+        """Obtiene configuraciones por tipo (Unitario, Articulado)"""
+        cls._load_data()
+        return [c for c in cls._data if c["type"] == tipo]
+
+    @classmethod
+    def get_axes_count(cls, code: str) -> int | None:
+        """Obtiene el número de ejes de una configuración"""
+        config = cls.get_config(code)
+        return config.get("axes") if config else None

catalogmx/catalogs/sat/carta_porte/material_peligroso.py

@@ -0,0 +1,66 @@
+"""Catálogo c_MaterialPeligroso - Materiales Peligrosos ONU"""
+
+import json
+from pathlib import Path
+
+
+class MaterialPeligrosoCatalog:
+    _data: list[dict] | None = None
+    _by_un_number: 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"
+                / "carta_porte_3"
+                / "material_peligroso.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("materiales", data)
+            # JSON has "code" field, map it as un_number
+            cls._by_un_number = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_material(cls, un_number: str) -> dict | None:
+        """Obtiene material peligroso por número ONU"""
+        cls._load_data()
+        return cls._by_un_number.get(un_number)
+
+    @classmethod
+    def is_valid(cls, un_number: str) -> bool:
+        """Verifica si un número ONU es válido"""
+        return cls.get_material(un_number) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los materiales peligrosos"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_by_class(cls, hazard_class: str) -> list[dict]:
+        """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)]
+
+    @classmethod
+    def get_by_packing_group(cls, packing_group: str) -> list[dict]:
+        """Obtiene materiales por grupo de embalaje (I, II, III)"""
+        cls._load_data()
+        return [
+            m for m in cls._data if m.get("packing_group") and packing_group in m["packing_group"]
+        ]
+
+    @classmethod
+    def requires_special_handling(cls, un_number: str) -> bool:
+        """Verifica si requiere manejo especial (grupos I y II)"""
+        material = cls.get_material(un_number)
+        if not material or not material.get("packing_group"):
+            return False
+        return "I" in material["packing_group"] or "II" in material["packing_group"]

catalogmx/catalogs/sat/carta_porte/puertos_maritimos.py

@@ -0,0 +1,63 @@
+"""Catálogo c_NumAutorizacionNaviero - Puertos Marítimos"""
+
+import json
+from pathlib import Path
+
+from catalogmx.utils.text import normalize_text
+
+
+class PuertosMaritimos:
+    _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"
+                / "carta_porte_3"
+                / "puertos_maritimos.json"
+            )
+            with open(path, encoding="utf-8") as f:
+                cls._data = json.load(f)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_puerto(cls, code: str) -> dict | None:
+        """Obtiene puerto 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 puerto es válido"""
+        return cls.get_puerto(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los puertos"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_by_coast(cls, coast: str) -> list[dict]:
+        """Obtiene puertos por costa (insensible a acentos)"""
+        cls._load_data()
+        coast_normalized = normalize_text(coast)
+        return [p for p in cls._data if normalize_text(p["coast"]) == coast_normalized]
+
+    @classmethod
+    def get_by_state(cls, state: str) -> list[dict]:
+        """Obtiene puertos por estado (insensible a acentos)"""
+        cls._load_data()
+        state_normalized = normalize_text(state)
+        return [p for p in cls._data if normalize_text(p["state"]) == state_normalized]
+
+    @classmethod
+    def search_by_name(cls, name: str) -> list[dict]:
+        """Busca puertos por nombre (insensible a acentos)"""
+        cls._load_data()
+        name_normalized = normalize_text(name)
+        return [p for p in cls._data if name_normalized in normalize_text(p["name"])]

catalogmx/catalogs/sat/carta_porte/tipo_embalaje.py

@@ -0,0 +1,48 @@
+"""Catálogo c_TipoEmbalaje - Tipos de Embalaje"""
+
+import json
+from pathlib import Path
+
+
+class TipoEmbalajeCatalog:
+    _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"
+                / "carta_porte_3"
+                / "tipo_embalaje.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("embalajes", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_embalaje(cls, code: str) -> dict | None:
+        """Obtiene embalaje 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 embalaje es válido"""
+        return cls.get_embalaje(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los embalajes"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_by_material(cls, material: str) -> list[dict]:
+        """Obtiene embalajes por material (Acero, Plástico, Madera, etc.)"""
+        cls._load_data()
+        return [e for e in cls._data if e["material"] == material]

catalogmx/catalogs/sat/carta_porte/tipo_permiso.py

@@ -0,0 +1,54 @@
+"""Catálogo c_TipoPermiso - Tipos de Permiso"""
+
+import json
+from pathlib import Path
+
+
+class TipoPermisoCatalog:
+    _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"
+                / "carta_porte_3"
+                / "tipo_permiso.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("permisos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_permiso(cls, code: str) -> dict | None:
+        """Obtiene permiso 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 permiso es válido"""
+        return cls.get_permiso(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los permisos"""
+        cls._load_data()
+        return cls._data.copy()
+
+    @classmethod
+    def get_by_type(cls, tipo: str) -> list[dict]:
+        """Obtiene permisos por tipo (Carga, Pasajeros)"""
+        cls._load_data()
+        return [p for p in cls._data if p["type"] == tipo]
+
+    @classmethod
+    def is_carga_permit(cls, code: str) -> bool:
+        """Verifica si es un permiso de carga"""
+        permiso = cls.get_permiso(code)
+        return permiso.get("type") == "Carga" if permiso else False

catalogmx/catalogs/sat/cfdi_4/__init__.py

@@ -0,0 +1,42 @@
+"""
+Catálogos del SAT para CFDI 4.0
+
+Catálogos incluidos:
+- c_RegimenFiscal: Regímenes fiscales
+- c_UsoCFDI: Usos del CFDI
+- c_FormaPago: Formas de pago
+- c_MetodoPago: Método de pago
+- c_TipoComprobante: Tipos de comprobante
+- c_Impuesto: Impuestos
+- c_Exportacion: Claves de exportación
+- c_TipoRelacion: Tipos de relación entre CFDI
+- c_ObjetoImp: Objeto de impuesto
+- c_ClaveUnidad: Claves de unidad de medida (~2,400 unidades)
+- c_ClaveProdServ: Claves de productos y servicios (~52,000 códigos - SQLite)
+"""
+
+from .clave_prod_serv import ClaveProdServCatalog
+from .clave_unidad import ClaveUnidadCatalog
+from .exportacion import ExportacionCatalog
+from .forma_pago import FormaPagoCatalog
+from .impuesto import ImpuestoCatalog
+from .metodo_pago import MetodoPagoCatalog
+from .objeto_imp import ObjetoImpCatalog
+from .regimen_fiscal import RegimenFiscalCatalog
+from .tipo_comprobante import TipoComprobanteCatalog
+from .tipo_relacion import TipoRelacionCatalog
+from .uso_cfdi import UsoCFDICatalog
+
+__all__ = [
+    "RegimenFiscalCatalog",
+    "UsoCFDICatalog",
+    "FormaPagoCatalog",
+    "MetodoPagoCatalog",
+    "TipoComprobanteCatalog",
+    "ImpuestoCatalog",
+    "ExportacionCatalog",
+    "TipoRelacionCatalog",
+    "ObjetoImpCatalog",
+    "ClaveUnidadCatalog",
+    "ClaveProdServCatalog",
+]