@typespec/http-client-python 0.38.1 → 0.39.0

package/emitter/test/emitter.test.ts

@@ -1,6 +1,40 @@
 import { expectDiagnostics, t } from "@typespec/compiler/testing";
 import { expect, it } from "vitest";
-import { emitCodeModel } from "./test-host.js";
+import { EmitterTester, emitCodeModel } from "./test-host.js";
+
+it.each([undefined, false, true])(
+  "propagates enable-sse-reconnect=%s to the Python generator",
+  async (enabled) => {
+    const { commandArgs, diagnostics } = await emitCodeModel(
+      "@service namespace Test; op read(): string;",
+      enabled === undefined ? {} : { "enable-sse-reconnect": enabled },
+    );
+
+    expectDiagnostics(diagnostics, []);
+    expect(commandArgs["enable-sse-reconnect"]).toBe(enabled ?? false);
+  },
+);
+
+it.each(["yes", "no", 2, {}, []])("rejects invalid enable-sse-reconnect=%s", async (value) => {
+  const [, diagnostics] = await EmitterTester.compileAndDiagnose(
+    "@service namespace Test; op read(): string;",
+    {
+      compilerOptions: {
+        options: {
+          "@typespec/http-client-python": {
+            "emit-yaml-only": true,
+            "enable-sse-reconnect": value,
+          },
+        },
+      },
+    },
+  );
+
+  expectDiagnostics(diagnostics, {
+    code: "invalid-schema",
+    message: /enable-sse-reconnect/,
+  });
+});
 
 it("targets the service namespace when no SDK clients are found", async () => {
   const { diagnostics } = await emitCodeModel(t.code`

package/emitter/test/test-host.ts

@@ -6,6 +6,7 @@ import jsyaml from "js-yaml";
 import { tmpdir } from "os";
 import { join } from "path";
 import { $onEmit } from "../src/emitter.js";
+import { $lib, type PythonEmitterOptions } from "../src/lib.js";
 
 const PythonTester = createTester(resolvePath(import.meta.dirname, "../.."), {
   libraries: ["@azure-tools/typespec-client-generator-core"],
@@ -20,10 +21,13 @@ export const EmitterTester = PythonTester.files({
   "node_modules/@typespec/http-client-python/package.json": JSON.stringify({
     name: "@typespec/http-client-python",
     version: "0.0.0",
+    tspMain: "./lib.tsp",
     exports: { ".": "./index.js" },
   }),
+  "node_modules/@typespec/http-client-python/lib.tsp": 'import "./index.js";',
   "node_modules/@typespec/http-client-python/index.js": mockFile.js({
     $onEmit,
+    $lib,
   }),
 }).emit("@typespec/http-client-python", {
   "generate-packaging-files": false,
@@ -48,7 +52,12 @@ export interface CodeModel {
  */
 export async function emitCodeModel(
   code: string,
-): Promise<{ codeModel: CodeModel; diagnostics: readonly Diagnostic[] }> {
+  options: PythonEmitterOptions = {},
+): Promise<{
+  codeModel: CodeModel;
+  commandArgs: Record<string, unknown>;
+  diagnostics: readonly Diagnostic[];
+}> {
   const outputDir = await mkdtemp(join(tmpdir(), "typespec-python-"));
   let yamlPath: string | undefined;
   try {
@@ -56,6 +65,7 @@ export async function emitCodeModel(
       compilerOptions: {
         options: {
           "@typespec/http-client-python": {
+            ...options,
             "emit-yaml-only": true,
             "emitter-output-dir": outputDir,
           },
@@ -71,9 +81,10 @@ export async function emitCodeModel(
     if (!pointerName) {
       throw new Error("Emitter did not produce a code model.");
     }
-    ({ yamlPath } = JSON.parse(await readFile(join(outputDir, pointerName), "utf-8")));
+    const pointer = JSON.parse(await readFile(join(outputDir, pointerName), "utf-8"));
+    ({ yamlPath } = pointer);
     const codeModel = jsyaml.load(await readFile(yamlPath!, "utf-8")) as CodeModel;
-    return { codeModel, diagnostics };
+    return { codeModel, commandArgs: pointer.commandArgs, diagnostics };
   } finally {
     await rm(outputDir, { recursive: true, force: true });
     if (yamlPath) {

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

@@ -80,10 +80,9 @@ export const SpecialFlags: Record<string, Record<string, any>> = {
 
 // ---- Spec-specific emitter option overrides ----
 
-export const AZURE_EMITTER_OPTIONS: Record<
-  string,
-  Record<string, string> | Record<string, string>[]
-> = {
+type EmitterOptions = Record<string, string | boolean>;
+
+export const AZURE_EMITTER_OPTIONS: Record<string, EmitterOptions | EmitterOptions[]> = {
   "azure/client-generator-core/access": {
     namespace: "specs.azure.clientgenerator.core.access",
   },
@@ -222,7 +221,16 @@ export const AZURE_EMITTER_OPTIONS: Record<
   },
 };
 
-export const EMITTER_OPTIONS: Record<string, Record<string, string> | Record<string, string>[]> = {
+export const EMITTER_OPTIONS: Record<string, EmitterOptions | EmitterOptions[]> = {
+  "streaming/sse": [
+    {
+      "enable-sse-reconnect": true,
+    },
+    {
+      "package-name": "streaming-sse-no-reconnect",
+      namespace: "streaming.ssenoreconnect",
+    },
+  ],
   "resiliency/srv-driven/old.tsp": {
     "package-name": "resiliency-srv-driven1",
     namespace: "resiliency.srv.driven1",
@@ -419,7 +427,7 @@ export function getEmitterOptions(
   spec: string,
   flavor: string,
   ctx: RegenerateContext,
-): Record<string, string>[] {
+): EmitterOptions[] {
   const specDir = isAzureSpec(spec) ? ctx.azureHttpSpecs : ctx.httpSpecs;
   const relativeSpec = toPosix(relative(specDir, spec));
   const key = relativeSpec.includes("resiliency/srv-driven/old.tsp")

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

@@ -32,6 +32,7 @@ class OptionsDict(MutableMapping):
         "keep-pyproject-fields": "",
         "generate-test": False,
         "head-as-boolean": True,
+        "enable-sse-reconnect": False,
         "keep-version-file": False,
         "low-level-client": False,
         "no-async": False,
@@ -175,6 +176,9 @@ class OptionsDict(MutableMapping):
             raise ValueError("Can only have tracing turned on for Azure SDKs.")
 
     def _validate_and_transform(self, key: str, value: Any) -> Any:
+        if key == "enable-sse-reconnect" and not isinstance(value, bool):
+            raise ValueError("--enable-sse-reconnect must be a boolean")
+
         if key == "builders-visibility" and value not in ["public", "hidden", "embedded"]:
             raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
 

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

@@ -267,11 +267,12 @@ 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)
+                if self.code_model.options["enable-sse-reconnect"]:
+                    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

@@ -1043,8 +1043,10 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
 
     def call_request_builder(self, builder: OperationType, is_paging: bool = False) -> list[str]:
         retval = self._call_request_builder_helper(builder, builder.request_builder, is_paging=is_paging)
-        if builder.has_structured_stream_response and any(
-            response.streaming_kind == "sse" for response in builder.responses
+        if (
+            self.code_model.options["enable-sse-reconnect"]
+            and builder.has_structured_stream_response
+            and any(response.streaming_kind == "sse" for response in builder.responses)
         ):
             retval.insert(0, '_last_event_id = kwargs.pop("last_event_id", None)')
             retval.extend(
@@ -1396,7 +1398,7 @@ 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]
+        if response.streaming_kind == "sse" and self.code_model.options["enable-sse-reconnect"]:
             retval.append("")
             retval.append(
                 "async def _reconnect(_last_event_id, _reconnect_delay):"

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

@@ -1,4 +1,5 @@
 # coding=utf-8
+{% set enable_sse_reconnect = code_model.options["enable-sse-reconnect"] %}
 {% if code_model.license_header %}
 {{ code_model.license_header }}
 {% endif %}
@@ -33,8 +34,11 @@ from typing import (
 
 from typing_extensions import Self
 
+{% if enable_sse_reconnect %}
 from {{ code_model.core_library }}.exceptions import StreamClosedError, StreamConsumedError
-from {{ code_model.core_library }}.rest import AsyncHttpResponse, HttpRequest, HttpResponse
+from {{ code_model.core_library }}.rest import HttpRequest
+{% endif %}
+from {{ code_model.core_library }}.rest import AsyncHttpResponse, HttpResponse
 
 DecodedType = TypeVar("DecodedType")
 ReturnType_co = TypeVar("ReturnType_co", covariant=True)
@@ -436,6 +440,7 @@ async def _aiter_sse_lines(iter_bytes: AsyncIterator[bytes]) -> AsyncGenerator[s
         yield line
 
 
+{% if enable_sse_reconnect %}
 def _read_sse_response(response: HttpResponse) -> None:
     """Read an SSE response body, ignoring responses that are already consumed or closed.
 
@@ -474,14 +479,22 @@ def _update_sse_request_headers(request: HttpRequest, last_event_id: Optional[st
         request.headers.pop("Last-Event-ID", None)
 
 
+{% endif %}
 class _SSEEventBuilder:
     """Accumulates SSE field lines and builds :class:`ServerSentEvent` instances.
 
+{% if enable_sse_reconnect %}
     :param last_event_id: The initial value of the SSE last event ID buffer.
     :type last_event_id: str
+{% endif %}
     """
 
+{% if enable_sse_reconnect %}
     def __init__(self, last_event_id: str = "") -> None:
+{% else %}
+    def __init__(self) -> None:
+        last_event_id = ""
+{% endif %}
         self._data: List[str] = []
         self._event_type = ""
         self._last_id = last_event_id
@@ -565,12 +578,19 @@ class SSEDecoder:
 
     https://html.spec.whatwg.org/multipage/server-sent-events.html
 
+{% if enable_sse_reconnect %}
     :keyword last_event_id: The initial value of the SSE last event ID buffer.
     :paramtype last_event_id: str or None
+{% endif %}
     """
 
+{% if enable_sse_reconnect %}
     def __init__(self, *, last_event_id: Optional[str] = None) -> None:
         self._builder = _SSEEventBuilder(last_event_id or "")
+{% else %}
+    def __init__(self) -> None:
+        self._builder = _SSEEventBuilder()
+{% endif %}
 
     @property
     def last_event_id(self) -> str:
@@ -609,12 +629,19 @@ class AsyncSSEDecoder:
 
     https://html.spec.whatwg.org/multipage/server-sent-events.html
 
+{% if enable_sse_reconnect %}
     :keyword last_event_id: The initial value of the SSE last event ID buffer.
     :paramtype last_event_id: str or None
+{% endif %}
     """
 
+{% if enable_sse_reconnect %}
     def __init__(self, *, last_event_id: Optional[str] = None) -> None:
         self._builder = _SSEEventBuilder(last_event_id or "")
+{% else %}
+    def __init__(self) -> None:
+        self._builder = _SSEEventBuilder()
+{% endif %}
 
     @property
     def last_event_id(self) -> str:
@@ -672,6 +699,7 @@ class Stream(Iterator[ReturnType_co]):
     :keyword terminal_event_predicate: Optional predicate that identifies a payload-bearing
         terminal event. The event is yielded before iteration stops.
     :paramtype terminal_event_predicate: Callable[[Any], bool] or None
+{% if enable_sse_reconnect %}
     :keyword last_event_id: Optional event ID from which this stream is resuming.
     :paramtype last_event_id: str or None
     :keyword reconnect_callback: Optional callback used to re-establish the underlying response
@@ -680,6 +708,7 @@ class Stream(Iterator[ReturnType_co]):
         called with the last-seen SSE event ID (or ``None``) and the reconnect delay in seconds,
         and must return a new response.
     :paramtype reconnect_callback: Callable[[str or None, float], ~{{ code_model.core_library }}.rest.HttpResponse] or None
+{% endif %}
     """
 
     def __init__(
@@ -691,8 +720,10 @@ class Stream(Iterator[ReturnType_co]):
         terminal_event: Optional[str] = None,
         terminal_event_names: Optional[Sequence[str]] = None,
         terminal_event_predicate: Optional[Callable[[DecodedType], bool]] = None,
+{% if enable_sse_reconnect %}
         last_event_id: Optional[str] = None,
         reconnect_callback: Optional[Callable[[Optional[str], float], HttpResponse]] = None,
+{% endif %}
     ) -> None:
         self._response = response
         content_type = response.headers.get("Content-Type", "").split(";", 1)[0].strip().lower()
@@ -700,7 +731,7 @@ class Stream(Iterator[ReturnType_co]):
             decoder
             if decoder is not None
             else (
-                SSEDecoder(last_event_id=last_event_id)
+                SSEDecoder({% if enable_sse_reconnect %}last_event_id=last_event_id{% endif %})
                 if content_type == "text/event-stream"
                 else JSONLDecoder()
             )
@@ -709,8 +740,12 @@ class Stream(Iterator[ReturnType_co]):
         self._terminal_event = terminal_event
         self._terminal_event_names = frozenset(terminal_event_names or ())
         self._terminal_event_predicate = terminal_event_predicate
+{% if enable_sse_reconnect %}
         self._reconnect_callback = reconnect_callback
         self._last_event_id = last_event_id
+{% else %}
+        self._last_event_id: Optional[str] = None
+{% endif %}
         self._retry: Optional[int] = None
         self._iterator = self._iter_results()
 
@@ -731,7 +766,9 @@ class Stream(Iterator[ReturnType_co]):
         return self
 
     def _iter_results(self) -> Generator[ReturnType_co, None, None]:
+{% if enable_sse_reconnect %}
         terminal = False
+{% endif %}
         try:
             while True:
                 if getattr(self._response, "status_code", None) == 204:
@@ -744,7 +781,9 @@ class Stream(Iterator[ReturnType_co]):
                     if event_retry is not None:
                         self._retry = event_retry
                     if self._terminal_event is not None and getattr(event, "data", None) == self._terminal_event:
+{% if enable_sse_reconnect %}
                         terminal = True
+{% endif %}
                         break
                     result = self._deserialization_callback(self._response, cast(Any, event))
                     yield result
@@ -755,14 +794,17 @@ class Stream(Iterator[ReturnType_co]):
                         self._terminal_event_predicate is not None
                         and self._terminal_event_predicate(cast(Any, event))
                     ):
+{% if enable_sse_reconnect %}
                         terminal = True
+{% endif %}
                         break
-                if terminal or self._reconnect_callback is None:
-                    break
                 if isinstance(self._decoder, SSEDecoder):
                     self._last_event_id = self._decoder.last_event_id
                     if self._decoder.retry is not None:
                         self._retry = self._decoder.retry
+{% if enable_sse_reconnect %}
+                if terminal or self._reconnect_callback is None:
+                    break
                 self._response.close()
                 reconnect_delay = (self._retry if self._retry is not None else 3000) / 1000
                 self._response = self._reconnect_callback(self._last_event_id, reconnect_delay)
@@ -771,6 +813,9 @@ class Stream(Iterator[ReturnType_co]):
                     if isinstance(self._decoder, SSEDecoder)
                     else type(self._decoder)()
                 )
+{% else %}
+                break
+{% endif %}
         finally:
             self._response.close()
 
@@ -814,6 +859,7 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
     :keyword terminal_event_predicate: Optional predicate that identifies a payload-bearing
         terminal event. The event is yielded before iteration stops.
     :paramtype terminal_event_predicate: Callable[[Any], bool] or None
+{% if enable_sse_reconnect %}
     :keyword last_event_id: Optional event ID from which this stream is resuming.
     :paramtype last_event_id: str or None
     :keyword reconnect_callback: Optional callback used to re-establish the underlying response
@@ -822,6 +868,7 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
         called with the last-seen SSE event ID (or ``None``) and the reconnect delay in seconds,
         and must resolve to a new response.
     :paramtype reconnect_callback: Callable[[str or None, float], Any] or None
+{% endif %}
     """
 
     def __init__(
@@ -833,8 +880,10 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
         terminal_event: Optional[str] = None,
         terminal_event_names: Optional[Sequence[str]] = None,
         terminal_event_predicate: Optional[Callable[[DecodedType], bool]] = None,
+{% if enable_sse_reconnect %}
         last_event_id: Optional[str] = None,
         reconnect_callback: Optional[Callable[[Optional[str], float], Any]] = None,
+{% endif %}
     ) -> None:
         self._response = response
         content_type = response.headers.get("Content-Type", "").split(";", 1)[0].strip().lower()
@@ -842,7 +891,7 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
             decoder
             if decoder is not None
             else (
-                AsyncSSEDecoder(last_event_id=last_event_id)
+                AsyncSSEDecoder({% if enable_sse_reconnect %}last_event_id=last_event_id{% endif %})
                 if content_type == "text/event-stream"
                 else AsyncJSONLDecoder()
             )
@@ -851,8 +900,12 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
         self._terminal_event = terminal_event
         self._terminal_event_names = frozenset(terminal_event_names or ())
         self._terminal_event_predicate = terminal_event_predicate
+{% if enable_sse_reconnect %}
         self._reconnect_callback = reconnect_callback
         self._last_event_id = last_event_id
+{% else %}
+        self._last_event_id: Optional[str] = None
+{% endif %}
         self._retry: Optional[int] = None
         self._iterator = self._iter_results()
 
@@ -873,7 +926,9 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
         return self
 
     async def _iter_results(self) -> AsyncGenerator[ReturnType_co, None]:
+{% if enable_sse_reconnect %}
         terminal = False
+{% endif %}
         try:
             while True:
                 if getattr(self._response, "status_code", None) == 204:
@@ -888,7 +943,9 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
                         if event_retry is not None:
                             self._retry = event_retry
                         if self._terminal_event is not None and getattr(event, "data", None) == self._terminal_event:
+{% if enable_sse_reconnect %}
                             terminal = True
+{% endif %}
                             break
                         result = self._deserialization_callback(self._response, cast(Any, event))
                         yield result
@@ -899,18 +956,21 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
                             self._terminal_event_predicate is not None
                             and self._terminal_event_predicate(cast(Any, event))
                         ):
+{% if enable_sse_reconnect %}
                             terminal = True
+{% endif %}
                             break
                 finally:
                     aclose = getattr(events, "aclose", None)
                     if aclose is not None:
                         await aclose()
-                if terminal or self._reconnect_callback is None:
-                    break
                 if isinstance(self._decoder, AsyncSSEDecoder):
                     self._last_event_id = self._decoder.last_event_id
                     if self._decoder.retry is not None:
                         self._retry = self._decoder.retry
+{% if enable_sse_reconnect %}
+                if terminal or self._reconnect_callback is None:
+                    break
                 await self._response.close()
                 reconnect_delay = (self._retry if self._retry is not None else 3000) / 1000
                 self._response = await self._reconnect_callback(self._last_event_id, reconnect_delay)
@@ -919,6 +979,9 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
                     if isinstance(self._decoder, AsyncSSEDecoder)
                     else type(self._decoder)()
                 )
+{% else %}
+                break
+{% endif %}
         finally:
             await self._response.close()
 

package/generator/pygen/__init__.py

@@ -32,6 +32,7 @@ class OptionsDict(MutableMapping):
         "keep-pyproject-fields": "",
         "generate-test": False,
         "head-as-boolean": True,
+        "enable-sse-reconnect": False,
         "keep-version-file": False,
         "low-level-client": False,
         "no-async": False,
@@ -175,6 +176,9 @@ class OptionsDict(MutableMapping):
             raise ValueError("Can only have tracing turned on for Azure SDKs.")
 
     def _validate_and_transform(self, key: str, value: Any) -> Any:
+        if key == "enable-sse-reconnect" and not isinstance(value, bool):
+            raise ValueError("--enable-sse-reconnect must be a boolean")
+
         if key == "builders-visibility" and value not in ["public", "hidden", "embedded"]:
             raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
 

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

@@ -267,11 +267,12 @@ 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)
+                if self.code_model.options["enable-sse-reconnect"]:
+                    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/pygen/codegen/serializers/builder_serializer.py

@@ -1043,8 +1043,10 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
 
     def call_request_builder(self, builder: OperationType, is_paging: bool = False) -> list[str]:
         retval = self._call_request_builder_helper(builder, builder.request_builder, is_paging=is_paging)
-        if builder.has_structured_stream_response and any(
-            response.streaming_kind == "sse" for response in builder.responses
+        if (
+            self.code_model.options["enable-sse-reconnect"]
+            and builder.has_structured_stream_response
+            and any(response.streaming_kind == "sse" for response in builder.responses)
         ):
             retval.insert(0, '_last_event_id = kwargs.pop("last_event_id", None)')
             retval.extend(
@@ -1396,7 +1398,7 @@ 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]
+        if response.streaming_kind == "sse" and self.code_model.options["enable-sse-reconnect"]:
             retval.append("")
             retval.append(
                 "async def _reconnect(_last_event_id, _reconnect_delay):"