[Fixed] Preserve integer precision in additionalProperties past 2^53 (#3650)

* Preserve integer precision in additionalProperties past 2^53

Avoid lossy int -> float upconversion in validate_and_convert_types when
both int and float are valid target types (e.g. additionalProperties on
every ModelNormal subclass). Without this guard, calling float() on any
integer above 2^53 silently rounds to the nearest IEEE 754 double,
losing the low bits.

Fixes #3649.

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

* Apply precision fix to model_utils.j2 template

The previous commit patched only the generated src/datadog_api_client/model_utils.py;
this commit applies the same guard to the Jinja2 template at
.generator/src/generator/templates/model_utils.j2 so the fix survives the
next regeneration via ./generate.sh.

Verified: rerunning the generator + ruff (pinned to v0.1.4 per
.pre-commit-config.yaml) produces no diff against the file from the prior
commit.

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

* pre-commit fixes

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: 3 people

.generator/src/generator/templates/model_utils.j2

@@ -1348,6 +1348,13 @@ def validate_and_convert_types(
         valid_classes_coercible = remove_uncoercible(
             valid_classes, input_value, spec_property_naming, must_convert=False
         )
+        # Preserve integer precision past 2^53: skip the (int, float) upconversion
+        # when `int` is already a valid target. Without this guard, the loop below
+        # would call `float(big_int)` for additionalProperties (whose default
+        # `additional_properties_type` contains both float and int) and silently
+        # round any integer above 2^53 to the nearest float64 representation.
+        if type(input_value) is int and int in valid_classes and float in valid_classes_coercible:
+            valid_classes_coercible = [c for c in valid_classes_coercible if c is not float]
         if valid_classes_coercible:
             return attempt_convert_item(
                 input_value,

src/datadog_api_client/model_utils.py

@@ -1364,6 +1364,13 @@ def validate_and_convert_types(
         valid_classes_coercible = remove_uncoercible(
             valid_classes, input_value, spec_property_naming, must_convert=False
         )
+        # Preserve integer precision past 2^53: skip the (int, float) upconversion
+        # when `int` is already a valid target. Without this guard, the loop below
+        # would call `float(big_int)` for additionalProperties (whose default
+        # `additional_properties_type` contains both float and int) and silently
+        # round any integer above 2^53 to the nearest float64 representation.
+        if type(input_value) is int and int in valid_classes and float in valid_classes_coercible:
+            valid_classes_coercible = [c for c in valid_classes_coercible if c is not float]
         if valid_classes_coercible:
             return attempt_convert_item(
                 input_value,

tests/test_deserialization.py

@@ -308,3 +308,34 @@ def test_get_api_test():
     path_to_item = ["received_data", "config", "steps"]
     converted_value = validate_and_convert_types(value, required_types_mixed, path_to_item, True, True, Configuration())
     assert isinstance(converted_value[0], UnparsedObject)
+
+
+def test_additional_properties_preserve_integer_precision():
+    """JSON integers above 2^53 must survive deserialization into a model's
+    additionalProperties without being silently rounded to float64."""
+    from datadog_api_client.v1.model.usage_summary_response import UsageSummaryResponse
+
+    # 2^53 + 1 — the smallest integer not exactly representable in float64.
+    edge = 9007199254740993
+    # A real byte-count value seen in /api/v1/usage/summary at large orgs.
+    realistic = 56355942906113522
+
+    body = json.dumps({"some_unknown_field": edge, "another_unknown_field": realistic})
+    config = Configuration()
+    deserialized = validate_and_convert_types(
+        json.loads(body), (UsageSummaryResponse,), ["received_data"], True, True, config
+    )
+
+    v_edge = deserialized["some_unknown_field"]
+    v_real = deserialized["another_unknown_field"]
+    assert type(v_edge) is int and v_edge == edge, f"expected int {edge}, got {type(v_edge).__name__} {v_edge!r}"
+    assert (
+        type(v_real) is int and v_real == realistic
+    ), f"expected int {realistic}, got {type(v_real).__name__} {v_real!r}"
+
+
+def test_schema_declared_float_still_upconverts_int_input():
+    """Regression guard: when the schema explicitly declares a field as float,
+    an integer JSON value must still upconvert to float."""
+    converted = validate_and_convert_types(3, (float,), ["received_data"], True, True, Configuration())
+    assert type(converted) is float and converted == 3.0