@typespec/http-client-python 0.6.2 → 0.6.4

package/generator/pygen/codegen/templates/serialization.py.jinja2

@@ -184,73 +184,7 @@ try:
 except NameError:
     _long_type = int
 
-
-class UTC(datetime.tzinfo):
-    """Time Zone info for handling UTC"""
-
-    def utcoffset(self, dt):
-        """UTF offset for UTC is 0.
-
-        :param datetime.datetime dt: The datetime
-        :returns: The offset
-        :rtype: datetime.timedelta
-        """
-        return datetime.timedelta(0)
-
-    def tzname(self, dt):
-        """Timestamp representation.
-
-        :param datetime.datetime dt: The datetime
-        :returns: The timestamp representation
-        :rtype: str
-        """
-        return "Z"
-
-    def dst(self, dt):
-        """No daylight saving for UTC.
-
-        :param datetime.datetime dt: The datetime
-        :returns: The daylight saving time
-        :rtype: datetime.timedelta
-        """
-        return datetime.timedelta(hours=1)
-
-
-try:
-    from datetime import timezone as _FixedOffset  # type: ignore
-except ImportError:  # Python 2.7
-
-    class _FixedOffset(datetime.tzinfo):  # type: ignore
-        """Fixed offset in minutes east from UTC.
-        Copy/pasted from Python doc
-        :param datetime.timedelta offset: offset in timedelta format
-        """
-
-        def __init__(self, offset) -> None:
-            self.__offset = offset
-
-        def utcoffset(self, dt):
-            return self.__offset
-
-        def tzname(self, dt):
-            return str(self.__offset.total_seconds() / 3600)
-
-        def __repr__(self):
-            return "<FixedOffset {}>".format(self.tzname(None))
-
-        def dst(self, dt):
-            return datetime.timedelta(0)
-
-        def __getinitargs__(self):
-            return (self.__offset,)
-
-
-try:
-    from datetime import timezone
-
-    TZ_UTC = timezone.utc
-except ImportError:
-    TZ_UTC = UTC()  # type: ignore
+TZ_UTC = datetime.timezone.utc
 
 _FLATTEN = re.compile(r"(?<!\\)\.")
 
@@ -2050,7 +1984,7 @@ class Deserializer:
         try:
             parsed_date = email.utils.parsedate_tz(attr)  # type: ignore
             date_obj = datetime.datetime(
-                *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
+                *parsed_date[:6], tzinfo=datetime.timezone(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
             )
             if not date_obj.tzinfo:
                 date_obj = date_obj.astimezone(tz=TZ_UTC)

package/generator/test/azure/mock_api_tests/conftest.py

@@ -8,9 +8,11 @@ import subprocess
 import signal
 import pytest
 import re
-from typing import Literal
+from typing import Literal, List
 from pathlib import Path
 
+FILE_FOLDER = Path(__file__).parent
+
 
 def start_server_process():
     azure_http_path = Path(os.path.dirname(__file__)) / Path("../../../../node_modules/@azure-tools/azure-http-specs")
@@ -149,3 +151,57 @@ def authentication_policy():
     from azure.core.pipeline.policies import SansIOHTTPPolicy
 
     return SansIOHTTPPolicy()
+
+
+SPECIAL_WORDS = [
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "constructor",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "exec",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield",
+]
+
+
+@pytest.fixture
+def special_words() -> List[str]:
+    return SPECIAL_WORDS
+
+
+@pytest.fixture
+def png_data() -> bytes:
+    with open(str(FILE_FOLDER / "data/image.png"), "rb") as file_in:
+        return file_in.read()
+
+
+@pytest.fixture
+def jpg_data() -> bytes:
+    with open(str(FILE_FOLDER / "data/image.jpg"), "rb") as file_in:
+        return file_in.read()

package/generator/test/generic_mock_api_tests/conftest.py

@@ -9,7 +9,6 @@ import signal
 import pytest
 import importlib
 from pathlib import Path
-from typing import List
 
 FILE_FOLDER = Path(__file__).parent
 
@@ -64,48 +63,6 @@ def key_credential(core_library):
         return core_library.credentials.ServiceKeyCredential
 
 
-SPECIAL_WORDS = [
-    "and",
-    "as",
-    "assert",
-    "async",
-    "await",
-    "break",
-    "class",
-    "constructor",
-    "continue",
-    "def",
-    "del",
-    "elif",
-    "else",
-    "except",
-    "exec",
-    "finally",
-    "for",
-    "from",
-    "global",
-    "if",
-    "import",
-    "in",
-    "is",
-    "lambda",
-    "not",
-    "or",
-    "pass",
-    "raise",
-    "return",
-    "try",
-    "while",
-    "with",
-    "yield",
-]
-
-
-@pytest.fixture
-def special_words() -> List[str]:
-    return SPECIAL_WORDS
-
-
 @pytest.fixture
 def png_data() -> bytes:
     with open(str(FILE_FOLDER / "data/image.png"), "rb") as file_in:

package/generator/test/unbranded/mock_api_tests/asynctests/test_encode_duration_async.py

@@ -0,0 +1,63 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import datetime
+
+import pytest
+from encode.duration.aio import DurationClient
+from encode.duration.property.models import (
+    Int32SecondsDurationProperty,
+    ISO8601DurationProperty,
+    FloatSecondsDurationProperty,
+    DefaultDurationProperty,
+    FloatSecondsDurationArrayProperty,
+)
+
+
+@pytest.fixture
+async def client():
+    async with DurationClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+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_array(input=[36, 47])
+    await client.query.float_seconds(input=35.625)
+    await client.query.float64_seconds(input=35.625)
+
+
+@pytest.mark.asyncio
+async def test_property(client: DurationClient):
+    result = await client.property.default(DefaultDurationProperty(value=datetime.timedelta(days=40)))
+    assert result.value == datetime.timedelta(days=40)
+    result = await client.property.default(DefaultDurationProperty(value="P40D"))
+    assert result.value == datetime.timedelta(days=40)
+    result = await client.property.iso8601(ISO8601DurationProperty(value=datetime.timedelta(days=40)))
+    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(FloatSecondsDurationProperty(value=35.625))
+    assert abs(result.value - 35.625) < 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
+
+
+@pytest.mark.asyncio
+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.float_seconds(duration=35.625)
+    await client.header.float64_seconds(duration=35.625)

package/generator/test/unbranded/mock_api_tests/asynctests/test_encode_numeric_async.py

@@ -0,0 +1,35 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from encode.numeric.aio import NumericClient
+from encode.numeric.property import models
+
+
+@pytest.fixture
+async def client():
+    async with NumericClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_safeint_as_string(client: NumericClient):
+    result = await client.property.safeint_as_string(models.SafeintAsStringProperty(value=10000000000))
+    assert result.value == 10000000000
+    assert result["value"] == "10000000000"
+
+
+@pytest.mark.asyncio
+async def test_uint32_as_string_optional(client: NumericClient):
+    result = await client.property.uint32_as_string_optional(models.Uint32AsStringProperty(value=1))
+    assert result.value == 1
+    assert result["value"] == "1"
+
+
+@pytest.mark.asyncio
+async def test_uint8_as_string_optional(client: NumericClient):
+    result = await client.property.uint8_as_string(models.Uint32AsStringProperty(value=255))
+    assert result.value == 255
+    assert result["value"] == "255"

package/generator/test/unbranded/mock_api_tests/asynctests/test_parameters_basic_async.py

@@ -0,0 +1,24 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from parameters.basic.aio import BasicClient
+from parameters.basic.explicitbody.models import User
+
+
+@pytest.fixture
+async def client():
+    async with BasicClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_explicit_simple(client: BasicClient):
+    await client.explicit_body.simple(User(name="foo"))
+
+
+@pytest.mark.asyncio
+async def test_implicit_simple(client: BasicClient):
+    await client.implicit_body.simple(name="foo")

package/generator/test/unbranded/mock_api_tests/asynctests/test_parameters_spread_async.py

@@ -0,0 +1,76 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from parameters.spread.aio import SpreadClient
+from parameters.spread.model.models import BodyParameter
+
+
+@pytest.fixture
+async def client():
+    async with SpreadClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_model_body(client: SpreadClient):
+    await client.model.spread_as_request_body(name="foo")
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request_only_with_body(client: SpreadClient):
+    await client.model.spread_composite_request_only_with_body(BodyParameter(name="foo"))
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request_without_body(client: SpreadClient):
+    await client.model.spread_composite_request_without_body(name="foo", test_header="bar")
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request(client: SpreadClient):
+    await client.model.spread_composite_request(name="foo", body=BodyParameter(name="foo"), test_header="bar")
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request_mix(client: SpreadClient):
+    await client.model.spread_composite_request_mix(name="foo", prop="foo", test_header="bar")
+
+
+@pytest.mark.asyncio
+async def test_alias_body(client: SpreadClient):
+    await client.alias.spread_as_request_body(name="foo")
+
+
+@pytest.mark.asyncio
+async def test_alias_parameter(client: SpreadClient):
+    await client.alias.spread_as_request_parameter("1", x_ms_test_header="bar", name="foo")
+
+
+@pytest.mark.asyncio
+async def test_alias_multiple_parameter(client: SpreadClient):
+    await client.alias.spread_with_multiple_parameters(
+        "1",
+        x_ms_test_header="bar",
+        required_string="foo",
+        required_int_list=[1, 2],
+        optional_string_list=["foo", "bar"],
+        optional_int=1,
+    )
+    await client.alias.spread_with_multiple_parameters(
+        "1",
+        {"requiredString": "foo", "optionalInt": 1, "requiredIntList": [1, 2], "optionalStringList": ["foo", "bar"]},
+        x_ms_test_header="bar",
+    )
+
+
+@pytest.mark.asyncio
+async def test_inner_model(client: SpreadClient):
+    await client.alias.spread_parameter_with_inner_model(id="1", x_ms_test_header="bar", body={"name": "foo"})
+
+
+@pytest.mark.asyncio
+async def test_inner_alias(client: SpreadClient):
+    await client.alias.spread_parameter_with_inner_alias(id="1", x_ms_test_header="bar", body={"name": "foo", "age": 1})

package/generator/test/unbranded/mock_api_tests/asynctests/test_payload_content_negotiation_async.py

@@ -0,0 +1,37 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import base64
+import pytest
+from payload.contentnegotiation.aio import ContentNegotiationClient
+from payload.contentnegotiation.differentbody.models import PngImageAsJson
+
+
+@pytest.fixture
+async def client():
+    async with ContentNegotiationClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_get_avatar_as_png(client: ContentNegotiationClient, png_data: bytes):
+    assert b"".join([d async for d in (await client.same_body.get_avatar_as_png())]) == png_data
+
+
+@pytest.mark.asyncio
+async def test_get_avatar_as_jpeg(client: ContentNegotiationClient, jpg_data: bytes):
+    assert b"".join([d async for d in (await client.same_body.get_avatar_as_jpeg())]) == jpg_data
+
+
+@pytest.mark.asyncio
+async def test_different_body_get_avatar_as_png(client: ContentNegotiationClient, png_data: bytes):
+    assert b"".join([d async for d in (await client.different_body.get_avatar_as_png())]) == png_data
+
+
+@pytest.mark.asyncio
+async def test_different_body_get_avatar_as_json(client: ContentNegotiationClient, png_data: bytes):
+    result = await client.different_body.get_avatar_as_json()
+    expected = PngImageAsJson(content=base64.b64encode(png_data).decode())
+    assert result == expected

package/generator/test/unbranded/mock_api_tests/asynctests/test_payload_multipart_async.py

@@ -0,0 +1,154 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from pathlib import Path
+import pytest
+from payload.multipart import models
+from payload.multipart.aio import MultiPartClient
+from payload.multipart.formdata.httpparts.nonstring.models import FloatRequest
+
+JPG = Path(__file__).parent.parent / "data/image.jpg"
+PNG = Path(__file__).parent.parent / "data/image.png"
+
+
+@pytest.fixture
+async def client():
+    async with MultiPartClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_anonymous_model(client: MultiPartClient):
+    await client.form_data.anonymous_model({"profileImage": open(str(JPG), "rb")})
+
+
+@pytest.mark.asyncio
+async def test_basic(client: MultiPartClient):
+    await client.form_data.basic(
+        models.MultiPartRequest(
+            id="123",
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_binary_array_parts(client: MultiPartClient):
+    await client.form_data.binary_array_parts(
+        models.BinaryArrayPartsRequest(
+            id="123",
+            pictures=[
+                open(str(PNG), "rb"),
+                open(str(PNG), "rb"),
+            ],
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_check_file_name_and_content_type(client: MultiPartClient):
+    await client.form_data.check_file_name_and_content_type(
+        models.MultiPartRequest(
+            id="123",
+            profile_image=("hello.jpg", open(str(JPG), "rb"), "image/jpg"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_complex(client: MultiPartClient):
+    await client.form_data.file_array_and_basic(
+        models.ComplexPartsRequest(
+            id="123",
+            address=models.Address(city="X"),
+            pictures=[
+                open(str(PNG), "rb"),
+                open(str(PNG), "rb"),
+            ],
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_json_part(client: MultiPartClient):
+    await client.form_data.json_part(
+        models.JsonPartRequest(
+            address=models.Address(city="X"),
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_multi_binary_parts(client: MultiPartClient):
+    await client.form_data.multi_binary_parts(
+        models.MultiBinaryPartsRequest(
+            profile_image=open(str(JPG), "rb"),
+            picture=open(str(PNG), "rb"),
+        )
+    )
+    await client.form_data.multi_binary_parts(
+        models.MultiBinaryPartsRequest(
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_file_with_http_part_specific_content_type(client: MultiPartClient):
+    await client.form_data.http_parts.content_type.image_jpeg_content_type(
+        models.FileWithHttpPartSpecificContentTypeRequest(
+            profile_image=("hello.jpg", open(str(JPG), "rb"), "image/jpg"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_file_with_http_part_required_content_type(client: MultiPartClient):
+    await client.form_data.http_parts.content_type.required_content_type(
+        models.FileWithHttpPartRequiredContentTypeRequest(
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_file_with_http_part_optional_content_type(client: MultiPartClient):
+    # call twice: one with content type, one without
+    await client.form_data.http_parts.content_type.optional_content_type(
+        models.FileWithHttpPartOptionalContentTypeRequest(
+            profile_image=("hello.jpg", open(str(JPG), "rb").read()),
+        )
+    )
+    await client.form_data.http_parts.content_type.optional_content_type(
+        models.FileWithHttpPartOptionalContentTypeRequest(
+            profile_image=("hello.jpg", open(str(JPG), "rb").read(), "application/octet-stream"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_complex_with_http_part(client: MultiPartClient):
+    await client.form_data.http_parts.json_array_and_file_array(
+        models.ComplexHttpPartsModelRequest(
+            id="123",
+            previous_addresses=[
+                models.Address(city="Y"),
+                models.Address(city="Z"),
+            ],
+            address=models.Address(city="X"),
+            pictures=[
+                open(str(PNG), "rb"),
+                open(str(PNG), "rb"),
+            ],
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_http_parts_non_string_float(client: MultiPartClient):
+    await client.form_data.http_parts.non_string.float(FloatRequest(temperature=0.5))

package/generator/test/unbranded/mock_api_tests/asynctests/test_serialization_encoded_name_json_async.py

@@ -0,0 +1,24 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from serialization.encodedname.json.aio import JsonClient
+from serialization.encodedname.json.property import models
+
+
+@pytest.fixture
+async def client():
+    async with JsonClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_property_send(client: JsonClient):
+    await client.property.send(models.JsonEncodedNameModel(default_name=True))
+
+
+@pytest.mark.asyncio
+async def test_property_get(client: JsonClient):
+    assert (await client.property.get()).default_name

package/generator/test/unbranded/mock_api_tests/asynctests/test_special_words_async.py

@@ -0,0 +1,43 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from specialwords.aio import SpecialWordsClient
+from specialwords.models import models
+from specialwords.modelproperties import models as model_properties_models
+
+
+@pytest.fixture
+async def client():
+    async with SpecialWordsClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_operations(client: SpecialWordsClient, special_words):
+    for sw in special_words:
+        suffix = "" if sw == "constructor" else "_method"
+        await getattr(client.operations, sw + suffix)()
+
+
+@pytest.mark.asyncio
+async def test_parameter(client: SpecialWordsClient, special_words):
+    for sw in special_words:
+        suffix = "" if sw == "constructor" else "_parameter"
+        await getattr(client.parameters, "with_" + sw)(**{sw + suffix: "ok"})
+    await client.parameters.with_cancellation_token(cancellation_token="ok")
+
+
+@pytest.mark.asyncio
+async def test_model(client: SpecialWordsClient, special_words):
+    for sw in special_words:
+        suffix = "" if sw == "constructor" else "Model"
+        model = getattr(models, sw.capitalize() + suffix)
+        await getattr(client.models, "with_" + sw)(model(name="ok"))
+
+
+@pytest.mark.asyncio
+async def test_model_properties(client: SpecialWordsClient):
+    await client.model_properties.same_as_model(model_properties_models.SameAsModel(same_as_model="ok"))