pylibjxl

Fast Python bindings for JPEG XL (libjxl) and JPEG (libjpeg-turbo)

pylibjxl provides efficient, high-performance Python bindings for libjxl and libjpeg-turbo. Built with nanobind, it features GIL-free encoding/decoding and native async support for maximum throughput.

✨ Key Features

🚀 High Performance — C++ core releases the GIL during heavy computation.
📦 Metadata Excellence — Full support for EXIF, XMP, and JUMBF metadata.
⚡ Async-First — Native asyncio integration for non-blocking I/O.
🖼️ NumPy Native — Directly encode from and decode to ndarray (RGB/RGBA).
🔄 Lossless JPEG Transcoding — Bit-perfect JPEG ↔ JXL roundtrips.
🎯 Thread-Safe — RunnerPool enables true concurrent encode/decode with controlled resources.

🛠️ Installation

Install from PyPI

# Recommended: Using uv
uv pip install pylibjxl

# Or via standard pip
pip install pylibjxl

Install from Source

uv pip install git+https://github.com/twn39/pylibjxl.git --recursive

Quick Start

🖼️ Basic In-Memory Operations

import numpy as np
import pylibjxl

# Create a test image (Height, Width, Channels)
image = np.random.randint(0, 256, (512, 512, 3), dtype=np.uint8)

# Encode to JXL bytes
data = pylibjxl.encode(image, effort=7, distance=1.0)

# Decode back to NumPy array
decoded = pylibjxl.decode(data)

💾 File I/O & Metadata

pylibjxl handles EXIF and XMP metadata seamlessly.

# Write an image with EXIF metadata
exif_data = b"Raw EXIF bytes..."
pylibjxl.write("output.jxl", image, effort=9, exif=exif_data)

# Read image and its metadata
img, meta = pylibjxl.read("output.jxl", metadata=True)
print(f"Loaded image shape: {img.shape}")
print(f"EXIF size: {len(meta.get('exif', b''))} bytes")

🔄 Lossless JPEG Transcoding

Reduce JPEG file size by ~20% without losing a single bit of information. The resulting .jxl can be restored to the exact original .jpg.

# Convert JPEG to JXL losslessly
pylibjxl.convert_jpeg_to_jxl("input.jpg", "input.jxl")

# Restore the bit-identical original JPEG
pylibjxl.convert_jxl_to_jpeg("input.jxl", "restored.jpg")

⚡ Async Support

High-performance non-blocking I/O for web servers and data pipelines.

import asyncio

async def main():
    # Async encoding
    data = await pylibjxl.encode_async(image, distance=0.0)
    
    # Async file reading
    img = await pylibjxl.read_async("input.jxl")

asyncio.run(main())

🏗️ Batch Processing (Context Manager)

Using the JXL context manager maintains a persistent thread pool, providing a significant speedup for batch operations.

# High-performance batch conversion
with pylibjxl.JXL(effort=7) as jxl:
    for i in range(100):
        img = jxl.read(f"input_{i}.jxl")
        # Process and save as high-quality JPEG
        jxl.write_jpeg(f"output_{i}.jpg", img, quality=95)

🚀 FastAPI / Asyncio Integration

pylibjxl is designed for high-concurrency web servers. By using a shared AsyncJXL instance, you can limit the total number of native worker threads, preventing resource exhaustion under load.

from fastapi import FastAPI, UploadFile
import pylibjxl
import numpy as np

app = FastAPI()

# Create a shared async codec with a RunnerPool.
# The pool holds N independent runners (N = CPU cores by default).
# Concurrent requests each acquire their own runner — true parallel encoding!
runner = pylibjxl.AsyncJXL()

@app.on_event("startup")
async def startup():
    runner.enter()

@app.on_event("shutdown")
async def shutdown():
    runner.close()

@app.post("/encode")
async def encode_image(file: UploadFile):
    # Read bytes (non-blocking)
    content = await file.read()
    
    # Multiple requests run truly in parallel — each gets its own runner from the pool.
    # No global lock, no CPU oversubscription.
    image = await runner.decode_jpeg_async(content)
    
    # Process image...
    
    # Encode back to JXL
    return await runner.encode_async(image, effort=5)

📈 Performance & Stability

pylibjxl is engineered for high-performance production environments where throughput and responsiveness are critical.

🚀 Key Benchmarks

Tested on Apple M2 Pro (1440x960 RGB Image)

JXL Encoding (pylibjxl vs. pillow-jxl-plugin)

Both libraries are tested using the same effort parameter (1-11) to ensure a fair comparison. Higher effort results in better compression but slower encoding.

Effort Level	pylibjxl	pillow-jxl-plugin	Scaling
Effort 1 (Fastest)	~20.7 ms	~13.2 ms	Low latency
Effort 4 (Balanced)	~39.2 ms	~21.9 ms	Optimal mix
Effort 7 (Default)	~275.1 ms	~94.0 ms	Best compression

Decoding Performance

Format	pylibjxl	pillow-jxl-plugin / PIL	Improvement
JXL Decode	24.5 ms	11.0 ms
JPEG Decode	17.0 ms	18.4 ms	~8% Faster

🛠️ Architecture Highlights

GIL-Free Execution: The C++ core releases Python's Global Interpreter Lock (GIL) during all heavy encoding and decoding tasks. This allows for true multi-core parallelism when using Python's threading or concurrent.futures.
RunnerPool: A thread-safe pool of JxlResizableParallelRunner instances. Each concurrent operation acquires its own runner from the pool, enabling true parallel encode/decode without any global lock. Pool size defaults to hardware_concurrency().
Native Async Support: Unlike standard Pillow-based plugins, pylibjxl provides native asyncio bindings. This prevents event-loop blocking in high-concurrency web servers (e.g., FastAPI, Tornado).
Zero Memory Leaks: Extensive stability testing (500+ consecutive rounds) shows that memory usage stabilizes after initial warm-up, with no ongoing growth.
Optimized Memory Management:
- Adaptive Buffering: Employs an intelligent buffer growth strategy during encoding to minimize reallocations while handling high-entropy images.
- RunnerPool Reuse: Both JXL/AsyncJXL context managers and free functions reuse pooled runners, eliminating the overhead of creating/destroying thread pools per call.

Concurrent Throughput

Tested on Apple M2 Pro (1440x960 RGB Image, effort=3)

Concurrent Tasks	Encode (ops/sec)	Decode (ops/sec)
1	18	22
4	66	89
8	109	148
16	104	164

[!TIP] Both free functions (pylibjxl.encode_async) and context managers (AsyncJXL.encode_async) now support true parallel execution via RunnerPool. Use context managers for batch workflows and free functions for ad-hoc operations.

📂 API Reference

🖼️ JXL In-Memory Operations

`encode(input, effort=7, distance=1.0, lossless=False, decoding_speed=0, *, exif=None, xmp=None, jumbf=None) -> bytes`

`async encode_async(...) -> bytes`

Encodes a NumPy array into JPEG XL format.

Parameter	Type	Default	Description
`input`	`ndarray`	required	uint8 array of shape `(H, W, 3)` or `(H, W, 4)`
`effort`	`int`	`7`	Speed/size tradeoff `[1-11]`. 1=fastest, 11=best compression.
`distance`	`float`	`1.0`	Perceptual quality `[0.0-25.0]`. 0.0=lossless, 1.0=visually lossless.
`lossless`	`bool`	`False`	If `True`, enables mathematical lossless mode.
`decoding_speed`	`int`	`0`	Decoding speed tier `[0-4]`. 0=default, 4=fastest decoding.
`exif`	`bytes`	`None`	Optional raw EXIF metadata.
`xmp`	`bytes`	`None`	Optional raw XMP (XML) metadata.
`jumbf`	`bytes`	`None`	Optional raw JUMBF metadata.

# Synchronous encoding
data = pylibjxl.encode(image, effort=9, lossless=True)

# Asynchronous encoding
data = await pylibjxl.encode_async(image, distance=0.5)

`decode(data, *, metadata=False) -> ndarray | tuple[ndarray, dict]`

`async decode_async(...) -> ndarray | tuple[ndarray, dict]`

Decodes JPEG XL bytes back into a NumPy array.

Parameter	Type	Default	Description
`data`	`bytes`	required	JPEG XL encoded bytes.
`metadata`	`bool`	`False`	If `True`, returns a tuple including a metadata dictionary.

# Basic decode
img = pylibjxl.decode(jxl_bytes)

# Decode with metadata
img, meta = await pylibjxl.decode_async(jxl_bytes, metadata=True)
print(f"EXIF size: {len(meta.get('exif', b''))} bytes")

💾 JXL File I/O

`read(path, *, metadata=False)` / `async read_async(...)`

Reads a .jxl file from disk and decodes it.

Parameter	Type	Default	Description
`path`	`str	Path`	required
`metadata`	`bool`	`False`	Whether to return metadata alongside the image.

img = pylibjxl.read("input.jxl")
img, meta = await pylibjxl.read_async("input.jxl", metadata=True)

`write(path, image, ...)` / `async write_async(...)`

Encodes a NumPy array and writes it directly to a .jxl file.

Parameter	Type	Default	Description
`path`	`str	Path`	required
`image`	`ndarray`	required	The image data to encode.
`...`			Supports all parameters from `encode()`.

pylibjxl.write("output.jxl", image, effort=7, distance=1.0)
await pylibjxl.write_async("output.jxl", image, lossless=True)

📷 JPEG Support (libjpeg-turbo)

`encode_jpeg(input, quality=95) -> bytes` / `async encode_jpeg_async(...)`

Encodes a NumPy array to JPEG bytes using high-speed libjpeg-turbo.

Parameter	Type	Default	Description
`input`	`ndarray`	required	uint8 array of shape `(H, W, 3)`.
`quality`	`int`	`95`	JPEG quality factor `[1-100]`.

jpeg_bytes = pylibjxl.encode_jpeg(image, quality=90)

`decode_jpeg(data) -> ndarray` / `async decode_jpeg_async(...)`

Decodes JPEG bytes to a NumPy RGB array.

Parameter	Type	Default	Description
`data`	`bytes`	required	JPEG encoded bytes.

image = pylibjxl.decode_jpeg(jpeg_bytes)

`read_jpeg(path)` / `write_jpeg(path, image, quality=95)`

Stand-alone JPEG file I/O operations using libjpeg-turbo.

img = pylibjxl.read_jpeg("photo.jpg")
pylibjxl.write_jpeg("output.jpg", img, quality=85)

🔄 Lossless Transcoding (JPEG ↔ JXL)

`jpeg_to_jxl(data, effort=7) -> bytes` / `async jpeg_to_jxl_async(...)`

Transcodes raw JPEG bytes into a JPEG XL container losslessly.

Parameter	Type	Default	Description
`data`	`bytes`	required	Original JPEG bytes.
`effort`	`int`	`7`	Transcoding effort `[1-11]`.

jxl_data = pylibjxl.jpeg_to_jxl(jpeg_bytes)

`jxl_to_jpeg(data) -> bytes` / `async jxl_to_jpeg_async(...)`

Restores the original JPEG bytes from a transcoded JXL file.

Parameter	Type	Default	Description
`data`	`bytes`	required	Transcoded JPEG XL bytes.

original_jpeg = pylibjxl.jxl_to_jpeg(jxl_data)

`convert_jpeg_to_jxl(in_path, out_path)` / `convert_jxl_to_jpeg(...)`

File-to-file versions of the above transcoding operations.

pylibjxl.convert_jpeg_to_jxl("input.jpg", "output.jxl")
pylibjxl.convert_jxl_to_jpeg("output.jxl", "restored.jpg")

🏗️ Context Managers

`JXL(effort=7, distance=1.0, lossless=False, decoding_speed=0)`

`AsyncJXL(...)`

Sync and Async context managers that maintain a persistent thread pool.

Parameter	Type	Default	Description
`effort`	`int`	`7`	Default effort for operations.
`distance`	`float`	`1.0`	Default distance for operations.
`lossless`	`bool`	`False`	Default lossless mode.
`decoding_speed`	`int`	`0`	Default decoding speed tier.
`threads`	`int`	`0`	Threads per runner in the pool (0 = auto). The pool size equals CPU core count.

with pylibjxl.JXL(effort=7) as jxl:
    # Uses persistent threads for all methods
    img = jxl.read("input.jxl")
    jxl.write("output.jxl", img, distance=0.5)

ℹ️ System Information

Function	Return Type	Description
`version()`	`dict`	Returns library version (major, minor, patch).
`decoder_version()`	`int`	Returns libjxl decoder version integer.
`encoder_version()`	`int`	Returns libjxl encoder version integer.

print(f"pylibjxl version: {pylibjxl.version()}")

📜 License

BSD 3-Clause License

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

pylibjxl-0.3.8.tar.gz (59.2 MB view details)

Uploaded Feb 22, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

pylibjxl-0.3.8-cp314-cp314-win_amd64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.14Windows x86-64

pylibjxl-0.3.8-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (2.9 MB view details)

Uploaded Feb 22, 2026 CPython 3.14manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

pylibjxl-0.3.8-cp314-cp314-macosx_14_0_x86_64.whl (2.6 MB view details)

Uploaded Feb 22, 2026 CPython 3.14macOS 14.0+ x86-64

pylibjxl-0.3.8-cp314-cp314-macosx_14_0_arm64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.14macOS 14.0+ ARM64

pylibjxl-0.3.8-cp313-cp313-win_amd64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.13Windows x86-64

pylibjxl-0.3.8-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (2.9 MB view details)

Uploaded Feb 22, 2026 CPython 3.13manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

pylibjxl-0.3.8-cp313-cp313-macosx_14_0_x86_64.whl (2.6 MB view details)

Uploaded Feb 22, 2026 CPython 3.13macOS 14.0+ x86-64

pylibjxl-0.3.8-cp313-cp313-macosx_14_0_arm64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.13macOS 14.0+ ARM64

pylibjxl-0.3.8-cp312-cp312-win_amd64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.12Windows x86-64

pylibjxl-0.3.8-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (2.9 MB view details)

Uploaded Feb 22, 2026 CPython 3.12manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

pylibjxl-0.3.8-cp312-cp312-macosx_14_0_x86_64.whl (2.6 MB view details)

Uploaded Feb 22, 2026 CPython 3.12macOS 14.0+ x86-64

pylibjxl-0.3.8-cp312-cp312-macosx_14_0_arm64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.12macOS 14.0+ ARM64

pylibjxl-0.3.8-cp311-cp311-win_amd64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.11Windows x86-64

pylibjxl-0.3.8-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (2.9 MB view details)

Uploaded Feb 22, 2026 CPython 3.11manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

pylibjxl-0.3.8-cp311-cp311-macosx_14_0_x86_64.whl (2.6 MB view details)

Uploaded Feb 22, 2026 CPython 3.11macOS 14.0+ x86-64

pylibjxl-0.3.8-cp311-cp311-macosx_14_0_arm64.whl (2.0 MB view details)

Uploaded Feb 22, 2026 CPython 3.11macOS 14.0+ ARM64

File details

Details for the file pylibjxl-0.3.8.tar.gz.

File metadata

Download URL: pylibjxl-0.3.8.tar.gz
Upload date: Feb 22, 2026
Size: 59.2 MB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/6.1.0 CPython/3.13.7

File hashes

Hashes for pylibjxl-0.3.8.tar.gz
Algorithm	Hash digest
SHA256	`7bfeb94b7cbbadbc9dc00bf3641e5e34b2e98b19687ce106a31ca3ec358b78e0`
MD5	`ae54a87cc4e915b68e82e17cae54b082`
BLAKE2b-256	`6c072b3ddd0bc0f178acc2ada9cb27efb680f76243d3c24cb936a69ff2f4366f`

Algorithm	Hash digest
SHA256	`cfee086ecc87be5443bb1f0e9c77ab6d4fb1de0cbd1a8260645d852b996bb82b`
MD5	`f7f609cdc462f0b559faafcd6142feaf`
BLAKE2b-256	`38a2cf9cc4caeda4f3e56379f6f1192be2c45dccd6ee00fe62e8355cdf357884`

Algorithm	Hash digest
SHA256	`66885c81ebec7efc6f6ab41db2d34d8c159998f77678c7e68d4c46b4f27932c7`
MD5	`7279dc83776057024abdfe9dc7a2303e`
BLAKE2b-256	`2ce90dd743d90935229eb4af86e0e2959f6bb74c1d4cf2772c7ae944e02b4ceb`

Algorithm	Hash digest
SHA256	`adc5d8abfd4e10eff686d053d1b01fdf4d903857e610eafcc86b6aa9c6ff7a99`
MD5	`2b3c191a296e6432da94ab0b148523bf`
BLAKE2b-256	`f39026fe8f1e0eebba008e81193cc7d3fef8d7a8446b89c1c06ce7c078968a9d`

Algorithm	Hash digest
SHA256	`488b56b8e0880642ffc37ce216563539732c95b5b5bf2f0aa6035188b9e5cc14`
MD5	`a6a67d609729473fcb5432154a4bcf7c`
BLAKE2b-256	`dcce6a9519caa7e580bb7ff745074879931ba9a6fba319c9ce191a8de54cf1dd`

Algorithm	Hash digest
SHA256	`c1fa5d68583899e03f4fbc6d43f266dbd25a22a68aa0da7c1f9083b275fbbe6d`
MD5	`f35ff69ab807615d6992c4f10230e443`
BLAKE2b-256	`970266482caa0bcc0b8c572fa7ae62630f6db0f90512af5d7308fbc214c05312`

Algorithm	Hash digest
SHA256	`f74f3c478158f35671ad256025497061158d6a2bc4820813efcd1cd37723d464`
MD5	`901caa0fbcc21aa5d8b41d133425e913`
BLAKE2b-256	`f3f07d6f910aa1f33c7448a095507677cc26f670dc7aaf5ac42b8b7c7f4fe57e`

Algorithm	Hash digest
SHA256	`2befaf39a2aa9d069884abf15ef681ba44d3e04de57ea3107bf0263546f844a3`
MD5	`721d8070aa486d48242c510c4c640157`
BLAKE2b-256	`50579fec5a39ac4dae3786a630c29ffb65ae2e1e9ad312f0f93071851512d323`

Algorithm	Hash digest
SHA256	`7b71aa02a7ce6ecf9c761dae194acd7cf53f77e274f1d4bd2de68ddf2a28d593`
MD5	`92ec77e77e874cec65e6f2f9ccecb069`
BLAKE2b-256	`71b41562ec4bd203ee213239b45e73aa38f92399c5f8a6eff34588445d92b406`

Algorithm	Hash digest
SHA256	`8c877b985aa6f283ed81453ef640cf48a3d4f61f0eb96e565113a22364603e7d`
MD5	`8fe7ede446983cb50e24e4eed6730d1e`
BLAKE2b-256	`77954304e0045ed6f3d90961aba68de8e2686118d856fabe727b19db49aec62e`

Algorithm	Hash digest
SHA256	`2c8e62e74b91543129d955ba109c43880d231733d8c101ace7e45cae20dbed3a`
MD5	`32d75cf47ba6689914b21687660f6374`
BLAKE2b-256	`1127b343d26724a1f5cdbb59a113702cb05c0a055ae5780017e2a0a53fd18774`

Algorithm	Hash digest
SHA256	`935e5eaee6266b2032bad038cbfd193763cb193a5f32370399ec9684dabe27e2`
MD5	`2916c4853494c8af65dfcf0ce568cdc1`
BLAKE2b-256	`bdc0b25979567051a1d78b67b01278ebf0f19e99d7e98da29794d562c0de18d6`

Algorithm	Hash digest
SHA256	`fe0e43c16db5dffc8e7fecc9f80ae40e35954efb596d2cea11326ec0099b2ff4`
MD5	`894768d67ebcb0fee2dec4c970a8285c`
BLAKE2b-256	`982934151bdcee99b9994a59d24394343d91f0872967c8d644559310884ad947`

Algorithm	Hash digest
SHA256	`5c3444875d94cf2081bd793ed41d2a86ae1f60248fa26af105803a16c9b303f8`
MD5	`422e160c558b5f4bef6138af23333657`
BLAKE2b-256	`ca68acc529896e6bd245c3845bd77a339125762f5d1542739c722321e9163c96`

Algorithm	Hash digest
SHA256	`30e7d210a92abcbe3d787def824e80b2449434bc154a67e50649a7579e15d4f5`
MD5	`cad201aae94463ea01b01118df02ea05`
BLAKE2b-256	`55277d7a3827b250df55fc2c0c4daf894f2a5ed6b92d92c832f4b2742722ccf3`

Algorithm	Hash digest
SHA256	`eebd35e601f5ef8f510f7ab5601cd8a1663da8b4fc5bd5596d139f51b3dd02fa`
MD5	`44a3390c4631e5dbbb69ffaeb740c45a`
BLAKE2b-256	`9ef8f87094195f9ca0c2ca8396430a5a0945222cb2ead0e38d0d4de195ced07f`

Algorithm	Hash digest
SHA256	`d5cb3232f99dddc3adf4865fc3fa2406f3e436e22c1c8f51ed6eda5366dccde9`
MD5	`59c2d5d1f49e9a831b7d3cef8574fa31`
BLAKE2b-256	`ff0712bd51e88f873842a7e071da385f62faad06298460d02487c8cde9d111bd`

pylibjxl 0.3.8

pylibjxl

✨ Key Features

🛠️ Installation

Install from PyPI

Install from Source

Quick Start

🖼️ Basic In-Memory Operations

💾 File I/O & Metadata

🔄 Lossless JPEG Transcoding

⚡ Async Support

🏗️ Batch Processing (Context Manager)

🚀 FastAPI / Asyncio Integration

📈 Performance & Stability

🚀 Key Benchmarks

JXL Encoding (pylibjxl vs. pillow-jxl-plugin)

Decoding Performance

🛠️ Architecture Highlights

Concurrent Throughput

📂 API Reference

🖼️ JXL In-Memory Operations

encode(input, effort=7, distance=1.0, lossless=False, decoding_speed=0, *, exif=None, xmp=None, jumbf=None) -> bytes

async encode_async(...) -> bytes

decode(data, *, metadata=False) -> ndarray | tuple[ndarray, dict]

async decode_async(...) -> ndarray | tuple[ndarray, dict]

💾 JXL File I/O

read(path, *, metadata=False) / async read_async(...)

write(path, image, ...) / async write_async(...)

📷 JPEG Support (libjpeg-turbo)

encode_jpeg(input, quality=95) -> bytes / async encode_jpeg_async(...)

decode_jpeg(data) -> ndarray / async decode_jpeg_async(...)

read_jpeg(path) / write_jpeg(path, image, quality=95)

🔄 Lossless Transcoding (JPEG ↔ JXL)

jpeg_to_jxl(data, effort=7) -> bytes / async jpeg_to_jxl_async(...)

jxl_to_jpeg(data) -> bytes / async jxl_to_jpeg_async(...)

convert_jpeg_to_jxl(in_path, out_path) / convert_jxl_to_jpeg(...)

🏗️ Context Managers

JXL(effort=7, distance=1.0, lossless=False, decoding_speed=0)

AsyncJXL(...)

ℹ️ System Information

📜 License

Project links

Key dates

1 maintainer

Credits

License

Requires

Tags

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

`encode(input, effort=7, distance=1.0, lossless=False, decoding_speed=0, *, exif=None, xmp=None, jumbf=None) -> bytes`

`async encode_async(...) -> bytes`

`decode(data, *, metadata=False) -> ndarray | tuple[ndarray, dict]`

`async decode_async(...) -> ndarray | tuple[ndarray, dict]`

`read(path, *, metadata=False)` / `async read_async(...)`

`write(path, image, ...)` / `async write_async(...)`

`encode_jpeg(input, quality=95) -> bytes` / `async encode_jpeg_async(...)`

`decode_jpeg(data) -> ndarray` / `async decode_jpeg_async(...)`

`read_jpeg(path)` / `write_jpeg(path, image, quality=95)`

`jpeg_to_jxl(data, effort=7) -> bytes` / `async jpeg_to_jxl_async(...)`

`jxl_to_jpeg(data) -> bytes` / `async jxl_to_jpeg_async(...)`

`convert_jpeg_to_jxl(in_path, out_path)` / `convert_jxl_to_jpeg(...)`

`JXL(effort=7, distance=1.0, lossless=False, decoding_speed=0)`

`AsyncJXL(...)`