@typespec/http-client-python 0.29.1 → 0.30.0-alpha.20260529.1

package/eng/scripts/Build-Packages.ps1

@@ -75,6 +75,13 @@ New-Item -ItemType Directory -Force -Path "$outputPath/packages" | Out-Null
 $emitterVersion = node -p -e "require('$packageRoot/package.json').version"
 Write-Host "Package version: $emitterVersion"
 
+# Stamp prerelease version if BuildNumber is provided
+if ($BuildNumber) {
+    $versionTag = $Prerelease ? "-alpha" : "-beta"
+    $emitterVersion = "$emitterVersion$versionTag.$BuildNumber"
+    Write-Host "Stamped prerelease version: $emitterVersion"
+}
+
 Push-Location "$packageRoot"
 try {
     # Step 1: Build the emitter and generator
@@ -87,12 +94,20 @@ try {
         Invoke-LoggedCommand "npm run lint" -GroupOutput
     }
 
-    # Step 3: Create npm package
+    # Step 3: Stamp version in package.json if prerelease
+    if ($BuildNumber) {
+        Write-Host "`n=== Updating package.json version to $emitterVersion ===" -ForegroundColor Cyan
+        $packageJson = Get-Content -Raw "package.json" | ConvertFrom-Json -AsHashtable
+        $packageJson.version = $emitterVersion
+        $packageJson | ConvertTo-Json -Depth 100 | Out-File -Path "package.json" -Encoding utf8 -NoNewline -Force
+    }
+
+    # Step 4: Create npm package
     Write-Host "`n=== Creating npm package ===" -ForegroundColor Cyan
     Invoke-LoggedCommand "npm pack"
     Copy-Item "typespec-http-client-python-$emitterVersion.tgz" -Destination "$outputPath/packages"
 
-    # Step 4: Verify package can be installed
+    # Step 5: Verify package can be installed
     Write-Host "`n=== Verifying package installation ===" -ForegroundColor Cyan
     Invoke-LoggedCommand "npm install typespec-http-client-python-$emitterVersion.tgz" -GroupOutput
 

package/eng/scripts/ci/dev_requirements.txt

@@ -5,8 +5,8 @@ tox-uv
 mypy==1.19.1
 colorama==0.4.6
 debugpy==1.8.2
-pytest==8.3.2
+pytest==9.0.3
 coverage==7.6.1
-black==26.3.1
+black==24.4.0
 ptvsd==4.3.2
 types-PyYAML==6.0.12.8

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/eng/scripts/ci/run_pylint.py

@@ -47,6 +47,15 @@ def _single_dir_pylint(mod):
     ]
     if is_azure:
         pylint_args.append("--load-plugins=pylint_guidelines_checker")
+    # Per-package suppressions for generated code where pylint's ignore-paths
+    # is not honored (pylint 4.x + recursive + plugin). Keep the scope as
+    # narrow as possible: only this package, only the offending check.
+    per_package_disables = {
+        "azure-client-generator-core-exact-name": ["client-incorrect-naming-convention"],
+    }
+    extra_disables = per_package_disables.get(mod.name)
+    if extra_disables:
+        pylint_args.append("--disable={}".format(",".join(extra_disables)))
     pylint_args.append(str(inner_class.absolute()))
     try:
         check_call(pylint_args)

package/eng/scripts/setup/package_manager.py

@@ -100,10 +100,20 @@ def install_packages(packages: list, venv_context=None, package_manager: str = N
 
     try:
         if cwd:
-            subprocess.check_call(install_cmd + packages, cwd=cwd)
+            result = subprocess.run(install_cmd + packages, cwd=cwd, capture_output=True, text=True)
         else:
-            subprocess.check_call(install_cmd + packages)
-    except subprocess.CalledProcessError as e:
+            result = subprocess.run(install_cmd + packages, capture_output=True, text=True)
+        if result.returncode != 0:
+            error_output = (result.stderr or "") + (result.stdout or "")
+            error_msg = f"Failed to install packages with {package_manager}: command exited with code {result.returncode}\n{error_output}"
+            if "401" in error_output or "Unauthorized" in error_output:
+                error_msg += (
+                    "\n\nReceived a 401 Unauthorized error from the Azure feed. "
+                    "A pip dependency may not yet be cached. To fix this, follow the authentication steps at: "
+                    "https://github.com/Azure/azure-sdk-for-python/blob/main/CONTRIBUTING.md#authentication-for-upstream-pull-through"
+                )
+            raise RuntimeError(error_msg)
+    except OSError as e:
         raise RuntimeError(f"Failed to install packages with {package_manager}: {e}")
 
 

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

@@ -91,11 +91,16 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         self.has_etag: bool = self.yaml_data.get("hasEtag", False)
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
 
+    @property
+    def exact_name_params(self) -> set[str]:
+        """Return the set of client names for parameters with isExactName."""
+        return {p.client_name for p in self.parameters.method if p.is_exact_name}
+
     @property
     def stream_value(self) -> Union[str, bool]:
         return (
             f'kwargs.pop("stream", {self.has_stream_response})'
-            if self.expose_stream_keyword and self.has_response_body
+            if self.expose_stream_keyword and self.has_response_body and "stream" not in self.exact_name_params
             else self.has_stream_response
         )
 

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

@@ -87,6 +87,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
         self.default_to_unset_sentinel: bool = self.yaml_data.get("defaultToUnsetSentinel", False)
         self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
         self.is_continuation_token: bool = bool(self.yaml_data.get("isContinuationToken"))
+        self.is_exact_name: bool = self.yaml_data.get("isExactName", False)
 
     def get_declaration(self, value: Any = None) -> Any:
         return self.type.get_declaration(value)

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

@@ -627,7 +627,8 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         return ""
 
     def pop_kwargs_from_signature(self, builder: OperationType) -> list[str]:
-        kwargs_to_pop = builder.parameters.kwargs_to_pop
+        exact_names = builder.exact_name_params
+        kwargs_to_pop = [k for k in builder.parameters.kwargs_to_pop if k.client_name not in exact_names]
         kwargs = self.parameter_serializer.pop_kwargs_from_signature(
             kwargs_to_pop,
             check_kwarg_dict=True,
@@ -645,7 +646,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             body_parameter=builder.parameters.body_parameter if builder.parameters.has_body else None,
         )
         for p in builder.parameters.parameters:
-            if p.hide_in_operation_signature and not p.is_continuation_token:
+            if p.hide_in_operation_signature and not p.is_continuation_token and p.client_name not in exact_names:
                 kwargs.append(f'{p.client_name} = kwargs.pop("{p.client_name}", None)')
         cls_annotation = builder.cls_type_annotation(
             async_mode=self.async_mode, serialize_namespace=self.serialize_namespace

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}"')