@typespec/http-client-python 0.35.0 → 0.36.0

package/emitter/test/browser-pyodide.test.ts

@@ -0,0 +1,25 @@
+import { strictEqual } from "assert";
+import { afterEach, describe, it, vi } from "vitest";
+
+const loadPyodide = vi.hoisted(() => vi.fn());
+
+vi.mock("../src/pyodide-loader.js", () => ({ loadPyodide }));
+
+describe("typespec-python: browser pyodide bootstrap", () => {
+  afterEach(() => {
+    delete (globalThis as any).window;
+    loadPyodide.mockReset();
+    vi.resetModules();
+  });
+
+  // Hosts like the TypeSpec playground import every available emitter up front. Booting Pyodide at
+  // module scope downloaded a full CPython WebAssembly runtime on every page load, which pushed the
+  // page past the per-tab memory budget on mobile browsers and prevented it from loading.
+  it("does not boot pyodide when the emitter is imported in a browser", async () => {
+    (globalThis as any).window = globalThis;
+
+    await import("../src/emitter.js");
+
+    strictEqual(loadPyodide.mock.calls.length, 0);
+  });
+});

package/emitter/test/types.test.ts

@@ -0,0 +1,72 @@
+import type { SdkBuiltInType } from "@azure-tools/typespec-client-generator-core";
+import { deepStrictEqual } from "assert";
+import { describe, it } from "vitest";
+import type { PythonSdkContext } from "../src/lib.js";
+import { getType } from "../src/types.js";
+
+function createBuiltInType(
+  kind: SdkBuiltInType["kind"],
+  encode?: string,
+  wireType?: SdkBuiltInType,
+): SdkBuiltInType {
+  return {
+    kind,
+    name: kind,
+    crossLanguageDefinitionId: `TypeSpec.${kind}`,
+    decorators: [],
+    encode,
+    wireType,
+  };
+}
+
+function emitBuiltInType(type: SdkBuiltInType): Record<string, any> {
+  const context = {
+    __simpleTypesMap: new Map(),
+  } as PythonSdkContext;
+  return getType(context, type);
+}
+
+describe("typespec-python: built-in types", () => {
+  it("preserves boolean encoded as string", () => {
+    deepStrictEqual(
+      emitBuiltInType(createBuiltInType("boolean", "string", createBuiltInType("string"))),
+      {
+        type: "boolean",
+        encode: "string",
+      },
+    );
+  });
+
+  it.each(["safeint", "uint32", "uint8"] as const)(
+    "preserves %s encoded as string as an integer",
+    (kind) => {
+      deepStrictEqual(
+        emitBuiltInType(createBuiltInType(kind, "string", createBuiltInType("string"))),
+        {
+          type: "integer",
+          encode: "string",
+        },
+      );
+    },
+  );
+
+  it.each(["base64", "base64url"] as const)("preserves bytes encoded as %s", (encode) => {
+    deepStrictEqual(
+      emitBuiltInType(createBuiltInType("bytes", encode, createBuiltInType("string"))),
+      {
+        type: "bytes",
+        encode,
+      },
+    );
+  });
+
+  it("falls back to the wire type for a custom encoding", () => {
+    deepStrictEqual(
+      emitBuiltInType(createBuiltInType("string", "abc", createBuiltInType("int32"))),
+      {
+        type: "integer",
+        encode: "abc",
+      },
+    );
+  });
+});

package/eng/scripts/ci/dev_requirements.txt

@@ -7,6 +7,6 @@ colorama==0.4.6
 debugpy==1.8.2
 pytest==9.0.3
 coverage==7.6.1
-black==24.4.0
+black==26.3.1
 ptvsd==4.3.2
 types-PyYAML==6.0.12.8

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

@@ -16,8 +16,7 @@
 import { compile, NodeHost } from "@typespec/compiler";
 import { execSync } from "child_process";
 import { existsSync, rmSync } from "fs";
-import { access, cp, mkdir, mkdtemp, readdir, writeFile } from "fs/promises";
-import { tmpdir } from "os";
+import { access, mkdir, readdir, writeFile } from "fs/promises";
 import { dirname, join, relative, resolve } from "path";
 import pc from "picocolors";
 
@@ -70,7 +69,11 @@ export interface BuildTaskGroupsOptions {
 
 // ---- Public constants ----
 
-export const SKIP_SPECS: string[] = ["type/file"];
+export const SKIP_SPECS: string[] = [
+  "type/file",
+  // LroPaging.postPagingLroWithBody generates begin_post_paging_lro_with_body with pylint R0915 (52/50).
+  "azure/resource-manager/operation-templates",
+];
 
 export const SpecialFlags: Record<string, Record<string, any>> = {
   azure: {
@@ -321,7 +324,7 @@ export const EMITTER_OPTIONS: Record<string, Record<string, string> | Record<str
     {
       "package-name": "typetest-model-usage-typeddictonly",
       namespace: "typetest.model.usage.typeddictonly",
-      "models-mode": "typeddict",
+      "models-mode": "none",
     },
   ],
   "type/model/visibility": [
@@ -655,6 +658,28 @@ export async function runParallel(
   return results;
 }
 
+/**
+ * Removes every generated file under `tests/generated`, keeping only the
+ * hand-authored files that are tracked in git. `git clean -xdf` deletes ignored
+ * and untracked files but never tracked ones, so `.gitignore` stays the single
+ * source of truth for which fixtures survive regeneration (each exception there
+ * documents why it cannot be regenerated).
+ */
+export async function cleanGeneratedCode(generatedFolder: string): Promise<void> {
+  const repoDir = resolve(generatedFolder, "..");
+  const testsGeneratedDir = resolve(repoDir, "tests/generated");
+  if (!existsSync(testsGeneratedDir)) return;
+
+  console.log(pc.cyan(`\n${"=".repeat(60)}`));
+  console.log(pc.cyan(`Cleaning generated test packages`));
+  console.log(pc.cyan(`${"=".repeat(60)}\n`));
+
+  execSync(`git clean -x -d -f -q -- "${testsGeneratedDir}"`, {
+    cwd: repoDir,
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+}
+
 /**
  * Pre-create the marker files that the test harness expects to find before
  * regeneration so it can verify they're cleared/preserved correctly.
@@ -698,99 +723,3 @@ export async function preprocess(flavor: string, generatedFolder: string): Promi
     }),
   );
 }
-
-/**
- * Resets the `tests/generated/{azure,unbranded}` baseline by sparse-checking-out
- * `eng/tools/azure-sdk-tools/emitter/generated` from the Azure/azure-sdk-for-python repo, then
- * deleting a couple of fully-generated package folders so regeneration has to
- * recreate them from scratch (smoke test of full-emit path).
- *
- * `generatedFolder` is the per-repo `generator/` directory; baseline lands at
- * `<generatedFolder>/../tests/generated`.
- */
-export async function prepareBaselineOfGeneratedCode(generatedFolder: string): Promise<void> {
-  const repoUrl = "https://github.com/Azure/azure-sdk-for-python.git";
-  const branch = "typespec-python-generated-tests";
-  const sourceSubdir = "eng/tools/azure-sdk-tools/emitter/generated";
-  const testsGeneratedDir = resolve(generatedFolder, "../tests/generated");
-
-  console.log(pc.cyan(`\n${"=".repeat(60)}`));
-  console.log(pc.cyan(`Resetting baseline from ${repoUrl} (${branch}/${sourceSubdir})`));
-  console.log(pc.cyan(`${"=".repeat(60)}\n`));
-
-  // Wipe tests/generated
-  if (existsSync(testsGeneratedDir)) {
-    console.log(pc.dim(`Removing ${testsGeneratedDir}`));
-    rmSync(testsGeneratedDir, { recursive: true, force: true });
-  }
-
-  // Sparse-checkout the baseline folder into a temp directory
-  const tempDir = await mkdtemp(join(tmpdir(), "azsdk-baseline-"));
-  try {
-    console.log(pc.dim(`Cloning into ${tempDir}`));
-    const run = (cmd: string) =>
-      execSync(cmd, { cwd: tempDir, stdio: ["ignore", "ignore", "inherit"] });
-
-    run(`git init`);
-    run(`git config core.longpaths true`);
-    run(`git remote add origin ${repoUrl}`);
-    run(`git config core.sparseCheckout true`);
-    run(`git sparse-checkout init --cone`);
-    run(`git sparse-checkout set ${sourceSubdir}`);
-    run(`git fetch --depth 1 origin ${branch}`);
-    run(`git checkout FETCH_HEAD`);
-
-    // we don't copy whole generated folder, just the specific subfolders needed for tests
-    // to verify correct preservation/deletion of files and folders during regeneration,
-    // to avoid accidentally including any manually edited code that might be in the repo
-    // and cause confusion when it doesn't get updated during regeneration
-    const legacyCodePathNeededForTests = [
-      "azure/authentication-api-key",
-      "unbranded/authentication-api-key",
-      "azure/authentication-union",
-      "azure/generation-subdir",
-      "azure/generation-subdir2",
-      "unbranded/generation-subdir",
-      "unbranded/generation-subdir2",
-      "azure/azure-client-generator-core-alternate-type",
-    ];
-
-    const sourceRoot = join(tempDir, ...sourceSubdir.split("/"));
-    for (const subPath of legacyCodePathNeededForTests) {
-      const segments = subPath.split("/");
-      const src = join(sourceRoot, ...segments);
-      const dest = join(testsGeneratedDir, ...segments);
-      if (!existsSync(src)) {
-        console.warn(pc.yellow(`Baseline folder not found: ${src}`));
-        continue;
-      }
-      console.log(pc.dim(`Copying ${subPath} -> ${dest}`));
-      await mkdir(dirname(dest), { recursive: true });
-      await cp(src, dest, { recursive: true });
-    }
-
-    console.log(pc.green(`Baseline reset complete.\n`));
-  } finally {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-
-  // Smoke test the full-emit path: delete a couple of fully-generated package
-  // folders and every README.md so regeneration has to recreate them.
-  const deleteIfExists = (path: string) => {
-    if (!existsSync(path)) return;
-    console.log(pc.dim(`Deleting ${path}`));
-    rmSync(path, { recursive: true, force: true });
-  };
-
-  deleteIfExists(join(testsGeneratedDir, "azure", "authentication-http-custom"));
-  deleteIfExists(join(testsGeneratedDir, "unbranded", "encode-array"));
-
-  if (existsSync(testsGeneratedDir)) {
-    const entries = await readdir(testsGeneratedDir, { recursive: true, withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === "README.md") {
-        deleteIfExists(join(entry.parentPath, entry.name));
-      }
-    }
-  }
-}

package/eng/scripts/ci/regenerate.ts

@@ -20,13 +20,12 @@ import pc from "picocolors";
 import { fileURLToPath } from "url";
 import { parseArgs } from "util";
 
+import type { RegenerateContext, RegenerateFlags } from "./regenerate-common.js";
 import {
   buildTaskGroups,
+  cleanGeneratedCode,
   getSubdirectories,
-  prepareBaselineOfGeneratedCode,
   preprocess,
-  RegenerateContext,
-  RegenerateFlags,
   runParallel,
 } from "./regenerate-common.js";
 
@@ -256,7 +255,7 @@ async function main() {
   const startTime = performance.now();
   let success: boolean;
 
-  await prepareBaselineOfGeneratedCode(GENERATED_FOLDER);
+  await cleanGeneratedCode(GENERATED_FOLDER);
 
   if (flavor) {
     success = await regenerateFlavor(flavor, name, debug, jobs);

package/eng/scripts/ci/run-tests.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-console */
-import { ChildProcess, spawn } from "child_process";
+import type { ChildProcess } from "child_process";
+import { spawn } from "child_process";
 import fs from "fs";
 import { cpus } from "os";
 import { dirname, join } from "path";

package/eng/scripts/setup/system-requirements.ts

@@ -1,4 +1,5 @@
-import { ChildProcess, spawn, SpawnOptions } from "child_process";
+import type { ChildProcess, SpawnOptions } from "child_process";
+import { spawn } from "child_process";
 
 /*
  * Copied from @autorest/system-requirements

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

@@ -12,7 +12,7 @@ from abc import ABC, abstractmethod
 from typing import Any, Iterator, Optional, Union
 
 import yaml
-from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE
+from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE, is_typeddict_only
 
 from ._version import VERSION
 
@@ -36,6 +36,7 @@ class OptionsDict(MutableMapping):
         "low-level-client": False,
         "no-async": False,
         "no-namespace-folders": False,
+        "generate-typeddict": True,
         "polymorphic-examples": 5,
         "validate-versioning": True,
         "version-tolerant": True,
@@ -45,10 +46,20 @@ class OptionsDict(MutableMapping):
 
     def __init__(self, options: Optional[dict[str, Any]] = None) -> None:
         self._data = options.copy() if options else {}
+        # 'models-mode: typeddict' is deprecated. Represent it internally as 'none' models-mode with
+        # TypedDict generation enabled, so the rest of the codebase reasons in terms of models-mode
+        # plus the generate-typeddict flag.
+        if self._data.get("models-mode") == "typeddict":
+            self._data["generate-typeddict"] = True
         for key in list(self._data):
             self._data[key] = self._validate_and_transform(key, self._data[key])
         self._validate_combinations()
 
+    @property
+    def generate_typeddict_only(self) -> bool:
+        """Whether this is TypedDict-only generation ('models-mode: none' + TypedDicts)."""
+        return is_typeddict_only(self)
+
     def __getitem__(self, key: str) -> Any:  # pylint: disable=too-many-return-statements
         if key == "head-as-boolean" and self.get("azure-arm"):
             # override to always true if azure-arm is set
@@ -167,14 +178,22 @@ class OptionsDict(MutableMapping):
         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'")
 
+        if key == "models-mode" and value == "typeddict":
+            # Deprecated: keep accepting it for back-compat but store it as 'none' (falsy) with
+            # TypedDict generation enabled (see OptionsDict.__init__ and generate_typeddict_only).
+            _LOGGER.warning(
+                "'models-mode: typeddict' is deprecated. Use 'models-mode: none' with "
+                "'generate-typeddict: true' (the default) instead."
+            )
+            value = False
+
         if key == "models-mode" and value == "none":
             value = False  # switch to falsy value for easier code writing
 
-        if key == "models-mode" and value not in ["msrest", "dpg", "typeddict", False]:
+        if key == "models-mode" and value not in ["msrest", "dpg", False]:
             raise ValueError(
-                "--models-mode can only be 'msrest', 'dpg', 'typeddict', or 'none'. "
-                "Pass in 'msrest' if you want msrest models, 'typeddict' for TypedDict models, or "
-                "'none' if you don't want any."
+                "--models-mode can only be 'dpg' or 'none'. "
+                "Pass in 'dpg' for DPG models, or 'none' if you don't want any."
             )
         if key == "package-mode":
             if (

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

@@ -169,7 +169,9 @@ def build_type(yaml_data: dict[str, Any], code_model: CodeModel) -> BaseType:
         # need to special case model to avoid recursion
         if yaml_data["base"] == "typeddict":
             model_type = TypedDictModelType  # type: ignore
-        elif yaml_data["base"] == "json" or not code_model.options["models-mode"]:
+        elif yaml_data["base"] == "json" or (
+            not code_model.options["models-mode"] and not code_model.generate_typeddict_only
+        ):
             model_type = JSONModelType
         elif yaml_data["base"] == "dpg":
             model_type = DPGModelType  # type: ignore

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

@@ -17,6 +17,7 @@ from .operation_group import OperationGroup
 from .utils import NamespaceType
 from .._utils import DEFAULT_HEADER_TEXT, DEFAULT_LICENSE_DESCRIPTION
 from ... import OptionsDict
+from ...utils import is_typeddict_only
 
 
 def _is_legacy(options) -> bool:
@@ -89,7 +90,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self.clients: list[Client] = [
             Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
-        if self.options["models-mode"] and self.model_types:
+        if (self.options["models-mode"] or self.generate_typeddict_only) and self.model_types:
             self.sort_model_types()
         self.named_unions: list[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
@@ -174,6 +175,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def get_unique_types_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
         return self._get_unique_import_alias(serialize_namespace, imported_namespace, "types")
 
+    @property
+    def generate_typeddict_only(self) -> bool:
+        """Whether this is TypedDict-only generation ('models-mode: none' + TypedDicts)."""
+        return is_typeddict_only(self.options)
+
     @property
     def client_namespace_types(self) -> dict[str, ClientNamespaceType]:
         if not self._client_namespace_types:

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

@@ -40,7 +40,7 @@ class EnumValue(BaseType):
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation"""
-        if self.code_model.options["models-mode"] == "typeddict":
+        if self.code_model.generate_typeddict_only:
             # A single constant enum value must be
             # annotated with its literal value directly (e.g. ``Literal["red"]``).
             return f"Literal[{self.value_type.get_declaration(self.value)}]"
@@ -83,7 +83,7 @@ class EnumValue(BaseType):
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
-        if self.code_model.options["models-mode"] == "typeddict":
+        if self.code_model.generate_typeddict_only:
             # In typeddict mode the enums module (``_enums.py``) is never generated
             return file_import
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
@@ -176,7 +176,7 @@ class EnumType(BaseType):
 
     @property
     def is_typeddict_mode(self) -> bool:
-        return self.code_model.options["models-mode"] == "typeddict"
+        return self.code_model.generate_typeddict_only
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation
@@ -184,7 +184,7 @@ class EnumType(BaseType):
         :return: The type annotation for this schema
         :rtype: str
         """
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             if self.is_typeddict_mode:
                 # In typeddict mode, enums are Literal aliases defined in types.py
                 serialize_namespace_type = kwargs.get("serialize_namespace_type")
@@ -221,13 +221,13 @@ class EnumType(BaseType):
         return self.value_type.get_declaration(value)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             return self.name
         return self.value_type.type_annotation(**kwargs)
 
     def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation."""
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             type_annotation = self.value_type.type_annotation(**kwargs)
             enum_type_annotation = f"{self.client_namespace}.models.{self.name}"
             return f"{type_annotation} or ~{enum_type_annotation}"
@@ -261,7 +261,7 @@ class EnumType(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             if self.is_typeddict_mode:
                 # In typeddict mode, enums are Literal aliases in types.py — no Union needed
                 serialize_namespace_type = kwargs.get("serialize_namespace_type")

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

@@ -38,6 +38,7 @@ class ListType(BaseType):
             self.code_model.options["version-tolerant"]
             and self.element_type.is_xml
             and not self.code_model.options["models-mode"]
+            and not self.code_model.generate_typeddict_only
         ):
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.type_annotation(**kwargs)

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

@@ -77,9 +77,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
         self.usage: int = self.yaml_data.get("usage", UsageFlags.Input.value | UsageFlags.Output.value)
         self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
-        self.is_typed_dict_only: bool = (
-            self.yaml_data.get("typedDictOnly", False) or code_model.options["models-mode"] == "typeddict"
-        )
+        self.is_typed_dict_only: bool = self.yaml_data.get("typedDictOnly", False) or code_model.generate_typeddict_only
 
     @property
     def is_usage_output(self) -> bool:

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

@@ -334,7 +334,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.merge(
                 response.imports(async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs)
             )
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
@@ -552,7 +552,12 @@ class Operation(OperationBase[Response]):
                 "distributed_trace_async",
                 ImportType.SDKCORE,
             )
-        if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models-mode"]:
+        if (
+            self.has_response_body
+            and not self.has_optional_return_type
+            and not self.code_model.options["models-mode"]
+            and not self.code_model.generate_typeddict_only
+        ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
 
         return file_import

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

@@ -338,7 +338,9 @@ class Parameter(_ParameterBase):
     ) -> ParameterMethodLocation:
         if not self.in_method_signature:
             raise ValueError(f"Parameter '{self.client_name}' is not in the method.")
-        if self.code_model.options["models-mode"] in ("dpg", "typeddict") and self.in_flattened_body:
+        if (
+            self.code_model.options["models-mode"] == "dpg" or self.code_model.generate_typeddict_only
+        ) and self.in_flattened_body:
             return ParameterMethodLocation.KEYWORD_ONLY
         if self.grouper:
             return ParameterMethodLocation.POSITIONAL

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

@@ -34,6 +34,20 @@ def add_to_pylint_disable(curr_str: str, entry: str) -> str:
     return f"  # pylint: disable={entry}"
 
 
+def escape_sphinx_field_name(name: str) -> str:
+    """Escape a name used as the target of a Sphinx info field (``:ivar``, ``:vartype``,
+    ``:keyword``, ``:paramtype``, ``:param``, ``:type``).
+
+    A name containing ``@`` (e.g. a wire name such as ``@search.facets``) is wrapped in
+    double backticks so it is treated as an inline literal. This renders cleanly in Sphinx
+    without a leading ``@`` being misinterpreted, and — unlike a ``\\@`` escape — introduces
+    no invalid escape sequence into the generated Python docstring.
+    """
+    if "@" in name:
+        return f"``{name}``"
+    return name
+
+
 class NamespaceType(str, Enum):
     """Special signal for impports"""
 

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

@@ -207,10 +207,10 @@ class JinjaSerializer(ReaderAndWriter):
                 self._serialize_and_write_top_level_folder(env=env, namespace=client_namespace)
 
             # add models folder if there are models in this namespace
-            is_typeddict_mode = self.code_model.options["models-mode"] == "typeddict"
-            if (
-                self.code_model.has_non_json_models(client_namespace_type.models) or client_namespace_type.enums
-            ) and self.code_model.options["models-mode"]:
+            is_typeddict_mode = self.code_model.generate_typeddict_only
+            if (self.code_model.has_non_json_models(client_namespace_type.models) or client_namespace_type.enums) and (
+                self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only
+            ):
                 self._serialize_and_write_models_folder(
                     env=env,
                     namespace=client_namespace,
@@ -238,7 +238,7 @@ class JinjaSerializer(ReaderAndWriter):
                     ).serialize(),
                 )
 
-            if not self.code_model.options["models-mode"]:
+            if not self.code_model.options["models-mode"] and not self.code_model.generate_typeddict_only:
                 # keep models file if users ended up just writing a models file
                 model_path = generation_path / Path("models.py")
                 if self.read_file(model_path):
@@ -321,7 +321,7 @@ class JinjaSerializer(ReaderAndWriter):
         # Write the models folder
         models_path = self.code_model.get_generation_dir(namespace) / "models"
         models_mode = self.code_model.options["models-mode"]
-        if models_mode in ("dpg", "typeddict"):
+        if models_mode == "dpg" or self.code_model.generate_typeddict_only:
             serializer = DpgModelSerializer
         else:
             serializer = MsrestModelSerializer