catalogmx 0.3.0__py3-none-any.whl

catalogmx/catalogs/sat/cfdi_4/exportacion.py

@@ -0,0 +1,45 @@
+"""Catálogo c_Exportacion"""
+
+import json
+from pathlib import Path
+
+
+class ExportacionCatalog:
+    """Catálogo de Exportaciones del SAT (c_Exportacion)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "exportacion.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("exportaciones", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_exportacion(cls, code: str) -> dict | None:
+        """Obtiene una exportación por su código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de exportación es válido"""
+        return cls.get_exportacion(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todas las exportaciones"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/forma_pago.py

@@ -0,0 +1,45 @@
+"""Catálogo c_FormaPago"""
+
+import json
+from pathlib import Path
+
+
+class FormaPagoCatalog:
+    """Catálogo de Formas de Pago del SAT (c_FormaPago)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "forma_pago.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("formas_pago", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_forma_pago(cls, code: str) -> dict | None:
+        """Obtiene una forma de pago por su código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de forma de pago es válido"""
+        return cls.get_forma_pago(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todas las formas de pago"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/impuesto.py

@@ -0,0 +1,57 @@
+"""Catálogo c_Impuesto"""
+
+import json
+from pathlib import Path
+
+
+class ImpuestoCatalog:
+    """Catálogo de Impuestos del SAT (c_Impuesto)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "impuesto.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("impuestos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_impuesto(cls, code: str) -> dict | None:
+        """Obtiene un impuesto por su código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de impuesto es válido"""
+        return cls.get_impuesto(code) is not None
+
+    @classmethod
+    def supports_retention(cls, code: str) -> bool:
+        """Valida si un impuesto soporta retención"""
+        impuesto = cls.get_impuesto(code)
+        return impuesto.get("retention", False) if impuesto else False
+
+    @classmethod
+    def supports_transfer(cls, code: str) -> bool:
+        """Valida si un impuesto soporta traslado"""
+        impuesto = cls.get_impuesto(code)
+        return impuesto.get("transfer", False) if impuesto else False
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los impuestos"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/meses.py

@@ -0,0 +1,34 @@
+"""Catálogo de Meses (SAT)"""
+
+import json
+
+from ....helpers import get_project_root
+
+
+class Meses:
+    _data = None
+
+    @classmethod
+    def _load_data(cls):
+        if cls._data is None:
+            root = get_project_root()
+            path = root / "packages" / "shared-data" / "sat" / "cfdi_4.0" / "c_Meses.json"
+            with open(path, encoding="utf-8") as f:
+                json_data = json.load(f)
+                cls._data = {item["valor"]: item for item in json_data["data"]}
+        return cls._data
+
+    @classmethod
+    def get_data(cls):
+        return cls._load_data()
+
+    @classmethod
+    def get_by_id(cls, mes_id):
+        """Busca un mes por su ID (e.g., '01', '02')."""
+        data = cls.get_data()
+        return data.get(mes_id)
+
+    @classmethod
+    def is_valid(cls, mes_id):
+        """Verifica si un ID de mes es válido."""
+        return mes_id in cls.get_data()

catalogmx/catalogs/sat/cfdi_4/metodo_pago.py

@@ -0,0 +1,45 @@
+"""Catálogo c_MetodoPago"""
+
+import json
+from pathlib import Path
+
+
+class MetodoPagoCatalog:
+    """Catálogo de Métodos de Pago del SAT (c_MetodoPago)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "metodo_pago.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("metodos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_metodo(cls, code: str) -> dict | None:
+        """Obtiene un método de pago por su código"""
+        cls._load_data()
+        return cls._by_code.get(code.upper())
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de método de pago es válido"""
+        return cls.get_metodo(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los métodos de pago"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/objeto_imp.py

@@ -0,0 +1,45 @@
+"""Catálogo c_ObjetoImp"""
+
+import json
+from pathlib import Path
+
+
+class ObjetoImpCatalog:
+    """Catálogo de Objetos Impuestos del SAT (c_ObjetoImp)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "objeto_imp.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("objetos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_objeto(cls, code: str) -> dict | None:
+        """Obtiene un objeto impuesto por su código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de objeto impuesto es válido"""
+        return cls.get_objeto(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los objetos impuestos"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/periodicidad.py

@@ -0,0 +1,34 @@
+"""Catálogo de Periodicidad (SAT)"""
+
+import json
+
+from ....helpers import get_project_root
+
+
+class Periodicidad:
+    _data = None
+
+    @classmethod
+    def _load_data(cls):
+        if cls._data is None:
+            root = get_project_root()
+            path = root / "packages" / "shared-data" / "sat" / "cfdi_4.0" / "c_Periodicidad.json"
+            with open(path, encoding="utf-8") as f:
+                json_data = json.load(f)
+                cls._data = {item["valor"]: item for item in json_data["data"]}
+        return cls._data
+
+    @classmethod
+    def get_data(cls):
+        return cls._load_data()
+
+    @classmethod
+    def get_by_id(cls, periodicidad_id):
+        """Busca una periodicidad por su ID."""
+        data = cls.get_data()
+        return data.get(periodicidad_id)
+
+    @classmethod
+    def is_valid(cls, periodicidad_id):
+        """Verifica si un ID de periodicidad es válido."""
+        return periodicidad_id in cls.get_data()

catalogmx/catalogs/sat/cfdi_4/regimen_fiscal.py

@@ -0,0 +1,57 @@
+"""Catálogo c_RegimenFiscal"""
+
+import json
+from pathlib import Path
+
+
+class RegimenFiscalCatalog:
+    """Catálogo de Regímenes Fiscales del SAT (c_RegimenFiscal)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "regimen_fiscal.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 un régimen fiscal por su código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de régimen fiscal es válido"""
+        return cls.get_regimen(code) is not None
+
+    @classmethod
+    def is_valid_for_persona_fisica(cls, code: str) -> bool:
+        """Valida si un régimen es válido para persona física"""
+        regimen = cls.get_regimen(code)
+        return regimen.get("fisica", False) if regimen else False
+
+    @classmethod
+    def is_valid_for_persona_moral(cls, code: str) -> bool:
+        """Valida si un régimen es válido para persona moral"""
+        regimen = cls.get_regimen(code)
+        return regimen.get("moral", False) if regimen else False
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los regímenes fiscales"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/tasa_o_cuota.py

@@ -0,0 +1,42 @@
+"""Catálogo de Tasa o Cuota (SAT)"""
+
+import json
+from pathlib import Path
+
+
+class TasaOCuota:
+    _data = None
+
+    @classmethod
+    def _load_data(cls):
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "c_TasaOCuota.json"
+            )
+            with open(path, encoding="utf-8") as f:
+                json_data = json.load(f)
+                # This catalog has a more complex structure, let's index by a combination of fields
+                cls._data = json_data["data"]
+        return cls._data
+
+    @classmethod
+    def get_data(cls):
+        return cls._load_data()
+
+    @classmethod
+    def get_by_range_and_tax(cls, valor_min, valor_max, impuesto, factor, trasladado, retenido):
+        """Finds a rate based on multiple criteria."""
+        data = cls.get_data()
+        # This is a placeholder for a more complex search logic
+        return [
+            item
+            for item in data
+            if item.get("valor_mínimo") == valor_min
+            and item.get("valor_máximo") == valor_max
+            and item.get("impuesto") == impuesto
+            and item.get("factor") == factor
+        ]

catalogmx/catalogs/sat/cfdi_4/tipo_comprobante.py

@@ -0,0 +1,45 @@
+"""Catálogo c_TipoComprobante"""
+
+import json
+from pathlib import Path
+
+
+class TipoComprobanteCatalog:
+    """Catálogo de Tipos de Comprobante del SAT (c_TipoComprobante)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "tipo_comprobante.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("tipos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_tipo(cls, code: str) -> dict | None:
+        """Obtiene un tipo de comprobante por su código"""
+        cls._load_data()
+        return cls._by_code.get(code.upper())
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de tipo de comprobante es válido"""
+        return cls.get_tipo(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los tipos de comprobante"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/tipo_factor.py

@@ -0,0 +1,34 @@
+"""Catálogo de Tipos de Factor (SAT)"""
+
+import json
+
+from ....helpers import get_project_root
+
+
+class TipoFactor:
+    _data = None
+
+    @classmethod
+    def _load_data(cls):
+        if cls._data is None:
+            root = get_project_root()
+            path = root / "packages" / "shared-data" / "sat" / "cfdi_4.0" / "c_TipoFactor.json"
+            with open(path, encoding="utf-8") as f:
+                json_data = json.load(f)
+                cls._data = {item["valor"]: item for item in json_data["data"]}
+        return cls._data
+
+    @classmethod
+    def get_data(cls):
+        return cls._load_data()
+
+    @classmethod
+    def get_by_id(cls, tipo_factor_id):
+        """Busca un tipo de factor por su ID."""
+        data = cls.get_data()
+        return data.get(tipo_factor_id)
+
+    @classmethod
+    def is_valid(cls, tipo_factor_id):
+        """Verifica si un ID de tipo de factor es válido."""
+        return tipo_factor_id in cls.get_data()

catalogmx/catalogs/sat/cfdi_4/tipo_relacion.py

@@ -0,0 +1,45 @@
+"""Catálogo c_TipoRelacion"""
+
+import json
+from pathlib import Path
+
+
+class TipoRelacionCatalog:
+    """Catálogo de Tipos de Relación del SAT (c_TipoRelacion)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "tipo_relacion.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("tipos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_tipo(cls, code: str) -> dict | None:
+        """Obtiene un tipo de relación por su código"""
+        cls._load_data()
+        return cls._by_code.get(code)
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de tipo de relación es válido"""
+        return cls.get_tipo(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los tipos de relación"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/cfdi_4/uso_cfdi.py

@@ -0,0 +1,45 @@
+"""Catálogo c_UsoCFDI"""
+
+import json
+from pathlib import Path
+
+
+class UsoCFDICatalog:
+    """Catálogo de Usos del CFDI del SAT (c_UsoCFDI)"""
+
+    _data: list[dict] | None = None
+    _by_code: dict[str, dict] | None = None
+
+    @classmethod
+    def _load_data(cls) -> None:
+        """Carga los datos del catálogo si aún no han sido cargados"""
+        if cls._data is None:
+            path = (
+                Path(__file__).parent.parent.parent.parent.parent.parent
+                / "shared-data"
+                / "sat"
+                / "cfdi_4.0"
+                / "uso_cfdi.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("usos", data)
+            cls._by_code = {item["code"]: item for item in cls._data}
+
+    @classmethod
+    def get_uso(cls, code: str) -> dict | None:
+        """Obtiene un uso del CFDI por su código"""
+        cls._load_data()
+        return cls._by_code.get(code.upper())
+
+    @classmethod
+    def is_valid(cls, code: str) -> bool:
+        """Valida si un código de uso del CFDI es válido"""
+        return cls.get_uso(code) is not None
+
+    @classmethod
+    def get_all(cls) -> list[dict]:
+        """Obtiene todos los usos del CFDI"""
+        cls._load_data()
+        return cls._data.copy()

catalogmx/catalogs/sat/comercio_exterior/__init__.py

@@ -0,0 +1,39 @@
+"""
+Catálogos del SAT para Complemento de Comercio Exterior 2.0
+
+Este módulo contiene los catálogos oficiales del SAT necesarios para la emisión
+de CFDI con Complemento de Comercio Exterior versión 2.0 (vigente desde enero 18, 2024).
+
+Catálogos incluidos:
+- c_INCOTERM: 11 Incoterms 2020
+- c_ClavePedimento: ~40 claves de pedimento aduanero
+- c_UnidadAduana: ~30 unidades de medida aduanera
+- c_MotivoTraslado: 6 motivos de traslado
+- c_RegistroIdentTribReceptor: Tipos de identificación tributaria
+- c_Moneda: ~180 monedas ISO 4217
+- c_Pais: ~250 países ISO 3166-1
+- c_Estado: Estados USA y provincias Canadá
+- c_FraccionArancelaria: ~20,000 fracciones arancelarias TIGIE/NICO
+"""
+
+from .claves_pedimento import ClavePedimentoCatalog
+from .estados import EstadoCatalog
+from .incoterms import IncotermsValidator
+from .monedas import MonedaCatalog
+from .motivos_traslado import MotivoTrasladoCatalog
+from .paises import PaisCatalog
+from .registro_ident_trib import RegistroIdentTribCatalog
+from .unidades_aduana import UnidadAduanaCatalog
+from .validator import ComercioExteriorValidator
+
+__all__ = [
+    "IncotermsValidator",
+    "ClavePedimentoCatalog",
+    "UnidadAduanaCatalog",
+    "MotivoTrasladoCatalog",
+    "RegistroIdentTribCatalog",
+    "MonedaCatalog",
+    "PaisCatalog",
+    "EstadoCatalog",
+    "ComercioExteriorValidator",
+]