@typespec/http-client-python 0.29.0 → 0.29.2

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

@@ -677,7 +677,7 @@ export async function preprocess(flavor: string, generatedFolder: string): Promi
 
 /**
  * Resets the `tests/generated/{azure,unbranded}` baseline by sparse-checking-out
- * `eng/tools/emitter/gen` from the Azure/azure-sdk-for-python repo, then
+ * `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).
  *
@@ -686,8 +686,8 @@ export async function preprocess(flavor: string, generatedFolder: string): Promi
  */
 export async function prepareBaselineOfGeneratedCode(generatedFolder: string): Promise<void> {
   const repoUrl = "https://github.com/Azure/azure-sdk-for-python.git";
-  const branch = "main";
-  const sourceSubdir = "eng/tools/emitter/gen";
+  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)}`));
@@ -708,6 +708,7 @@ export async function prepareBaselineOfGeneratedCode(generatedFolder: string): P
       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`);
@@ -732,16 +733,23 @@ export async function prepareBaselineOfGeneratedCode(generatedFolder: string): P
     rmSync(tempDir, { recursive: true, force: true });
   }
 
-  // Delete a couple of fully-generated package folders so regeneration has to
-  // recreate them from scratch (smoke test of full-emit path).
-  const targetsToDelete = [
-    join(testsGeneratedDir, "azure", "authentication-http-custom"),
-    join(testsGeneratedDir, "unbranded", "encode-array"),
-  ];
-  for (const target of targetsToDelete) {
-    if (existsSync(target)) {
-      console.log(pc.dim(`Deleting ${target}`));
-      rmSync(target, { 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/generator/build/lib/pygen/codegen/models/response.py

@@ -181,7 +181,21 @@ class PagingResponse(Response):
 
     def type_annotation(self, **kwargs: Any) -> str:
         iterable = "AsyncItemPaged" if kwargs["async_mode"] else "ItemPaged"
-        return f"{iterable}[{self.item_type.type_annotation(**kwargs)}]"
+        return f"{iterable}[{self._item_type_annotation(**kwargs)}]"
+
+    def _item_type_annotation(self, **kwargs: Any) -> str:
+        # When the page item is a ListType, render the outer `List`/`list`
+        # wrapper here using the operation-file alias decision so a list page
+        # item rendered inside an operation file named `list` uses the `List`
+        # alias (avoiding the built-in `list` shadowed by `List = list`).
+        # Recurse into the element type without is_operation_file so nested
+        # generated model types keep their forward-reference quoting
+        # (e.g. ItemPaged[List["_models.Product"]]).
+        if isinstance(self.item_type, ListType):
+            use_list_import = self.code_model.has_operation_named_list
+            list_type = "List" if use_list_import else "list"
+            return f"{list_type}[{self.item_type.element_type.type_annotation(**kwargs)}]"
+        return self.item_type.type_annotation(**kwargs)
 
     def docstring_text(self, **kwargs: Any) -> str:
         base_description = "An iterator like instance of "

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

@@ -6,13 +6,73 @@
 from typing import Optional
 from abc import ABC, abstractmethod
 
-from ..models import ModelType, Property, ConstantType, EnumValue
+from ..models import ModelType, Property, ConstantType, EnumValue, EnumType
 from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
+from ..models.primitive_types import (
+    BooleanType,
+    IntegerType,
+    FloatType,
+    DecimalType,
+    StringType,
+    DatetimeType,
+    UnixTimeType,
+    TimeType,
+    DateType,
+    DurationType,
+    ByteArraySchema,
+)
 from .import_serializer import FileImportSerializer
 from .base_serializer import BaseSerializer
 from ..models.utils import NamespaceType
 
 
+def _get_xml_deserializer_name(prop: Property) -> Optional[str]:  # pylint: disable=too-many-return-statements
+    """Return the _xml_deser_* function name for a scalar XML property, or None."""
+    prop_type = prop.type
+    # Unwrap ConstantType to get the underlying value type
+    if isinstance(prop_type, ConstantType):
+        prop_type = prop_type.value_type
+
+    if isinstance(prop_type, StringType):
+        return "_xml_deser_str"
+    if isinstance(prop_type, IntegerType):
+        return "_xml_deser_int"
+    if isinstance(prop_type, FloatType):
+        return "_xml_deser_float"
+    if isinstance(prop_type, BooleanType):
+        return "_xml_deser_bool"
+    if isinstance(prop_type, DecimalType):
+        return "_xml_deser_decimal"
+    if isinstance(prop_type, DatetimeType):
+        if prop_type.encode == "rfc7231":
+            return "_xml_deser_datetime_rfc7231"
+        return "_xml_deser_datetime"
+    if isinstance(prop_type, UnixTimeType):
+        return "_xml_deser_datetime_unix_timestamp"
+    if isinstance(prop_type, TimeType):
+        return "_xml_deser_time"
+    if isinstance(prop_type, DateType):
+        return "_xml_deser_date"
+    if isinstance(prop_type, DurationType):
+        return "_xml_deser_duration"
+    if isinstance(prop_type, ByteArraySchema):
+        encode = getattr(prop_type, "encode", None) or getattr(prop, "encode", None)
+        if encode == "base64url":
+            return "_xml_deser_bytes_base64url"
+        return "_xml_deser_bytes"
+    if isinstance(prop_type, EnumType):
+        return f"enum:{prop_type.name}"
+    return None
+
+
+def _get_xml_deserializer_enum_type(prop: Property) -> Optional[EnumType]:
+    """Return the EnumType for an XML enum property (unwrapping ConstantType), or None."""
+    prop_type = prop.type
+    if isinstance(prop_type, ConstantType):
+        prop_type = prop_type.value_type
+    return prop_type if isinstance(prop_type, EnumType) else None
+
+
 def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> list[str]:
     retval: list[str] = []
     sphinx_prefix = f":{description_keyword} {prop.client_name}:"
@@ -253,6 +313,9 @@ class DpgModelSerializer(_ModelSerializer):
                 TypingSection.REGULAR,
                 alias="_Model",
             )
+        # Collect XML deserializer functions needed by models in this file
+        xml_deser_names: set[str] = set()
+        xml_deser_enums: dict[str, EnumType] = {}
         for model in self.models:
             if model.base == "json":
                 continue
@@ -271,6 +334,15 @@ class DpgModelSerializer(_ModelSerializer):
                         called_by_property=True,
                     )
                 )
+                # Track XML deserializer functions needed
+                if prop.xml_metadata:
+                    deser_name = _get_xml_deserializer_name(prop)
+                    if deser_name:
+                        xml_deser_names.add(deser_name)
+                    if deser_name and deser_name.startswith("enum:"):
+                        enum_type = _get_xml_deserializer_enum_type(prop)
+                        if enum_type is not None:
+                            xml_deser_enums[enum_type.name] = enum_type
             for parent in model.parents:
                 if parent.client_namespace != model.client_namespace:
                     file_import.add_submodule_import(
@@ -285,6 +357,38 @@ class DpgModelSerializer(_ModelSerializer):
                 file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
+        # Add imports for XML deserializer functions
+        has_enum_deser = False
+        for deser_name in sorted(xml_deser_names):
+            if deser_name.startswith("enum:"):
+                has_enum_deser = True
+                continue
+            file_import.add_submodule_import(
+                self.code_model.get_relative_import_path(self.serialize_namespace, module_name="_utils.model_base"),
+                deser_name,
+                ImportType.LOCAL,
+            )
+        if has_enum_deser:
+            file_import.add_import("functools", ImportType.STDLIB)
+            file_import.add_submodule_import(
+                self.code_model.get_relative_import_path(self.serialize_namespace, module_name="_utils.model_base"),
+                "_xml_deser_enum_or_str",
+                ImportType.LOCAL,
+            )
+            # Ensure each referenced enum class is imported at runtime (not just
+            # under TYPE_CHECKING), so functools.partial can bind the class at
+            # class-body evaluation time.
+            for enum_name, enum_type in xml_deser_enums.items():
+                file_import.add_submodule_import(
+                    self.code_model.get_relative_import_path(
+                        self.serialize_namespace,
+                        self.code_model.get_imported_namespace_for_model(enum_type.client_namespace),
+                        module_name=self.code_model.enums_filename,
+                    ),
+                    enum_name,
+                    ImportType.LOCAL,
+                    TypingSection.REGULAR,
+                )
         # if there is a property named `list` we have to make sure there's no conflict with the built-in `list`
         if self.code_model.has_property_named_list:
             file_import.define_mypy_type("List", "list")
@@ -337,6 +441,14 @@ class DpgModelSerializer(_ModelSerializer):
 
         if prop.xml_metadata:
             args.append(f"xml={prop.xml_metadata}")
+            # Add fast-path deserializer for scalar XML fields
+            deser_name = _get_xml_deserializer_name(prop)
+            if deser_name:
+                if deser_name.startswith("enum:"):
+                    enum_name = deser_name[5:]
+                    args.append(f"deserializer=functools.partial(_xml_deser_enum_or_str, {enum_name})")
+                else:
+                    args.append(f"deserializer={deser_name}")
 
         if prop.original_tsp_name:
             args.append(f'original_tsp_name="{prop.original_tsp_name}"')