arca-client 0.6.0__py3-none-any.whl

arca_client/__init__.py

@@ -0,0 +1,81 @@
+from .certificates import certificate_paths, cuit_from_certificate
+from .environments import Environment
+from .exceptions import (
+    ArcaError,
+    PersonaNoEncontrada,
+    RespuestaNoReconocida,
+    WSAAError,
+    WSCDCError,
+    WSFEConnectionError,
+    WSFEError,
+    WSPCIError,
+)
+from .wsaa import WSAA, AccessTicket, FileTicketCache, MemoryTicketCache
+from .wscdc import WSCDC, ComprobanteConsultado, Constatacion, ModoAutorizacion
+from .wsfe import (
+    WSFE,
+    Alicuota,
+    CbteTipo,
+    ComprobanteAsociado,
+    ComprobanteAutorizado,
+    Concepto,
+    CondicionIVAReceptor,
+    DocTipo,
+    Emisor,
+    Item,
+    IvaAlicuota,
+    Receptor,
+    TipoTributo,
+    Tributo,
+    neto_por_alicuota,
+    parse_qr_url,
+    qr_url,
+    render_invoice_pdf,
+)
+from .wspci import WSPCI, Categoria, Constancia, Domicilio, Impuesto, TipoPersona
+
+__all__ = [
+    "WSAA",
+    "WSCDC",
+    "WSFE",
+    "WSPCI",
+    "AccessTicket",
+    "Alicuota",
+    "ArcaError",
+    "Categoria",
+    "CbteTipo",
+    "ComprobanteAsociado",
+    "ComprobanteAutorizado",
+    "Concepto",
+    "Constancia",
+    "ComprobanteConsultado",
+    "Constatacion",
+    "CondicionIVAReceptor",
+    "DocTipo",
+    "Domicilio",
+    "Emisor",
+    "Impuesto",
+    "Item",
+    "IvaAlicuota",
+    "Receptor",
+    "Environment",
+    "FileTicketCache",
+    "MemoryTicketCache",
+    "ModoAutorizacion",
+    "PersonaNoEncontrada",
+    "RespuestaNoReconocida",
+    "TipoPersona",
+    "TipoTributo",
+    "Tributo",
+    "WSAAError",
+    "WSCDCError",
+    "WSFEConnectionError",
+    "WSFEError",
+    "WSPCIError",
+    "certificate_paths",
+    "cuit_from_certificate",
+    "neto_por_alicuota",
+    "parse_qr_url",
+    "qr_url",
+    "render_invoice_pdf",
+]

arca_client/certificates.py

@@ -0,0 +1,121 @@
+"""Generación de clave privada y CSR para obtener certificados de ARCA."""
+
+import os
+import re
+from pathlib import Path
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.x509.oid import NameOID
+
+from .environments import Environment
+
+_CUIT_WEIGHTS = (5, 4, 3, 2, 7, 6, 5, 4, 3, 2)
+_ALIAS_RE = re.compile(r"^[A-Za-z0-9]+$")
+
+
+def normalize_cuit(cuit: str) -> str:
+    """Quita guiones y espacios: ``20-12345678-6`` -> ``20123456786``."""
+    return re.sub(r"[\s-]", "", cuit)
+
+
+def is_valid_cuit(cuit: str) -> bool:
+    """Valida longitud y dígito verificador (módulo 11)."""
+    cuit = normalize_cuit(cuit)
+    if not re.fullmatch(r"\d{11}", cuit):
+        return False
+    total = sum(int(d) * w for d, w in zip(cuit[:10], _CUIT_WEIGHTS, strict=True))
+    check = 11 - total % 11
+    if check == 11:
+        check = 0
+    return check != 10 and check == int(cuit[10])
+
+
+def is_valid_alias(alias: str) -> bool:
+    """ARCA solo admite letras y números en el nombre del certificado (CN)."""
+    return bool(_ALIAS_RE.fullmatch(alias))
+
+
+def generate_private_key(key_size: int = 2048) -> rsa.RSAPrivateKey:
+    return rsa.generate_private_key(public_exponent=65537, key_size=key_size)
+
+
+def private_key_pem(key, password: bytes | None = None) -> bytes:
+    encryption = (
+        serialization.BestAvailableEncryption(password)
+        if password
+        else serialization.NoEncryption()
+    )
+    return key.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption,
+    )
+
+
+def build_csr(key, cuit: str, organization: str, alias: str) -> x509.CertificateSigningRequest:
+    """CSR con el DN que exige ARCA: C=AR, O=<razón social>, CN=<alias>, serialNumber=CUIT <n>."""
+    subject = x509.Name(
+        [
+            x509.NameAttribute(NameOID.COUNTRY_NAME, "AR"),
+            x509.NameAttribute(NameOID.ORGANIZATION_NAME, organization),
+            x509.NameAttribute(NameOID.COMMON_NAME, alias),
+            x509.NameAttribute(NameOID.SERIAL_NUMBER, f"CUIT {normalize_cuit(cuit)}"),
+        ]
+    )
+    return x509.CertificateSigningRequestBuilder().subject_name(subject).sign(key, hashes.SHA256())
+
+
+def csr_pem(csr: x509.CertificateSigningRequest) -> bytes:
+    return csr.public_bytes(serialization.Encoding.PEM)
+
+
+def certificate_matches_key(cert_pem: bytes, key) -> bool:
+    cert = x509.load_pem_x509_certificate(cert_pem)
+    return cert.public_key().public_numbers() == key.public_key().public_numbers()
+
+
+def write_private(path: Path, data: bytes) -> None:
+    """Escribe un archivo legible solo por el dueño (0600)."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "wb") as f:
+        f.write(data)
+
+
+def read_pem(value: bytes | str | os.PathLike) -> bytes:
+    """Acepta el contenido PEM en bytes o una ruta a archivo."""
+    if isinstance(value, bytes):
+        return value
+    with open(value, "rb") as f:
+        return f.read()
+
+
+def certificate_paths(
+    alias: str, env: Environment | str, base_dir: str | os.PathLike = "certs"
+) -> tuple[Path, Path]:
+    """Rutas (certificado, clave) donde las guarda `arca-setup`: ``<base_dir>/<ambiente>/<alias>``.
+
+    Un `base_dir` relativo se resuelve contra el directorio actual; una app conviene
+    que pase una ruta absoluta (ej. ``BASE_DIR / "certs"``).
+    """
+    if not is_valid_alias(alias):
+        raise ValueError(f"Alias inválido {alias!r}: solo se permiten letras y números")
+    folder = Path(base_dir) / Environment(env).value
+    return folder / f"{alias}.crt", folder / f"{alias}.key"
+
+
+def cuit_from_certificate(cert: x509.Certificate | bytes | str | os.PathLike) -> str | None:
+    """Extrae la CUIT del campo serialNumber del DN (``CUIT 20123456786``).
+
+    Acepta el certificado ya cargado, el PEM en bytes o una ruta a archivo, igual
+    que ``WSAA(cert=...)``. Devuelve `None` si el certificado no tiene CUIT.
+    """
+    if not isinstance(cert, x509.Certificate):
+        cert = x509.load_pem_x509_certificate(read_pem(cert))
+    for attr in cert.subject.get_attributes_for_oid(NameOID.SERIAL_NUMBER):
+        match = re.fullmatch(r"CUIT\s*(\d{11})", str(attr.value).strip())
+        if match:
+            return match.group(1)
+    return None

arca_client/environments.py

@@ -0,0 +1,50 @@
+from enum import Enum
+
+
+class Environment(str, Enum):
+    """Ambientes de ARCA."""
+
+    HOMOLOGACION = "homologacion"
+    PRODUCCION = "produccion"
+
+
+WSAA_URLS = {
+    Environment.HOMOLOGACION: "https://wsaahomo.afip.gov.ar/ws/services/LoginCms",
+    Environment.PRODUCCION: "https://wsaa.afip.gov.ar/ws/services/LoginCms",
+}
+
+
+def wsaa_wsdl(env: Environment) -> str:
+    return f"{WSAA_URLS[env]}?wsdl"
+
+
+WSFE_URLS = {
+    Environment.HOMOLOGACION: "https://wswhomo.afip.gov.ar/wsfev1/service.asmx",
+    Environment.PRODUCCION: "https://servicios1.afip.gov.ar/wsfev1/service.asmx",
+}
+
+
+def wsfe_wsdl(env: Environment) -> str:
+    return f"{WSFE_URLS[env]}?WSDL"
+
+
+WSCDC_URLS = {
+    Environment.HOMOLOGACION: "https://wswhomo.afip.gov.ar/WSCDC/service.asmx",
+    Environment.PRODUCCION: "https://servicios1.afip.gov.ar/WSCDC/service.asmx",
+}
+
+
+def wscdc_wsdl(env: Environment) -> str:
+    return f"{WSCDC_URLS[env]}?WSDL"
+
+
+# El manual de la Constancia de Inscripción indica hosts `*.arca.gov.ar`, pero no conectaron
+# en la prueba; los `*.afip.gov.ar` sí responden.
+WSPCI_URLS = {
+    Environment.HOMOLOGACION: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5",
+    Environment.PRODUCCION: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5",
+}
+
+
+def wspci_wsdl(env: Environment) -> str:
+    return f"{WSPCI_URLS[env]}?WSDL"

arca_client/exceptions.py

@@ -0,0 +1,113 @@
+class ArcaError(Exception):
+    """Error base de arca-client."""
+
+
+class WSAAError(ArcaError):
+    """Error devuelto por el WSAA como SoapFault.
+
+    `code` es el código de la especificación (ej. ``coe.alreadyAuthenticated``,
+    ``cms.cert.expired``).
+    """
+
+    def __init__(self, code: str, message: str):
+        self.code = code
+        self.message = message
+        super().__init__(f"{code}: {message}")
+
+    @property
+    def retryable(self) -> bool:
+        """Según la spec, solo `wsaa.*` y `wsn.unavailable` admiten reintento (tras 60 s)."""
+        return self.code.startswith("wsaa.") or self.code == "wsn.unavailable"
+
+
+class RespuestaNoReconocida(ArcaError):
+    """ARCA respondió algo que no se pudo interpretar.
+
+    El mensaje no incluye la respuesta (puede tener CUIT, CAE y datos del receptor, y
+    terminar en logs); para depurar, está completa en el atributo ``respuesta``.
+    """
+
+    def __init__(self, message: str, respuesta=None):
+        self.respuesta = respuesta
+        super().__init__(message)
+
+
+class WSFEError(ArcaError):
+    """WSFE rechazó el pedido.
+
+    `errores` son los ``<Errors>`` generales y `observaciones` los ``<Obs>`` del
+    comprobante; ambos son listas de :class:`arca_client.wsfe.Mensaje`.
+    """
+
+    def __init__(self, errores: list, observaciones: list | None = None):
+        self.errores = errores
+        self.observaciones = observaciones or []
+        detalle = "; ".join(str(m) for m in [*self.errores, *self.observaciones])
+        super().__init__(detalle or "WSFE rechazó el comprobante sin detalle")
+
+    @property
+    def codes(self) -> list[int]:
+        return [m.code for m in [*self.errores, *self.observaciones]]
+
+
+class WSCDCError(ArcaError):
+    """WSCDC no pudo procesar el pedido de constatación (``<Errors>`` sin resultado).
+
+    No significa que el comprobante sea inválido: no se llegó a verificarlo.
+    `errores` es una lista de :class:`arca_client.wsfe.Mensaje`.
+    """
+
+    def __init__(self, errores: list):
+        self.errores = errores
+        detalle = "; ".join(str(m) for m in errores)
+        super().__init__(detalle or "WSCDC no devolvió resultado")
+
+    @property
+    def codes(self) -> list[int]:
+        return [m.code for m in self.errores]
+
+
+class WSPCIError(ArcaError):
+    """WSPCI respondió con un SOAP Fault: no se pudo obtener la constancia.
+
+    No dice nada sobre el contribuyente. `errores` es una lista de textos.
+    """
+
+    def __init__(self, errores: list[str]):
+        self.errores = errores
+        super().__init__("; ".join(errores) or "WSPCI no devolvió detalle")
+
+
+class PersonaNoEncontrada(WSPCIError):
+    """ARCA no registra ninguna persona con esa CUIT."""
+
+
+class WSFEConnectionError(ArcaError):
+    """Se interrumpió la comunicación al pedir el CAE.
+
+    - ``safe_to_retry=True``: se verificó con ``FECompConsultar`` que ARCA no
+      registró el comprobante; se puede volver a llamar a ``create_invoice_c``.
+    - ``safe_to_retry=False``: no se pudo verificar. **No reintentar** con
+      ``create_invoice_c`` (emitiría otro número): consultá
+      ``WSFE.get_voucher(punto_venta, tipo, numero)`` cuando vuelva la conexión.
+
+    Si el corte fue una respuesta que no se pudo interpretar, ``respuesta`` la tiene
+    completa (no va en el mensaje, para que no termine en logs); si no, es ``None``.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        punto_venta: int,
+        tipo,
+        numero: int,
+        safe_to_retry: bool,
+        respuesta=None,
+    ):
+        self.punto_venta = punto_venta
+        self.tipo = tipo
+        self.numero = numero
+        self.safe_to_retry = safe_to_retry
+        self.respuesta = respuesta
+        super().__init__(message)