Skip to main content

exarch

PyPI Python CI License

Memory-safe archive extraction and creation library for Python.

Important: exarch is designed as a secure replacement for vulnerable archive libraries like Python's tarfile, which has known CVEs with CVSS scores up to 9.4.

This package provides Python bindings for exarch-core, a Rust library with built-in protection against common archive vulnerabilities.

Installation

pip install exarch

Tip: Use uv pip install exarch for faster installation.

Alternative Package Managers

# Poetry
poetry add exarch

# Pipenv
pipenv install exarch

Requirements

  • Python >= 3.11

Quick Start

Extraction

import exarch

result = exarch.extract_archive("archive.tar.gz", "/output/path")
print(f"Extracted {result.files_extracted} files")

Creation

import exarch

result = exarch.create_archive("backup.tar.gz", ["src/", "Cargo.toml"])
print(f"Created archive with {result.files_added} files")

Usage

Basic Extraction

import exarch

result = exarch.extract_archive("archive.tar.gz", "/output/path")

print(f"Files extracted: {result.files_extracted}")
print(f"Bytes written: {result.bytes_written}")
print(f"Duration: {result.duration_ms}ms")

With pathlib.Path

from pathlib import Path
import exarch

archive = Path("archive.tar.gz")
output = Path("/output/path")

result = exarch.extract_archive(archive, output)

Custom Security Configuration

import exarch

config = exarch.SecurityConfig()
config = config.with_max_file_size(100 * 1024 * 1024)  # 100 MB

result = exarch.extract_archive("archive.tar.gz", "/output", config)

Verifying Payload Integrity

verify_archive checks security only by default and reports integrity_status as "SKIPPED". Opt in to decode the payload and verify checksums:

import exarch

options = exarch.VerificationOptions().with_integrity_check()  # 500 MiB budget
report = exarch.verify_archive("archive.zip", options=options)

print(report.integrity_status)  # "OK", "FAILED", "INCOMPLETE" or "SKIPPED"

Note: "INCOMPLETE" means part of the payload was not verified (budget, resource limit, solid 7z archive while allow_solid_archives is off, TAR without an end-of-archive marker); it comes with a Medium issue, so status is at least "WARNING". With the check on, a TAR entry whose content fails to decode raises InvalidArchiveError.

Archives in Memory

list_archive_bytes, verify_archive_bytes and extract_archive_to_memory take the archive as bytes or a binary file object. The format is detected from the leading bytes, or stated with format ("Tar", "TarGz", "TarBz2", "TarXz", "TarZst", "Zip", "SevenZ"). Nothing is written to disk.

import exarch

data = open("archive.tar.gz", "rb").read()

manifest = exarch.list_archive_bytes(data)
report = exarch.verify_archive_bytes(data)

result = exarch.extract_archive_to_memory(data, max_bytes=64 * 1024 * 1024)
for entry in result.entries:
    print(entry.path, entry.kind)  # "file", "directory" or "symlink"
    if entry.kind == "file":
        content = entry.data  # bytes

A file object is read from its current position. If it is seekable() every format works; otherwise only TAR (plain or compressed) can be read. An exception raised by the object propagates unchanged instead of becoming a verdict.

with open("archive.tar.gz", "rb") as f:
    manifest = exarch.list_archive_bytes(f)

Note: max_bytes caps payload plus path bytes plus 256 per entry and defaults to the config's max_total_size; exceeding it raises QuotaExceededError. path_model="portable" validates names against the strictest rules of every platform instead of this host's.

list_archive_bytes_with_progress, verify_archive_bytes_with_progress and extract_archive_to_memory_with_progress take a progress callback (path, total, current, bytes_written) as their last argument, after format; current counts from 1 and total is None for TAR. A raising callback cancels the run before the next entry and its exception is raised (with progress_callback_error = True); the result is discarded. The GIL is released while the archive is processed.

extract_archive_to_callback(data, on_entry) hands each verified entry to on_entry(entry) instead of collecting them, so memory use is one file at a time (bounded by max_file_size). A file arrives whole, after its size was verified. An exception raised by on_entry stops the extraction and is raised unchanged. A "symlink" entry's target is spelled as the archive stores it, relative to the link. A "hardlink" entry comes last and by reference: its target is the root-relative resolved path of an entry already delivered, a file or an earlier hardlink (a chain is delivered link by link). With SinkOptions(existing_files="overwrite") a path can be delivered more than once and a hardlink refers to the latest delivery; implicit parent directories are not delivered. Entries are provisional: each is delivered as soon as it is verified, so a later failure refuses the archive after earlier entries were already delivered. The gzip CRC of a .tar.gz is verified after the end-of-archive marker, so a corrupt compressed stream refuses the archive only after its entries were delivered.

sizes = {}


def on_entry(entry):
    if entry.kind == "file":
        sizes[entry.path] = len(entry.data)


report = exarch.extract_archive_to_callback(data, on_entry)

create_archive_to_bytes(sources, format) builds an archive in memory and returns a CreatedArchive with data and report:

created = exarch.create_archive_to_bytes(["src/"], "TarGz")
open("src.tar.gz", "wb").write(created.data)

Note: the whole archive is held in memory, up to about 2-3x its size at the peak, and there is no size cap. Sources must be regular files and directories; FIFOs and device files are not supported. Use create_archive for large archives.

Error Handling

import exarch

try:
    result = exarch.extract_archive("archive.tar.gz", "/output")
    print(f"Extracted {result.files_extracted} files")
except exarch.PathTraversalError as e:
    print(f"Blocked path traversal: {e}")
except exarch.ZipBombError as e:
    print(f"Zip bomb detected: {e}")
except exarch.SecurityViolationError as e:
    # e.relaxable_by names the SecurityConfig setting that would admit the entry, or None
    # e.sub_code names the refusal family, e.g. "PATH_NAME", "LINK_POLICY" or "ENCRYPTED"
    print(f"Security violation ({e.relaxable_by}, {e.sub_code}): {e}")
except exarch.InvalidArchiveError as e:
    # e.sub_code is "TAR_AMBIGUITY", "TAR_TRAILER", "ZIP_READER", "LINK_TARGET", "DUPLICATE_ENTRY", "ENTRY_NAME", "DECLARED_SIZE" or "INTEGRITY", else None
    print(f"Invalid archive ({e.sub_code}): {e}")
except exarch.ArchiveError as e:
    print(f"Extraction failed: {e}")

API Reference

extract_archive(archive_path, output_dir, config=None, options=None)

Extract an archive to the specified directory with security validation.

Parameters:

Name Type Description
archive_path str | Path Path to the archive file
output_dir str | Path Directory where files will be extracted
config SecurityConfig Optional security configuration
options ExtractionOptions Optional ExtractionOptions().with_staging("atomic") / .with_existing_files("skip" | "overwrite" | "refuse")

Returns: ExtractionReport

Attribute Type Description
files_extracted int Number of files extracted
directories_created int Number of directories created
symlinks_created int Number of symlinks created
bytes_written int Total bytes written
duration_ms int Extraction duration in milliseconds
files_skipped int Number of files skipped (e.g. duplicates)
warnings list[AnyExtractionWarning] Typed warnings (AntiItemsSkippedWarning, BackupCleanupFailedWarning, RootAccessNarrowedWarning with a reason token): branch on kind, not on message text

Raises:

Exception Description
PathTraversalError Path traversal attempt detected
SymlinkEscapeError Symlink points outside extraction directory
HardlinkEscapeError Hardlink target outside extraction directory
ZipBombError Potential zip bomb detected
QuotaExceededError Resource quota exceeded
SecurityViolationError Security policy violation
UnsupportedFormatError Archive format not supported
UnknownFormatError Archive format cannot be determined from path or magic bytes (subclass of UnsupportedFormatError)
InvalidArchiveError Archive is corrupted
IOError I/O operation failed

create_archive(output_path, sources, config=None, overwrite=True, durability="synced", format=None)

Create an archive from files and directories. The archive is staged in a temporary file next to output_path (its directory must be writable) and renamed into place when complete, so a failed creation leaves the output as it was. format states the format when the extension does not (for example "Zip" for a .whl); overwrite=False refuses any existing output.

Note: create_archive raises FileNotFoundError for missing sources, OutputExistsError (a FileExistsError subclass) when the output exists and overwrite=False, and ValueError for invalid compression levels — matching standard Python conventions. SourceNotFoundError and OutputExistsError fill errno, strerror and filename as open() does, and I/O failures carry a stable io_kind token (for example "PermissionDenied").

create_archive and create_archive_with_progress take durability="synced" (the default) or "unsynced". "synced" flushes the archive and its directory entry before returning. "unsynced" skips both, which is faster, but after a crash or power loss a replaced output can be empty or truncated and a new output can be empty, and write-back errors (network filesystems, quotas, delayed allocation) are not reported, so success does not prove the bytes reached the disk. Any other value raises InvalidConfigurationError with setting == "durability".

extract_archive_with_progress(archive_path, output_dir, config=None, options=None, progress=None)

Extract an archive with a progress callback. The GIL is released during extraction, with or without a callback; the callback takes it back for each call.

Parameters:

Name Type Description
archive_path str | Path Path to the archive file
output_dir str | Path Directory where files will be extracted
config SecurityConfig | None Optional security configuration
options ExtractionOptions | None Optional extraction options
progress Callable[[str, int, int, int], None] | None Optional progress callback: (path, total_files, current_file, bytes_written)
import exarch


def on_progress(path: str, total: int, current: int, bytes_written: int) -> None:
    print(f"[{current}/{total}] {path} ({bytes_written} bytes)")


result = exarch.extract_archive_with_progress("archive.tar.gz", "/output", progress=on_progress)

If progress raises (KeyboardInterrupt included), extraction is cancelled: it stops before the next entry and progress is not called again. What was written stays on disk, or is rolled back under an atomic staging. progress's own exception propagates unchanged, with a progress_callback_error = True marker attribute and writes plus, while the files remain on disk, files_extracted/bytes_written/files_skipped/skipped/warnings describing what was written (check the marker before treating the presence of files_extracted as a partial-extraction signal, since a genuine partial-extraction failure carries the same attribute names). If extraction failed for its own reason first, the extraction error takes priority — a raising progress can never mask a security error such as SymlinkEscapeError — and progress's exception is attached as __cause__ instead of being dropped. create_archive_with_progress behaves the same way, discarding the staged archive and attaching no counters.

SecurityConfig

Builder-style security configuration.

config = exarch.SecurityConfig()
config = config.with_max_file_size(100 * 1024 * 1024)  # 100 MB per file
config = config.with_max_total_size(1024 * 1024 * 1024)  # 1 GB total
config = config.with_max_file_count(10_000)  # Max 10k entries
config = config.with_max_compression_ratio(50.0)  # Zip bomb threshold
config = config.add_allowed_extension(".txt")  # Extension allowlist
config = config.add_allowed_extension(".md")
config.allowed_extensions = None  # allow every extension again; [] is refused
config = config.add_banned_component("__MACOSX")  # Skip components
config = config.add_include_pattern("src")  # Extract only matching entries...
config = config.add_exclude_pattern("*.tmp")  # ...except these
config = config.with_strip_components(1)  # Drop leading path components (or .with_flatten())
config = config.with_allow_solid_archives(True)  # Allow solid 7z archives
config = config.with_zip_consistency(
    "ignore"
)  # ZIP structure policy: "enforce" (default) or "ignore"
config = config.with_parallel_decode_memory(
    256 * 1024 * 1024
)  # 7z LZMA2 lookahead memory (default 128 MiB); None decodes on one thread
# Each extract/verify call may start up to 16 worker threads and hold its own
# lookahead, so concurrent calls multiply both.
config = config.with_allow_windows_reserved_names(True)  # CON, NUL, ... (refused by default)
config = config.with_max_tar_metadata_bytes(
    8 * 1024 * 1024
)  # TAR header/metadata bytes between entries (default 4 MiB)
config = config.with_max_decoder_memory(512 * 1024 * 1024)  # Decoder memory (default 256 MiB)
config = config.with_compressed_member_allowance(
    20_000
)  # Base gzip members / bzip2 streams of a compressed TAR (default 10,000)
config = config.with_max_solid_compression_ratio(
    500.0
)  # Solid 7z block ratio; needs with_allow_solid_archives first

Every setting an error names in relaxable_by has a setter. list_archive* takes options=ListOptions().with_stored_targets("read") ("skip" or "read"; the argument is required) to read the 7z link targets that a listing leaves unread by default.

Newer core values. Output tokens (kind, code, sub_code, io_kind, entry and disposition kinds, ...) are the strings exarch-core emits, so a value added to the core after your stubs were written still arrives as a plain str; an unknown report class falls back to its base class (ArchiveEntry, LinkTarget whose state is the core token, EntryDisposition, MemoryEntry, ExtractionWarning, CreationWarning) instead of raising.

Patterns. Include, exclude and CreationConfig exclude patterns share one glob grammar (matched case-sensitively on raw bytes, \ is a separator):

Pattern Meaning
* any run of bytes within one path component
? exactly one byte within one component
[a-c], [0-9] one byte from a positive ASCII class; ranges only inside 0-9, a-z, A-Z
** as a whole component: any number of components, including none (src/**/*.rs)
name a name without / matches any path component, and so the subtree below it
dir/name, target/ a pattern with a / anywhere matches from the archive root, and so its subtree

{a,b}, a leading !, a**b, negated or POSIX classes, unterminated classes and commas are refused (InvalidConfigurationError, setting is exclude_pattern, entry_include or entry_exclude).

Entry selection. Include and exclude patterns, strip_components and flatten live in SecurityConfig, so extract_archive*, list_archive* and verify_archive* apply them identically (manifest.dispositions shows where each listed entry lands, why it is skipped, or that it is refused, under the config passed to list_archive*). Order of operations: the entry name is validated, matched against the patterns on its original (pre-strip) path, stripped or flattened, and the new name is validated again. An exclude pattern wins over an include pattern, an include pattern that matches nothing fails the extraction (InvalidConfigurationError, setting == "entry_include", unmatched_patterns), and staging="atomic_replace" refuses a selection.

Security Features

The library provides built-in protection against:

Protection Description
Path traversal Blocks ../ and absolute paths
Symlink attacks Prevents symlinks escaping extraction directory
Hardlink attacks Validates hardlink targets
Zip bombs Detects high compression ratios
TAR metadata bombs Bounds GNU long-name/long-link and PAX header record reads
Permission sanitization Strips setuid/setgid bits
Size limits Enforces file and total size limits

Caution: Unlike Python's standard tarfile module, exarch applies security validation by default.

Supported Formats

Format Extensions Extract Create List Verify
TAR .tar ✅ ✅ ✅ ✅
TAR+GZIP .tar.gz, .tgz ✅ ✅ ✅ ✅
TAR+BZIP2 .tar.bz2, .tbz2 ✅ ✅ ✅ ✅
TAR+XZ .tar.xz, .txz ✅ ✅ ✅ ✅
TAR+ZSTD .tar.zst, .tzst ✅ ✅ ✅ ✅
ZIP .zip ✅ ✅ ✅ ✅
ZIP-family .jar, .war, .ear, .nar, .nbm, .apk, .aab, .ipa, .appx, .msix, .whl, .vsix, .xpi, .epub ✅ — ✅ ✅
7z .7z ✅ — ✅ ✅

Note: ZIP-family formats share the ZIP container but add extra structure (signing, checksum manifests, ordering rules) that exarch doesn't produce, so creation is rejected for those extensions. 7z creation is not yet supported. Solid and encrypted 7z archives are rejected for security reasons. A 7z archive holding a Windows reparse point is refused as a whole; a Unix S_IFLNK symlink is read and validated through the symlink policy, so it is created only with symlinks allowed, and a 7z FIFO, socket or device node is refused.

Comparison with tarfile

# UNSAFE - tarfile has known vulnerabilities (CVE-2007-4559)
import tarfile

with tarfile.open("archive.tar.gz") as tar:
    tar.extractall("/output")  # May extract outside target directory!

# SAFE - exarch validates all paths
import exarch

exarch.extract_archive("archive.tar.gz", "/output")  # Protected by default

Development

This package is built using PyO3 and maturin.

# Clone repository
git clone https://github.com/bug-ops/exarch
cd exarch/crates/exarch-python

# Build with maturin
pip install maturin
maturin develop

# Run tests
pytest tests/

License

Licensed under either of:

at your option.

Metadata

Release files for exarch 0.10.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Built distributions (wheels)

Table of built distributions (wheels) for exarch 0.10.0
File Actions
exarch-0.10.0-cp311-abi3-win_amd64.whl CPython 3.11 abi3 Windows x86-64 Details for exarch-0.10.0-cp311-abi3-win_amd64.whl
exarch-0.10.0-cp311-abi3-musllinux_1_2_x86_64.whl CPython 3.11 abi3 Linux musl 1.2+ x86-64 Details for exarch-0.10.0-cp311-abi3-musllinux_1_2_x86_64.whl
exarch-0.10.0-cp311-abi3-musllinux_1_2_aarch64.whl CPython 3.11 abi3 Linux musl 1.2+ ARM64 Details for exarch-0.10.0-cp311-abi3-musllinux_1_2_aarch64.whl
exarch-0.10.0-cp311-abi3-manylinux_2_34_x86_64.whl CPython 3.11 abi3 Linux glibc 2.34+ x86-64 Details for exarch-0.10.0-cp311-abi3-manylinux_2_34_x86_64.whl
exarch-0.10.0-cp311-abi3-manylinux_2_34_aarch64.whl CPython 3.11 abi3 Linux glibc 2.34+ ARM64 Details for exarch-0.10.0-cp311-abi3-manylinux_2_34_aarch64.whl
exarch-0.10.0-cp311-abi3-macosx_11_0_arm64.whl CPython 3.11 abi3 macOS 11.0+ ARM64 Details for exarch-0.10.0-cp311-abi3-macosx_11_0_arm64.whl
exarch-0.10.0-cp311-abi3-macosx_10_12_x86_64.whl CPython 3.11 abi3 macOS 10.12+ x86-64 Details for exarch-0.10.0-cp311-abi3-macosx_10_12_x86_64.whl

Total release size: 21.7 MB

Release files / exarch-0.10.0-cp311-abi3-win_amd64.whl

Download URL exarch-0.10.0-cp311-abi3-win_amd64.whl
Size 3.1 MB
Tags CPython 3.11 Windows x86-64 abi3
SHA-256 checksum
How to use checksums
9923cfbcaf5a42ef76bf8ba6b770d59e7ebcace678d91b5fa084e0499f897472
BLAKE2b-256 checksum
How to use checksums
14a8897a30890a7282a4ef83b4cb0686f0b615573107eedb7dcf5e9c2bc7b849
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / exarch-0.10.0-cp311-abi3-musllinux_1_2_x86_64.whl

Download URL exarch-0.10.0-cp311-abi3-musllinux_1_2_x86_64.whl
Size 3.4 MB
Tags CPython 3.11 Linux musl 1.2+ x86-64 abi3
SHA-256 checksum
How to use checksums
1d58e3bedef9302ab473548d9ea4e672ce2c88f741b1524459d23f35c77a3c46
BLAKE2b-256 checksum
How to use checksums
6949d8a16559539d979f206a0bc0a4f3596d53eb2093aced026dc518ccc80d7a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / exarch-0.10.0-cp311-abi3-musllinux_1_2_aarch64.whl

Download URL exarch-0.10.0-cp311-abi3-musllinux_1_2_aarch64.whl
Size 3.1 MB
Tags CPython 3.11 Linux musl 1.2+ ARM64 abi3
SHA-256 checksum
How to use checksums
a3bed020f45878454f7faf86d5c44be1577917b1f42ee0fa9066ac079e22f3da
BLAKE2b-256 checksum
How to use checksums
05d509e4a2cf7dcd7bfe62e40c3fc8c985de0b0ed6eba5a2f78b1e822c41cc94
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / exarch-0.10.0-cp311-abi3-manylinux_2_34_x86_64.whl

Download URL exarch-0.10.0-cp311-abi3-manylinux_2_34_x86_64.whl
Size 3.2 MB
Tags CPython 3.11 Linux glibc 2.34+ x86-64 abi3
SHA-256 checksum
How to use checksums
96a71a1667f04758a9e09b93dbc5bd0d52565a5052b614fb183c9f26dcb8acd7
BLAKE2b-256 checksum
How to use checksums
660cd82d6c700c889432c0682ec6fb85f8c178f7f1f46f1f56e7a092e8d5f33b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / exarch-0.10.0-cp311-abi3-manylinux_2_34_aarch64.whl

Download URL exarch-0.10.0-cp311-abi3-manylinux_2_34_aarch64.whl
Size 3.0 MB
Tags CPython 3.11 Linux glibc 2.34+ ARM64 abi3
SHA-256 checksum
How to use checksums
5b7ee765ecc2d39e08145da2d370059550bbf8076fe4f786905e35218b98953a
BLAKE2b-256 checksum
How to use checksums
fe29b6384b6d2c4fad59e23d7f55aece6818914f04c5cd3e4b12652b8e074a5a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / exarch-0.10.0-cp311-abi3-macosx_11_0_arm64.whl

Download URL exarch-0.10.0-cp311-abi3-macosx_11_0_arm64.whl
Size 2.8 MB
Tags CPython 3.11 abi3 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
279622483fb958d6d04ae425a5d5b76dce28db47aba07a964a5a6022fca0f785
BLAKE2b-256 checksum
How to use checksums
aef3c2b95d49eacf2750b064c4d0ab31f86a5477a653078600e7bcfea4174b2a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Release files / exarch-0.10.0-cp311-abi3-macosx_10_12_x86_64.whl

Download URL exarch-0.10.0-cp311-abi3-macosx_10_12_x86_64.whl
Size 3.0 MB
Tags CPython 3.11 abi3 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
ba8aae9e64a865ed7a26c616b31b2a3f55cb70af626458e0b7c4208d67c0812a
BLAKE2b-256 checksum
How to use checksums
411eb39c4d956dc252074382be7e674c71136595548e5d32ed964a41388b316c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

Security for exarch 0.10.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

All 7 files in this release have been uploaded with provenance metadata.

Select from 7 files

Attestation for exarch-0.10.0-cp311-abi3-win_amd64.whl

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 10, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page