@typespec/http-client-python 0.37.3 → 0.38.1

package/eng/scripts/ci/regenerate-common.ts

@@ -120,6 +120,9 @@ export const AZURE_EMITTER_OPTIONS: Record<
   "azure/client-generator-core/override": {
     namespace: "specs.azure.clientgenerator.core.override",
   },
+  "azure/client-generator-core/response-replacement": {
+    namespace: "specs.azure.clientgenerator.core.responsereplacement",
+  },
   "azure/client-generator-core/hierarchy-building": {
     namespace: "specs.azure.clientgenerator.core.hierarchybuilding",
   },

package/generator/build/lib/pygen/codegen/models/response.py

@@ -267,6 +267,11 @@ class Response(BaseModel):
             file_import.add_submodule_import(relative_path, stream_class, ImportType.LOCAL)
             if self.streaming_kind == "sse":
                 file_import.add_import("json", ImportType.STDLIB)
+                read_response_helper = (
+                    "_read_sse_response_async" if kwargs.get("async_mode", False) else "_read_sse_response"
+                )
+                file_import.add_submodule_import(relative_path, read_response_helper, ImportType.LOCAL)
+                file_import.add_submodule_import(relative_path, "_update_sse_request_headers", ImportType.LOCAL)
                 for event in self.streaming_events:
                     file_import.merge(event.payload_type.imports(**kwargs))
         return file_import

package/generator/build/lib/pygen/codegen/serializers/builder_serializer.py

@@ -1150,22 +1150,36 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         return retval
 
     def handle_error_response(  # pylint: disable=too-many-statements, too-many-branches
-        self, builder: OperationType
+        self,
+        builder: OperationType,
+        *,
+        response_name: str = "response",
+        pipeline_response_name: str = "pipeline_response",
+        success_status_codes: Optional[list[int]] = None,
+        stream_value: Optional[Union[str, bool]] = None,
+        response_read_name: Optional[str] = None,
     ) -> list[str]:
         async_await = "await " if self.async_mode else ""
-        retval = [f"if response.status_code not in {str(builder.success_status_codes)}:"]
-        response_read = [
-            "    try:",
-            f"        {async_await}response.read()  # Load the body in memory and close the socket",
-            "    except (StreamConsumedError, StreamClosedError):",
-            "        pass",
-        ]
-        if builder.stream_value is True:  # _stream is True so no need to judge it
+        success_status_codes = builder.success_status_codes if success_status_codes is None else success_status_codes
+        stream_value = builder.stream_value if stream_value is None else stream_value
+        retval = [f"if {response_name}.status_code not in {str(success_status_codes)}:"]
+        if response_read_name:
+            response_read = [f"    {async_await}{response_read_name}({response_name})"]
+        else:
+            response_read = [
+                "    try:",
+                f"        {async_await}{response_name}.read()  # Load the body in memory and close the socket",
+                "    except (StreamConsumedError, StreamClosedError):",
+                "        pass",
+            ]
+        if stream_value is True:  # _stream is True so no need to judge it
             retval.extend(response_read)
-        elif isinstance(builder.stream_value, str):  # _stream is not sure, so we need to judge it
+        elif isinstance(stream_value, str):  # _stream is not sure, so we need to judge it
             retval.append("    if _stream:")
             retval.extend([f"    {l}" for l in response_read])
-        retval.append("    map_error(status_code=response.status_code, response=response, error_map=error_map)")
+        retval.append(
+            f"    map_error(status_code={response_name}.status_code, " f"response={response_name}, error_map=error_map)"
+        )
         error_model = ""
         if builder.non_default_errors and (  # pylint: disable=too-many-nested-blocks
             self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only
@@ -1181,7 +1195,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     pylint_disable = ""
                 if isinstance(e.status_codes[0], int):
                     for status_code in e.status_codes:
-                        retval.append(f"    {condition} response.status_code == {status_code}:")
+                        retval.append(f"    {condition} {response_name}.status_code == {status_code}:")
                         type_annotation = e.type.type_annotation(  # type: ignore
                             is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
                         )
@@ -1190,13 +1204,15 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                                 fn = "_failsafe_deserialize_xml"
                             else:
                                 fn = "_failsafe_deserialize"
-                            retval.append(f"        error = {fn}({type_annotation},{pylint_disable}\n  response)")
+                            retval.append(
+                                f"        error = {fn}({type_annotation},{pylint_disable}\n  {response_name})"
+                            )
                         else:
                             retval.extend(
                                 [
                                     "        error = self._deserialize.failsafe_deserialize(",
                                     f"            {type_annotation},{pylint_disable}",
-                                    "            pipeline_response,",
+                                    f"            {pipeline_response_name},",
                                     "        )",
                                 ]
                             )
@@ -1209,7 +1225,8 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 # ranged status code only exist in typespec and will not have multiple status codes
                 else:
                     retval.append(
-                        f"    {condition} {e.status_codes[0][0]} <= response.status_code <= {e.status_codes[0][1]}:"
+                        f"    {condition} {e.status_codes[0][0]} <= "
+                        f"{response_name}.status_code <= {e.status_codes[0][1]}:"
                     )
                     type_annotation = e.type.type_annotation(  # type: ignore
                         is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
@@ -1218,19 +1235,19 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                         if xml_serializable(str(e.default_content_type)):
                             retval.append(
                                 "        error = _failsafe_deserialize_xml("
-                                f"{type_annotation},{pylint_disable}\n  response)"
+                                f"{type_annotation},{pylint_disable}\n  {response_name})"
                             )
                         else:
                             retval.append(
-                                "        error = _failsafe_deserialize("
-                                f"{type_annotation},{pylint_disable}\n  response)"
+                                f"        error = _failsafe_deserialize("
+                                f"{type_annotation},{pylint_disable}\n  {response_name})"
                             )
                     else:
                         retval.extend(
                             [
                                 "        error = self._deserialize.failsafe_deserialize(",
                                 f"            {type_annotation},{pylint_disable}",
-                                "            pipeline_response,",
+                                f"            {pipeline_response_name},",
                                 "        )",
                             ]
                         )
@@ -1254,7 +1271,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     [
                         f"{indent}error = {fn}(",
                         f"{indent}    {default_error_deserialization}",
-                        f"{indent}    response,",
+                        f"{indent}    {response_name},",
                         f"{indent})",
                     ]
                 )
@@ -1263,12 +1280,13 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     [
                         f"{indent}error = self._deserialize.failsafe_deserialize(",
                         f"{indent}    {default_error_deserialization}",
-                        f"{indent}    pipeline_response,",
+                        f"{indent}    {pipeline_response_name},",
                         f"{indent})",
                     ]
                 )
         retval.append(
-            "    raise HttpResponseError(response=response{}{})".format(
+            "    raise HttpResponseError(response={}{}{})".format(
+                response_name,
                 error_model,
                 (", error_format=ARMErrorFormat" if self.code_model.options["azure-arm"] else ""),
             )
@@ -1378,6 +1396,41 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             stream_kwargs.append(f"terminal_event={terminal_event!r}")
         if terminal_event_names:
             stream_kwargs.append(f"terminal_event_names={terminal_event_names!r}")
+        if response.streaming_kind == "sse":  # type: ignore[attr-defined]
+            retval.append("")
+            retval.append(
+                "async def _reconnect(_last_event_id, _reconnect_delay):"
+                if self.async_mode
+                else "def _reconnect(_last_event_id, _reconnect_delay):"
+            )
+            retval.append("    _transport: Any = pipeline_response.context.transport")
+            retval.append(f"    {'await ' if self.async_mode else ''}_transport.sleep(_reconnect_delay)")
+            retval.append("    _update_sse_request_headers(_request, _last_event_id)")
+            retval.append(
+                f"    _reconnect_response = {self._call_method}self._client.send_request("
+                "_request, stream=True, **kwargs)"
+            )
+            reconnect_status_codes = list(builder.success_status_codes)
+            if 204 not in reconnect_status_codes:
+                reconnect_status_codes.append(204)
+            retval.extend(
+                [
+                    f"    {line}"
+                    for line in self.handle_error_response(
+                        builder,
+                        response_name="_reconnect_response",
+                        pipeline_response_name=(
+                            "PipelineResponse(_request, _reconnect_response, pipeline_response.context)"
+                        ),
+                        success_status_codes=reconnect_status_codes,
+                        stream_value=True,
+                        response_read_name=("_read_sse_response_async" if self.async_mode else "_read_sse_response"),
+                    )
+                ]
+            )
+            retval.append("    return _reconnect_response")
+            stream_kwargs.append("last_event_id=_last_event_id")
+            stream_kwargs.append("reconnect_callback=_reconnect")
         unnamed_terminal_values = (
             [discriminator_value for discriminator_value, event in unnamed_discriminator[1] if event.is_terminal]
             if unnamed_discriminator is not None
@@ -1843,7 +1896,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             if builder.lro_response.headers:
                 retval.append("    response_headers = {}")
             if (
-                (not self.code_model.options["models-mode"] and not self.code_model.generate_typeddict_only)
+                not self.code_model.options["models-mode"]
                 or self.code_model.options["models-mode"] == "dpg"
                 or builder.lro_response.headers
             ):

package/generator/build/lib/pygen/codegen/serializers/unions_serializer.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from ..models import CodeModel
+from ..models import CodeModel, CombinedType
 from ..models.imports import FileImport, ImportType
 from ..models.utils import NamespaceType
 from .import_serializer import FileImportSerializer
@@ -18,9 +18,19 @@ class UnionsSerializer(BaseSerializer):
     ):
         super().__init__(code_model=code_model, env=env)
 
+    @property
+    def named_unions(self) -> list[CombinedType]:
+        # The same named union can reach codegen as multiple objects, so collapse
+        # by emitted alias name (keeping insertion order) to avoid duplicate aliases.
+        deduped: dict[str, CombinedType] = {}
+        for union in self.code_model.named_unions:
+            if union.name:
+                deduped.setdefault(union.name, union)
+        return list(deduped.values())
+
     def imports(self) -> FileImport:
         file_import = FileImport(self.code_model)
-        if self.code_model.named_unions:
+        if self.named_unions:
             file_import.add_submodule_import(
                 "typing",
                 "TypeAlias",
@@ -31,7 +41,7 @@ class UnionsSerializer(BaseSerializer):
                 "Union",
                 ImportType.STDLIB,
             )
-        for nu in self.code_model.named_unions:
+        for nu in self.named_unions:
             file_import.merge(
                 nu.imports(
                     serialize_namespace=self.serialize_namespace,
@@ -44,6 +54,7 @@ class UnionsSerializer(BaseSerializer):
         template = self.env.get_template("unions.py.jinja2")
         return template.render(
             code_model=self.code_model,
+            named_unions=self.named_unions,
             imports=FileImportSerializer(self.imports()),
             serializer=self,
         )

package/generator/build/lib/pygen/codegen/templates/enum.py.jinja2

@@ -3,13 +3,13 @@ class {{ enum.name }}({{enum.pylint_disable()}}
   {{ enum.value_type.type_annotation(is_operation_file=False) }}, Enum, metaclass=CaseInsensitiveEnumMeta
 ):
     {% if enum.yaml_data.get("description") %}
-    """{{ op_tools.wrap_string(enum.yaml_data["description"], "\n    ") }}
+    """{{ op_tools.wrap_docstring(enum.yaml_data["description"], "\n    ") }}
     """
     {% endif %}
 
     {% for value in enum.values %}
     {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
     {% if value.description(is_operation_file=False) %}
-    """{{ op_tools.wrap_string(value.description(is_operation_file=False), "\n    ") }}"""
+    """{{ op_tools.wrap_docstring(value.description(is_operation_file=False), "\n    ") }}"""
     {% endif %}
     {% endfor %}

package/generator/build/lib/pygen/codegen/templates/operation_tools.jinja2

@@ -31,6 +31,11 @@
 {%- endif -%}
 {{ normalized_string | replace("\\", "\\\\") | wordwrap(width=width, break_long_words=False, break_on_hyphens=False, wrapstring=wrapstring)}}{% endmacro %}
 
+{# Escape quotes after wrapping so wrapping cannot split an escape sequence. #}
+{% macro wrap_docstring(string, wrapstring, width=95) -%}
+{{ wrap_string(string, wrapstring, width) | replace('"', '\\"') }}
+{%- endmacro %}
+
 {% macro description(builder, serializer) %}
 {% set example_template = serializer.example_template(builder) %}
 {% set param_description_and_response_docstring = serializer.param_description_and_response_docstring(builder) %}