@typespec/http-client-python 0.36.0 → 0.37.1

package/generator/build/lib/pygen/preprocess/__init__.py

@@ -35,6 +35,8 @@ def update_overload_section(
         for overload_s, original_s in zip(overload[section], yaml_data[section]):
             if overload_s.get("type"):
                 overload_s["type"] = original_s["type"]
+            if overload_s.get("streaming"):
+                overload_s["streaming"] = original_s["streaming"]
             if overload_s.get("headers"):
                 for overload_h, original_h in zip(overload_s["headers"], original_s["headers"]):
                     if overload_h.get("type"):

package/generator/component-detection-pip-report.json

@@ -4,7 +4,7 @@
   "install": [
     {
       "download_info": {
-        "url": "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl",
+        "url": "https://pkgs.dev.azure.com/azure-sdk/29ec6040-b234-4e31-b139-33dc4287b756/_packaging/3572dbf9-b5ef-433b-9137-fc4d7768e7cc/pypi/download/setuptools/84/setuptools-84.0.0-py3-none-any.whl",
         "archive_info": {
           "hashes": {
             "sha256": "51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670"
@@ -122,13 +122,13 @@
   ],
   "environment": {
     "implementation_name": "cpython",
-    "implementation_version": "3.11.15",
+    "implementation_version": "3.11.16",
     "os_name": "posix",
     "platform_machine": "x86_64",
-    "platform_release": "6.17.0-1020-azure",
+    "platform_release": "6.17.0-1022-azure",
     "platform_system": "Linux",
-    "platform_version": "#20~24.04.1-Ubuntu SMP Fri Jun 19 20:09:14 UTC 2026",
-    "python_full_version": "3.11.15",
+    "platform_version": "#22-Ubuntu SMP Mon Jul 27 17:24:03 UTC 2026",
+    "python_full_version": "3.11.16",
     "platform_python_implementation": "CPython",
     "python_version": "3.11",
     "sys_platform": "linux"

package/generator/pygen/codegen/models/code_model.py

@@ -279,12 +279,22 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             self.need_utils_utils(async_mode, client_namespace)
             or self.need_utils_serialization
             or self.options["models-mode"] == "dpg"
+            or self.has_structured_stream
         )
 
     @property
     def need_utils_serialization(self) -> bool:
         return not self.options["client-side-validation"]
 
+    @property
+    def has_structured_stream(self) -> bool:
+        return any(
+            op.has_structured_stream_response
+            for client in self.clients
+            for og in client.operation_groups
+            for op in og.operations
+        )
+
     def need_utils_utils(self, async_mode: bool, client_namespace: str) -> bool:
         return (
             self.need_utils_form_data(async_mode, client_namespace)
@@ -395,22 +405,26 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def _sort_model_types_helper(
         self,
         current: ModelType,
-        seen_schema_names: set[str],
+        seen_schema_keys: set[tuple[str, str]],
         seen_schema_yaml_ids: set[int],
     ):
         if current.id in seen_schema_yaml_ids:
             return []
-        if current.name in seen_schema_names:
-            raise ValueError(f"We have already generated a schema with name {current.name}")
+        current_schema_key = (current.client_namespace, current.name)
+        if current_schema_key in seen_schema_keys:
+            raise ValueError(
+                f"We have already generated a schema with name {current.name} "
+                f"in namespace {current.client_namespace}"
+            )
         ancestors = [current]
         if current.parents:
             for parent in current.parents:
                 if parent.id in seen_schema_yaml_ids:
                     continue
-                seen_schema_names.add(current.name)
+                seen_schema_keys.add(current_schema_key)
                 seen_schema_yaml_ids.add(current.id)
-                ancestors = self._sort_model_types_helper(parent, seen_schema_names, seen_schema_yaml_ids) + ancestors
-        seen_schema_names.add(current.name)
+                ancestors = self._sort_model_types_helper(parent, seen_schema_keys, seen_schema_yaml_ids) + ancestors
+        seen_schema_keys.add(current_schema_key)
         seen_schema_yaml_ids.add(current.id)
         return ancestors
 
@@ -420,11 +434,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         :return: None
         :rtype: None
         """
-        seen_schema_names: set[str] = set()
+        seen_schema_keys: set[tuple[str, str]] = set()
         seen_schema_yaml_ids: set[int] = set()
         sorted_object_schemas: list[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
-            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_names, seen_schema_yaml_ids))
+            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_keys, seen_schema_yaml_ids))
         self.model_types = sorted_object_schemas
 
     @property

package/generator/pygen/codegen/models/enum_type.py

@@ -203,6 +203,10 @@ class EnumType(BaseType):
                 model_alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
                 module_name = f"{model_alias}."
             file_name = f"{self.code_model.enums_filename}." if self.internal else ""
+            if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                # In types.py the enum symbol is imported directly (bare name), so no ``_enums.``
+                # module prefix even for internal enums — the prefix would be an undefined name.
+                file_name = ""
             model_name = module_name + file_name + self.name
             # we don't need quoted annotation in operation files, and need it in model folder files.
             if not kwargs.get("is_operation_file", False):
@@ -305,9 +309,17 @@ class EnumType(BaseType):
                         typing_section=TypingSection.REGULAR,
                     )
                 elif serialize_namespace_type == NamespaceType.TYPES_FILE:
-                    # Import enum name directly to avoid dotted forward refs in TypedDict annotations
+                    # Import the enum symbol directly to avoid dotted forward refs in TypedDict
+                    # annotations. Internal enums are not re-exported from the public ``models``
+                    # package, so import them from the private ``_enums`` submodule instead — the
+                    # bare-symbol import (rather than the ``_enums`` module) also avoids name
+                    # collisions when internal enums come from several sibling namespaces.
+                    module_name = f"models.{self.code_model.enums_filename}" if self.internal else "models"
+                    enums_module = self.code_model.get_relative_import_path(
+                        serialize_namespace, self.client_namespace, module_name=module_name
+                    )
                     file_import.add_submodule_import(
-                        f"{relative_path}models" if relative_path != "." else ".models",
+                        enums_module,
                         self.name,
                         ImportType.LOCAL,
                         typing_section=TypingSection.TYPING,

package/generator/pygen/codegen/models/operation.py

@@ -104,6 +104,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             else self.has_stream_response
         )
 
+    @property
+    def has_structured_stream_response(self) -> bool:
+        """Whether any success response is a structured (JSONL / SSE) stream returning Stream[T]."""
+        return any(getattr(r, "is_structured_stream", False) for r in self.responses)
+
     @property
     def has_form_data_body(self):
         return self.parameters.has_form_data_body
@@ -506,7 +511,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
 
     @property
     def has_stream_response(self) -> bool:
-        return any(r.is_stream_response for r in self.responses)
+        return any(r.is_stream_response or r.is_structured_stream for r in self.responses)
 
     @classmethod
     def get_request_builder(cls, yaml_data: dict[str, Any], client: "Client"):

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

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from dataclasses import dataclass
 from typing import Optional, Any, TYPE_CHECKING, Union
 
 from .base import BaseModel
@@ -17,6 +18,53 @@ from .combined_type import CombinedType
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
+DEFAULT_SSE_EVENT_TYPE = "message"
+
+
+@dataclass(frozen=True)
+class StreamingEvent:
+    event_type: Optional[str]
+    payload_type: BaseType
+    payload_content_type: Optional[str]
+    is_terminal: bool
+
+
+def get_streaming_event_discriminator(
+    events: list[StreamingEvent],
+) -> Optional[tuple[str, list[tuple[str, StreamingEvent]]]]:
+    discriminator_name: Optional[str] = None
+    variants: list[tuple[str, StreamingEvent]] = []
+    values: set[str] = set()
+    for event in events:
+        discriminator_property = getattr(event.payload_type, "discriminator_property", None)
+        discriminator_value = getattr(event.payload_type, "discriminator_value", None)
+        if discriminator_property is None or discriminator_value is None:
+            return None
+        if discriminator_name is None:
+            discriminator_name = discriminator_property.wire_name
+        elif discriminator_property.wire_name != discriminator_name:
+            return None
+        if discriminator_value in values:
+            return None
+        values.add(discriminator_value)
+        variants.append((discriminator_value, event))
+    if discriminator_name is None:
+        return None
+    return discriminator_name, variants
+
+
+def _get_terminal_event_names(events: list[StreamingEvent]) -> list[str]:
+    unnamed_events = [event for event in events if event.event_type is None]
+    terminal_event_names: list[str] = []
+    for event in events:
+        if not event.is_terminal:
+            continue
+        if event.event_type is not None:
+            terminal_event_names.append(event.event_type)
+        elif len(unnamed_events) == 1:
+            terminal_event_names.append(DEFAULT_SSE_EVENT_TYPE)
+    return list(dict.fromkeys(terminal_event_names))
+
 
 class ResponseHeader(BaseModel):
     def __init__(
@@ -58,6 +106,25 @@ class Response(BaseModel):
         self.type = type
         self.nullable = yaml_data.get("nullable")
         self.default_content_type = yaml_data.get("defaultContentType")
+        streaming = yaml_data.get("streaming")
+        self.streaming_kind: Optional[str] = streaming["kind"] if streaming else None
+        self.streaming_events: list[StreamingEvent] = []
+        self.terminal_event: Optional[str] = streaming.get("terminalEvent") if streaming else None
+        # Named / model ``@terminalEvent`` events: deserialized and yielded like any other event,
+        # then iteration stops. The bare string-constant sentinel (``terminal_event``)
+        # stops WITHOUT yielding and is matched on event ``data`` instead of the event name.
+        self.terminal_event_names: list[str] = []
+        if streaming:
+            self.streaming_events = [
+                StreamingEvent(
+                    event_type=event.get("eventType"),
+                    payload_type=self.code_model.lookup_type(id(event["payloadType"])),
+                    payload_content_type=event.get("payloadContentType"),
+                    is_terminal=event.get("isTerminal", False),
+                )
+                for event in streaming.get("events", [])
+            ]
+            self.terminal_event_names = _get_terminal_event_names(self.streaming_events)
 
     @property
     def result_property(self) -> str:
@@ -92,12 +159,48 @@ class Response(BaseModel):
         )
         return retval
 
+    @property
+    def is_structured_stream(self) -> bool:
+        """Is the response a structured (JSONL / SSE) stream rendered as Stream[T] / AsyncStream[T]."""
+        return self.streaming_kind is not None
+
+    def stream_class_name(self, async_mode: bool) -> str:
+        return "AsyncStream" if async_mode else "Stream"
+
+    @property
+    def stream_item_type(self) -> Optional[BaseType]:
+        event_item_types = list(dict.fromkeys(event.payload_type for event in self.streaming_events))
+        if len(event_item_types) == 1:
+            return event_item_types[0]
+        if event_item_types:
+            return CombinedType({"type": "combined"}, self.code_model, event_item_types)
+        return self.type
+
     def serialization_type(self, **kwargs: Any) -> str:
         if self.type:
             return self.type.serialization_type(**kwargs)
         return "None"
 
+    def stream_item_annotation(self, **kwargs: Any) -> str:
+        """Valid type expression for a structured stream's item type.
+
+        A named ``CombinedType`` (``@events`` union) renders its ``type_annotation`` as the
+        ``_unions.<Name>`` alias, which is a module-level variable and therefore rejected by
+        pyright/mypy inside ``Stream[...]`` ("Variable not allowed in type expression"). Expand
+        the union inline (``Union[Model, ...]`` / the single member) so the annotation is a
+        valid type expression.
+        """
+        item_type = self.stream_item_type
+        if isinstance(item_type, CombinedType):
+            return item_type.type_definition(**kwargs)
+        return item_type.type_annotation(**kwargs) if item_type else "None"
+
     def type_annotation(self, **kwargs: Any) -> str:
+        if self.is_structured_stream and self.type:
+            kwargs["is_operation_file"] = True
+            kwargs["is_response"] = True
+            stream_class = self.stream_class_name(kwargs.get("async_mode", False))
+            return f"{stream_class}[{self.stream_item_annotation(**kwargs)}]"
         if self.type:
             kwargs["is_operation_file"] = True
             kwargs["is_response"] = True
@@ -109,30 +212,63 @@ class Response(BaseModel):
 
     def docstring_text(self, **kwargs: Any) -> str:
         kwargs["is_response"] = True
+        if self.is_structured_stream and self.type:
+            stream_class = self.stream_class_name(kwargs.get("async_mode", False))
+            item_type = self.stream_item_type or self.type
+            return f"An instance of {stream_class} that iterates over {item_type.docstring_text(**kwargs)}"
         if self.nullable and self.type:
             return f"{self.type.docstring_text(**kwargs)} or None"
         return self.type.docstring_text(**kwargs) if self.type else "None"
 
     def docstring_type(self, **kwargs: Any) -> str:
         kwargs["is_response"] = True
+        if self.is_structured_stream and self.type:
+            stream_class = self.stream_class_name(kwargs.get("async_mode", False))
+            item_type = (self.stream_item_type or self.type).docstring_type(**kwargs)
+            return f"~{self.code_model.namespace}.{stream_class}[{item_type}]"
         if self.nullable and self.type:
             return f"{self.type.docstring_type(**kwargs)} or None"
         return self.type.docstring_type(**kwargs) if self.type else "None"
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        if self.type:
-            file_import.merge(self.type.imports(**kwargs))
+        item_type = self.stream_item_type if self.is_structured_stream else self.type
+        # For a structured stream whose item type is a named ``@events`` union, the annotation
+        # is expanded inline (see ``stream_item_annotation``), so import the union member types
+        # rather than the ``_unions`` alias.
+        if self.is_structured_stream and isinstance(item_type, CombinedType):
+            for member in item_type.types:
+                file_import.merge(member.imports(**kwargs))
+            # ``Union`` is only needed when the inline expansion actually yields a union of
+            # 2+ distinct member types (a single member collapses to that member; a union of
+            # only literals collapses to a single ``Literal[...]``).
+            distinct = list(dict.fromkeys(m.type_annotation(**kwargs) for m in item_type.types))
+            all_constant = all(t.type == "constant" for t in item_type.types)
+            if len(distinct) > 1 and not all_constant:
+                file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+        elif item_type:
+            file_import.merge(item_type.imports(**kwargs))
+            if not self.is_structured_stream and isinstance(item_type, CombinedType) and item_type.name:
+                serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+                file_import.add_submodule_import(
+                    self.code_model.get_relative_import_path(serialize_namespace),
+                    "_unions",
+                    ImportType.LOCAL,
+                    TypingSection.TYPING,
+                )
         if self.nullable:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-        if isinstance(self.type, CombinedType) and self.type.name:
+        if self.is_structured_stream:
+            stream_class = self.stream_class_name(kwargs.get("async_mode", False))
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
-            file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(serialize_namespace),
-                "_unions",
-                ImportType.LOCAL,
-                TypingSection.TYPING,
+            relative_path = self.code_model.get_relative_import_path(
+                serialize_namespace, module_name="_utils.streaming_base"
             )
+            file_import.add_submodule_import(relative_path, stream_class, ImportType.LOCAL)
+            if self.streaming_kind == "sse":
+                file_import.add_import("json", ImportType.STDLIB)
+                for event in self.streaming_events:
+                    file_import.merge(event.payload_type.imports(**kwargs))
         return file_import
 
     def _get_import_type(self, input_path: str) -> ImportType:
@@ -143,6 +279,14 @@ class Response(BaseModel):
 
     @classmethod
     def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "Response":
+        streaming = yaml_data.get("streaming")
+        if streaming:
+            return cls(
+                yaml_data=yaml_data,
+                code_model=code_model,
+                headers=[ResponseHeader.from_yaml(header, code_model) for header in yaml_data["headers"]],
+                type=code_model.lookup_type(id(streaming["itemType"])),
+            )
         type = code_model.lookup_type(id(yaml_data["type"])) if yaml_data.get("type") else None
         # use ByteIteratorType if we are returning a binary type
         default_content_type = yaml_data.get("defaultContentType", "application/json")

package/generator/pygen/codegen/serializers/__init__.py

@@ -525,6 +525,13 @@ class JinjaSerializer(ReaderAndWriter):
                 general_serializer.serialize_model_base_file(),
             )
 
+        # write _utils/streaming_base.py (vendored Stream/AsyncStream + JSONL/SSE decoders)
+        if self.code_model.has_structured_stream:
+            self.write_file(
+                utils_folder_path / Path("streaming_base.py"),
+                general_serializer.serialize_streaming_base_file(),
+            )
+
     def _serialize_and_write_top_level_folder(self, env: Environment, namespace: str) -> None:
         root_dir = self.code_model.get_root_dir()
         generation_dir = self.code_model.get_generation_dir(namespace)