fix: apply review cleanups (comment, isnan guard, stronger cap/swap/temp tests)

Low-severity polish from the adversarial review of the hardening commits; the
core logic was verified correct, so this is comment/test/robustness tightening.

- _normalize_params: gate math.isnan behind isinstance(value, float) so a huge
out-of-double-range int (direct callers only; Gradio bounds reject it) falls
through to the clamps instead of raising OverflowError. Docstring notes NaN is
live only for temperature (precision=0 rejects NaN for the integer fields).
- Fix the tolerance-gate comment: 0.1*9 is exactly 0.9, not 0.999… — reword to a
value that actually drifts near 1.0.
- Strengthen tests: pin the exact trimmed token count (90 == 720//8) instead of
a `<= constant` tautology; add a non-divisor beam case (1024,7 -> 102) to lock
floor-division; bracket the temperature tolerance with a 1.0+1e-3 sampling
case; add an RTL-source swap orientation (exercises output_rtl's True branch).

71 fast pass; counts unchanged (tests strengthened in place).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app.py

@@ -122,10 +122,15 @@ def _normalize_params(
     direct, and the ZeroGPU duration callable — goes through. ``None``/``NaN`` fall back to the
     defaults; values are clamped to the ranges the Advanced ``gr.Number`` controls advertise; and
     the token×beam product is capped (``_MAX_TOKEN_BEAM_PRODUCT``) so generation stays within the
-    GPU time it reserved."""
+    GPU time it reserved. ``None`` reaches here for all three params, but ``NaN`` only for
+    temperature — ``gr.Number``'s ``precision=0`` rejects ``NaN`` for the integer fields before
+    ``translate()`` runs, so their ``NaN`` handling is defensive (covering direct callers and the
+    duration callable)."""
 
     def _num(value: float | None, default: float) -> float:
-        return default if value is None or math.isnan(value) else value
+        # NaN can only be a float; gate the isnan on isinstance so a huge int (which math.isnan
+        # would OverflowError converting to a double) falls through to the clamps instead.
+        return default if value is None or (isinstance(value, float) and math.isnan(value)) else value
 
     beams = int(max(1, min(8, _num(num_beams, 1))))
     tokens = int(max(1, min(1024, _num(max_new_tokens, 512))))
@@ -171,7 +176,8 @@ def translate(
     # public submit path passes gr.Number values uncast, and a cleared field arrives as
     # None/NaN, so coerce and clamp before use (the duration callable normalizes identically).
     max_new_tokens, num_beams, temperature = _normalize_params(max_new_tokens, num_beams, temperature)
-    # Compare with a tolerance so float spinner drift (e.g. 0.1*9 = 0.999…) doesn't trip sampling.
+    # Compare with a tolerance so float spinner drift (repeated 0.1 steps land on values like
+    # 0.9999999999999999, not a clean 1.0) doesn't trip sampling.
     sampling = abs(temperature - 1.0) > 1e-6
 
     tokenizer = _load_tokenizer()

tests/test_app.py

@@ -202,19 +202,19 @@ def test_translate_forwards_generation_params():
 def test_translate_applies_token_beam_cap():
     """A high token×beam request must reach model.generate with the capped token count (not the
     raw value) so generation stays within its GPU reservation."""
-    import app
-
     kwargs, _ = _run_translate("Hello", "French (fr)", max_new_tokens=1024, num_beams=8)
     assert kwargs["num_beams"] == 8
-    assert kwargs["max_new_tokens"] * kwargs["num_beams"] <= app._MAX_TOKEN_BEAM_PRODUCT
+    assert kwargs["max_new_tokens"] == 90  # 720 // 8 — exact trim, not just within budget
 
 
 def test_translate_tolerates_near_default_temperature():
-    """A temperature within ~1e-6 of 1.0 (float spinner drift) stays greedy; a clearly different
-    value still samples."""
+    """A temperature within ~1e-6 of 1.0 (float spinner drift) stays greedy; values outside the
+    band (either side) still sample, bracketing the tolerance."""
     near_one, _ = _run_translate("Hello", "French (fr)", temperature=1.0 - 1e-9)
+    just_outside, _ = _run_translate("Hello", "French (fr)", temperature=1.0 + 1e-3)
     sampled, _ = _run_translate("Hello", "French (fr)", temperature=0.7)
     assert "do_sample" not in near_one, "near-1.0 temperature should stay greedy"
+    assert just_outside.get("do_sample") is True, "1e-3 outside the band should sample"
     assert sampled.get("do_sample") is True
 
 
@@ -238,8 +238,9 @@ def test_normalize_params_caps_token_beam_product():
     reservation _estimate_duration grants (the worst case must not outlive its 120s budget)."""
     import app
 
-    mnt, beams, _ = app._normalize_params(1024, 8, 1.0)
-    assert beams == 8 and mnt * beams <= app._MAX_TOKEN_BEAM_PRODUCT
+    assert app._normalize_params(1024, 8, 1.0) == (90, 8, 1.0)  # 720 // 8 — exact trimmed value
+    # non-divisor beam width: floor division leaves the product strictly below the budget
+    assert app._normalize_params(1024, 7, 1.0) == (102, 7, 1.0)  # 720 // 7 = 102; 102*7 = 714 < 720
     # the duration estimate, built on the same normalization, never exceeds its 120s cap
     assert app._estimate_duration("hi", "French (fr)", 1024, 8, 1.0) <= 120
     # comfortably-small products are left untouched
@@ -293,10 +294,15 @@ def test_swap_flips_rtl_to_follow_text():
         new_source, new_target, input_update, output_update = app._swap_languages(
             "English (en)", "Arabic (ar)", "Hello", "RTL-text"
         )
+        # symmetric orientation: RTL source -> the output box (now holding the source) goes RTL
+        rtl_src = app._swap_languages("Arabic (ar)", "English (en)", "RTL-src", "english-tgt")
     assert (new_source, new_target) == ("Arabic (ar)", "English (en)")
     # input box now holds the Arabic translation -> RTL; output box holds the English source -> LTR
     assert input_update == gr.update(value="RTL-text", rtl=True, text_align="right")
     assert output_update == gr.update(value="Hello", rtl=False, text_align="left")
+    # RTL source: input gets the LTR translation (LTR), output gets the RTL source (RTL)
+    assert rtl_src[2] == gr.update(value="english-tgt", rtl=False, text_align="left")
+    assert rtl_src[3] == gr.update(value="RTL-src", rtl=True, text_align="right")
 
 
 def test_translate_with_loading_flips_rtl_for_rtl_target():