From 9fc7cc3b66c28de3b284be2f81a576ee6ab4e82f Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:14:21 +0000 Subject: [PATCH 1/6] test(http-client-python): expand encode/duration mock_api coverage Co-authored-by: msyyc <70930885+msyyc@users.noreply.github.com> --- .../asynctests/test_encode_duration_async.py | 54 +++++++++++++++++-- .../mock_api/azure/test_encode_duration.py | 50 +++++++++++++++-- .../asynctests/test_encode_duration_async.py | 54 +++++++++++++++++-- .../unbranded/test_encode_duration.py | 50 +++++++++++++++-- 4 files changed, 196 insertions(+), 12 deletions(-) diff --git a/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py b/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py index b79a501903b..e46ff7ac0f4 100644 --- a/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py +++ b/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py @@ -9,11 +9,20 @@ import pytest_asyncio from encode.duration.aio import DurationClient from encode.duration.models import ( - Int32SecondsDurationProperty, + DefaultDurationProperty, ISO8601DurationProperty, + Int32SecondsDurationProperty, FloatSecondsDurationProperty, - DefaultDurationProperty, + Float64SecondsDurationProperty, + Int32MillisecondsDurationProperty, + FloatMillisecondsDurationProperty, + Float64MillisecondsDurationProperty, FloatSecondsDurationArrayProperty, + FloatMillisecondsDurationArrayProperty, + Int32SecondsLargerUnitDurationProperty, + FloatSecondsLargerUnitDurationProperty, + Int32MillisecondsLargerUnitDurationProperty, + FloatMillisecondsLargerUnitDurationProperty, ) @@ -28,9 +37,17 @@ async def test_query(client: DurationClient): await client.query.default(input=datetime.timedelta(days=40)) await client.query.iso8601(input=datetime.timedelta(days=40)) await client.query.int32_seconds(input=36) + await client.query.int32_seconds_larger_unit(input=120) await client.query.int32_seconds_array(input=[36, 47]) await client.query.float_seconds(input=35.625) + await client.query.float_seconds_larger_unit(input=150.0) await client.query.float64_seconds(input=35.625) + await client.query.int32_milliseconds(input=36000) + await client.query.int32_milliseconds_larger_unit(input=180000) + await client.query.int32_milliseconds_array(input=[36000, 47000]) + await client.query.float_milliseconds(input=35625) + await client.query.float_milliseconds_larger_unit(input=210000.0) + await client.query.float64_milliseconds(input=35625) @pytest.mark.asyncio @@ -47,11 +64,34 @@ async def test_property(client: DurationClient): assert result.value == 36 result = await client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 - result = await client.property.float64_seconds(FloatSecondsDurationProperty(value=35.625)) + result = await client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 + result = await client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) + assert result.value == 36000 + result = await client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 + result = await client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 result = await client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) assert abs(result.value[0] - 35.625) < 0.0001 assert abs(result.value[1] - 46.75) < 0.0001 + result = await client.property.float_milliseconds_array( + FloatMillisecondsDurationArrayProperty(value=[35625, 46750]) + ) + assert abs(result.value[0] - 35625) < 0.0001 + assert abs(result.value[1] - 46750) < 0.0001 + result = await client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) + assert result.value == 120 + result = await client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) + assert abs(result.value - 150.0) < 0.0001 + result = await client.property.int32_milliseconds_larger_unit( + Int32MillisecondsLargerUnitDurationProperty(value=180000) + ) + assert result.value == 180000 + result = await client.property.float_milliseconds_larger_unit( + FloatMillisecondsLargerUnitDurationProperty(value=210000.0) + ) + assert abs(result.value - 210000.0) < 0.0001 @pytest.mark.asyncio @@ -60,5 +100,13 @@ async def test_header(client: DurationClient): await client.header.iso8601(duration=datetime.timedelta(days=40)) await client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) await client.header.int32_seconds(duration=36) + await client.header.int32_seconds_larger_unit(duration=120) await client.header.float_seconds(duration=35.625) + await client.header.float_seconds_larger_unit(duration=150.0) await client.header.float64_seconds(duration=35.625) + await client.header.int32_milliseconds(duration=36000) + await client.header.int32_milliseconds_larger_unit(duration=180000) + await client.header.int32_milliseconds_array(duration=[36000, 47000]) + await client.header.float_milliseconds(duration=35625) + await client.header.float_milliseconds_larger_unit(duration=210000.0) + await client.header.float64_milliseconds(duration=35625) diff --git a/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py b/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py index db0e29416f4..ba7d858e66a 100644 --- a/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py +++ b/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py @@ -8,11 +8,20 @@ import pytest from encode.duration import DurationClient from encode.duration.models import ( - Int32SecondsDurationProperty, + DefaultDurationProperty, ISO8601DurationProperty, + Int32SecondsDurationProperty, FloatSecondsDurationProperty, - DefaultDurationProperty, + Float64SecondsDurationProperty, + Int32MillisecondsDurationProperty, + FloatMillisecondsDurationProperty, + Float64MillisecondsDurationProperty, FloatSecondsDurationArrayProperty, + FloatMillisecondsDurationArrayProperty, + Int32SecondsLargerUnitDurationProperty, + FloatSecondsLargerUnitDurationProperty, + Int32MillisecondsLargerUnitDurationProperty, + FloatMillisecondsLargerUnitDurationProperty, ) @@ -26,9 +35,17 @@ def test_query(client: DurationClient): client.query.default(input=datetime.timedelta(days=40)) client.query.iso8601(input=datetime.timedelta(days=40)) client.query.int32_seconds(input=36) + client.query.int32_seconds_larger_unit(input=120) client.query.int32_seconds_array(input=[36, 47]) client.query.float_seconds(input=35.625) + client.query.float_seconds_larger_unit(input=150.0) client.query.float64_seconds(input=35.625) + client.query.int32_milliseconds(input=36000) + client.query.int32_milliseconds_larger_unit(input=180000) + client.query.int32_milliseconds_array(input=[36000, 47000]) + client.query.float_milliseconds(input=35625) + client.query.float_milliseconds_larger_unit(input=210000.0) + client.query.float64_milliseconds(input=35625) def test_property(client: DurationClient): @@ -44,11 +61,30 @@ def test_property(client: DurationClient): assert result.value == 36 result = client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 - result = client.property.float64_seconds(FloatSecondsDurationProperty(value=35.625)) + result = client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 + result = client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) + assert result.value == 36000 + result = client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 + result = client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 result = client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) assert abs(result.value[0] - 35.625) < 0.0001 assert abs(result.value[1] - 46.75) < 0.0001 + result = client.property.float_milliseconds_array(FloatMillisecondsDurationArrayProperty(value=[35625, 46750])) + assert abs(result.value[0] - 35625) < 0.0001 + assert abs(result.value[1] - 46750) < 0.0001 + result = client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) + assert result.value == 120 + result = client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) + assert abs(result.value - 150.0) < 0.0001 + result = client.property.int32_milliseconds_larger_unit(Int32MillisecondsLargerUnitDurationProperty(value=180000)) + assert result.value == 180000 + result = client.property.float_milliseconds_larger_unit( + FloatMillisecondsLargerUnitDurationProperty(value=210000.0) + ) + assert abs(result.value - 210000.0) < 0.0001 def test_header(client: DurationClient): @@ -56,5 +92,13 @@ def test_header(client: DurationClient): client.header.iso8601(duration=datetime.timedelta(days=40)) client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) client.header.int32_seconds(duration=36) + client.header.int32_seconds_larger_unit(duration=120) client.header.float_seconds(duration=35.625) + client.header.float_seconds_larger_unit(duration=150.0) client.header.float64_seconds(duration=35.625) + client.header.int32_milliseconds(duration=36000) + client.header.int32_milliseconds_larger_unit(duration=180000) + client.header.int32_milliseconds_array(duration=[36000, 47000]) + client.header.float_milliseconds(duration=35625) + client.header.float_milliseconds_larger_unit(duration=210000.0) + client.header.float64_milliseconds(duration=35625) diff --git a/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py b/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py index 2b0716dc98b..0a55860b0fa 100644 --- a/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py +++ b/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py @@ -9,11 +9,20 @@ import pytest_asyncio from encode.duration.aio import DurationClient from encode.duration.property.models import ( - Int32SecondsDurationProperty, + DefaultDurationProperty, ISO8601DurationProperty, + Int32SecondsDurationProperty, FloatSecondsDurationProperty, - DefaultDurationProperty, + Float64SecondsDurationProperty, + Int32MillisecondsDurationProperty, + FloatMillisecondsDurationProperty, + Float64MillisecondsDurationProperty, FloatSecondsDurationArrayProperty, + FloatMillisecondsDurationArrayProperty, + Int32SecondsLargerUnitDurationProperty, + FloatSecondsLargerUnitDurationProperty, + Int32MillisecondsLargerUnitDurationProperty, + FloatMillisecondsLargerUnitDurationProperty, ) @@ -28,9 +37,17 @@ async def test_query(client: DurationClient): await client.query.default(input=datetime.timedelta(days=40)) await client.query.iso8601(input=datetime.timedelta(days=40)) await client.query.int32_seconds(input=36) + await client.query.int32_seconds_larger_unit(input=120) await client.query.int32_seconds_array(input=[36, 47]) await client.query.float_seconds(input=35.625) + await client.query.float_seconds_larger_unit(input=150.0) await client.query.float64_seconds(input=35.625) + await client.query.int32_milliseconds(input=36000) + await client.query.int32_milliseconds_larger_unit(input=180000) + await client.query.int32_milliseconds_array(input=[36000, 47000]) + await client.query.float_milliseconds(input=35625) + await client.query.float_milliseconds_larger_unit(input=210000.0) + await client.query.float64_milliseconds(input=35625) @pytest.mark.asyncio @@ -47,11 +64,34 @@ async def test_property(client: DurationClient): assert result.value == 36 result = await client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 - result = await client.property.float64_seconds(FloatSecondsDurationProperty(value=35.625)) + result = await client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 + result = await client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) + assert result.value == 36000 + result = await client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 + result = await client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 result = await client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) assert abs(result.value[0] - 35.625) < 0.0001 assert abs(result.value[1] - 46.75) < 0.0001 + result = await client.property.float_milliseconds_array( + FloatMillisecondsDurationArrayProperty(value=[35625, 46750]) + ) + assert abs(result.value[0] - 35625) < 0.0001 + assert abs(result.value[1] - 46750) < 0.0001 + result = await client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) + assert result.value == 120 + result = await client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) + assert abs(result.value - 150.0) < 0.0001 + result = await client.property.int32_milliseconds_larger_unit( + Int32MillisecondsLargerUnitDurationProperty(value=180000) + ) + assert result.value == 180000 + result = await client.property.float_milliseconds_larger_unit( + FloatMillisecondsLargerUnitDurationProperty(value=210000.0) + ) + assert abs(result.value - 210000.0) < 0.0001 @pytest.mark.asyncio @@ -60,5 +100,13 @@ async def test_header(client: DurationClient): await client.header.iso8601(duration=datetime.timedelta(days=40)) await client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) await client.header.int32_seconds(duration=36) + await client.header.int32_seconds_larger_unit(duration=120) await client.header.float_seconds(duration=35.625) + await client.header.float_seconds_larger_unit(duration=150.0) await client.header.float64_seconds(duration=35.625) + await client.header.int32_milliseconds(duration=36000) + await client.header.int32_milliseconds_larger_unit(duration=180000) + await client.header.int32_milliseconds_array(duration=[36000, 47000]) + await client.header.float_milliseconds(duration=35625) + await client.header.float_milliseconds_larger_unit(duration=210000.0) + await client.header.float64_milliseconds(duration=35625) diff --git a/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py b/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py index 6025a3670da..a90992592ca 100644 --- a/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py +++ b/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py @@ -8,11 +8,20 @@ import pytest from encode.duration import DurationClient from encode.duration.property.models import ( - Int32SecondsDurationProperty, + DefaultDurationProperty, ISO8601DurationProperty, + Int32SecondsDurationProperty, FloatSecondsDurationProperty, - DefaultDurationProperty, + Float64SecondsDurationProperty, + Int32MillisecondsDurationProperty, + FloatMillisecondsDurationProperty, + Float64MillisecondsDurationProperty, FloatSecondsDurationArrayProperty, + FloatMillisecondsDurationArrayProperty, + Int32SecondsLargerUnitDurationProperty, + FloatSecondsLargerUnitDurationProperty, + Int32MillisecondsLargerUnitDurationProperty, + FloatMillisecondsLargerUnitDurationProperty, ) @@ -26,9 +35,17 @@ def test_query(client: DurationClient): client.query.default(input=datetime.timedelta(days=40)) client.query.iso8601(input=datetime.timedelta(days=40)) client.query.int32_seconds(input=36) + client.query.int32_seconds_larger_unit(input=120) client.query.int32_seconds_array(input=[36, 47]) client.query.float_seconds(input=35.625) + client.query.float_seconds_larger_unit(input=150.0) client.query.float64_seconds(input=35.625) + client.query.int32_milliseconds(input=36000) + client.query.int32_milliseconds_larger_unit(input=180000) + client.query.int32_milliseconds_array(input=[36000, 47000]) + client.query.float_milliseconds(input=35625) + client.query.float_milliseconds_larger_unit(input=210000.0) + client.query.float64_milliseconds(input=35625) def test_property(client: DurationClient): @@ -44,11 +61,30 @@ def test_property(client: DurationClient): assert result.value == 36 result = client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 - result = client.property.float64_seconds(FloatSecondsDurationProperty(value=35.625)) + result = client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) assert abs(result.value - 35.625) < 0.0001 + result = client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) + assert result.value == 36000 + result = client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 + result = client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) + assert abs(result.value - 35625) < 0.0001 result = client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) assert abs(result.value[0] - 35.625) < 0.0001 assert abs(result.value[1] - 46.75) < 0.0001 + result = client.property.float_milliseconds_array(FloatMillisecondsDurationArrayProperty(value=[35625, 46750])) + assert abs(result.value[0] - 35625) < 0.0001 + assert abs(result.value[1] - 46750) < 0.0001 + result = client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) + assert result.value == 120 + result = client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) + assert abs(result.value - 150.0) < 0.0001 + result = client.property.int32_milliseconds_larger_unit(Int32MillisecondsLargerUnitDurationProperty(value=180000)) + assert result.value == 180000 + result = client.property.float_milliseconds_larger_unit( + FloatMillisecondsLargerUnitDurationProperty(value=210000.0) + ) + assert abs(result.value - 210000.0) < 0.0001 def test_header(client: DurationClient): @@ -56,5 +92,13 @@ def test_header(client: DurationClient): client.header.iso8601(duration=datetime.timedelta(days=40)) client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) client.header.int32_seconds(duration=36) + client.header.int32_seconds_larger_unit(duration=120) client.header.float_seconds(duration=35.625) + client.header.float_seconds_larger_unit(duration=150.0) client.header.float64_seconds(duration=35.625) + client.header.int32_milliseconds(duration=36000) + client.header.int32_milliseconds_larger_unit(duration=180000) + client.header.int32_milliseconds_array(duration=[36000, 47000]) + client.header.float_milliseconds(duration=35625) + client.header.float_milliseconds_larger_unit(duration=210000.0) + client.header.float64_milliseconds(duration=35625) From dba9e6558896c677778f16ae64aa2dda119f861a Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:16:16 +0000 Subject: [PATCH 2/6] test(http-client-python): format tests and add changelog for encode/duration Co-authored-by: msyyc <70930885+msyyc@users.noreply.github.com> --- .../add-python-encode-duration-tests-2026-6-10-9-3-37.md | 7 +++++++ .../tests/mock_api/azure/test_encode_duration.py | 4 +--- .../tests/mock_api/unbranded/test_encode_duration.py | 4 +--- 3 files changed, 9 insertions(+), 6 deletions(-) create mode 100644 .chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md diff --git a/.chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md b/.chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md new file mode 100644 index 00000000000..d3bef34b0a2 --- /dev/null +++ b/.chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md @@ -0,0 +1,7 @@ +--- +changeKind: internal +packages: + - "@typespec/http-client-python" +--- + +Expand sync and async mock_api tests for the `encode/duration` Spector scenarios (milliseconds, larger-unit, and array encodings for query, property, and header) for both azure and unbranded flavors. diff --git a/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py b/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py index ba7d858e66a..d70d2f15187 100644 --- a/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py +++ b/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py @@ -81,9 +81,7 @@ def test_property(client: DurationClient): assert abs(result.value - 150.0) < 0.0001 result = client.property.int32_milliseconds_larger_unit(Int32MillisecondsLargerUnitDurationProperty(value=180000)) assert result.value == 180000 - result = client.property.float_milliseconds_larger_unit( - FloatMillisecondsLargerUnitDurationProperty(value=210000.0) - ) + result = client.property.float_milliseconds_larger_unit(FloatMillisecondsLargerUnitDurationProperty(value=210000.0)) assert abs(result.value - 210000.0) < 0.0001 diff --git a/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py b/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py index a90992592ca..60fc91841fc 100644 --- a/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py +++ b/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py @@ -81,9 +81,7 @@ def test_property(client: DurationClient): assert abs(result.value - 150.0) < 0.0001 result = client.property.int32_milliseconds_larger_unit(Int32MillisecondsLargerUnitDurationProperty(value=180000)) assert result.value == 180000 - result = client.property.float_milliseconds_larger_unit( - FloatMillisecondsLargerUnitDurationProperty(value=210000.0) - ) + result = client.property.float_milliseconds_larger_unit(FloatMillisecondsLargerUnitDurationProperty(value=210000.0)) assert abs(result.value - 210000.0) < 0.0001 From a7edc4d0cc2841e21198353610e408631fc02950 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 11 Jun 2026 09:54:53 +0000 Subject: [PATCH 3/6] feat(http-client-python): support timedelta for seconds/milliseconds duration encoding Co-authored-by: msyyc <70930885+msyyc@users.noreply.github.com> --- ...ds-milliseconds-encode-2026-6-10-9-3-37.md | 17 +++ ...-encode-duration-tests-2026-6-10-9-3-37.md | 7 - .../http-client-python/emitter/src/types.ts | 7 + .../pygen/codegen/models/primitive_types.py | 16 ++- .../codegen/templates/model_base.py.jinja2 | 41 +++++- .../codegen/templates/serialization.py.jinja2 | 104 +++++++++++++++ .../asynctests/test_encode_duration_async.py | 116 ++++++++++------- .../mock_api/azure/test_encode_duration.py | 120 +++++++++++------- .../asynctests/test_encode_duration_async.py | 116 ++++++++++------- .../unbranded/test_encode_duration.py | 120 +++++++++++------- 10 files changed, 459 insertions(+), 205 deletions(-) create mode 100644 .chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md delete mode 100644 .chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md diff --git a/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md b/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md new file mode 100644 index 00000000000..fea41628910 --- /dev/null +++ b/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md @@ -0,0 +1,17 @@ +--- +changeKind: feature +packages: + - "@typespec/http-client-python" +--- + +Support `datetime.timedelta` for `duration` types encoded as `seconds` or `milliseconds`. SDK users can now pass a `datetime.timedelta` (instead of a raw `int`/`float`) and responses are deserialized back into `datetime.timedelta`. + +```python +from datetime import timedelta + +client.query.int32_seconds(input=timedelta(seconds=36)) +result = client.property.int32_milliseconds( + Int32MillisecondsDurationProperty(value=timedelta(milliseconds=36000)) +) +assert result.value == timedelta(milliseconds=36000) +``` diff --git a/.chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md b/.chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md deleted file mode 100644 index d3bef34b0a2..00000000000 --- a/.chronus/changes/add-python-encode-duration-tests-2026-6-10-9-3-37.md +++ /dev/null @@ -1,7 +0,0 @@ ---- -changeKind: internal -packages: - - "@typespec/http-client-python" ---- - -Expand sync and async mock_api tests for the `encode/duration` Spector scenarios (milliseconds, larger-unit, and array encodings for query, property, and header) for both azure and unbranded flavors. diff --git a/packages/http-client-python/emitter/src/types.ts b/packages/http-client-python/emitter/src/types.ts index a23aaff6edc..f3d53dcfdc8 100644 --- a/packages/http-client-python/emitter/src/types.ts +++ b/packages/http-client-python/emitter/src/types.ts @@ -479,6 +479,13 @@ function emitBuiltInType( encode: type.encode, }); } + if (type.encode === "seconds" || type.encode === "milliseconds") { + return getSimpleTypeResult(context, { + type: type.kind, + encode: type.encode, + wireType: getType(context, type.wireType), + }); + } } if (type.kind === "utcDateTime" || type.kind === "offsetDateTime") { if (type.encode === "unixTimestamp") { diff --git a/packages/http-client-python/generator/pygen/codegen/models/primitive_types.py b/packages/http-client-python/generator/pygen/codegen/models/primitive_types.py index 5aced33eb61..cc864cf3ee1 100644 --- a/packages/http-client-python/generator/pygen/codegen/models/primitive_types.py +++ b/packages/http-client-python/generator/pygen/codegen/models/primitive_types.py @@ -522,8 +522,22 @@ def serialize_sample_value(value: Any) -> str: class DurationType(PrimitiveType): + def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None: + super().__init__(yaml_data=yaml_data, code_model=code_model) + # ``seconds`` and ``milliseconds`` encodings serialize a timedelta to a numeric + # wire value. ``encode`` is set to a combined format token (e.g. + # ``duration-seconds-int``) so that serialization/deserialization can convert + # between ``datetime.timedelta`` and the numeric wire type. ISO8601 (the default) + # leaves ``encode`` unset and keeps the legacy ISO 8601 string behavior. + self.encode: Optional[str] = None + encode = yaml_data.get("encode") + if encode in ("seconds", "milliseconds"): + wire_type = yaml_data.get("wireType") or {} + wire = "int" if wire_type.get("type") == "integer" else "float" + self.encode = f"duration-{encode}-{wire}" + def serialization_type(self, **kwargs: Any) -> str: - return "duration" + return self.encode or "duration" def docstring_type(self, **kwargs: Any) -> str: return "~" + self.type_annotation() diff --git a/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 b/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 index 90af28ba13e..078dddc1496 100644 --- a/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 +++ b/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 @@ -112,6 +112,29 @@ def _serialize_bytes(o, format: typing.Optional[str] = None) -> str: return encoded +def _serialize_duration(td: timedelta, format: typing.Optional[str] = None): + """Serialize a timedelta to its wire representation. + + For the ``seconds``/``milliseconds`` encodings the value is converted to a + numeric value, otherwise it falls back to an ISO 8601 duration string. + + :param timedelta td: The timedelta to serialize. + :param str format: The duration encoding format. + :rtype: int or float or str + :return: serialized duration + """ + seconds = td.total_seconds() + if format == "duration-seconds-int": + return int(seconds) + if format == "duration-seconds-float": + return seconds + if format == "duration-milliseconds-int": + return int(seconds * 1000) + if format == "duration-milliseconds-float": + return seconds * 1000 + return _timedelta_as_isostr(td) + + def _serialize_datetime(o, format: typing.Optional[str] = None): if hasattr(o, "year") and hasattr(o, "hour"): if format == "rfc7231": @@ -307,6 +330,18 @@ def _deserialize_duration(attr): return isodate.parse_duration(attr) +def _deserialize_duration_seconds(attr): + if isinstance(attr, timedelta): + return attr + return timedelta(seconds=float(attr)) + + +def _deserialize_duration_milliseconds(attr): + if isinstance(attr, timedelta): + return attr + return timedelta(milliseconds=float(attr)) + + def _deserialize_decimal(attr): if isinstance(attr, decimal.Decimal): return attr @@ -336,6 +371,10 @@ _DESERIALIZE_MAPPING_WITHFORMAT = { "unix-timestamp": _deserialize_datetime_unix_timestamp, "base64": _deserialize_bytes, "base64url": _deserialize_bytes_base64, + "duration-seconds-int": _deserialize_duration_seconds, + "duration-seconds-float": _deserialize_duration_seconds, + "duration-milliseconds-int": _deserialize_duration_milliseconds, + "duration-milliseconds-float": _deserialize_duration_milliseconds, } @@ -576,7 +615,7 @@ def _serialize(o, format: typing.Optional[str] = None): # pylint: disable=too-m pass # Last, try datetime.timedelta try: - return _timedelta_as_isostr(o) + return _serialize_duration(o, format) except AttributeError: # This will be raised when it hits value.total_seconds in the method above pass diff --git a/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 b/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 index 9d611b54b85..c81680a2bfc 100644 --- a/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 +++ b/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 @@ -516,6 +516,10 @@ class Serializer: # pylint: disable=too-many-public-methods "rfc-1123": Serializer.serialize_rfc, "unix-time": Serializer.serialize_unix, "duration": Serializer.serialize_duration, + "duration-seconds-int": Serializer.serialize_duration_seconds_int, + "duration-seconds-float": Serializer.serialize_duration_seconds_float, + "duration-milliseconds-int": Serializer.serialize_duration_milliseconds_int, + "duration-milliseconds-float": Serializer.serialize_duration_milliseconds_float, "date": Serializer.serialize_date, "time": Serializer.serialize_time, "decimal": Serializer.serialize_decimal, @@ -1105,6 +1109,62 @@ class Serializer: # pylint: disable=too-many-public-methods attr = isodate.parse_duration(attr) return isodate.duration_isoformat(attr) + @staticmethod + def serialize_duration_seconds_int(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into an integer number of seconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: int + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + if isinstance(attr, datetime.timedelta): + return int(attr.total_seconds()) + return int(attr) + + @staticmethod + def serialize_duration_seconds_float(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into a floating point number of seconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: float + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + if isinstance(attr, datetime.timedelta): + return attr.total_seconds() + return float(attr) + + @staticmethod + def serialize_duration_milliseconds_int(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into an integer number of milliseconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: int + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + if isinstance(attr, datetime.timedelta): + return int(attr.total_seconds() * 1000) + return int(attr) + + @staticmethod + def serialize_duration_milliseconds_float(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into a floating point number of milliseconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: float + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + if isinstance(attr, datetime.timedelta): + return attr.total_seconds() * 1000 + return float(attr) + @staticmethod def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into RFC-1123 formatted string. @@ -1377,6 +1437,10 @@ class Deserializer: "rfc-1123": Deserializer.deserialize_rfc, "unix-time": Deserializer.deserialize_unix, "duration": Deserializer.deserialize_duration, + "duration-seconds-int": Deserializer.deserialize_duration_seconds, + "duration-seconds-float": Deserializer.deserialize_duration_seconds, + "duration-milliseconds-int": Deserializer.deserialize_duration_milliseconds, + "duration-milliseconds-float": Deserializer.deserialize_duration_milliseconds, "date": Deserializer.deserialize_date, "time": Deserializer.deserialize_time, "decimal": Deserializer.deserialize_decimal, @@ -1389,6 +1453,10 @@ class Deserializer: } self.deserialize_expected_types = { "duration": (isodate.Duration, datetime.timedelta), + "duration-seconds-int": (isodate.Duration, datetime.timedelta), + "duration-seconds-float": (isodate.Duration, datetime.timedelta), + "duration-milliseconds-int": (isodate.Duration, datetime.timedelta), + "duration-milliseconds-float": (isodate.Duration, datetime.timedelta), "iso-8601": (datetime.datetime), } self.dependencies: dict[str, type] = dict(classes) if classes else {} @@ -1950,6 +2018,42 @@ class Deserializer: raise DeserializationError(msg) from err return duration + @staticmethod + def deserialize_duration_seconds(attr): + """Deserialize a numeric number of seconds into a TimeDelta object. + + :param attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = datetime.timedelta(seconds=float(attr)) + except (ValueError, OverflowError, TypeError) as err: + msg = "Cannot deserialize duration object." + raise DeserializationError(msg) from err + return duration + + @staticmethod + def deserialize_duration_milliseconds(attr): + """Deserialize a numeric number of milliseconds into a TimeDelta object. + + :param attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = datetime.timedelta(milliseconds=float(attr)) + except (ValueError, OverflowError, TypeError) as err: + msg = "Cannot deserialize duration object." + raise DeserializationError(msg) from err + return duration + @staticmethod def deserialize_date(attr): """Deserialize ISO-8601 formatted string into Date object. diff --git a/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py b/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py index e46ff7ac0f4..6e2dd00b4b0 100644 --- a/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py +++ b/packages/http-client-python/tests/mock_api/azure/asynctests/test_encode_duration_async.py @@ -36,18 +36,20 @@ async def client(): async def test_query(client: DurationClient): await client.query.default(input=datetime.timedelta(days=40)) await client.query.iso8601(input=datetime.timedelta(days=40)) - await client.query.int32_seconds(input=36) - await client.query.int32_seconds_larger_unit(input=120) - await client.query.int32_seconds_array(input=[36, 47]) - await client.query.float_seconds(input=35.625) - await client.query.float_seconds_larger_unit(input=150.0) - await client.query.float64_seconds(input=35.625) - await client.query.int32_milliseconds(input=36000) - await client.query.int32_milliseconds_larger_unit(input=180000) - await client.query.int32_milliseconds_array(input=[36000, 47000]) - await client.query.float_milliseconds(input=35625) - await client.query.float_milliseconds_larger_unit(input=210000.0) - await client.query.float64_milliseconds(input=35625) + await client.query.int32_seconds(input=datetime.timedelta(seconds=36)) + await client.query.int32_seconds_larger_unit(input=datetime.timedelta(seconds=120)) + await client.query.int32_seconds_array(input=[datetime.timedelta(seconds=36), datetime.timedelta(seconds=47)]) + await client.query.float_seconds(input=datetime.timedelta(seconds=35.625)) + await client.query.float_seconds_larger_unit(input=datetime.timedelta(seconds=150)) + await client.query.float64_seconds(input=datetime.timedelta(seconds=35.625)) + await client.query.int32_milliseconds(input=datetime.timedelta(milliseconds=36000)) + await client.query.int32_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=180000)) + await client.query.int32_milliseconds_array( + input=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + await client.query.float_milliseconds(input=datetime.timedelta(milliseconds=35625)) + await client.query.float_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=210000)) + await client.query.float64_milliseconds(input=datetime.timedelta(milliseconds=35625)) @pytest.mark.asyncio @@ -60,38 +62,52 @@ async def test_property(client: DurationClient): assert result.value == datetime.timedelta(days=40) result = await client.property.iso8601(ISO8601DurationProperty(value="P40D")) assert result.value == datetime.timedelta(days=40) - result = await client.property.int32_seconds(Int32SecondsDurationProperty(value=36)) - assert result.value == 36 - result = await client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = await client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = await client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) - assert result.value == 36000 - result = await client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = await client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = await client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) - assert abs(result.value[0] - 35.625) < 0.0001 - assert abs(result.value[1] - 46.75) < 0.0001 + result = await client.property.int32_seconds(Int32SecondsDurationProperty(value=datetime.timedelta(seconds=36))) + assert result.value == datetime.timedelta(seconds=36) + result = await client.property.float_seconds(FloatSecondsDurationProperty(value=datetime.timedelta(seconds=35.625))) + assert result.value == datetime.timedelta(seconds=35.625) + result = await client.property.float64_seconds( + Float64SecondsDurationProperty(value=datetime.timedelta(seconds=35.625)) + ) + assert result.value == datetime.timedelta(seconds=35.625) + result = await client.property.int32_milliseconds( + Int32MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=36000)) + ) + assert result.value == datetime.timedelta(milliseconds=36000) + result = await client.property.float_milliseconds( + FloatMillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = await client.property.float64_milliseconds( + Float64MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = await client.property.float_seconds_array( + FloatSecondsDurationArrayProperty(value=[datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)]) + ) + assert result.value == [datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)] result = await client.property.float_milliseconds_array( - FloatMillisecondsDurationArrayProperty(value=[35625, 46750]) + FloatMillisecondsDurationArrayProperty( + value=[datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + ) + ) + assert result.value == [datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + result = await client.property.int32_seconds_larger_unit( + Int32SecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=120)) ) - assert abs(result.value[0] - 35625) < 0.0001 - assert abs(result.value[1] - 46750) < 0.0001 - result = await client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) - assert result.value == 120 - result = await client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) - assert abs(result.value - 150.0) < 0.0001 + assert result.value == datetime.timedelta(seconds=120) + result = await client.property.float_seconds_larger_unit( + FloatSecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=150)) + ) + assert result.value == datetime.timedelta(seconds=150) result = await client.property.int32_milliseconds_larger_unit( - Int32MillisecondsLargerUnitDurationProperty(value=180000) + Int32MillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=180000)) ) - assert result.value == 180000 + assert result.value == datetime.timedelta(milliseconds=180000) result = await client.property.float_milliseconds_larger_unit( - FloatMillisecondsLargerUnitDurationProperty(value=210000.0) + FloatMillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=210000)) ) - assert abs(result.value - 210000.0) < 0.0001 + assert result.value == datetime.timedelta(milliseconds=210000) @pytest.mark.asyncio @@ -99,14 +115,16 @@ async def test_header(client: DurationClient): await client.header.default(duration=datetime.timedelta(days=40)) await client.header.iso8601(duration=datetime.timedelta(days=40)) await client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) - await client.header.int32_seconds(duration=36) - await client.header.int32_seconds_larger_unit(duration=120) - await client.header.float_seconds(duration=35.625) - await client.header.float_seconds_larger_unit(duration=150.0) - await client.header.float64_seconds(duration=35.625) - await client.header.int32_milliseconds(duration=36000) - await client.header.int32_milliseconds_larger_unit(duration=180000) - await client.header.int32_milliseconds_array(duration=[36000, 47000]) - await client.header.float_milliseconds(duration=35625) - await client.header.float_milliseconds_larger_unit(duration=210000.0) - await client.header.float64_milliseconds(duration=35625) + await client.header.int32_seconds(duration=datetime.timedelta(seconds=36)) + await client.header.int32_seconds_larger_unit(duration=datetime.timedelta(seconds=120)) + await client.header.float_seconds(duration=datetime.timedelta(seconds=35.625)) + await client.header.float_seconds_larger_unit(duration=datetime.timedelta(seconds=150)) + await client.header.float64_seconds(duration=datetime.timedelta(seconds=35.625)) + await client.header.int32_milliseconds(duration=datetime.timedelta(milliseconds=36000)) + await client.header.int32_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=180000)) + await client.header.int32_milliseconds_array( + duration=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + await client.header.float_milliseconds(duration=datetime.timedelta(milliseconds=35625)) + await client.header.float_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=210000)) + await client.header.float64_milliseconds(duration=datetime.timedelta(milliseconds=35625)) diff --git a/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py b/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py index d70d2f15187..78d5ae4f066 100644 --- a/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py +++ b/packages/http-client-python/tests/mock_api/azure/test_encode_duration.py @@ -34,18 +34,20 @@ def client(): def test_query(client: DurationClient): client.query.default(input=datetime.timedelta(days=40)) client.query.iso8601(input=datetime.timedelta(days=40)) - client.query.int32_seconds(input=36) - client.query.int32_seconds_larger_unit(input=120) - client.query.int32_seconds_array(input=[36, 47]) - client.query.float_seconds(input=35.625) - client.query.float_seconds_larger_unit(input=150.0) - client.query.float64_seconds(input=35.625) - client.query.int32_milliseconds(input=36000) - client.query.int32_milliseconds_larger_unit(input=180000) - client.query.int32_milliseconds_array(input=[36000, 47000]) - client.query.float_milliseconds(input=35625) - client.query.float_milliseconds_larger_unit(input=210000.0) - client.query.float64_milliseconds(input=35625) + client.query.int32_seconds(input=datetime.timedelta(seconds=36)) + client.query.int32_seconds_larger_unit(input=datetime.timedelta(seconds=120)) + client.query.int32_seconds_array(input=[datetime.timedelta(seconds=36), datetime.timedelta(seconds=47)]) + client.query.float_seconds(input=datetime.timedelta(seconds=35.625)) + client.query.float_seconds_larger_unit(input=datetime.timedelta(seconds=150)) + client.query.float64_seconds(input=datetime.timedelta(seconds=35.625)) + client.query.int32_milliseconds(input=datetime.timedelta(milliseconds=36000)) + client.query.int32_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=180000)) + client.query.int32_milliseconds_array( + input=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + client.query.float_milliseconds(input=datetime.timedelta(milliseconds=35625)) + client.query.float_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=210000)) + client.query.float64_milliseconds(input=datetime.timedelta(milliseconds=35625)) def test_property(client: DurationClient): @@ -57,46 +59,66 @@ def test_property(client: DurationClient): assert result.value == datetime.timedelta(days=40) result = client.property.iso8601(ISO8601DurationProperty(value="P40D")) assert result.value == datetime.timedelta(days=40) - result = client.property.int32_seconds(Int32SecondsDurationProperty(value=36)) - assert result.value == 36 - result = client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) - assert result.value == 36000 - result = client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) - assert abs(result.value[0] - 35.625) < 0.0001 - assert abs(result.value[1] - 46.75) < 0.0001 - result = client.property.float_milliseconds_array(FloatMillisecondsDurationArrayProperty(value=[35625, 46750])) - assert abs(result.value[0] - 35625) < 0.0001 - assert abs(result.value[1] - 46750) < 0.0001 - result = client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) - assert result.value == 120 - result = client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) - assert abs(result.value - 150.0) < 0.0001 - result = client.property.int32_milliseconds_larger_unit(Int32MillisecondsLargerUnitDurationProperty(value=180000)) - assert result.value == 180000 - result = client.property.float_milliseconds_larger_unit(FloatMillisecondsLargerUnitDurationProperty(value=210000.0)) - assert abs(result.value - 210000.0) < 0.0001 + result = client.property.int32_seconds(Int32SecondsDurationProperty(value=datetime.timedelta(seconds=36))) + assert result.value == datetime.timedelta(seconds=36) + result = client.property.float_seconds(FloatSecondsDurationProperty(value=datetime.timedelta(seconds=35.625))) + assert result.value == datetime.timedelta(seconds=35.625) + result = client.property.float64_seconds(Float64SecondsDurationProperty(value=datetime.timedelta(seconds=35.625))) + assert result.value == datetime.timedelta(seconds=35.625) + result = client.property.int32_milliseconds( + Int32MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=36000)) + ) + assert result.value == datetime.timedelta(milliseconds=36000) + result = client.property.float_milliseconds( + FloatMillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = client.property.float64_milliseconds( + Float64MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = client.property.float_seconds_array( + FloatSecondsDurationArrayProperty(value=[datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)]) + ) + assert result.value == [datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)] + result = client.property.float_milliseconds_array( + FloatMillisecondsDurationArrayProperty( + value=[datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + ) + ) + assert result.value == [datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + result = client.property.int32_seconds_larger_unit( + Int32SecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=120)) + ) + assert result.value == datetime.timedelta(seconds=120) + result = client.property.float_seconds_larger_unit( + FloatSecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=150)) + ) + assert result.value == datetime.timedelta(seconds=150) + result = client.property.int32_milliseconds_larger_unit( + Int32MillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=180000)) + ) + assert result.value == datetime.timedelta(milliseconds=180000) + result = client.property.float_milliseconds_larger_unit( + FloatMillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=210000)) + ) + assert result.value == datetime.timedelta(milliseconds=210000) def test_header(client: DurationClient): client.header.default(duration=datetime.timedelta(days=40)) client.header.iso8601(duration=datetime.timedelta(days=40)) client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) - client.header.int32_seconds(duration=36) - client.header.int32_seconds_larger_unit(duration=120) - client.header.float_seconds(duration=35.625) - client.header.float_seconds_larger_unit(duration=150.0) - client.header.float64_seconds(duration=35.625) - client.header.int32_milliseconds(duration=36000) - client.header.int32_milliseconds_larger_unit(duration=180000) - client.header.int32_milliseconds_array(duration=[36000, 47000]) - client.header.float_milliseconds(duration=35625) - client.header.float_milliseconds_larger_unit(duration=210000.0) - client.header.float64_milliseconds(duration=35625) + client.header.int32_seconds(duration=datetime.timedelta(seconds=36)) + client.header.int32_seconds_larger_unit(duration=datetime.timedelta(seconds=120)) + client.header.float_seconds(duration=datetime.timedelta(seconds=35.625)) + client.header.float_seconds_larger_unit(duration=datetime.timedelta(seconds=150)) + client.header.float64_seconds(duration=datetime.timedelta(seconds=35.625)) + client.header.int32_milliseconds(duration=datetime.timedelta(milliseconds=36000)) + client.header.int32_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=180000)) + client.header.int32_milliseconds_array( + duration=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + client.header.float_milliseconds(duration=datetime.timedelta(milliseconds=35625)) + client.header.float_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=210000)) + client.header.float64_milliseconds(duration=datetime.timedelta(milliseconds=35625)) diff --git a/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py b/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py index 0a55860b0fa..bb99138d88d 100644 --- a/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py +++ b/packages/http-client-python/tests/mock_api/unbranded/asynctests/test_encode_duration_async.py @@ -36,18 +36,20 @@ async def client(): async def test_query(client: DurationClient): await client.query.default(input=datetime.timedelta(days=40)) await client.query.iso8601(input=datetime.timedelta(days=40)) - await client.query.int32_seconds(input=36) - await client.query.int32_seconds_larger_unit(input=120) - await client.query.int32_seconds_array(input=[36, 47]) - await client.query.float_seconds(input=35.625) - await client.query.float_seconds_larger_unit(input=150.0) - await client.query.float64_seconds(input=35.625) - await client.query.int32_milliseconds(input=36000) - await client.query.int32_milliseconds_larger_unit(input=180000) - await client.query.int32_milliseconds_array(input=[36000, 47000]) - await client.query.float_milliseconds(input=35625) - await client.query.float_milliseconds_larger_unit(input=210000.0) - await client.query.float64_milliseconds(input=35625) + await client.query.int32_seconds(input=datetime.timedelta(seconds=36)) + await client.query.int32_seconds_larger_unit(input=datetime.timedelta(seconds=120)) + await client.query.int32_seconds_array(input=[datetime.timedelta(seconds=36), datetime.timedelta(seconds=47)]) + await client.query.float_seconds(input=datetime.timedelta(seconds=35.625)) + await client.query.float_seconds_larger_unit(input=datetime.timedelta(seconds=150)) + await client.query.float64_seconds(input=datetime.timedelta(seconds=35.625)) + await client.query.int32_milliseconds(input=datetime.timedelta(milliseconds=36000)) + await client.query.int32_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=180000)) + await client.query.int32_milliseconds_array( + input=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + await client.query.float_milliseconds(input=datetime.timedelta(milliseconds=35625)) + await client.query.float_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=210000)) + await client.query.float64_milliseconds(input=datetime.timedelta(milliseconds=35625)) @pytest.mark.asyncio @@ -60,38 +62,52 @@ async def test_property(client: DurationClient): assert result.value == datetime.timedelta(days=40) result = await client.property.iso8601(ISO8601DurationProperty(value="P40D")) assert result.value == datetime.timedelta(days=40) - result = await client.property.int32_seconds(Int32SecondsDurationProperty(value=36)) - assert result.value == 36 - result = await client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = await client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = await client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) - assert result.value == 36000 - result = await client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = await client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = await client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) - assert abs(result.value[0] - 35.625) < 0.0001 - assert abs(result.value[1] - 46.75) < 0.0001 + result = await client.property.int32_seconds(Int32SecondsDurationProperty(value=datetime.timedelta(seconds=36))) + assert result.value == datetime.timedelta(seconds=36) + result = await client.property.float_seconds(FloatSecondsDurationProperty(value=datetime.timedelta(seconds=35.625))) + assert result.value == datetime.timedelta(seconds=35.625) + result = await client.property.float64_seconds( + Float64SecondsDurationProperty(value=datetime.timedelta(seconds=35.625)) + ) + assert result.value == datetime.timedelta(seconds=35.625) + result = await client.property.int32_milliseconds( + Int32MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=36000)) + ) + assert result.value == datetime.timedelta(milliseconds=36000) + result = await client.property.float_milliseconds( + FloatMillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = await client.property.float64_milliseconds( + Float64MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = await client.property.float_seconds_array( + FloatSecondsDurationArrayProperty(value=[datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)]) + ) + assert result.value == [datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)] result = await client.property.float_milliseconds_array( - FloatMillisecondsDurationArrayProperty(value=[35625, 46750]) + FloatMillisecondsDurationArrayProperty( + value=[datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + ) + ) + assert result.value == [datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + result = await client.property.int32_seconds_larger_unit( + Int32SecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=120)) ) - assert abs(result.value[0] - 35625) < 0.0001 - assert abs(result.value[1] - 46750) < 0.0001 - result = await client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) - assert result.value == 120 - result = await client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) - assert abs(result.value - 150.0) < 0.0001 + assert result.value == datetime.timedelta(seconds=120) + result = await client.property.float_seconds_larger_unit( + FloatSecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=150)) + ) + assert result.value == datetime.timedelta(seconds=150) result = await client.property.int32_milliseconds_larger_unit( - Int32MillisecondsLargerUnitDurationProperty(value=180000) + Int32MillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=180000)) ) - assert result.value == 180000 + assert result.value == datetime.timedelta(milliseconds=180000) result = await client.property.float_milliseconds_larger_unit( - FloatMillisecondsLargerUnitDurationProperty(value=210000.0) + FloatMillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=210000)) ) - assert abs(result.value - 210000.0) < 0.0001 + assert result.value == datetime.timedelta(milliseconds=210000) @pytest.mark.asyncio @@ -99,14 +115,16 @@ async def test_header(client: DurationClient): await client.header.default(duration=datetime.timedelta(days=40)) await client.header.iso8601(duration=datetime.timedelta(days=40)) await client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) - await client.header.int32_seconds(duration=36) - await client.header.int32_seconds_larger_unit(duration=120) - await client.header.float_seconds(duration=35.625) - await client.header.float_seconds_larger_unit(duration=150.0) - await client.header.float64_seconds(duration=35.625) - await client.header.int32_milliseconds(duration=36000) - await client.header.int32_milliseconds_larger_unit(duration=180000) - await client.header.int32_milliseconds_array(duration=[36000, 47000]) - await client.header.float_milliseconds(duration=35625) - await client.header.float_milliseconds_larger_unit(duration=210000.0) - await client.header.float64_milliseconds(duration=35625) + await client.header.int32_seconds(duration=datetime.timedelta(seconds=36)) + await client.header.int32_seconds_larger_unit(duration=datetime.timedelta(seconds=120)) + await client.header.float_seconds(duration=datetime.timedelta(seconds=35.625)) + await client.header.float_seconds_larger_unit(duration=datetime.timedelta(seconds=150)) + await client.header.float64_seconds(duration=datetime.timedelta(seconds=35.625)) + await client.header.int32_milliseconds(duration=datetime.timedelta(milliseconds=36000)) + await client.header.int32_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=180000)) + await client.header.int32_milliseconds_array( + duration=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + await client.header.float_milliseconds(duration=datetime.timedelta(milliseconds=35625)) + await client.header.float_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=210000)) + await client.header.float64_milliseconds(duration=datetime.timedelta(milliseconds=35625)) diff --git a/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py b/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py index 60fc91841fc..0f9e6a1a593 100644 --- a/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py +++ b/packages/http-client-python/tests/mock_api/unbranded/test_encode_duration.py @@ -34,18 +34,20 @@ def client(): def test_query(client: DurationClient): client.query.default(input=datetime.timedelta(days=40)) client.query.iso8601(input=datetime.timedelta(days=40)) - client.query.int32_seconds(input=36) - client.query.int32_seconds_larger_unit(input=120) - client.query.int32_seconds_array(input=[36, 47]) - client.query.float_seconds(input=35.625) - client.query.float_seconds_larger_unit(input=150.0) - client.query.float64_seconds(input=35.625) - client.query.int32_milliseconds(input=36000) - client.query.int32_milliseconds_larger_unit(input=180000) - client.query.int32_milliseconds_array(input=[36000, 47000]) - client.query.float_milliseconds(input=35625) - client.query.float_milliseconds_larger_unit(input=210000.0) - client.query.float64_milliseconds(input=35625) + client.query.int32_seconds(input=datetime.timedelta(seconds=36)) + client.query.int32_seconds_larger_unit(input=datetime.timedelta(seconds=120)) + client.query.int32_seconds_array(input=[datetime.timedelta(seconds=36), datetime.timedelta(seconds=47)]) + client.query.float_seconds(input=datetime.timedelta(seconds=35.625)) + client.query.float_seconds_larger_unit(input=datetime.timedelta(seconds=150)) + client.query.float64_seconds(input=datetime.timedelta(seconds=35.625)) + client.query.int32_milliseconds(input=datetime.timedelta(milliseconds=36000)) + client.query.int32_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=180000)) + client.query.int32_milliseconds_array( + input=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + client.query.float_milliseconds(input=datetime.timedelta(milliseconds=35625)) + client.query.float_milliseconds_larger_unit(input=datetime.timedelta(milliseconds=210000)) + client.query.float64_milliseconds(input=datetime.timedelta(milliseconds=35625)) def test_property(client: DurationClient): @@ -57,46 +59,66 @@ def test_property(client: DurationClient): assert result.value == datetime.timedelta(days=40) result = client.property.iso8601(ISO8601DurationProperty(value="P40D")) assert result.value == datetime.timedelta(days=40) - result = client.property.int32_seconds(Int32SecondsDurationProperty(value=36)) - assert result.value == 36 - result = client.property.float_seconds(FloatSecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = client.property.float64_seconds(Float64SecondsDurationProperty(value=35.625)) - assert abs(result.value - 35.625) < 0.0001 - result = client.property.int32_milliseconds(Int32MillisecondsDurationProperty(value=36000)) - assert result.value == 36000 - result = client.property.float_milliseconds(FloatMillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = client.property.float64_milliseconds(Float64MillisecondsDurationProperty(value=35625)) - assert abs(result.value - 35625) < 0.0001 - result = client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75])) - assert abs(result.value[0] - 35.625) < 0.0001 - assert abs(result.value[1] - 46.75) < 0.0001 - result = client.property.float_milliseconds_array(FloatMillisecondsDurationArrayProperty(value=[35625, 46750])) - assert abs(result.value[0] - 35625) < 0.0001 - assert abs(result.value[1] - 46750) < 0.0001 - result = client.property.int32_seconds_larger_unit(Int32SecondsLargerUnitDurationProperty(value=120)) - assert result.value == 120 - result = client.property.float_seconds_larger_unit(FloatSecondsLargerUnitDurationProperty(value=150.0)) - assert abs(result.value - 150.0) < 0.0001 - result = client.property.int32_milliseconds_larger_unit(Int32MillisecondsLargerUnitDurationProperty(value=180000)) - assert result.value == 180000 - result = client.property.float_milliseconds_larger_unit(FloatMillisecondsLargerUnitDurationProperty(value=210000.0)) - assert abs(result.value - 210000.0) < 0.0001 + result = client.property.int32_seconds(Int32SecondsDurationProperty(value=datetime.timedelta(seconds=36))) + assert result.value == datetime.timedelta(seconds=36) + result = client.property.float_seconds(FloatSecondsDurationProperty(value=datetime.timedelta(seconds=35.625))) + assert result.value == datetime.timedelta(seconds=35.625) + result = client.property.float64_seconds(Float64SecondsDurationProperty(value=datetime.timedelta(seconds=35.625))) + assert result.value == datetime.timedelta(seconds=35.625) + result = client.property.int32_milliseconds( + Int32MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=36000)) + ) + assert result.value == datetime.timedelta(milliseconds=36000) + result = client.property.float_milliseconds( + FloatMillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = client.property.float64_milliseconds( + Float64MillisecondsDurationProperty(value=datetime.timedelta(milliseconds=35625)) + ) + assert result.value == datetime.timedelta(milliseconds=35625) + result = client.property.float_seconds_array( + FloatSecondsDurationArrayProperty(value=[datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)]) + ) + assert result.value == [datetime.timedelta(seconds=35.625), datetime.timedelta(seconds=46.75)] + result = client.property.float_milliseconds_array( + FloatMillisecondsDurationArrayProperty( + value=[datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + ) + ) + assert result.value == [datetime.timedelta(milliseconds=35625), datetime.timedelta(milliseconds=46750)] + result = client.property.int32_seconds_larger_unit( + Int32SecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=120)) + ) + assert result.value == datetime.timedelta(seconds=120) + result = client.property.float_seconds_larger_unit( + FloatSecondsLargerUnitDurationProperty(value=datetime.timedelta(seconds=150)) + ) + assert result.value == datetime.timedelta(seconds=150) + result = client.property.int32_milliseconds_larger_unit( + Int32MillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=180000)) + ) + assert result.value == datetime.timedelta(milliseconds=180000) + result = client.property.float_milliseconds_larger_unit( + FloatMillisecondsLargerUnitDurationProperty(value=datetime.timedelta(milliseconds=210000)) + ) + assert result.value == datetime.timedelta(milliseconds=210000) def test_header(client: DurationClient): client.header.default(duration=datetime.timedelta(days=40)) client.header.iso8601(duration=datetime.timedelta(days=40)) client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)]) - client.header.int32_seconds(duration=36) - client.header.int32_seconds_larger_unit(duration=120) - client.header.float_seconds(duration=35.625) - client.header.float_seconds_larger_unit(duration=150.0) - client.header.float64_seconds(duration=35.625) - client.header.int32_milliseconds(duration=36000) - client.header.int32_milliseconds_larger_unit(duration=180000) - client.header.int32_milliseconds_array(duration=[36000, 47000]) - client.header.float_milliseconds(duration=35625) - client.header.float_milliseconds_larger_unit(duration=210000.0) - client.header.float64_milliseconds(duration=35625) + client.header.int32_seconds(duration=datetime.timedelta(seconds=36)) + client.header.int32_seconds_larger_unit(duration=datetime.timedelta(seconds=120)) + client.header.float_seconds(duration=datetime.timedelta(seconds=35.625)) + client.header.float_seconds_larger_unit(duration=datetime.timedelta(seconds=150)) + client.header.float64_seconds(duration=datetime.timedelta(seconds=35.625)) + client.header.int32_milliseconds(duration=datetime.timedelta(milliseconds=36000)) + client.header.int32_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=180000)) + client.header.int32_milliseconds_array( + duration=[datetime.timedelta(milliseconds=36000), datetime.timedelta(milliseconds=47000)] + ) + client.header.float_milliseconds(duration=datetime.timedelta(milliseconds=35625)) + client.header.float_milliseconds_larger_unit(duration=datetime.timedelta(milliseconds=210000)) + client.header.float64_milliseconds(duration=datetime.timedelta(milliseconds=35625)) From d721ff7480ed354d24f293b41695cde23350a5a7 Mon Sep 17 00:00:00 2001 From: Yuchao Yan Date: Fri, 12 Jun 2026 10:34:27 +0800 Subject: [PATCH 4/6] Update add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md --- ...ion-seconds-milliseconds-encode-2026-6-10-9-3-37.md | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md b/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md index fea41628910..55229f548a3 100644 --- a/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md +++ b/.chronus/changes/add-python-duration-seconds-milliseconds-encode-2026-6-10-9-3-37.md @@ -5,13 +5,3 @@ packages: --- Support `datetime.timedelta` for `duration` types encoded as `seconds` or `milliseconds`. SDK users can now pass a `datetime.timedelta` (instead of a raw `int`/`float`) and responses are deserialized back into `datetime.timedelta`. - -```python -from datetime import timedelta - -client.query.int32_seconds(input=timedelta(seconds=36)) -result = client.property.int32_milliseconds( - Int32MillisecondsDurationProperty(value=timedelta(milliseconds=36000)) -) -assert result.value == timedelta(milliseconds=36000) -``` From e97e859c888332771271ef8009a2520a95acfc72 Mon Sep 17 00:00:00 2001 From: Yuchao Yan Date: Fri, 12 Jun 2026 11:22:56 +0800 Subject: [PATCH 5/6] Deduplicate numeric duration serialize/deserialize helpers Collapse the seconds/milliseconds (int/float) duration serializers and deserializers behind shared parameterized helpers in model_base and serialization runtime templates. Behavior is unchanged; all encode/duration mock_api tests pass (azure + unbranded, sync + async). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../codegen/templates/model_base.py.jinja2 | 18 ++--- .../codegen/templates/serialization.py.jinja2 | 67 ++++++++++--------- 2 files changed, 42 insertions(+), 43 deletions(-) diff --git a/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 b/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 index 078dddc1496..e51a7645dde 100644 --- a/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 +++ b/packages/http-client-python/generator/pygen/codegen/templates/model_base.py.jinja2 @@ -330,16 +330,10 @@ def _deserialize_duration(attr): return isodate.parse_duration(attr) -def _deserialize_duration_seconds(attr): +def _deserialize_duration_numeric(attr, unit): if isinstance(attr, timedelta): return attr - return timedelta(seconds=float(attr)) - - -def _deserialize_duration_milliseconds(attr): - if isinstance(attr, timedelta): - return attr - return timedelta(milliseconds=float(attr)) + return timedelta(**{unit: float(attr)}) def _deserialize_decimal(attr): @@ -371,10 +365,10 @@ _DESERIALIZE_MAPPING_WITHFORMAT = { "unix-timestamp": _deserialize_datetime_unix_timestamp, "base64": _deserialize_bytes, "base64url": _deserialize_bytes_base64, - "duration-seconds-int": _deserialize_duration_seconds, - "duration-seconds-float": _deserialize_duration_seconds, - "duration-milliseconds-int": _deserialize_duration_milliseconds, - "duration-milliseconds-float": _deserialize_duration_milliseconds, + "duration-seconds-int": functools.partial(_deserialize_duration_numeric, unit="seconds"), + "duration-seconds-float": functools.partial(_deserialize_duration_numeric, unit="seconds"), + "duration-milliseconds-int": functools.partial(_deserialize_duration_numeric, unit="milliseconds"), + "duration-milliseconds-float": functools.partial(_deserialize_duration_numeric, unit="milliseconds"), } diff --git a/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 b/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 index c81680a2bfc..b231f49fc30 100644 --- a/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 +++ b/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 @@ -1109,6 +1109,21 @@ class Serializer: # pylint: disable=too-many-public-methods attr = isodate.parse_duration(attr) return isodate.duration_isoformat(attr) + @staticmethod + def _serialize_duration_numeric(attr, scale, as_int): + """Serialize a TimeDelta into a numeric value scaled to the wire unit. + + :param TimeDelta attr: Object to be serialized. + :param int scale: Multiplier applied to total seconds (1 for seconds, 1000 for milliseconds). + :param bool as_int: Whether to truncate the result to an int. + :rtype: int or float + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + value = attr.total_seconds() * scale if isinstance(attr, datetime.timedelta) else attr + return int(value) if as_int else float(value) + @staticmethod def serialize_duration_seconds_int(attr, **kwargs): # pylint: disable=unused-argument """Serialize TimeDelta object into an integer number of seconds. @@ -1117,11 +1132,7 @@ class Serializer: # pylint: disable=too-many-public-methods :rtype: int :return: serialized duration """ - if isinstance(attr, str): - attr = isodate.parse_duration(attr) - if isinstance(attr, datetime.timedelta): - return int(attr.total_seconds()) - return int(attr) + return Serializer._serialize_duration_numeric(attr, 1, True) @staticmethod def serialize_duration_seconds_float(attr, **kwargs): # pylint: disable=unused-argument @@ -1131,11 +1142,7 @@ class Serializer: # pylint: disable=too-many-public-methods :rtype: float :return: serialized duration """ - if isinstance(attr, str): - attr = isodate.parse_duration(attr) - if isinstance(attr, datetime.timedelta): - return attr.total_seconds() - return float(attr) + return Serializer._serialize_duration_numeric(attr, 1, False) @staticmethod def serialize_duration_milliseconds_int(attr, **kwargs): # pylint: disable=unused-argument @@ -1145,11 +1152,7 @@ class Serializer: # pylint: disable=too-many-public-methods :rtype: int :return: serialized duration """ - if isinstance(attr, str): - attr = isodate.parse_duration(attr) - if isinstance(attr, datetime.timedelta): - return int(attr.total_seconds() * 1000) - return int(attr) + return Serializer._serialize_duration_numeric(attr, 1000, True) @staticmethod def serialize_duration_milliseconds_float(attr, **kwargs): # pylint: disable=unused-argument @@ -1159,11 +1162,7 @@ class Serializer: # pylint: disable=too-many-public-methods :rtype: float :return: serialized duration """ - if isinstance(attr, str): - attr = isodate.parse_duration(attr) - if isinstance(attr, datetime.timedelta): - return attr.total_seconds() * 1000 - return float(attr) + return Serializer._serialize_duration_numeric(attr, 1000, False) @staticmethod def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument @@ -2019,10 +2018,12 @@ class Deserializer: return duration @staticmethod - def deserialize_duration_seconds(attr): - """Deserialize a numeric number of seconds into a TimeDelta object. + def _deserialize_duration_numeric(attr, unit): + """Deserialize a numeric duration value into a TimeDelta object. :param attr: response value to be deserialized. + :param str unit: The wire unit, used as the ``timedelta`` keyword + (``"seconds"`` or ``"milliseconds"``). :return: Deserialized duration :rtype: TimeDelta :raises DeserializationError: if value is invalid. @@ -2030,12 +2031,23 @@ class Deserializer: if isinstance(attr, ET.Element): attr = attr.text try: - duration = datetime.timedelta(seconds=float(attr)) + duration = datetime.timedelta(**{unit: float(attr)}) except (ValueError, OverflowError, TypeError) as err: msg = "Cannot deserialize duration object." raise DeserializationError(msg) from err return duration + @staticmethod + def deserialize_duration_seconds(attr): + """Deserialize a numeric number of seconds into a TimeDelta object. + + :param attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + return Deserializer._deserialize_duration_numeric(attr, "seconds") + @staticmethod def deserialize_duration_milliseconds(attr): """Deserialize a numeric number of milliseconds into a TimeDelta object. @@ -2045,14 +2057,7 @@ class Deserializer: :rtype: TimeDelta :raises DeserializationError: if value is invalid. """ - if isinstance(attr, ET.Element): - attr = attr.text - try: - duration = datetime.timedelta(milliseconds=float(attr)) - except (ValueError, OverflowError, TypeError) as err: - msg = "Cannot deserialize duration object." - raise DeserializationError(msg) from err - return duration + return Deserializer._deserialize_duration_numeric(attr, "milliseconds") @staticmethod def deserialize_date(attr): From 75237737f80071e561670b8faf5a77fcac0ab7c1 Mon Sep 17 00:00:00 2001 From: Yuchao Yan Date: Fri, 12 Jun 2026 04:58:23 +0000 Subject: [PATCH 6/6] update --- .../pygen/codegen/templates/serialization.py.jinja2 | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 b/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 index b231f49fc30..65a9c1f8f9e 100644 --- a/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 +++ b/packages/http-client-python/generator/pygen/codegen/templates/serialization.py.jinja2 @@ -2021,7 +2021,7 @@ class Deserializer: def _deserialize_duration_numeric(attr, unit): """Deserialize a numeric duration value into a TimeDelta object. - :param attr: response value to be deserialized. + :param float attr: response value to be deserialized. :param str unit: The wire unit, used as the ``timedelta`` keyword (``"seconds"`` or ``"milliseconds"``). :return: Deserialized duration @@ -2031,7 +2031,7 @@ class Deserializer: if isinstance(attr, ET.Element): attr = attr.text try: - duration = datetime.timedelta(**{unit: float(attr)}) + duration = datetime.timedelta(**{unit: float(attr)}) # type: ignore except (ValueError, OverflowError, TypeError) as err: msg = "Cannot deserialize duration object." raise DeserializationError(msg) from err @@ -2041,7 +2041,7 @@ class Deserializer: def deserialize_duration_seconds(attr): """Deserialize a numeric number of seconds into a TimeDelta object. - :param attr: response value to be deserialized. + :param float attr: response value to be deserialized. :return: Deserialized duration :rtype: TimeDelta :raises DeserializationError: if value is invalid. @@ -2052,7 +2052,7 @@ class Deserializer: def deserialize_duration_milliseconds(attr): """Deserialize a numeric number of milliseconds into a TimeDelta object. - :param attr: response value to be deserialized. + :param float attr: response value to be deserialized. :return: Deserialized duration :rtype: TimeDelta :raises DeserializationError: if value is invalid.