Address review: float inputs in the gap render from shortest representation; pin 10**36 boundary

- itzzdev09 noted intword(1e50) printed int()'s binary expansion in the new
  plain-number fallback. Format float inputs from Decimal(repr(abs(value)))
  instead, giving the clean digits the caller has in mind. Note: format(v,
  '.0f') would NOT fix this - float fixed-point formatting renders the exact
  binary value too.
- Add test_intword_decillion_boundary pinning 10**36 -> plain number
  (intended change from '1000.0 decillion') and test_intword_gap_float_inputs.
- Docstring: document the float behavior + doctest for intword(1e50).

Author: Vinayak Deshmuk

src/humanize/number.py

@@ -5,6 +5,7 @@
 __lazy_modules__ = {"bisect"}
 
 import bisect
+import decimal
 
 from .i18n import _gettext as _
 from .i18n import _gettext_noop as N_
@@ -228,6 +229,9 @@ def intword(value: NumberOrString, format: str = "%.1f") -> str:
     up to decillion (33 digits) and googol (100 digits). There is no named unit
     between decillion and googol: values of 1000 decillion or more are returned as
     the plain number, except values rounding up to a googol, which become "1.0 googol".
+    Float inputs in that range are rendered from their shortest representation, so
+    `intword(1e50)` gives the clean 51-digit number rather than the float's binary
+    expansion.
 
     Examples:
         ```pycon
@@ -241,6 +245,8 @@ def intword(value: NumberOrString, format: str = "%.1f") -> str:
         '1.2 billion'
         >>> intword(8100000000000000000000000000000000)
         '8.1 decillion'
+        >>> intword(1e50)
+        '100000000000000000000000000000000000000000000000000'
         >>> intword(None)
         'None'
         >>> intword("1234000", "%0.3f")
@@ -262,6 +268,13 @@ def intword(value: NumberOrString, format: str = "%.1f") -> str:
     try:
         if not math.isfinite(float(value)):
             return _format_not_finite(float(value))
+        if isinstance(value, float):
+            # The plain-number fallback below must render from the original
+            # float's shortest representation: int(value) exposes the float's
+            # binary expansion (int(1e50) != 10**50).
+            plain_value: str | None = f"{decimal.Decimal(repr(abs(value))):f}"
+        else:
+            plain_value = None
         value = int(value)
     except (TypeError, ValueError):
         return str(value)
@@ -303,6 +316,8 @@ def intword(value: NumberOrString, format: str = "%.1f") -> str:
             ordinal += 1
             rounded_value = 1.0
         elif rounded_value >= 1000:
+            if plain_value is not None:
+                return f"{negative_prefix}{plain_value}"
             return f"{negative_prefix}{value}"
 
     singular, plural = human_powers[ordinal]

tests/test_number.py

@@ -219,6 +219,28 @@ def test_intword_decillion_googol_gap() -> None:
     assert humanize.intword(2 * 10**100) == "2.0 googol"
 
 
+def test_intword_decillion_boundary() -> None:
+    """Pin the 10**36 boundary explicitly.
+
+    1000 decillion has no named unit to carry into, so it renders as the plain
+    number (changed from "1000.0 decillion" by the #356 fix), while values just
+    below the boundary are untouched.
+    """
+    assert humanize.intword(10**33) == "1.0 decillion"
+    assert humanize.intword(9995 * 10**32) == "999.5 decillion"
+    assert humanize.intword(10**36) == "1" + "0" * 36
+    assert humanize.intword(-(10**36)) == "-1" + "0" * 36
+
+
+def test_intword_gap_float_inputs() -> None:
+    """Float inputs in the decillion..googol gap render from their shortest
+    representation, not the float's binary expansion (review on #415)."""
+    assert humanize.intword(1e50) == "1" + "0" * 50
+    assert humanize.intword(-1e50) == "-1" + "0" * 50
+    assert humanize.intword(1.5e50) == "15" + "0" * 49
+    assert humanize.intword(1e36) == "1" + "0" * 36
+
+
 @pytest.mark.parametrize(
     "test_input, expected",
     [