xhandler 6.0.0a1__py3-none-any.whl

xhandler/xsender/__init__.py

@@ -0,0 +1,280 @@
+"""Sends signed UBL documents to SUNAT: the SOAP services (billService,
+consult and validation) and the REST API of the guias de remision with its
+OAuth token.
+
+The xhandler core builds every request and reads every answer (CDR, tickets,
+faults); this package only sends them over HTTP with httpx.
+"""
+
+from __future__ import annotations
+
+import base64
+import threading
+import time
+from typing import Any
+
+import httpx
+
+from xhandler._core import ErrorKind, XhandlerError, invoke
+from xhandler.xsender.models import (
+    BILL_CONSULT_SERVICE_URL,
+    BILL_VALID_SERVICE_URL,
+    CDR,
+    ConsultDocument,
+    ConsultResult,
+    ConsultStatus,
+    Credentials,
+    Fault,
+    File,
+    NoCDR,
+    SendResult,
+    Status,
+    Target,
+    URLs,
+    ValidateCDP,
+    VerifyResult,
+)
+
+__all__ = [
+    "BILL_CONSULT_SERVICE_URL",
+    "BILL_VALID_SERVICE_URL",
+    "CDR",
+    "ConsultDocument",
+    "ConsultResult",
+    "ConsultStatus",
+    "Credentials",
+    "Fault",
+    "File",
+    "FileSender",
+    "NoCDR",
+    "SendResult",
+    "Status",
+    "SunatClient",
+    "Target",
+    "URLs",
+    "ValidateCDP",
+    "VerifyResult",
+]
+
+
+_RATE_LIMIT_PAUSES = (1, 2)
+"""Seconds before retrying a request SUNAT's front proxy refused."""
+
+
+class SunatClient:
+    """Sends the requests to SUNAT and keeps the OAuth tokens of the guias de
+    remision. Share one between the FileSenders of several companies."""
+
+    def __init__(
+        self, http: httpx.Client | None = None, security_api_url: str | None = None
+    ) -> None:
+        """``http`` defaults to a client with a 30s connection timeout and a
+        120s timeout for the rest. ``security_api_url`` is where the tokens of
+        the guias are requested (SUNAT's by default)."""
+        self._http = http or httpx.Client(timeout=httpx.Timeout(120, connect=30))
+        self._security_api_url = security_api_url
+        self._lock = threading.Lock()  # guards _tokens
+        self._tokens: dict[str, tuple[str, float]] = {}
+        # Held while a token is requested, so concurrent calls don't revoke
+        # each other's tokens
+        self._requesting = threading.Lock()
+
+    def close(self) -> None:
+        """Closes the HTTP connections."""
+        self._http.close()
+
+    def __enter__(self) -> SunatClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def get_status(
+        self, url: str, document: ConsultDocument, credentials: Credentials
+    ) -> ConsultResult:
+        """billConsultService getStatus: the status of a document already sent."""
+        call = {"get_status": {"url": url, "document": _json(document)}}
+        return ConsultResult.model_validate(self._exchange(call, False, credentials))
+
+    def get_status_cdr(
+        self, url: str, document: ConsultDocument, credentials: Credentials
+    ) -> ConsultResult:
+        """billConsultService getStatusCdr: the CDR of a document already sent."""
+        call = {"get_status_cdr": {"url": url, "document": _json(document)}}
+        return ConsultResult.model_validate(self._exchange(call, False, credentials))
+
+    def validate_cdp(self, url: str, cdp: ValidateCDP, credentials: Credentials) -> ConsultResult:
+        """billValidService validaCDPcriterios."""
+        call = {"validate_cdp": {"url": url, "cdp": _json(cdp)}}
+        return ConsultResult.model_validate(self._exchange(call, False, credentials))
+
+    def validate_file(self, url: str, file: File, credentials: Credentials) -> ConsultResult:
+        """billValidService verificaCPEarchivo."""
+        call = {"validate_file": {"url": url, "file": _json(file)}}
+        return ConsultResult.model_validate(self._exchange(call, False, credentials))
+
+    def _exchange(self, call: Any, rest: bool, credentials: Credentials) -> Any:
+        """Sends a call and returns its answer. SUNAT revokes the tokens of the
+        guias before they expire: a REST call rejected with HTTP 401 is retried
+        once with a new token. A SOAP call refused by SUNAT's rate limiting is
+        retried after a pause."""
+        if rest:
+            token = self._token(credentials)
+            response = self._send(self._request(call, credentials, token))
+            if response.status_code == 401 and credentials.token is None:
+                self._forget(credentials, token)
+                response = self._send(self._request(call, credentials, self._token(credentials)))
+            return _parse(call, response)
+
+        request = self._request(call, credentials, None)
+        for pause in (*_RATE_LIMIT_PAUSES, None):
+            try:
+                return _parse(call, self._send(request))
+            except XhandlerError as error:
+                if error.kind is not ErrorKind.RATE_LIMITED or pause is None:
+                    raise
+                time.sleep(pause)
+
+    @staticmethod
+    def _request(call: Any, credentials: Credentials, token: str | None) -> Any:
+        return invoke("request", {"call": call, "credentials": _json(credentials), "token": token})
+
+    def _send(self, request: dict[str, Any]) -> httpx.Response:
+        def send() -> httpx.Response:
+            return self._http.request(
+                request["method"],
+                request["url"],
+                headers=dict(request["headers"]),
+                content=request["body"],
+            )
+
+        try:
+            return send()
+        except (httpx.ConnectError, httpx.ConnectTimeout):
+            return send()  # once more: the request never reached SUNAT
+
+    def _token(self, credentials: Credentials) -> str:
+        """The token of the credentials, a cached one (reused until a minute
+        before it expires), or a new one."""
+        if credentials.token is not None:
+            return credentials.token
+        key = _token_key(credentials)
+        cached = self._cached_token(key)
+        if cached:
+            return cached
+        with self._requesting:
+            cached = self._cached_token(key)
+            if cached:
+                return cached
+            return self._request_token(key, credentials)
+
+    def _cached_token(self, key: str) -> str | None:
+        with self._lock:
+            cached = self._tokens.get(key)
+        return cached[0] if cached and time.monotonic() < cached[1] else None
+
+    def _request_token(self, key: str, credentials: Credentials) -> str:
+        call = {"token": {"url": self._security_api_url}}
+        token = self._exchange(call, False, credentials)["token"]
+        with self._lock:
+            reuse_before = time.monotonic() + max(token["expires_in"] - 60, 0)
+            self._tokens[key] = (token["access_token"], reuse_before)
+        return str(token["access_token"])
+
+    def _forget(self, credentials: Credentials, rejected: str) -> None:
+        """Forgets the rejected token, unless another call already replaced it."""
+        key = _token_key(credentials)
+        with self._lock:
+            if self._tokens.get(key, ("",))[0] == rejected:
+                del self._tokens[key]
+
+
+def _parse(call: Any, response: httpx.Response) -> Any:
+    return invoke(
+        "parse",
+        {
+            "call": call,
+            "status": response.status_code,
+            "headers": list(response.headers.multi_items()),
+            "body": response.text,
+        },
+    )
+
+
+def _token_key(credentials: Credentials) -> str:
+    return f"{credentials.client_id or ''}:{credentials.username}"
+
+
+def _json(model: Any) -> Any:
+    return model.model_dump(mode="json")
+
+
+def _b64(data: bytes) -> str:
+    return base64.b64encode(data).decode()
+
+
+_default_client: SunatClient | None = None
+_default_client_lock = threading.Lock()
+
+
+class FileSender:
+    """Sends the signed documents of one company. The document decides
+    everything else: the file name, the service and the operation."""
+
+    def __init__(
+        self, urls: URLs, credentials: Credentials, client: SunatClient | None = None
+    ) -> None:
+        self.urls = urls
+        self.credentials = credentials
+        self._client = client
+
+    @property
+    def client(self) -> SunatClient:
+        global _default_client
+        if self._client is None:
+            with _default_client_lock:
+                _default_client = _default_client or SunatClient()
+            self._client = _default_client
+        return self._client
+
+    def send_file(self, xml: bytes | str) -> SendResult:
+        """Zips the signed XML and sends it to its SUNAT service."""
+        prepared = invoke("prepare_send_file", {"xml": _b64(_bytes(xml)), "urls": _json(self.urls)})
+        return self._send(prepared)
+
+    def send_pack(self, name: str, files: list[bytes | str]) -> SendResult:
+        """Sends several invoices in one zip called ``name`` (sendPack)."""
+        prepared = invoke(
+            "prepare_send_pack",
+            {"name": name, "files": [_b64(_bytes(f)) for f in files], "urls": _json(self.urls)},
+        )
+        return self._send(prepared)
+
+    def _send(self, prepared: dict[str, Any]) -> SendResult:
+        target = prepared["send_target"]
+        call = {"send_file": {"target": target, "file": prepared["file"]}}
+        answer = self.client._exchange(call, target["protocol"] == "rest", self.credentials)
+        return SendResult.model_validate(
+            {
+                **answer,
+                "send_target": target,
+                "verify_ticket_target": prepared["verify_ticket_target"],
+            }
+        )
+
+    def verify_ticket(self, target: Target, ticket: str) -> VerifyResult:
+        """Asks the service ``target`` for the status of a ticket."""
+        call = {"verify_ticket": {"target": _json(target), "ticket": ticket}}
+        answer = self.client._exchange(call, target.protocol == "rest", self.credentials)
+        return VerifyResult.model_validate(answer)
+
+    def verify_file_ticket(self, xml: bytes | str, ticket: str) -> VerifyResult:
+        """:meth:`verify_ticket` with the service of the sent document."""
+        target = invoke(
+            "verify_ticket_target", {"xml": _b64(_bytes(xml)), "urls": _json(self.urls)}
+        )
+        return self.verify_ticket(Target.model_validate(target), ticket)
+
+
+def _bytes(xml: bytes | str) -> bytes:
+    return xml.encode() if isinstance(xml, str) else xml

xhandler/xsender/models.py

@@ -0,0 +1,197 @@
+"""Inputs and answers of the SUNAT services."""
+
+from __future__ import annotations
+
+import base64
+from collections.abc import Iterator
+from enum import Enum
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, PlainSerializer
+
+
+def _from_base64(value: object) -> object:
+    return base64.b64decode(value) if isinstance(value, str) else value
+
+
+Bytes = Annotated[
+    bytes,
+    BeforeValidator(_from_base64),
+    PlainSerializer(lambda b: base64.b64encode(b).decode(), return_type=str, when_used="json"),
+]
+"""Raw bytes in Python, base64 in the JSON of the core."""
+
+
+class _Model(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+
+class URLs(_Model):
+    """The SUNAT services where a company sends its documents."""
+
+    invoice: str
+    perception_retention: str
+    despatch: str = ""
+    """The REST API of the guias de remision; SUNAT has no beta for it."""
+
+    @classmethod
+    def beta(cls) -> URLs:
+        """SUNAT beta (testing) services; without guias de remision."""
+        return cls(
+            invoice="https://e-beta.sunat.gob.pe/ol-ti-itcpfegem-beta/billService",
+            perception_retention="https://e-beta.sunat.gob.pe/ol-ti-itemision-otroscpe-gem-beta/billService",
+        )
+
+    @classmethod
+    def production(cls) -> URLs:
+        """SUNAT production services."""
+        return cls(
+            invoice="https://e-factura.sunat.gob.pe/ol-ti-itcpfegem/billService",
+            perception_retention="https://e-factura.sunat.gob.pe/ol-ti-itemision-otroscpe-gem/billService",
+            despatch="https://api-cpe.sunat.gob.pe/v1/contribuyente/gem",
+        )
+
+
+BILL_CONSULT_SERVICE_URL = "https://e-factura.sunat.gob.pe/ol-it-wsconscpegem/billConsultService"
+"""Looks up documents already sent (get_status, get_status_cdr)."""
+BILL_VALID_SERVICE_URL = "https://e-factura.sunat.gob.pe/ol-it-wsconsvalidcpe/billValidService"
+"""Validates documents (validate_cdp, validate_file)."""
+
+
+class Credentials(_Model):
+    """Credentials of the company. They never show their secrets."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True, hide_input_in_errors=True)
+
+    username: str
+    """SOL user, e.g. "20123456789MODDATOS"."""
+    password: str
+    client_id: str | None = None
+    """API client of the REST services (guias de remision), from SUNAT's SOL menu."""
+    client_secret: str | None = None
+    token: str | None = Field(default=None, exclude=True)
+    """A token of the guias obtained elsewhere; used as is when set."""
+
+    def __repr_args__(self) -> Iterator[tuple[str | None, Any]]:
+        """For repr and str: only the username."""
+        yield "username", self.username
+
+
+class Target(_Model):
+    """A SUNAT service for a file or a ticket."""
+
+    protocol: Literal["soap", "rest"]
+    url: str
+    action: Literal["bill", "summary", "pack"] | None = None
+    """The operation of the SOAP files."""
+
+
+class File(_Model):
+    """A zip for SUNAT."""
+
+    filename: str
+    zip: Bytes
+
+
+class ConsultDocument(_Model):
+    """A document already sent to SUNAT."""
+
+    ruc: str
+    tipo_comprobante: str
+    """Catalog1, e.g. "01"."""
+    serie: str
+    numero: int
+
+
+class ValidateCDP(ConsultDocument):
+    """The criteria of validaCDPcriterios."""
+
+    tipo_documento_identidad_receptor: str
+    """Catalog6."""
+    numero_documento_identidad_receptor: str
+    fecha_emision: str
+    """dd/MM/yyyy."""
+    importe_total: str
+    numero_autorizacion: str | None = None
+
+
+class Status(str, Enum):
+    """The SUNAT verdict of a document; prints as SUNAT says it, e.g. ACEPTADO."""
+
+    ACCEPTED = "ACEPTADO"
+    REJECTED = "RECHAZADO"
+    EXCEPTION = "EXCEPCION"
+    IN_PROGRESS = "EN_PROCESO"
+    UNKNOWN = "UNKNOWN"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class CDR(_Model):
+    """The receipt SUNAT gives back (Constancia de Recepcion)."""
+
+    zip: Bytes
+    response_code: str
+    description: str
+    notes: list[str]
+    status: Status
+    status_code: str | None = None
+    """The ticket status, only when verifying a ticket."""
+
+
+class Fault(_Model):
+    """An error answered by SUNAT."""
+
+    code: str
+    """SUNAT's code as given: the SOAP faultcode (e.g. "soap-env:Client.0111") or
+    the error code of a REST answer (e.g. "1033")."""
+    sunat_code: int | None = None
+    """The number in ``code`` (111), when it has one."""
+    http_status: int | None = None
+    """The status of the answer, e.g. 500 for SOAP faults or 422 for REST errors."""
+    message: str
+    status: Status
+
+
+class NoCDR(_Model):
+    """A ticket status without CDR, e.g. "98" (in progress)."""
+
+    status_code: str
+    status: Status
+
+
+class SendResult(_Model):
+    """The answer to a sent file: a CDR, a ticket to verify later (summaries,
+    voided documents, packs, guias) or a fault."""
+
+    cdr: CDR | None = None
+    ticket: str | None = None
+    fault: Fault | None = None
+    send_target: Target
+    verify_ticket_target: Target | None = None
+    """Where the ticket is verified."""
+
+
+class VerifyResult(_Model):
+    """The answer to a ticket: a CDR, no CDR yet (e.g. in progress) or a fault."""
+
+    cdr: CDR | None = None
+    no_cdr: NoCDR | None = None
+    fault: Fault | None = None
+
+
+class ConsultStatus(_Model):
+    """e.g. "0001" (accepted) for get_status, or "0" for validate_cdp."""
+
+    status_code: str
+    status_message: str | None = None
+    cdr_zip: Bytes | None = None
+    """The CDR of get_status_cdr."""
+
+
+class ConsultResult(_Model):
+    """The answer of the consult and validation services."""
+
+    status: ConsultStatus | None = None
+    fault: Fault | None = None

xhandler/xsigner/__init__.py

@@ -0,0 +1,48 @@
+"""Signs UBL documents with the enveloped RSA-SHA256 XML signature SUNAT
+requires. The signature is placed in the first empty ``ext:ExtensionContent``
+of the document, as rendered by :mod:`xhandler.xbuilder`."""
+
+from __future__ import annotations
+
+import base64
+from typing import Any, overload
+
+from xhandler._core import invoke
+
+
+class SigningKey:
+    """The private key and certificate that sign the documents. The key is
+    checked when signing. It never shows its secrets in ``repr``."""
+
+    __slots__ = ("_key",)
+
+    def __init__(self, key: dict[str, Any]) -> None:
+        self._key = key
+
+    @classmethod
+    def from_pem(cls, private_key: str, certificate: str) -> SigningKey:
+        """A PEM private key (PKCS#8 or PKCS#1) and a PEM X.509 certificate."""
+        return cls({"pem": {"private_key": private_key, "certificate": certificate}})
+
+    @classmethod
+    def from_pkcs12(cls, der: bytes, password: str) -> SigningKey:
+        """The signing key stored in a PKCS#12 keystore (.pfx, .p12)."""
+        return cls({"pkcs12": {"der": base64.b64encode(der).decode(), "password": password}})
+
+    def __repr__(self) -> str:
+        return "SigningKey(<redacted>)"
+
+
+@overload
+def sign(xml: bytes, key: SigningKey) -> bytes: ...
+@overload
+def sign(xml: str, key: SigningKey) -> str: ...
+def sign(xml: bytes | str, key: SigningKey) -> bytes | str:
+    """Returns the XML with its signature, as bytes for bytes and as text for
+    text. Bytes may be UTF-8 or ISO-8859-1 (as their XML declaration says);
+    the signed bytes are UTF-8."""
+    data = xml.encode() if isinstance(xml, str) else xml
+    signed = base64.b64decode(
+        invoke("sign", {"xml": base64.b64encode(data).decode(), "key": key._key})
+    )
+    return signed.decode() if isinstance(xml, str) else signed

xhandler-6.0.0a1.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: xhandler
+Version: 6.0.0-alpha.1
+Summary: Create, sign and send the electronic documents (UBL XML) of SUNAT Peru
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: wasmtime>=30
+Description-Content-Type: text/markdown
+
+# xhandler-python
+
+[![License](https://img.shields.io/github/license/project-openubl/xhandler-python?logo=apache)](https://www.apache.org/licenses/LICENSE-2.0)
+[![CI](https://github.com/project-openubl/xhandler-python/actions/workflows/ci.yml/badge.svg)](https://github.com/project-openubl/xhandler-python/actions/workflows/ci.yml)
+
+Crea, firma y envía los comprobantes electrónicos (XML UBL) de la SUNAT del Perú desde Python. Sin
+extensiones nativas que compilar.
+
+## Instalación
+
+Hasta la primera versión en PyPI, instálalo desde GitHub:
+
+```shell
+pip install "xhandler @ git+https://github.com/project-openubl/xhandler-python"
+# o
+uv add "xhandler @ git+https://github.com/project-openubl/xhandler-python"
+```
+
+Python 3.10 o superior, en Linux, macOS y Windows.
+
+## Uso
+
+```python
+from decimal import Decimal
+from pathlib import Path
+
+from xhandler import xbuilder
+from xhandler.xsender import Credentials, FileSender, URLs
+from xhandler.xsigner import SigningKey, sign
+
+# Crear
+invoice = xbuilder.Invoice(
+    serie_numero="F001-1",
+    proveedor=xbuilder.Proveedor(ruc="12345678912", razon_social="Softgreen S.A.C."),
+    cliente=xbuilder.Cliente(
+        tipo_documento_identidad="6",  # RUC (Catalog6)
+        numero_documento_identidad="12121212121",
+        nombre="Carlos Feria",
+    ),
+    detalles=[xbuilder.Detalle(descripcion="Item", cantidad=Decimal(2), precio=Decimal("100.00"))],
+)
+xml = xbuilder.build(invoice)  # fecha de hoy en Perú y tasas vigentes
+
+# Firmar
+key = SigningKey.from_pkcs12(Path("certificado.pfx").read_bytes(), "password")
+signed = sign(xml.encode(), key)
+
+# Enviar
+sender = FileSender(URLs.beta(), Credentials(username="12345678959MODDATOS", password="MODDATOS"))
+result = sender.send_file(signed)
+if result.cdr:
+    # ACEPTADO La Factura numero F001-1, ha sido aceptada
+    print(result.cdr.status, result.cdr.description)
+elif result.ticket:  # resúmenes, bajas y guías: consulta el ticket después
+    print(sender.verify_file_ticket(signed, result.ticket))
+else:
+    print(result.fault.status, result.fault.code, result.fault.message)
+```
+
+- **Crear**: facturas, boletas, notas de crédito y débito, guías de remisión, percepciones,
+  retenciones, resúmenes diarios, bajas y reversiones. `xbuilder.enrich` devuelve el documento con
+  los valores calculados (impuestos, totales, leyendas) en lugar del XML. `xbuilder.Defaults`
+  cambia la fecha de emisión o las tasas.
+- **Firmar**: `SigningKey.from_pem(llave_privada, certificado)` para archivos PEM. `sign` devuelve
+  texto si recibe texto y bytes si recibe bytes.
+- **Enviar**: `send_pack` envía varias facturas en un zip. `SunatClient` también tiene los
+  servicios de consulta y validación (`get_status`, `get_status_cdr`, `validate_cdp`,
+  `validate_file`). Si envías por varias empresas, comparte un `SunatClient` (conexiones y tokens)
+  entre sus `FileSender`.
+- **Guías de remisión**: usan `URLs.production()` (la SUNAT no tiene beta para ellas) y el
+  `client_id`/`client_secret` de la API.
+- **Errores**: los del núcleo lanzan `xhandler.XhandlerError` con un `kind`: `ErrorKind.VALIDATION`
+  (p. ej. un código de catálogo inválido), `ErrorKind.INVALID_KEY`, `ErrorKind.RESPONSE`... Los
+  rechazos de la SUNAT no son errores: llegan en `result.fault`.
+
+## Contribuir
+
+Revisa [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Licencia
+
+[Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)

xhandler-6.0.0a1.dist-info/RECORD

@@ -0,0 +1,13 @@
+xhandler/__init__.py,sha256=dgZM4-fSIja7qJpqd0JuBwR1fd2ZEdnpI3qG9s0do3s,370
+xhandler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xhandler/_core/VERSION,sha256=9IGx4GPPQn13Mbt2yoHgxYIXZkqPCFEx32Klaz7caSE,14
+xhandler/_core/__init__.py,sha256=751IUS3fx0T3JPeb7d5jfQA2UC9QkxANSArqfjfxyiY,5115
+xhandler/_core/xhandler.wasm,sha256=DSiAXV0mWEebxT1pvV6xzFJSkfzq6DsORXb4h71O8kU,4371842
+xhandler/xbuilder/__init__.py,sha256=GhZboB6JB_Karx0hr2v8QSoYPz_4X1oW7RdkjfbRT1w,1805
+xhandler/xbuilder/models.py,sha256=PmYjkUN4VHRKNUiLE9i9YnR6gsDh2xaYJ2sLHxFyNRg,24783
+xhandler/xsender/__init__.py,sha256=2C3clKlLfMEPOxpF2ATmaPfWAmeWu_UelrWY7ZO-Gxo,10216
+xhandler/xsender/models.py,sha256=Aj_IppTn3-RSF3rrk5IYRYnYDDm6vibdXcymPCI_bKE,5636
+xhandler/xsigner/__init__.py,sha256=r6hFV0WFmvU1J59g0CkXH6Jx8niEyXWM-O6i0OsvKsE,1791
+xhandler-6.0.0a1.dist-info/METADATA,sha256=wdjFfxb4XMGOXvZFRzLl817eLMe6gdOKsdaO3gd7Y18,3745
+xhandler-6.0.0a1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+xhandler-6.0.0a1.dist-info/RECORD,,

xhandler-6.0.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any