Extract dimension calc, add pytest, fix aspect ratio rounding

- Extract compute_output_dimensions() into dimensions.py with comment
explaining why round-to-8 is used instead of floor
- Add tests/test_dimensions.py (23 cases) covering multiples-of-8,
long-side pinning, aspect ratio error bound, and round-beats-floor
- Add pytest to requirements.txt
- app.py delegates to compute_output_dimensions()

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -29,6 +29,7 @@ print("Using device:", device)
 torch.backends.cuda.matmul.allow_tf32 = True
 torch.backends.cudnn.allow_tf32 = True
 
+from dimensions import compute_output_dimensions
 from diffusers import FlowMatchEulerDiscreteScheduler
 from qwenimage.pipeline_qwenimage_edit_plus import QwenImageEditPlusPipeline
 from qwenimage.transformer_qwenimage import QwenImageTransformer2DModel
@@ -154,13 +155,7 @@ def update_dimensions_on_upload(image):
     if image is None:
         return MAX_OUTPUT_DIM, MAX_OUTPUT_DIM
     w, h = image.size
-    if w > h:
-        nw = MAX_OUTPUT_DIM
-        nh = int(nw * h / w)
-    else:
-        nh = MAX_OUTPUT_DIM
-        nw = int(nh * w / h)
-    return (nw // 8) * 8, (nh // 8) * 8
+    return compute_output_dimensions(w, h)
 
 
 @spaces.GPU

dimensions.py

@@ -0,0 +1,15 @@
+MAX_OUTPUT_DIM = 2048
+
+
+def compute_output_dimensions(w, h, max_dim=MAX_OUTPUT_DIM):
+    # Pin the long side to max_dim and scale the short side proportionally.
+    # We snap to the nearest multiple of 8 (not floor) to minimise aspect ratio
+    # distortion: floor always undershoots, whereas rounding keeps the error
+    # within ±4px, which halves the worst-case ratio deviation.
+    if w > h:
+        nw = max_dim
+        nh = round(nw * h / w / 8) * 8
+    else:
+        nh = max_dim
+        nw = round(nh * w / h / 8) * 8
+    return nw, nh

requirements.txt

@@ -10,6 +10,7 @@ kernels
 spaces
 hf_xet
 gradio
+pytest
 torch
 numpy
 av

tests/conftest.py

@@ -0,0 +1,4 @@
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

tests/test_dimensions.py

@@ -0,0 +1,99 @@
+import pytest
+from dimensions import compute_output_dimensions, MAX_OUTPUT_DIM
+
+
+def aspect_ratio_error(w_in, h_in, w_out, h_out):
+    return abs(w_out / h_out - w_in / h_in)
+
+
+# --- output constraints ---
+
+@pytest.mark.parametrize("w, h", [
+    (1920, 1080),
+    (1080, 1920),
+    (1000, 1000),
+    (1000, 381),
+    (381, 1000),
+    (3840, 2160),
+    (1, 1),
+])
+def test_output_is_multiple_of_8(w, h):
+    nw, nh = compute_output_dimensions(w, h)
+    assert nw % 8 == 0
+    assert nh % 8 == 0
+
+
+@pytest.mark.parametrize("w, h", [
+    (1920, 1080),
+    (1000, 381),
+    (3840, 2160),
+])
+def test_landscape_long_side_is_max_dim(w, h):
+    nw, nh = compute_output_dimensions(w, h)
+    assert nw == MAX_OUTPUT_DIM
+
+
+@pytest.mark.parametrize("w, h", [
+    (1080, 1920),
+    (381, 1000),
+])
+def test_portrait_long_side_is_max_dim(w, h):
+    nw, nh = compute_output_dimensions(w, h)
+    assert nh == MAX_OUTPUT_DIM
+
+
+def test_square_stays_square():
+    nw, nh = compute_output_dimensions(1000, 1000)
+    assert nw == nh == MAX_OUTPUT_DIM
+
+
+# --- aspect ratio preservation ---
+
+@pytest.mark.parametrize("w, h", [
+    (1920, 1080),
+    (1080, 1920),
+    (1000, 381),
+    (381, 1000),
+    (3840, 2160),
+])
+def test_aspect_ratio_error_within_one_step(w, h):
+    nw, nh = compute_output_dimensions(w, h)
+    # Rounding to nearest-8 introduces at most 4px error on the short side.
+    # Ratio error = long * delta_short / short^2, so max = long * 4 / short^2.
+    max_allowed = max(nw, nh) * 4 / min(nw, nh) ** 2
+    assert aspect_ratio_error(w, h, nw, nh) <= max_allowed
+
+
+@pytest.mark.parametrize("w, h", [
+    (1000, 381),
+    (381, 1000),
+])
+def test_round_beats_floor_on_tricky_ratio(w, h):
+    """Cases where floor-to-8 and round-to-8 disagree: round must be at least as accurate."""
+    nw, nh = compute_output_dimensions(w, h)
+    # Reproduce floor-to-8 result for comparison
+    if w > h:
+        nh_floor = (int(MAX_OUTPUT_DIM * h / w) // 8) * 8
+        nw_floor = MAX_OUTPUT_DIM
+    else:
+        nw_floor = (int(MAX_OUTPUT_DIM * w / h) // 8) * 8
+        nh_floor = MAX_OUTPUT_DIM
+    assert aspect_ratio_error(w, h, nw, nh) <= aspect_ratio_error(w, h, nw_floor, nh_floor)
+
+
+# --- exact known values ---
+
+def test_16_9_landscape():
+    nw, nh = compute_output_dimensions(1920, 1080)
+    assert (nw, nh) == (2048, 1152)
+
+
+def test_16_9_portrait():
+    nw, nh = compute_output_dimensions(1080, 1920)
+    assert (nw, nh) == (1152, 2048)
+
+
+def test_custom_max_dim():
+    nw, nh = compute_output_dimensions(1920, 1080, max_dim=1024)
+    assert nw == 1024
+    assert nh % 8 == 0