@typespec/http-client-python 0.32.0 → 0.34.0

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

@@ -196,6 +196,16 @@ def is_json_model_type(parameters: ParameterListType) -> bool:
     )
 
 
+def _is_dpg_or_typeddict_body(body_param: BodyParameter) -> bool:
+    """Check if a body parameter is a DPG model or a CombinedType wrapping one."""
+    body_type = body_param.type
+    if isinstance(body_type, DPGModelType):
+        return True
+    if isinstance(body_type, CombinedType):
+        return body_type.target_model_subtype((DPGModelType,)) is not None
+    return False
+
+
 class _BuilderBaseSerializer(Generic[BuilderType]):
     def __init__(self, code_model: CodeModel, async_mode: bool, client_namespace: str) -> None:
         self.code_model = code_model
@@ -712,8 +722,20 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
                 f"'{serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
+        elif self.code_model.options["models-mode"] == "typeddict":
+            # TypedDict-only models are plain dicts — no serialization needed
+            create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
         elif self.code_model.options["models-mode"] == "dpg":
-            if json_serializable(body_param.default_content_type):
+            # Check if this is a typeddict-only model within dpg mode — skip serialization
+            body_model_type = body_param.type
+            if isinstance(body_model_type, CombinedType):
+                body_model_type = body_model_type.target_model_subtype((DPGModelType,))
+            is_typeddict_only_body = isinstance(body_model_type, DPGModelType) and getattr(
+                body_model_type, "is_typed_dict_only", False
+            )
+            if is_typeddict_only_body:
+                create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
+            elif json_serializable(body_param.default_content_type):
                 if hasattr(body_param.type, "encode") and body_param.type.encode:  # type: ignore
                     create_body_call = (
                         f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
@@ -791,9 +813,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             overload.request_builder.parameters.body_parameter.client_name for overload in builder.overloads
         ]
         all_dpg_model_overloads = False
-        if self.code_model.options["models-mode"] == "dpg" and builder.overloads:
+        if self.code_model.options["models-mode"] in ("dpg", "typeddict") and builder.overloads:
             all_dpg_model_overloads = all(
-                isinstance(o.parameters.body_parameter.type, DPGModelType) for o in builder.overloads
+                _is_dpg_or_typeddict_body(o.parameters.body_parameter) for o in builder.overloads
             )
         if not all_dpg_model_overloads:
             for v in sorted(set(client_names), key=client_names.index):
@@ -1002,6 +1024,12 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             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}"'
@@ -1437,18 +1465,23 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
             )
         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)

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

@@ -66,7 +66,26 @@ class GeneralSerializer(BaseSerializer):
         if dep_version > default_version:
             version_map[dep_name] = str(dep_version)
 
-    def external_lib_version_map(self, file_content: str, additional_version_map: dict[str, str]) -> dict:
+    # Project-level pyproject.toml fields that may be preserved across regeneration
+    # via the "keep-pyproject-fields" option.
+    KEEPABLE_PROJECT_FIELDS = ("authors", "description", "classifiers", "urls")
+
+    @staticmethod
+    def _parse_keep_pyproject_fields(value: Any) -> tuple[str, ...]:
+        # The "keep-pyproject-fields" option may be a comma-separated string (e.g.
+        # "authors,description") or an already-parsed sequence of field names.
+        if not value:
+            return ()
+        if isinstance(value, str):
+            return tuple(field.strip() for field in value.split(",") if field.strip())
+        return tuple(value)
+
+    def external_lib_version_map(
+        self,
+        file_content: str,
+        additional_version_map: dict[str, str],
+        keep_pyproject_fields: tuple[str, ...] = (),
+    ) -> dict:
         # Load the pyproject.toml file if it exists and extract fields to keep.
         result: dict = {"KEEP_FIELDS": {}}
         try:
@@ -85,6 +104,14 @@ class GeneralSerializer(BaseSerializer):
 
         # Process dependencies
         if "project" in loaded_pyproject_toml:
+            project = loaded_pyproject_toml["project"]
+
+            # Keep manually customized project fields the emitter would otherwise overwrite.
+            # Only the fields explicitly listed in the "keep-pyproject-fields" option are preserved.
+            for field in keep_pyproject_fields:
+                if field in self.KEEPABLE_PROJECT_FIELDS and field in project:
+                    result["KEEP_FIELDS"][f"project.{field}"] = project[field]
+
             # Handle main dependencies
             if "dependencies" in loaded_pyproject_toml["project"]:
                 kept_deps = []
@@ -127,7 +154,10 @@ class GeneralSerializer(BaseSerializer):
 
         # Add fields to keep from an existing pyproject.toml
         if template_name == "pyproject.toml.jinja2":
-            params = self.external_lib_version_map(file_content, additional_version_map)
+            keep_pyproject_fields = self._parse_keep_pyproject_fields(
+                self.code_model.options.get("keep-pyproject-fields")
+            )
+            params = self.external_lib_version_map(file_content, additional_version_map, keep_pyproject_fields)
         else:
             params = {}
 

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

@@ -32,7 +32,7 @@ class ModelInitSerializer:
                         ", ".join(model_enum_name_intersection)
                     )
                 )
-        has_models = self.models
+        has_models = self.code_model.has_non_json_models(self.models)
         has_enums = self.enums
         template = self.env.get_template("model_init.py.jinja2")
         return template.render(

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional
+from typing import Any, Optional
 from abc import ABC, abstractmethod
 
 from ..models import ModelType, Property, ConstantType, EnumValue, EnumType
@@ -73,12 +73,19 @@ def _get_xml_deserializer_enum_type(prop: Property) -> Optional[EnumType]:
     return prop_type if isinstance(prop_type, EnumType) else None
 
 
-def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> list[str]:
+def _documentation_string(
+    prop: Property, description_keyword: str, docstring_type_keyword: str, **kwargs: Any
+) -> list[str]:
     retval: list[str] = []
     sphinx_prefix = f":{description_keyword} {prop.client_name}:"
     description = prop.description(is_operation_file=False).replace("\\", "\\\\")
     retval.append(f"{sphinx_prefix} {description}" if description else sphinx_prefix)
-    retval.append(f":{docstring_type_keyword} {prop.client_name}: {prop.type.docstring_type()}")
+    # In the types file, use type_annotation (the serialized form) for docstrings
+    if kwargs.get("serialize_namespace_type") == NamespaceType.TYPES_FILE:
+        doc_type = prop.type.type_annotation(**kwargs)
+    else:
+        doc_type = prop.type.docstring_type(**kwargs)
+    retval.append(f":{docstring_type_keyword} {prop.client_name}: {doc_type}")
     return retval
 
 
@@ -494,3 +501,120 @@ class DpgModelSerializer(_ModelSerializer):
         if final_result:
             return "# pylint: disable=" + ", ".join(final_result)
         return ""
+
+
+class TypedDictModelSerializer(_ModelSerializer):
+    def _is_parent_discriminated_base(self, model: ModelType) -> bool:
+        """Check if any parent of this model is a discriminated base (has discriminated_subtypes)."""
+        return any(p.discriminated_subtypes for p in model.parents)
+
+    def _reorder_models(self, models: list[ModelType]) -> list[ModelType]:
+        """Reorder so discriminated base Union aliases come after all their subtypes."""
+        bases = [m for m in models if m.discriminated_subtypes]
+        non_bases = [m for m in models if not m.discriminated_subtypes]
+        return non_bases + bases
+
+    def serialize(self) -> str:
+        template = self.env.get_template("model_container.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(self.imports()),
+            str=str,
+            serializer=self,
+            models=self._reorder_models(self.models),
+        )
+
+    def imports(self) -> FileImport:
+        file_import = FileImport(self.code_model)
+        has_required = False
+        has_discriminated_union = False
+        for model in self.models:
+            if model.base == "json":
+                continue
+            if model.discriminated_subtypes:
+                has_discriminated_union = True
+            file_import.merge(
+                model.imports(
+                    is_operation_file=False,
+                    serialize_namespace=self.serialize_namespace,
+                    serialize_namespace_type=NamespaceType.MODEL,
+                )
+            )
+            for prop in model.properties:
+                file_import.merge(
+                    prop.imports(
+                        serialize_namespace=self.serialize_namespace,
+                        serialize_namespace_type=NamespaceType.MODEL,
+                        called_by_property=True,
+                    )
+                )
+                if not (prop.optional or prop.client_default_value is not None):
+                    has_required = True
+            for parent in model.parents:
+                if parent.client_namespace != model.client_namespace and not parent.discriminated_subtypes:
+                    file_import.add_submodule_import(
+                        self.code_model.get_relative_import_path(
+                            self.serialize_namespace,
+                            self.code_model.get_imported_namespace_for_model(parent.client_namespace),
+                        ),
+                        parent.name,
+                        ImportType.LOCAL,
+                    )
+        file_import.add_submodule_import("typing_extensions", "TypedDict", ImportType.STDLIB)
+        if has_required:
+            file_import.add_submodule_import("typing_extensions", "Required", ImportType.STDLIB)
+        if has_discriminated_union:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+        return file_import
+
+    def declare_model(self, model: ModelType) -> str:
+        # If the model's parent is a discriminated base, don't inherit from it
+        non_discriminated_parents = [p for p in model.parents if not p.discriminated_subtypes]
+        if non_discriminated_parents:
+            basename = ", ".join([m.name for m in non_discriminated_parents])
+            return f"class {model.name}({basename}):{model.pylint_disable()}"
+        return f"class {model.name}(TypedDict, total=False):{model.pylint_disable()}"
+
+    @staticmethod
+    def get_properties_to_declare(model: ModelType) -> list[Property]:
+        # Only exclude inherited properties from non-discriminated parents
+        non_discriminated_parents = [p for p in model.parents if not p.discriminated_subtypes]
+        if non_discriminated_parents:
+            parent_properties = [p for bm in non_discriminated_parents for p in bm.properties]
+            properties_to_declare = [
+                p
+                for p in model.properties
+                if not any(
+                    p.client_name == pp.client_name
+                    and p.type_annotation() == pp.type_annotation()
+                    and not p.is_base_discriminator
+                    for pp in parent_properties
+                )
+            ]
+        else:
+            properties_to_declare = model.properties
+        return properties_to_declare
+
+    def declare_property(self, prop: Property) -> str:
+        type_annotation = prop.type_annotation(serialize_namespace=self.serialize_namespace)
+        is_optional = prop.optional or prop.client_default_value is not None
+        if is_optional:
+            return f"{prop.wire_name}: {type_annotation}"
+        return f"{prop.wire_name}: Required[{type_annotation}]"
+
+    def initialize_properties(self, model: ModelType) -> list[str]:
+        return []
+
+    def need_init(self, model: ModelType) -> bool:
+        return False
+
+    def discriminated_subtypes_union(self, model: ModelType) -> str:
+        subtypes = list(model.discriminated_subtypes.values())
+        subtype_names = [s.name for s in subtypes]
+        return f"{model.name} = Union[{', '.join(subtype_names)}]"
+
+    def is_discriminated_base(self, model: ModelType) -> bool:
+        return bool(model.discriminated_subtypes)
+
+    def global_pylint_disables(self) -> str:
+        return ""

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

@@ -3,34 +3,285 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+import keyword
+import re
+from typing import Optional
+from ..models import ModelType, CodeModel
+from ..models.enum_type import EnumType
 from ..models.imports import FileImport, ImportType
 from ..models.utils import NamespaceType
+from ..models.property import Property
+from .model_serializer import _documentation_string
 from .import_serializer import FileImportSerializer
 from .base_serializer import BaseSerializer
 
+# Python builtin type names that can be shadowed by TypedDict field wire_names.
+# When a field name matches one of these, all references to that builtin in type
+# annotations within the same class are qualified as builtins.X.
+_BUILTIN_TYPE_NAMES = frozenset(
+    {
+        "int",
+        "str",
+        "float",
+        "bool",
+        "list",
+        "dict",
+        "tuple",
+        "set",
+        "bytes",
+        "type",
+        "object",
+        "complex",
+        "frozenset",
+        "bytearray",
+        "memoryview",
+    }
+)
+
+
+def _qualify_shadowed_builtins(annotation: str, shadowed: frozenset[str]) -> str:
+    """Replace bare builtin type references with builtins.X when shadowed by a field name."""
+    if not shadowed:
+        return annotation
+    for name in shadowed:
+        annotation = re.sub(rf"\b{name}\b", f"builtins.{name}", annotation)
+    return annotation
+
 
 class TypesSerializer(BaseSerializer):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env,
+        client_namespace: Optional[str] = None,
+        models: Optional[list[ModelType]] = None,
+        enums: Optional[list["EnumType"]] = None,
+    ):
+        super().__init__(code_model=code_model, env=env, client_namespace=client_namespace)
+        self._models = models or []
+        self._enums = enums or []
+
+    @property
+    def literal_enums(self) -> list[EnumType]:
+        """Enums to render as Literal type aliases in typeddict mode."""
+        return sorted(self._enums)
+
+    def declare_literal_enum(self, enum: EnumType) -> str:
+        """Generate a Literal type alias for an enum, e.g. MyColor = Literal["red", "blue"]."""
+        values = [enum.get_declaration(v.value) for v in enum.values]
+        return f"{enum.name} = Literal[{', '.join(values)}]"
+
+    @property
+    def typeddict_models(self) -> list[ModelType]:
+        """Models that should be rendered as TypedDicts (excluding discriminated bases which become unions).
+
+        When both a dpg model and its typeddict copy exist (same crossLanguageDefinitionId),
+        prefer the dpg model (it already renders as a TypedDict in types.py) and skip the copy.
+        """
+        candidates = [m for m in self._models if m.base != "json" and not m.discriminated_subtypes]
+        seen_ids: dict[str, "ModelType"] = {}
+        result: list["ModelType"] = []
+        for m in candidates:
+            clid = m.yaml_data.get("crossLanguageDefinitionId")
+            if clid and clid in seen_ids:
+                # Prefer the dpg model over the typeddict copy
+                if m.base == "dpg" and seen_ids[clid].base == "typeddict":
+                    # Replace the typeddict copy with the dpg model
+                    result = [r if r is not seen_ids[clid] else m for r in result]
+                    seen_ids[clid] = m
+                # Otherwise skip this duplicate
+                continue
+            if clid:
+                seen_ids[clid] = m
+            result.append(m)
+        return result
+
+    @property
+    def discriminated_base_models(self) -> list[ModelType]:
+        """Discriminated base models that become Union type aliases in types.py.
+
+        Topologically sorted so that nested discriminated bases (e.g. Shark)
+        are defined before their parents (e.g. Fish = Union[Salmon, Shark]).
+        """
+        bases = [m for m in self._models if m.base != "json" and m.discriminated_subtypes]
+        base_names = {m.name for m in bases}
+        sorted_bases: list[ModelType] = []
+        visited: set[str] = set()
+
+        def visit(model: ModelType) -> None:
+            if model.name in visited:
+                return
+            visited.add(model.name)
+            for subtype in model.discriminated_subtypes.values():
+                if subtype.name in base_names:
+                    visit(subtype)
+            sorted_bases.append(model)
+
+        for m in bases:
+            visit(m)
+        return sorted_bases
+
+    def discriminated_subtypes_union(self, model: ModelType) -> str:
+        """Generate a Union alias for a discriminated base using TypedDict subtype names."""
+        subtypes = list(model.discriminated_subtypes.values())
+        subtype_names = [s.name for s in subtypes]
+        return f"{model.name} = Union[{', '.join(subtype_names)}]"
+
+    @staticmethod
+    def has_keyword_wire_names(model: ModelType) -> bool:
+        """Whether any property wire_name is a Python keyword or requires functional TypedDict form."""
+        return any(keyword.iskeyword(p.wire_name) or not p.wire_name.isidentifier() for p in model.properties)
+
+    @staticmethod
+    def get_shadowed_builtins(model: ModelType) -> frozenset[str]:
+        """Return the set of builtin type names shadowed by property wire_names in this model.
+
+        Only includes a builtin if it is both used as a wire_name AND referenced
+        in a type annotation within the same model (otherwise no shadowing occurs).
+        """
+        wire_builtins = {p.wire_name for p in model.properties if p.wire_name in _BUILTIN_TYPE_NAMES}
+        if not wire_builtins:
+            return frozenset()
+        # Check which of these builtins actually appear in type annotations
+        used = set()
+        for prop in model.properties:
+            annotation = prop.type_annotation()
+            for name in wire_builtins:
+                if re.search(rf"\b{name}\b", annotation):
+                    used.add(name)
+        return frozenset(used)
+
     def imports(self) -> FileImport:
         file_import = FileImport(self.code_model)
-        if self.code_model.named_unions:
-            file_import.add_submodule_import(
-                "typing",
-                "Union",
-                ImportType.STDLIB,
-            )
-        for nu in self.code_model.named_unions:
-            file_import.merge(
-                nu.imports(
-                    serialize_namespace=self.serialize_namespace, serialize_namespace_type=NamespaceType.TYPES_FILE
+
+        literal_enums = self.literal_enums
+        if literal_enums:
+            file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB)
+
+        td_models = self.typeddict_models
+        if td_models or self.discriminated_base_models:
+            if td_models:
+                file_import.add_submodule_import("typing_extensions", "TypedDict", ImportType.STDLIB)
+            if self.discriminated_base_models:
+                file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+            has_required = False
+            needs_builtins = False
+            for model in td_models:
+                file_import.merge(
+                    model.imports(
+                        is_operation_file=False,
+                        serialize_namespace=self.serialize_namespace,
+                        serialize_namespace_type=NamespaceType.TYPES_FILE,
+                    )
                 )
-            )
+                for prop in model.properties:
+                    file_import.merge(
+                        prop.imports(
+                            serialize_namespace=self.serialize_namespace,
+                            serialize_namespace_type=NamespaceType.TYPES_FILE,
+                            called_by_property=True,
+                        )
+                    )
+                    if not (prop.optional or prop.client_default_value is not None):
+                        has_required = True
+                if self.get_shadowed_builtins(model):
+                    needs_builtins = True
+                for parent in model.parents:
+                    if parent.client_namespace != model.client_namespace and not parent.discriminated_subtypes:
+                        # Import parent class from sibling namespace's types module
+                        file_import.add_submodule_import(
+                            self.code_model.get_relative_import_path(
+                                self.serialize_namespace,
+                                parent.client_namespace,
+                                module_name="types",
+                            ),
+                            parent.name,
+                            ImportType.LOCAL,
+                        )
+            if has_required:
+                file_import.add_submodule_import("typing_extensions", "Required", ImportType.STDLIB)
+            if needs_builtins:
+                file_import.add_import("builtins", ImportType.STDLIB)
         return file_import
 
+    def declare_model(self, model: ModelType) -> str:
+        """Generate the class declaration or functional form for a TypedDict model.
+
+        Uses functional form when any property wire_name is a Python keyword
+        (e.g. 'and', 'class') since keywords can't be identifiers in class bodies.
+        """
+        if self.has_keyword_wire_names(model):
+            return ""  # functional form is rendered separately
+        non_discriminated_parents = [p for p in model.parents if not p.discriminated_subtypes]
+        if non_discriminated_parents:
+            basename = ", ".join([m.name for m in non_discriminated_parents])
+            return f"class {model.name}({basename}):{model.pylint_disable()}"
+        return f"class {model.name}(TypedDict, total=False):{model.pylint_disable()}"
+
+    def declare_functional_model(self, model: ModelType) -> str:
+        """Generate a functional-form TypedDict for models with keyword wire_names.
+
+        Functional form is required when any field name is a Python keyword.
+        All fields (including inherited) are included since functional form
+        can't specify a base class.
+        """
+        shadowed = self.get_shadowed_builtins(model)
+        entries: list[str] = []
+        for prop in model.properties:
+            type_annotation = prop.type_annotation(
+                serialize_namespace=self.serialize_namespace,
+                serialize_namespace_type=NamespaceType.TYPES_FILE,
+            )
+            type_annotation = _qualify_shadowed_builtins(type_annotation, shadowed)
+            is_optional = prop.optional or prop.client_default_value is not None
+            if is_optional:
+                entries.append(f'    "{prop.wire_name}": {type_annotation},')
+            else:
+                entries.append(f'    "{prop.wire_name}": Required[{type_annotation}],')
+        fields = "\n".join(entries)
+        return f'{model.name} = TypedDict("{model.name}", {{\n{fields}\n}}, total=False)'
+
+    @staticmethod
+    def get_properties_to_declare(model: ModelType) -> list[Property]:
+        if TypesSerializer.has_keyword_wire_names(model):
+            return []  # functional form handles all properties
+        non_discriminated_parents = [p for p in model.parents if not p.discriminated_subtypes]
+        if non_discriminated_parents:
+            parent_properties = [p for bm in non_discriminated_parents for p in bm.properties]
+            return [
+                p
+                for p in model.properties
+                if not any(
+                    p.client_name == pp.client_name
+                    and p.type_annotation() == pp.type_annotation()
+                    and not p.is_base_discriminator
+                    for pp in parent_properties
+                )
+            ]
+        return list(model.properties)
+
+    def declare_property(self, prop: Property, shadowed_builtins: frozenset[str]) -> str:
+        type_annotation = prop.type_annotation(
+            serialize_namespace=self.serialize_namespace,
+            serialize_namespace_type=NamespaceType.TYPES_FILE,
+        )
+        type_annotation = _qualify_shadowed_builtins(type_annotation, shadowed_builtins)
+        is_optional = prop.optional or prop.client_default_value is not None
+        if is_optional:
+            return f"{prop.wire_name}: {type_annotation}"
+        return f"{prop.wire_name}: Required[{type_annotation}]"
+
+    @staticmethod
+    def variable_documentation_string(prop: Property) -> list[str]:
+        return _documentation_string(prop, "ivar", "vartype", serialize_namespace_type=NamespaceType.TYPES_FILE)
+
     def serialize(self) -> str:
-        # Generate the models
         template = self.env.get_template("types.py.jinja2")
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(self.imports()),
             serializer=self,
+            literal_enums=self.literal_enums,
+            models=self.typeddict_models,
+            discriminated_bases=self.discriminated_base_models,
         )

package/generator/pygen/codegen/serializers/unions_serializer.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.
+# --------------------------------------------------------------------------
+from ..models import CodeModel
+from ..models.imports import FileImport, ImportType
+from ..models.utils import NamespaceType
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+
+
+class UnionsSerializer(BaseSerializer):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env,
+    ):
+        super().__init__(code_model=code_model, env=env)
+
+    def imports(self) -> FileImport:
+        file_import = FileImport(self.code_model)
+        if self.code_model.named_unions:
+            file_import.add_submodule_import(
+                "typing",
+                "Union",
+                ImportType.STDLIB,
+            )
+        for nu in self.code_model.named_unions:
+            file_import.merge(
+                nu.imports(
+                    serialize_namespace=self.serialize_namespace,
+                    serialize_namespace_type=NamespaceType.UNIONS_FILE,
+                )
+            )
+        return file_import
+
+    def serialize(self) -> str:
+        template = self.env.get_template("unions.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(self.imports()),
+            serializer=self,
+        )

package/generator/pygen/codegen/templates/model_container.py.jinja2

@@ -9,7 +9,7 @@
 
 {{ imports }}
 {% for model in models %}
-{% if model.base == "dpg" %}
+{% if model.base == "dpg" or model.base == "typeddict" %}
 {% include "model_dpg.py.jinja2" %}
 {% elif model.base == "msrest" %}
 {% include "model_msrest.py.jinja2" %}