xhandler 6.0.0a1__tar.gz

xhandler-6.0.0a1/.github/dependabot.yml

@@ -0,0 +1,36 @@
+version: 2
+
+# Dependabot PRs are auto-approved and auto-merged once CI passes
+# (.github/workflows/auto-merge-dependabot.yaml), so the cooldown keeps freshly published
+# (possibly compromised) releases out; security updates skip it.
+# Groups take minor/patch only, so a breaking major arrives as its own PR.
+updates:
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      github-actions:
+        update-types: ["minor", "patch"]
+
+  # Maintain dependencies for pyproject.toml and uv.lock
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+      semver-major-days: 14
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      uv:
+        update-types: ["minor", "patch"]

xhandler-6.0.0a1/.github/workflows/auto-merge-dependabot.yaml

@@ -0,0 +1,17 @@
+name: Auto-merge Dependabot PRs
+
+# Approves Dependabot PRs and enables auto-merge; the merge happens only once the required
+# checks on main (lint, test) pass. See project-openubl/release-tools README.
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+    branches: [main]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  auto-merge:
+    uses: project-openubl/release-tools/.github/workflows/auto-merge-dependabot.yaml@main
+    secrets: inherit

xhandler-6.0.0a1/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches-ignore:
+      - "dependabot/**"
+  pull_request: { }
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        python: [ "3.10", "3.11", "3.12", "3.13", "3.14" ]
+        os: [ ubuntu-latest ]
+        include:
+          - { python: "3.14", os: macos-latest }
+          - { python: "3.14", os: windows-latest }
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python }}
+      # Every case of the conformance corpus, raw and through the models
+      - run: uv run pytest
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+      - run: uv run ruff check
+      - run: uv run ruff format --check
+      - run: uv run mypy src
+      # The committed core is the xhandler.wasm of the xhandler-rust release in its VERSION
+      - run: make verify-core

xhandler-6.0.0a1/.github/workflows/release.yml

@@ -0,0 +1,60 @@
+name: Release
+
+# Runs when a release is published (release-tools' release-xhandler workflow creates it after
+# syncing the core of the xhandler-rust release of the same version) and publishes to PyPI.
+# The package version is the core's (src/xhandler/_core/VERSION), e.g. 6.0.0a1 for
+# v6.0.0-alpha.1.
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Existing release tag to publish again, e.g. v6.0.0-alpha.1"
+        required: true
+        type: string
+
+# release-tools finds the run of a release by this name
+run-name: Release ${{ github.event.release.tag_name || inputs.tag }}
+
+permissions:
+  contents: read
+
+env:
+  TAG: ${{ github.event.release.tag_name || inputs.tag }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ env.TAG }}
+      - uses: astral-sh/setup-uv@v7
+      # A release carries the core released by xhandler-rust as the same version (release-tools
+      # checks it too, before tagging)
+      - run: make verify-release TAG="$TAG"
+      - run: uv run pytest
+      - run: uv build
+      - uses: actions/upload-artifact@v7.0.2
+        with:
+          name: dist
+          path: dist/
+
+  pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    # PyPI trusted publishing: the publisher on pypi.org names this repository, release.yml and
+    # this environment
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8.0.2
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@v1.14.3
+        with:
+          skip-existing: true

xhandler-6.0.0a1/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+/.dist/

xhandler-6.0.0a1/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+# Contribuir a xhandler-python
+
+## Requisitos
+
+- Python 3.10 o superior y [uv](https://docs.astral.sh/uv/).
+- Para cambiar el núcleo: un checkout de
+  [xhandler-rust](https://github.com/project-openubl/xhandler-rust) junto a este (revisa
+  [su CONTRIBUTING.md](https://github.com/project-openubl/xhandler-rust/blob/main/CONTRIBUTING.md)).
+
+## Comandos
+
+```shell
+uv sync
+make test                                          # uv run pytest
+make lint                                          # ruff check, ruff format --check, mypy
+uv run pytest tests/test_xsender.py -k token       # un archivo, los tests que coinciden con un nombre
+XHANDLER_E2E=true uv run pytest tests/test_e2e.py  # crea, firma y envía una factura a la SUNAT beta
+```
+
+## Hacer un cambio
+
+- Crear, firmar, armar las peticiones a la SUNAT y leer sus respuestas ocurre en el núcleo de
+  Rust (`src/xhandler/_core/xhandler.wasm`). Esos cambios van en xhandler-rust; luego aquí:
+
+  ```shell
+  make sync RUST_REPO=../xhandler-rust   # el núcleo de tu checkout, para desarrollar
+  make sync CORE=6.0.0-alpha.1           # el núcleo de una versión de xhandler-rust
+  ```
+
+  `make sync` copia el núcleo, los modelos (`src/xhandler/xbuilder/models.py`) y el corpus de
+  conformidad (`testdata/conformance/`). No los edites a mano. La versión del paquete es la del
+  núcleo, y una versión solo se publica con el núcleo de la versión igual de xhandler-rust:
+  `make verify-core` lo comprueba.
+- En Python está lo que necesita IO: el cliente HTTP (httpx), los reintentos y el caché de tokens
+  (`src/xhandler/xsender/`).
+- Los nombres (`FileSender`, `SunatClient`, `SigningKey`...) se mantienen iguales en Go, Python y
+  Java.
+
+## Pull requests
+
+- Título con [Conventional Commits](https://www.conventionalcommits.org/) (`feat:`, `fix:`,
+  `docs:`...); los cambios incompatibles llevan `!`.
+- Deben pasar `lint` y `test` (Python 3.10 a 3.14 en Linux; macOS y Windows).
+
+Al contribuir aceptas que tus contribuciones se distribuyan bajo la
+[Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).

xhandler-6.0.0a1/Makefile

@@ -0,0 +1,51 @@
+# The core (src/xhandler/_core/xhandler.wasm, src/xhandler/xbuilder/models.py and
+# testdata/conformance) comes from xhandler-rust:
+#
+#   make sync CORE=<version>   the xhandler-rust v<version> release
+#   make sync                  a checkout of xhandler-rust (RUST_REPO), for development
+#   make verify-core           checks that the committed core is the one released as its VERSION
+#   make verify-release TAG=v<version>
+#                              what releasing <version> requires: syncing the xhandler-rust
+#                              release of the same version changes nothing
+#
+# The package version is the core's (src/xhandler/_core/VERSION).
+RUST_REPO ?= ../xhandler-rust
+CORE ?=
+DIST := $(if $(CORE),.dist,$(RUST_REPO)/dist)
+
+SYNCED := src/xhandler/_core/xhandler.wasm src/xhandler/_core/VERSION src/xhandler/xbuilder/models.py testdata/conformance
+
+.PHONY: sync dist verify-core verify-release test lint
+
+sync: dist
+	cp $(DIST)/xhandler.wasm $(DIST)/VERSION src/xhandler/_core/
+	cp $(DIST)/models/python/models.py src/xhandler/xbuilder/models.py
+	rm -rf testdata/conformance && cp -r $(DIST)/conformance testdata/conformance
+	$(if $(CORE),rm -rf $(DIST))
+
+dist:
+ifeq ($(CORE),)
+	$(MAKE) -C $(RUST_REPO)/xhandler-wasm dist
+else
+	./hack/core.sh download $(CORE) $(DIST)
+endif
+
+verify-core:
+	./hack/core.sh verify src/xhandler/_core/xhandler.wasm src/xhandler/_core/VERSION
+
+verify-release:
+	./hack/core.sh verify-release $(TAG) src/xhandler/_core/xhandler.wasm src/xhandler/_core/VERSION
+	$(MAKE) --no-print-directory sync CORE=$(TAG:v%=%)
+	@if [ -n "$$(git status --porcelain -- $(SYNCED))" ]; then \
+		echo "error: the core differs from the xhandler-rust $(TAG) release (now synced here):" >&2; \
+		git status --short -- $(SYNCED) >&2; \
+		exit 1; \
+	fi
+
+test:
+	uv run pytest
+
+lint:
+	uv run ruff check
+	uv run ruff format --check
+	uv run mypy src

xhandler-6.0.0a1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,82 @@
+# 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/hack/core.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+# The xhandler core (xhandler.wasm, its models and the conformance corpus) comes from the
+# releases of xhandler-rust, which attach xhandler-dist-<version>.tar.gz, xhandler.wasm and
+# SHA256SUMS. This script is identical in xhandler-go, xhandler-python and xhandler-java.
+#
+#   core.sh download <version> <dir>
+#       extracts the release's dist into <dir>
+#   core.sh verify <wasm> <version-file>
+#       checks that <wasm> is the xhandler.wasm released as the version in <version-file>; a
+#       version that was never released (a core built from a checkout) only warns
+#   core.sh verify-release <tag> <wasm> <version-file>
+#       what releasing <tag> requires: the version in <version-file> is the tag's and <wasm> is
+#       the xhandler.wasm of that xhandler-rust release
+#
+# A release that can't be read (network, GitHub errors) is an error, never "not released".
+# XHANDLER_RUST_RELEASES replaces the releases URL (for tests).
+set -euo pipefail
+
+releases=${XHANDLER_RUST_RELEASES:-https://github.com/project-openubl/xhandler-rust/releases/download}
+# The versions release-tools releases
+version_re='^[0-9]+\.[0-9]+\.[0-9]+(-(alpha|beta|rc)\.[0-9]+)?$'
+
+die() {
+  echo "error: $*" >&2
+  exit 1
+}
+usage() {
+  echo "usage: core.sh download <version> <dir> | verify <wasm> <version-file> | verify-release <tag> <wasm> <version-file>" >&2
+  exit 2
+}
+sha256() { if command -v sha256sum >/dev/null; then sha256sum "$1"; else shasum -a 256 "$1"; fi | cut -d' ' -f1; }
+# The version in a VERSION file, without a Windows line ending
+read_version() { tr -d '\r\n' <"$1"; }
+
+# fetch <url> <file>: 0 when downloaded, 1 when the release has no such file (404); any other
+# failure stops the script
+fetch() {
+  local status
+  status=$(curl -sSL -o "$2" -w '%{http_code}' "$1") || die "cannot download $1"
+  case "$status" in
+  200) return 0 ;;
+  404) return 1 ;;
+  *) die "cannot download $1: HTTP $status" ;;
+  esac
+}
+
+# The checksum of <asset> in the SHA256SUMS of release <version>; empty if it was never released
+# (or not sealed yet: SHA256SUMS goes last)
+released_sha256() {
+  local sums
+  sums=$(mktemp)
+  if fetch "$releases/v$1/SHA256SUMS" "$sums"; then
+    awk -v asset="$2" '$2 == asset {print $1}' "$sums"
+  fi
+  rm -f "$sums"
+}
+
+case "${1:-}" in
+download)
+  [ $# -eq 3 ] || usage
+  version=${2#v} dir=$3 asset="xhandler-dist-${2#v}.tar.gz"
+  [[ "$version" =~ $version_re ]] || die "$2 is not a release version (X.Y.Z or X.Y.Z-alpha.N, -beta.N, -rc.N)"
+  expected=$(released_sha256 "$version" "$asset")
+  [ -n "$expected" ] || die "xhandler-rust v$version is not released (no SHA256SUMS with $asset)"
+  tmp=$(mktemp -d)
+  trap 'rm -rf "$tmp"' EXIT
+  fetch "$releases/v$version/$asset" "$tmp/$asset" || die "xhandler-rust v$version has no $asset"
+  [ "$(sha256 "$tmp/$asset")" = "$expected" ] || die "$asset does not match the SHA256SUMS of xhandler-rust v$version"
+  rm -rf "$dir" && mkdir -p "$dir" && tar -xzf "$tmp/$asset" -C "$dir"
+  ;;
+verify | verify-release)
+  if [ "$1" = verify-release ]; then
+    [ $# -eq 4 ] || usage
+    tag=$2
+    shift
+  else
+    [ $# -eq 3 ] || usage
+    tag=""
+  fi
+  wasm=$2 version=$(read_version "$3")
+  if [ -n "$tag" ]; then
+    [ "v$version" = "$tag" ] || die "the core is $version, not ${tag#v}: run make sync CORE=${tag#v}"
+    [[ "$version" =~ $version_re ]] || die "$tag is not a release version (vX.Y.Z or vX.Y.Z-alpha.N, -beta.N, -rc.N)"
+  fi
+  expected=$(released_sha256 "$version" xhandler.wasm)
+  message="the core $version ($wasm) is not an xhandler-rust release: sync a release with 'make sync CORE=<version>'"
+  if [ -z "$expected" ]; then
+    [ -z "$tag" ] || die "$message"
+    echo "warning: $message" >&2
+  elif [ "$(sha256 "$wasm")" != "$expected" ]; then
+    die "$wasm is not the xhandler.wasm of xhandler-rust v$version"
+  else
+    echo "$wasm is the xhandler.wasm of xhandler-rust v$version"
+  fi
+  ;;
+*) usage ;;
+esac

xhandler-6.0.0a1/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "xhandler"
+# The version of the core it carries (make sync), e.g. 6.0.0-alpha.1 -> 6.0.0a1
+dynamic = ["version"]
+description = "Create, sign and send the electronic documents (UBL XML) of SUNAT Peru"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.27",
+    "pydantic>=2.7",
+    "wasmtime>=30",
+]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.13",
+    "pytest>=8",
+    "ruff>=0.8",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/xhandler/_core/VERSION"
+pattern = "(?P<version>.+)"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/xhandler"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["tests"]
+
+[tool.ruff]
+line-length = 100
+extend-exclude = ["src/xhandler/xbuilder/models.py"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.mypy]
+strict = true
+plugins = ["pydantic.mypy"]

xhandler-6.0.0a1/src/xhandler/__init__.py

@@ -0,0 +1,10 @@
+"""Create, sign and send the electronic documents (UBL XML) of SUNAT Peru.
+
+The work is done by the xhandler Rust core, embedded as a WebAssembly module:
+see the ``xhandler.xbuilder``, ``xhandler.xsigner`` and ``xhandler.xsender``
+packages.
+"""
+
+from xhandler._core import CORE_VERSION, ErrorKind, XhandlerError
+
+__all__ = ["CORE_VERSION", "ErrorKind", "XhandlerError"]

xhandler-6.0.0a1/src/xhandler/_core/VERSION

@@ -0,0 +1 @@
+6.0.0-alpha.1