add e2e tests

Author: iscai-msft

packages/http-client-python/eng/scripts/ci/regenerate.ts

@@ -307,10 +307,18 @@ const EMITTER_OPTIONS: Record<string, Record<string, string> | Record<string, st
       "clear-output-folder": "true",
     },
   ],
-  "type/model/usage": {
-    "package-name": "typetest-model-usage",
-    namespace: "typetest.model.usage",
-  },
+  "type/model/usage": [
+    {
+      "package-name": "typetest-model-usage",
+      namespace: "typetest.model.usage",
+    },
+    {
+      "package-name": "typetest-model-usage-typeddictonly",
+      namespace: "typetest.model.usage.typeddictonly",
+      "models-mode": "typeddict",
+      "typed-dict-only-models": "InputRecord,OutputRecord,InputOutputRecord",
+    },
+  ],
   "type/model/visibility": [
     {
       "package-name": "typetest-model-visibility",

packages/http-client-python/generator/pygen/__init__.py

@@ -181,6 +181,8 @@ def _validate_and_transform(self, key: str, value: Any) -> Any:
                 raise ValueError(
                     f"--package-mode can only be {' or '.join(TYPESPEC_PACKAGE_MODE)} or directory which contains template files"  # pylint: disable=line-too-long
                 )
+        if key == "typed-dict-only-models" and isinstance(value, str):
+            value = [v.strip() for v in value.split(",") if v.strip()]
         return value
 
     def setdefault(self, key: str, default: Any, /) -> Any:  # type: ignore # pylint: disable=arguments-differ

packages/http-client-python/generator/pygen/codegen/models/code_model.py

@@ -349,7 +349,7 @@ def model_types(self, val: list[ModelType]) -> None:
 
     @staticmethod
     def get_public_model_types(models: list[ModelType]) -> list[ModelType]:
-        return [m for m in models if not m.internal and not m.base == "json"]
+        return [m for m in models if not m.internal and not m.base == "json" and not m.is_typed_dict_only]
 
     @property
     def public_model_types(self) -> list[ModelType]:

packages/http-client-python/generator/pygen/codegen/models/model_type.py

@@ -77,6 +77,10 @@ def __init__(
         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 self.name in code_model.options.get("typed-dict-only-models", [])
+        )
 
     @property
     def is_usage_output(self) -> bool:
@@ -352,6 +356,22 @@ def imports(self, **kwargs: Any) -> FileImport:
 class DPGModelType(GeneratedModelType):
     base = "dpg"
 
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.is_typed_dict_only:
+            is_operation_file = kwargs.pop("is_operation_file", False)
+            skip_quote = kwargs.get("skip_quote", False)
+            retval = f"types.{self.name}"
+            return retval if is_operation_file or skip_quote else f'"{retval}"'
+        return super().type_annotation(**kwargs)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        if self.is_typed_dict_only:
+            client_namespace = self.client_namespace
+            if self.code_model.options.get("generation-subdir"):
+                client_namespace += f".{self.code_model.options['generation-subdir']}"
+            return f"~{client_namespace}.types.{self.name}"
+        return super().docstring_type(**kwargs)
+
     def serialization_type(self, **kwargs: Any) -> str:
         return (
             self.type_annotation(skip_quote=True, **kwargs)
@@ -364,6 +384,28 @@ def instance_check_template(self) -> str:
         return "isinstance({}, " + f"_models.{self.name})"
 
     def imports(self, **kwargs: Any) -> FileImport:
+        if self.is_typed_dict_only:
+            file_import = FileImport(self.code_model)
+            serialize_namespace_type = kwargs.get("serialize_namespace_type")
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+            relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
+            if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
+                file_import.add_submodule_import(
+                    relative_path,
+                    "types",
+                    ImportType.LOCAL,
+                )
+            elif serialize_namespace_type in [NamespaceType.TYPES_FILE, NamespaceType.UNIONS_FILE] or (
+                serialize_namespace_type == NamespaceType.MODEL
+                and kwargs.get("called_by_property", False)
+            ):
+                file_import.add_submodule_import(
+                    relative_path,
+                    "types",
+                    ImportType.LOCAL,
+                    typing_section=TypingSection.TYPING,
+                )
+            return file_import
         file_import = super().imports(**kwargs)
         if self.flattened_property:
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)

packages/http-client-python/generator/pygen/codegen/serializers/__init__.py

@@ -304,10 +304,14 @@ def _serialize_and_write_models_folder(
             serializer = DpgModelSerializer
         else:
             serializer = MsrestModelSerializer
-        if self.code_model.has_non_json_models(models):
+        # Filter out typed-dict-only models — they only appear in types.py, not as model classes
+        class_models = [m for m in models if not m.is_typed_dict_only]
+        if self.code_model.has_non_json_models(class_models):
             self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
-                serializer(code_model=self.code_model, env=env, client_namespace=namespace, models=models).serialize(),
+                serializer(
+                    code_model=self.code_model, env=env, client_namespace=namespace, models=class_models
+                ).serialize(),
             )
         if enums:
             self.write_file(
@@ -318,7 +322,7 @@ def _serialize_and_write_models_folder(
             )
         self.write_file(
             models_path / Path("__init__.py"),
-            ModelInitSerializer(code_model=self.code_model, env=env, models=models, enums=enums).serialize(),
+            ModelInitSerializer(code_model=self.code_model, env=env, models=class_models, enums=enums).serialize(),
         )
 
         self._keep_patch_file(models_path / Path("_patch.py"), env)

packages/http-client-python/generator/pygen/codegen/serializers/builder_serializer.py

@@ -1000,6 +1000,12 @@ def response_deserialization(  # pylint: disable=too-many-statements
             elif self.code_model.options["models-mode"] == "dpg":
                 if builder.has_stream_response:
                     deserialize_code.append("deserialized = response.content")
+                elif isinstance(response.type, ModelType) and response.type.is_typed_dict_only:
+                    # Typed-dict-only models skip deserialization — return raw JSON
+                    deserialize_code.append("if response.content:")
+                    deserialize_code.append("    deserialized = response.json()")
+                    deserialize_code.append("else:")
+                    deserialize_code.append("    deserialized = None")
                 else:
                     format_filed = (
                         f', format="{response.type.encode}"'
@@ -1429,18 +1435,23 @@ def _extract_data_callback(  # pylint: disable=too-many-statements,too-many-bran
             )
         pylint_disable = ""
         if self.code_model.options["models-mode"] == "dpg":
-            item_type = builder.item_type.type_annotation(
-                is_operation_file=True, serialize_namespace=self.serialize_namespace
-            )
-            pylint_disable = (
-                "  # pylint: disable=protected-access" if getattr(builder.item_type, "internal", False) else ""
-            )
-            list_of_elem_deserialized = [
-                "_deserialize(",
-                f"{item_type},{pylint_disable}",
-                f"deserialized{access},",
-                ")",
-            ]
+            is_item_typed_dict_only = isinstance(builder.item_type, ModelType) and builder.item_type.is_typed_dict_only
+            if is_item_typed_dict_only:
+                # Typed-dict-only models skip deserialization — return raw JSON items
+                list_of_elem_deserialized = [f"deserialized{access}"]
+            else:
+                item_type = builder.item_type.type_annotation(
+                    is_operation_file=True, serialize_namespace=self.serialize_namespace
+                )
+                pylint_disable = (
+                    "  # pylint: disable=protected-access" if getattr(builder.item_type, "internal", False) else ""
+                )
+                list_of_elem_deserialized = [
+                    "_deserialize(",
+                    f"{item_type},{pylint_disable}",
+                    f"deserialized{access},",
+                    ")",
+                ]
         else:
             list_of_elem_deserialized = [f"deserialized{access}"]
         list_of_elem_deserialized_str = "\n    ".join(list_of_elem_deserialized)

packages/http-client-python/tests/mock_api/shared/test_typetest_model_usage_typeddictonly.py

@@ -0,0 +1,44 @@
+# -------------------------------------------------------------------------
+# 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 typetest.model.usage.typeddictonly import UsageClient
+from typetest.model.usage.typeddictonly.types import InputRecord, OutputRecord, InputOutputRecord
+
+
+@pytest.fixture
+def client():
+    with UsageClient() as client:
+        yield client
+
+
+def test_input(client: UsageClient):
+    # TypedDict-only: pass a plain dict matching the TypedDict schema
+    result = client.input({"requiredProp": "example-value"})
+    assert result is None
+
+
+def test_output(client: UsageClient):
+    # TypedDict-only: output should be a plain dict (no model deserialization)
+    output = client.output()
+    assert isinstance(output, dict)
+    assert output["requiredProp"] == "example-value"
+
+
+def test_input_and_output(client: UsageClient):
+    # TypedDict-only: input a dict, get a dict back
+    result = client.input_and_output({"requiredProp": "example-value"})
+    assert isinstance(result, dict)
+    assert result["requiredProp"] == "example-value"
+
+
+def test_no_model_classes():
+    """Verify that typed-dict-only models don't generate model classes."""
+    from typetest.model.usage.typeddictonly import models
+
+    # models.__all__ should be empty — no model classes exported
+    assert models.__all__ == []
+    # The TypedDicts should only exist in the types module
+    assert hasattr(InputRecord, "__required_keys__") or hasattr(InputRecord, "__annotations__")

packages/http-client-python/tests/unit/test_typeddict.py

@@ -169,3 +169,78 @@ def test_unions_serializer_no_unions():
     output = us.serialize()
     assert "TypedDict" not in output
     assert "Union" not in output
+
+
+# ---------- typed-dict-only ----------
+
+
+def _make_typed_dict_only_model(code_model, name, **extra_yaml):
+    """Create a TypedDictModelType with typedDictOnly=True."""
+    yaml_data = {
+        "name": name,
+        "type": "model",
+        "snakeCaseName": name.lower(),
+        "usage": 2,
+        "typedDictOnly": True,
+        **extra_yaml,
+    }
+    return TypedDictModelType(
+        yaml_data=yaml_data,
+        code_model=code_model,
+        properties=[],
+    )
+
+
+def test_typed_dict_only_property():
+    """is_typed_dict_only should be True when yaml_data has typedDictOnly=True."""
+    code_model = _make_code_model(models_mode="typeddict")
+    model = _make_typed_dict_only_model(code_model, "Foo")
+    assert model.is_typed_dict_only is True
+
+    normal_model = _make_model(code_model, "Bar", model_cls=TypedDictModelType)
+    assert normal_model.is_typed_dict_only is False
+
+
+def test_typed_dict_only_excluded_from_public_model_types():
+    """Typed-dict-only models should not appear in public_model_types."""
+    code_model = _make_code_model(models_mode="typeddict")
+    normal = _make_model(code_model, "Normal", model_cls=TypedDictModelType)
+    td_only = _make_typed_dict_only_model(code_model, "TdOnly")
+    code_model.model_types = [normal, td_only]
+
+    public = code_model.public_model_types
+    assert normal in public
+    assert td_only not in public
+
+
+def test_typed_dict_only_still_in_types_file():
+    """Typed-dict-only models should still appear in types.py as TypedDicts."""
+    code_model = _make_code_model(models_mode="typeddict")
+    td_only = _make_typed_dict_only_model(code_model, "MyModel")
+    code_model.model_types = [td_only]
+
+    env = _make_env()
+    ts = TypesSerializer(code_model=code_model, env=env, models=[td_only])
+    output = ts.serialize()
+    assert "class MyModel(TypedDict, total=False):" in output
+
+
+def test_typed_dict_only_type_annotation():
+    """Typed-dict-only models should use types.Name, not _models.Name."""
+    code_model = _make_code_model(models_mode="typeddict")
+    model = _make_typed_dict_only_model(code_model, "Foo")
+
+    # In operation files, should be types.Name
+    annotation = model.type_annotation(is_operation_file=True)
+    assert annotation == "types.Foo"
+    assert "_models" not in annotation
+
+
+def test_typed_dict_only_docstring_type():
+    """Typed-dict-only models should reference types module, not models."""
+    code_model = _make_code_model(models_mode="typeddict")
+    model = _make_typed_dict_only_model(code_model, "Foo")
+
+    docstring = model.docstring_type()
+    assert "types.Foo" in docstring
+    assert "models.Foo" not in docstring