dynimg 0.1.9__tar.gz → 0.1.11__tar.gz

{dynimg-0.1.9 → dynimg-0.1.11}/Cargo.lock

@@ -630,7 +630,7 @@ dependencies = [
 
 [[package]]
 name = "dynimg"
-version = "0.1.9"
+version = "0.1.11"
 dependencies = [
  "anyhow",
  "anyrender",

{dynimg-0.1.9 → dynimg-0.1.11}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dynimg"
-version = "0.1.9"
+version = "0.1.11"
 edition = "2024"
 description = "A fast library and CLI for rendering HTML/CSS to images"
 license = "MIT"
@@ -65,4 +65,4 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 bytes = "1"
 
 [profile.release]
-lto = 'thin'
+lto = "thin"

dynimg-0.1.11/Makefile

@@ -0,0 +1,34 @@
+.PHONY: install dev test lint fmt clean build
+
+# Install Python package into local venv
+install:
+	maturin develop --release
+
+# Install in development mode (faster builds, debug symbols)
+dev:
+	maturin develop
+
+# Run tests
+test: install
+	cargo test
+	python test_wheels/test_dynimg.py
+
+# Run lints
+lint:
+	cargo clippy -- -D warnings
+	cargo fmt -- --check
+
+# Format code
+fmt:
+	cargo fmt
+
+# Clean build artifacts
+clean:
+	cargo clean
+	rm -rf dist/
+	rm -rf target/
+	rm -rf *.egg-info/
+
+# Build release wheels
+build:
+	maturin build --release

{dynimg-0.1.9 → dynimg-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynimg
-Version: 0.1.9
+Version: 0.1.11
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{dynimg-0.1.9 → dynimg-0.1.11}/examples/google-fonts.html

@@ -62,7 +62,7 @@
             <h1>Google Fonts Example</h1>
             <p>
                 This example attempts to use
-                <span class="highlight">Playfair Display</span> and
+                <span class="highlight">Playwrite IN Guides</span> and
                 <span class="highlight">Inter</span> from Google Fonts.
             </p>
             <div class="note">

{dynimg-0.1.9 → dynimg-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "dynimg"
-version = "0.1.9"
+version = "0.1.11"
 description = "A fast library for rendering HTML/CSS to images"
 readme = "README.md"
 license = { text = "MIT" }

{dynimg-0.1.9 → dynimg-0.1.11}/python/dynimg/__init__.py

@@ -32,4 +32,6 @@ __all__ = [
     "render_to_file",
 ]
 
-__version__ = "0.1.0"
+from importlib.metadata import version as _get_version
+
+__version__ = _get_version("dynimg")

{dynimg-0.1.9 → dynimg-0.1.11}/scripts/render-examples.sh

@@ -71,6 +71,7 @@ echo ""
 echo "--- Mixed Assets (requires both flags) ---"
 run_test "Without flags" false "$DYNIMG" "$EXAMPLES_DIR/mixed-assets.html" -o "$OUTPUT_DIR/mixed-no-flags.png"
 run_test "With --allow-net only" false "$DYNIMG" "$EXAMPLES_DIR/mixed-assets.html" -o "$OUTPUT_DIR/mixed-net-only.png" --allow-net
+run_test "With --allow-net only" false "$DYNIMG" "$EXAMPLES_DIR/mixed-assets.html" -o "$OUTPUT_DIR/mixed-net-only.webp" --allow-net
 run_test "With --assets only" false "$DYNIMG" "$EXAMPLES_DIR/mixed-assets.html" -o "$OUTPUT_DIR/mixed-assets-only.png" --assets "$ASSETS_DIR"
 run_test "With both flags" false "$DYNIMG" "$EXAMPLES_DIR/mixed-assets.html" -o "$OUTPUT_DIR/mixed-both-flags.png" --allow-net --assets "$ASSETS_DIR"
 run_test "With both flags" false "$DYNIMG" "$EXAMPLES_DIR/google-fonts.html" -o "$OUTPUT_DIR/google-fonts.png" --allow-net --assets "$ASSETS_DIR"
@@ -78,6 +79,7 @@ run_test "With both flags" false "$DYNIMG" "$EXAMPLES_DIR/google-fonts.html" -o
 echo ""
 echo "--- OG Image Templates ---"
 run_test "og-image.html" false "$DYNIMG" "$EXAMPLES_DIR/og-image.html" -o "$OUTPUT_DIR/og-image.png"
+run_test "og-image.html" false "$DYNIMG" "$EXAMPLES_DIR/og-image.html" -o "$OUTPUT_DIR/og-image.webp"
 run_test "social-card.html" false "$DYNIMG" "$EXAMPLES_DIR/social-card.html" -o "$OUTPUT_DIR/social-card.png"
 run_test "quote.html" false "$DYNIMG" "$EXAMPLES_DIR/quote.html" -o "$OUTPUT_DIR/quote.png"
 

{dynimg-0.1.9 → dynimg-0.1.11}/src/lib.rs

@@ -451,18 +451,22 @@ async fn render_document(
 ) -> Result<RenderedImage, Error> {
     // Resolve resource requests
     if let Some(p) = provider {
-        loop {
+        // Wait for all network requests including cascading requests.
+        // CSS stylesheets may trigger font fetches when processed, so we need
+        // multiple consecutive "empty" checks to ensure all cascading requests complete.
+        // Using 5 cycles provides safety margin for complex pages with many resources.
+        let mut consecutive_empty = 0u32;
+        const REQUIRED_EMPTY_CYCLES: u32 = 5;
+
+        while consecutive_empty < REQUIRED_EMPTY_CYCLES {
             document.resolve(0.0);
-            if p.is_empty() {
-                break;
-            }
             tokio::time::sleep(std::time::Duration::from_millis(1)).await;
-        }
 
-        // Extra resolve cycles for font registration
-        for _ in 0..3 {
-            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
-            document.resolve(0.0);
+            if p.is_empty() {
+                consecutive_empty += 1;
+            } else {
+                consecutive_empty = 0;
+            }
         }
     }
 
@@ -521,11 +525,13 @@ fn write_png(path: &Path, buffer: &[u8], width: u32, height: u32) -> Result<(),
 fn encode_png(buffer: &[u8], width: u32, height: u32) -> Result<Vec<u8>, Error> {
     const PPM: u32 = (144.0 * 39.3701) as u32;
 
-    let mut output = Vec::new();
+    // Pre-allocate output (PNG is typically 10-50% of raw size after compression)
+    let mut output = Vec::with_capacity(buffer.len() / 4);
     {
         let mut encoder = png::Encoder::new(&mut output, width, height);
         encoder.set_color(png::ColorType::Rgba);
         encoder.set_depth(png::BitDepth::Eight);
+        encoder.set_compression(png::Compression::Fast);
         encoder.set_pixel_dims(Some(png::PixelDimensions {
             xppu: PPM,
             yppu: PPM,
@@ -552,14 +558,19 @@ fn write_jpeg(
 }
 
 fn encode_jpeg(buffer: &[u8], width: u32, height: u32, quality: u8) -> Result<Vec<u8>, Error> {
-    let rgb_buffer: Vec<u8> = buffer
-        .chunks(4)
-        .flat_map(|rgba| [rgba[0], rgba[1], rgba[2]])
-        .collect();
+    // Pre-allocate RGB buffer (3 bytes per pixel instead of 4)
+    let pixel_count = (width * height) as usize;
+    let mut rgb_buffer = Vec::with_capacity(pixel_count * 3);
+
+    // Convert RGBA to RGB in-place
+    for chunk in buffer.chunks_exact(4) {
+        rgb_buffer.extend_from_slice(&chunk[..3]);
+    }
 
     let img = image::RgbImage::from_raw(width, height, rgb_buffer).ok_or(Error::InvalidBuffer)?;
 
-    let mut output = Vec::new();
+    // Pre-allocate output (estimate ~10% of raw size for compressed JPEG)
+    let mut output = Vec::with_capacity(pixel_count / 10);
     let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut output, quality);
     encoder.encode_image(&img)?;
 
@@ -574,6 +585,10 @@ fn write_webp_lossless(path: &Path, buffer: &[u8], width: u32, height: u32) -> R
 
 fn encode_webp_lossless(buffer: &[u8], width: u32, height: u32) -> Vec<u8> {
     let encoder = webp::Encoder::from_rgba(buffer, width, height);
-    let webp_data = encoder.encode_lossless();
+    let mut config = webp::WebPConfig::new().unwrap();
+    config.lossless = 1;
+    config.quality = 75.0;
+    config.method = 0; // 0=fastest, 6=slowest (default)
+    let webp_data = encoder.encode_advanced(&config).unwrap();
     webp_data.to_vec()
 }

{dynimg-0.1.9 → dynimg-0.1.11}/test_wheels/.gitignore

@@ -2,3 +2,6 @@
 *.whl
 .venv/
 test_output.*
+*.jpg
+*.webp
+*.png

{dynimg-0.1.9 → dynimg-0.1.11}/test_wheels/test_dynimg.py

@@ -2,6 +2,20 @@
 """Test script for dynimg wheels."""
 
 import sys
+import time
+from contextlib import contextmanager
+
+
+class RunTimer:
+    def __init__(self):
+        self.start = time.perf_counter()
+
+    @contextmanager
+    def measure(self, name):
+        t0 = time.perf_counter()
+        yield
+        t1 = time.perf_counter()
+        print(f"[{t1 - self.start:.3f}s] {name} took {(t1 - t0) * 1000:.2f}ms")
 
 
 def test_import():
@@ -17,11 +31,26 @@ def test_render_basic():
     """Test basic rendering."""
     import dynimg
 
+    timer = RunTimer()
     html = '<html><body style="background:blue;"><h1>Test</h1></body></html>'
-    img = dynimg.render(html, dynimg.RenderOptions(width=100, height=100, scale=1.0))
+
+    with timer.measure("Render"):
+        img = dynimg.render(
+            html, dynimg.RenderOptions(width=100, height=100, scale=1.0)
+        )
 
     assert img.width == 100, f"Expected width 100, got {img.width}"
     assert img.height == 100, f"Expected height 100, got {img.height}"
+
+    with timer.measure("Save PNG"):
+        img.save_png("test_basic.png")
+
+    with timer.measure("Save JPEG"):
+        img.save_jpeg("test_basic.jpg")
+
+    with timer.measure("Save WebP"):
+        img.save_webp("test_basic.webp")
+
     print(f"Basic render: {img.width}x{img.height}")
     return True
 
@@ -30,6 +59,7 @@ def test_render_gradient():
     """Test gradient rendering."""
     import dynimg
 
+    timer = RunTimer()
     html = """
     <html>
     <body style="background: linear-gradient(135deg, #667eea, #764ba2);
@@ -42,10 +72,21 @@ def test_render_gradient():
     </html>
     """
     options = dynimg.RenderOptions(width=1200, height=630, scale=2.0)
-    img = dynimg.render(html, options)
+
+    with timer.measure("Render"):
+        img = dynimg.render(html, options)
 
     assert img.width == 2400, f"Expected width 2400, got {img.width}"
     assert img.height == 1260, f"Expected height 1260, got {img.height}"
+    with timer.measure("Save WebP"):
+        img.save_webp("test_gradient.webp")
+
+    with timer.measure("Save PNG"):
+        img.save_png("test_gradient.png")
+
+    with timer.measure("Save JPEG"):
+        img.save_jpeg("test_gradient.jpg")
+
     print(f"Gradient render: {img.width}x{img.height}")
     return True
 
@@ -56,32 +97,32 @@ def test_save_formats():
 
     import dynimg
 
+    timer = RunTimer()
     html = '<html><body style="background:red; width:50px; height:50px;"></body></html>'
-    img = dynimg.render(html, dynimg.RenderOptions(width=50, height=50, scale=1.0))
+    with timer.measure("Render"):
+        img = dynimg.render(html, dynimg.RenderOptions(width=50, height=50, scale=1.0))
 
     # Test PNG
-    img.save_png("test_output.png")
+    with timer.measure("Save PNG"):
+        img.save_png("test_output.png")
     assert os.path.exists("test_output.png"), "PNG file not created"
     png_size = os.path.getsize("test_output.png")
     print(f"PNG saved: {png_size} bytes")
 
     # Test WebP
-    img.save_webp("test_output.webp")
+    with timer.measure("Save WebP"):
+        img.save_webp("test_output.webp")
     assert os.path.exists("test_output.webp"), "WebP file not created"
     webp_size = os.path.getsize("test_output.webp")
     print(f"WebP saved: {webp_size} bytes")
 
     # Test JPEG
-    img.save_jpeg("test_output.jpg", quality=90)
+    with timer.measure("Save JPEG"):
+        img.save_jpeg("test_output.jpg", quality=90)
     assert os.path.exists("test_output.jpg"), "JPEG file not created"
     jpeg_size = os.path.getsize("test_output.jpg")
     print(f"JPEG saved: {jpeg_size} bytes")
 
-    # Cleanup
-    os.remove("test_output.png")
-    os.remove("test_output.webp")
-    os.remove("test_output.jpg")
-
     return True
 
 
@@ -89,10 +130,13 @@ def test_to_bytes():
     """Test encoding to bytes."""
     import dynimg
 
+    timer = RunTimer()
     html = (
         '<html><body style="background:green; width:50px; height:50px;"></body></html>'
     )
-    img = dynimg.render(html, dynimg.RenderOptions(width=50, height=50, scale=1.0))
+
+    with timer.measure("Render"):
+        img = dynimg.render(html, dynimg.RenderOptions(width=50, height=50, scale=1.0))
 
     png_bytes = img.to_png()
     assert len(png_bytes) > 0, "PNG bytes empty"
@@ -118,21 +162,24 @@ def test_render_to_file():
 
     import dynimg
 
+    timer = RunTimer()
     html = (
         '<html><body style="background:yellow; width:50px; height:50px;"></body></html>'
     )
 
-    dynimg.render_to_file(html, "test_direct.png")
+    with timer.measure("render_to_file PNG"):
+        dynimg.render_to_file(html, "test_direct.png")
     assert os.path.exists("test_direct.png"), "Direct PNG not created"
     print(f"render_to_file PNG: {os.path.getsize('test_direct.png')} bytes")
     os.remove("test_direct.png")
 
-    dynimg.render_to_file(
-        html,
-        "test_direct.webp",
-        options=dynimg.RenderOptions(width=100, height=100, scale=1.0),
-        quality=85,
-    )
+    with timer.measure("render_to_file WebP"):
+        dynimg.render_to_file(
+            html,
+            "test_direct.webp",
+            options=dynimg.RenderOptions(width=100, height=100, scale=1.0),
+            quality=85,
+        )
     assert os.path.exists("test_direct.webp"), "Direct WebP not created"
     print(f"render_to_file WebP: {os.path.getsize('test_direct.webp')} bytes")
     os.remove("test_direct.webp")